swarph-cli 0.72.5__tar.gz → 0.72.7__tar.gz

{swarph_cli-0.72.5/src/swarph_cli.egg-info → swarph_cli-0.72.7}/PKG-INFO

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

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

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

{swarph_cli-0.72.5 → swarph_cli-0.72.7}/src/swarph_cli/commands/mesh.py

@@ -1515,7 +1515,14 @@ class TmuxSink(Sink):
             # Opencode keeps the finished ▣ header on screen, so a deferral
             # during the turn must not clear the flag: the next idle poll
             # still owes a wake. Cursor's #620 clear stays.
-            if _opencode_in_progress(self.target) or _grok_in_progress(self.target):
+            if _opencode_in_progress(self.target):
+                # Card #1052: name the real deferral cause — without this
+                # the log says "composer holds human text" on a CLEAR
+                # composer while a finished header misreads as live.
+                self.deferred_reason = "opencode turn in progress"
+                return None
+            if _grok_in_progress(self.target):
+                self.deferred_reason = "grok turn in progress"
                 return None
             led["wake_outstanding"] = False
         if led.get("wake_outstanding"):
@@ -2327,10 +2334,15 @@ _MUSE_WAKE_PROMPT = "check mesh: swarph_dm_unread"
 # A finished turn keeps its ▣ header and adds a duration.
 # Short turns read `· 3.3s` (drop-on-meta-edge, 1.18.33, card #961 post
 # 54557). A longer idle turn reads `· 3m 4s` (opencode pane, 2026-09-29
-# 07:10Z). On a wide pane the same row continues into the sidebar, so the
-# duration is not the end of the line. An in-progress header has no duration.
+# 07:10Z). Long turns read h/m-only: `· 4h 59m`, `· 12m`, `· 1h` (opencode,
+# card #1052 — the old regex needed trailing seconds and read these as
+# live for 32h). On a wide pane the same row continues into the sidebar,
+# so the duration is not the end of the line. An in-progress header has
+# no duration.
 _OPENCODE_DONE = re.compile(
-    r"·\s*(?:\d+h\s*)?(?:\d+m\s*)?\d+(?:\.\d+)?s\b"
+    r"·\s*(?:(?:\d+h\s+)?(?:\d+m\s+)?\d+(?:\.\d+)?s"
+    r"|\d+h(?:\s+\d+m)?"
+    r"|\d+m)\b"
 )
 # Submit-verify bounds (#533): the settle pause lets the -l literal LAND in
 # the composer before Enter can submit it (the blind gesture raced this), and
@@ -2504,31 +2516,37 @@ def _is_opencode_pane(lines: list[str]) -> bool:
     return bool(lines) and _bottom_tui(lines) == "opencode"
 
 
+def _last_box_header(lines: list[str]) -> Optional[str]:
+    """The LAST ▣ header on screen. Scrollback keeps old headers (card
+    #1052: a finished `4h 59m` header above the live tail); only the
+    bottom-most one judges the turn."""
+    for ln in reversed(lines):
+        if ln.strip().startswith("▣"):
+            return ln.strip()
+    return None
+
+
 def _opencode_running(lines: list[str]) -> bool:
     """True only while a turn is in progress.
 
-    The footer shows ``esc interrupt``, and the ▣ header has no trailing
-    duration. A finished turn keeps the ▣ header and adds ``· <n>s``,
-    with no interrupt hint. That pane is idle. The permission dialog is
+    The footer shows ``esc interrupt``, and the last ▣ header has no
+    trailing duration. A finished turn keeps the ▣ header and adds a
+    duration (``· <n>s`` or h/m-only like ``· 4h 59m``), with no
+    interrupt hint. That pane is idle. The permission dialog is
     not a turn; it has its own branch.
     """
     if any("esc interrupt" in ln for ln in lines):
         return True
-    for ln in lines:
-        s = ln.strip()
-        if s.startswith("▣") and not _OPENCODE_DONE.search(s):
-            return True
-    return False
+    last = _last_box_header(lines)
+    return last is not None and not _OPENCODE_DONE.search(last)
 
 
 def _opencode_turn_finished(lines: list[str]) -> bool:
-    """The ▣ header carried a duration and the interrupt hint is gone."""
+    """The last ▣ header carried a duration and the interrupt hint is gone."""
     if _opencode_running(lines):
         return False
-    return any(
-        ln.strip().startswith("▣") and _OPENCODE_DONE.search(ln.strip())
-        for ln in lines
-    )
+    last = _last_box_header(lines)
+    return last is not None and bool(_OPENCODE_DONE.search(last))
 
 
 def _opencode_in_progress(target: str) -> bool:

