swarph-cli 0.72.2__tar.gz → 0.72.4__tar.gz

{swarph_cli-0.72.2/src/swarph_cli.egg-info → swarph_cli-0.72.4}/PKG-INFO

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

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

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

{swarph_cli-0.72.2 → swarph_cli-0.72.4}/src/swarph_cli/commands/mesh.py

@@ -1483,6 +1483,10 @@ class TmuxSink(Sink):
     def deliver(self, state: "MonitorState", dms: list, up_to_id: int) -> Optional[bool]:
         led = state.ledger(self.name)
         self.failure_reason = None
+        # #1010: the deferral cause, named for the monitor's DEFERRED log —
+        # a hardcoded cause is a lie on every path that defers for another
+        # reason (the standing-wake hold defers with a CLEAR composer).
+        self.deferred_reason = None
         # #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
@@ -1601,21 +1605,36 @@ class TmuxSink(Sink):
                         if ok is None:
                             return None  # human adopted mid-settle: defer
                         return False     # unreadable: loud failure
-                    # Wake submitted into THIS session and still inside its
-                    # trust window; re-injecting would only stack. This return
-                    # is the ONLY delivery report backed by no fresh keystroke
-                    # — every other outcome (delivered, failed, deferred)
-                    # announces itself, and this branch's 57 lines had zero
-                    # print() calls. Silence correlated with the lie (#611,
-                    # cursor-win's swallowed wake): say what we are claiming
-                    # and how old the evidence is. (#616 makes #332's
-                    # "injection predates the ledger anchor" arm unreachable
-                    # on this path — an undated wake is always stale — so the
-                    # arm is removed rather than kept as readable-dead code.)
-                    print(f"[monitor] {self.name}: delivery reported on a STANDING wake "
-                          f"(injected {time.time() - injected_at:.0f}s ago, "
-                          f"no keystroke this poll)")
-                    return True
+                    # #1010 STRAND-ONLY (lab's ruling after the 5th FAIL,
+                    # science-claude #1101): this return was the ONLY
+                    # delivery report backed by no fresh keystroke, and it
+                    # STRANDED the DM batch it reported. The ledger cursor
+                    # advanced to the newest id, the monitor then owed
+                    # nothing, and this poll was the last one that would
+                    # ever look at the batch — measured by droplet on
+                    # friendly-coder: its tail was down, typing was its only
+                    # wake, and the standing-wake claim "delivered" every
+                    # DM with ZERO keystrokes while the cell idled at an
+                    # empty prompt, forever. Fix WITHOUT classification:
+                    # report the hold, not a delivery. deliver returns None
+                    # — the cursor does not advance, the batch stays OWED
+                    # and is retried on every poll — and BASE'S OWN stale
+                    # bound below (_WAKE_STALE_S, 600 s from the injection)
+                    # re-injects and types at the first idle poll past it.
+                    # Bounded, loud, never silently dropped; no pane
+                    # classifier is consulted, so every pane keeps base's
+                    # behaviour. The anti-stack property survives: zero
+                    # keystrokes while the window stands.
+                    print(f"[monitor] {self.name}: standing wake inside its "
+                          f"{_WAKE_STALE_S:.0f}s trust window (injected "
+                          f"{time.time() - injected_at:.0f}s ago) — DM held "
+                          f"owed, zero keys this poll; the stale bound "
+                          f"re-injects and types")
+                    self.deferred_reason = (
+                        f"standing wake inside the {_WAKE_STALE_S:.0f}s "
+                        "trust window — DM held owed, the stale bound "
+                        "re-injects and types")
+                    return None
                 if composer == "busy":
                     # Human text shares the composer (possibly merged into our
                     # wake) — an Enter here submits THEIR line (#403's shape).
@@ -3333,8 +3352,13 @@ def _monitor_deliver(state: MonitorState) -> None:
                         state.gateway, state.token, state.self_name, ticks, len(dms)
                     )
                 changed = True
+                # #1010: name the deferral's real cause — a hardcoded
+                # "composer holds human text" is a lie on the standing-wake
+                # hold, which defers with a CLEAR composer.
+                detail = getattr(sink, "deferred_reason", None) \
+                    or "composer holds human text"
                 print(f"{state.log_prefix} delivery DEFERRED for {sink.name} "
-                      f"(composer holds human text); wake stays owed, "
+                      f"({detail}); wake stays owed, "
                       f"no failure counted",
                       flush=True)
                 continue

