swarph-cli 0.69.5__tar.gz → 0.69.7__tar.gz

{swarph_cli-0.69.5/src/swarph_cli.egg-info → swarph_cli-0.69.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.69.5
+Version: 0.69.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.69.5 → swarph_cli-0.69.7}/pyproject.toml

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

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

{swarph_cli-0.69.5 → swarph_cli-0.69.7}/src/swarph_cli/commands/mesh.py

@@ -1481,6 +1481,18 @@ class TmuxSink(Sink):
 
     def deliver(self, state: "MonitorState", dms: list, up_to_id: int) -> Optional[bool]:
         led = state.ledger(self.name)
+        # #723: a rate-limit or usage-limit screen is not deliverable. An
+        # empty composer beside "Retry failed: rate limit" used to inject
+        # again, and the 1.0.44 upgrade modal (no Grok footer) used to
+        # return False and log DELIVERY FAILED. Defer with a named reason
+        # and send nothing.
+        pane = _capture_pane_lines(self.target)
+        if pane:
+            reason = _grok_block_reason(pane)
+            if reason:
+                print(f"[monitor] {self.name}: {reason} — deferring, zero keys",
+                      flush=True)
+                return None
         # #620: a wake's job is done the moment a TURN is observed running —
         # the cell is awake, whoever woke it (our injected wake fired, or
         # the human typed). Both older clearing paths miss the zombie
@@ -1497,7 +1509,7 @@ 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):
+            if _opencode_in_progress(self.target) or _grok_in_progress(self.target):
                 return None
             led["wake_outstanding"] = False
         if led.get("wake_outstanding"):
@@ -1524,7 +1536,8 @@ class TmuxSink(Sink):
                     # A finished opencode turn leaves a ▣ header with a
                     # trailing duration and a clear box. The standing-wake
                     # claim would swallow every later DM. Inject again.
-                    if _opencode_turn_finished_target(self.target):
+                    if (_opencode_turn_finished_target(self.target)
+                            or _grok_turn_finished_target(self.target)):
                         ok = _tmux_wake(self.target)
                         if ok:
                             _stamp_wake(led)
@@ -2020,6 +2033,9 @@ _WAKE_PROMPT = "check mesh"
 # not shown. Longer than _WAKE_PROMPT, so wake-text detection strips this
 # one first.
 _OPENCODE_WAKE_PROMPT = "check mesh: swarph_dm_unread"
