swarph-cli 0.69.4__tar.gz → 0.69.5__tar.gz

{swarph_cli-0.69.4/src/swarph_cli.egg-info → swarph_cli-0.69.5}/PKG-INFO

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

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

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

{swarph_cli-0.69.4 → swarph_cli-0.69.5}/src/swarph_cli/commands/daemon.py

@@ -381,8 +381,12 @@ def _legacy_attempt_delivery_removed(state: DaemonState) -> None:
         entries = state.queue.pending()
         block = _render_delivery_block(entries)
         if session_bridge.inject(pane, block):
+            stalled = state.queue.deferred_ticks
             state.queue.remove({e["id"] for e in entries})
             state.queue.reset_deferred()
+            if stalled:
+                stall_alert.clear_stall_alert(
+                    state.gateway, state.token, state.self_name)
         # inject failure → leave queued, retry next tick (no counter bump —
         # the cell was idle; a send failure is transient, not a stall).
     except Exception as exc:  # noqa: BLE001 — bridge must never crash the loop

{swarph_cli-0.69.4 → swarph_cli-0.69.5}/src/swarph_cli/commands/mcp_server.py

@@ -344,14 +344,15 @@ def _dm_reply(message_id: int, text: str, kind: str = "answer",
         st, d = _mesh._post_json(f"{gw}/messages", body, tok)
         if not (200 <= st < 300):
             return {"error": f"gateway {st}: {d.get('detail', d) if isinstance(d, dict) else d}"}
-        ack_st, _ = _mesh._post_json(f"{gw}/messages/{int(message_id)}/read", {}, tok)
+        failed = _mesh._mark_read(gw, tok, [{"id": int(message_id)}])
+        acked = int(message_id) not in failed
         return {
             "id": d.get("id"),
             "to_node": to,
             "kind": kind,
             "thread_id": d.get("thread_id"),
-            "acked": int(message_id) if 200 <= ack_st < 300 else None,
-            "ack_status": ack_st,
+            "acked": int(message_id) if acked else None,
+            "ack_status": 200 if acked else 0,
             "closed_obligations": d.get("closed_obligations") or [],
         }
     except Exception as exc:

{swarph_cli-0.69.4 → swarph_cli-0.69.5}/src/swarph_cli/commands/mesh.py

@@ -944,38 +944,58 @@ def _run_reply(args: argparse.Namespace) -> int:
     return 0
 
 
-def _mark_read(gateway: str, token: str, messages: list) -> None:
+_BULK_READ_MAX = 500
+
+
+def _mark_read(gateway: str, token: str, messages: list) -> list:
     """Mark every unread DM we just surfaced as read. Best-effort.
 
-    Reading your inbox consumes it — like any mail client. Without this, a peer's
-    request stays "unread" no matter how many times it is answered, and an agent
-    whose loop asks "is it still unread?" can never exit. That is not theoretical:
-    on 2026-07-10 grok-researcher answered one request 67 times (~410k tokens)
-    because the CLI never called the gateway's POST /messages/{id}/read.
+    One POST /messages/read per 500 ids. The gateway's single worker spends a
+    synchronous sqlite write on every request, so a per-id loop is how a drain
+    turns into HTTP 503. A 404 means that route is not on this gateway yet, and
+    only then does this fall back to one POST per id.
 
     A mark-read failure must NEVER fail the listing — the caller has already seen
     the messages, and losing the read receipt is strictly less bad than losing them.
     """
     base = gateway.rstrip("/")
-    failed = []
+    ids = []
     for dm in messages:
-        if dm.get("read_at"):
-            continue
-        msg_id = dm.get("id")
+        if isinstance(dm, dict):
+            if dm.get("read_at"):
+                continue
+            msg_id = dm.get("id")
+        else:
+            msg_id = dm
         if msg_id is None:
             continue
+        ids.append(msg_id)
+    failed = []
+    for start in range(0, len(ids), _BULK_READ_MAX):
+        chunk = ids[start:start + _BULK_READ_MAX]
         try:
-            status, _ = _post_json(f"{base}/messages/{msg_id}/read", {}, token)
-            if status < 200 or status >= 300:
-                failed.append(msg_id)
+            status, _ = _post_json(f"{base}/messages/read", {"ids": chunk}, token)
         except Exception:  # network, DNS, timeout — never break the listing
-            failed.append(msg_id)
+            failed.extend(chunk)
+            continue
+        if status == 404:
+            for msg_id in chunk:
+                try:
+                    one, _ = _post_json(f"{base}/messages/{msg_id}/read", {}, token)
+                    if one < 200 or one >= 300:
+                        failed.append(msg_id)
+                except Exception:
+                    failed.append(msg_id)
+            continue
+        if status < 200 or status >= 300:
+            failed.extend(chunk)
     if failed:
         print(
             f"swarph mesh inbox: mark-read failed for id(s) {failed} "
             "(messages shown above; they will be re-listed as unread)",
             file=sys.stderr,
         )
+    return failed
 
 
 def _run_inbox(args: argparse.Namespace) -> int:
@@ -2673,7 +2693,8 @@ def _monitor_deliver(state: MonitorState) -> None:
                       f"no failure counted",
                       flush=True)
                 continue
