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

{swarph_cli-0.72.6/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.6
+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.6 → swarph_cli-0.72.7}/pyproject.toml

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

{swarph_cli-0.72.6 → 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.6 → 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.6
+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.6 → swarph_cli-0.72.7}/src/swarph_cli.egg-info/SOURCES.txt

@@ -194,6 +194,7 @@ 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_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