+# Grok's TUI has the same shape (#715, grok 1.0.41): no push channel, so
+# the wake is one line naming the pull tool and no DM body.
+_GROK_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
@@ -2130,7 +2146,7 @@ def _only_wake_text(content: str) -> bool:
     human's line.
     """
     rest = content
-    for prompt in (_OPENCODE_WAKE_PROMPT, _WAKE_PROMPT):
+    for prompt in (_GROK_WAKE_PROMPT, _OPENCODE_WAKE_PROMPT, _WAKE_PROMPT):
         rest = rest.replace(prompt, "")
     return rest.strip() == ""
 
@@ -2265,6 +2281,126 @@ def _opencode_composer_state(lines: list[str]) -> Optional[str]:
     return "busy"
 
 
+def _is_grok_pane(lines: list[str]) -> bool:
+    """Grok Build composer, measured on sacrificial 1.0.41 and 0.2.51 TUIs.
+
+    The footer names ``Grok 4.`` inside the box, or the splash prints
+    ``Grok Build``. History also draws a ``❯`` for the submitted prompt;
+    that row has no box bar, so it is not the composer. A usage-limit
+    modal drops both of those and is recognized by ``_grok_block_reason``.
+    """
+    return any("Grok 4." in ln or ln.strip().startswith("Grok Build") for ln in lines)
+
+
+def _grok_input(lines: list[str]) -> Optional[str]:
+    """Text in the live ``│ ❯`` box, '' when empty, None if no box."""
+    row = None
+    for ln in lines:
+        if "❯" in ln and "│" in ln:
+            row = ln
+    if row is None:
+        return None
+    after = row.split("❯", 1)[1]
+    if "│" in after:
+        after = after.split("│", 1)[0]
+    return after.strip()
+
+
+# One grok screen, measured on the live 0.2.51 pane (52 rows). Lines above
+# this window are scrollback. A transcript that merely quotes the limit
+# strings is not the limit screen.
+_GROK_SCREEN_ROWS = 52
+
+
+def _grok_block_reason(lines: list[str]) -> Optional[str]:
+    """A rate or usage limit screen is not an idle composer and not a dead pane.
+
+    Match the screen by where it is drawn, not by a quote anywhere in the
+    capture. 1.0.44 draws a ``┃`` modal ``You hit your free usage limit``
+    (no Grok footer). 0.2.51 draws a status line that starts ``Retry failed:``
+    on the current screen, under the composer. A cursor transcript that
+    quotes those sentences, and a grok scrollback that still contains them
+    above an idle screen, are not that screen.
+    """
+    screen = lines[-_GROK_SCREEN_ROWS:]
+    # Opencode draws its transcript in ┃ rows, so a quoted sentence there is
+    # not the grok modal. The modal identifies itself (Upgrade to SuperGrok)
+    # or the pane is already grok.
+    modal = "\n".join(ln for ln in screen if "┃" in ln).lower()
+    if ("you hit your free usage limit" in modal
+            and (_is_grok_pane(screen) or "upgrade to supergrok" in modal)):
+        return "grok-usage-limit"
+    if not _is_grok_pane(screen):
+        return None
+    for ln in screen:
+        stripped = ln.strip()
+        low = stripped.lower()
+        if not stripped.startswith("Retry failed:"):
+            continue
+        if "rate limit" in low:
+            return "grok-rate-limit"
+        return "grok-retry-failed"
+    return None
+
+
+def _grok_running(lines: list[str]) -> bool:
+    """True only while the turn is in progress.
+
+    1.0.41/1.0.44: ``Waiting for response``. 0.2.51: ``Waiting…`` at the
+    start of the turn, then a tool row whose footer is ``Ctrl+c:cancel``
+    for as long as the turn lasts. ``Worked for`` / ``Thought for`` stay
+    on screen after the turn and must not count as running.
+    """
+    for ln in lines:
+        if "Waiting for response" in ln or "Waiting…" in ln or "Waiting..." in ln:
+            return True
+        if "Ctrl+c:cancel" in ln:
+            return True
+    return False
+
+
+def _grok_turn_finished(lines: list[str]) -> bool:
+    if _grok_running(lines) or _grok_block_reason(lines):
+        return False
+    return any(
+        "Worked for" in ln or "Thought for" in ln or "Turn cancelled" in ln
+        for ln in lines
+    )
+
+
+def _grok_in_progress(target: str) -> bool:
+    lines = _capture_pane_lines(target)
+    if not lines or not _is_grok_pane(lines):
+        return False
+    return _grok_running(lines)
+
+
+def _grok_turn_finished_target(target: str) -> bool:
+    lines = _capture_pane_lines(target)
+    if not lines or not _is_grok_pane(lines):
+        return False
+    return _grok_turn_finished(lines)
+
+
+def _grok_composer_state(lines: list[str]) -> Optional[str]:
+    text = _grok_input(lines)
+    if text is None:
+        return None
+    if not text:
+        return "clear"
+    if _only_wake_text(text):
+        return "wake"
+    return "busy"
+
+
+def _wake_prompt_for(lines: Optional[list[str]]) -> str:
+    if lines and _is_grok_pane(lines):
+        return _GROK_WAKE_PROMPT
+    if lines and _is_opencode_pane(lines):
+        return _OPENCODE_WAKE_PROMPT
+    return _WAKE_PROMPT
+
+
 def _agent_running(target: str) -> Optional[bool]:
     """True while a keystroke would miss the idle composer.
 
@@ -2283,6 +2419,8 @@ def _agent_running(target: str) -> Optional[bool]:
         return None
     if _is_opencode_pane(lines):
         return _opencode_running(lines)
+    if _is_grok_pane(lines):
+        return _grok_running(lines)
     composer = _composer_line(lines)
     if composer is None:
         return None
@@ -2311,6 +2449,8 @@ def _composer_state(target: str) -> Optional[str]:
         return None
     if _is_opencode_pane(lines):
         return _opencode_composer_state(lines)
+    if _is_grok_pane(lines):
+        return _grok_composer_state(lines)
     composer = _composer_line(lines)
     if composer is None:
         return None
