meshcode 2.10.53__tar.gz → 2.10.55__tar.gz

{meshcode-2.10.53 → meshcode-2.10.55}/PKG-INFO

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

{meshcode-2.10.53 → meshcode-2.10.55}/meshcode/__init__.py

@@ -1,2 +1,2 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.10.53"
+__version__ = "2.10.55"

{meshcode-2.10.53 → meshcode-2.10.55}/meshcode/cli.py

@@ -34,7 +34,7 @@ def main():
                 exec(compile(f.read(), candidate, "exec"), globs)
             return
 
-    print("[ERROR] comms_v4.py not found. Reinstall: pip install meshcode")
+    print("[meshcode] ERROR: comms_v4.py not found. Reinstall: pip install meshcode")
     sys.exit(1)
 
 

{meshcode-2.10.53 → meshcode-2.10.55}/meshcode/comms_v4.py

@@ -120,12 +120,12 @@ def _request(method, path, *, data=None, prefer=None):
             if "Daily message limit reached" in msg:
                 print(f"[QUOTA] {msg}", file=sys.stderr)
             else:
-                print(f"[ERROR] {method} {path}: {e.code} {msg}", file=sys.stderr)
+                print(f"[meshcode] ERROR: {method} {path}: {e.code} {msg}", file=sys.stderr)
         except Exception:
-            print(f"[ERROR] {method} {path}: {e.code} {err[:200]}", file=sys.stderr)
+            print(f"[meshcode] ERROR: {method} {path}: {e.code} {err[:200]}", file=sys.stderr)
         return None
     except URLError as e:
-        print(f"[ERROR] Network: {e.reason}", file=sys.stderr)
+        print(f"[meshcode] ERROR: Network: {e.reason}", file=sys.stderr)
         return None
 
 
@@ -962,7 +962,7 @@ def register(project, name, role=""):
     ensure_sessions()
     project_id = get_project_id(project)
     if not project_id:
-        print(f"[ERROR] Could not create/find project '{project}'")
+        print(f"[meshcode] ERROR: Could not create/find project '{project}'")
         return
 
     ppid = os.getppid()
@@ -992,7 +992,7 @@ def register(project, name, role=""):
     # the RPC validates owner/member access (no anon bypass).
     _api_key = _load_api_key_for_cli()
     if not _api_key:
-        print("[ERROR] Not authenticated. Run `meshcode login <api_key>` first.")
+        print("[meshcode] ERROR: Not authenticated. Run `meshcode login <api_key>` first.")
         return
     rpc_result = sb_rpc("mc_register_agent_with_api_key", {
         "p_api_key": _api_key,
@@ -1003,11 +1003,11 @@ def register(project, name, role=""):
     })
 
     if rpc_result and rpc_result.get("error"):
-        print(f"[ERROR] {rpc_result['error']}")
+        print(f"[meshcode] ERROR: {rpc_result['error']}")
         if rpc_result.get("upgrade_url"):
-            print(f"[ERROR] Upgrade: {rpc_result['upgrade_url']}")
+            print(f"[meshcode] ERROR: Upgrade: {rpc_result['upgrade_url']}")
         if rpc_result.get("current") is not None:
-            print(f"[ERROR] Agentes: {rpc_result['current']} / {rpc_result.get('max', '?')}")
+            print(f"[meshcode] ERROR: Agentes: {rpc_result['current']} / {rpc_result.get('max', '?')}")
         return
 
     # Update tty/pid (RPC doesn't take these — patch separately)
@@ -1094,7 +1094,7 @@ def _resolve_agent_name(project_id, name):
 def send_msg(project, from_agent, to_agent, content, msg_type="msg", compact=False):
     project_id = get_project_id(project)
     if not project_id:
-        print(f"[ERROR] Proyecto '{project}' no encontrado")
+        print(f"[meshcode] ERROR: Proyecto '{project}' no encontrado")
         return
 
     # Resolve partial agent names
@@ -1761,7 +1761,7 @@ def connect_terminal(project, name, role=""):
     ensure_sessions()
     project_id = get_project_id(project)
     if not project_id:
-        print(f"[ERROR] Could not create/find project '{project}'")
+        print(f"[meshcode] ERROR: Could not create/find project '{project}'")
         return
 
     tty, owning = _capture_tty_for_pid(os.getppid())
@@ -1791,11 +1791,11 @@ def connect_terminal(project, name, role=""):
             "p_instance_id": _instance_id,
         })
     else:
-        print("[ERROR] No API key found — cannot connect without authentication.")
-        print("[ERROR] Run: meshcode setup-key")
+        print("[meshcode] ERROR: No API key found — cannot connect without authentication.")
+        print("[meshcode] ERROR: Run: meshcode setup-key")
         return
     if rpc_result and rpc_result.get("error"):
-        print(f"[ERROR] {rpc_result['error']}")
+        print(f"[meshcode] ERROR: {rpc_result['error']}")
         return
 
     session_data = {"project": project, "agent": name, "pid": ppid, "tty": tty, "registered_at": now()}
@@ -1831,14 +1831,14 @@ def disconnect_terminal(project, name):
     """Mark agent offline, clear tty/pid, stop heartbeat, remove session file."""
     project_id = get_project_id(project)
     if not project_id:
-        print(f"[ERROR] project '{project}' not found")
+        print(f"[meshcode] ERROR: project '{project}' not found")
         return
     rpc_result = sb_rpc("mc_disconnect_agent", {
         "p_project_id": project_id,
         "p_agent_name": name,
     })
     if rpc_result and rpc_result.get("error"):
-        print(f"[ERROR] {rpc_result['error']}")
+        print(f"[meshcode] ERROR: {rpc_result['error']}")
         return
     _stop_heartbeat_daemon(project, name)
     sf = SESSIONS_DIR / f"{project}_{name}"
