meshcode 2.11.126__tar.gz → 2.11.128__tar.gz

{meshcode-2.11.126 → meshcode-2.11.128}/PKG-INFO

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

{meshcode-2.11.126 → meshcode-2.11.128}/meshcode/__init__.py

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

{meshcode-2.11.126 → meshcode-2.11.128}/meshcode/hostd.py

@@ -1051,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
@@ -1165,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.
@@ -2017,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.126 → meshcode-2.11.128}/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.126 → meshcode-2.11.128}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.126 → meshcode-2.11.128}/meshcode.egg-info/SOURCES.txt

@@ -74,6 +74,7 @@ tests/test_file_upload.py
 tests/test_init_device_code.py
 tests/test_install_guard.py
 tests/test_lease_sigterm_release.py
+tests/test_live_mesh_guard.py
 tests/test_mark_read_batch.py
 tests/test_marketplace_ratings.py
 tests/test_migration_integrity.py
@@ -90,5 +91,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.126 → meshcode-2.11.128}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.11.126"
+version = "2.11.128"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}
@@ -45,6 +45,14 @@ Repository = "https://github.com/rf2f7f7sg4-dev/meshcode"
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "--durations=10 --durations-min=0.5 -v --tb=short"
+markers = [
+    # live_mesh: the test talks to the REAL Supabase backend (registers agents,
+    # sends messages, reads the live roster). Opt-in via MESHCODE_TEST_PROJECT;
+    # CI/smoke must deselect with: -m "not live_mesh"
+    # (incident 2026-06-10: suite runs leaked 30 fixture agents into the live
+    # mesh-dev roster on Ian's dashboard).
+    "live_mesh: hits the real Supabase backend/live mesh; opt-in, deselect with -m 'not live_mesh'",
+]
 
 [tool.setuptools.packages.find]
 include = ["meshcode", "meshcode.*"]

{meshcode-2.11.126 → meshcode-2.11.128}/tests/test_boot_bug_regression.py

@@ -131,6 +131,7 @@ def test_module_import_rpc_allowlist():
     )
 
 
