swarph-cli 0.69.8__tar.gz → 0.70.0__tar.gz

{swarph_cli-0.69.8/src/swarph_cli.egg-info → swarph_cli-0.70.0}/PKG-INFO

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

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

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

{swarph_cli-0.69.8 → swarph_cli-0.70.0}/src/swarph_cli/commands/mesh.py

@@ -2136,6 +2136,33 @@ _COMPOSER_PLACEHOLDERS = ("Add a follow-up", "Ask Codex to do anything")
 #: running agent into an idle one forever.
 _CURSOR_RUN_HINT = "ctrl+c to stop"
 
+#: A live cursor turn draws a braille spinner and then ``Thinking``,
+#: ``Running``, or ``Working`` on the row directly above the Tip/composer
+#: block. A quote of that row anywhere else, including a code echo, is not
+#: a turn. The match is anchored: stripped text has to start with the glyph.
+_CURSOR_SPINNER_ROW = re.compile(
+    r"^[\u2800-\u28FF]+\s*(?:Thinking|Running|Working)\b"
+)
+
+#: How many non-empty rows at the bottom can hold the cursor composer.
+#: Measured on cursor-lin 2026-09-30: the composer is the 4th non-empty row
+#: from the bottom (composer, task count, model footer, tilde). A quote of
+#: that row higher in the pane is scrollback, not the composer. Blank rows
+#: between those chrome lines do not count: a raw tail of N lines drops the
+#: composer off the window when the screen interleaves blanks.
+_CURSOR_COMPOSER_TAIL = 6
+
+#: The 1.18.33 permission dialog draws ``△ Permission required`` above a
+#: stack of option rows. On the measured screen that row is the 10th
+#: non-empty row from the bottom, outside the composer tail.
+_OPENCODE_PERMISSION_TAIL = 12
+
+
+def _nonempty_tail(lines: list[str], n: int) -> list[str]:
+    """The last ``n`` rows that contain text. Blank rows are not rows."""
+    filled = [ln for ln in lines if ln.strip()]
+    return filled[-n:]
+
 
 def _only_wake_text(content: str) -> bool:
     """True when the composer holds wake text and nothing else.
@@ -2172,19 +2199,21 @@ def _opencode_permission_row(line: str) -> bool:
     return s.startswith("┃") and "△" in s and "Permission required" in s
 
 
+def _is_opencode_composer_row(line: str) -> bool:
+    """One row of the opencode box: the mode row, the ``╹▀`` border, or the
+    permission dialog. A quote of ``┃ Build ·`` above the tail is not this."""
+    s = line.strip()
+    return s.startswith("╹▀") or _opencode_mode_row(line) or _opencode_permission_row(line)
+
+
 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.
+    Decided by ``_bottom_tui``: the mode row, the ``╹▀`` border, or the
+    permission dialog has to be the bottom-most composer in the non-empty
+    tail. A cursor pane that merely quotes ``┃ Build ·`` is not opencode.
     """
-    for ln in lines:
-        s = ln.strip()
-        if s.startswith("╹▀") or _opencode_mode_row(ln) or _opencode_permission_row(ln):
-            return True
-    return False
+    return bool(lines) and _bottom_tui(lines) == "opencode"
 
 
 def _opencode_running(lines: list[str]) -> bool:
@@ -2281,29 +2310,115 @@ def _opencode_composer_state(lines: list[str]) -> Optional[str]:
     return "busy"
 
 
-def _is_grok_pane(lines: list[str]) -> bool:
-    """Grok Build composer, measured on sacrificial 1.0.41 and 0.2.51 TUIs.
+def _is_grok_composer_row(lines: list[str], index: int) -> bool:
+    """A grok composer starts at a ``│ ❯`` row. Continuation rows that also
+    start with ``│`` may sit between it and the ``╰`` footer, which is how
+    a wrapped draft is drawn. A cursor diff hunk (``▎``) never counts."""
+    row = lines[index].strip()
+    if row.startswith("▎") or not (row.startswith("│") and "❯" in row):
+        return False
+    j = index + 1
+    while j < len(lines):
+        nxt = lines[j].strip()
+        if nxt.startswith("▎"):
+            return False
+        if nxt.startswith("╰"):
+            return True
+        if nxt.startswith("│"):
+            j += 1
+            continue
+        return False
+    return False
 
-    The footer names ``Grok 4.`` inside the box, or the splash prints
-    ``Grok Build``. History also draws a ``❯`` for the submitted prompt;
-    that row has no box bar, so it is not the composer. A usage-limit
-    modal drops both of those and is recognized by ``_grok_block_reason``.
-    """
-    return any("Grok 4." in ln or ln.strip().startswith("Grok Build") for ln in lines)
 
+def _is_cursor_composer_row(line: str) -> bool:
+    """Any cursor composer row, including a human draft. The empty one
+    reads ``→ Add a follow-up``. A ``▎`` hunk never counts."""
+    row = line.strip()
+    return row.startswith("→") and not row.startswith("▎")
 