@@ -2242,7 +2242,7 @@ def show_subcommand_help(cmd):
     if text:
         print(text)
     else:
-        print(f"[ERROR] No help available for '{cmd}'")
+        print(f"[meshcode] ERROR: No help available for '{cmd}'")
         show_help()
 
 
@@ -2447,7 +2447,7 @@ if __name__ == "__main__":
     elif cmd == "validate-sessions":
         proj = pos[0] if len(pos) > 0 else (sys.argv[2] if len(sys.argv) > 2 else "")
         if not proj:
-            print("[ERROR] Uso: meshcode validate-sessions <project>")
+            print("[meshcode] ERROR: Uso: meshcode validate-sessions <project>")
             sys.exit(1)
         ensure_sessions()
         prefix = f"{proj}_"
@@ -2473,11 +2473,11 @@ if __name__ == "__main__":
         proj = pos[0] if len(pos) > 0 else ""
         name = pos[1] if len(pos) > 1 else ""
         if not proj or not name:
-            print("[ERROR] Uso: meshcode wake-headless <project> <agent>")
+            print("[meshcode] ERROR: Uso: meshcode wake-headless <project> <agent>")
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
-            print(f"[ERROR] project '{proj}' not found")
+            print(f"[meshcode] ERROR: project '{proj}' not found")
             sys.exit(1)
         ok = spawn_headless_agent(proj, name, project_id,
                                   "ping: synthetic wake-headless test message", "test-harness")
@@ -2489,16 +2489,16 @@ if __name__ == "__main__":
         proj = pos[0] if len(pos) > 0 else "default"
         name = pos[1] if len(pos) > 1 else ""
         if not name:
-            print(f"[ERROR] Uso: meshcode {cmd} <project> <agent>")
+            print(f"[meshcode] ERROR: Uso: meshcode {cmd} <project> <agent>")
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
-            print(f"[ERROR] project '{proj}' not found")
+            print(f"[meshcode] ERROR: project '{proj}' not found")
             sys.exit(1)
         rpc_name = {"kill": "mc_agent_kill", "wake": "mc_agent_wake", "sleep": "mc_agent_sleep"}[cmd]
         result = sb_rpc(rpc_name, {"p_project_id": project_id, "p_agent_name": name})
         if result and result.get("error"):
-            print(f"[ERROR] {result['error']}")
+            print(f"[meshcode] ERROR: {result['error']}")
             sys.exit(1)
         print(f"[{proj}] {name}: {cmd} → {json.dumps(result, ensure_ascii=False)}")
 
@@ -2508,11 +2508,11 @@ if __name__ == "__main__":
         proj = pos[1] if len(pos) > 1 else "default"
         name = pos[2] if len(pos) > 2 else ""
         if not name:
-            print("[ERROR] Uso: meshcode profile get|set <project> <agent> [flags]")
+            print("[meshcode] ERROR: Uso: meshcode profile get|set <project> <agent> [flags]")
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
-            print(f"[ERROR] project '{proj}' not found")
+            print(f"[meshcode] ERROR: project '{proj}' not found")
             sys.exit(1)
         if sub == "get":
             result = sb_rpc("mc_agent_get_profile", {"p_project_id": project_id, "p_agent_name": name})
@@ -2529,11 +2529,11 @@ if __name__ == "__main__":
                 params["p_launch_prompt"] = flags["launch-prompt"]
             result = sb_rpc("mc_agent_update_profile", params)
             if result and result.get("error"):
-                print(f"[ERROR] {result['error']}")
+                print(f"[meshcode] ERROR: {result['error']}")
                 sys.exit(1)
             print(f"[{proj}] profile updated for {name}")
         else:
-            print(f"[ERROR] subcomando desconocido: {sub}. Usa 'get' o 'set'.")
+            print(f"[meshcode] ERROR: subcomando desconocido: {sub}. Usa 'get' o 'set'.")
             sys.exit(1)
 
     elif cmd == "connect":
@@ -2721,7 +2721,7 @@ if __name__ == "__main__":
     elif cmd == "login":
         key = sys.argv[2] if len(sys.argv) > 2 else ""
         if not key:
-            print("[ERROR] Uso: meshcode login <api_key>")
+            print("[meshcode] ERROR: Uso: meshcode login <api_key>")
             sys.exit(1)
         login(key)
 
@@ -2824,10 +2824,10 @@ if __name__ == "__main__":
                 arg = sys.argv[3].lower()
                 if arg in ("on", "yes", "y", "true", "1"):
                     ok = set_auto_update(True)
-                    print("[meshcode] auto_update = ON" if ok else "[ERROR] failed to save")
+                    print("[meshcode] auto_update = ON" if ok else "[meshcode] ERROR: failed to save")
                 elif arg in ("off", "no", "n", "false", "0"):
                     ok = set_auto_update(False)
-                    print("[meshcode] auto_update = OFF" if ok else "[ERROR] failed to save")
+                    print("[meshcode] auto_update = OFF" if ok else "[meshcode] ERROR: failed to save")
                 elif arg == "reset":
                     reset_auto_update()
                     print("[meshcode] auto_update preference cleared")
@@ -2845,10 +2845,10 @@ if __name__ == "__main__":
             if len(sys.argv) > 3:
                 mode = sys.argv[3].lower()
                 if mode not in VALID_PERMISSION_MODES:
-                    print(f"[ERROR] mode must be one of: {', '.join(sorted(VALID_PERMISSION_MODES))}")
+                    print(f"[meshcode] ERROR: mode must be one of: {', '.join(sorted(VALID_PERMISSION_MODES))}")
                     sys.exit(1)
                 ok = set_permission_mode(mode)
