swarph-cli 0.72.28__tar.gz → 0.72.29__tar.gz

{swarph_cli-0.72.28/src/swarph_cli.egg-info → swarph_cli-0.72.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.28
+Version: 0.72.29
 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
@@ -179,7 +179,7 @@ The mesh **board** — the projects + cards kanban the mesh coordinates on — a
 ```
 swarph board projects list
 swarph board projects add <slug> --title "…" [--goal "…"]
-swarph board cards list [--project <id|slug>] [--stage <s>] [--assignee <who>]
+swarph board cards list [--project <id|slug>] [--stage <s>] [--assignee <who>] [--search <text>]   # --search: title OR body, says how many cards it searched
 swarph board cards show <id>
 swarph board cards add --project <id|slug> --title "…" [--body "…"] [--ai2] [--priority N]
 swarph board cards edit <id> [--title "…"] [--body "…"] [--project <id|slug>] [--priority N]

{swarph_cli-0.72.28 → swarph_cli-0.72.29}/README.md

@@ -130,7 +130,7 @@ The mesh **board** — the projects + cards kanban the mesh coordinates on — a
 ```
 swarph board projects list
 swarph board projects add <slug> --title "…" [--goal "…"]
-swarph board cards list [--project <id|slug>] [--stage <s>] [--assignee <who>]
+swarph board cards list [--project <id|slug>] [--stage <s>] [--assignee <who>] [--search <text>]   # --search: title OR body, says how many cards it searched
 swarph board cards show <id>
 swarph board cards add --project <id|slug> --title "…" [--body "…"] [--ai2] [--priority N]
 swarph board cards edit <id> [--title "…"] [--body "…"] [--project <id|slug>] [--priority N]

{swarph_cli-0.72.28 → swarph_cli-0.72.29}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.72.28"
+version = "0.72.29"
 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" }
@@ -173,3 +173,6 @@ testpaths = ["tests"]
 # nearly identical. That agreement is a polluted baseline, not isolation.
 pythonpath = ["src"]
 addopts = "-v --tb=short"
+markers = [
+    "live_tmux: drives a real tmux server/pane; opt-in, and the test must state its reason (card #1034)",
+]

{swarph_cli-0.72.28 → swarph_cli-0.72.29}/src/swarph_cli/__init__.py

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

{swarph_cli-0.72.28 → swarph_cli-0.72.29}/src/swarph_cli/bench/claude_cli.py

@@ -23,9 +23,12 @@ class CliResult:
 
 
 def build_argv(model_id: str, system: str) -> list:
+    # Card #1090: one token each. --mcp-config is variadic, so a following
+    # JSON token is consumed only while the token after that is a flag.
     return ["claude", "-p", "--model", model_id, "--system-prompt", system, "--max-turns", "1",
-            "--output-format", "stream-json", "--verbose", "--strict-mcp-config",
-            "--mcp-config", '{"mcpServers":{}}', "--tools", "", "--setting-sources", ""]
+            "--output-format", "stream-json", "--verbose",
+            "--tools=", "--strict-mcp-config",
+            '--mcp-config={"mcpServers":{}}', "--setting-sources="]
 
 
 def clean_env(env: dict) -> dict:

{swarph_cli-0.72.28 → swarph_cli-0.72.29}/src/swarph_cli/commands/board.py

@@ -71,9 +71,11 @@ def _patch_json(url: str, body: dict, token: str, *, timeout: float = 10.0) -> t
 # ── pure builders (unit-tested) ───────────────────────────────────────────────
 
 def _cards_list_url(gateway: str, *, project=None, stage=None, assignee=None,
-                    label=None) -> str:
+                    label=None, search=None) -> str:
     q = {k: v for k, v in (("project", project), ("stage", stage),
                            ("assignee", assignee), ("label", label)) if v}
+    if search is not None:  # blank still goes: the gateway refuses it, we do not drop it
+        q["q"] = search
     base = f"{gateway.rstrip('/')}/board/cards"
     return f"{base}?{urllib.parse.urlencode(q)}" if q else base
 
