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

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

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

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

{swarph_cli-0.69.5 → swarph_cli-0.69.6}/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,110 @@ 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()
+
+
+def _grok_block_reason(lines: list[str]) -> Optional[str]:
+    """A rate or usage limit is not an idle composer and not a dead pane.
+
+    0.2.51 draws ``Retry failed: You've hit the rate limit for your plan``
+    under an empty ``│ ❯`` box, with no spinner. 1.0.44 draws a ``┃`` modal
+    ``You hit your free usage limit`` and drops the Grok footer entirely.
+    Either screen used to look clear (inject again) or unreadable
+    (DELIVERY FAILED). Return a stable reason token, or None.
+    """
+    blob = "\n".join(lines).lower()
+    if "you hit your free usage limit" in blob:
+        return "grok-usage-limit"
+    if "rate limit" in blob:
+        return "grok-rate-limit"
+    if "usage limit" in blob:
+        return "grok-usage-limit"
+    if "retry failed" in blob:
+        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 +2403,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 +2433,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 +2523,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.6/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.6
 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.6}/src/swarph_cli.egg-info/SOURCES.txt

@@ -219,7 +219,9 @@ 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_729_dm_once.py

swarph_cli-0.69.6/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.6/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