-                print(f"[meshcode] permission_mode = {mode}" if ok else "[ERROR] failed to save")
+                print(f"[meshcode] permission_mode = {mode}" if ok else "[meshcode] ERROR: failed to save")
                 sys.exit(0 if ok else 1)
             else:
                 cur = get_permission_mode()

{meshcode-2.10.53 → meshcode-2.10.55}/meshcode/meshcode_mcp/backend.py

@@ -266,34 +266,40 @@ def _headers(*, prefer: Optional[str] = None, content_profile: bool = True) -> D
     return h
 
 
-def _request(method: str, path: str, *, data: Any = None, prefer: Optional[str] = None) -> Any:
+def _request(method: str, path: str, *, data: Any = None, prefer: Optional[str] = None,
+             _max_retries: int = 3) -> Any:
+    import random as _random
     if not _circuit.can_execute():
         return {"_error": "circuit breaker open — Supabase temporarily unavailable", "_code": 503}
     rest_path = f"/rest/v1/{path}"
     body = json.dumps(data).encode("utf-8") if data else None
     hdrs = _headers(prefer=prefer)
-    try:
-        status, raw = _pool.request(method, rest_path, body, hdrs)
-        if 200 <= status < 300:
-            _circuit.record_success()
-            return json.loads(raw) if raw.strip() else None
-        elif 400 <= status < 500:
-            _circuit.record_success()
-            try:
-                err_obj = json.loads(raw)
-                return {"_error": err_obj.get("message", raw[:200]), "_code": status}
-            except Exception:
-                return {"_error": raw[:200], "_code": status}
-        else:
-            _circuit.record_failure()
-            try:
-                err_obj = json.loads(raw)
-                return {"_error": err_obj.get("message", raw[:200]), "_code": status}
-            except Exception:
-                return {"_error": raw[:200], "_code": status}
-    except (URLError, OSError, TimeoutError, http.client.HTTPException) as e:
-        _circuit.record_failure()
-        return {"_error": str(getattr(e, 'reason', e)), "_code": 0}
+    last_err = None
+    for attempt in range(_max_retries):
+        try:
+            status, raw = _pool.request(method, rest_path, body, hdrs)
+            if 200 <= status < 300:
+                _circuit.record_success()
+                return json.loads(raw) if raw.strip() else None
+            elif 400 <= status < 500:
+                # Client errors are not transient — don't retry
+                _circuit.record_success()
+                try:
+                    err_obj = json.loads(raw)
+                    return {"_error": err_obj.get("message", raw[:200]), "_code": status}
+                except Exception:
+                    return {"_error": raw[:200], "_code": status}
+            else:
+                # 5xx — transient, retry
+                last_err = raw[:200]
+        except (URLError, OSError, TimeoutError, http.client.HTTPException) as e:
+            last_err = str(getattr(e, 'reason', e))
+        # Retry with jitter for transient errors (5xx, network)
+        if attempt < _max_retries - 1:
+            delay = (2 ** attempt) + _random.uniform(0, 1)
+            _time.sleep(delay)
+    _circuit.record_failure()
+    return {"_error": str(last_err)[:200] if last_err else "request failed after retries", "_code": 0}
 
 
 def sb_select(table: str, filters: str = "", order: Optional[str] = None, limit: Optional[int] = None) -> List[Dict]:
@@ -422,8 +428,10 @@ def sb_rpc_raw(fn_name: str, params: Dict) -> Any:
         status, raw = _pool.request("POST", rpc_path, body, hdrs)
         if 200 <= status < 300:
             return json.loads(raw) if raw.strip() else None
+        log.warning("sb_rpc_raw(%s) returned %d: %s", fn_name, status, raw[:200])
         return None
-    except Exception:
+    except Exception as e:
+        log.warning("sb_rpc_raw(%s) failed: %s", fn_name, e)
         return None
 
 
@@ -865,13 +873,16 @@ def encrypt_payload(payload: Dict, hex_key: str, aad: Optional[str] = None) -> s
 def decrypt_payload(encrypted_b64: str, hex_key: str, aad: Optional[str] = None) -> Optional[Dict]:
     """Decrypt an AES-256-GCM encrypted payload. Returns None on failure.
 
-    Tries with AAD first, falls back to no-AAD for backward compat
-    with messages encrypted before AAD was added.
+    If AAD is provided, it is MANDATORY — the message MUST have been
+    encrypted with the same AAD. No fallback to no-AAD when AAD is
+    present (this prevents swap/replay attacks). Messages without AAD
+    (legacy, pre-AAD era) are still decrypted with aad=None.
     """
     import base64
     try:
         from cryptography.hazmat.primitives.ciphers.aead import AESGCM
     except ImportError:
+        log.warning("decrypt_payload: cryptography package not installed")
         return None
     try:
         key = bytes.fromhex(hex_key)
@@ -880,17 +891,12 @@ def decrypt_payload(encrypted_b64: str, hex_key: str, aad: Optional[str] = None)
         ciphertext = raw[12:]
         aesgcm = AESGCM(key)
         aad_bytes = aad.encode("utf-8") if aad else None
-        # Try with AAD first
-        if aad_bytes:
-            try:
-                plaintext = aesgcm.decrypt(nonce, ciphertext, aad_bytes)
-                return json.loads(plaintext.decode("utf-8"))
-            except Exception:
-                pass  # Fall through to no-AAD for backward compat
-        # Try without AAD (legacy messages)
-        plaintext = aesgcm.decrypt(nonce, ciphertext, None)
+        # AAD is mandatory when provided — no fallback to prevent replay attacks.
+        # Legacy messages (aad=None) are decrypted without AAD.
+        plaintext = aesgcm.decrypt(nonce, ciphertext, aad_bytes)
         return json.loads(plaintext.decode("utf-8"))
-    except Exception:
+    except Exception as e:
+        log.warning("decrypt_payload failed (aad=%s): %s", aad[:20] if aad else "none", e)
         return None
 
 

