swarph-cli 0.69.0__tar.gz → 0.69.2__tar.gz

{swarph_cli-0.69.0/src/swarph_cli.egg-info → swarph_cli-0.69.2}/PKG-INFO

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

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

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

{swarph_cli-0.69.0 → swarph_cli-0.69.2}/src/swarph_cli/commands/mesh.py

@@ -1474,6 +1474,11 @@ class TmuxSink(Sink):
         # observation and let the fresh path take over — it defers while
         # running (#619) and injects at the first idle poll.
         if led.get("wake_outstanding") and _agent_running(self.target):
+            # 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):
+                return None
             led["wake_outstanding"] = False
         if led.get("wake_outstanding"):
             # Lazy: watchdog imports mesh module-level, so the reverse must
@@ -1496,6 +1501,17 @@ class TmuxSink(Sink):
                     _tmux_enter(self.target)  # one verified nudge, no new text
                     return True
                 if composer == "clear":
+                    # 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):
+                        ok = _tmux_wake(self.target)
+                        if ok:
+                            _stamp_wake(led)
+                            return True
+                        if ok is None:
+                            return None
+                        return False
                     # #611: a clear composer proves the wake SUBMITTED only if
                     # the pane it was injected into is still the pane we are
                     # reading. The ledger flag survives a respawn; the wake
@@ -1979,6 +1995,19 @@ def _log_dm(state: MonitorState, dm: dict) -> None:
 
 
 _WAKE_PROMPT = "check mesh"
+# Opencode has no push channel (#601). The wake is one line that names the
+# pull tool and carries no DM body, so the turn cannot answer mail it was
+# not shown. Longer than _WAKE_PROMPT, so wake-text detection strips this
+# one first.
+_OPENCODE_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
+# 07:10Z). On a wide pane the same row continues into the sidebar, so the
+# duration is not the end of the line. An in-progress header has no duration.
+_OPENCODE_DONE = re.compile(
+    r"·\s*(?:\d+h\s*)?(?:\d+m\s*)?\d+(?:\.\d+)?s\b"
+)
 # Submit-verify bounds (#533): the settle pause lets the -l literal LAND in
 # the composer before Enter can submit it (the blind gesture raced this), and
 # the attempt bound keeps a never-submitting pane from being Enter-spammed
@@ -2072,20 +2101,168 @@ _COMPOSER_PLACEHOLDERS = ("Add a follow-up", "Ask Codex to do anything")
 _CURSOR_RUN_HINT = "ctrl+c to stop"
 
 