@@ -353,6 +355,10 @@ def _format_due_head(data) -> list[str]:
 def _format_cards(data) -> str:
     head = _format_due_head(data)
     rows = _cards_of(data)
+    if isinstance(data, dict) and "searched" in data:
+        # #931: a zero must say how many cards it looked at.
+        head = [f"searched {data['searched']} cards: {len(rows)} match"] + (
+            [""] + head if head else [])
     if not rows:
         body = ["(no cards)"]
     else:
@@ -604,14 +610,49 @@ def _thread_line(d) -> str:
             f"(#509/#562 — the VERB is the mechanism, the thread is where it lands)")
 
 
+def _hours_token(n) -> str:
+    if isinstance(n, float) and n.is_integer():
+        n = int(n)
+    return str(n)
+
+
+def _clock_line(d) -> str | None:
+    """The due-date clock (#935). It starts when the row is taken, not now.
+
+    `clock_hours` is the menu step's hours, or the `--hours` override.
+    `timeout_at` is a different clock — when the row reads OVERDUE — and
+    is not this line. Absent fields mean an older gateway; the caller
+    keeps its previous sentence rather than inventing a clock.
+    """
+    hours = d.get("clock_hours")
+    if hours is None:
+        return None
+    source = d.get("clock_source") or "menu"
+    menu = d.get("menu_hours")
+    if (source == "override" and isinstance(menu, (int, float))
+            and not isinstance(menu, bool) and menu
+            and isinstance(hours, (int, float)) and not isinstance(hours, bool)):
+        if hours % menu == 0:
+            detail = f"override, {int(hours // menu)}x menu {_hours_token(menu)}h"
+        else:
+            detail = f"override, menu {_hours_token(menu)}h"
+    else:
+        detail = str(source)
+    return f"clock: {_hours_token(hours)}h ({detail}) — STARTS ON TAKE, not now"
+
+
 def _format_ask(d) -> str:
-    """One line naming the obligation, its holder, and when it goes red.
+    """Name the obligation, who owes it, and the deadline clock.
 
     >>> NAMING THE DEADLINE OR ITS ABSENCE IS THE POINT, NOT DECORATION. <<< #145's
     lesson, one layer over: "0 overdue" must not be able to mean "nobody set dates".