{meshcode-2.10.53 → meshcode-2.10.55}/meshcode/meshcode_mcp/realtime.py

@@ -70,6 +70,13 @@ class RealtimeListener:
         # meshcode_wait awaits this instead of polling -> zero-cost idle.
         self.message_event: Optional[asyncio.Event] = None
 
+        # Deaf detection: track when we last received ANY event from Realtime
+        # (message, task, or heartbeat reply). If this goes stale while the
+        # agent is supposedly listening, Realtime is deaf and needs restart.
+        import time as _time_mod
+        self.last_event_at: float = _time_mod.time()
+        self._deaf_restart_count: int = 0
+
     @property
     def ws_url(self) -> str:
         host = self.supabase_url.replace("https://", "").replace("http://", "").rstrip("/")
@@ -271,6 +278,8 @@ class RealtimeListener:
                 return
 
     async def _handle_message(self, msg: Dict[str, Any]) -> None:
+        import time as _time_mod
+        self.last_event_at = _time_mod.time()
         event = msg.get("event")
         payload = msg.get("payload") or {}
 
@@ -382,3 +391,18 @@ class RealtimeListener:
     @property
     def is_subscribed(self) -> bool:
         return self._connected and getattr(self, "_subscription_ok", False)
+
+    @property
+    def seconds_since_last_event(self) -> float:
+        import time as _time_mod
+        return _time_mod.time() - self.last_event_at
+
+    @property
+    def is_deaf(self) -> bool:
+        """True if Realtime claims to be subscribed but hasn't received
+        any events for >60s. This indicates a silent WebSocket failure."""
+        return self.is_subscribed and self.seconds_since_last_event > 60.0
+
+    @property
+    def deaf_restart_count(self) -> int:
+        return self._deaf_restart_count

{meshcode-2.10.53 → meshcode-2.10.55}/meshcode/meshcode_mcp/server.py

@@ -74,7 +74,7 @@ def _agent_color(name: str) -> str:
 
 
 def _mc_log(msg: str, level: str = "info") -> None:
-    """Colored [meshcode-mcp] log line. Uses agent color if available.
+    """Colored [meshcode] log line. Uses agent color if available.
 
     CRITICAL: Must write to stderr, NEVER stdout. MCP protocol uses stdout
     for JSON-RPC — any non-JSON output to stdout corrupts the stream and