+def _only_wake_text(content: str) -> bool:
+    """True when the composer holds wake text and nothing else.
+
+    The opencode prompt contains the cursor/claude prompt as a prefix, so
+    the longer string is removed first. A stack of either prompt still
+    counts as wake text (one Enter drains it). Anything left over is a
+    human's line.
+    """
+    rest = content
+    for prompt in (_OPENCODE_WAKE_PROMPT, _WAKE_PROMPT):
+        rest = rest.replace(prompt, "")
+    return rest.strip() == ""
+
+
+def _opencode_mode_row(line: str) -> bool:
+    """The mode row under the input. ``--auto`` inserts a word, so the row
+    is ``Build ·`` or ``Build auto ·`` (measured 1.18.33, both shapes).
+    """
+    s = line.strip()
+    if not s.startswith("┃") or "·" not in s:
+        return False
+    body = s[1:].strip()
+    return body.startswith("Build") or body.startswith("Plan")
+
+
+def _opencode_permission_row(line: str) -> bool:
+    """The 1.18.33 dialog, drawn inside the box.
+
+    The row is ``┃  △ Permission required``. The mode row and the ``╹▀``
+    border are gone on that screen, so this row is the whole signal.
+    """
+    s = line.strip()
+    return s.startswith("┃") and "△" in s and "Permission required" in s
+
+
+def _is_opencode_pane(lines: list[str]) -> bool:
+    """The opencode composer box, measured on 1.18.33.
+
+    The input row is a ``┃`` line. The mode row under it names Build or
+    Plan and a ``·``. The bottom of the box is ``╹▀``. The permission
+    dialog keeps the ``┃`` row and drops the mode row and the border.
+    Cursor and claude do not draw any of these.
+    """
+    for ln in lines:
+        s = ln.strip()
+        if s.startswith("╹▀") or _opencode_mode_row(ln) or _opencode_permission_row(ln):
+            return True
+    return False
+
+
+def _opencode_running(lines: list[str]) -> bool:
+    """True only while a turn is in progress.
+
+    The footer shows ``esc interrupt``, and the ▣ header has no trailing
+    duration. A finished turn keeps the ▣ header and adds ``· <n>s``,
+    with no interrupt hint. That pane is idle. The permission dialog is
+    not a turn; it has its own branch.
+    """
+    if any("esc interrupt" in ln for ln in lines):
+        return True
+    for ln in lines:
+        s = ln.strip()
+        if s.startswith("▣") and not _OPENCODE_DONE.search(s):
+            return True
+    return False
+
+
+def _opencode_turn_finished(lines: list[str]) -> bool:
+    """The ▣ header carried a duration and the interrupt hint is gone."""
+    if _opencode_running(lines):
+        return False
+    return any(
+        ln.strip().startswith("▣") and _OPENCODE_DONE.search(ln.strip())
+        for ln in lines
+    )
+
+
+def _opencode_in_progress(target: str) -> bool:
+    """In-progress opencode turn. A deferral here keeps wake_outstanding."""
+    lines = _capture_pane_lines(target)
+    if not lines or not _is_opencode_pane(lines):
+        return False
+    return _opencode_running(lines)
+
+
+def _opencode_turn_finished_target(target: str) -> bool:
+    lines = _capture_pane_lines(target)
+    if not lines or not _is_opencode_pane(lines):
+        return False
+    return _opencode_turn_finished(lines)
+
+
+def _opencode_row_text(line: str) -> str:
+    """Text on one ``┃`` row, with a right-aligned footer cut off.
+
+    A long cwd:branch is drawn inside the box, right-aligned, and wraps
+    across as many rows as the path needs. The gap before that footer is
+    a run of 4 or more spaces. Composer text is the left side of the row.
+    Leading spaces stay in place for the split, then the left side is
+    stripped. Skipping a fixed number of rows cannot work: the row count
+    is the path length over the box width.
+    """
+    idx = line.find("┃")
+    if idx < 0:
+        return ""
+    return re.split(r" {4,}", line[idx + 1:], maxsplit=1)[0].strip()
+
+
+def _opencode_input(lines: list[str]) -> Optional[str]:
+    """Composer text inside the box, '' when that box is empty, None if no box.
+
+    Walk up from the mode row. Each ``┃`` row contributes only the text
+    before its footer gap. The walk stops at the first line that is not a
+    ``┃`` row — the top of the box — so a transcript ``┃`` row above the
+    box is never composer text.
+    """
+    mode_at = None
+    for i, ln in enumerate(lines):
+        if _opencode_mode_row(ln):
+            mode_at = i
+    if mode_at is None:
+        return None
+    for ln in reversed(lines[:mode_at]):
+        if not ln.strip().startswith("┃"):
+            return ""
+        text = _opencode_row_text(ln)
+        if text:
+            return text
+    return ""
+
+
+def _opencode_composer_state(lines: list[str]) -> Optional[str]:
+    if any(_opencode_permission_row(ln) for ln in lines):
+        return "busy"
+    text = _opencode_input(lines)
+    if text is None:
+        return None
+    if not text or text.startswith("Ask anything"):
+        return "clear"
+    if _only_wake_text(text):
+        return "wake"
+    return "busy"
+
+
 def _agent_running(target: str) -> Optional[bool]:
-    """True if the pane's composer row carries cursor's run-state hint.
-
-    The #619 deferral signal: a keystroke into a RUNNING TUI lands in the
-    follow-up queue, and the queue is input-gated (measured live 2026-08-26,
-    twice: queued wakes fired only when the human next typed — 10:00 and
-    10:09Z). On an unattended cell a queued wake never fires, so no wake
-    keystroke may be sent while this returns True. None = pane or composer
-    unreadable; callers treat unknown as NOT-running (the composer state was
-    already established by then — this guard only vets the timing).
+    """True while a keystroke would miss the idle composer.
+
+    Cursor: the composer row carries 'ctrl+c to stop' (measured live on
+    cursor-lin 2026-08-24). A keystroke into that TUI lands in the
+    follow-up queue, and the queue is input-gated (measured live
+    2026-08-26, twice: queued wakes fired only when the human next typed).
+    Opencode: ``esc interrupt`` or a ▣ header with no trailing duration.
+    A finished ``· <n>s`` header is idle. None =
+    pane or composer unreadable; callers treat unknown as NOT-running
+    (the composer state was already established by then — this guard
+    only vets the timing).
     """
     lines = _capture_pane_lines(target)
     if lines is None:
         return None
+    if _is_opencode_pane(lines):
+        return _opencode_running(lines)
     composer = _composer_line(lines)
     if composer is None:
         return None
@@ -2112,6 +2289,8 @@ def _composer_state(target: str) -> Optional[str]:
     lines = _capture_pane_lines(target)
     if lines is None:
         return None
+    if _is_opencode_pane(lines):
+        return _opencode_composer_state(lines)
     composer = _composer_line(lines)
     if composer is None:
         return None
@@ -2126,7 +2305,7 @@ def _composer_state(target: str) -> Optional[str]:
     # 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() == "":
+    if _only_wake_text(content):
         return "wake"
     return "busy"
 
@@ -2199,8 +2378,11 @@ def _tmux_wake(target: str) -> Optional[bool]:
     wake stays owed and the ledger retries the whole wake later.
     """
     try:
+        seen = _capture_pane_lines(target)
+        prompt = (_OPENCODE_WAKE_PROMPT
+                  if seen and _is_opencode_pane(seen) else _WAKE_PROMPT)
         subprocess.run(
-            ["tmux", "send-keys", "-t", target, "-l", _WAKE_PROMPT],
+            ["tmux", "send-keys", "-t", target, "-l", prompt],
             check=True,
             stdout=subprocess.DEVNULL,
             stderr=subprocess.PIPE,
@@ -2234,6 +2416,10 @@ def _tmux_wake(target: str) -> Optional[bool]:
                 # sink DEFER, keeping the cursor back so a later poll
                 # retries the wake when the composer clears.
                 return None
+            # "wake" while a turn is already on screen: another Enter stacks
+            # a follow-up. Defer; the sink does not advance.
+            if _agent_running(target):
+                return None
             # "wake": still sitting unsubmitted — loop another Enter.
         print(
             f"[monitor] tmux wake still unsubmitted after "

{swarph_cli-0.69.0 → swarph_cli-0.69.2/src/swarph_cli.egg-info}/PKG-INFO

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

@@ -60,6 +60,7 @@ def test_tmux_wake_sends_literal_prompt_then_submits_and_verifies(monkeypatch):
     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", "capture-pane", "-p", "-t", "gpt-lc:0.0"],
         ["tmux", "send-keys", "-t", "gpt-lc:0.0", "-l", "check mesh"],
         ["tmux", "send-keys", "-t", "gpt-lc:0.0", "Enter"],
     ]

{swarph_cli-0.69.0 → swarph_cli-0.69.2}/tests/test_tmux_wake_runstate_defer.py

@@ -44,6 +44,8 @@ def _rig(monkeypatch, *, composer="clear", unread=3, session_created=None,
     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(mesh, "_opencode_in_progress", lambda t: False)
+    monkeypatch.setattr(mesh, "_opencode_turn_finished_target", lambda t: False)
     monkeypatch.setattr(watchdog, "_gateway_unread_count",
                         lambda *a, **k: unread)
 

{swarph_cli-0.69.0 → swarph_cli-0.69.2}/tests/test_tmux_wake_submit_verify.py

@@ -53,7 +53,9 @@ def test_second_enter_fires_only_when_the_first_did_not_submit(tmux):
     """The Codex shape, now verified instead of blind: first Enter leaves the
     prompt in the composer, second clears it."""
     calls, state = tmux
-    state["captures"] = ["> check mesh", "> "]
+    # First frame is the pre-inject look (prompt choice). The pending frame
+    # is what the first Enter left behind.
+    state["captures"] = ["> ", "> check mesh", "> "]
     assert mesh._tmux_wake("pane") is True
     assert enters(calls) == 2
 
@@ -62,7 +64,7 @@ def test_concatenated_backlog_is_detected_and_drained(tmux):
     """The observed defect shape: two wakes stacked unsubmitted. The substring
     check catches the concatenation and the retry Enter drains it."""
     calls, state = tmux
-    state["captures"] = ["> check meshcheck mesh", "> "]
+    state["captures"] = ["> ", "> check meshcheck mesh", "> "]
     assert mesh._tmux_wake("pane") is True
     assert enters(calls) == 2
 
@@ -101,7 +103,7 @@ def test_capture_failure_mid_loop_stops_the_loop(tmux, monkeypatch):
     state["captures"] = ["> check mesh"]  # first capture: still pending
 
     def flaky(argv, **kw):
-        if argv[1] == "capture-pane" and state["i"] > 0:
+        if argv[1] == "capture-pane" and state["i"] > 1:
             raise OSError("tmux socket vanished")
         if argv[1] == "capture-pane":
             i = min(state["i"], len(state["captures"]) - 1)
@@ -161,7 +163,7 @@ def test_codex_composer_marker_counts_as_recognizable(tmux):
 
 def test_cursor_composer_holding_the_wake_is_pending(tmux):
     calls, state = tmux
-    state["captures"] = ["→ check mesh", "→ Add a follow-up"]
+    state["captures"] = ["→ Add a follow-up", "→ check mesh", "→ Add a follow-up"]
     assert mesh._tmux_wake("pane") is True
     assert enters(calls) == 2
 
@@ -199,6 +201,8 @@ def gate(monkeypatch):
                         lambda t: calls.__setitem__("enter", calls["enter"] + 1) or True)
     monkeypatch.setattr(mesh, "_wake_still_pending", lambda t: box["pending"])
     monkeypatch.setattr(mesh, "_composer_state", lambda t: box["composer"])
+    monkeypatch.setattr(mesh, "_opencode_in_progress", lambda t: False)
+    monkeypatch.setattr(mesh, "_opencode_turn_finished_target", lambda t: False)
     import swarph_cli.commands.watchdog as wd
     monkeypatch.setattr(wd, "_gateway_unread_count",
                         lambda g, p, t: box["unread"])
@@ -540,3 +544,272 @@ def test_engine_defers_on_adopted_mid_settle_with_real_tmux_sink(tmp_path, tmux,
     out = capsys.readouterr()
     assert "DEFERRED" in out.out
     assert "DELIVERY FAILED" not in out.err
+
+
+# ── opencode 1.18.33, measured on a sacrificial pane (card #961) ──────────
+#
+# The composer is a ┃ box, not a > / › / → line. A ▣ spinner sits between
+# the transcript and the box; lines above it are history. `esc interrupt`
+# and `Permission required` mean a keystroke is the wrong key.
+
+_OPENCODE_IDLE = """\
+┃
+┃  Ask anything… "What is the tech stack of this project?"
+┃
+┃  Build · DeepSeek V4 Pro (New) OpenCode Go
+╹▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
+  tab agents
+  ctrl+p commands
+"""
+
+_OPENCODE_HOLDING = """\
+┃
+┃  check mesh: swarph_dm_unread
+┃
+┃  Build · DeepSeek V4 Pro (New) OpenCode Go
+╹▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
+"""
+
+_OPENCODE_RUNNING = """\
+┃  check mesh: swarph_dm_unread
+┃  Click to expand
+▣  Build · DeepSeek V4 Pro (New)
+┃
+┃
+┃  Build · DeepSeek V4 Pro (New) OpenCode Go
+  esc interrupt
+"""
+
+# 1.18.33 draws the dialog inside the box. The mode row and the bottom
+# border are not on this screen (drop-on-meta-edge, card #961 post 54557).
+_OPENCODE_PERMISSION = """\
+┃
+┃  △ Permission required
+┃
+  Allow once
+  Allow always
+  Reject
+"""
+
+_OPENCODE_FINISHED = """\
+▣  Build · DeepSeek V4 Pro (New) · 3.3s
+┃
+┃  Ask anything… "What is the tech stack of this project?"
+┃
+┃  Build · DeepSeek V4 Pro (New) OpenCode Go
+╹▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
+  tab agents  ctrl+p commands
+"""
+
+
+def test_live_idle_footer_is_clear_and_not_running(tmux):
+    """The 07:10Z pane: composer empty, transcript full of ┃ rows, footer
+    cwd on the ┃ row above the mode row, finished header `· 3m 4s`.
+    0.69.1 returns that path as composer text and treats the header as
+    still running."""
+    from pathlib import Path
+    fixture = (Path(__file__).resolve().parent / "fixtures"
+               / "opencode-pane-idle-footer-0710.txt")
+    text = fixture.read_text(encoding="utf-8")
+    lines = text.splitlines()
+    assert any("Found the real blocker" in ln and ln.strip().startswith("┃")
+               for ln in lines)
+    _calls, state = tmux
+    state["captures"] = [text]
+    assert mesh._opencode_input(lines) == ""
+    assert mesh._composer_state("sac") == "clear"
+    assert mesh._agent_running("sac") is False
+
+
+def test_drop_six_captures_split_the_footer():
+    """A wrapped cwd is a run of spaces, not a fixed number of rows.
+    Measured by drop-on-meta-edge on sacW 220x55 (card #961, #612)."""
+    from pathlib import Path
+    fix = Path(__file__).resolve().parent / "fixtures"
+    wide = (fix / "opencode-961" / "W2_turn2.txt").read_text(encoding="utf-8")
+    narrow = (fix / "opencode-961" / "G3_turn2.txt").read_text(encoding="utf-8")
+    live = (fix / "opencode-pane-idle-footer-0710.txt").read_text(encoding="utf-8")
+    assert mesh._opencode_input(wide.splitlines()) == ""
+    assert mesh._opencode_input(live.splitlines()) == ""
+    assert mesh._opencode_input(narrow.splitlines()) == ""
+    typed_narrow = "\n".join([
+        "                       ┃",
+        "                       ┃  hello from a human",
+        "                       ┃",
+        "                       ┃  Build · DeepSeek V4 Pro (New) OpenCode Go",
+    ])
+    assert mesh._opencode_input(typed_narrow.splitlines()) == "hello from a human"
+    overlay = (
+        "  ┃  hello from a human" + (" " * 150)
+        + "meta-edge/d7cba227-9da7-4d92-92da-"
+    )
+    typed_wide = "\n".join([
+        "  ┃",
+        overlay,
+        "  ┃  Build · DeepSeek V4 Pro (New) OpenCode Go" + (" " * 40)
+        + "feat/sacrificial-612",
+    ])
+    assert mesh._opencode_input(typed_wide.splitlines()) == "hello from a human"
+    holding = "\n".join([
+        "┃",
+        "┃  check mesh: swarph_dm_unread",
+        "┃",
+        "┃  Build · DeepSeek V4 Pro (New) OpenCode Go",
+    ])
+    assert mesh._opencode_input(holding.splitlines()) == "check mesh: swarph_dm_unread"
+    # A wide pane keeps the sidebar on the ▣ row, past the duration.
+    sidebar = "▣  Build · DeepSeek V4.1 Flash · 5.1s" + (" " * 40) + "LSPs are disabled"
+    assert mesh._OPENCODE_DONE.search(sidebar)
+    assert mesh._opencode_running([sidebar]) is False
+    assert mesh._opencode_running(["▣  Build · DeepSeek V4 Pro (New)"]) is True
+
+
+def test_wide_empty_box_records_the_wake_outstanding(tmux):
+    """W-D1: the footer showed up after Enter and the old read called the
+    box busy, so the injected wake was reported as a human's line and
+    wake_outstanding stayed unset."""
+    from pathlib import Path
+    wide = (Path(__file__).resolve().parent / "fixtures" / "opencode-961"
+            / "W2_turn2.txt").read_text(encoding="utf-8")
+    calls, state = tmux
+    state["captures"] = [wide]
+    st = _State()
+    assert mesh.TmuxSink("sacW").deliver(st, [], 1) is True
+    assert st.ledger("x")["wake_outstanding"] is True
+    literals = [c for c in calls if "-l" in c]
+    assert literals == [[
+        "tmux", "send-keys", "-t", "sacW", "-l", mesh._OPENCODE_WAKE_PROMPT]]
+    assert enters(calls) == 1
+
+
+def test_opencode_idle_box_is_a_clear_composer(tmux):
+    calls, state = tmux
+    state["captures"] = [_OPENCODE_IDLE]
+    assert mesh._composer_state("sac") == "clear"
+    assert mesh._agent_running("sac") is False
+    # `--auto` rewrites the mode row to "Build auto ·" (1.18.33).
+    state["captures"] = [_OPENCODE_IDLE.replace("Build ·", "Build auto ·")]
+    state["i"] = 0
+    assert mesh._composer_state("sac") == "clear"
+
+
+def test_opencode_unsubmitted_pointer_is_wake_not_unknown(tmux):
+    """Main reads this pane as no composer at all, so the sink fails closed
+    and the text stays typed. The box is a composer, and this line is wake."""
+    calls, state = tmux
+    state["captures"] = [_OPENCODE_HOLDING]
+    assert mesh._composer_state("sac") == "wake"
+
+
+def test_opencode_human_text_in_the_box_is_busy(tmux):
+    calls, state = tmux
+    state["captures"] = [_OPENCODE_HOLDING.replace(
+        "check mesh: swarph_dm_unread", "look at the diff")]
+    assert mesh._composer_state("sac") == "busy"
+
+
+def test_opencode_transcript_above_the_spinner_is_not_the_composer(tmux):
+    """The submitted prompt stays on screen above ▣. Reading it as the
+    composer would send another Enter into the running turn."""
+    calls, state = tmux
+    state["captures"] = [_OPENCODE_RUNNING]
+    assert mesh._composer_state("sac") == "clear"
+    assert mesh._agent_running("sac") is True
+
+
+def test_opencode_permission_modal_is_not_typed_into(tmux):
+    """The dialog is a ┃ row. deliver returns None from the busy branch.
+    False would be the unrecognised-pane fallthrough, which also sends no
+    keys and is the wrong outcome."""
+    calls, state = tmux
+    assert "┃  △ Permission required" in _OPENCODE_PERMISSION
+    assert "╹▀" not in _OPENCODE_PERMISSION
+    assert "Build ·" not in _OPENCODE_PERMISSION
+    state["captures"] = [_OPENCODE_PERMISSION]
+    assert mesh._composer_state("sac") == "busy"
+    sink = mesh.TmuxSink("sac")
+    assert sink.deliver(_State(), [], 1) is None
+    assert enters(calls) == 0
+    assert not any("-l" in c for c in calls)
+
+
+def test_opencode_finished_header_is_not_a_running_turn(tmux):
+    calls, state = tmux
+    state["captures"] = [_OPENCODE_FINISHED]
+    assert mesh._agent_running("sac") is False
+    assert mesh._opencode_turn_finished_target("sac") is True
+    assert mesh._composer_state("sac") == "clear"
+
+
+def test_opencode_deferral_keeps_wake_outstanding(tmux):
+    calls, state = tmux
+    state["captures"] = [_OPENCODE_RUNNING]
+    st = _State()
+    st.ledger("x")["wake_outstanding"] = True
+    assert mesh.TmuxSink("sac").deliver(st, [], 2) is None
+    assert st.ledger("x")["wake_outstanding"] is True
+    assert enters(calls) == 0
+    assert not any("-l" in c for c in calls)
+
+
+def test_opencode_finished_turn_earns_another_wake(tmux, monkeypatch):
+    """Inside the trust window a standing wake would report delivery with
+    no keystroke. A finished header means the cell is idle again."""
+    import time
+    import swarph_cli.commands.watchdog as wd
+    monkeypatch.setattr(wd, "_gateway_unread_count", lambda *a, **k: 1)
+    calls, state = tmux
+    state["captures"] = [_OPENCODE_FINISHED]
+    st = _State()
+    st.ledger("x")["wake_outstanding"] = True
+    st.ledger("x")["last_wake_injected_at"] = time.time()
+    assert mesh.TmuxSink("sac").deliver(st, [], 3) is True
+    literals = [c for c in calls if "-l" in c]
+    assert literals == [[
+        "tmux", "send-keys", "-t", "sac", "-l", mesh._OPENCODE_WAKE_PROMPT]]
+    assert enters(calls) == 1
+    assert st.ledger("x")["wake_outstanding"] is True
+
+
+def test_opencode_running_turn_gets_no_second_prompt(tmux):
+    calls, state = tmux
+    state["captures"] = [_OPENCODE_RUNNING]
+    sink = mesh.TmuxSink("sac")
+    assert sink.deliver(_State(), [], 1) is None
+    assert enters(calls) == 0
+    assert not any("-l" in c for c in calls)
+
+
+def test_opencode_idle_injects_the_pointer_then_one_enter(tmux):
+    calls, state = tmux
+    state["captures"] = [_OPENCODE_IDLE, _OPENCODE_RUNNING]
+    assert mesh._tmux_wake("sac") is True
+    literals = [c for c in calls if "-l" in c]
+    assert literals == [[
+        "tmux", "send-keys", "-t", "sac", "-l", mesh._OPENCODE_WAKE_PROMPT]]
+    assert enters(calls) == 1
+
+
+def test_opencode_holding_wake_is_nudged_not_retyped(tmux):
+    calls, state = tmux
+    state["captures"] = [_OPENCODE_HOLDING]
+    sink = mesh.TmuxSink("sac")
+    assert sink.deliver(_State(), [], 1) is True
+    assert enters(calls) == 1
+    assert not any("-l" in c for c in calls)
+
+
+def test_opencode_dropin_names_the_tmux_sink_and_is_not_the_template():
+    """install-unit renders swarph-monitor@.service only. This file is the
+    review copy of the opencode drop-in; nothing in this test installs it."""
+    from pathlib import Path
+    root = Path(__file__).resolve().parents[1]
+    dropin = root / "deploy" / "monitor" / "swarph-monitor@opencode.conf"
+    text = dropin.read_text(encoding="utf-8")
+    assert "ExecStart=" in text
+    assert "--deliver tmux:opencode" in text
+    assert "--deliver pull" in text
+    assert "--as opencode" in text
+    template = (root / "src" / "swarph_cli" / "systemd"
+                / "swarph-monitor@.service").read_text(encoding="utf-8")
+    assert "tmux:opencode" not in template