meshcode 2.11.4__tar.gz → 2.11.5__tar.gz

{meshcode-2.11.4 → meshcode-2.11.5}/PKG-INFO

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

{meshcode-2.11.4 → meshcode-2.11.5}/meshcode/__init__.py

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

{meshcode-2.11.4 → meshcode-2.11.5}/meshcode/meshcode_mcp/server.py

@@ -499,73 +499,18 @@ def _filter_and_mark(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     return out
 
 
-_SLEEP_PAYLOAD_TYPES = {"sleep", "go_to_sleep", "shutdown", "got_done", "done",
-                        "exit", "stop", "kill", "terminate"}
-# Multi-word imperative markers ONLY. Single Spanish verbs like "salir" /
-# "terminar" / "duerme" were too loose and caught idiomatic prose like
-# "terminaron sus tasks" or "no puedo salir" (msg cfbd36b0 2026-05-14 alexa +
-# commander incidents — feedback_done_signal_false_positive_idiomatic
-# precedent). The parser now requires a directive-shaped phrase: a verb
-# combined with a temporal/object qualifier ("ahora" / "todos" / "to sleep")
-# so describing an event in prose can't trip must_exit.
-_SLEEP_TEXT_MARKERS = (
-    # English directives
-    "go to sleep", "all sleep now", "sleep now", "got_done", "go_done",
-    "shut down", "shutdown", "stop now", "exit now",
-    # Spanish directives (es-MX, sammybenu's primary). All require either a
-    # leading "a"/"todos" or a trailing "ahora" so plain conjugations
-    # ("salir", "terminar", "duerme") in body prose don't trigger.
-    "a dormir", "todos a dormir", "duerme ahora", "duerman ahora",
-    "dormir ahora", "para la sesion", "exit y duerme",
+# Sleep-signal parsing lives in a separate pure module so it can be tested
+# without booting the full MCP server. Re-export the public surface here
+# for back-compat with any in-tree caller that imports from server.
+from .sleep_signals import (  # noqa: F401
+    _SLEEP_PAYLOAD_TYPES,
+    _SLEEP_TEXT_MARKERS,
+    _KNOWN_HUMAN_HANDLES,
+    _is_human_authored,
+    _looks_like_sleep_signal,
+    _split_messages,
 )
 
-
-def _looks_like_sleep_signal(m: Dict[str, Any]) -> bool:
-    """Detect commander broadcasts / DMs that authorize the wait-loop exit.
-
-    Catches three encodings (BE-S5.11): structured payload.type, top-level
-    text marker, and broadcast-with-sleep-type. Single source of truth so
-    every receive path (PRODUCT RULE 2 + inner _meshcode_wait_inner) routes
-    sleep authorizations into done_signals consistently.
-    """
-    pl = m.get("payload") or {}
-    if isinstance(pl, dict):
-        if str(pl.get("type", "")).lower() in _SLEEP_PAYLOAD_TYPES:
-            return True
-        if str(pl.get("directive", "")).lower() in _SLEEP_PAYLOAD_TYPES:
-            return True
-        text = str(pl.get("text", "")).lower()
-        if any(marker in text for marker in _SLEEP_TEXT_MARKERS):
-            return True
-    return False
-
-
-def _split_messages(messages: List[Dict[str, Any]]) -> Dict[str, Any]:
-    """Split a list of normalized message dicts into messages / acks / done_signals.
-
-    BE-S5.11: classify ANY message (including broadcasts) carrying a sleep
-    intent into done_signals so meshcode_wait surfaces them with the
-    must_exit flag. Previous logic only matched type='done' literally,
-    which the broadcast path could never produce.
-    """
-    real: List[Dict[str, Any]] = []
-    acks: List[Dict[str, Any]] = []
-    dones: List[Dict[str, Any]] = []
-    for m in messages:
-        t = m.get("type", "msg")
-        if t == "ack":
-            acks.append(m)
-        elif t == "done" or _looks_like_sleep_signal(m):
-            dones.append(m)
-        else:
-            real.append(m)
-    return {
-        "messages": real,
-        "acks": acks,
-        "done_signals": dones,
-        "count": len(real),
-    }
-
 from . import backend as be
 from .realtime import RealtimeListener
 
@@ -1718,8 +1663,26 @@ def _orphan_watchdog_fn():
                 # Parent exited (or boot was already orphaned). Confirm with
                 # stdin peer probe to avoid killing intentional daemons.
                 if _BOOT_PPID != 1 or _stdin_peer_dead():
+                    # 2s confirmation grace before os._exit(0). Without this,
+                    # a transient ppid/stdin race (FastMCP stdio fd duplication,
+                    # brief reparent during macOS process-group shuffles) can
+                    # false-positive and kill an actively-attached MCP — observed
+                    # mode-b of fe57b7a5 (mid-session crash after ~10min normal
+                    # ops, Samuel 2026-05-14T19:31Z mesh-commander session).
+                    # We accept a +2s detection latency for legitimate orphans;
+                    # the heartbeat-path orphan check at line ~1798 still catches
+                    # them within one heartbeat tick (5-15s).
+                    _orphan_watchdog_stop.wait(2)
+                    if _orphan_watchdog_stop.is_set():
+                        break
+                    if os.getppid() != 1 or not (_BOOT_PPID != 1 or _stdin_peer_dead()):
+                        log.info(
+                            f"orphan watchdog: transient ppid==1 cleared after "
+                            f"2s grace (ppid_now={os.getppid()}) — continuing"
+                        )
+                        continue
                     log.warning(
-                        f"orphan watchdog: parent gone "
+                        f"orphan watchdog: parent gone (confirmed after 2s grace) "
                         f"(boot_ppid={_BOOT_PPID} → ppid=1, "
                         f"stdin_peer_dead={_stdin_peer_dead()}) — "
                         f"force-exiting MCP for {AGENT_NAME}"
@@ -1852,18 +1815,34 @@ def _heartbeat_loop_inner():
                         and os.getppid() == 1):
                     _orphan = (_BOOT_PPID != 1) or _stdin_peer_dead()
                     if _orphan:
-                        log.warning(
-                            f"parent process exited (boot_ppid={_BOOT_PPID} → "
-                            f"current_ppid=1, stdin_peer_dead={_BOOT_PPID == 1}) "
-                            f"— orphan MCP for {AGENT_NAME}, releasing lease "
-                            f"and exiting"
-                        )
-                        try:
-                            _release_lease()
-                        except Exception:
-                            pass
-                        _heartbeat_stop.set()
-                        os._exit(0)
+                        # 2s confirmation grace — same rationale as the
+                        # orphan_watchdog above (fe57b7a5 mode-b). Heartbeat
+                        # ticks every 5-15s, so adding 2s here trades minimal
+                        # detection latency for false-positive resistance.
+                        _heartbeat_stop.wait(2)
+                        if _heartbeat_stop.is_set():
+                            break
+                        if os.getppid() != 1 or not ((_BOOT_PPID != 1) or _stdin_peer_dead()):
+                            log.info(
+                                f"heartbeat orphan check: transient ppid==1 "
+                                f"cleared after 2s grace (ppid_now={os.getppid()}) "
+                                f"— continuing"
+                            )
+                        else:
+                            log.warning(
+                                f"parent process exited "
+                                f"(confirmed after 2s grace) "
+                                f"(boot_ppid={_BOOT_PPID} → "
+                                f"current_ppid=1, stdin_peer_dead={_BOOT_PPID == 1}) "
+                                f"— orphan MCP for {AGENT_NAME}, releasing lease "
+                                f"and exiting"
+                            )
+                            try:
+                                _release_lease()
+                            except Exception:
+                                pass
+                            _heartbeat_stop.set()
+                            os._exit(0)
             except Exception:
                 pass
 
@@ -2064,65 +2043,67 @@ async def lifespan(_app):
             log.warning(f"initial heartbeat attempt {_attempt+1} failed: {e}")
             import time; time.sleep(2)
 
-    # Per-agent persona (BE-S4.1.sdk / mig 232): tone/voice/policy that
-    # shapes how the agent talks. Loaded once per session; soft-fail if the
-    # RPC is unavailable on older projects.
-    global _PERSONA
-    try:
-        _persona_resp = be.sb_rpc("mc_agent_persona", {
-            "p_api_key": _get_api_key(),
-            "p_project_id": _PROJECT_ID,
-            "p_agent_name": AGENT_NAME,
-        })
-        if isinstance(_persona_resp, dict) and _persona_resp.get("ok"):
-            _PERSONA = _persona_resp.get("persona") or {}
-            log.info(
-                f"[meshcode] persona loaded: tone={_PERSONA.get('tone','default')} "
-                f"language={_PERSONA.get('language','en')} "
-                f"reply_max_tokens={_PERSONA.get('reply_max_tokens','unset')}"
-            )
-        else:
-            log.debug(f"persona load returned non-ok: {_persona_resp} — continuing without")
-    except Exception as e:
-        log.debug(f"persona RPC unavailable ({e}) — continuing without")
-
-    # Boot-context bundle (S1-2.F2 / mig 217): single RPC returns last_seen
-    # + recent msgs + open tasks + relevant memories + peer state. Cached on
-    # the module global so the first ~30s of tool calls can short-circuit.
-    # Soft-fail: if the RPC isn't deployed (older project) or errors, log
-    # warn + continue with the legacy lazy-load path.
-    global _BOOT_CONTEXT_BUNDLE, _BOOT_CONTEXT_AT
-    try:
-        _ctx = be.sb_rpc("mc_agent_boot_context", {
-            "p_api_key": _get_api_key(),
-            "p_project_id": _PROJECT_ID,
-            "p_agent_name": AGENT_NAME,
-        })
-        if isinstance(_ctx, dict) and _ctx.get("ok"):
-            _BOOT_CONTEXT_BUNDLE = _ctx
-            _BOOT_CONTEXT_AT = _time.time()
-            log.info(
-                f"[meshcode] boot_context: "
-                f"{len(_ctx.get('recent_msgs', []))} unread, "
-                f"{len(_ctx.get('open_tasks', []))} open tasks, "
-                f"{len(_ctx.get('relevant_memories', []))} memories surfaced"
-            )
-        else:
-            # Defense-in-depth: if the failure is a missing GRANT (mig
-            # 270 regressed or older project), the legacy lazy-load
-            # path already fills the gap. WARN puts a stderr line that
-            # some Claude Code versions surface as "MCP server failed
-            # at launch". Downgrade only the GRANT case; other non-ok
-            # responses still warn.
-            if _is_grant_or_permission_error(_ctx):
-                log.debug(f"boot_context permission_denied (legacy boot ok): {_ctx}")
+    # fe57b7a5 mode-a fix (2026-05-14): mc_agent_persona + mc_agent_boot_context
+    # used to run synchronously here, adding ~1-4s to lifespan pre-yield latency.
+    # Combined with the module-import RPCs (3-15s), commanders with large
+    # _INSTRUCTIONS payloads + many memories exceeded Claude Code's MCP
+    # handshake window under congestion → "MCP failed at launch". Both RPCs
+    # produce module globals (_PERSONA, _BOOT_CONTEXT_BUNDLE) consumed lazily
+    # by tools that already have soft-fail fallbacks, so deferring them into
+    # a daemon thread is safe — first reads within ~1s after lifespan yield
+    # may see None, in which case consumers fall back to live RPC paths.
+    global _PERSONA, _BOOT_CONTEXT_BUNDLE, _BOOT_CONTEXT_AT
+
+    def _load_persona_bg():
+        global _PERSONA
+        try:
+            _persona_resp = be.sb_rpc("mc_agent_persona", {
+                "p_api_key": _get_api_key(),
+                "p_project_id": _PROJECT_ID,
+                "p_agent_name": AGENT_NAME,
+            })
+            if isinstance(_persona_resp, dict) and _persona_resp.get("ok"):
+                _PERSONA = _persona_resp.get("persona") or {}
+                log.info(
+                    f"[meshcode] persona loaded (bg): tone={_PERSONA.get('tone','default')} "
+                    f"language={_PERSONA.get('language','en')} "
+                    f"reply_max_tokens={_PERSONA.get('reply_max_tokens','unset')}"
+                )
             else:
-                log.warning(f"boot_context returned non-ok: {_ctx} — continuing legacy boot")
-    except Exception as e:
-        if _is_grant_or_permission_error(str(e)):
-            log.debug(f"boot_context permission_denied (legacy boot ok): {e}")
-        else:
-            log.warning(f"boot_context RPC unavailable ({e}) — continuing legacy boot")
+                log.debug(f"persona load returned non-ok (bg): {_persona_resp} — continuing without")
+        except Exception as e:
+            log.debug(f"persona RPC unavailable (bg) ({e}) — continuing without")
+
+    def _load_boot_context_bg():
+        global _BOOT_CONTEXT_BUNDLE, _BOOT_CONTEXT_AT
+        try:
+            _ctx = be.sb_rpc("mc_agent_boot_context", {
+                "p_api_key": _get_api_key(),
+                "p_project_id": _PROJECT_ID,
+                "p_agent_name": AGENT_NAME,
+            })
+            if isinstance(_ctx, dict) and _ctx.get("ok"):
+                _BOOT_CONTEXT_BUNDLE = _ctx
+                _BOOT_CONTEXT_AT = _time.time()
+                log.info(
+                    f"[meshcode] boot_context (bg): "
+                    f"{len(_ctx.get('recent_msgs', []))} unread, "
+                    f"{len(_ctx.get('open_tasks', []))} open tasks, "
+                    f"{len(_ctx.get('relevant_memories', []))} memories surfaced"
+                )
+            else:
+                if _is_grant_or_permission_error(_ctx):
+                    log.debug(f"boot_context permission_denied (bg, legacy boot ok): {_ctx}")
+                else:
+                    log.warning(f"boot_context returned non-ok (bg): {_ctx} — continuing legacy boot")
+        except Exception as e:
+            if _is_grant_or_permission_error(str(e)):
+                log.debug(f"boot_context permission_denied (bg, legacy boot ok): {e}")
+            else:
+                log.warning(f"boot_context RPC unavailable (bg) ({e}) — continuing legacy boot")
+
+    _threading.Thread(target=_load_persona_bg, daemon=True, name="meshcode-load-persona").start()
+    _threading.Thread(target=_load_boot_context_bg, daemon=True, name="meshcode-load-boot-context").start()
 
     # Heartbeat in daemon thread — independent of asyncio event loop.
     _heartbeat_stop.clear()
@@ -2726,21 +2707,43 @@ def meshcode_download_file(file_id: str) -> Dict[str, Any]:
     file_name = file_info.get("file_name", "download")
     signed_url = file_info.get("signed_url")
 
-    # Strategy 1: signed_url (no auth headers, no client service_role needed)
+    sb_url = os.environ.get("SUPABASE_URL", be._sb_url if hasattr(be, '_sb_url') else "")
+    anon_key = os.environ.get("SUPABASE_KEY", be._sb_key if hasattr(be, '_sb_key') else "")
+    service_key = os.environ.get("MESHCODE_SUPABASE_SERVICE_KEY", "")
+
+    tried_labels: List[str] = []
+    last_err: Optional[str] = None
+
+    # Strategy 1: signed_url (no auth headers, no client service_role needed).
+    # Path B (235e85b6): server-side RPC mints the URL via backend GUCs and
+    # returns it; client just GETs. Works for guest workspaces that
+    # intentionally lack MESHCODE_SUPABASE_SERVICE_KEY in their .mcp.json.
     if signed_url:
+        tried_labels.append("signed_url")
         try:
             with _req.urlopen(_req.Request(signed_url), timeout=30) as resp:
                 content = resp.read()
             return _consume(content, mime_type, file_name)
-        except _uerr.HTTPError:
-            pass  # fall through to legacy path
-        except Exception:
-            pass
-
-    # Strategy 2: legacy service_role/anon/public on storage_path
-    sb_url = os.environ.get("SUPABASE_URL", be._sb_url if hasattr(be, '_sb_url') else "")
-    anon_key = os.environ.get("SUPABASE_KEY", be._sb_key if hasattr(be, '_sb_key') else "")
-    service_key = os.environ.get("MESHCODE_SUPABASE_SERVICE_KEY", "")
+        except _uerr.HTTPError as e:
+            last_err = f"HTTP {e.code} on signed_url: {e.reason}"
+        except Exception as e:
+            last_err = f"{type(e).__name__} on signed_url: {e}"
+
+    # Strategy 2 candidates: direct storage REST with available keys.
+    # Guest workspaces (no MESHCODE_SUPABASE_SERVICE_KEY) cannot read a
+    # private bucket via anon — every Strategy-2 attempt will 400/403. Bail
+    # early with a clear root-cause diagnosis instead of churning through
+    # doomed attempts and surfacing a generic HTTP 400 to the user. Task
+    # 8ecd56bb 2026-05-14: alexa + bob hit this path.
+    if not signed_url and not service_key:
+        return {
+            "error": "server-side signed_url unavailable and this workspace has no service_role key",
+            "error_code": "missing_server_guc",
+            "tried": tried_labels,
+            "storage_path": storage_path,
+            "hint": "backend RPC mc_get_file_download did not return a signed_url. Likely the Supabase project is missing GUC `app.settings.service_role_key` + `app.settings.supabase_url` so the RPC body cannot mint a signed URL. Ask Samuel to apply both ALTER DATABASE settings on the meshcode Supabase project (sb_secret_... + https://gjinagyyjttyxnaoavnz.supabase.co), or distribute MESHCODE_SUPABASE_SERVICE_KEY into guest .mcp.json (security tradeoff — not recommended).",
+            "diagnosis": "guest_workspace_pattern",
+        }
 
     if not sb_url or not anon_key:
         return {"error": "storage not configured", "error_code": "config_error"}
@@ -2769,9 +2772,7 @@ def meshcode_download_file(file_id: str) -> Dict[str, Any]:
     attempts.append(("anon auth", auth_url, anon_key))
     attempts.append(("anon public", public_url, anon_key))
 
-    last_err = None
     content = None
-    tried_labels: List[str] = ["signed_url"] if signed_url else []
     for label, _url, _key in attempts:
         tried_labels.append(label)
         try:
@@ -2789,7 +2790,12 @@ def meshcode_download_file(file_id: str) -> Dict[str, Any]:
             "error_code": "download_error",
             "tried": tried_labels,
             "storage_path": storage_path,
-            "hint": "ask commander to apply backend GUC app.settings.service_role_key + supabase_url so the RPC can mint signed URLs" if not signed_url else None,
+            "hint": (
+                "every fallback failed. If 'signed_url' was tried and 400'd, the URL may be expired or "
+                "signed against a stale key — re-request via meshcode_download_file. If signed_url was "
+                "absent, the backend GUC `app.settings.service_role_key`/`app.settings.supabase_url` is "
+                "missing on the Supabase project."
+            ),
         }
 
     return _consume(content, mime_type, file_name)

meshcode-2.11.5/meshcode/meshcode_mcp/sleep_signals.py

@@ -0,0 +1,110 @@
+"""Sleep-authorization signal parser for the wait loop.
+
+Pure module — no side effects, no env deps. Extracted from server.py so the
+parser can be imported and tested in isolation. server.py re-exports these
+names for back-compat.
+
+Authorizes a wait-loop exit (must_exit=True) only on explicit sleep-auth
+context. Two valid encodings:
+
+  (1) STRUCTURED DIRECTIVE — payload.type or payload.directive is in
+      _SLEEP_PAYLOAD_TYPES. Deliberately-shaped messages; an agent that
+      sets payload.type to a sleep verb is issuing a directive on purpose.
+  (2) HUMAN TEXT KEYWORD — payload.text contains a sleep marker AND the
+      sender is a human user.
+
+Plain text idioms from AI-role agents are deliberately IGNORED — quoting
+"a dormir" or describing "Samuel cierra la sesion" inside a debate-close
+summary is not authorization. Task fabfc602 (bob@justforfun 2026-05-14).
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+_SLEEP_PAYLOAD_TYPES = {"sleep", "go_to_sleep", "shutdown", "got_done", "done",
+                        "exit", "stop", "kill", "terminate"}
+
+# Multi-word imperative markers ONLY. Single Spanish verbs like "salir" /
+# "terminar" / "duerme" were too loose and caught idiomatic prose like
+# "terminaron sus tasks" or "no puedo salir" (msg cfbd36b0 2026-05-14 alexa +
+# commander incidents — feedback_done_signal_false_positive_idiomatic
+# precedent). The parser requires a directive-shaped phrase: a verb
+# combined with a temporal/object qualifier ("ahora" / "todos" / "to sleep")
+# so describing an event in prose can't trip must_exit.
+_SLEEP_TEXT_MARKERS = (
+    # English directives
+    "go to sleep", "all sleep now", "sleep now", "got_done", "go_done",
+    "shut down", "shutdown", "stop now", "exit now",
+    # Spanish directives (es-MX). Each requires a leading "a"/"todos" or
+    # a trailing "ahora" so plain conjugations in prose don't trigger.
+    "a dormir", "todos a dormir", "duerme ahora", "duerman ahora",
+    "dormir ahora", "para la sesion", "exit y duerme",
+)
+
+# Back-compat fallback for messages predating mig 289 (payload.sender_role
+# stamping). Kept in sync with _stop_hook_template._KNOWN_HUMAN_HANDLES so
+# server + hook share authority on who counts as a human user.
+_KNOWN_HUMAN_HANDLES = frozenset({"sammybenu", "samuel", "sam"})
+
+
+def _is_human_authored(m: Dict[str, Any]) -> bool:
+    """True when the message carries explicit human-user authorship.
+
+    Two encodings (mig 289 + back-compat):
+      (a) payload.sender_role == "human_user" (or .from_role) — server-stamped
+      (b) sender handle in _KNOWN_HUMAN_HANDLES — pre-mig-289 fallback
+    """
+    pl = m.get("payload") or {}
+    if isinstance(pl, dict):
+        role = pl.get("sender_role") or pl.get("from_role")
+        if isinstance(role, str) and role.lower() == "human_user":
+            return True
+    sender = m.get("from") or ""
+    if isinstance(sender, str) and sender.lower() in _KNOWN_HUMAN_HANDLES:
+        return True
+    return False
+
+
+def _looks_like_sleep_signal(m: Dict[str, Any]) -> bool:
+    """Detect mesh messages that authorize the wait-loop exit.
+
+    See module docstring for the two valid encodings and the rationale
+    for ignoring idiom matches from AI-role senders.
+    """
+    pl = m.get("payload") or {}
+    if isinstance(pl, dict):
+        if str(pl.get("type", "")).lower() in _SLEEP_PAYLOAD_TYPES:
+            return True
+        if str(pl.get("directive", "")).lower() in _SLEEP_PAYLOAD_TYPES:
+            return True
+        text = str(pl.get("text", "")).lower()
+        if text and any(marker in text for marker in _SLEEP_TEXT_MARKERS):
+            if _is_human_authored(m):
+                return True
+    return False
+
+
+def _split_messages(messages: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """Split a list of normalized message dicts into messages / acks / done_signals.
+
+    Classifies any message carrying a sleep intent into done_signals so
+    meshcode_wait surfaces them with must_exit=True. Idiom matches from
+    AI-role senders fall through to plain `messages` (no must_exit).
+    """
+    real: List[Dict[str, Any]] = []
+    acks: List[Dict[str, Any]] = []
+    dones: List[Dict[str, Any]] = []
+    for m in messages:
+        t = m.get("type", "msg")
+        if t == "ack":
+            acks.append(m)
+        elif t == "done" or _looks_like_sleep_signal(m):
+            dones.append(m)
+        else:
+            real.append(m)
+    return {
+        "messages": real,
+        "acks": acks,
+        "done_signals": dones,
+        "count": len(real),
+    }

{meshcode-2.11.4 → meshcode-2.11.5}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.4 → meshcode-2.11.5}/meshcode.egg-info/SOURCES.txt

@@ -183,6 +183,7 @@ meshcode/meshcode_mcp/__main__.py
 meshcode/meshcode_mcp/backend.py
 meshcode/meshcode_mcp/realtime.py
 meshcode/meshcode_mcp/server.py
+meshcode/meshcode_mcp/sleep_signals.py
 meshcode/meshcode_mcp/test_backend.py
 meshcode/meshcode_mcp/test_realtime.py
 meshcode/meshcode_mcp/test_server_wrapper.py
@@ -201,6 +202,7 @@ tests/test_rls_cross_tenant.py
 tests/test_rpc_migrations.py
 tests/test_security_regressions.py
 tests/test_sentinel.py
+tests/test_sleep_signals.py
 tests/test_status_enum_coverage.py
 tests/test_stay_on_loop_hook.py
 tests/test_wait_open_tasks_contradiction.py

{meshcode-2.11.4 → meshcode-2.11.5}/pyproject.toml

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