swarph-cli 0.48.0__tar.gz → 0.48.2__tar.gz

{swarph_cli-0.48.0/src/swarph_cli.egg-info → swarph_cli-0.48.2}/PKG-INFO

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

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

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

{swarph_cli-0.48.0 → swarph_cli-0.48.2}/src/swarph_cli/commands/mesh.py

@@ -1045,8 +1045,13 @@ class Sink:
     def __init__(self, name: str):
         self.name = name
 
-    def deliver(self, state: "MonitorState", dms: list, up_to_id: int) -> bool:
-        """Push `dms` (may be a bounded/empty replay). True == delivered."""
+    def deliver(self, state: "MonitorState", dms: list, up_to_id: int) -> Optional[bool]:
+        """Push `dms` (may be a bounded/empty replay). Three outcomes:
+        True == delivered (cursor advances); False == FAILED (loud, counted —
+        the sink is probably gone); None == DEFERRED (still owed, but neither
+        delivered nor failed — e.g. TmuxSink's politeness gate finding a
+        human mid-write. A deferral never increments consecutive_failures:
+        a busy composer is not a dead sink)."""
         raise NotImplementedError
 
     def observe(self, state: "MonitorState", ledger: dict, window: list) -> bool:
@@ -1134,6 +1139,16 @@ class TmuxSink(Sink):
     ('check meshcheck mesh…' ×7 observed live on cursor-lin). If the pane
     observably still HOLDS an unsubmitted wake, the gate sends a single
     verified Enter nudge instead of new text — the anti-stack retry.