{swarph_cli-0.72.2 → swarph_cli-0.72.4}/src/swarph_cli/commands/spawn.py

@@ -581,9 +581,16 @@ def _spawn_env_base(cell: Cell) -> dict[str, str]:
     # NOTE: the marketplace/validity gate lives in _validate_channel, which
     # _build_claude_argv (and the muse env builder) run. This base stays a
     # pure reflection of the resolved mode so every provider's env agrees.
+    # #1022: SWARPH_CHANNEL must be exported too, whatever the mode's source.
+    # channel_opted_in() (channel.py) gates on SWARPH_CHANNEL alone, so a
+    # mode that came from cell.yaml — not from the parent env — left the
+    # session with SWARPH_CHANNEL_CELL set and the channel deaf: the server
+    # never declared claude/channel (droplet 4 days, gridiron on lab).
     if mode in {"allowlisted", "dev"}:
+        env["SWARPH_CHANNEL"] = mode
         env["SWARPH_CHANNEL_CELL"] = cell.name
     else:
+        env.pop("SWARPH_CHANNEL", None)
         env.pop("SWARPH_CHANNEL_CELL", None)
     return env
 

{swarph_cli-0.72.2 → swarph_cli-0.72.4}/src/swarph_cli/guide/GUIDE.md

@@ -23,6 +23,7 @@ Read the topic you need. You do not need to read this top to bottom.
 | [Check your own setup](#check-your-own-setup) | commands with their expected answers |
 | [How to](#how-to) | tasks, phrased the way you'd ask for them |
 | [Glossary](#glossary) | the words this mesh uses |
+| [Architecture overview](#architecture-overview) | the five layers, the six rules, and how a change ships |
 
 ---
 
@@ -55,6 +56,15 @@ want, run the command.
 | see what a wake hook would print | `swarph wake-hook-output` |
 | search this guide | `swarph guide --search <word>` |
 | learn the standard of evidence | `swarph guide doctrine` |
+| see how the stack fits together | see [Architecture overview](#architecture-overview) |
+
+---
+
+## Architecture overview
+
+The five layers, the six rules, the delivery pipeline, shadow-to-graduate,
+the security posture, and the stack-versus-off-the-shelf table are in
+[docs/architecture-overview.md](../../../docs/architecture-overview.md).
 
 ---
 

{swarph_cli-0.72.2 → swarph_cli-0.72.4}/src/swarph_cli/scripts/wake_watchdog.py

@@ -1,4 +1,4 @@
-"""Card #729. Every pass, a cell with nobody reading its inbox is an outage.
+"""IMMUNE (cell watchdog), card #729. Every pass, a cell with nobody reading its inbox is an outage.
 
 One DM per outage. A live watcher clears it, so the next gap can alert again.
 """
@@ -360,17 +360,17 @@ def main(argv: list[str] | None = None) -> int:
     for name in alert:
         print(f"outage {name}", flush=True)
         dm_rc = mesh_send(
-            swarph, name, sender, "your DM wake is dead, re-arm", token_file)
+            swarph, name, sender, "IMMUNE (cell watchdog): your DM wake is dead, re-arm", token_file)
         dm_ok = dm_rc == 0
         card_argv = [swarph, "board", "cards", "say", "729", "--as", sender,
-                     "--to", name, "--content", f"{name}: DM wake is dead, re-arm"]
+                     "--to", name, "--content", f"IMMUNE (cell watchdog) — {name}: DM wake is dead, re-arm"]
         if token_file:
             card_argv.extend(["--token-file", token_file])
         card = subprocess.run(card_argv, check=False)
         esc_ok = True
         if escalate and escalate != name:
             esc_rc = mesh_send(
-                swarph, escalate, sender, f"{name}: DM wake is dead, re-arm",
+                swarph, escalate, sender, f"IMMUNE (cell watchdog) — {name}: DM wake is dead, re-arm",
                 token_file)
             esc_ok = esc_rc == 0
         if dm_ok and card.returncode == 0 and esc_ok:

{swarph_cli-0.72.2 → swarph_cli-0.72.4}/src/swarph_cli/systemd/swarph-watchdog.service

@@ -1,5 +1,5 @@
 [Unit]
-Description=Swarph watchdog one-shot check (stranded-session recovery)
+Description=IMMUNE (cell watchdog): Swarph watchdog one-shot check (stranded-session recovery)
 Documentation=https://github.com/BrainSurfing-tech/swarph-cli
 After=network-online.target
 Wants=network-online.target

{swarph_cli-0.72.2 → swarph_cli-0.72.4}/src/swarph_cli/systemd/swarph-watchdog.timer

@@ -1,5 +1,5 @@
 [Unit]
-Description=Run swarph watchdog every 5 minutes (stranded-session recovery)
+Description=Run IMMUNE (cell watchdog): swarph watchdog every 5 minutes (stranded-session recovery)
 Documentation=https://github.com/BrainSurfing-tech/swarph-cli
 Requires=swarph-watchdog.service
 

{swarph_cli-0.72.2 → swarph_cli-0.72.4/src/swarph_cli.egg-info}/PKG-INFO

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

@@ -188,6 +188,7 @@ src/swarph_cli/systemd/swarph-watchdog.service
 src/swarph_cli/systemd/swarph-watchdog.timer
 tests/test_1006_board_publisher.py
 tests/test_1006_session_board.py
+tests/test_1010_strand_only.py
 tests/test_1013_spawn_channel.py
 tests/test_1017_muse_tui.py
 tests/test_124_register_merge.py

{swarph_cli-0.72.2 → swarph_cli-0.72.4}/tests/test_1006_board_publisher.py

@@ -346,3 +346,77 @@ def test_in_session_marker_sets_the_flag_and_strips_the_title():
     assert "[in-session]" not in marked["title"]
     assert "[commander]" not in marked["title"]
     assert plain["in_session"] is False
+
+
+def _commander_obligation(oid, holder="commander", step="build", accept="PASS=x | FAIL=y", title="Do it"):
+    return {
+        "id": oid,
+        "holder": holder,
+        "card_id": 291,
+        "state": "open",
+        "step": step,
+        "accept": f"[commander] {title} | {accept}",
+    }
+
+
+def test_tap_closable_commander_rows_render_yes_no():
+    """card #291 ruling_1157 (1): a tap-closable commander row (build or
+    step-less) renders as yes/no with the fixed mapping yes=pass, no=fail —
+    even when the row carries its own prose options."""
+    pub = _load()
+    rows = pub.commander_rows([
+        _commander_obligation(1, step="build"),
+        _commander_obligation(2, step=None),
+    ])
+    assert [r["step"] for r in rows] == ["build", None]
+    by_cell = {}
+    for row in rows:
+        row["title"] = "Do it"
+        row["options"] = [{"label": "Prose", "text": "discuss first", "rec": True}]
+        by_cell.setdefault(row["cell"], []).append(row)
+    questions = pub.build_board._questions(by_cell["commander"])
+    assert len(questions) == 2
+    for q in questions:
+        assert [(o["label"], o["text"], o["outcome"]) for o in q["options"]] == [
+            ("Yes", "yes", "pass"),
+            ("No", "no", "fail"),
+        ], "RED: tap-closable rows render yes/no, never row prose"
+
+
+def test_validate_plan_review_rows_keep_display_only_options():
+    """card #291 ruling_1157 (1): validate/plan-review commander rows are
+    NOT taps — their options stay prose and every option carries
+    outcome None (display-only, closes nothing)."""
+    pub = _load()
+    rows = pub.commander_rows([
+        _commander_obligation(3, step="validate"),
+        _commander_obligation(4, step="plan-review"),
+    ])
+    by_cell = {}
+    for row in rows:
+        row["title"] = "Check it"
+        row["options"] = [{"label": "Prose", "text": "discuss first", "rec": True}]
+        by_cell.setdefault(row["cell"], []).append(row)
+    questions = pub.build_board._questions(by_cell["commander"])
+    assert len(questions) == 2
+    for q in questions:
+        assert all(o.get("outcome") is None for o in q["options"]), \
+            "RED: no prose option closes PASS by default"
+        assert [o["label"] for o in q["options"]] == ["Prose"]
+
+
+def test_default_options_are_display_only():
+    """The three fallback prose options carry outcome None on every row."""
+    pub = _load()
+    rows = pub.commander_rows([_commander_obligation(5, step="build")])
+    row = dict(rows[0])
+    row["title"] = "Do it"
+    row.pop("options", None)
+    other = dict(row, cell="drop-on-meta-edge", holder="drop-on-meta-edge")
+    for q in pub.build_board._questions([row, other]):
+        if q["to_node"] == "commander":
+            assert [o["outcome"] for o in q["options"]] == ["pass", "fail"]
+        else:
+            assert [o["label"] for o in q["options"]] == [
+                "Answer on the card", "Ask for a narrower question", "Park it"]
+            assert all(o["outcome"] is None for o in q["options"])

swarph_cli-0.72.4/tests/test_1010_strand_only.py

@@ -0,0 +1,225 @@
+"""#1010 STRAND-ONLY (lab's ruling after science-claude's #1101 FAIL, the
+5th on PR 534): PR 534 ships NO pane idle/busy classifier change — every
+pane keeps base 0.72.3's behaviour — and the strand is fixed in the
+LEDGER layer alone.
+
+THE STRAND (measured by droplet on friendly-coder): the tmux sink's
+standing-wake path returned True with ZERO keystrokes. The monitor
+advanced `last_delivered_id`, owed nothing from then on, and the DM
+batch was never looked at again — every DM "delivered" in the log while
+the cell idled at an empty prompt, typing its only wake, forever. The
+repro that opened #1010: an ANSWERED wake, a monitor RESTART, a new DM.
+
+THE FIX (no classification): the standing-wake hold reports the hold,
+not a delivery. deliver returns None — the cursor does not advance, the
+batch stays OWED and is retried on every poll — and BASE'S OWN stale
+bound (_WAKE_STALE_S = 600 s from the injection) re-injects and types
+at the first idle poll past it. Bounded, loud, never silently dropped.
+
+>>> RED on e445877 (base 0.72.3): the monitor-level repro below never
+typed — the first poll returned True with zero keystrokes, the cursor
+advanced, and every later poll owed nothing (assert wake_calls == 1
+fails with 0). The unit pins of the hold returned True there too.
+"""
+from __future__ import annotations
+
+import pathlib
+import time
+
+import swarph_cli.commands.mesh as mesh
+import swarph_cli.commands.watchdog as watchdog
+
+
+class _StubState:
+    def __init__(self):
+        self.gateway = "http://gw:8788"
+        self.self_name = "cursor-lin"
+        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 _rig(monkeypatch, *, composer="clear", unread=3,
+         session_created=None, running=False):
+    """Pin every observation deliver() makes; record the keystrokes.
+
+    running defaults to False: the #1010 repro is the ANSWERED wake — the
+    turn already ran, the pane idles at an empty prompt. The rig pins
+    `_capture_pane_lines` too: the conftest guard fails any unmocked tmux
+    call, and deliver() reads the pane for the grok-block check before
+    any of this."""
+    calls = {"wake": 0, "enter": 0}
+    monkeypatch.setattr(mesh, "_capture_pane_lines", lambda t: ["row"])
+    monkeypatch.setattr(mesh, "_composer_state", lambda t: composer)
+    monkeypatch.setattr(mesh, "_tmux_session_created", lambda t: session_created)
+    monkeypatch.setattr(mesh, "_agent_running", lambda t: running)
+    monkeypatch.setattr(watchdog, "_gateway_unread_count",
+                        lambda *a, **k: unread)
+
+    def fake_wake(target):
+        calls["wake"] += 1
+        return True
+
+    def fake_enter(target):
+        calls["enter"] += 1
+        return True
+
+    monkeypatch.setattr(mesh, "_tmux_wake", fake_wake)
+    monkeypatch.setattr(mesh, "_tmux_enter", fake_enter)
+    return calls
+
+
+def _owed_state(injected_at=None):
+    state = _StubState()
+    led = state.ledger("tmux:cursor-lin")
+    led["wake_outstanding"] = True
+    if injected_at is not None:
+        led["last_wake_injected_at"] = injected_at
+    return state
+
+
+# ── the hold: loud, bounded, zero keystrokes, nothing marked delivered ───
+
+def test_standing_wake_hold_is_loud_bounded_and_keeps_the_dm_owed(
+        monkeypatch, capsys):
+    """#1010 clause 2: a DM suppressed by a standing wake is NEVER
+    marked delivered while untyped. The hold says what it is doing — the
+    trust window, the wake's age, and that the stale bound types — and
+    returns None, so the monitor's cursor stays put and the batch is
+    retried next poll. >>> RED on e445877: this returned True — delivery
+    reported, zero keystrokes, the DM stranded."""
+    now = time.time()
+    calls = _rig(monkeypatch, composer="clear", unread=3,
+                 session_created=now - 7200, running=False)
+    state = _owed_state(injected_at=now - 60)
+    sink = mesh.TmuxSink("cursor-lin")
+
+    assert sink.deliver(state, [{"id": 9}], 9) is None
+    assert calls["wake"] == 0 and calls["enter"] == 0, "zero keys inside the window"
+    led = state.ledger("tmux:cursor-lin")
+    assert led["wake_outstanding"] is True, "the standing wake is undisturbed"
+    out = capsys.readouterr().out
+    assert "standing wake inside its 600s trust window" in out, out
+    assert "DM held owed" in out
+    assert "zero keys" in out
+    assert "re-injects and types" in out
+    # the monitor's DEFERRED line names the real cause, not human text
+    assert "standing wake" in (sink.deferred_reason or "")
+    assert "human text" not in (sink.deferred_reason or "")
+
+
+def test_no_keystroke_sooner_than_base_inside_the_window(monkeypatch):
+    """The FAIL arm: no keystroke SOONER than base. Repeated polls inside
+    the trust window type nothing — the anti-stack property the
+    edge-trigger exists for (#312) survives the hold. Base stacked zero
+    keys here too; the difference is only that base also claimed
+    delivery."""
+    now = time.time()
+    calls = _rig(monkeypatch, composer="clear", unread=3,
+                 session_created=now - 7200, running=False)
+    state = _owed_state(injected_at=now - 60)
+    sink = mesh.TmuxSink("cursor-lin")
+    for _ in range(5):
+        assert sink.deliver(state, [{"id": 9}], 9) is None
+    assert calls["wake"] == 0 and calls["enter"] == 0
+
+
+def test_held_dm_is_typed_when_the_600s_window_lapses(monkeypatch):
+    """#1010 clause 2, the other arm: the held DM does not stay held
+    forever — BASE'S OWN stale bound (a wake undrained for
+    _WAKE_STALE_S) re-injects, and the first idle poll past the bound
+    carries a real keystroke. The DM is then delivered for real."""
+    now = time.time()
+    calls = _rig(monkeypatch, composer="clear", unread=3,
+                 session_created=now - 7200, running=False)
+    state = _owed_state(injected_at=now - 601)
+    sink = mesh.TmuxSink("cursor-lin")
+
+    assert sink.deliver(state, [{"id": 9}], 9) is True
+    assert calls["wake"] == 1, "the stale bound re-injects — a keystroke"
+    led = state.ledger("tmux:cursor-lin")
+    assert led["last_wake_injected_at"] > now - 5, "the retry re-anchors"
+
+
+# ── the original repro, at the monitor: answered wake, restart, new DM ────
+
+class _MonitorStubState(_StubState):
+    """The poll-loop pass reads: sinks, the observed cursor, the ledgers,
+    the idle-guard clock, and the inbox log for replay."""
+
+    def __init__(self, observed_id, delivered_id, ledgers=None, inbox_log=None):
+        super().__init__()
+        if ledgers is not None:
+            self._ledgers = ledgers  # the restart shape: one persisted ledger
+        self.sinks = [mesh.TmuxSink("cursor-lin")]
+        self.ledgers = self._ledgers
+        self.observed = {"last_msg_id": observed_id}
+        self.min_interval_s = 60
+        self.deliveries: dict = {}
+        self.ledgers_path = pathlib.Path("/dev/null")
+        self.log_prefix = "[test]"
+        self.inbox_log_path = inbox_log or pathlib.Path(
+            "/tmp/1010-strand-no-such-inbox.log")
+        self.replay_limit = 50
+        led = self.ledger("tmux:cursor-lin")
+        led["last_delivered_id"] = delivered_id
+        led["last_delivery_at"] = time.time() - 3600
+        led["wake_outstanding"] = True
+
+
+def _poll(monkeypatch, state, unread):
+    monkeypatch.setattr(watchdog, "_gateway_unread_count",
+                        lambda *a, **k: unread)
+    writes = []
+    monkeypatch.setattr(mesh, "_write_ledgers_atomic",
+                        lambda p, d: writes.append(dict(d)))
+    mesh._monitor_deliver(state)
+    return writes
+
+
+def test_the_original_repro_types_by_600s_even_after_a_restart(monkeypatch,
+                                                               capsys):
+    """THE #1010 repro, end to end through the poll loop: an ANSWERED
+    wake (turn ran and finished; the flag stands, injected 60 s ago), a
+    monitor RESTART (a fresh state over the SAME ledger), a new DM.
+
+    At the head: the first poll HOLDS (zero keys, cursor unmoved, loud
+    line); 600 s later the stale bound re-injects — ONE keystroke — and
+    the ledger finally advances. Nothing strands and nothing types
+    sooner than base.
+
+    >>> RED on e445877: the first poll reported delivery with ZERO
+    keystrokes, the cursor advanced to 10, and every later poll owed
+    nothing — the DM was never typed (wake_calls stays 0)."""
+    now = time.time()
+    calls = _rig(monkeypatch, composer="clear", unread=3,
+                 session_created=now - 7200, running=False)
+
+    # an answered wake, 60 s inside its trust window; the monitor owes DM 10
+    ledgers: dict = {}
+    state = _MonitorStubState(observed_id=10, delivered_id=9, ledgers=ledgers)
+    state.ledger("tmux:cursor-lin")["last_wake_injected_at"] = now - 60
+
+    _poll(monkeypatch, state, unread=3)  # poll 1: the hold
+    led = ledgers["tmux:cursor-lin"]
+    assert led["last_delivered_id"] == 9, "nothing marked delivered untyped"
+    assert calls["wake"] == 0 and calls["enter"] == 0
+    assert "DM held owed" in capsys.readouterr().out
+    assert led.get("deferred_ticks") == 1, "the deferral is counted, not a failure"
+
+    # monitor restart: a fresh state over the SAME persisted ledger
+    state2 = _MonitorStubState(observed_id=10, delivered_id=9, ledgers=ledgers)
+    # 600 s pass; the same injection is now past base's stale bound
+    ledgers["tmux:cursor-lin"]["last_wake_injected_at"] = time.time() - 601
+
+    _poll(monkeypatch, state2, unread=3)  # poll 2: past the bound
+    assert calls["wake"] == 1, "the stale bound re-injects and TYPES"
+    assert ledgers["tmux:cursor-lin"]["last_delivered_id"] == 10
+
+    _poll(monkeypatch, state2, unread=3)  # poll 3: owes nothing now
+    assert calls["wake"] == 1, "delivered for real — no repeat keystroke"
+    assert "delivered to tmux:cursor-lin up to id 10" in capsys.readouterr().out

{swarph_cli-0.72.2 → swarph_cli-0.72.4}/tests/test_1013_spawn_channel.py

@@ -244,3 +244,28 @@ def test_parent_channel_cell_does_not_reach_a_different_cell(tmp_path, monkeypat
     assert rc == 0
     assert env_added.get("SWARPH_CHANNEL_CELL") == "science-claude"
 
+
+def test_field_channel_exports_swarph_channel_so_serve_is_not_deaf(tmp_path, monkeypatch, capsys):
+    """Card #1022. A mode that came from cell.yaml must reach channel-serve:
+    the spawned env carries SWARPH_CHANNEL=mode (not just SWARPH_CHANNEL_CELL),
+    and channel_opted_in() is True under that env. On 7afd16b the field path
+    set only SWARPH_CHANNEL_CELL, so the server never declared claude/channel
+    and the cell ran deaf (droplet ~4 days, gridiron on lab).
+    """
+    from swarph_cli.channel import channel_opted_in
+
+    _registry(tmp_path, monkeypatch, with_swarph=True)
+    monkeypatch.delenv("SWARPH_CHANNEL", raising=False)
+    p = _cell_yaml(tmp_path, "claude", channel="allowlisted", name="gridiron")
+    rc, argv, env_added = _print(tmp_path, p, capsys)
+    assert rc == 0
+    assert "--channels" in argv and "plugin:swarph@swarph" in argv
+    # The env handed to claude names the mode, whatever its source was.
+    assert env_added.get("SWARPH_CHANNEL") == "allowlisted"
+    assert env_added.get("SWARPH_CHANNEL_CELL") == "gridiron"
+    # And the server's own gate agrees under exactly that env.
+    with monkeypatch.context() as ctx:
+        ctx.setenv("SWARPH_CHANNEL", env_added["SWARPH_CHANNEL"])
+        ctx.setenv("SWARPH_CHANNEL_CELL", env_added["SWARPH_CHANNEL_CELL"])
+        assert channel_opted_in() is True
+

{swarph_cli-0.72.2 → swarph_cli-0.72.4}/tests/test_mesh_sidecar.py

@@ -10,6 +10,11 @@ import pytest
 
 from swarph_cli.commands import mesh
 
+#: The real capture seam, taken at import before any autouse fixture pins
+#: it (#1010 strand-only hermeticity): the #533 test below asserts the
+#: leading capture-pane call that its own subprocess stub must serve.
+_REAL_CAPTURE_PANE_LINES = mesh._capture_pane_lines
+
 
 @pytest.fixture(autouse=True)
 def _clean_composer(monkeypatch):
@@ -17,6 +22,15 @@ def _clean_composer(monkeypatch):
     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")
+    # #1010 strand-only hermeticity (#1083): the grok-block probe, the
+    # run-state read and the session-age read inside deliver() reach the
+    # REAL tmux binary when unpatched — a bare CI runner and a box with
+    # live cells must read the suite the same way. A missing pane reads
+    # unreadable at base; False/None keep the same falsy fall-through
+    # these tests pin.
+    monkeypatch.setattr(mesh, "_capture_pane_lines", lambda t: None)
+    monkeypatch.setattr(mesh, "_agent_running", lambda t: False)
+    monkeypatch.setattr(mesh, "_tmux_session_created", lambda t: None)
 
 
 def _state(tmp_path: Path) -> mesh.MeshSidecarState:
@@ -49,6 +63,10 @@ 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)
+    # #1010 strand-only hermeticity: the autouse fixture pins the capture
+    # seam so no OTHER pane read reaches the real binary; this test's own
+    # subprocess stub serves the leading capture-pane call it asserts.
+    monkeypatch.setattr(mesh, "_capture_pane_lines", _REAL_CAPTURE_PANE_LINES)
     # 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.

{swarph_cli-0.72.2 → swarph_cli-0.72.4}/tests/test_mesh_sidecar_cursor_decoupled.py

@@ -28,6 +28,15 @@ def _clean_composer(monkeypatch):
     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")
+    # #1010 strand-only hermeticity (#1083): the grok-block probe, the
+    # run-state read and the session-age read inside deliver() reach the
+    # REAL tmux binary when unpatched — a bare CI runner and a box with
+    # live cells must read the suite the same way. A missing pane reads
+    # unreadable at base; False/None keep the same falsy fall-through
+    # these tests pin.
+    monkeypatch.setattr(mesh, "_capture_pane_lines", lambda t: None)
+    monkeypatch.setattr(mesh, "_agent_running", lambda t: False)
+    monkeypatch.setattr(mesh, "_tmux_session_created", lambda t: None)
 
 
 def _state(tmp_path, wake_min_interval_s=0):

{swarph_cli-0.72.2 → swarph_cli-0.72.4}/tests/test_mesh_sidecar_wake_survives_read.py

@@ -20,6 +20,15 @@ def _clean_composer(monkeypatch):
     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")
+    # #1010 strand-only hermeticity (#1083): the grok-block probe, the
+    # run-state read and the session-age read inside deliver() reach the
+    # REAL tmux binary when unpatched — a bare CI runner and a box with
+    # live cells must read the suite the same way. A missing pane reads
+    # unreadable at base; False/None keep the same falsy fall-through
+    # these tests pin.
+    monkeypatch.setattr(mesh, "_capture_pane_lines", lambda t: None)
+    monkeypatch.setattr(mesh, "_agent_running", lambda t: False)
+    monkeypatch.setattr(mesh, "_tmux_session_created", lambda t: None)
 
 
 def _state(tmp_path, wake_min_interval_s=0):

{swarph_cli-0.72.2 → swarph_cli-0.72.4}/tests/test_monitor_cli.py

@@ -25,8 +25,15 @@ from swarph_cli.commands import mesh, monitor
 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."""
+    way. The gate's own matrix lives in test_tmux_wake_submit_verify.py.
+    #1010 strand-only hermeticity (#1083): every pane named by this rig
+    is synthetic — an unpatched capture/run-state/session read reaches
+    the REAL tmux binary. A missing pane reads unreadable at base;
+    False/None keep the same falsy fall-through these tests pin."""
     monkeypatch.setattr(mesh, "_composer_state", lambda t: "clear")
+    monkeypatch.setattr(mesh, "_capture_pane_lines", lambda t: None)
+    monkeypatch.setattr(mesh, "_agent_running", lambda t: False)
+    monkeypatch.setattr(mesh, "_tmux_session_created", lambda t: None)
 
 
 def _env(monkeypatch):