@@ -82,7 +82,7 @@ def _mc_log(msg: str, level: str = "info") -> None:
     """
     agent = os.environ.get("MESHCODE_AGENT", "")
     c = _agent_color(agent) if agent else "\033[36m"
-    prefix = f"{c}{_ANSI_BOLD}[meshcode-mcp]{_ANSI_RESET}"
+    prefix = f"{c}{_ANSI_BOLD}[meshcode]{_ANSI_RESET}"
     if level == "error":
         print(f"{prefix} \033[91mERROR:{_ANSI_RESET} {msg}", file=sys.stderr)
     elif level == "warn":
@@ -368,6 +368,74 @@ def _split_messages(messages: List[Dict[str, Any]]) -> Dict[str, Any]:
         "count": len(real),
     }
 
+
+_PAYLOAD_TRUNCATE_LIMIT = 500  # chars — messages longer get truncated
+
+
+def _compress_message(m: Dict[str, Any]) -> Dict[str, Any]:
+    """Compress a single message for token-efficient LLM delivery.
+
+    - Truncates long text payloads with a hint to use meshcode_read_message
+    - Strips null/empty fields (parent_id)
+    """
+    out: Dict[str, Any] = {"from": m.get("from"), "type": m.get("type", "msg")}
+    msg_id = m.get("id")
+    if msg_id:
+        out["id"] = msg_id
+    ts = m.get("ts")
+    if ts:
+        out["ts"] = ts
+    parent = m.get("parent_id")
+    if parent:
+        out["parent_id"] = parent
+    # Truncate large payloads
+    payload = m.get("payload", {})
+    if isinstance(payload, dict):
+        text = payload.get("text")
+        if isinstance(text, str) and len(text) > _PAYLOAD_TRUNCATE_LIMIT:
+            payload = {**payload, "text": text[:_PAYLOAD_TRUNCATE_LIMIT] + "...",
+                       "_truncated": True}
+            if msg_id:
+                payload["_full"] = f"use meshcode_read_message(msg_id='{msg_id}') for full content"
+        # Check overall payload size
+        import json as _json
+        _payload_str = _json.dumps(payload, default=str)
+        if len(_payload_str) > _PAYLOAD_TRUNCATE_LIMIT * 2:
+            payload = {"_summary": _payload_str[:_PAYLOAD_TRUNCATE_LIMIT] + "...",
+                       "_truncated": True}
+            if msg_id:
+                payload["_full"] = f"use meshcode_read_message(msg_id='{msg_id}') for full content"
+    out["payload"] = payload
+    return out
+
+
+def _compress_output(result: Dict[str, Any]) -> Dict[str, Any]:
+    """Compress the output dict for token efficiency.
+
+    - Compresses individual messages
+    - Omits empty arrays (acks, done_signals)
+    - Strips redundant metadata
+    """
+    out: Dict[str, Any] = {}
+    # Copy non-list fields
+    for k, v in result.items():
+        if k in ("messages", "acks", "done_signals"):
+            continue
+        if v is not None:
+            out[k] = v
+    # Compress and include messages
+    msgs = result.get("messages", [])
+    if msgs:
+        out["messages"] = [_compress_message(m) for m in msgs]
+    # Only include acks/dones if non-empty
+    acks = result.get("acks", [])
+    if acks:
+        out["acks"] = [_compress_message(m) for m in acks]
+    dones = result.get("done_signals", [])
+    if dones:
+        out["done_signals"] = [_compress_message(m) for m in dones]
+    return out
+
 from . import backend as be
 from .realtime import RealtimeListener
 
@@ -441,14 +509,14 @@ try:
     from mcp.server.fastmcp import FastMCP
 except ImportError:
     print(
-        "[meshcode-mcp] ERROR: mcp package not installed. Run: pip install 'mcp[cli]>=1.0'",
+        "[meshcode] ERROR: mcp package not installed. Run: pip install 'mcp[cli]>=1.0'",
         file=sys.stderr,
     )
     sys.exit(2)
 
 logging.basicConfig(level=logging.INFO, stream=sys.stderr,
-                    format="[meshcode-mcp] %(message)s")
-log = logging.getLogger("meshcode-mcp")
+                    format="[meshcode] %(message)s")
+log = logging.getLogger("meshcode")
 
 
 # ============================================================
@@ -462,7 +530,7 @@ EDITOR_TYPE = os.environ.get("MESHCODE_EDITOR_TYPE", "")
 
 if not PROJECT_NAME or not AGENT_NAME:
     print(
-        "[meshcode-mcp] ERROR: MESHCODE_PROJECT and MESHCODE_AGENT env vars required",
+        "[meshcode] ERROR: MESHCODE_PROJECT and MESHCODE_AGENT env vars required",
         file=sys.stderr,
     )
     sys.exit(2)
@@ -625,6 +693,7 @@ import time as _time
 _flip_lock = _threading.Lock()
 _current_state = "online"
 _last_tool_at = _time.time()
+_last_send_at = 0.0  # timestamp of last message sent (skip heartbeat if recent)
 _current_tool = ""
 _IDLE_THRESHOLD_S = 120  # seconds without tool call → IDLE
 _SLEEPING_THRESHOLD_S = 300  # seconds in waiting without activity → SLEEPING
@@ -721,6 +790,52 @@ def with_working_status(func):
                 # to prevent cascade through FastMCP into the event loop.
                 # Return an error dict instead of propagating BaseException.
                 log.debug(f"[meshcode] tool {name} cancelled by client (ESC)")
+                # 2.10.54 deaf-agent fix: for meshcode_wait specifically, the
+                # inner cancel handler already tries to drain pending messages.
+                # If we still got CancelledError here, the inner drain failed —
+                # do a last-ditch DB read so the LLM sees pending mail instead
+                # of a generic error and goes silent.
+                if name == "meshcode_wait":
+                    try:
+                        _t = asyncio.current_task()
+                        if _t is not None and hasattr(_t, "uncancel"):
+                            _t.uncancel()
+                    except Exception:
+                        pass
+                    try:
+                        _ak = _get_api_key()
+                        if _ak:
+                            _raw = be.read_inbox(
+                                _PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_ak
+                            )
+                            if _raw:
+                                _msgs = [
+                                    {
+                                        "from": m["from_agent"],
+                                        "type": m.get("type", "msg"),
+                                        "ts": m.get("created_at"),
+                                        "payload": m.get("payload", {}),
+                                        "id": m.get("id"),
+                                        "parent_id": m.get("parent_msg_id"),
+                                    }
+                                    for m in _raw
+                                ]
+                                _filter_and_mark(_msgs)
+                                _split = _split_messages(_msgs)
+                                if _split["messages"] or _split["done_signals"]:
+                                    log.info(
+                                        f"[meshcode] wrapper-level cancel-drain rescued "
+                                        f"{_split['count']} messages"
+                                    )
+                                    return {
+                                        "got_message": True,
+                                        "cancelled_during_wait": True,
+                                        **_split,
+                                    }
+                    except Exception as _final_err:
+                        log.debug(
+                            f"[meshcode] wrapper cancel-drain failed: {_final_err}"
+                        )
                 return {"error": "cancelled_by_client", "tool": name}
             except Exception as e:
                 if not skip:
@@ -1411,6 +1526,22 @@ def _heartbeat_loop_inner():
                             asyncio.run_coroutine_threadsafe(_REALTIME.restart(), _MAIN_LOOP)
                     except Exception as e:
                         log.debug(f"Realtime restart scheduling failed: {e}")
+                elif _REALTIME.is_deaf and in_wait:
+                    # DEAF DETECTION: Realtime claims subscribed but no events
+                    # for >60s while agent is actively waiting. This is the
+                    # "silent deaf" failure mode Samuel flagged. Auto-recover.
+                    _deaf_secs = _REALTIME.seconds_since_last_event
+                    _REALTIME._deaf_restart_count += 1
+                    log.warning(
+                        f"DEAF DETECTED: no Realtime events for {_deaf_secs:.0f}s "
+                        f"while in_wait=True — forcing restart "
+                        f"(deaf_restart #{_REALTIME._deaf_restart_count})"
+                    )
+                    try:
+                        if _MAIN_LOOP and _MAIN_LOOP.is_running():
+                            asyncio.run_coroutine_threadsafe(_REALTIME.restart(), _MAIN_LOOP)
+                    except Exception as e:
+                        log.debug(f"Deaf recovery restart scheduling failed: {e}")
                 else:
                     log.debug(f"heartbeat ok for {AGENT_NAME}")
             else:
@@ -1432,9 +1563,27 @@ def _heartbeat_loop_inner():
             except Exception as e:
                 log.warning(f"lease renewal failed: {e}")
 
-        # Adaptive heartbeat: fast for paid plans, moderate for free
-        # Free: 15s (~6K req/day/agent). Pro+: 5s (~17K req/day/agent).
-        hb_interval = 5 if _PROJECT_PLAN in ("pro", "team", "enterprise", "unlimited") else 15
+        # Adaptive heartbeat intervals based on agent activity state.
+        # Skip heartbeat entirely if a message was sent <5s ago (already proved alive).
+        now = _time.time()
+        since_send = now - _last_send_at
+        if since_send < 5.0:
+            _heartbeat_stop.wait(5.0 - since_send)
+            continue
+
+        # Base interval by plan (free gets slower baseline)
+        base = 5 if _PROJECT_PLAN in ("pro", "team", "enterprise", "unlimited") else 15
+        # Scale up based on idle duration
+        if cur_state in ("working", "waiting"):
+            hb_interval = base  # real-time matters
+        elif cur_state == "sleeping":
+            hb_interval = 60
+        elif idle_secs > 120:
+            hb_interval = 30
+        elif idle_secs > 30:
+            hb_interval = 15
+        else:
+            hb_interval = base
         _heartbeat_stop.wait(hb_interval)
 
 
@@ -1577,7 +1726,7 @@ if _DISABLE_LIFESPAN:
         name=f"meshcode-{PROJECT_NAME}-{AGENT_NAME}",
         instructions=_INSTRUCTIONS,
     )
-    print("[meshcode-mcp] LIFESPAN DISABLED (MESHCODE_DISABLE_LIFESPAN=1) — diagnostic mode", file=sys.stderr, flush=True)
+    print("[meshcode] LIFESPAN DISABLED (MESHCODE_DISABLE_LIFESPAN=1) — diagnostic mode", file=sys.stderr, flush=True)
 else:
     mcp = FastMCP(
         name=f"meshcode-{PROJECT_NAME}-{AGENT_NAME}",
@@ -1608,7 +1757,7 @@ async def meshcode_debug_sleep(seconds: int = 30) -> Dict[str, Any]:
         await _asyncio.sleep(max(1, int(seconds)))
         return {"ok": True, "slept": int(seconds), "pid": _os.getpid()}
     except BaseException as e:
-        sys.stderr.write(f"[meshcode-mcp] debug_sleep cancelled with {type(e).__name__}: {e}\n")
+        sys.stderr.write(f"[meshcode] debug_sleep cancelled with {type(e).__name__}: {e}\n")
         sys.stderr.flush()
         raise
 
@@ -1618,6 +1767,7 @@ async def meshcode_debug_sleep(seconds: int = 30) -> Dict[str, Any]:
 def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None,
                   sensitive: bool = False, encrypted: bool = False) -> Dict[str, Any]:
     """Send message. Use "agent@meshwork" for cross-mesh. sensitive=True hides from exports. Pass encrypted=True for secrets/credentials (AES-256-GCM)."""
+    global _last_send_at
     if not to or not to.strip():
         return {"error": "recipient 'to' cannot be empty"}
     to = to.strip()
@@ -1673,11 +1823,20 @@ def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None,
         })
         if isinstance(result, dict) and result.get("ok") and encrypted:
             result["encrypted"] = True
+        if isinstance(result, dict) and result.get("ok"):
+            _last_send_at = _time.time()
         return result
 
-    return be.send_message(_PROJECT_ID, AGENT_NAME, to, payload, msg_type="msg",
-                           parent_msg_id=in_reply_to, sensitive=sensitive,
-                           api_key=_get_api_key(), encrypted=encrypted)
+    # Enforce encryption for ALL sensitive messages (within-mesh and cross-mesh)
+    if sensitive and not encrypted:
+        return {"error": "sensitive messages must use encrypted=True"}
+
+    result = be.send_message(_PROJECT_ID, AGENT_NAME, to, payload, msg_type="msg",
+                             parent_msg_id=in_reply_to, sensitive=sensitive,
+                             api_key=_get_api_key(), encrypted=encrypted)
+    if isinstance(result, dict) and result.get("sent"):
+        _last_send_at = _time.time()
+    return result
 
 
 @mcp.tool()
@@ -1689,6 +1848,7 @@ def meshcode_broadcast(payload: Any) -> Dict[str, Any]:
       - dict (structured): {"type": "...", "detail": "..."}
       - str (shorthand): wrapped internally as {"text": "..."}
     """