+
+    POLITENESS GATE (commander, 2026-08-24, same day): even a verified wake
+    INJECTS BLIND — '-l' appends to whatever sits in the composer, so a wake
+    landing mid-keystroke merges into the human's half-typed line. The gate:
+    no inject and no nudge unless the composer is OBSERVED in a compatible
+    state ("clear" to inject, "wake"-only to nudge). A BUSY composer DEFERS
+    (deliver returns None): the wake stays owed, the cursor does not advance,
+    and no failure is counted — a human typing is not a dead sink. An
+    UNREADABLE composer FAILS without a keystroke: never type blind, and a
+    dead pane must keep the failure loud.
     """
 
     is_push = True
@@ -1142,7 +1157,7 @@ class TmuxSink(Sink):
         super().__init__(f"tmux:{target}")
         self.target = target
 
-    def deliver(self, state: "MonitorState", dms: list, up_to_id: int) -> bool:
+    def deliver(self, state: "MonitorState", dms: list, up_to_id: int) -> Optional[bool]:
         led = state.ledger(self.name)
         if led.get("wake_outstanding"):
             # Lazy: watchdog imports mesh module-level, so the reverse must
@@ -1154,18 +1169,47 @@ class TmuxSink(Sink):
             if unread == 0:
                 led["wake_outstanding"] = False  # drained since — re-arm
             else:
-                pending = _wake_still_pending(self.target)
-                if pending is True:
+                composer = _composer_state(self.target)
+                if composer == "wake":
                     _tmux_enter(self.target)  # one verified nudge, no new text
                     return True
-                if pending is False:
+                if composer == "clear":
                     # Wake submitted; the cell simply hasn't drained yet. The
                     # wake did its job — re-injecting would only stack.
                     return True
+                if composer == "busy":
+                    # Human text shares the composer (possibly merged into our
+                    # wake) — an Enter here submits THEIR line (#403's shape).
+                    return None
                 return False  # pane unreadable: keep the failure loud
+        # Fresh path, gated on the OBSERVED composer (gpt-ops REVISE, #312):
+        # "wake" — wake text already sits ALONE in the composer (a monitor
+        # restart loses wake_outstanding; the ledger flag is gone but the
+        # keystrokes landed). Nudge it with one Enter — injecting here would
+        # stack a second copy, the exact defect the gate exists to prevent.
+        # "busy" DEFERS (None — a human mid-write is not a dead sink).
+        # Unreadable FAILS (False) without a single keystroke: we never type
+        # blind into a pane, and a dead pane must stay loud — deferring it
+        # would silently freeze the dead-sink alarm the ledger exists to ring.
+        composer = _composer_state(self.target)
+        if composer == "wake":
+            if _tmux_enter(self.target):
+                led["wake_outstanding"] = True
+                return True
+            return False
+        if composer == "busy":
+            return None
+        if composer != "clear":
+            return False
         # Module-global lookup on purpose: the sidecar regression suites patch
         # `mesh._tmux_wake`, and a `from`-import here would silently bypass them.
         ok = _tmux_wake(self.target)
+        if ok is None:
+            # The human ADOPTED the composer mid-settle (gpt-ops, #312 round
+            # 5): the wake text never submitted as ours. DEFER — the cursor
+            # must NOT advance, or the wake is silently lost when the human
+            # never sends their line.
+            return None
         if ok:
             led["wake_outstanding"] = True
             return True
@@ -1514,15 +1558,17 @@ _WAKE_SETTLE_S = 0.6
 _WAKE_SUBMIT_ATTEMPTS = 4
 
 
-def _wake_still_pending(target: str) -> Optional[bool]:
-    """Three-way: True = the wake prompt still sits in the pane's bottom lines
-    (UNSUBMITTED, waiting in the composer — a concatenated backlog like
-    'check meshcheck mesh' matches the same substring check and is drained by
-    the retry Enter that submits it). False = observed clear. None = UNKNOWN
-    (capture failed) — and unknown must FAIL CLOSED (gpt-ops, PR #306): an
-    unverified retry Enter is not a no-op, it is a keypress into a pane whose
-    composer may hold a human's half-typed line (#403's shape). Unknown stops
-    the loop and owes the wake; it never earns another Enter."""
+def _capture_pane_lines(target: str) -> Optional[list[str]]:
+    """The pane's non-empty lines, or None when the pane is UNREADABLE
+    (capture error / non-zero rc). Shared by the wake verifier and the
+    politeness gate — None must always fail closed, never "probably fine".
+
+    NOT a fixed tail window: cursor's TUI renders chrome BELOW the composer
+    (task count, model/status bar, '~' — measured live on cursor-lin
+    2026-08-24: the composer sits 4 non-empty lines from the bottom), so a
+    tail-3 lands entirely in the chrome and reads every cursor pane as
+    unknown. The composer is identified structurally instead — see
+    _composer_line."""
     try:
         r = subprocess.run(
             ["tmux", "capture-pane", "-p", "-t", target],
@@ -1534,21 +1580,98 @@ def _wake_still_pending(target: str) -> Optional[bool]:
         return None
     if r.returncode != 0:
         return None
-    lines = [ln for ln in (r.stdout or "").splitlines() if ln.strip()]
-    tail = lines[-3:]
-    if any(_WAKE_PROMPT in ln for ln in tail):
-        return True
-    # "Clear" must be an OBSERVATION, not an absence (gpt-ops, PR #306 round
-    # 2): a successful-but-empty or unrecognizable capture proves nothing
-    # about the composer. Only a pane whose bottom shows a composer prompt
-    # line with no wake text in it counts as submitted. The marker is
-    # per-TUI: '>' for claude/codex composers, '→' for cursor's Linux TUI
-    # (measured live on cursor-lin 2026-08-24: the composer renders
-    # '→ Add a follow-up', never '>'). A pane showing NEITHER marker is
-    # unrecognizable → unknown → fail closed.
-    if any(ln.strip().startswith((">", "→")) for ln in tail):
-        return False
-    return None
+    return [ln for ln in (r.stdout or "").splitlines() if ln.strip()]
+
+
+_COMPOSER_MARKERS = (">", "›", "→")
+
+
+def _composer_line(lines: list[str]) -> Optional[str]:
+    """The LAST non-empty line starting with a composer marker — by TUI
+    layout the composer is always the bottom-most prompt line; everything
+    below it is chrome (status bars never start with a marker), and
+    everything above is history. Cursor echoes submitted prompts as
+    '│ ○ text │' and claude/codex as '> text' ABOVE the composer, so the
+    last-marker rule is what keeps history out of the reading. Markers:
+    '>' claude, '›' codex (gpt-ops live capture), '→' cursor (measured live
+    on cursor-lin 2026-08-24: the composer renders '→ Add a follow-up')."""
+    composer = None
+    for ln in lines:
+        s = ln.strip()
+        if s.startswith(_COMPOSER_MARKERS):
+            composer = s
+    return composer
+
+
+def _wake_still_pending(target: str) -> Optional[bool]:
+    """Projection of the four-way composer state (gpt-ops, PR #312 round 4):
+
+    True = the composer holds ONLY wake text (one unsubmitted wake, or the
+    pre-fix stacked concatenation 'check meshcheck mesh' — both are drained
+    by the retry Enter). False = anything else OBSERVED: a clear composer
+    (the wake submitted) OR human text in the line — including wake text
+    MERGED with human text ('> check mesh half-typed', typed during the
+    settle). Merged must stop the loop WITHOUT another Enter: that Enter
+    would submit the human's half-typed line (#403's shape). The wake is
+    then out of our hands — the human owns the line, and the busy-deferral
+    in TmuxSink.deliver keeps the wake owed until they send it. None =
+    UNKNOWN (unreadable / no composer line recognized) — and unknown must
+    FAIL CLOSED (gpt-ops, PR #306): an unverified retry Enter is not a
+    no-op, it is a keypress into a pane whose composer may hold a human's
+    half-typed line. Unknown stops the loop and owes the wake; it never
+    earns another Enter."""
+    state = _composer_state(target)
+    if state is None:
+        return None
+    return state == "wake"
+
+
+#: cursor's EMPTY composer is not bare: it renders the marker plus a dimmed
+#: placeholder ('→ Add a follow-up', measured live on cursor-lin 2026-08-24).
+#: Treating any text-after-marker as busy would defer every wake forever on
+#: cursor; treating the placeholder as human text is the only false positive
+#: it can produce, and the failure direction there is a wake never sent —
+#: visible in the log, never a keystroke into someone's line.
+_CURSOR_COMPOSER_PLACEHOLDER = "Add a follow-up"
+
+
+def _composer_state(target: str) -> Optional[str]:
+    """What the pane's composer LINE holds, four-way (the politeness gate):
+
+      "clear" — a composer prompt observed EMPTY (bare marker, or cursor's
+                placeholder). Safe to inject.
+      "wake"  — the composer holds ONLY wake text (one wake, or the pre-fix
+                stacked concatenation 'check meshcheck mesh'). Safe to
+                nudge with ONE Enter; injecting more text would stack.
+      "busy"  — the composer holds anything else: a human mid-write, or
+                human text merged into our wake. Neither inject nor Enter.
+      None    — pane unreadable or no composer line recognized. UNKNOWN,
+                and unknown fails closed: we never type blind into a pane.
+
+    The composer line comes from _composer_line (last marker line in the
+    capture — cursor renders chrome BELOW the composer, so no fixed tail
+    window can find it).
+    """
+    lines = _capture_pane_lines(target)
+    if lines is None:
+        return None
+    composer = _composer_line(lines)
+    if composer is None:
+        return None
+    content = composer[1:].strip()
+    # cursor right-aligns run-state hints ('ctrl+c to stop') on the composer
+    # ROW, so the placeholder is a PREFIX of the line while the agent runs,
+    # not the whole line. A human message beginning with the exact placeholder
+    # text is the accepted false positive — the only failure it can produce
+    # is an inject alongside contrived text, never a silent deferral.
+    if not content or content.startswith(_CURSOR_COMPOSER_PLACEHOLDER):
+        return "clear"
+    # A human who types exactly 'check mesh' by hand is indistinguishable
+    # from our own unsubmitted wake — and submitting it runs the same
+    # command, so the collision is harmless in that direction only.
+    if content.replace(_WAKE_PROMPT, "").strip() == "":
+        return "wake"
+    return "busy"
 
 
 def _tmux_enter(target: str) -> bool:
@@ -1567,7 +1690,7 @@ def _tmux_enter(target: str) -> bool:
         return False
 
 
-def _tmux_wake(target: str) -> bool:
+def _tmux_wake(target: str) -> Optional[bool]:
     """Inject the wake prompt and confirm it SUBMITTED (#533).
 
     Was: Codex's blind double-Enter, on the assumption that a second Enter in
@@ -1577,13 +1700,16 @@ def _tmux_wake(target: str) -> bool:
     prompt on cursor-lin, 2026-08-24, three times in a row.
 
     Now: inject, settle, then Enter-and-verify in a bounded loop — re-Enter
-    only while the prompt is OBSERVED still sitting in the composer. Codex's
+    only while the composer is OBSERVED holding wake text alone. Codex's
     second Enter falls out naturally (it fires only when the first did not
-    submit). Returns True only on an observed-clear composer: a wake we
-    cannot confirm stays owed, because the cursor advances only inside
-    `if _tmux_wake(...)`. An UNREADABLE pane (capture failure) fails closed
-    — no unverified retries, no claimed success; the wake stays owed and the
-    ledger retries the whole wake later.
+    submit). Three outcomes: True on an observed-clear composer (submitted);
+    None when the human ADOPTED the composer mid-settle (wake text merged
+    with their typing — another Enter would submit their line, so the loop
+    stops, and the sink DEFERS: the cursor must not advance on a wake that
+    never submitted as ours — gpt-ops, #312 round 5); False when the pane
+    could not be verified (the wake stays owed). An UNREADABLE pane (capture
+    failure) fails closed — no unverified retries, no claimed success; the
+    wake stays owed and the ledger retries the whole wake later.
     """
     try:
         subprocess.run(
@@ -1603,8 +1729,8 @@ def _tmux_wake(target: str) -> bool:
                 text=True, encoding="utf-8", errors="replace",
             )
             time.sleep(_WAKE_SETTLE_S)
-            pending = _wake_still_pending(target)
-            if pending is None:
+            state = _composer_state(target)
+            if state is None:
                 print(
                     "[monitor] tmux wake unverifiable (capture failed); "
                     "failing closed — wake stays owed",
@@ -1612,8 +1738,16 @@ def _tmux_wake(target: str) -> bool:
                     flush=True,
                 )
                 return False
-            if not pending:
+            if state == "clear":
                 return True
+            if state == "busy":
+                # The human typed into the wake mid-settle (gpt-ops, #312
+                # round 5): the wake text never submitted as ours, so this
+                # must NOT acknowledge delivery — return None and let the
+                # sink DEFER, keeping the cursor back so a later poll
+                # retries the wake when the composer clears.
+                return None
+            # "wake": still sitting unsubmitted — loop another Enter.
         print(
             f"[monitor] tmux wake still unsubmitted after "
             f"{_WAKE_SUBMIT_ATTEMPTS} Enters; wake stays owed",
@@ -1805,7 +1939,18 @@ def _monitor_deliver(state: MonitorState) -> None:
                       f"delivering the newest {len(dms)} (limit "
                       f"{state.replay_limit}) -- see {state.inbox_log_path}",
                       file=sys.stderr, flush=True)
-            if sink.deliver(state, dms, observed):
+            outcome = sink.deliver(state, dms, observed)
+            if outcome is None:
+                # DEFERRED (e.g. TmuxSink's politeness gate): the wake stays
+                # owed — the cursor does NOT advance — but a deferral is not
+                # a failure: no count, no alarm, no ledger write. Retried on
+                # the next poll like any owed delivery.
+                print(f"{state.log_prefix} delivery DEFERRED for {sink.name} "
+                      f"(composer holds human text); wake stays owed, "
+                      f"no failure counted",
+                      flush=True)
+                continue
+            if outcome:
                 led["last_delivered_id"] = observed
                 led["last_delivery_at"] = now
                 led["consecutive_failures"] = 0

{swarph_cli-0.48.0 → swarph_cli-0.48.2/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.48.0
+Version: 0.48.2
 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.48.0 → swarph_cli-0.48.2}/tests/test_mesh_sidecar.py

@@ -6,9 +6,19 @@ import json
 import time
 from pathlib import Path
 
+import pytest
+
 from swarph_cli.commands import mesh
 
 
+@pytest.fixture(autouse=True)
+def _clean_composer(monkeypatch):
+    """These tests pin ledger/cursor mechanics, not the politeness gate —
+    default every composer to OBSERVED-CLEAN so the gate stays out of the
+    way. The gate's own matrix lives in test_tmux_wake_submit_verify.py."""
+    monkeypatch.setattr(mesh, "_composer_state", lambda t: "clear")
+
+
 def _state(tmp_path: Path) -> mesh.MeshSidecarState:
     return mesh.MeshSidecarState(
         self_name="gpt-ops",
@@ -39,12 +49,19 @@ def test_tmux_wake_sends_literal_prompt_then_submits_and_verifies(monkeypatch):
         lambda command, **kwargs: calls.append((command, kwargs)) or Result(),
     )
     monkeypatch.setattr(mesh.time, "sleep", lambda _s: None)
+    # The verifier is now a projection of the four-way composer state; the
+    # autouse fixture stubs that state. Record the consultation instead of
+    # expecting a raw capture-pane call in the sequence.
+    seen = []
+    monkeypatch.setattr(
+        mesh, "_composer_state",
+        lambda t: seen.append(t) or "clear")
 
     assert mesh._tmux_wake("gpt-lc:0.0") is True
+    assert seen == ["gpt-lc:0.0"]  # verified through the composer gate
     assert [command for command, _ in calls] == [
         ["tmux", "send-keys", "-t", "gpt-lc:0.0", "-l", "check mesh"],
         ["tmux", "send-keys", "-t", "gpt-lc:0.0", "Enter"],
-        ["tmux", "capture-pane", "-p", "-t", "gpt-lc:0.0"],
     ]
 
 

{swarph_cli-0.48.0 → swarph_cli-0.48.2}/tests/test_mesh_sidecar_cursor_decoupled.py

@@ -17,9 +17,19 @@ succeeds. Waking is DELIVERY; the cursor is BOOKKEEPING.
 
 Run: venv/bin/python -m pytest tests/test_mesh_sidecar_cursor_decoupled.py -v
 """
+import pytest
+
 from swarph_cli.commands import mesh
 
 
+@pytest.fixture(autouse=True)
+def _clean_composer(monkeypatch):
+    """These tests pin cursor/ledger decoupling, not the politeness gate —
+    default every composer to OBSERVED-CLEAN so the gate stays out of the
+    way. The gate's own matrix lives in test_tmux_wake_submit_verify.py."""
+    monkeypatch.setattr(mesh, "_composer_state", lambda t: "clear")
+
+
 def _state(tmp_path, wake_min_interval_s=0):
     return mesh.MeshSidecarState(
         self_name="lab-ovh",

{swarph_cli-0.48.0 → swarph_cli-0.48.2}/tests/test_mesh_sidecar_wake_survives_read.py

@@ -9,9 +9,19 @@ Run: venv/bin/python -m pytest tests/test_mesh_sidecar_wake_survives_read.py -v
 """
 import urllib.parse
 
+import pytest
+
 from swarph_cli.commands import mesh
 
 
+@pytest.fixture(autouse=True)
+def _clean_composer(monkeypatch):
+    """These tests pin ledger/cursor mechanics, not the politeness gate —
+    default every composer to OBSERVED-CLEAN so the gate stays out of the
+    way. The gate's own matrix lives in test_tmux_wake_submit_verify.py."""
+    monkeypatch.setattr(mesh, "_composer_state", lambda t: "clear")
+
+
 def _state(tmp_path, wake_min_interval_s=0):
     return mesh.MeshSidecarState(
         self_name="grok-researcher",

{swarph_cli-0.48.0 → swarph_cli-0.48.2}/tests/test_monitor_cli.py

@@ -16,9 +16,19 @@ from __future__ import annotations
 import json
 import os
 
+import pytest
+
 from swarph_cli.commands import mesh, monitor
 
 
+@pytest.fixture(autouse=True)
+def _clean_composer(monkeypatch):
+    """These tests pin CLI/ledger mechanics, not the politeness gate —
+    default every composer to OBSERVED-CLEAN so the gate stays out of the
+    way. The gate's own matrix lives in test_tmux_wake_submit_verify.py."""
+    monkeypatch.setattr(mesh, "_composer_state", lambda t: "clear")
+
+
 def _env(monkeypatch):
     monkeypatch.setenv("SWARPH_SELF", "lab-ovh")
     monkeypatch.setenv("MESH_GATEWAY_TOKEN", "tok")

{swarph_cli-0.48.0 → swarph_cli-0.48.2}/tests/test_monitor_state_split.py

@@ -25,6 +25,14 @@ import pytest
 from swarph_cli.commands import mesh
 
 
+@pytest.fixture(autouse=True)
+def _clean_composer(monkeypatch):
+    """These tests pin ledger/cursor mechanics, not the politeness gate —
+    default every composer to OBSERVED-CLEAN so the gate stays out of the
+    way. The gate's own matrix lives in test_tmux_wake_submit_verify.py."""
+    monkeypatch.setattr(mesh, "_composer_state", lambda t: "clear")
+
+
 def _state(tmp_path, sinks, *, min_interval_s=0, self_name="lab-ovh", replay_limit=50):
     return mesh.MonitorState(
         self_name=self_name,