-    An obligation with no timeout never goes red on its own, and the operator has to
-    be told that AT THE MOMENT THEY CREATE IT — afterwards it looks identical to one
-    that simply is not late yet.
+    The deadline is the due-date clock (`clock_hours`): the menu step's hours,
+    or the `--hours` override, and it STARTS ON TAKE, not at mint (#935).
+    `timeout_at` is the other clock — when the row READS OVERDUE — and is
+    printed under that name, never as the deadline. A response that carries
+    neither clock says NO TIMEOUT, because an obligation with no timeout never
+    goes red on its own and the operator has to be told that AT THE MOMENT
+    THEY CREATE IT.
 
     #532 applies the same rule to the falsifier: an obligation with no accept
     check reads RED in the sweep, and one whose check has no FAIL branch is
@@ -619,9 +660,17 @@ def _format_ask(d) -> str:
     rows look identical to sound ones.
     """
     when = d.get("timeout_at")
-    deadline = f"overdue after {when}" if when else _NO_TIMEOUT
-    return (f"obligation #{d.get('id')} on card #{d.get('card_id')}: "
-            f"{d.get('holder')} owes it, status={d.get('status')}, {deadline}\n"
+    clock = _clock_line(d)
+    head = (f"obligation #{d.get('id')} on card #{d.get('card_id')}: "
+            f"{d.get('holder')} owes it, status={d.get('status')}")
+    if clock:
+        extra = f"\n  {clock}"
+        extra += f"\n  overdue after {when}" if when else f"\n  {_NO_TIMEOUT}"
+    else:
+        deadline = f"overdue after {when}" if when else _NO_TIMEOUT
+        head = f"{head}, {deadline}"
+        extra = ""
+    return (f"{head}{extra}\n"
             f"  {_accept_line(d.get('accept'))}\n"
             f"  {_thread_line(d)}")
 
@@ -763,6 +812,13 @@ def _ask_line(d) -> str:
         if missing:
             line += f" · still missing: {missing}"
     if not str(state).startswith("closed"):
+        clock = _clock_line(d)
+        if clock:
+            # #935: the due-date clock, then the overdue clock under its own name.
+            # A stepped mint used to say neither, so --timeout-hours was read as the due date.
+            line += "\n  " + clock
+            if d.get("timeout_at"):
+                line += "\n  overdue after " + _s(d["timeout_at"])
         line += "\n  " + _accept_line(d.get("accept"))
         if d.get("step") is None:
             # unstepped: no menu clock, no container — the pre-#591 rules hold
@@ -974,6 +1030,9 @@ def _build_parser() -> argparse.ArgumentParser:
     cl = cards.add_parser("list", help="list cards")
     cl.add_argument("--project"); cl.add_argument("--stage"); cl.add_argument("--assignee")
     cl.add_argument("--label", help="only cards carrying this label (exact match)")
+    cl.add_argument("--search", metavar="TEXT",
+                    help="only cards whose title OR body contains TEXT (case-insensitive, "
+                         "matched by the gateway); prints how many cards were searched")
     cl.add_argument("--json", action="store_true"); _add_common(cl)
     cs = cards.add_parser("show", help="show one card"); cs.add_argument("id", type=int)
     cs.add_argument("--json", action="store_true"); _add_common(cs)
@@ -1034,7 +1093,8 @@ def _build_parser() -> argparse.ArgumentParser:
     ck.add_argument("what", help="what is owed, in one line")
     ck.add_argument("--timeout-hours", type=int, default=None,
                     help="hours until this obligation reads OVERDUE (default: none, "
-                         "which means it never goes red on its own)")
+                         "which means it never goes red on its own). This is not "
+                         "the due-date clock; that is --hours, and it starts on take")
     ck.add_argument("--accept", default=None, metavar='"PASS = ... | FAIL = ..."',
                     help="the falsifiable check that closes this obligation "
                          "(#532). Omitting it mints an obligation that reads RED "
@@ -1057,7 +1117,9 @@ def _build_parser() -> argparse.ArgumentParser:
                     help="explicit edges by step name (added to the menu's); repeatable, "
                          "comma lists and the contract's `+step` spelling all accepted")
     ck.add_argument("--hours", type=int, default=None,
-                    help="clock override, up to 4x the menu value")
+                    help="the due-date clock in hours. Starts on take, not now. "
+                         "Default is the menu step's hours. Up to 4x that value. "
+                         "Not the overdue timeout (--timeout-hours)")
     ck.add_argument("--holder", dest="holder_flag", default=None, metavar="PEER|me",
                     help="who owes it: a peer (offered), `me` (open: a bound self-ask "
                          "is a take), or omit (requested: the eligible set is DM'd)")
@@ -1186,7 +1248,9 @@ def _build_parser() -> argparse.ArgumentParser:
     oa.add_argument("--accept-json", default=None, metavar="'{...}'",
                     help="replace the check with a structured one (#1068); "
                          "mutually exclusive with --accept")
-    oa.add_argument("--hours", type=int, default=None, help="clock override, up to 4x the menu value")
+    oa.add_argument("--hours", type=int, default=None,
+                    help="the due-date clock, starts on take, up to 4x the menu value. "
+                         "Not the overdue timeout")
     oa.add_argument("--needs-add", action="append", dest="needs_add", default=None,
                     metavar="STEP", help="add an edge (repeatable)")
     oa.add_argument("--needs-remove", action="append", dest="needs_remove", default=None,
@@ -1338,7 +1402,15 @@ def run_board(argv: list[str]) -> int:
                 return 1
             st, d = _http_get_json(_cards_list_url(gw, project=pid, stage=args.stage,
                                                    assignee=args.assignee,
-                                                   label=getattr(args, "label", None)), token)
+                                                   label=getattr(args, "label", None),
+                                                   search=args.search), token)
+            if (args.search is not None and st and 200 <= st < 300
+                    and not (isinstance(d, dict) and "searched" in d)):
+                # A gateway older than #931 ignores q and returns EVERY card.
+                print("swarph board: the gateway ignored --search (its reply has no "
+                      "`searched` count), so this list is NOT filtered; refusing to "
+                      "show it as a search result", file=sys.stderr)
+                return 1
             return _out(st, d, _format_cards, aj)
         if args.command == "show":
             st, d = _http_get_json(f"{gw}/board/cards/{args.id}", token)

{swarph_cli-0.72.28 → swarph_cli-0.72.29}/src/swarph_cli/commands/hook_output.py

@@ -5,10 +5,10 @@ Receives Claude Code's hook-input JSON on stdin, discovers the
 applicable cell.yaml, and emits a hook-output JSON to stdout
 containing the starter prompt as ``additionalContext``.
 
-Skipped (no-op) when ``SWARPH_SPAWN=1`` env is set — that environment
-marker is set by ``swarph spawn`` to indicate the spawn path already
-injected the prompt via ``--append-system-prompt``. Avoids
-double-injection when the session was launched through swarph.
+``SWARPH_SPAWN=1`` means ``swarph spawn`` already put the starter on
+``--append-system-prompt``. This hook then emits the ten and only the
+ten, so the starter is not doubled. With no ten to read, that path is
+still a no-op.
 
 Cell discovery:
   1. Cwd-local ``./cell.yaml`` (alpha #891 D3 auto-discovery)
@@ -39,13 +39,14 @@ from swarph_cli.cell import (
     load_cell,
     read_starter_prompt,
 )
+from swarph_cli.the_ten import session_block
 
 
 def _emit_no_op() -> int:
     """Emit empty additionalContext + exit 0.
 
-    Used when there's no cell.yaml to load OR when SWARPH_SPAWN=1 OR
-    on any error path. Hook MUST NOT block session startup.
+    Used when there is nothing to add: no starter and no ten, or
+    ``SWARPH_SPAWN=1`` with no ten. Hook MUST NOT block session startup.
     """
     output = {
         "hookSpecificOutput": {
@@ -77,12 +78,34 @@ def _discover_cell_path() -> Path | None:
     return None
 
 
-def run_hook_output(argv: list[str] | None = None) -> int:
-    # Skip when launched-via-swarph-spawn (already injected via
-    # --append-system-prompt; double-injection would duplicate context).
-    if os.environ.get("SWARPH_SPAWN", "").strip() == "1":
-        return _emit_no_op()
+def _emit(additional: str) -> int:
+    output: dict[str, Any] = {
+        "hookSpecificOutput": {
+            "hookEventName": "SessionStart",
+            "additionalContext": additional,
+        }
+    }
+    print(json.dumps(output))
+    return 0
+
 
+def _starter_text() -> str:
+    """The cell's starter prompt, or ``""`` when there is nothing to add.
+
+    A missing cell, a malformed cell, or an unreadable starter is an
+    empty starter. The hook still emits the ten when that block exists.
+    """
+    cell_path = _discover_cell_path()
+    if cell_path is None:
+        return ""
+    try:
+        cell = load_cell(cell_path)
+        return read_starter_prompt(cell) or ""
+    except CellError:
+        return ""
+
+
+def run_hook_output(argv: list[str] | None = None) -> int:
     # Drain hook-input from stdin (we don't actually use any field
     # currently, but Claude Code's protocol expects us to consume it
     # without blocking on TTY-detection edge cases).
@@ -92,32 +115,17 @@ def run_hook_output(argv: list[str] | None = None) -> int:
     except Exception:
         pass  # swallow stdin-read errors; hook output is the only thing that matters
 
-    cell_path = _discover_cell_path()
-    if cell_path is None:
-        return _emit_no_op()
-
-    try:
-        cell = load_cell(cell_path)
-    except CellError:
-        # cell.yaml exists but is malformed — emit no-op + skip rather
-        # than blocking session startup. Operator can fix cell.yaml
-        # offline; meanwhile sessions still start.
-        return _emit_no_op()
+    # Commit-addressed. Empty when the repo or the ref is missing, and
+    # that emptiness must not change the starter-only behaviour.
+    block = session_block()
 
-    try:
-        starter = read_starter_prompt(cell)
-    except CellError:
-        # starter_prompt_path set but unreadable — emit no-op.
-        return _emit_no_op()
+    # SWARPH_SPAWN=1 means the starter is already on --append-system-prompt.
+    # The ten is not part of that flag, so this path still emits the block
+    # and only the block.
+    if os.environ.get("SWARPH_SPAWN", "").strip() == "1":
+        return _emit(block) if block else _emit_no_op()
 
-    if not starter:
+    parts = [part for part in (_starter_text(), block) if part]
+    if not parts:
         return _emit_no_op()
-
-    output: dict[str, Any] = {
-        "hookSpecificOutput": {
-            "hookEventName": "SessionStart",
-            "additionalContext": starter,
-        }
-    }
-    print(json.dumps(output))
-    return 0
+    return _emit("\n\n".join(parts))

{swarph_cli-0.72.28 → swarph_cli-0.72.29}/src/swarph_cli/commands/lane.py

@@ -111,7 +111,22 @@ def _run_create(args: argparse.Namespace) -> int:
     status, payload = post_json(f"{base}/lanes", body, token)
     if not _ok(status):
         return _fail("create", status, payload)
-    print(f"created lane {args.name}")
+    # Card #949. The gateway persists the row at n=0 and starts workers only
+    # in scale_lane. Sending n on create is not enough on a server that
+    # ignores it, and a bare "created" line reads as if the workers exist.
+    # When the operator asked for workers, scale and report both results.
+    # n=0 stays a create, and the line says so.
+    if args.n and args.n > 0:
+        name = urllib.parse.quote(args.name, safe="")
+        scale_status, scale_payload = post_json(
+            f"{base}/lanes/{name}/scale", {"n": args.n}, token)
+        print(f"created lane {args.name}")
+        if not _ok(scale_status):
+            return _fail("scale", scale_status, scale_payload)
+        got = scale_payload.get("n", args.n) if isinstance(scale_payload, dict) else args.n
+        print(f"scaled {args.name} -> {got}")
+        return 0
+    print(f"created lane {args.name} n=0; run lane scale")
     return 0
 
 

{swarph_cli-0.72.28 → swarph_cli-0.72.29}/src/swarph_cli/commands/mesh.py

@@ -1511,6 +1511,15 @@ class TmuxSink(Sink):
                 print(f"[monitor] {self.name}: {reason} — deferring, zero keys",
                       flush=True)
                 return None
+        # #1034: a pane in copy-mode (or view-mode) swallows the wake keys --
+        # tmux runs them as copy-mode commands, the TUI never sees them, and the
+        # capture still reads idle. Ask tmux, not the screen; if in a mode, send
+        # nothing and keep the DM owed (the same owed-state #1010/#1126 use).
+        if _pane_in_mode(self.target):
+            self.deferred_reason = "pane in copy-mode"
+            print(f"[monitor] {self.name}: pane in copy-mode — deferring, zero keys",
+                  flush=True)
+            return None
         # #620: a wake's job is done the moment a TURN is observed running —
         # the cell is awake, whoever woke it (our injected wake fired, or
         # the human typed). Both older clearing paths miss the zombie
@@ -2589,6 +2598,16 @@ def _opencode_turn_finished(lines: list[str]) -> bool:
 # when the same pane is seen unchanged on a later poll at least this
 # many seconds later (the monitor polls each minute, so about 2 polls).
 _MAYBE_START_GRACE_S = 60
+# Card #1222: the grace above is reset every time the footer CHANGES ("a
+# progressing turn rewrites this region every poll"), which is right for a
+# booting turn — but a pane whose footer churns FOREVER (a recreated session
+# showing a bare header — the 2026-10-18 opencode deafness) re-arms first_seen
+# on every poll and NEVER matures to idle. wake_outstanding then stands
+# indefinitely: 8h of deafness, three offers never woke the cell. This ABSOLUTE
+# cap is anchored to the FIRST sighting of maybe-starting and is NOT reset by
+# churn, so a bare header past it reads idle and the wake can re-inject. 600 s
+# matches #616's _WAKE_STALE_S bound.
+_MAYBE_START_MAX_S = 600.0
 
 
 def _opencode_pane_fingerprint(lines: list[str]) -> str:
@@ -2625,19 +2644,39 @@ def _opencode_poll_verdict(lines: list[str], now: float,
     if last is None or _OPENCODE_DONE.search(last):
         return "idle", fingerprint, None
     first_seen = None
+    capped_since = None
     if isinstance(prior, dict):
         seen = prior.get("first_seen")
         if (prior.get("fingerprint") == fingerprint
                 and isinstance(seen, (int, float))
                 and not isinstance(seen, bool)):
             first_seen = float(seen)
+        cap = prior.get("capped_since")
+        if isinstance(cap, (int, float)) and not isinstance(cap, bool):
+            capped_since = float(cap)
+    # Card #1222: the first sighting of maybe-starting is remembered in its own
+    # field so FOOTER CHURN cannot reset the hard cap. A bare header that has
+    # deferred for _MAYBE_START_MAX_S is aborting or idle, never still booting.
+    if capped_since is None:
+        capped_since = first_seen if first_seen is not None else now
+    if now - capped_since >= _MAYBE_START_MAX_S:
+        # Card #1222: past the hard cap the pane is idle, AND the record is KEPT
+        # (non-None) so the caller does not drop the anchor. Dropping it would
+        # make the very next poll a first sight -> maybe-starting again: the
+        # deafness would sawtooth instead of ending.
+        return "idle", fingerprint, {
+            "fingerprint": fingerprint,
+            "first_seen": first_seen if first_seen is not None else now,
+            "capped_since": capped_since}
     if first_seen is None:
         return ("maybe-starting", fingerprint,
-                {"fingerprint": fingerprint, "first_seen": now})
+                {"fingerprint": fingerprint, "first_seen": now,
+                 "capped_since": capped_since})
     if now - first_seen >= _MAYBE_START_GRACE_S:
         return "idle", fingerprint, None
     return ("maybe-starting", fingerprint,
-            {"fingerprint": fingerprint, "first_seen": first_seen})
+            {"fingerprint": fingerprint, "first_seen": first_seen,
+             "capped_since": capped_since})
 
 
 def _opencode_in_progress(target: str, ledger=None, now=None):
@@ -2659,7 +2698,10 @@ def _opencode_in_progress(target: str, ledger=None, now=None):
     moment = time.time() if now is None else now
     verdict, _fingerprint, record = _opencode_poll_verdict(
         lines, moment, ledger.get("opencode_maybe_start"))
-    if verdict == "maybe-starting":
+    # Card #1222: keep the record whenever the verdict returns one. maybe-starting
+    # carries the grace anchor; the cap-‘idle’ carries the anchor too so the cap
+    # stays anchored across polls. running / grace-idle return None and clear it.
+    if record is not None:
         ledger["opencode_maybe_start"] = record
     else:
         ledger.pop("opencode_maybe_start", None)
@@ -3192,6 +3234,28 @@ def _composer_state(target: str) -> Optional[str]:
     return "busy"
 
 
+def _pane_in_mode(target: str) -> bool:
+    """True if the pane is in a tmux MODE (copy-mode / view-mode), card #1034.
+
+    In copy-mode the TUI receives nothing: a keystroke is a copy-mode command,
+    the captured screen still reads idle (it shows the scrolled view), and the
+    monitor would mark the DM delivered while the cell never woke -- "delivered
+    is not submitted" with a new cause. Ask tmux, not the screen:
+    #{pane_in_mode} is 1 in a mode. Unknown (tmux cannot answer) reads as NOT in
+    mode, matching the pre-fix behaviour; the composer gate already fails closed
+    on an unreadable pane.
+    """
+    try:
+        r = subprocess.run(
+            ["tmux", "display-message", "-p", "-t", target, "#{pane_in_mode}"],
+            capture_output=True, timeout=5,
+            text=True, encoding="utf-8", errors="replace",
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+    return r.returncode == 0 and (r.stdout or "").strip() == "1"
+
+
 def _tmux_session_created(target: str) -> Optional[float]:
     """Epoch seconds the target's tmux SESSION was created, or None.
 
@@ -3726,6 +3790,22 @@ def _monitor_iteration(state: MonitorState, *, poll_channels: bool = True) -> No
     _write_cursor_atomic(state.heartbeat_path, {
         "ts": time.time(), "iterations": state.iterations, "pid": os.getpid()})
 
+    # Card #513: detect a SECOND live session under this identity and raise ONE
+    # alarm row. Per-cell, IN the monitor (not the send path). It NEVER kills
+    # anything and never raises out of the loop. Throttled inside.
+    _maybe_duplicate_check(state)
+
+
+def _maybe_duplicate_check(state: MonitorState) -> None:
+    """Card #513. Enumerate at most once every duplicate_session.CHECK_EVERY ticks
+    (the check spawns `ps`), and never on the first tick so an ordinary monitor
+    test drives one clean iteration. duplicate_session.check swallows its own
+    errors, so this can never break delivery. It NEVER kills anything."""
+    from swarph_cli import duplicate_session
+    if state.iterations % duplicate_session.CHECK_EVERY != 0:
+        return
+    duplicate_session.check(state)
+
 
 def _monitor_loop(state: MonitorState) -> int:
     print(

{swarph_cli-0.72.28 → swarph_cli-0.72.29}/src/swarph_cli/commands/roster.py

@@ -297,12 +297,18 @@ def _local_tmux_peers() -> list:
 
 
 def _capture_peer_pane(peer: str):
-    """One read-only full-height capture of the peer's active pane. Never
-    sends keys (ruling 6); None on any failure — the peer reads unknown."""
+    """One read-only capture of the peer's pane, including scrollback.
+
+    Card #1228 F2. `capture-pane -p` alone is the visible screen. A Claude
+    Code /usage stdout display scrolls off it, so the multi-window parser
+    never sees the form it knows. `-S -` starts at the top of history.
+    Never sends keys (ruling 6); None on any failure — the peer reads unknown.
+    """
     try:
-        out = subprocess.run(["tmux", "capture-pane", "-p", "-t", peer],
-                             capture_output=True, timeout=10, text=True,
-                             encoding="utf-8", errors="replace")
+        out = subprocess.run(
+            ["tmux", "capture-pane", "-p", "-S", "-", "-t", peer],
+            capture_output=True, timeout=10, text=True,
+            encoding="utf-8", errors="replace")
     except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
         return None
     if out.returncode != 0:

{swarph_cli-0.72.28 → swarph_cli-0.72.29}/src/swarph_cli/commands/schedule.py

@@ -57,10 +57,11 @@ def _build_parser() -> argparse.ArgumentParser:
     create.add_argument(
         "--deliver",
         choices=["wake", "dm"],
-        default="wake",
-        help="delivery mode: wake (default) types into a host-local tmux pane; "
-             "dm schedules a deferred DM to the target peer — use dm for any "
-             "cell not on lab's box (card #1081)",
+        default="dm",
+        help="delivery mode: dm (default) schedules a deferred DM to the target "
+             "peer and works for any cell; wake types into a host-local tmux pane "
+             "and the gateway refuses it for any cell off lab's box, so pass "
+             "--deliver wake only when you mean it (card #1081)",
     )
     add_common_args(create)
 
@@ -196,11 +197,15 @@ def _run_create(args: argparse.Namespace) -> int:
         body["out_channel"] = args.out_channel
     if args.min_interval is not None:
         body["min_interval_sec"] = args.min_interval
-    if args.deliver == "dm":
-        body["deliver"] = "dm"
+    body["deliver"] = args.deliver
     status, payload = post_json(f"{base}/scheduled-events", body, token)
     if not _ok(status):
-        return _fail("create", status, payload)
+        rc = _fail("create", status, payload)
+        if status == 403 and "operator-gated" in str(payload.get("detail", "")):
+            print("hint: a wake-delivery create is refused as operator-gated for any "
+                  "cell off lab's box. Use `--deliver dm` (the default) to schedule a "
+                  "deferred DM to the target peer instead.", file=sys.stderr)
+        return rc
     print(f"scheduled {args.name}")
     return 0