-def _grok_input(lines: list[str]) -> Optional[str]:
-    """Text in the live ``│ ❯`` box, '' when empty, None if no box."""
-    row = None
-    for ln in lines:
-        if "❯" in ln and "│" in ln:
-            row = ln
-    if row is None:
+
+def _bottom_tui(lines: list[str]) -> "str | None":
+    """Who owns the bottom-most composer row in the non-empty tail.
+
+    ``"cursor"``, ``"grok"``, or ``"opencode"``. A match above that tail
+    is scrollback. The lower composer wins, so a quoted grok box or a
+    quoted ``┃ Build ·`` row above the cursor composer does not take the pane.
+    """
+    tail = _nonempty_tail(lines, _CURSOR_COMPOSER_TAIL)
+    for i in range(len(tail) - 1, -1, -1):
+        if _is_cursor_composer_row(tail[i]):
+            return "cursor"
+        if _is_grok_composer_row(tail, i):
+            return "grok"
+        if _is_opencode_composer_row(tail[i]):
+            return "opencode"
+    # A permission dialog is taller than the composer tail. Look further
+    # for that one row. A mode row or a cursor/grok composer in the same
+    # stretch is a quote, not a reason to take the pane.
+    wider = _nonempty_tail(lines, _OPENCODE_PERMISSION_TAIL)
+    for i in range(len(wider) - 1, -1, -1):
+        if _is_cursor_composer_row(wider[i]) or _is_grok_composer_row(wider, i):
+            return None
+        if not _is_opencode_composer_row(wider[i]):
+            continue
+        if _opencode_permission_row(wider[i]):
+            return "opencode"
         return None
-    after = row.split("❯", 1)[1]
+    return None
+
+
+def _is_cursor_composer(lines: list[str]) -> bool:
+    """The cursor composer ROW, not a quote of its placeholder.
+
+    The row is the bottom-most composer inside the non-empty tail, the
+    same row ``_composer_state`` reads. Its stripped text has to start
+    with ``→ Add a follow-up``. A mention of that placeholder anywhere
+    else in the pane is not the composer.
+    """
+    return bool(lines) and _bottom_tui(lines) == "cursor"
+
+
+def _is_grok_pane(lines: list[str]) -> bool:
+    """The grok TUI, by the composer row at the bottom of the pane.
+
+    Cursor's footer can read ``Grok 4.7``. That string is not the test.
+    A grok composer is a ``│ ❯`` row immediately followed by ``╰``, and
+    only when that pair is the bottom-most composer in the non-empty tail.
+    A ``│``/``❯`` pair or a ``╰`` / ``always-approve`` pair anywhere else,
+    including a cursor diff hunk that starts with ``▎``, is not a grok pane.
+    A history ``❯`` without the box bar is not the composer. A usage-limit
+    modal drops the box and is recognized by ``_grok_block_reason``.
+    """
+    return bool(lines) and _bottom_tui(lines) == "grok"
+
+
+def _grok_box_text(lines: list[str], index: int) -> str:
+    """The draft inside a grok box, including ``│`` continuation rows."""
+    after = lines[index].split("❯", 1)[1]
     if "│" in after:
         after = after.split("│", 1)[0]
-    return after.strip()
+    parts = [after.strip()]
+    j = index + 1
+    while j < len(lines) and lines[j].strip().startswith("│"):
+        body = lines[j].strip()[1:]
+        if "│" in body:
+            body = body.split("│", 1)[0]
+        parts.append(body.strip())
+        j += 1
+    return " ".join(p for p in parts if p)
+
+
+def _grok_input(lines: list[str]) -> Optional[str]:
+    """Text in the live grok box, '' when empty, None if that box is not
+    the bottom composer. Continuation rows count as part of the draft."""
+    tail = _nonempty_tail(lines, _CURSOR_COMPOSER_TAIL)
+    for i in range(len(tail) - 1, -1, -1):
+        if _is_cursor_composer_row(tail[i]) or _is_opencode_composer_row(tail[i]):
+            return None
+        if _is_grok_composer_row(tail, i):
+            return _grok_box_text(tail, i)
+    return None
 
 
 # One grok screen, measured on the live 0.2.51 pane (52 rows). Lines above
@@ -2421,10 +2536,28 @@ def _agent_running(target: str) -> Optional[bool]:
         return _opencode_running(lines)
     if _is_grok_pane(lines):
         return _grok_running(lines)
-    composer = _composer_line(lines)
-    if composer is None:
+    tail = _nonempty_tail(lines, _CURSOR_COMPOSER_TAIL)
+    composer = _composer_line(tail)
+    if composer is None or not composer.startswith("→"):
         return None
-    return _CURSOR_RUN_HINT in composer
+    if _CURSOR_RUN_HINT in composer:
+        return True
+    # The spinner is the non-empty row directly above the Tip/composer
+    # block: the Tip row when it is present, otherwise the composer.
+    # No other row in the tail can make the pane read as running.
+    idx = None
+    for i in range(len(tail) - 1, -1, -1):
+        if _is_cursor_composer_row(tail[i]):
+            idx = i
+            break
+    if idx is None or idx == 0:
+        return False
+    anchor = idx - 1
+    if tail[anchor].strip().startswith("Tip:"):
+        if anchor == 0:
+            return False
+        anchor -= 1
+    return bool(_CURSOR_SPINNER_ROW.match(tail[anchor].strip()))
 
 
 def _composer_state(target: str) -> Optional[str]:
@@ -2452,6 +2585,12 @@ def _composer_state(target: str) -> Optional[str]:
     if _is_grok_pane(lines):
         return _grok_composer_state(lines)
     composer = _composer_line(lines)
+    if composer is not None and composer.startswith("→"):
+        # A cursor marker above the bottom tail is a quoted row. The
+        # composer itself is off-screen, so this pane is not readable.
+        composer = _composer_line(_nonempty_tail(lines, _CURSOR_COMPOSER_TAIL))
+        if composer is None or not composer.startswith("→"):
+            return None
     if composer is None:
         return None
     content = composer[1:].strip()
@@ -2976,8 +3115,11 @@ def _monitor_loop(state: MonitorState) -> int:
         try:
             _monitor_iteration(state)
         except KeyboardInterrupt:
+            # An interrupt during an iteration is not a clean return. Swallowing
+            # it and returning 0 made _run_pinned delete monitor.pid, so the
+            # watchdog then reported the cell unsupervised.
             state.shutdown_requested = True
-            break
+            raise
         except Exception as exc:
             print(f"{state.log_prefix} iteration error: {type(exc).__name__}: {exc}",
                   file=sys.stderr)

{swarph_cli-0.69.8 → swarph_cli-0.70.0}/src/swarph_cli/commands/monitor.py

@@ -326,6 +326,38 @@ def _read_cgroup(pid: int) -> "str | None":
         return None
 
 
+def _service_leaf(text: "str | None") -> "str | None":
+    """The .service leaf of a cgroup, or None.
+
+    user@<uid>.service is the session manager, not a supervisor. The leaf
+    keeps its .service suffix so a later reader can name the unit after
+    this process is gone.
+    """
+    if not text:
+        return None
+    for line in text.splitlines():
+        leaf = line.rsplit("/", 1)[-1].strip()
+        if leaf.endswith(".service") and not leaf.startswith("user@"):
+            return leaf
+    return None
+
+
+def _supervisor_for_pidfile(explicit: "str | None") -> "str | None":
+    """What start writes into monitor.pid.
+
+    An explicit claim wins over the cgroup. Otherwise record a unit only
+    when its name says it supervises a monitor (swarph-monitor*.service).
+    A foreign leaf such as claude-tmux@X.service is not a monitor supervisor.
+    The read is this process's own cgroup, taken now, while the pid is ours.
+    """
+    if explicit:
+        return explicit
+    leaf = _service_leaf(_read_cgroup(os.getpid()))
+    if leaf and leaf.startswith("swarph-monitor"):
+        return leaf
+    return None
+
+
 def _derive_systemd_unit(pid: "int | None") -> "str | None":
     """The supervisor Linux already knows (#344 review): Windows has no
     pid→task map so the pidfile CLAIM is the whole answer there, but on
@@ -589,10 +621,11 @@ def _cmd_start(args: argparse.Namespace) -> int:
         )
         return 0
 
+    recorded = _supervisor_for_pidfile(supervisor)
     if args.once:
         mesh.write_pidfile(
             pidfile, self_name=self_name, sinks=sinks, poll_s=args.poll_s,
-            supervisor=supervisor,
+            supervisor=recorded,
         )
         mesh._monitor_iteration(state)
         return 0
@@ -602,22 +635,26 @@ def _cmd_start(args: argparse.Namespace) -> int:
             print("swarph monitor: no fork() on this platform — running in the "
                   "foreground", file=sys.stderr)
         return _run_pinned(state, pidfile, self_name, sinks, args.poll_s,
-                           supervisor=supervisor)
+                           supervisor=recorded)
 
     return _start_detached(state, pidfile, self_name, sinks, args.poll_s,
-                           supervisor=supervisor)
+                           supervisor=recorded)
 
 
 def _run_pinned(state, pidfile: Path, self_name: str, sinks: list, poll_s: int,
                 supervisor: "str | None" = None) -> int:
     mesh.write_pidfile(pidfile, self_name=self_name, sinks=sinks, poll_s=poll_s,
                        supervisor=supervisor)
+    clean = False
     try:
-        return mesh._monitor_loop(state)
+        result = mesh._monitor_loop(state)
+        clean = True
+        return result
     finally:
-        # Only clear the pidfile if it is still OURS — a racing `start` may have
-        # legitimately reclaimed it, and deleting its record would strand it.
-        if mesh.pidfile_status(pidfile)[0] == "live_ours":
+        # A clean return can drop the file. SIGINT and any other unwind must
+        # not: the recorded supervisor is what the watchdog names after the
+        # process is gone. `monitor stop` still deletes the file itself.
+        if clean and mesh.pidfile_status(pidfile)[0] == "live_ours":
             pidfile.unlink(missing_ok=True)