-            if led.get("deferred_ticks"):
+            was_stalled = bool(led.get("deferred_ticks"))
+            if was_stalled:
                 led["deferred_ticks"] = 0
             if outcome:
                 led["last_delivered_id"] = observed
@@ -2682,6 +2703,10 @@ def _monitor_deliver(state: MonitorState) -> None:
                 state.deliveries[sink.name] = state.deliveries.get(sink.name, 0) + 1
                 print(f"{state.log_prefix} delivered to {sink.name} up to id {observed}",
                       flush=True)
+                if was_stalled:
+                    from swarph_cli import stall_alert
+                    stall_alert.clear_stall_alert(
+                        state.gateway, state.token, state.self_name)
             else:
                 # A dead sink is VISIBLE instead of silently freezing anything.
                 led["consecutive_failures"] = int(led["consecutive_failures"]) + 1

{swarph_cli-0.69.4 → swarph_cli-0.69.5}/src/swarph_cli/scripts/ensure_monitor.sh

@@ -64,12 +64,71 @@ STATE_DIR="${1:-${SWARPH_STATE_DIR:-}}"
 SD=()
 [ -n "$STATE_DIR" ] && SD=(--state-dir "$STATE_DIR")
 
+# >>> #960: a fresh channel heartbeat is already a reader. <<<
+# swarph channel-serve writes channel_heartbeat.json beside the inbox every
+# 60s and names no path on its command line, so `monitor status` cannot see
+# it. Starting a pull monitor beside a heartbeat younger than 180s is the
+# duplicate this script exists to prevent. Absent or older: start, as before.
+# A missing python3 is treated as absent (start), never as a failed caller.
+_heartbeat_fresh() {
+  local f="$1"
+  [ -n "$f" ] && [ -f "$f" ] || return 1
+  command -v python3 >/dev/null 2>&1 || return 1
+  python3 -c 'import json,os,sys,time
+try:
+    data=json.load(open(sys.argv[1],encoding="utf-8"))
+    ts=float(data.get("ts") or 0)
+except Exception:
+    raise SystemExit(1)
+age=time.time()-ts
+# A clock a few seconds ahead is still a live writer. An hour ahead is not.
+if age < -30 or age >= 180:
+    raise SystemExit(1)
+pid=data.get("pid")
+if pid is None:
+    raise SystemExit(0)
+try:
+    pid=int(pid)
+except (TypeError, ValueError):
+    raise SystemExit(1)
+# pid 0 is this process group and pid -1 is every process we can signal.
+# Neither is the channel server. os.kill would report both as alive.
+if pid <= 0:
+    raise SystemExit(1)
+try:
+    os.kill(pid, 0)
+except PermissionError:
+    pass
+except OSError:
+    raise SystemExit(1)
+try:
+    raw=open("/proc/%s/cmdline" % pid, "rb").read()
+except OSError:
+    # No command line to read (macOS, or a pid we may not inspect).
+    # A live pid still counts, which is the check this host can make.
+    raise SystemExit(0)
+text=raw.replace(b"\x00", b" ").decode("utf-8", "replace")
+if "channel-serve" in text or "swarph_cli.channel" in text:
+    raise SystemExit(0)
+raise SystemExit(1)' "$f"
+}
+
+HB_ROOT="${STATE_DIR:-$HOME/swarph_state/$SELF}"
+HB_FILE=""
+if [ -f "$HB_ROOT/channel_heartbeat.json" ]; then
+  HB_FILE="$HB_ROOT/channel_heartbeat.json"
+elif [ -f "$HB_ROOT/mesh-sidecar/channel_heartbeat.json" ]; then
+  HB_FILE="$HB_ROOT/mesh-sidecar/channel_heartbeat.json"
+fi
+
 "$SW" monitor status --as "$SELF" ${SD[@]+"${SD[@]}"} >/dev/null 2>&1
 case $? in
   0) ;;                                   # running, nothing pending
   1) ;;                                   # running, DMs pending — reported below
