meshcode 2.11.127__tar.gz → 2.11.129__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: meshcode
-Version: 2.11.127
+Version: 2.11.129
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -18,17 +18,8 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: mcp[cli]>=1.0.0
-Requires-Dist: websockets>=12.0
-Requires-Dist: realtime>=2.0.0
-Requires-Dist: keyring>=24.0
-Requires-Dist: cryptography>=41.0
 Provides-Extra: test
-Requires-Dist: pytest>=8; extra == "test"
 Provides-Extra: dev
-Requires-Dist: build>=1.0; extra == "dev"
-Requires-Dist: twine>=4; extra == "dev"
-Requires-Dist: pytest>=8; extra == "dev"
 
 # MeshCode
 

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

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

{meshcode-2.11.127 → meshcode-2.11.129}/meshcode/meshcode_mcp/backend.py

@@ -1327,6 +1327,17 @@ def task_complete(api_key, project_id, task_id, completing_agent, summary=""):
     })
 
 
+def feature_flag_enabled(api_key, flag_name):
+    """Agent-facing feature-flag check (mig478). The FE's mc_check_feature_flag
+    is auth.uid()-only, so agents use this api-key variant. Returns the raw
+    RPC dict ({"ok": true, "enabled": bool}); callers treat anything else as
+    disabled."""
+    return sb_rpc("mc_feature_flag_enabled", {
+        "p_api_key": api_key,
+        "p_flag_name": flag_name,
+    })
+
+
 # Per-(project,agent,session,event_type) min interval. Same idea as task_list:
 # fire-and-forget pollers that hammer record_event at >2/sec are throttled
 # client-side. Identical events within the window are dropped (returns

{meshcode-2.11.127 → meshcode-2.11.129}/meshcode/meshcode_mcp/server.py

@@ -609,16 +609,53 @@ import uuid as _uuid
 _SESSION_ID = str(_uuid.uuid4())[:12]
 
 
+# DB F2.1 (task 7f016375): tool_call events are 82% of mc_session_events
+# storage and their only dashboard consumer (session replay / timeline) is
+# gated behind the ff_session_replay feature flag — so the WRITE is gated by
+# the same flag. Feature-flag gate, NOT sampling (a partial replay lies when
+# debugging). ONLY 'tool_call' is gated; lifecycle events (boot/shutdown/
+# error/status_change) always record. ORTHOGONAL to the 2.11.33 M3a throttle
+# in backend.record_event: that one limits the RATE of whatever is enabled,
+# this one decides IF tool_call records at all. The flag is also enforced
+# server-side inside mc_record_event (mig488) — that covers old clients; this
+# client cache just saves the network call. Fail-closed: unknown flag state
+# records nothing (storage emergency beats replay completeness).
+_FF_REPLAY_TTL_SEC = 600.0  # re-check the flag every 10 min per process
+_ff_replay_cache = {"enabled": None, "checked_mono": 0.0}
+
+
+def _session_replay_enabled() -> bool:
+    """Cached ff_session_replay lookup. Runs INSIDE the bg record thread, so a
+    slow/failed flag fetch never adds latency to a tool call."""
+    now = _time.monotonic()
+    cache = _ff_replay_cache
+    if cache["enabled"] is None or now - cache["checked_mono"] >= _FF_REPLAY_TTL_SEC:
+        try:
+            res = be.feature_flag_enabled(_get_api_key(), "ff_session_replay")
+            cache["enabled"] = bool(isinstance(res, dict) and res.get("enabled"))
+        except Exception:
+            # Keep the last known answer; with no answer yet, fail closed.
+            if cache["enabled"] is None:
+                cache["enabled"] = False
+        cache["checked_mono"] = now
+    return cache["enabled"]
+
+
 def _record_event_bg(event_type: str, payload: dict = None) -> None:
-    """Fire-and-forget: record a session event in background thread."""
+    """Fire-and-forget: record a session event in background thread.
+    'tool_call' events are dropped while ff_session_replay is off (task
+    7f016375); every other event type records unconditionally."""
     try:
         api_key = _get_api_key()
         import threading