+    global _last_send_at
     if isinstance(payload, str):
         payload = {"text": payload}
     elif not isinstance(payload, dict):
@@ -1699,6 +1859,7 @@ def meshcode_broadcast(payload: Any) -> Dict[str, Any]:
     # N-row fanout that caused duplicate-render bugs.
     be.send_message(_PROJECT_ID, AGENT_NAME, "*", payload, msg_type="broadcast",
                     api_key=_get_api_key())
+    _last_send_at = _time.time()
     return {"broadcast": True, "to": "*"}
 
 
@@ -2120,10 +2281,79 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
             try:
                 result = await _meshcode_wait_inner(actual_timeout=capped_timeout, include_acks=include_acks)
             except asyncio.CancelledError:
-                # Safety net: if CancelledError escapes _meshcode_wait_inner
-                # despite the inner shield, catch it here to prevent cascade.
-                log.debug("[meshcode] meshcode_wait outer loop caught CancelledError")
-                result = {"timed_out": True, "reason": "cancelled_by_client"}
+                # 2.10.54 deaf-agent fix: when ESC fires during meshcode_wait,
+                # Python keeps the task in cancelled state — every subsequent
+                # await re-raises CancelledError, even if we caught the first
+                # one. That trapped us in a loop that eventually returned
+                # `{"error": "cancelled_by_client"}` to the LLM, which never
+                # saw the messages that arrived during the cancel window —
+                # they sat in the queue/DB unread (the "deaf agents" bug).
+                #
+                # Fix: uncancel the current task so we can run a final drain
+                # cycle without re-raising. Then aggressively pull from BOTH
+                # the realtime buffer AND the DB and return whatever we find
+                # to the LLM. If nothing is pending, return cancelled-timeout
+                # cleanly so the LLM's wait loop continues normally.
+                log.info("[meshcode] meshcode_wait caught CancelledError — uncancelling + final drain")
+                try:
+                    _t = asyncio.current_task()
+                    if _t is not None and hasattr(_t, "uncancel"):
+                        _t.uncancel()
+                except Exception:
+                    pass
+
+                _final_msgs: List[Dict[str, Any]] = []
+                # 1) Drain realtime buffer (messages received during cancel window)
+                if _REALTIME:
+                    try:
+                        _rt_buf = _REALTIME.drain()
+                        if _rt_buf:
+                            _final_msgs.extend(_rt_buf)
+                    except Exception as _drain_err:
+                        log.debug(f"[meshcode] cancel-drain realtime failed: {_drain_err}")
+                # 2) Pull from DB (catches messages realtime missed)
+                try:
+                    _api_key = _get_api_key()
+                    if _api_key:
+                        _db_unread = be.read_inbox(
+                            _PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_api_key
+                        )
+                        if _db_unread:
+                            _final_msgs.extend([
+                                {
+                                    "from": m["from_agent"],
+                                    "type": m.get("type", "msg"),
+                                    "ts": m.get("created_at"),
+                                    "payload": m.get("payload", {}),
+                                    "id": m.get("id"),
+                                    "parent_id": m.get("parent_msg_id"),
+                                }
+                                for m in _db_unread
+                            ])
+                except Exception as _db_err:
+                    log.debug(f"[meshcode] cancel-drain DB failed: {_db_err}")
+
+                if _final_msgs:
+                    # Dedupe + filter, then return as got_message so the LLM
+                    # processes them instead of seeing a generic cancel error.
+                    _filter_and_mark(_final_msgs)
+                    _split = _split_messages(_final_msgs)
+                    if not include_acks:
+                        _split["acks"] = []
+                    if _split["messages"] or _split["done_signals"]:
+                        log.info(
+                            f"[meshcode] cancel-drain rescued {_split['count']} pending "
+                            f"messages from going deaf"
+                        )
+                        result = {
+                            "got_message": True,
+                            "cancelled_during_wait": True,
+                            **_split,
+                        }
+                    else:
+                        result = {"timed_out": True, "reason": "cancelled_by_client"}
+                else:
+                    result = {"timed_out": True, "reason": "cancelled_by_client"}
 
             if result.get("got_message"):
                 # Real message arrived — return to agent for processing