-  *) # not running (2) or unknown: start it. Idempotent, so a race is harmless.
-     if "$SW" monitor start --as "$SELF" --deliver pull ${SD[@]+"${SD[@]}"} >/tmp/.swarph-monitor-start.$$ 2>&1; then
+  *) # not running (2) or unknown.
+     if _heartbeat_fresh "$HB_FILE"; then
+       echo "[monitor] channel heartbeat is under 180s old — not starting a monitor"
+     elif "$SW" monitor start --as "$SELF" --deliver pull ${SD[@]+"${SD[@]}"} >/tmp/.swarph-monitor-start.$$ 2>&1; then
        echo "[monitor] started (--deliver pull)"
      else
        # LOUD, not silent: an auto-start that fails quietly rebuilds the exact

swarph_cli-0.69.5/src/swarph_cli/stall_alert.py

@@ -0,0 +1,144 @@
+"""stall_alert — surface a cell whose live session is perpetually busy so its
+undelivered DMs don't rot silently. Exponential backoff (6,12,24,48…) prevents
+the linear-flood failure (the 145-DM incident, feedback_modal_stalls_cell_wake).
+
+Card #989: the surface is one obligation held by lab-ovh, never a DM to
+commander. A second stall tick while that row is open opens nothing new. A
+drain closes it. Fail-safe: a failed POST never raises and never blocks
+delivery."""
+from __future__ import annotations
+
+import json
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+from swarph_cli.console_safe import print_safe
+
+_STALL_FIRST = 6  # first alert after this many consecutive deferred ticks
+_CARD = 989
+_HOLDER = "lab-ovh"
+# lab-ovh's own stall cannot escalate to lab-ovh. Another orchestrator holds it.
+_OTHER = "drop-on-meta-edge"
+_TIMEOUT_HOURS = 24
+_PREFIX = f"STALL card #{_CARD}"
+
+
+def is_alert_tick(deferred_ticks: int) -> bool:
+    """True exactly at 6, 12, 24, 48, 96 … — first at _STALL_FIRST, doubling."""
+    if deferred_ticks < _STALL_FIRST or deferred_ticks % _STALL_FIRST != 0:
+        return False
+    k = deferred_ticks // _STALL_FIRST
+    return (k & (k - 1)) == 0  # k is a power of two
+
+
+def _accept(self_name: str, count: int, pending_n: int) -> str:
+    return (
+        f"{_PREFIX} cell={self_name} ticks={count} pending={pending_n} | "
+        "PASS = the cell drained and this row is closed | "
+        "FAIL = the cell is still unable to deliver"
+    )
+
+
+def _what(self_name: str, count: int, pending_n: int) -> str:
+    return (
+        f"{_PREFIX}\n"
+        f"cell={self_name} ticks={count} pending_dms={pending_n}"
+    )
+
+
+def _open_url(req, timeout):
+    host = urllib.parse.urlparse(req.full_url).hostname
+    if host in {"127.0.0.1", "localhost", "::1"}:
+        return urllib.request.build_opener(
+            urllib.request.ProxyHandler({})).open(req, timeout=timeout)
+    return urllib.request.urlopen(req, timeout=timeout)
+
+
+def _request(method: str, url: str, token: str, payload: dict | None = None) -> dict:
+    data = None if payload is None else json.dumps(payload).encode()
+    req = urllib.request.Request(
+        url, data=data, method=method,
+        headers={"Authorization": f"Bearer {token}",
+                 "Content-Type": "application/json"})
+    with _open_url(req, timeout=10) as resp:
+        raw = resp.read().decode()
+        if not (200 <= resp.status < 300):
+            raise urllib.error.URLError(f"HTTP {resp.status}")
+    return json.loads(raw) if raw else {}
+
+
+def _holder_for(self_name: str) -> str:
+    return _OTHER if self_name == _HOLDER else _HOLDER
+
+
+def _cell_row(row: dict, self_name: str) -> bool:
+    needle = f"cell={self_name} "
+    return needle in (row.get("accept") or "") or needle in (row.get("what") or "")
+
+
+def _live(gateway: str, token: str, self_name: str) -> list[dict]:
+    rows: list[dict] = []
+    for status in ("open", "fallback_fired"):
+        data = _request(
+            "GET",
+            f"{gateway}/board/obligations?card_id={_CARD}&status={status}",
+            token)
+        rows.extend(data.get("obligations") or [])
+    seen = set()
+    live = []
+    for row in rows:
+        if row.get("id") in seen:
+            continue
+        seen.add(row.get("id"))
+        if _cell_row(row, self_name):
+            live.append(row)
+    return live
+
+
+def send_stall_alert(gateway: str, token: str, self_name: str,
+                     count: int, pending_n: int) -> bool:
+    """Open one obligation on card #989 held by lab-ovh. True when that row
+    is open (newly or already). False on any error. Never raises, never
+    DMs commander, and a second call while the row is open opens nothing."""
+    try:
+        gateway = gateway.rstrip("/")
+        if _live(gateway, token, self_name):
+            return True
+        holder = _holder_for(self_name)
+        _request(
+            "POST", f"{gateway}/board/cards/{_CARD}/ask", token,
+            {"holder": holder,
+             "what": _what(self_name, count, pending_n),
+             "created_by": self_name,
+             "kind": "action",
+             "fallback_mode": "escalate",
+             "fallback_target": holder,
+             "timeout_hours": _TIMEOUT_HOURS,
+             "accept": _accept(self_name, count, pending_n)})
+        return True
+    except (urllib.error.URLError, OSError, ValueError, json.JSONDecodeError) as exc:
+        print_safe(f"[swarph-daemon] stall-alert POST failed: {exc}",
+                   file=sys.stderr, flush=True)
+        return False
+
+
+def clear_stall_alert(gateway: str, token: str, self_name: str) -> bool:
+    """Close the open stall row after a drain. True when none remain open.
+    False on any error. Never raises."""
+    evidence = (
+        f"{_PREFIX} cell={self_name} drained. "
+        "The deferred delivery completed, so this row is closed."
+    )
+    try:
+        gateway = gateway.rstrip("/")
+        live = _live(gateway, token, self_name)
+        for row in live:
+            _request(
+                "POST", f"{gateway}/board/obligations/{row['id']}/close", token,
+                {"outcome": "pass", "evidence": evidence})
+        return True
+    except (urllib.error.URLError, OSError, ValueError, json.JSONDecodeError) as exc:
+        print_safe(f"[swarph-daemon] stall-alert close failed: {exc}",
+                   file=sys.stderr, flush=True)
+        return False