-        threading.Thread(
-            target=be.record_event,
-            args=(api_key, _PROJECT_ID, AGENT_NAME, _SESSION_ID, event_type, payload or {}),
-            daemon=True,
-        ).start()
+
+        def _record():
+            if event_type == "tool_call" and not _session_replay_enabled():
+                return
+            be.record_event(api_key, _PROJECT_ID, AGENT_NAME, _SESSION_ID,
+                            event_type, payload or {})
+
+        threading.Thread(target=_record, daemon=True).start()
     except Exception:
         pass
 

{meshcode-2.11.127 → meshcode-2.11.129}/meshcode/secrets.py

@@ -97,12 +97,45 @@ def _probe_keyring() -> bool:
         _KEYRING_BACKEND_NAME = type(backend).__name__
         # Some installs report a "fail" backend on headless Linux. Probe with a
         # write+read+delete round trip on a sentinel key.
-        sentinel_key = "meshcode_probe_sentinel"
+        # BUG 6b28a32f: the sentinel MUST be unique per process. With a fixed
+        # name, N concurrent CLIs (hostd respawn sweeps spawn up to 3 in the
+        # same second) race set/get/delete on the SAME wincred entry — the
+        # loser reads None (or its delete raises because a sibling already
+        # deleted it) and wrongly concludes the keychain is unusable, which
+        # cascades into "[meshcode] Not logged in" + a dead terminal tab.
+        # Fast path (race-immune): if we can READ an existing entry, the
+        # backend is proven usable — no write probe needed. The write probe
+        # below is only for fresh installs with no entry yet (interactive
+        # `meshcode login`, single process, no concurrency).
+        try:
+            if keyring.get_password(SERVICE_NAME, DEFAULT_PROFILE):
+                _KEYRING_AVAILABLE = True
+                return True
+        except Exception:
+            pass
+        sentinel_key = f"meshcode_probe_{os.getpid()}_{_stdlib_secrets.token_hex(4)}"
         sentinel_val = "ok"
         try:
+            import time as _time
             keyring.set_password(SERVICE_NAME, sentinel_key, sentinel_val)
-            got = keyring.get_password(SERVICE_NAME, sentinel_key)
-            keyring.delete_password(SERVICE_NAME, sentinel_key)
+            # Windows CredMan has read-after-write visibility lag under
+            # concurrent vault access (verified 6b28a32f: CredWrite succeeds,
+            # immediate CredRead misses, the entry IS there later). Retry the
+            # read-back briefly before declaring the backend unusable.
+            got = None
+            for _attempt in range(4):
+                got = keyring.get_password(SERVICE_NAME, sentinel_key)
+                if got == sentinel_val:
+                    break
+                _time.sleep(0.05 * (_attempt + 1))
+            for _attempt in range(2):
+                try:
+                    keyring.delete_password(SERVICE_NAME, sentinel_key)
+                    break
+                except Exception:
+                    # cleanup failure does not mean the backend is unusable;
+                    # one delayed retry keeps orphan sentinels out of the vault
+                    _time.sleep(0.05)
             _KEYRING_AVAILABLE = (got == sentinel_val)
         except KeyringError:
             _KEYRING_AVAILABLE = False
@@ -218,15 +251,22 @@ def get_api_key(profile: str = DEFAULT_PROFILE) -> Optional[str]:
     1. Keychain entry (SERVICE_NAME, profile)
     2. ~/.meshcode/credentials.<profile>.json (fallback file from set_api_key)
     3. ~/.meshcode/credentials.json (legacy pre-1.4.1 file, default profile only)
