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

{swarph_cli-0.48.1/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.1
+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.1 → swarph_cli-0.48.2}/pyproject.toml

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

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

@@ -1204,6 +1204,12 @@ class TmuxSink(Sink):
         # 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
@@ -1653,7 +1659,12 @@ def _composer_state(target: str) -> Optional[str]:
     if composer is None:
         return None
     content = composer[1:].strip()
-    if not content or content == _CURSOR_COMPOSER_PLACEHOLDER:
+    # 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
@@ -1679,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
@@ -1689,14 +1700,14 @@ 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 when the wake is no longer ours to drive: an
-    observed-clear composer (submitted), or a composer the human has ADOPTED
-    (wake text merged with their typing mid-settle — another Enter would
-    submit their line, so the loop stops and the busy-deferral owns the wake
-    from there). A wake we cannot confirm stays owed, because the cursor
-    advances only inside `if _tmux_wake(...)`. An UNREADABLE pane (capture
+    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.
     """
@@ -1718,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",
@@ -1727,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",

{swarph_cli-0.48.1 → 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.1
+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.1 → swarph_cli-0.48.2}/tests/test_tmux_wake_submit_verify.py

@@ -377,18 +377,39 @@ def test_claude_history_prompt_above_composer(tmux):
 
 
 def test_merged_wake_and_human_text_stops_the_loop(tmux):
-    """gpt-ops, PR #312 round 4: the human types DURING the settle — the
+    """gpt-ops, PR #312 rounds 4-5: the human types DURING the settle — the
     composer holds 'check mesh half-typed human line'. Pending must mean
     wake-ONLY: merged reads False, and the verify loop sends NO further
-    Enter (it would submit the human's half-typed line, #403's shape). The
-    wake is out of our hands; the busy-deferral owns it from there."""
+    Enter (it would submit the human's half-typed line, #403's shape). And
+    the wake must NOT be acknowledged: _tmux_wake returns None so the sink
+    DEFERS and the cursor stays back — otherwise the wake is silently lost
+    when the human never sends their line."""
     calls, state = tmux
     state["captures"] = ["> check mesh half-typed human line"]
     assert mesh._wake_still_pending("pane") is False
-    assert mesh._tmux_wake("pane") is True  # adopted — not owed
+    assert mesh._tmux_wake("pane") is None  # adopted — DEFER, not delivered
     assert sum(1 for c in calls if c[-1] == "Enter") == 1  # first Enter only
 
 
+def test_merged_mid_settle_defers_and_holds_the_cursor(tmux):
+    """Deliver-level round 5: the gate reads clear, the inject lands, and
+    the human merges into the wake during the settle. deliver() must DEFER
+    (None): last_delivered_id does NOT advance, no failure is counted, and
+    wake_outstanding is NOT set (nothing of ours is driving)."""
+    calls, capstate = tmux
+    capstate["captures"] = [
+        "> ",                              # gate: observed clean
+        "> check mesh half-typed human",   # verify: adopted mid-settle
+    ]
+    state = _State()
+    sink = mesh.TmuxSink("pane")
+    assert sink.deliver(state, [], 7) is None
+    led = state.ledger("tmux:pane")
+    assert led.get("last_delivered_id", 0) == 0   # cursor held
+    assert led.get("consecutive_failures", 0) == 0
+    assert led.get("wake_outstanding") is not True
+
+
 def test_busy_composer_defers_the_inject(gate):
     """THE commander's case: mid-write, a wake arrives. No text lands, the
     wake stays owed, and NOTHING is counted as failed."""
@@ -489,3 +510,28 @@ def test_engine_counts_deferral_as_neither_success_nor_failure(tmp_path, capsys)
     out = capsys.readouterr()
     assert "DEFERRED" in out.out
     assert "DELIVERY FAILED" not in out.err
+
+
+def test_engine_defers_on_adopted_mid_settle_with_real_tmux_sink(tmp_path, tmux, capsys):
+    """gpt-ops, #312 round 6: the deliver-level merged test's cursor
+    assertions pass TRIVIALLY — deliver() never writes last_delivered_id,
+    the ENGINE does. This pins the real path end-to-end: a REAL TmuxSink,
+    scripted clear→merged captures, through _monitor_deliver. The DM stays
+    owed (cursor held at 0), no failure counted, no delivery recorded, no
+    ledger written."""
+    calls, capstate = tmux
+    capstate["captures"] = [
+        "> ",                              # gate: observed clean
+        "> check mesh half-typed human",   # verify: adopted mid-settle
+    ]
+    state = _EngineState(tmp_path)
+    state.sinks = [mesh.TmuxSink("pane")]
+    mesh._monitor_deliver(state)
+    led = state.ledgers["tmux:pane"]
+    assert led["last_delivered_id"] == 0  # id 5 still owed
+    assert led["consecutive_failures"] == 0
+    assert state.deliveries == {}
+    assert not state.ledgers_path.exists()
+    out = capsys.readouterr()
+    assert "DEFERRED" in out.out
+    assert "DELIVERY FAILED" not in out.err