@@ -2273,7 +2503,7 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
             out["got_done"] = True
             out["reason"] = done["reason"]
             out["from"] = done["from"]
-        return out
+        return _compress_output(out)
 
     # 1) Drain anything already buffered from before this call.
     if _REALTIME:
@@ -2288,14 +2518,23 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
 
     if _rt_live:
         # 2a) Realtime wait with DB safety net.
-        # Split into 5s sub-waits. Between each sub-wait, also check DB
-        # as a safety net — Realtime WS can die silently and is_subscribed
-        # stays True, so we must not rely on it exclusively.
-        _rt_sub_timeout = 5.0
+        # Split into sub-waits with ADAPTIVE safety-net polling.
+        # When Realtime is healthy (safety net finds nothing), we back off
+        # the DB poll interval exponentially: 5s → 10s → 20s → 40s (cap).
+        # If safety net catches a message Realtime missed, snap back to 5s.
+        # This reduces DB load from ~48 roundtrips/120s to ~8-10 when healthy.
+        _RT_SAFETY_BASE = 5.0
+        _RT_SAFETY_CAP = 40.0
+        _rt_safety_interval = _RT_SAFETY_BASE
         _rt_elapsed = 0.0
+        _rt_since_last_safety = 0.0
+        _rt_since_last_task_check = 0.0
+        _TASK_CHECK_INTERVAL = 15.0  # check tasks every 15s, not every 5s
         woke = False
         while _rt_elapsed < actual_timeout:
-            _this_wait = min(_rt_sub_timeout, actual_timeout - _rt_elapsed)
+            _this_wait = min(_rt_safety_interval - _rt_since_last_safety,
+                             actual_timeout - _rt_elapsed, 5.0)
+            _this_wait = max(_this_wait, 1.0)
             try:
                 woke = await asyncio.shield(
                     _REALTIME.wait_for_message(timeout=_this_wait)
@@ -2310,38 +2549,51 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
             if woke:
                 break
             _rt_elapsed += _this_wait
-            # Check for new tasks between sub-iterations
-            _sub_tasks = _get_pending_tasks_summary()
-            if _sub_tasks:
-                return {"timed_out": False, "got_message": False, "pending_tasks": _sub_tasks, "reason": "task_detected_mid_wait"}
-            # DB safety net: check for unread messages even when Realtime
-            # claims to be alive. Realtime WS can die silently.
-            try:
-                _safety_key = _get_api_key()
-                if _safety_key:
-                    _safety_cnt = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_safety_key)
-                    if _safety_cnt and _safety_cnt > 0:
-                        log.info(f"[meshcode] DB safety net: {_safety_cnt} unread msgs despite Realtime — reading from DB")
-                        _safety_raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_safety_key)
-                        if _safety_raw:
-                            _safety_msgs = [
-                                {"from": m["from_agent"], "type": m.get("type", "msg"),
-                                 "ts": m.get("created_at"), "payload": m.get("payload", {}),
-                                 "id": m.get("id"), "parent_id": m.get("parent_msg_id")}
-                                for m in _safety_raw
-                            ]
-                            _filter_and_mark(_safety_msgs)
-                            _safety_split = _split_messages(_safety_msgs)
-                            if not include_acks:
-                                _safety_split["acks"] = []
-                            if _safety_split["messages"] or _safety_split["done_signals"]:
-                                return {"got_message": True, **_safety_split}
-            except Exception as _db_err:
-                log.warning(f"[meshcode] DB safety net error: {_db_err}")
-            # Health check: if subscription dropped, switch to DB poll
+            _rt_since_last_safety += _this_wait
+            _rt_since_last_task_check += _this_wait
+            # Check for new tasks at a relaxed interval (15s instead of 5s)
+            if _rt_since_last_task_check >= _TASK_CHECK_INTERVAL:
+                _rt_since_last_task_check = 0.0
+                _sub_tasks = _get_pending_tasks_summary()
+                if _sub_tasks:
+                    return {"timed_out": False, "got_message": False, "pending_tasks": _sub_tasks, "reason": "task_detected_mid_wait"}
+            # DB safety net: only poll when the adaptive interval has elapsed
+            if _rt_since_last_safety >= _rt_safety_interval:
+                _rt_since_last_safety = 0.0
+                try:
+                    _safety_key = _get_api_key()
+                    if _safety_key:
+                        _safety_cnt = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_safety_key)
+                        if _safety_cnt and _safety_cnt > 0:
+                            # Safety net caught something — snap back to base interval
+                            _rt_safety_interval = _RT_SAFETY_BASE
+                            log.info(f"[meshcode] DB safety net: {_safety_cnt} unread msgs despite Realtime — reading from DB")
+                            _safety_raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_safety_key)
+                            if _safety_raw:
+                                _safety_msgs = [
+                                    {"from": m["from_agent"], "type": m.get("type", "msg"),
+                                     "ts": m.get("created_at"), "payload": m.get("payload", {}),
+                                     "id": m.get("id"), "parent_id": m.get("parent_msg_id")}
+                                    for m in _safety_raw
+                                ]
+                                _filter_and_mark(_safety_msgs)
+                                _safety_split = _split_messages(_safety_msgs)
+                                if not include_acks:
+                                    _safety_split["acks"] = []
+                                if _safety_split["messages"] or _safety_split["done_signals"]:
+                                    return _compress_output({"got_message": True, **_safety_split})
+                        else:
+                            # Realtime is healthy — back off safety net interval
+                            _rt_safety_interval = min(_rt_safety_interval * 2, _RT_SAFETY_CAP)
+                except Exception as _db_err:
+                    log.warning(f"[meshcode] DB safety net error: {_db_err}")
+            # Health check: if subscription dropped or deaf, switch to DB poll
             if not (_REALTIME and _REALTIME.is_subscribed):
                 log.info("[meshcode] Realtime subscription lost mid-wait — switching to DB poll")
                 break
+            if _REALTIME and _REALTIME.is_deaf:
+                log.warning(f"[meshcode] Realtime deaf mid-wait ({_REALTIME.seconds_since_last_event:.0f}s silent) — switching to DB poll")
+                break
         if woke:
             buffered = _REALTIME.drain()
             if buffered:
@@ -2381,7 +2633,7 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
                             if not include_acks:
                                 split["acks"] = []
                             if split["messages"] or split["done_signals"]:
-                                return {"got_message": True, **split}
+                                return _compress_output({"got_message": True, **split})
             except Exception as e:
                 log.warning(f"DB poll fallback error: {e}")
 
@@ -2405,7 +2657,7 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
                     if not include_acks:
                         split["acks"] = []
                     if split["messages"] or split["done_signals"]:
-                        return {"got_message": True, **split}
+                        return _compress_output({"got_message": True, **split})
     except Exception as e:
         log.warning(f"final DB fallback error: {e}")
 
@@ -2516,7 +2768,7 @@ def meshcode_check(include_acks: bool = False, since: Optional[str] = None, mark
     pending_tasks = _get_pending_tasks_summary()
     if pending_tasks:
         result["pending_tasks"] = pending_tasks
-    return result
+    return _compress_output(result)
 
 
 @mcp.tool()
@@ -3777,7 +4029,7 @@ def run_server():
     """Start the MCP server on stdio (default for Claude Code)."""
     _auto_update()
     print(
-        f"[meshcode-mcp] Starting server for {AGENT_NAME}@{PROJECT_NAME}",
+        f"[meshcode] Starting server for {AGENT_NAME}@{PROJECT_NAME}",
         file=sys.stderr,
     )
     # Restore real stdout for FastMCP's JSON-RPC transport.
@@ -3812,7 +4064,7 @@ def run_server():
         except Exception:
             name = f"signal-{signum}"
         try:
-            sys.stderr.write(f"[meshcode-mcp] received {name} ({signum}); ignored to keep MCP alive during tool cancellation\n")
+            sys.stderr.write(f"[meshcode] received {name} ({signum}); ignored to keep MCP alive during tool cancellation\n")
             sys.stderr.flush()
         except Exception:
             pass
@@ -3856,7 +4108,7 @@ def run_server():
             _restart_count += 1
             try:
                 sys.stderr.write(
-                    f"[meshcode-mcp] mcp.run() raised {type(_e).__name__}: {_e} "
+                    f"[meshcode] mcp.run() raised {type(_e).__name__}: {_e} "
                     f"(restart #{_restart_count}); re-entering event loop in 0.3s\n"
                 )
                 sys.stderr.flush()
@@ -3864,7 +4116,7 @@ def run_server():
                 pass
             if _restart_count > 20:
                 try:
-                    sys.stderr.write("[meshcode-mcp] too many restarts; exiting\n")
+                    sys.stderr.write("[meshcode] too many restarts; exiting\n")
                 except Exception:
                     pass
                 break
@@ -3896,7 +4148,7 @@ def run_server():
             pass
         try:
             sys.stderr.write(
-                "[meshcode-mcp] stdin EOF — Claude Code closed pipe (ESC, "
+                "[meshcode] stdin EOF — Claude Code closed pipe (ESC, "
                 "/mcp disconnect, or exit). State persisted to disk; next "
                 "MCP spawn will resume seamlessly. Exiting cleanly.\n"
             )

{meshcode-2.10.53 → meshcode-2.10.55}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.53 → meshcode-2.10.55}/pyproject.toml

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