meshcode 2.11.125__tar.gz → 2.11.127__tar.gz

{meshcode-2.11.125 → meshcode-2.11.127}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.125
+Version: 2.11.127
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.125 → meshcode-2.11.127}/meshcode/__init__.py

@@ -1,5 +1,5 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.11.125"
+__version__ = "2.11.127"
 
 # Exception hierarchy — eagerly imported (lightweight, no deps)
 from meshcode.exceptions import (  # noqa: F401

{meshcode-2.11.125 → meshcode-2.11.127}/meshcode/hostd.py

@@ -209,6 +209,34 @@ SPAWN_MIN_INTERVAL_SEC = _env_int("MESHCODE_SPAWN_MIN_INTERVAL_SEC", 45, 5)    #
 SPAWN_BURST_CAP        = _env_int("MESHCODE_SPAWN_BURST_CAP", 5, 2)            # max spawns ...
 SPAWN_BURST_WINDOW_SEC = _env_int("MESHCODE_SPAWN_BURST_WINDOW_SEC", 600, 60)  # ... within this rolling window before tripping
 
+# ------------------------------------------------------------------
+# Plain-respawn guards (Samuel P0 2026-06-10, terminal storm): the burst
+# breaker above NEVER saw the overnight storm — hostd respawned zylo-bemate
+# every ~16 min for 13 h (125 terminals): slow boots under load kept resetting
+# the server-side respawn cap (the agent heartbeats briefly, count -> 0), the
+# ~16 min cadence stays under 5 spawns/10 min, and every respawn STACKED a new
+# window on top of the still-alive previous session, adding load that made the
+# next boot even slower. Two guards on the plain-respawn path in _do_respawns:
+#
+#   LIVE-SESSION GUARD — never open a second terminal while the previous
+#   session's process is still alive: HOLD (spawn nothing), hard-kill the stuck
+#   session after _RESPAWN_STUCK_KILL_S, and relaunch only once it is fully
+#   gone. An explicit Start (fresh spawned_at) kills the old session at once —
+#   a restart the human asked for must first fully close the old terminal.
+#
+#   CONVERGENCE GUARD — mirror of the recycle guard (451d33a0) for plain
+#   respawns, keyed on time BETWEEN consecutive respawns so it catches ANY
+#   cadence: _RESPAWN_CONVERGE_MAX consecutive respawns each started less than
+#   _RESPAWN_CONVERGE_LIFETIME_S after the previous one -> BLOCK further
+#   respawns for _RESPAWN_CONVERGE_BLOCK_TTL_S + resolve the pending launch as
+#   failed (FE toast). An explicit Start clears the block.
+# ------------------------------------------------------------------
+_RESPAWN_STUCK_KILL_S         = _env_int("MESHCODE_RESPAWN_STUCK_KILL_SEC", 600, 60)       # kill a stale-but-alive session after this hold
+_RESPAWN_CONVERGE_MAX         = _env_int("MESHCODE_RESPAWN_CONVERGE_MAX", 3, 2)            # consecutive short-lived respawns before blocking
+_RESPAWN_CONVERGE_LIFETIME_S  = _env_int("MESHCODE_RESPAWN_CONVERGE_LIFETIME_SEC", 1800, 120)   # "short-lived" = next respawn needed within this
+_RESPAWN_CONVERGE_BLOCK_TTL_S = _env_int("MESHCODE_RESPAWN_CONVERGE_BLOCK_TTL_SEC", 21600, 600)  # block duration before one clean retry
+_RESPAWN_FRESH_CLICK_S        = _env_int("MESHCODE_RESPAWN_FRESH_CLICK_SEC", 90, 30)       # spawned_age_s under this = explicit Start click
+
 
 def _log(msg: str) -> None:
     line = f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {msg}"
@@ -535,6 +563,88 @@ def _do_respawns(api_key: str, host_id: str) -> int:
             _rrall[_target] = _rr
             _rst["recyrespawn"] = _rrall
             _save_state(_rst)
+        # ---- plain-respawn guards (Samuel P0 2026-06-10, terminal storm; see
+        # ---- constants block above for the full incident rationale) ----
+        if not _is_recycle:
+            _now2 = time.time()
+            _st2 = _load_state()
+            try:
+                _fresh_click = float(c.get("spawned_age_s")) < _RESPAWN_FRESH_CLICK_S
+            except (TypeError, ValueError):
+                _fresh_click = False
+            _cv_all = dict(_st2.get("respawn_conv") or {})
+            _cv = dict(_cv_all.get(_target) or {})
+            if _fresh_click and (_cv or _target in (_st2.get("respawn_hold") or {})):
+                # explicit Start (fresh spawned_at) = human permission: clear guard state
+                _cv = {}
+                _cv_all.pop(_target, None)
+                _hh = dict(_st2.get("respawn_hold") or {})
+                _hh.pop(_target, None)
+                _st2["respawn_conv"] = _cv_all
+                _st2["respawn_hold"] = _hh
+                _save_state(_st2)
+                _log(f"RESPAWN-GUARD {_target}: explicit Start — cleared hold/convergence state")
+            elif _cv.get("blocked_ts"):
+                if (_now2 - float(_cv["blocked_ts"])) < _RESPAWN_CONVERGE_BLOCK_TTL_S:
+                    _log(f"SKIP respawn {_target}: BLOCKED (respawn_no_converge, "
+                         f"{_cv.get('count')} short-lived respawns) — holding until TTL or a manual Start")
+                    continue
+                _cv.pop("blocked_ts", None)
+                _cv["count"] = 0  # TTL elapsed -> one clean retry; re-blocks if it storms again
+            # LIVE-SESSION GUARD: never stack a second terminal on a still-alive session.
+            _live = [p for p in _discover_agent_pids(_target) if _pid_alive(p)]
+            if _live:
+                _hold_all = dict(_st2.get("respawn_hold") or {})
+                _hold = dict(_hold_all.get(_target) or {})
+                _first = float(_hold.get("first_ts") or _now2)
+                if _fresh_click or (_now2 - _first) >= _RESPAWN_STUCK_KILL_S:
+                    _killed = sum(1 for _p in _live if _kill_headless_pid(_target, _p))
+                    _hold_all.pop(_target, None)
+                    _log(f"RESPAWN-STUCK-KILL {_target}: closed {_killed}/{len(_live)} stale-but-alive "
+                         f"session pid(s) {_live} "
+                         f"({'explicit Start' if _fresh_click else 'stuck > ' + str(_RESPAWN_STUCK_KILL_S) + 's'}) "
+                         f"— relaunch on next sweep once fully gone")
+                else:
+                    _hold["first_ts"] = _first
+                    _hold_all[_target] = _hold
+                    _log(f"RESPAWN-HOLD {_target}: previous session still ALIVE (pids {_live}) — "
+                         f"NOT opening another terminal; stuck-kill in "
+                         f"{int(_RESPAWN_STUCK_KILL_S - (_now2 - _first))}s unless it heartbeats")
+                _st2["respawn_hold"] = _hold_all
+                _save_state(_st2)
+                continue
+            # previous session fully gone — count this relaunch against convergence
+            _hold_all = dict(_st2.get("respawn_hold") or {})
+            if _target in _hold_all:
+                _hold_all.pop(_target, None)
+                _st2["respawn_hold"] = _hold_all
+            if _cv.get("last_ts") and (_now2 - float(_cv["last_ts"])) <= _RESPAWN_CONVERGE_LIFETIME_S:
+                _cv["count"] = int(_cv.get("count", 0)) + 1
+            else:
+                _cv = {"count": 1}  # converged/idle long enough -> fresh count
+            _cv["last_ts"] = _now2
+            if _cv["count"] >= _RESPAWN_CONVERGE_MAX:
+                _cv["blocked_ts"] = _now2
+                _cv_all[_target] = _cv
+                _st2["respawn_conv"] = _cv_all
+                _save_state(_st2)
+                _log(f"ALERT {_target}: respawn NOT CONVERGING — {_cv['count']} consecutive respawns "
+                     f"each <{_RESPAWN_CONVERGE_LIFETIME_S}s apart; BLOCKING respawns for "
+                     f"{_RESPAWN_CONVERGE_BLOCK_TTL_S}s (a manual Start clears the block). "
+                     f"[respawn_blocked_reason=respawn_no_converge]")
+                try:  # stop the dashboard's eternal 'launching…' spinner + actionable toast
+                    _rpc("mc_resolve_launch", {
+                        "p_api_key": api_key, "p_project_id": c.get("project_id"), "p_agent": agent,
+                        "p_status": "failed", "p_reason": "respawn_no_converge",
+                        "p_detail": f"agent kept dying or booting too slowly {_cv['count']}x in a row — "
+                                    f"respawns paused to protect your machine and tokens; press Start "
+                                    f"to retry when ready"})
+                except Exception:
+                    pass
+                continue
+            _cv_all[_target] = _cv
+            _st2["respawn_conv"] = _cv_all
+            _save_state(_st2)
         _ok, _burst, _why = _spawn_rate_ok(_target)
         if not _ok:
             _log(f"SKIP {'recycle-' if _is_recycle else ''}respawn {_target}: rate-limited ({_why})")
@@ -941,9 +1051,63 @@ def _discover_agent_pids(target: str) -> list:
                     pids.append(p)
     except Exception:
         pass
+    # GHOST-TERMINAL fix (task 91201315): on POSIX `meshcode run` EXECVP's claude, so the
+    # live agent's cmdline is `claude …` — no 'meshcode run <target>' survives and the
+    # pgrep above sees NOTHING for a visible macOS agent (the '0 stopped forever' hole).
+    # Its launcher bash (~/.meshcode/launchers/<label>.command) DOES keep the target in
+    # its cmdline for the window's whole life — so also return that bash's direct agent
+    # children. Launcher children are hostd-spawned BY CONSTRUCTION: a session the human
+    # opened by hand (`claude --resume` in a plain tab) can NEVER match.
+    if sys.platform != "win32":
+        try:
+            pids += [p for p in _discover_launcher_child_pids(target) if p not in pids]
+        except Exception:
+            pass
     return pids
 
 
+def _discover_launcher_child_pids(target: str) -> list:
+    """PIDs of `target`'s agent process(es) running UNDER its launcher bash
+    (~/.meshcode/launchers/<label>.command — the macOS visible spawn path).
+
+    One ps snapshot: find the bash whose cmdline ends in the target's launcher
+    file, then return its DIRECT children whose cmdline looks like the agent
+    (claude/meshcode). The marker is re.escape'd and anchored (whitespace/EOL
+    lookahead) so 'mesh-dev_back.command' can never prefix-match
+    'mesh-dev_back-2.command' (same WHOLE-token rule as _discover_agent_pids).
+    Best-effort; [] on non-POSIX or any failure."""
+    if sys.platform == "win32":
+        return []
+    marker = _terminal_window_marker(target)  # '<sanitized label>.command'
+    if not marker:
+        return []
+    rx = re.compile(r"launchers/" + re.escape(marker) + r"(?=\s|$)")
+    kids = []
+    try:
+        out = subprocess.run(["ps", "-axo", "pid=,ppid=,args="],
+                             capture_output=True, text=True, timeout=8).stdout
+        rows, bash_pids = [], set()
+        for ln in out.splitlines():
+            parts = ln.split(None, 2)
+            if len(parts) < 3:
+                continue
+            try:
+                pid, ppid = int(parts[0]), int(parts[1])
+            except Exception:
+                continue
+            rows.append((pid, ppid, parts[2]))
+            if rx.search(parts[2]):
+                bash_pids.add(pid)
+        for pid, ppid, args in rows:
+            if ppid in bash_pids and pid not in bash_pids:
+                low = args.lower()
+                if "claude" in low or "meshcode" in low:
+                    kids.append(pid)
+    except Exception:
+        pass
+    return kids
+
+
 def _kill_heartbeat_fork(target: str) -> None:
     """Kill the agent's heartbeat daemon fork (Fix B, task 24e3dd44). The fork is detached into its
     OWN session, so os.killpg(getpgid(agent_pid)) in _kill_headless_pid does NOT take it down — it
@@ -1055,6 +1219,104 @@ def _do_stops(api_key: str, host_id: str) -> int:
     return n
 
 
+def _term_ghost_pid(target: str, pid: int) -> bool:
+    """Kill a stop-ghost agent process WITHOUT killpg (task 91201315). The launcher
+    bash shares the pgid — it must SURVIVE the kill so it sees rc=143 and the
+    wrapper's clean-close path (protocol_handler) closes its own Terminal window.
+    SIGTERM the pid only, escalate to SIGKILL (pid only) after a short grace.
+    Cmdline reuse-guard is STRICTER than _kill_headless_pid's: an EMPTY cmdline is
+    a skip too (we only ever kill a process we can positively read as the agent).
+    Windows has no .command wrapper — delegate to _kill_headless_pid (tree kill).
+    Returns True if the ghost was killed."""
+    if not pid:
+        return False
+    if sys.platform == "win32":
+        return _kill_headless_pid(target, pid)
+    cl = _pid_cmdline(pid).lower()
+    if "meshcode" not in cl and "claude" not in cl:
+        _log(f"GHOST {target}: pid {pid} cmdline unreadable/mismatch — skip kill")
+        return False
+    try:
+        os.kill(pid, _signal.SIGTERM)
+    except ProcessLookupError:
+        return False
+    except Exception as e:
+        _log(f"WARN: GHOST {target}: SIGTERM pid {pid} failed: {e}")
+        return False
+    time.sleep(2.0)
+    try:
+        os.kill(pid, 0)                      # still alive?
+        os.kill(pid, _signal.SIGKILL)        # didn't honor SIGTERM
+        _log(f"GHOST {target}: pid {pid} ignored SIGTERM — SIGKILLed")
+    except ProcessLookupError:
+        pass
+    except Exception:
+        pass
+    _kill_heartbeat_fork(target)  # its detached heartbeat fork won't die with the pid
+    _log(f"GHOST {target}: killed stop-ghost pid {pid} (desired=stopped, heartbeat stale)")
+    return True
+
+
+def _do_stopped_ghost_sweep(api_key: str, host_id: str) -> int:
+    """GHOST-TERMINAL kill sweep (task 91201315; Ian's live repro: back-2 pid 26078,
+    hostd logging '0 stopped' forever). The hole: on Stop the agent exits its loop
+    cleanly, clears its instance_id and STOPS heartbeating — and BOTH kill RPCs
+    (mc_agents_to_stop, mc_agents_to_force_kill) gate on last_heartbeat < 90s, so
+    once the heartbeat goes stale the still-alive claude process is INVISIBLE to
+    every RPC sweep and its terminal window stays open with claude running.
+
+    Sweep the ROSTER instead (mc_host_config_get — no fresh-heartbeat gate): every
+    desired_state='stopped' agent whose heartbeat is STALE or absent (>=90s; fresh
+    ones stay with the RPC sweeps so the cooperative must_exit gets first crack)
+    gets PID discovery; any live process found IS a ghost — desired says stopped,
+    nothing legit can be running. Kill via _term_ghost_pid (SIGTERM, no killpg) so
+    the launcher bash survives, sees rc=143 and closes its own window; then the
+    dead-window reap below mops up any '[Process completed]' leftovers (SIGKILL
+    path / wrappers generated before the rc=143 fix).
+
+    NEVER touches a hand-opened session: discovery matches ONLY 'meshcode run
+    <target>' cmdlines (token-safe) or direct children of the target's own
+    hostd launcher .command — a human `claude --resume` in a plain tab can't
+    match either. Returns number of ghosts killed."""
+    cfg = _rpc("mc_host_config_get", {"p_api_key": api_key, "p_host_id": host_id})
+    if not cfg or not cfg.get("ok"):
+        return 0
+    st = _load_state()
+    pids = st.get("headless_pids") or {}
+    n = 0
+    for a in (cfg.get("agents") or []):
+        if a.get("desired_state") != "stopped":
+            continue
+        hb = a.get("heartbeat_age_s")
+        if hb is not None and hb < 90:
+            continue  # fresh heartbeat -> mc_agents_to_stop/_force_kill own this window
+        proj, agent = a.get("project_name"), a.get("name")
+        if not proj or not agent:
+            continue
+        target = f"{proj}/{agent}"
+        killed_here = 0
+        for pid in _discover_agent_pids(target):
+            if _term_ghost_pid(target, pid):
+                killed_here += 1
+        if not killed_here:
+            continue
+        n += killed_here
+        pids.pop(target, None)
+        # The human pressed Stop — finish the job like _do_force_kills does: brief
+        # settle, then close any window left dead (SIGKILL fallback / old wrapper).
+        try:
+            time.sleep(1.5)
+            _wins = _list_dead_terminal_windows(target)
+            if _wins:
+                _close_dead_terminal_windows(target, _wins)
+        except Exception:
+            pass
+    if n:
+        st["headless_pids"] = pids
+        _save_state(st)
+    return n
+
+
 # 38523a98 Gap 1: explicit human force-kill of VISIBLE agents. ENABLED in 2.11.112 (task fa11ff48):
 # Samuel-blessed + 0 false-positives verified (backend2 pre-check + empty owner-scoped queue on our box).
 # _REAP_DRYRUN (autonomous reaper, below) stays True — SEPARATE gate, needs its own 0-FP + Samuel OK.
@@ -1907,11 +2169,14 @@ def cmd_hostd(args: list) -> int:
                         ver_recycled = _do_version_recycles(api_key, host_id)
                         stopped = _do_stops(api_key, host_id)
                         force_killed = _do_force_kills(api_key, host_id)  # 38523a98 Gap1: visible explicit human stop
+                        # 91201315: stopped agents whose instance/heartbeat already cleared —
+                        # invisible to both RPC sweeps above (their <90s heartbeat gate).
+                        ghost_killed = _do_stopped_ghost_sweep(api_key, host_id)
                         reaped = _do_reap(api_key, host_id)  # 38523a98: kill ghosts/dup-PIDs/crashed-orphans
                         _gc_headless_pids()  # cb90b058: drop dead PIDs (stale entry can't mask a live agent)
                         _up = int(time.monotonic() - _spawn_mono)
-                        if relaunched or recycled or ver_recycled or stopped or enforced or reaped or force_killed:
-                            _log(f"sweep done (uptime={_up}s) — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled, {stopped} stopped, {force_killed} force-killed, {enforced} recycle-enforced, {reaped} reaped")
+                        if relaunched or recycled or ver_recycled or stopped or enforced or reaped or force_killed or ghost_killed:
+                            _log(f"sweep done (uptime={_up}s) — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled, {stopped} stopped, {force_killed} force-killed, {ghost_killed} ghost-killed, {enforced} recycle-enforced, {reaped} reaped")
                         elif time.monotonic() - _last_alive_log >= 60:
                             _log(f"alive — uptime={_up}s")
                             _last_alive_log = time.monotonic()

{meshcode-2.11.125 → meshcode-2.11.127}/meshcode/protocol_handler.py

@@ -224,11 +224,14 @@ def _spawn_terminal_macos(cmd: str) -> tuple[bool, str]:
         _run = cmd
     lines.append(_run)
     lines.append('MC_RC=$?')
-    # Close THIS Terminal window ONLY on a clean exit (recycle/stop => 0). On a CRASH
-    # (non-zero) leave it OPEN so the scrollback is available for debugging (commander
-    # condition: debugging > clean window). The own-$MC_TTY filter closes ONLY this
-    # window — never another agent's. saving no => no "close?" prompt. macOS-only path.
-    lines.append('if [ "$MC_RC" = "0" ] && [ -n "$MC_TTY" ]; then')
+    # Close THIS Terminal window ONLY on a clean exit: rc=0 (recycle/stop self-exit)
+    # OR rc=143 (SIGTERM — hostd's stop/ghost kill sweep ended the agent because the
+    # human pressed Stop, task 91201315; that's the job FINISHING, not a crash). Any
+    # OTHER rc is a crash -> leave the window OPEN so the scrollback is available for
+    # debugging (commander condition: debugging > clean window). The own-$MC_TTY
+    # filter closes ONLY this window — never another agent's. saving no => no
+    # "close?" prompt. macOS-only path.
+    lines.append('if { [ "$MC_RC" = "0" ] || [ "$MC_RC" = "143" ]; } && [ -n "$MC_TTY" ]; then')
     lines.append(
         "  /usr/bin/osascript"
         " -e 'tell application \"Terminal\"'"

{meshcode-2.11.125 → meshcode-2.11.127}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.125
+Version: 2.11.127
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.125 → meshcode-2.11.127}/meshcode.egg-info/SOURCES.txt

@@ -90,5 +90,6 @@ tests/test_setup_path.py
 tests/test_sleep_signals.py
 tests/test_status_enum_coverage.py
 tests/test_stay_on_loop_hook.py
+tests/test_stop_ghost_terminal.py
 tests/test_swarm_events.py
 tests/test_wait_open_tasks_contradiction.py

{meshcode-2.11.125 → meshcode-2.11.127}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.11.125"
+version = "2.11.127"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}

meshcode-2.11.127/tests/test_stop_ghost_terminal.py

@@ -0,0 +1,211 @@
+"""
+Stop-Ghost-Terminal Regression Tests (task 91201315)
+=====================================================
+Bug (Ian live repro 2026-06-10, back-2 pid 26078): dashboard Stop -> agent
+exits its loop cleanly, clears instance_id and stops heartbeating BEFORE the
+hostd sweep -> mc_agents_to_stop / mc_agents_to_force_kill (both gate on
+last_heartbeat < 90s) never return it -> hostd logs '0 stopped' forever and
+the Terminal window stays open with a live claude.
+
+Fix under test:
+  1. hostd._do_stopped_ghost_sweep — roster-based sweep (mc_host_config_get)
+     for desired_state='stopped' + stale heartbeat, wired into the poll loop.
+  2. hostd._discover_launcher_child_pids — finds the agent process under its
+     launcher bash (on POSIX `meshcode run` execvp's claude, so the old
+     `pgrep -f "meshcode run <target>"` sees nothing for visible agents).
+  3. hostd._term_ghost_pid — SIGTERM the agent pid WITHOUT killpg so the
+     launcher bash survives to see rc=143.
+  4. protocol_handler wrapper — rc=143 (SIGTERM) closes the window like a
+     clean exit; any other non-zero rc still leaves it open for debugging.
+
+Safety invariants (commander conditions):
+  - NEVER kill a session the human opened by hand (`claude --resume` in a
+    plain tab): discovery only matches `meshcode run <target>` cmdlines or
+    direct children of the target's own launcher .command.
+  - Token-safe target matching: 'back' must never match 'back-2'.
+
+No live DB or processes needed: pure-function tests with subprocess mocked,
+plus source-pattern checks (pattern of tests/test_security_regressions.py).
+
+Usage:
+    pytest tests/test_stop_ghost_terminal.py -v
+"""
+
+import inspect
+import re
+import sys
+import types
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from meshcode import hostd, protocol_handler  # noqa: E402
+
+
+def _code_only(func) -> str:
+    """Source of `func` with the docstring and #-comments stripped, so the
+    assertions below test the CODE, not prose that mentions the same names."""
+    src = inspect.getsource(func)
+    src = re.sub(r'""".*?"""', "", src, count=1, flags=re.DOTALL)
+    return "\n".join(ln.split("#", 1)[0] for ln in src.splitlines())
+
+
+# ---------------------------------------------------------------------------
+# 1. Launcher-child discovery (the execvp'd-claude hole)
+# ---------------------------------------------------------------------------
+
+# Shaped like real `ps -axo pid=,ppid=,args=` output from the live repro box:
+# back-2 ghost tree + a SIBLING agent 'back' launcher (prefix trap) + a claude
+# the human opened by hand in a plain zsh tab (must NEVER be discovered).
+_FAKE_PS = """\
+26061 26060 login -pf user
+26075 26061 /bin/bash /Users/u/.meshcode/launchers/mesh-dev_back-2.command
+26078 26075 claude --dangerously-skip-permissions -- boot
+26140 26078 /usr/bin/python3 -m meshcode.meshcode_mcp serve
+30001 26061 /bin/bash /Users/u/.meshcode/launchers/mesh-dev_back.command
+30002 30001 claude --dangerously-skip-permissions -- boot
+40001 40000 -zsh
+40002 40001 claude --resume abc123
+50001 50000 vim notes.txt
+"""
+
+
+def _patch_ps(monkeypatch, stdout=_FAKE_PS):
+    def fake_run(cmd, **kw):
+        assert cmd[0] == "ps", f"unexpected subprocess in discovery: {cmd}"
+        return types.SimpleNamespace(stdout=stdout, returncode=0)
+    monkeypatch.setattr(hostd.subprocess, "run", fake_run)
+
+
+class TestLauncherChildDiscovery:
+    def test_finds_claude_child_of_target_launcher(self, monkeypatch):
+        _patch_ps(monkeypatch)
+        assert hostd._discover_launcher_child_pids("mesh-dev/back-2") == [26078]
+
+    def test_token_safe_back_does_not_match_back2(self, monkeypatch):
+        _patch_ps(monkeypatch)
+        # 'mesh-dev/back' must resolve to ITS OWN launcher child (30002),
+        # never to back-2's tree — the 24e3dd44 prefix-kill class of bug.
+        assert hostd._discover_launcher_child_pids("mesh-dev/back") == [30002]
+
+    def test_never_matches_hand_opened_claude_resume(self, monkeypatch):
+        _patch_ps(monkeypatch)
+        for target in ("mesh-dev/back-2", "mesh-dev/back"):
+            kids = hostd._discover_launcher_child_pids(target)
+            assert 40002 not in kids, "human `claude --resume` session would be killed!"
+
+    def test_grandchild_mcp_serve_not_returned(self, monkeypatch):
+        # SIGTERM goes to the claude child only; the mcp-serve grandchild exits
+        # with its stdio. Returning it would double-kill into the wrong layer.
+        _patch_ps(monkeypatch)
+        assert 26140 not in hostd._discover_launcher_child_pids("mesh-dev/back-2")
+
+    def test_empty_on_ps_failure(self, monkeypatch):
+        def boom(cmd, **kw):
+            raise OSError("no ps")
+        monkeypatch.setattr(hostd.subprocess, "run", boom)
+        assert hostd._discover_launcher_child_pids("mesh-dev/back-2") == []
+
+    def test_discover_agent_pids_includes_launcher_children(self, monkeypatch):
+        """_discover_agent_pids (used by _do_stops/_do_force_kills/_do_reap too)
+        must now see the execvp'd claude via the launcher path."""
+        def fake_run(cmd, **kw):
+            if cmd[0] == "pgrep":          # old path: nothing post-execvp
+                return types.SimpleNamespace(stdout="", returncode=1)
+            return types.SimpleNamespace(stdout=_FAKE_PS, returncode=0)
+        monkeypatch.setattr(hostd.subprocess, "run", fake_run)
+        assert 26078 in hostd._discover_agent_pids("mesh-dev/back-2")
+
+
+# ---------------------------------------------------------------------------
+# 2. _term_ghost_pid kill semantics
+# ---------------------------------------------------------------------------
+
+class TestTermGhostPid:
+    def test_no_killpg_ever(self):
+        """killpg would take the launcher bash down with the agent — the bash must
+        survive to see rc=143 and close its own window."""
+        assert "killpg" not in _code_only(hostd._term_ghost_pid)
+
+    def test_skips_unreadable_or_mismatched_cmdline(self, monkeypatch):
+        monkeypatch.setattr(hostd, "_pid_cmdline", lambda p: "")
+        sent = []
+        monkeypatch.setattr(hostd.os, "kill", lambda *a: sent.append(a))
+        monkeypatch.setattr(hostd.sys, "platform", "darwin")
+        assert hostd._term_ghost_pid("mesh-dev/back-2", 12345) is False
+        assert sent == [], "killed a pid whose cmdline could not be verified"
+
+    def test_sigterm_then_done_when_process_exits(self, monkeypatch):
+        monkeypatch.setattr(hostd.sys, "platform", "darwin")
+        monkeypatch.setattr(hostd, "_pid_cmdline",
+                            lambda p: "claude --dangerously-skip-permissions -- boot")
+        monkeypatch.setattr(hostd.time, "sleep", lambda s: None)
+        monkeypatch.setattr(hostd, "_kill_heartbeat_fork", lambda t: None)
+        calls = []
+
+        def fake_kill(pid, sig):
+            calls.append((pid, sig))
+            if sig == 0:                       # liveness probe: already gone
+                raise ProcessLookupError()
+        monkeypatch.setattr(hostd.os, "kill", fake_kill)
+        assert hostd._term_ghost_pid("mesh-dev/back-2", 26078) is True
+        assert (26078, hostd._signal.SIGTERM) in calls
+        assert (26078, hostd._signal.SIGKILL) not in calls
+
+
+# ---------------------------------------------------------------------------
+# 3. Ghost sweep gating + loop wiring (source checks)
+# ---------------------------------------------------------------------------
+
+class TestGhostSweep:
+    SRC = None
+
+    @classmethod
+    def setup_class(cls):
+        cls.SRC = _code_only(hostd._do_stopped_ghost_sweep)
+
+    def test_only_desired_state_stopped(self):
+        assert '"stopped"' in self.SRC and "desired_state" in self.SRC
+
+    def test_fresh_heartbeat_left_to_rpc_sweeps(self):
+        # < 90s heartbeat = the cooperative must_exit / RPC kill paths own it.
+        assert re.search(r"heartbeat_age_s", self.SRC) and "90" in self.SRC
+
+    def test_uses_roster_not_heartbeat_gated_rpc(self):
+        assert "mc_host_config_get" in self.SRC
+        assert "mc_agents_to_stop" not in self.SRC
+
+    def test_wired_into_poll_loop(self):
+        full = Path(hostd.__file__).read_text(encoding="utf-8", errors="replace")
+        m = re.search(r"_do_stopped_ghost_sweep\(api_key,\s*host_id\)", full)
+        assert m, "_do_stopped_ghost_sweep is defined but never called in the poll loop"
+
+    def test_sweep_runs_dead_window_reap(self):
+        assert "_close_dead_terminal_windows" in self.SRC
+
+
+# ---------------------------------------------------------------------------
+# 4. Wrapper rc=143 clean-close
+# ---------------------------------------------------------------------------
+
+class TestWrapperRc143:
+    SRC = None
+
+    @classmethod
+    def setup_class(cls):
+        cls.SRC = Path(protocol_handler.__file__).read_text(encoding="utf-8",
+                                                            errors="replace")
+
+    def test_close_condition_accepts_0_and_143(self):
+        m = re.search(r"lines\.append\('if (.+?)'\)", self.SRC)
+        assert m, "wrapper close-condition line not found"
+        cond = m.group(1)
+        assert '"$MC_RC" = "0"' in cond
+        assert '"$MC_RC" = "143"' in cond
+
+    def test_other_nonzero_rcs_stay_open(self):
+        m = re.search(r"lines\.append\('if (.+?)'\)", self.SRC)
+        cond = m.group(1)
+        # Only the two literal values may close the window — no wildcard/negation.
+        assert "!=" not in cond and "-ne" not in cond
+        assert re.findall(r'"\$MC_RC" = "(\d+)"', cond) == ["0", "143"]