{swarph_cli-0.72.5 → swarph_cli-0.72.7}/src/swarph_cli/scripts/dm_notify_filter.py

@@ -41,6 +41,12 @@ from typing import IO, Any, Optional
 
 _IDLE_DEFAULT_SECONDS = 1800
 
+# Card #1050: ANY per-line failure is a logged skip, never a process death
+# (a death in --once mode reads as "no DM arrived"). The notice keeps the
+# [MESH DM prefix and goes to stdout so a downstream waker wakes on it;
+# it is ASCII-only so it cannot itself raise on a hostile-errors stdout.
+_SKIP_NOTICE = "[MESH DM] unrenderable line skipped"
+
 
 def _reader(stream: IO[str], q: "queue.Queue[Optional[str]]") -> None:
     """Daemon thread: blocking readline loop, None sentinel on EOF."""
@@ -110,11 +116,16 @@ def run_filter(
             except Exception:
                 d = None
             if isinstance(d, dict):
-                d = d.get("dm") or d
-                rendered = _format_dm(d)
-                if rendered is not None:
-                    print(rendered, file=stdout, flush=True)
-                    quiet = False
+                try:
+                    d = d.get("dm") or d
+                    rendered = _format_dm(d)
+                    if rendered is not None:
+                        print(rendered, file=stdout, flush=True)
+                        quiet = False
+                except BrokenPipeError:
+                    raise  # a closed pipe stays loud (SIGPIPE contract)
+                except Exception:
+                    print(_SKIP_NOTICE, file=stdout, flush=True)
             processed += 1
             if max_lines is not None and processed >= max_lines:
                 return 0
@@ -148,11 +159,16 @@ def run_once(path: str, stdout: IO[str], *, timeout: float = 2.0) -> int:
             except Exception:
                 continue
             if isinstance(d, dict):
-                d = d.get("dm") or d
-                rendered = _format_dm(d) if isinstance(d, dict) else None
-                if rendered is not None:
-                    print(rendered, file=stdout, flush=True)
-                    return 0
+                try:
+                    d = d.get("dm") or d
+                    rendered = _format_dm(d) if isinstance(d, dict) else None
+                    if rendered is not None:
+                        print(rendered, file=stdout, flush=True)
+                        return 0
+                except BrokenPipeError:
+                    raise  # a closed pipe stays loud (SIGPIPE contract)
+                except Exception:
+                    print(_SKIP_NOTICE, file=stdout, flush=True)
         time.sleep(0.05)
     return 1
 
@@ -171,6 +187,13 @@ def main(argv: Optional[list[str]] = None) -> int:
     p.add_argument("--timeout", type=float, default=2.0,
                    help="seconds --once waits for a new DM (default: %(default)s)")
     args = p.parse_args(argv)
+    try:
+        # Card #1050: lone surrogates in DM content must render (as ?) and
+        # continue, never kill the watch on a strict-errors stdout. Set
+        # before EITHER print path: --once and filter mode both emit DMs.
+        sys.stdout.reconfigure(errors="replace")
+    except Exception:
+        pass
     if args.once:
         if not args.inbox:
             print("dm_notify_filter --once needs --inbox", file=sys.stderr)

{swarph_cli-0.72.5 → swarph_cli-0.72.7/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.5
+Version: 0.72.7
 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.5 → swarph_cli-0.72.7}/src/swarph_cli.egg-info/SOURCES.txt

@@ -193,6 +193,8 @@ tests/test_1006_session_board.py
 tests/test_1010_strand_only.py
 tests/test_1013_spawn_channel.py
 tests/test_1017_muse_tui.py
+tests/test_1050_surrogate_wake.py
+tests/test_1052_opencode_deaf.py
 tests/test_124_register_merge.py
 tests/test_126_pending_from_complete.py
 tests/test_132_ensure_monitor_state_dir.py

swarph_cli-0.72.7/tests/test_1050_surrogate_wake.py

@@ -0,0 +1,115 @@
+"""#1050 — a DM whose content holds a lone surrogate escape must not kill
+the wake filter.
+
+Found by drop-on-meta-edge in #1298 (card #1049 Go A/B): a valid JSON line
+carrying e.g. \\ud83d makes the filter raise UnicodeEncodeError on print —
+exit 1, NO deaf-watch line, and every later DM is never surfaced. This is
+the fleet's silent-wake filter (#482): any peer's DM can deafen a cell's
+wake without the deaf alarm firing.
+
+The escape MUST be outside Python's surrogateescape round-trip range
+(DC80-DCFF): \\udcff survives on UTF-8-mode boxes (it round-trips raw
+byte 0xFF through a pipe) and only kills on strict-errors stdouts, while
+\\ud83d (lead) and \\udfff (trail, above DCFF) kill everywhere — measured
+dead on the pre-fix filter under both default and strict stdouts (#1302).
+
+Seam: the process boundary — stdin lines in, stdout lines out — exactly
+what the accept check names.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+
+import pytest
+
+MOD = [sys.executable, "-u", "-m", "swarph_cli.scripts.dm_notify_filter"]
+
+# Lethal on every box (see module docstring for why these, not \\udcff).
+LETHAL_ESCAPES = ("\\ud83d", "\\udfff")
+
+GOOD = '{"id":12,"from_node":"b","kind":"fyi","content":"after bad"}'
+
+
+def _run(payload: bytes) -> "subprocess.CompletedProcess[bytes]":
+    return subprocess.run(
+        MOD + ["--idle-seconds", "3600"],
+        input=payload,
+        capture_output=True,
+        timeout=60,
+        env=dict(os.environ),
+    )
+
+
+def _bad(mid: int, esc: str) -> str:
+    return ('{"id":%d,"from_node":"a","kind":"fyi","content":"AB%scCD"}'
+            % (mid, esc))
+
+
+@pytest.mark.parametrize("esc", LETHAL_ESCAPES)
+def test_lone_surrogate_then_good_dm_survives(esc: str):
+    """The good DM after a lone-surrogate line is printed; the process
+    keeps running to EOF (deaf line) instead of dying on the bad line."""
+    p = _run((_bad(11, esc) + "\n" + GOOD + "\n").encode("ascii"))
+    assert b"id=12" in p.stdout, (
+        f"good DM lost after lone-surrogate line: rc={p.returncode} "
+        f"stdout={p.stdout!r} stderr={p.stderr[-300:]!r}"
+    )
+    assert b"DEAF" in p.stdout, (
+        f"watch died without its deaf-watch line: rc={p.returncode} "
+        f"stderr={p.stderr[-300:]!r}"
+    )
+
+
+def test_lone_surrogate_never_kills_process():
+    """No per-line content may exit the filter: a whole stream of hostile
+    lines still ends at the EOF deaf line, not a traceback."""
+    lines = ([_bad(i, LETHAL_ESCAPES[i % 2]) for i in range(20)]
+             + [GOOD])
+    p = _run(("\n".join(lines) + "\n").encode("ascii"))
+    assert b"id=12" in p.stdout
+    assert b"DEAF" in p.stdout
+    assert b"Traceback" not in p.stderr
+
+
+def test_once_skips_non_string_content_and_wakes_on_next(tmp_path):
+    """#1310: run_once shares the never-die contract. A first-arriving DM
+    whose content is not a string (a number here) must become a logged
+    skip, not a death read as 'no DM arrived'; the next good DM still
+    wakes (exit 0). Seam: the --once process boundary, fed live."""
+    import threading
+    import time
+
+    inbox = tmp_path / "inbox.log"
+    inbox.write_text("")
+    proc = subprocess.Popen(
+        MOD + ["--once", "--inbox", str(inbox), "--timeout", "10"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        env=dict(os.environ),
+    )
+
+    def feed():
+        time.sleep(0.5)
+        with open(inbox, "a") as fh:
+            fh.write('{"id":41,"from_node":"a","kind":"fyi",'
+                     '"content":42}\n')
+        time.sleep(0.5)
+        with open(inbox, "a") as fh:
+            fh.write(GOOD + "\n")
+
+    threading.Thread(target=feed, daemon=True).start()
+    out, err = proc.communicate(timeout=30)
+    assert b"Traceback" not in err, f"run_once died: {err[-300:]!r}"
+    assert b"unrenderable line skipped" in out, (
+        f"numeric content was not a logged skip: rc={proc.returncode} "
+        f"stdout={out!r}"
+    )
+    assert b"id=12" in out, (
+        f"good DM after the skip did not wake: rc={proc.returncode} "
+        f"stdout={out!r}"
+    )
+    assert proc.returncode == 0, (
+        f"wake on the good DM must exit 0, got {proc.returncode}"
+    )

swarph_cli-0.72.7/tests/test_1052_opencode_deaf.py

@@ -0,0 +1,105 @@
+"""#1052 — opencode wake DEAF 32h: _opencode_running read a FINISHED
+'▣ ... · 4h 59m' header as a live turn (the done-regex needs trailing
+seconds), so the monitor deferred forever, logging 'composer holds human
+text' on a CLEAR composer.
+
+Seams: the pure helpers on the two real captures (lab-ovh's 01:31Z and
+17:18Z fixtures), plus the TmuxSink deferral rigged at the deliver()
+boundary exactly like test_1010_strand_only's. Items: (1) the done-regex
+accepts h/m-only durations; (2) only the LAST ▣ header judges; (3) the
+opencode-in-progress deferral names its real reason.
+
+The committed fixtures are the real captures with one customer
+identifier redacted (a 6-letter tenant prefix -> acme, 7 spots each);
+headers, composer state and control lines are byte-identical to the
+originals.
+"""
+from __future__ import annotations
+
+import pathlib
+
+import pytest
+
+import swarph_cli.commands.mesh as mesh
+
+FIX = pathlib.Path(__file__).resolve().parent / "fixtures"
+
+
+def _lines(name: str) -> list[str]:
+    return (FIX / name).read_text(encoding="utf-8").splitlines()
+
+
+CAPTURES = ("opencode-deaf-0131Z.txt", "opencode-deaf-1718Z.txt")
+
+
+@pytest.mark.parametrize("name", CAPTURES)
+def test_finished_captures_are_not_running(name: str):
+    """Both real captures: the old scrollback '4h 59m' header is finished
+    and the newest '16.5s' header is finished — no live turn anywhere."""
+    lines = _lines(name)
+    assert any("4h 59m" in ln for ln in lines), "capture must hold the old header"
+    assert mesh._opencode_running(lines) is False
+    assert mesh._opencode_turn_finished(lines) is True
+
+
+def test_bare_header_without_duration_still_running():
+    """A header with NO duration is a live turn (or a mid-render one) —
+    the last-header rule must not call it finished."""
+    assert mesh._opencode_running(["▣  Build · DeepSeek V4 Pro (New)"]) is True
+    assert mesh._opencode_turn_finished(
+        ["▣  Build · DeepSeek V4 Pro (New)"]) is False
+
+
+def test_scrollback_done_does_not_mask_live_tail():
+    """Only the LAST ▣ header judges: a finished scrollback header plus a
+    live (duration-less) tail header is still a running turn."""
+    lines = ["▣  Build · x · 4h 59m", "some output",
+             "▣  Build · x (no duration yet)"]
+    assert mesh._opencode_running(lines) is True
+    assert mesh._opencode_turn_finished(lines) is False
+
+
+@pytest.mark.parametrize("name", CAPTURES)
+def test_h_m_only_durations_count_as_done(name: str):
+    """Item 1 directly: '4h 59m', '12m', '1h' all match the done-regex."""
+    assert mesh._OPENCODE_DONE.search("▣  Build · x · 4h 59m")
+    assert mesh._OPENCODE_DONE.search("▣  Build · x · 12m")
+    assert mesh._OPENCODE_DONE.search("▣  Build · x · 1h")
+    assert not mesh._OPENCODE_DONE.search("▣  Build · x (New)")
+
+
+class _StubState:
+    def __init__(self):
+        self.gateway = "http://gw:8788"
+        self.self_name = "opencode"
+        self.token = "tok"
+        self._ledgers: dict = {}
+
+    def ledger(self, name: str) -> dict:
+        return self._ledgers.setdefault(
+            name, {"last_delivered_id": 0, "last_delivery_at": 0.0,
+                   "consecutive_failures": 0})
+
+
+def test_opencode_deferral_names_its_real_reason(monkeypatch):
+    """Item 3: the opencode-in-progress deferral sets deferred_reason, so
+    the monitor's DEFERRED line stops saying 'composer holds human text'.
+    Rigged at deliver(): wake outstanding, agent running, and the real
+    17:18Z capture with a LIVE tail (bare header + interrupt hint — the
+    documented mid-turn screen) so the real reader judges in-progress."""
+    lines = _lines("opencode-deaf-1718Z.txt") + [
+        "     ▣  Build · DeepSeek V4.1 Flash",
+        "  esc interrupt",
+    ]
+    assert mesh._opencode_running(lines) is True, "rig must read live"
+    monkeypatch.setattr(mesh, "_capture_pane_lines", lambda t: lines)
+    monkeypatch.setattr(mesh, "_agent_running", lambda t: True)
+    state = _StubState()
+    led = state.ledger("tmux:opencode")
+    led["wake_outstanding"] = True
+    sink = mesh.TmuxSink("opencode")
+    assert sink.deliver(state, [{"id": 7}], 7) is None
+    assert "human text" not in (sink.deferred_reason or ""), \
+        sink.deferred_reason
+    assert "opencode" in (sink.deferred_reason or "").lower(), \
+        sink.deferred_reason