@@ -2399,8 +2539,7 @@ def _tmux_wake(target: str) -> Optional[bool]:
     """
     try:
         seen = _capture_pane_lines(target)
-        prompt = (_OPENCODE_WAKE_PROMPT
-                  if seen and _is_opencode_pane(seen) else _WAKE_PROMPT)
+        prompt = _wake_prompt_for(seen)
         subprocess.run(
             ["tmux", "send-keys", "-t", target, "-l", prompt],
             check=True,

{swarph_cli-0.69.5 → swarph_cli-0.69.7/src/swarph_cli.egg-info}/PKG-INFO

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

@@ -219,9 +219,12 @@ tests/test_654_reexec.py
 tests/test_656_owned_slm.py
 tests/test_684_dreaming_verb.py
 tests/test_689_pkg_version_order.py
+tests/test_715_grok_wake.py
 tests/test_716_timeline_one_path.py
+tests/test_723_grok_0251.py
 tests/test_724_ps1_ascii_or_bom.py
 tests/test_725_stdio_reconfigure.py
+tests/test_726_grok_limit_screen.py
 tests/test_729_dm_once.py
 tests/test_729_wake_watchdog.py
 tests/test_734_dreaming_enrich_degrade.py

swarph_cli-0.69.7/tests/test_715_grok_wake.py

@@ -0,0 +1,88 @@
+"""card #961 — grok 1.0.41 pane fixtures. These assertions fail on main:
+main has no grok reader, so an idle ``│ ❯`` box is not a clear composer and
+``Waiting for response`` is not a running turn.
+"""
+from pathlib import Path
+
+from swarph_cli.commands import mesh
+
+FIX = Path(__file__).resolve().parents[1] / "tests" / "fixtures" / "grok-715"
+
+
+def lines(name):
+    return (FIX / name).read_text(encoding="utf-8").splitlines()
+
+
+def test_idle_box_is_clear_and_not_running():
+    pane = lines("idle.txt")
+    assert mesh._is_grok_pane(pane)
+    assert mesh._grok_composer_state(pane) == "clear"
+    assert mesh._grok_running(pane) is False
+    assert mesh._wake_prompt_for(pane) == "check mesh: swarph_dm_unread"
+
+
+def test_typed_text_defers():
+    pane = lines("typed.txt")
+    assert mesh._grok_input(pane) == "draft-not-submitted"
+    assert mesh._grok_composer_state(pane) == "busy"
+    assert mesh._grok_running(pane) is False
+
+
+def test_running_turn_is_not_idle():
+    pane = lines("running.txt")
+    assert mesh._grok_running(pane) is True
+    assert mesh._grok_turn_finished(pane) is False
+    # the box is empty while the turn runs; empty must not read as "inject"
+    assert mesh._grok_input(pane) == ""
+
+
+def test_finished_turn_reads_idle_so_the_next_dm_can_wake():
+    pane = lines("finished.txt")
+    assert "Worked for" in "\n".join(pane)
+    assert mesh._grok_running(pane) is False
+    assert mesh._grok_turn_finished(pane) is True
+    # the submitted prompt stays in history with a bare ❯; the live box is empty
+    assert mesh._grok_input(pane) == ""
+    assert mesh._grok_composer_state(pane) == "clear"
+
+
+def test_history_prompt_is_not_composer_text():
+    pane = lines("finished.txt")
+    assert any(ln.strip().startswith("❯ Reply") for ln in pane)
+    assert mesh._grok_composer_state(pane) == "clear"
+
+
+class _State:
+    def __init__(self, led):
+        self.led = led
+        self.gateway = "http://stub.invalid"
+        self.self_name = "grok-researcher"
+        self.token = "tok"
+
+    def ledger(self, _name):
+        return self.led
+
+
+def test_a_running_delivery_sends_zero_keys(monkeypatch):
+    pane = lines("running.txt")
+    keys = []
+    monkeypatch.setattr(mesh, "_capture_pane_lines", lambda _t: pane)
+    monkeypatch.setattr(mesh, "_tmux_wake", lambda _t: keys.append("wake") or True)
+    monkeypatch.setattr(mesh, "_tmux_enter", lambda _t: keys.append("enter") or True)
+    led = {"wake_outstanding": True}
+    assert mesh.TmuxSink("grok-715-sac").deliver(_State(led), [], 1) is None
+    assert keys == []
+    assert led["wake_outstanding"] is True
+
+
+def test_a_finished_clear_box_injects_again(monkeypatch):
+    pane = lines("finished.txt")
+    keys = []
+    monkeypatch.setattr(mesh, "_capture_pane_lines", lambda _t: pane)
+    monkeypatch.setattr(mesh, "_tmux_wake", lambda _t: keys.append("wake") or True)
+    monkeypatch.setattr(mesh, "_tmux_enter", lambda _t: keys.append("enter") or True)
+    monkeypatch.setattr(
+        "swarph_cli.commands.watchdog._gateway_unread_count", lambda *_a: 1)
+    led = {"wake_outstanding": True, "last_wake_injected_at": 1.0}
+    assert mesh.TmuxSink("grok-715-sac").deliver(_State(led), [], 2) is True
+    assert keys == ["wake"]

swarph_cli-0.69.7/tests/test_723_grok_0251.py

@@ -0,0 +1,104 @@
+"""card #961 — grok 0.2.51 pane fixtures. These assertions fail on 87c8fba:
+that head only treats ``Waiting for response`` as running and ``Worked for``
+as finished, and an empty box beside a rate-limit line is a clear composer.
+"""
+from pathlib import Path
+
+from swarph_cli.commands import mesh
+
+FIX = Path(__file__).resolve().parents[1] / "tests" / "fixtures" / "grok-723"
+
+
+def lines(name):
+    return (FIX / name).read_text(encoding="utf-8").splitlines()
+
+
+class _State:
+    def __init__(self, led):
+        self.led = led
+        self.gateway = "http://stub.invalid"
+        self.self_name = "grok-researcher"
+        self.token = "tok"
+
+    def ledger(self, _name):
+        return self.led
+
+
+def _deliver(monkeypatch, pane, led):
+    keys = []
+    monkeypatch.setattr(mesh, "_capture_pane_lines", lambda _t: pane)
+    monkeypatch.setattr(mesh, "_tmux_wake", lambda _t: keys.append("wake") or True)
+    monkeypatch.setattr(mesh, "_tmux_enter", lambda _t: keys.append("enter") or True)
+    outcome = mesh.TmuxSink("grok-723-sac").deliver(_State(led), [], 1)
+    return outcome, keys
+
+
+def test_idle_0251_box_is_clear():
+    pane = lines("idle.txt")
+    assert "Grok Build  0.2.51" in "\n".join(pane)
+    assert mesh._is_grok_pane(pane)
+    assert mesh._grok_block_reason(pane) is None
+    assert mesh._grok_composer_state(pane) == "clear"
+    assert mesh._grok_running(pane) is False
+    assert mesh._wake_prompt_for(pane) == "check mesh: swarph_dm_unread"
+
+
+def test_typed_0251_defers():
+    pane = lines("typed.txt")
+    assert mesh._grok_block_reason(pane) is None
+    assert mesh._grok_input(pane) == "draft-not-submitted"
+    assert mesh._grok_composer_state(pane) == "busy"
+    assert mesh._grok_running(pane) is False
+
+
+def test_running_0251_is_not_idle(monkeypatch):
+    pane = lines("running.txt")
+    assert "Waiting…" in "\n".join(pane)
+    assert "Waiting for response" not in "\n".join(pane)
+    assert mesh._grok_running(pane) is True
+    assert mesh._grok_turn_finished(pane) is False
+    assert mesh._grok_input(pane) == ""
+    outcome, keys = _deliver(
+        monkeypatch, pane, {"wake_outstanding": True, "last_wake_injected_at": 1.0})
+    assert outcome is None
+    assert keys == []
+
+
+def test_finished_0251_thought_for_can_wake_again():
+    pane = lines("finished.txt")
+    text = "\n".join(pane)
+    assert "Thought for" in text
+    assert "Worked for" not in text
+    assert "Ctrl+c:cancel" not in text
+    assert mesh._grok_running(pane) is False
+    assert mesh._grok_turn_finished(pane) is True
+    assert mesh._grok_input(pane) == ""
+    assert mesh._grok_composer_state(pane) == "clear"
+
+
+def test_rate_limit_defers_with_named_reason_and_zero_keys(monkeypatch, capsys):
+    pane = lines("rate-limit.txt")
+    assert "rate limit" in "\n".join(pane).lower()
+    assert mesh._grok_block_reason(pane) == "grok-rate-limit"
+    assert mesh._grok_running(pane) is False
+    assert mesh._grok_turn_finished(pane) is False
+    # a previous turn's "Thought for" must not win over the limit screen
+    poisoned = pane + ["     ◆ Thought for 2s"]
+    assert mesh._grok_turn_finished(poisoned) is False
+    outcome, keys = _deliver(monkeypatch, pane, {})
+    assert outcome is None
+    assert keys == []
+    assert "grok-rate-limit" in capsys.readouterr().out
+
+
+def test_usage_limit_modal_defers_instead_of_failing(monkeypatch, capsys):
+    pane = lines("usage-limit.txt")
+    assert "You hit your free usage limit" in "\n".join(pane)
+    assert mesh._is_grok_pane(pane) is False
+    assert mesh._grok_block_reason(pane) == "grok-usage-limit"
+    outcome, keys = _deliver(monkeypatch, pane, {})
+    assert outcome is None
+    assert keys == []
+    err = capsys.readouterr().out
+    assert "grok-usage-limit" in err
+    assert "DELIVERY FAILED" not in err

swarph_cli-0.69.7/tests/test_726_grok_limit_screen.py

@@ -0,0 +1,60 @@
+"""card #961 — the limit check must be the limit screen, not a quote.
+
+These assertions fail on 1d55233: that head treats any line containing the
+limit sentences as a grok block, including a cursor transcript and grok
+scrollback above an idle screen.
+"""
+from pathlib import Path
+
+from swarph_cli.commands import mesh
+
+FIX723 = Path(__file__).resolve().parents[1] / "tests" / "fixtures" / "grok-723"
+FIX726 = Path(__file__).resolve().parents[1] / "tests" / "fixtures" / "grok-726"
+
+
+def lines(root, name):
+    return (root / name).read_text(encoding="utf-8").splitlines()
+
+
+def test_cursor_transcript_quoting_both_limits_is_not_blocked():
+    pane = lines(FIX726, "cursor-transcript.txt")
+    text = "\n".join(pane)
+    assert "rate limit" in text
+    assert "You hit your free usage limit" in text
+    assert "Models matching" in text
+    assert mesh._is_grok_pane(pane) is False
+    assert mesh._grok_block_reason(pane) is None
+
+
+def test_opencode_transcript_quoting_the_usage_limit_is_not_blocked():
+    src = Path(__file__).resolve().parents[1] / "tests" / "fixtures" / "opencode-pane-idle-footer-0710.txt"
+    pane = src.read_text(encoding="utf-8").splitlines()
+    # Inside the current screen, on a ┃ transcript row, not a grok modal.
+    pane.insert(len(pane) - 8, "  ┃  You hit your free usage limit")
+    assert mesh._is_opencode_pane(pane) is True
+    assert mesh._is_grok_pane(pane) is False
+    assert mesh._grok_block_reason(pane) is None
+
+
+def test_grok_rate_limit_and_usage_modal_still_defer():
+    rate = lines(FIX723, "rate-limit.txt")
+    usage = lines(FIX723, "usage-limit.txt")
+    assert mesh._grok_block_reason(rate) == "grok-rate-limit"
+    assert mesh._grok_turn_finished(rate) is False
+    assert mesh._is_grok_pane(usage) is False
+    assert mesh._grok_block_reason(usage) == "grok-usage-limit"
+
+
+def test_old_scrollback_limit_on_an_idle_grok_screen_reads_idle():
+    idle = lines(FIX723, "idle.txt")
+    scroll = [
+        "     ❯ an earlier turn",
+        "     Retry failed: You’ve hit the rate limit for your plan.",
+        "     You hit your free usage limit",
+    ]
+    # Push the quote above one screen. The idle composer stays.
+    pane = (scroll * 20) + idle
+    assert mesh._is_grok_pane(pane)
+    assert mesh._grok_block_reason(pane) is None
+    assert mesh._grok_composer_state(pane) == "clear"
+    assert mesh._grok_running(pane) is False