+
+    BUG 6b28a32f: READS are no longer gated on _probe_keyring(). The probe
+    does a write+read+delete round trip, which is only meaningful before a
+    WRITE (set_api_key) — gating reads on it meant any transient probe
+    failure (concurrent-CLI sentinel race, vault hiccup) skipped a perfectly
+    healthy keychain entry and fell through to fallback files that were
+    migrated-and-shredded, producing a false "Not logged in". Just try the
+    read; it is its own probe.
     """
-    if _probe_keyring():
-        try:
-            import keyring  # type: ignore
-            val = keyring.get_password(SERVICE_NAME, profile)
-            if val:
-                return val
-        except Exception:
-            pass
+    try:
+        import keyring  # type: ignore
+        val = keyring.get_password(SERVICE_NAME, profile)
+        if val:
+            return val
+    except Exception:
+        pass
 
     # Fallback file for this profile
     fallback_path = Path.home() / ".meshcode" / f"credentials.{profile}.json"

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: meshcode
-Version: 2.11.127
+Version: 2.11.129
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -18,17 +18,8 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: mcp[cli]>=1.0.0
-Requires-Dist: websockets>=12.0
-Requires-Dist: realtime>=2.0.0
-Requires-Dist: keyring>=24.0
-Requires-Dist: cryptography>=41.0
 Provides-Extra: test
-Requires-Dist: pytest>=8; extra == "test"
 Provides-Extra: dev
-Requires-Dist: build>=1.0; extra == "dev"
-Requires-Dist: twine>=4; extra == "dev"
-Requires-Dist: pytest>=8; extra == "dev"
 
 # MeshCode
 

{meshcode-2.11.127 → meshcode-2.11.129}/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
@@ -86,6 +87,7 @@ tests/test_run_agent_no_server_import.py
 tests/test_security_regressions.py
 tests/test_self_update_user_site.py
 tests/test_sentinel.py
+tests/test_session_replay_gate.py
 tests/test_setup_path.py
 tests/test_sleep_signals.py
 tests/test_status_enum_coverage.py

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.11.127"
+version = "2.11.129"
 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.127 → meshcode-2.11.129}/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.127 → meshcode-2.11.129}/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.127 → meshcode-2.11.129}/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.127 → meshcode-2.11.129}/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.129/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.127 → meshcode-2.11.129}/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.127 → meshcode-2.11.129}/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.129/tests/test_session_replay_gate.py

@@ -0,0 +1,153 @@
+"""
+Session-Replay tool_call Gate Tests (task 7f016375, DB F2.1)
+=============================================================
+tool_call events are 82% of mc_session_events storage; their only consumer
+(session replay / timeline) is feature-flagged. These tests pin the gate:
+
+  1. server.py: _record_event_bg drops 'tool_call' while ff_session_replay
+     is off, records it when on, and NEVER gates lifecycle events.
+  2. The flag lookup is cached (TTL) and fail-closed on first error.
+  3. mig478 SQL: mc_record_event gates ONLY tool_call; the flag seeds
+     disabled; the agent-facing flag RPC exists with grants.
+  4. The gate is a FLAG, not sampling — no random() anywhere in the path.
+
+Unit tests run fully offline (backend mocked). SQL checks parse migrations
+(pattern of test_security_regressions.py).
+
+Usage:
+    pytest tests/test_session_replay_gate.py -v
+"""
+
+import re
+import sys
+import time
+from pathlib import Path
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+MIGRATIONS_DIR = Path(__file__).parent.parent / "supabase" / "migrations"
+MIG478 = MIGRATIONS_DIR / "20260610_478_tool_call_replay_gate.sql"
+
+
+def _fresh_server():
+    """Import server with a clean flag cache. server.py is import-heavy but
+    side-effect-free at module level (asserted by test_boot_bug_regression)."""
+    from meshcode.meshcode_mcp import server
+    server._ff_replay_cache["enabled"] = None
+    server._ff_replay_cache["checked_mono"] = 0.0
+    return server
+
+
+def _run_record(server, event_type, flag_response):
+    """Call _record_event_bg with backend mocked; run the bg thread inline by
+    joining all threads it spawns. Returns the list of record_event calls."""
+    calls = []
+    import threading
+    started = []
+    orig_start = threading.Thread.start
+
+    def capture_start(self):
+        started.append(self)
+        orig_start(self)
+
+    with patch.object(server.be, "record_event",
+                      side_effect=lambda *a, **k: calls.append(a)), \
+         patch.object(server.be, "feature_flag_enabled",
+                      side_effect=flag_response), \
+         patch.object(server, "_get_api_key", return_value="mc_test_key"), \
+         patch.object(threading.Thread, "start", capture_start):
+        server._record_event_bg(event_type, {"tool": "x"})
+        for t in started:
+            t.join(timeout=5)
+    return calls
+
+
+class TestClientGate:
+    def test_tool_call_dropped_when_flag_off(self):
+        server = _fresh_server()
+        calls = _run_record(server, "tool_call",
+                            lambda *a: {"ok": True, "enabled": False})
+        assert calls == [], "tool_call recorded despite ff_session_replay off"
+
+    def test_tool_call_recorded_when_flag_on(self):
+        server = _fresh_server()
+        calls = _run_record(server, "tool_call",
+                            lambda *a: {"ok": True, "enabled": True})
+        assert len(calls) == 1 and calls[0][4] == "tool_call"
+
+    def test_lifecycle_events_never_gated(self):
+        for ev in ("boot", "shutdown", "error", "status_change"):
+            server = _fresh_server()
+
+            def explode(*a):
+                raise AssertionError(f"flag checked for lifecycle event {ev!r}")
+            calls = _run_record(server, ev, explode)
+            assert len(calls) == 1 and calls[0][4] == ev, (
+                f"lifecycle event {ev!r} must record unconditionally")
+
+    def test_fail_closed_on_first_flag_error(self):
+        server = _fresh_server()
+
+        def boom(*a):
+            raise OSError("network down")
+        calls = _run_record(server, "tool_call", boom)
+        assert calls == [], "flag fetch failure must fail CLOSED (no record)"
+
+    def test_flag_cached_within_ttl(self):
+        server = _fresh_server()
+        fetches = []
+
+        def counting(*a):
+            fetches.append(1)
+            return {"ok": True, "enabled": True}
+        _run_record(server, "tool_call", counting)
+        _run_record(server, "tool_call", counting)
+        assert len(fetches) == 1, (
+            f"flag fetched {len(fetches)}x within TTL — cache not working")
+
+    def test_no_sampling_anywhere(self):
+        """Commander condition 1: flag gate, NOT sampling."""
+        import inspect
+        from meshcode.meshcode_mcp import server
+        src = inspect.getsource(server._record_event_bg) + \
+            inspect.getsource(server._session_replay_enabled)
+        assert "random" not in src
+
+
+class TestMig478Sql:
+    SQL = None
+
+    @classmethod
+    def setup_class(cls):
+        cls.SQL = MIG478.read_text(errors="replace")
+
+    def test_gate_only_wraps_tool_call(self):
+        body = re.search(r"FUNCTION public\.mc_record_event.*?\$\$;", self.SQL,
+                         re.DOTALL).group(0)
+        gate = re.search(r"IF p_event_type = 'tool_call' THEN(.*?)END IF;",
+                         body, re.DOTALL)
+        assert gate, "tool_call gate missing from mc_record_event"
+        assert "ff_session_replay" in gate.group(1)
+        # The INSERT must be OUTSIDE the gate so other event types still write.
+        after_gate = body[body.index(gate.group(0)) + len(gate.group(0)):]
+        assert "INSERT INTO meshcode.mc_session_events" in after_gate
+
+    def test_flag_seeds_disabled(self):
+        seed = re.search(r"INSERT INTO meshcode\.mc_global_config.*?ON CONFLICT",
+                         self.SQL, re.DOTALL).group(0)
+        assert "'ff_session_replay'" in seed
+        assert '"enabled": false' in seed
+        assert "DO NOTHING" in self.SQL.split("ON CONFLICT", 1)[1][:30]
+
+    def test_flag_rpc_exists_with_grants(self):
+        assert "FUNCTION public.mc_feature_flag_enabled" in self.SQL
+        assert re.search(
+            r"GRANT EXECUTE ON FUNCTION public\.mc_feature_flag_enabled.*?TO anon",
+            self.SQL)
+
+    def test_backend_wrapper_targets_new_rpc(self):
+        from meshcode.meshcode_mcp import backend as be
+        import inspect
+        src = inspect.getsource(be.feature_flag_enabled)
+        assert "mc_feature_flag_enabled" in src