{swarph_cli-0.69.4 → swarph_cli-0.69.5/src/swarph_cli.egg-info}/PKG-INFO

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

@@ -250,6 +250,7 @@ tests/test_955_prompt_audit.py
 tests/test_957_auth_http.py
 tests/test_959_venv_interpreter.py
 tests/test_960_channel.py
+tests/test_960_ensure_monitor_heartbeat.py
 tests/test_963_plugin_manifest.py
 tests/test_964_channel_cell.py
 tests/test_965_mesh_wait.py

{swarph_cli-0.69.4 → swarph_cli-0.69.5}/tests/test_735_dm_mcp_tools.py

@@ -143,8 +143,8 @@ def test_reply_is_the_ack_and_only_that_message(monkeypatch):
     assert posts[0][0] == "http://gw/messages" and posts[0][1] == {
         "from_node": "lab-ovh", "to_node": "cursor-lin", "kind": "answer",
         "content": "on it — thread 81570cab", "thread_id": "81570cab-0000-4000-8000-000000000001"}
-    reads = [u for u, _ in posts if u.endswith("/read")]
-    assert reads == ["http://gw/messages/32004/read"], reads        # exactly one ack, the replied-to one
+    reads = [(u, b) for u, b in posts if str(u).endswith("/read")]
+    assert reads == [("http://gw/messages/read", {"ids": [32004]})], reads
     assert mcp_server._dm_reply(32004, "   ")["error"] == "empty reply text"
 
 