+@pytest.mark.live_mesh
 def test_register_all_valid_statuses_live():
     """RC #1 sentinel — mig 312. Catches SDK↔DDL enum drift like the
     'needs_launch' incident.

{meshcode-2.11.126 → meshcode-2.11.128}/tests/test_cross_agent_messaging.py

@@ -21,6 +21,14 @@ import time
 import unittest
 from pathlib import Path
 
+import pytest
+
+# These tests register agents and send messages on the REAL backend — every
+# run is visible on the owner's dashboard. Opt-in only (incident 2026-06-10:
+# fixture agents leaked into the live mesh-dev roster). Deselect in CI/smoke
+# with: -m "not live_mesh"
+pytestmark = pytest.mark.live_mesh
+
 # Add SDK to path
 SDK_PATH = Path(__file__).parent.parent / "meshcode" / "meshcode_mcp"
 if SDK_PATH.exists():
@@ -39,7 +47,10 @@ from meshcode.meshcode_mcp import backend as be
 # Agents are cleaned up in tearDown. No project creation needed.
 #
 
-TEST_PROJECT = os.environ.get("MESHCODE_TEST_PROJECT", "mesh-dev")
+# NEVER default to a live mesh. Unset MESHCODE_TEST_PROJECT = SKIP everything:
+# the old default ("mesh-dev") put every fixture agent and broadcast of this
+# suite straight onto the production dashboard (incident 2026-06-10).
+TEST_PROJECT = os.environ.get("MESHCODE_TEST_PROJECT")
 AGENT_A = f"e2e-alice-{int(time.time()) % 10000}"
 AGENT_B = f"e2e-bob-{int(time.time()) % 10000}"
 AGENT_C = f"e2e-carol-{int(time.time()) % 10000}"
@@ -61,6 +72,10 @@ def _get_api_key():
 API_KEY = _get_api_key()
 
 
+@unittest.skipUnless(
+    TEST_PROJECT,
+    "MESHCODE_TEST_PROJECT not set — live-mesh e2e tests are opt-in and must "
+    "point at a dedicated test meshwork, never a live one (incident 2026-06-10)")
 class CrossAgentMessagingTests(unittest.TestCase):
     """E2E tests for cross-agent message delivery."""
 
@@ -106,16 +121,25 @@ class CrossAgentMessagingTests(unittest.TestCase):
 
     @classmethod
     def tearDownClass(cls):
-        """Cleanup: unregister ephemeral test agents."""
+        """Cleanup: unregister ephemeral test agents. LOUD on failure — the old
+        except:pass (plus never checking sb_rpc's returned error dict) let a
+        404 on mc_unregister_agent leak fixture agents into the roster forever
+        (incident 2026-06-10)."""
+        failures = []
         for agent in [AGENT_A, AGENT_B, AGENT_C]:
-            try:
-                be.sb_rpc("mc_unregister_agent", {
-                    "p_api_key": API_KEY,
-                    "p_project_id": cls.project_id,
-                    "p_agent_name": agent,
-                })
-            except Exception:
-                pass
+            result = be.sb_rpc("mc_unregister_agent", {
+                "p_api_key": API_KEY,
+                "p_project_id": cls.project_id,
+                "p_agent_name": agent,
+            })
+            # sb_rpc reports errors as a return VALUE, not an exception.
+            if isinstance(result, dict) and (result.get("error") or result.get("_error")):
+                failures.append(f"{agent}: {result}")
+        if failures:
+            raise AssertionError(
+                "tearDown could not unregister test agents — they are now "
+                f"ORPHANED in '{TEST_PROJECT}' and must be removed by hand:\n  "
+                + "\n  ".join(failures))
         print(f"\n  Cleaned up test agents from {TEST_PROJECT}")
 
     # ── Basic Delivery ─────────────────────────────────────────────────────

{meshcode-2.11.126 → meshcode-2.11.128}/tests/test_epistemic_v1_stop_conditions.py

@@ -33,6 +33,7 @@ def _live_or_skip():
         pytest.skip("MESHCODE_SUPABASE_URL not set; epistemic V1 health is live-only.")
 
 
+@pytest.mark.live_mesh
 def test_epistemic_v1_health_all_conditions_healthy():
     """Live check: call mc_epistemic_v1_health() and assert each is_healthy."""
     _live_or_skip()

{meshcode-2.11.126 → meshcode-2.11.128}/tests/test_esc_deaf_state.py

@@ -20,6 +20,8 @@ import os
 import sys
 import time
 import unittest
+
+import pytest
 from pathlib import Path
 from unittest.mock import patch, MagicMock, AsyncMock
 
@@ -196,8 +198,12 @@ class TestCircuitBreakerAfterCancel(unittest.TestCase):
         # Not a hard failure — pool may recover via other means
 
 
+@pytest.mark.live_mesh
 class TestBackendOperationsAfterCancel(unittest.TestCase):
-    """Test that backend send/read work after simulated interrupt state."""
+    """Test that backend send/read work after simulated interrupt state.
+
+    live_mesh: test_06 reads count_pending against the REAL backend with the
+    keyring credential (read-only, but still a live-DB dependency)."""
 
     def test_06_send_message_after_cb_reset(self):
         """send_message should work even if circuit breaker was previously open."""

meshcode-2.11.128/tests/test_live_mesh_guard.py

@@ -0,0 +1,100 @@
+"""
+Live-Mesh Guard Regression Tests
+=================================
+Enforces the suite-wide rules from incident 2026-06-10 (30 fixture agents +
+broadcast/impersonation spam leaked into the LIVE mesh-dev roster on the
+owner's dashboard because e2e tests defaulted TEST_PROJECT to "mesh-dev" and
+their teardown swallowed a 404 on a nonexistent RPC):
+
+  1. No test may DEFAULT its target project to a live mesh — the project must
+     come from MESHCODE_TEST_PROJECT with no fallback value.
+  2. Any test file that registers agents on the real backend must carry the
+     `live_mesh` pytest marker so CI/smoke can deselect with -m "not live_mesh".
+  3. mc_unregister_agent teardowns must CHECK the sb_rpc result (errors come
+     back as a return value, not an exception) — no silent leaks.
+  4. The live_mesh marker stays registered in pyproject.toml.
+
+Source-parsing only (pattern of test_security_regressions.py) — no DB needed.
+
+Usage:
+    pytest tests/test_live_mesh_guard.py -v
+"""
+
+import re
+from pathlib import Path
+
+TESTS_DIR = Path(__file__).parent
+PYPROJECT = TESTS_DIR.parent / "pyproject.toml"
+THIS_FILE = Path(__file__).name
+
+
+def _test_sources():
+    for f in sorted(TESTS_DIR.glob("test_*.py")):
+        if f.name == THIS_FILE:
+            continue
+        yield f.name, f.read_text(errors="replace")
+
+
+def _code_lines(src: str):
+    """Lines with #-comments stripped (docstring prose is still included, so
+    the patterns below target call/assignment syntax, not bare words)."""
+    return [ln.split("#", 1)[0] for ln in src.splitlines()]
+
+
+class TestNoLiveMeshDefaults:
+    def test_no_default_value_for_test_project_env(self):
+        """os.environ.get("MESHCODE_TEST_PROJECT", <default>) is forbidden —
+        unset must mean SKIP, never a fallback mesh."""
+        rx = re.compile(r"""MESHCODE_TEST_PROJECT['"]\s*,""")
+        offenders = [name for name, src in _test_sources()
+                     for ln in _code_lines(src) if rx.search(ln)]
+        assert not offenders, (
+            f"MESHCODE_TEST_PROJECT must have NO default value (incident "
+            f"2026-06-10) — offenders: {offenders}")
+
+    def test_no_hardcoded_live_project_assignment(self):
+        """A module-level <X>PROJECT = "mesh-dev" (or any literal) hardcodes a
+        live mesh as the test target."""
+        rx = re.compile(r"""^\s*\w*PROJECT\s*=\s*['"][a-zA-Z]""")
+        offenders = [name for name, src in _test_sources()
+                     for ln in _code_lines(src) if rx.search(ln)]
+        assert not offenders, (
+            f"Test project names must come from MESHCODE_TEST_PROJECT, never "
+            f"a literal — offenders: {offenders}")
+
+
+class TestLiveMeshMarker:
+    def test_agent_registering_files_carry_marker(self):
+        """Every file that calls mc_register_agent against the real backend
+        (i.e. without mocking sb_rpc) must be deselectable via the marker."""
+        for name, src in _test_sources():
+            code = "\n".join(_code_lines(src))
+            registers = re.search(r"""sb_rpc\(\s*['"]mc_register_agent['"]""", code)
+            mocked = re.search(r"patch.*sb_rpc|sb_rpc\s*=|monkeypatch", code)
+            if registers and not mocked:
+                assert re.search(r"pytestmark\s*=\s*pytest\.mark\.live_mesh", code), (
+                    f"{name} registers agents on the live backend but has no "
+                    f"module-level `pytestmark = pytest.mark.live_mesh`")
+
+    def test_marker_registered_in_pyproject(self):
+        cfg = PYPROJECT.read_text(errors="replace")
+        assert re.search(r"live_mesh\s*:", cfg), (
+            "live_mesh marker must stay registered under "
+            "[tool.pytest.ini_options] markers in pyproject.toml")
+
+
+class TestLoudTeardown:
+    def test_unregister_results_are_checked(self):
+        """sb_rpc returns errors as a dict, not an exception — every
+        mc_unregister_agent caller must inspect the result."""
+        for name, src in _test_sources():
+            code = "\n".join(_code_lines(src))
+            if "mc_unregister_agent" not in code:
+                continue
+            # The call's result must be bound and error-checked.
+            assert re.search(r"=\s*be\.sb_rpc\(\s*['\"]mc_unregister_agent", code), (
+                f"{name}: mc_unregister_agent result is discarded — a 404 "
+                f"would silently leak fixture agents (incident 2026-06-10)")
+            assert re.search(r"""\.get\(\s*['"](_)?error['"]""", code), (
+                f"{name}: mc_unregister_agent result is never checked for an "
+                f"error key")

{meshcode-2.11.126 → meshcode-2.11.128}/tests/test_mark_read_batch.py

@@ -18,10 +18,17 @@ import time
 import unittest
 from pathlib import Path
 
+import pytest
+
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 os.environ.setdefault("SUPABASE_URL", "https://gjinagyyjttyxnaoavnz.supabase.co")
 
+# Registers agents and sends messages on the REAL backend — opt-in only
+# (incident 2026-06-10: mread-* fixtures leaked into the live mesh-dev
+# roster). Deselect in CI/smoke with: -m "not live_mesh"
+pytestmark = pytest.mark.live_mesh
+
 
 def _get_api_key():
     key = os.environ.get("MESHCODE_API_KEY")
@@ -36,9 +43,16 @@ def _get_api_key():
 
 
 API_KEY = _get_api_key()
-PROJECT = "mesh-dev"
+# NEVER default to a live mesh (the old hardcoded "mesh-dev" put mread-*
+# fixtures on the production dashboard). Unset = tests SKIP.
+PROJECT = os.environ.get("MESHCODE_TEST_PROJECT")
 PROJECT_ID = None
 
+_LIVE_GATE = unittest.skipUnless(
+    API_KEY and PROJECT,
+    "MESHCODE_TEST_PROJECT (and an API key) required — live-mesh tests are "
+    "opt-in and must point at a dedicated test meshwork (incident 2026-06-10)")
+
 
 def _resolve():
     global PROJECT_ID
@@ -57,7 +71,7 @@ AGENT_A = f"mread-a-{int(time.time()) % 10000}"
 AGENT_B = f"mread-b-{int(time.time()) % 10000}"
 
 
-@unittest.skipUnless(API_KEY, "No API key — skipping live tests")
+@_LIVE_GATE
 class TestBatchMarkRead(unittest.TestCase):
 
     @classmethod
@@ -77,16 +91,25 @@ class TestBatchMarkRead(unittest.TestCase):
 
     @classmethod
     def tearDownClass(cls):
+        # LOUD on failure — the old except:pass (plus never checking sb_rpc's
+        # returned error dict) let a 404 on mc_unregister_agent leak mread-*
+        # fixtures into the roster forever (incident 2026-06-10).
         from meshcode.meshcode_mcp import backend as be
+        failures = []
         for name in [AGENT_A, AGENT_B]:
-            try:
-                be.sb_rpc("mc_unregister_agent", {
-                    "p_api_key": API_KEY,
-                    "p_project_id": cls.pid,
-                    "p_agent_name": name,
-                })
-            except Exception:
-                pass
+            result = be.sb_rpc("mc_unregister_agent", {
+                "p_api_key": API_KEY,
+                "p_project_id": cls.pid,
+                "p_agent_name": name,
+            })
+            # sb_rpc reports errors as a return VALUE, not an exception.
+            if isinstance(result, dict) and (result.get("error") or result.get("_error")):
+                failures.append(f"{name}: {result}")
+        if failures:
+            raise AssertionError(
+                "tearDown could not unregister test agents — they are now "
+                f"ORPHANED in '{PROJECT}' and must be removed by hand:\n  "
+                + "\n  ".join(failures))
 
     def test_01_batch_mark_read(self):
         """Send 5 messages, read_inbox marks all read in one call."""
@@ -129,7 +152,7 @@ class TestBatchMarkRead(unittest.TestCase):
         self.assertEqual(count, 0, f"Pending should be 0 after mark_read, got {count}")
 
 
-@unittest.skipUnless(API_KEY, "No API key — skipping live tests")
+@_LIVE_GATE
 class TestEffectiveStatusIntegration(unittest.TestCase):
     """Live integration test for mc_agent_effective_status."""
 

{meshcode-2.11.126 → meshcode-2.11.128}/tests/test_rls_cross_tenant.py

@@ -17,10 +17,17 @@ import time
 import unittest
 from pathlib import Path
 
+import pytest
+
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 os.environ.setdefault("SUPABASE_URL", "https://gjinagyyjttyxnaoavnz.supabase.co")
 
+# Sends real messages (incl. impersonation probes a human can see on the
+# dashboard) against the REAL backend — opt-in only (incident 2026-06-10).
+# Deselect in CI/smoke with: -m "not live_mesh"
+pytestmark = pytest.mark.live_mesh
+
 
 def _get_api_key():
     key = os.environ.get("MESHCODE_API_KEY")
@@ -35,11 +42,18 @@ def _get_api_key():
 
 
 API_KEY = _get_api_key()
-# Use mesh-dev as the "own" project
-OWN_PROJECT = "mesh-dev"
+# NEVER default to a live mesh (the old hardcoded "mesh-dev" sent the
+# impersonation probes of this file to the production dashboard). Unset =
+# tests SKIP.
+OWN_PROJECT = os.environ.get("MESHCODE_TEST_PROJECT")
 OWN_PROJECT_ID = None
 FAKE_PROJECT_ID = "00000000-0000-0000-0000-000000000000"
 
+_LIVE_GATE = unittest.skipUnless(
+    API_KEY and OWN_PROJECT,
+    "MESHCODE_TEST_PROJECT (and an API key) required — live-mesh tests are "
+    "opt-in and must point at a dedicated test meshwork (incident 2026-06-10)")
+
 
 def _resolve_project():
     global OWN_PROJECT_ID
@@ -57,7 +71,7 @@ def _resolve_project():
     return OWN_PROJECT_ID
 
 
-@unittest.skipUnless(API_KEY, "No API key — skipping live RLS tests")
+@_LIVE_GATE
 class TestCrossTenantIsolation(unittest.TestCase):
     """Agent in project X cannot access project Y data."""
 
@@ -135,7 +149,7 @@ class TestCrossTenantIsolation(unittest.TestCase):
             self.assertTrue(is_safe, f"Unexpected result: {result}")
 
 
-@unittest.skipUnless(API_KEY, "No API key — skipping live RLS tests")
+@_LIVE_GATE
 class TestImpersonation(unittest.TestCase):
     """Cannot impersonate another agent or user."""
 
@@ -202,7 +216,7 @@ class TestImpersonation(unittest.TestCase):
                         f"Empty API key should be rejected: {result}")
 
 
-@unittest.skipUnless(API_KEY, "No API key — skipping live RLS tests")
+@_LIVE_GATE
 class TestRPCErrorConsistency(unittest.TestCase):
     """All RPCs should return consistent error format."""
 

meshcode-2.11.128/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"]