swarph_cli-0.69.5/tests/test_960_ensure_monitor_heartbeat.py

@@ -0,0 +1,166 @@
+"""#960: a fresh channel heartbeat is a reader. Do not start a monitor beside it.
+
+channel-serve writes channel_heartbeat.json beside the inbox and puts nothing
+on its command line, so monitor status reports "not running" while the channel
+is alive. On main, that status is enough to start a second reader. The head
+starts only when the file is absent or older than 180s.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import pytest
+
+SCRIPT = (
+    Path(__file__).resolve().parent.parent
+    / "src" / "swarph_cli" / "scripts" / "ensure_monitor.sh"
+)
+
+FAKE = """#!/usr/bin/env bash
+printf '%s\\n' "$*" >> "$FAKE_LOG"
+exit 2
+"""
+
+
+def _bash():
+    if sys.platform == "win32":
+        pytest.skip("windows-latest bash is the WSL stub")
+    found = shutil.which("bash")
+    if not found:
+        pytest.skip("no bash")
+    return found
+
+
+def _run(tmp_path: Path, *, age: float | None):
+    bindir = tmp_path / "bin"
+    bindir.mkdir()
+    shim = bindir / "swarph"
+    shim.write_text(FAKE, encoding="utf-8")
+    shim.chmod(0o755)
+    log = tmp_path / "calls.log"
+    state = tmp_path / "state"
+    side = state / "mesh-sidecar"
+    side.mkdir(parents=True)
+    if age is not None:
+        (side / "channel_heartbeat.json").write_text(
+            json.dumps({"ts": time.time() - age}), encoding="utf-8")
+    env = dict(os.environ)
+    env["PATH"] = f"{bindir}{os.pathsep}{env.get('PATH', '')}"
+    env["SWARPH_SELF"] = "cursor-lin"
+    env["SWARPH_STATE_DIR"] = str(state)
+    env["FAKE_LOG"] = str(log)
+    proc = subprocess.run(
+        [_bash(), str(SCRIPT)], env=env, capture_output=True, text=True, timeout=60)
+    calls = log.read_text(encoding="utf-8") if log.exists() else ""
+    return proc, calls
+
+
+def test_fresh_heartbeat_does_not_start(tmp_path):
+    proc, calls = _run(tmp_path, age=10)
+    assert proc.returncode == 0
+    assert "monitor start" not in calls
+    assert "under 180s" in proc.stdout
+
+
+def test_stale_heartbeat_still_starts(tmp_path):
+    proc, calls = _run(tmp_path, age=200)
+    assert proc.returncode == 0
+    assert "monitor start" in calls
+
+
+def test_absent_heartbeat_still_starts(tmp_path):
+    proc, calls = _run(tmp_path, age=None)
+    assert proc.returncode == 0
+    assert "monitor start" in calls
+
+
+def _run_payload(tmp_path: Path, payload: dict):
+    bindir = tmp_path / "bin"
+    bindir.mkdir()
+    shim = bindir / "swarph"
+    shim.write_text(FAKE, encoding="utf-8")
+    shim.chmod(0o755)
+    log = tmp_path / "calls.log"
+    side = tmp_path / "state" / "mesh-sidecar"
+    side.mkdir(parents=True)
+    (side / "channel_heartbeat.json").write_text(json.dumps(payload), encoding="utf-8")
+    env = dict(os.environ)
+    env["PATH"] = f"{bindir}{os.pathsep}{env.get('PATH', '')}"
+    env["SWARPH_SELF"] = "cursor-lin"
+    env["SWARPH_STATE_DIR"] = str(tmp_path / "state")
+    env["FAKE_LOG"] = str(log)
+    proc = subprocess.run(
+        [_bash(), str(SCRIPT)], env=env, capture_output=True, text=True, timeout=60)
+    calls = log.read_text(encoding="utf-8") if log.exists() else ""
+    return proc, calls
+
+
+def test_a_future_timestamp_an_hour_ahead_starts(tmp_path):
+    proc, calls = _run_payload(tmp_path, {"ts": time.time() + 3600})
+    assert proc.returncode == 0
+    assert "monitor start" in calls
+
+
+def test_a_timestamp_within_skew_stays_fresh(tmp_path):
+    proc, calls = _run_payload(tmp_path, {"ts": time.time() + 10})
+    assert proc.returncode == 0
+    assert "monitor start" not in calls
+
+
+def test_a_fresh_heartbeat_with_a_dead_pid_starts(tmp_path):
+    # Above any host pid_max. macOS has no /proc, so the dead pid cannot come from there.
+    proc, calls = _run_payload(tmp_path, {"ts": time.time(), "pid": 2**31 - 1})
+    assert proc.returncode == 0
+    assert "monitor start" in calls
+
+
+def test_a_fresh_heartbeat_with_a_live_pid_skips(tmp_path):
+    """A live channel-server process still suppresses the start.
+
+    Where /proc is missing the command line cannot be checked, so any live pid
+    still counts, which is what this host can see.
+    """
+    child = None
+    if os.path.isdir("/proc/self"):
+        child = subprocess.Popen(
+            [sys.executable, "-c", "import time; time.sleep(30)", "channel-serve"])
+        pid = child.pid
+    else:
+        pid = os.getpid()
+    try:
+        proc, calls = _run_payload(tmp_path, {"ts": time.time(), "pid": pid})
+    finally:
+        if child is not None:
+            child.kill()
+            child.wait(timeout=5)
+    assert proc.returncode == 0
+    assert "monitor start" not in calls
+
+
+def test_pid_zero_starts(tmp_path):
+    proc, calls = _run_payload(tmp_path, {"ts": time.time(), "pid": 0})
+    assert proc.returncode == 0
+    assert "monitor start" in calls
+
+
+def test_pid_minus_one_starts(tmp_path):
+    proc, calls = _run_payload(tmp_path, {"ts": time.time(), "pid": -1})
+    assert proc.returncode == 0
+    assert "monitor start" in calls
+
+
+def test_an_unrelated_live_pid_starts_when_its_command_line_is_readable(tmp_path):
+    if not os.path.isdir("/proc/self"):
+        pytest.skip("command-line check is not available")
+    parent = os.getppid()
+    text = open(f"/proc/{parent}/cmdline", "rb").read().replace(b"\x00", b" ").decode()
+    assert "channel-serve" not in text
+    proc, calls = _run_payload(tmp_path, {"ts": time.time(), "pid": parent})
+    assert proc.returncode == 0
+    assert "monitor start" in calls