meshcode 2.10.57__tar.gz → 2.10.59__tar.gz

{meshcode-2.10.57 → meshcode-2.10.59}/PKG-INFO

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

{meshcode-2.10.57 → meshcode-2.10.59}/meshcode/__init__.py

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

{meshcode-2.10.57 → meshcode-2.10.59}/meshcode/comms_v4.py

@@ -118,14 +118,14 @@ def _request(method, path, *, data=None, prefer=None):
             msg = err_obj.get("message", err[:200])
             # Daily message limit trigger raises a friendly message
             if "Daily message limit reached" in msg:
-                print(f"[QUOTA] {msg}", file=sys.stderr)
+                print(f"[meshcode] QUOTA: {msg}", file=sys.stderr)
             else:
                 print(f"[meshcode] ERROR: {method} {path}: {e.code} {msg}", file=sys.stderr)
         except Exception:
             print(f"[meshcode] ERROR: {method} {path}: {e.code} {err[:200]}", file=sys.stderr)
         return None
     except URLError as e:
-        print(f"[meshcode] ERROR: Network: {e.reason}", file=sys.stderr)
+        print(f"[meshcode] ERROR: network: {e.reason}", file=sys.stderr)
         return None
 
 
@@ -188,11 +188,11 @@ def sb_rpc(fn_name, params):
             msg = err_obj.get("message", err_body[:200])
         except Exception:
             msg = err_body[:200] if err_body else str(e)
-        print(f"[ERROR] rpc:{fn_name}: {e.code} {msg}", file=sys.stderr)
+        print(f"[meshcode] ERROR: rpc:{fn_name}: {e.code} {msg}", file=sys.stderr)
         log_error(f"rpc:{fn_name}", f"{e.code} {msg}", json.dumps(params, default=str)[:200])
         return None
     except URLError as e:
-        print(f"[ERROR] rpc:{fn_name}: network error: {e.reason}", file=sys.stderr)
+        print(f"[meshcode] ERROR: rpc:{fn_name}: network error: {e.reason}", file=sys.stderr)
         log_error(f"rpc:{fn_name}", f"network: {e.reason}", json.dumps(params, default=str)[:200])
         return None
 
@@ -2028,16 +2028,26 @@ def cmd_doctor(flags, pos):
     api_key = _load_api_key_for_cli()
     if api_key:
         try:
-            r = sb_rpc("mc_resolve_project", {"p_api_key": api_key, "p_project_name": "*"})
             # Try listing all projects for this user
-            projects_data = sb_rpc("mc_list_user_projects", {"p_api_key": api_key})
+            raw = sb_rpc("mc_list_user_projects", {"p_api_key": api_key})
+            # RPC returns {"projects": [...]} or a list directly
+            if isinstance(raw, dict) and "projects" in raw:
+                projects_data = raw["projects"]
+            elif isinstance(raw, list):
+                projects_data = raw
+            else:
+                projects_data = None
             if isinstance(projects_data, list):
                 stale_agents = []  # (project_id, agent_name)
                 for proj in projects_data[:5]:
                     pid = proj.get("id") or proj.get("project_id")
                     if not pid:
                         continue
-                    agents = sb_select("mc_agents", f"project_id=eq.{pid}")
+                    # mc_list_user_projects includes agents inline
+                    agents = proj.get("agents", [])
+                    if not agents:
+                        # Fallback: fetch from table if RPC didn't include agents
+                        agents = sb_select("mc_agents", f"project_id=eq.{pid}")
                     if isinstance(agents, list):
                         for a in agents:
                             hb = a.get("last_heartbeat", "")
@@ -2230,6 +2240,7 @@ MESSAGING:
 
 STATUS:
   board <proj>                               Agent status board
+  update <proj> <name> <status> [task]       Update agent status
   status [proj]                              Overview
   projects | list | ls                       List your meshworks
 
@@ -2260,12 +2271,12 @@ AGENT CONTROL:
 DIAGNOSTICS:
   doctor [--fix]                             Diagnose setup issues
   compat                                     Claude Code version compatibility
+  upgrade                                    Upgrade meshcode to latest version
 
 ADMIN:
   clear <proj> <name>                        Clear inbox
   unregister <proj> <name>                   Leave project
   prefs                                      View/set preferences
-  update                                     Check for package updates
 
 PROFILES (multi-account):
   profiles                                   List stored keychain profiles
@@ -2289,6 +2300,14 @@ an account, then prompts you to paste your API key.
 
 After init, run:
   meshcode go <agent-name> --project <meshwork-name>
+""",
+    "upgrade": """meshcode upgrade
+
+Check PyPI for the latest version and upgrade interactively.
+Supports both pip and pipx installs.
+
+EXAMPLES:
+  meshcode upgrade        # check + prompt to upgrade
 """,
     "doctor": """meshcode doctor [--fix]
 
@@ -2589,19 +2608,63 @@ if __name__ == "__main__":
             pass
 
     if cmd == "init":
-        # Guided onboarding: open signup page + prompt for API key
+        # Guided onboarding: try zero-config pairing first, then manual fallback
         import webbrowser
+        import time as _t
         print()
         print("  Welcome to MeshCode!")
         print("  " + "=" * 40)
         print()
-        print("  Step 1: Create your account")
-        print("  Opening meshcode.io in your browser...")
-        print()
+
+        # Try device-code pairing first
+        pairing = sb_rpc("mc_create_pairing_session", {})
+        if pairing and isinstance(pairing, dict) and pairing.get("ok"):
+            session_id = pairing["session_id"]
+            code = pairing["code"]
+            url = pairing["url"]
+            print(f"  Step 1: Open this link in your browser:")
+            print(f"  {url}")
+            print()
+            print(f"  Or go to meshcode.io/pair and enter code: {code}")
+            print()
+            try:
+                webbrowser.open(url)
+            except Exception:
+                pass
+            print("  Waiting for approval", end="", flush=True)
+            api_key = None
+            for _ in range(150):  # 150 * 2s = 5 minutes
+                _t.sleep(2)
+                print(".", end="", flush=True)
+                poll = sb_rpc("mc_poll_pairing_session", {"p_session_id": session_id})
+                if poll and isinstance(poll, dict):
+                    if poll.get("status") == "approved" and poll.get("api_key"):
+                        api_key = poll["api_key"]
+                        break
+                    elif poll.get("status") in ("expired", "consumed"):
+                        break
+            print()
+            if api_key:
+                print()
+                login(api_key)
+                print()
+                print("  Step 2: Create your first meshwork")
+                print("  Run: meshcode go <agent-name> --project <meshwork-name>")
+                print()
+                print("  Example:")
+                print("    meshcode go backend --project my-app")
+                print()
+                sys.exit(0)
+            else:
+                print("  Pairing timed out or was not approved.")
+                print()
+
+        # Fallback: manual API key paste
+        print("  Step 1: Create your account at meshcode.io")
         try:
             webbrowser.open("https://meshcode.io")
         except Exception:
-            print("  Could not open browser. Visit: https://meshcode.io")
+            print("  Visit: https://meshcode.io")
         print("  Step 2: Copy your API key from Settings")
         print()
         try:
@@ -2625,9 +2688,9 @@ if __name__ == "__main__":
 
     # Auth guard: commands that talk to Supabase need a valid API key.
     # doctor, help, version, login, prefs, launcher don't need auth.
-    _NO_AUTH_CMDS = {"doctor", "compat", "help", "--help", "-h", "login", "init",
-                     "prefs", "launcher", "--version", "-V", "version", "whoami",
-                     "profiles", "scan"}
+    _NO_AUTH_CMDS = {"doctor", "compat", "upgrade", "help", "--help", "-h", "login",
+                     "init", "prefs", "launcher", "--version", "-V", "version",
+                     "whoami", "profiles", "scan"}
     if cmd not in _NO_AUTH_CMDS:
         _cli_key = _load_api_key_for_cli()
         if not _cli_key:
@@ -2719,6 +2782,9 @@ if __name__ == "__main__":
         show_board(proj)
 
     elif cmd == "update":
+        if len(pos) < 3 and not flags.get("project"):
+            print(HELP_TEXTS.get("update", "meshcode update <project> <name> <status> [task]"))
+            sys.exit(0)
         proj = flags.get("project", pos[0] if len(pos) > 0 else "default")
         name = flags.get("name", pos[1] if len(pos) > 1 else "agent")
         st = flags.get("status", pos[2] if len(pos) > 2 else "online")
@@ -2753,7 +2819,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] Usage: meshcode validate-sessions <project>")
+            print("[meshcode] ERROR: Usage: meshcode validate-sessions <project>")
             sys.exit(1)
         ensure_sessions()
         prefix = f"{proj}_"
@@ -2779,7 +2845,7 @@ 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] Usage: meshcode wake-headless <project> <agent>")
+            print("[meshcode] ERROR: Usage: meshcode wake-headless <project> <agent>")
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
@@ -2795,7 +2861,7 @@ 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] Usage: meshcode {cmd} <project> <agent>")
+            print(f"[meshcode] ERROR: Usage: meshcode {cmd} <project> <agent>")
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
@@ -2814,7 +2880,7 @@ 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] Usage: meshcode profile get|set <project> <agent> [flags]")
+            print("[meshcode] ERROR: Usage: meshcode profile get|set <project> <agent> [flags]")
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
@@ -2839,7 +2905,7 @@ if __name__ == "__main__":
                 sys.exit(1)
             print(f"[{proj}] profile updated for {name}")
         else:
-            print(f"[ERROR] Unknown subcommand: {sub}. Use 'get' or 'set'.")
+            print(f"[meshcode] ERROR: Unknown subcommand: {sub}. Use 'get' or 'set'.")
             sys.exit(1)
 
     elif cmd == "connect":
@@ -3027,7 +3093,7 @@ if __name__ == "__main__":
     elif cmd == "login":
         key = sys.argv[2] if len(sys.argv) > 2 else ""
         if not key:
-            print("[ERROR] Usage: meshcode login <api_key>")
+            print("[meshcode] ERROR: Usage: meshcode login <api_key>")
             sys.exit(1)
         login(key)
 
@@ -3192,6 +3258,49 @@ if __name__ == "__main__":
             print("       meshcode prefs reset")
             sys.exit(1)
 
+    elif cmd == "upgrade":
+        # meshcode upgrade — interactive foreground upgrade
+        import importlib
+        _su = importlib.import_module("meshcode.self_update")
+        cur = _su._current_version()
+        print(f"\n  meshcode upgrade")
+        print(f"  {'=' * 40}")
+        print(f"  Current version: {cur}")
+        latest = _su.fetch_latest_version(timeout=5.0)
+        if not latest:
+            print(f"  Could not reach PyPI. Check your internet connection.")
+            sys.exit(1)
+        if not _su._is_newer(latest, cur):
+            print(f"  Already up to date ({cur}).")
+            sys.exit(0)
+        print(f"  Latest version:  {latest}")
+        print()
+        try:
+            confirm = input(f"  Upgrade to {latest}? [Y/n] ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            confirm = "n"
+            print()
+        if confirm in ("", "y", "yes"):
+            import subprocess as _sp
+            print(f"  Installing meshcode=={latest}...")
+            mode = "pipx" if _su.is_pipx_install() else "pip"
+            if mode == "pipx":
+                cmd_list = ["pipx", "upgrade", "meshcode"]
+            else:
+                cmd_list = [sys.executable, "-m", "pip", "install", "--disable-pip-version-check",
+                            f"meshcode=={latest}"]
+            result = _sp.run(cmd_list, capture_output=True, text=True, timeout=180)
+            if result.returncode == 0:
+                print(f"  Upgraded to {latest}. Restart your editor to use the new version.")
+            else:
+                print(f"  Upgrade failed (exit {result.returncode}).")
+                if result.stderr:
+                    print(f"  {result.stderr[:200]}")
+                sys.exit(1)
+        else:
+            print(f"  Upgrade cancelled.")
+        sys.exit(0)
+
     elif cmd == "compat":
         from meshcode.compat import check as cc_check, format_report, RECOMMENDED_VERSION
         version, status, entry = cc_check()
@@ -3218,6 +3327,31 @@ if __name__ == "__main__":
     elif cmd in ("help", "--help", "-h"):
         show_help()
 
+    elif cmd == "supervisor":
+        # meshcode supervisor start|stop|status [project] [agent]
+        import importlib
+        _sup = importlib.import_module("meshcode.supervisor")
+        sub = pos[0] if pos else "status"
+        if sub == "start":
+            if len(pos) < 3:
+                print("Usage: meshcode supervisor start <project> <agent>")
+                sys.exit(1)
+            _sup.start(pos[1], pos[2])
+        elif sub == "stop":
+            if len(pos) < 3:
+                print("Usage: meshcode supervisor stop <project> <agent>")
+                sys.exit(1)
+            _sup.stop(pos[1], pos[2])
+        elif sub == "status":
+            _sup.status()
+        elif sub == "--simple":
+            if len(pos) < 3:
+                print("Usage: meshcode supervisor --simple <project> <agent>")
+                sys.exit(1)
+            _sup.simple(pos[1], pos[2])
+        else:
+            print(f"Usage: meshcode supervisor [start|stop|status|--simple] <project> <agent>")
+
     else:
         known_cmds = [
             "register", "send", "broadcast", "read", "check", "watch", "inbox", "next",
@@ -3225,7 +3359,8 @@ if __name__ == "__main__":
             "history", "clear", "unregister", "connect", "disconnect",
             "setup", "run", "go", "invite", "join", "invites", "members",
             "revoke-invite", "revoke-member", "login", "prefs", "launcher",
-            "help", "init", "doctor", "compat", "profile", "validate-sessions", "wake-headless",
+            "help", "init", "doctor", "compat", "upgrade", "profile", "validate-sessions", "wake-headless",
+            "supervisor",
         ]
         # Simple fuzzy: prefix match + Levenshtein-like best match
         suggestions = [c for c in known_cmds if c.startswith(cmd)]

{meshcode-2.10.57 → meshcode-2.10.59}/meshcode/invites.py

@@ -71,10 +71,10 @@ def _rpc(name: str, body: Dict[str, Any]) -> Optional[Dict[str, Any]]:
             err_body = e.read().decode()
             return json.loads(err_body)
         except Exception:
-            print(f"[meshcode] HTTP {e.code} from {name}: {e.reason}", file=sys.stderr)
+            print(f"[meshcode] ERROR: HTTP {e.code} from {name}: {e.reason}", file=sys.stderr)
             return None
     except URLError as e:
-        print(f"[meshcode] network error calling {name}: {e.reason}", file=sys.stderr)
+        print(f"[meshcode] ERROR: network error calling {name}: {e.reason}", file=sys.stderr)
         return None
 
 

{meshcode-2.10.57 → meshcode-2.10.59}/meshcode/meshcode_mcp/backend.py

@@ -20,6 +20,38 @@ from urllib.parse import quote, urlparse
 from urllib.request import Request, urlopen
 
 
+# ── Normalised error envelope ───────────────────────────────────
+# Every internal error from _request() and sb_rpc() now returns:
+#   {"error": {"code": str, "message": str, "source": str}}
+# where:
+#   code    — HTTP status as string, "0" for network errors, "503" for circuit breaker
+#   message — human-readable description
+#   source  — "circuit_breaker", "http", "network", "rpc"
+#
+# Callers check with:  is_error(result)
+# Extract message:     get_error_message(result)
+
+def _make_error(message: str, *, code: str = "0", source: str = "unknown") -> Dict[str, Any]:
+    """Build a normalised error envelope."""
+    return {"error": {"code": str(code), "message": message, "source": source}}
+
+
+def is_error(result: Any) -> bool:
+    """Return True if *result* is a normalised error envelope."""
+    return (isinstance(result, dict)
+            and isinstance(result.get("error"), dict)
+            and "message" in result["error"])
+
+
+def get_error_message(result: Any) -> str:
+    """Extract the human-readable message from an error envelope (or '')."""
+    if is_error(result):
+        return result["error"]["message"]
+    if isinstance(result, dict) and isinstance(result.get("error"), str):
+        return result["error"]
+    return ""
+
+
 # ── Circuit Breaker ──────────────────────────────────────────────
 # Protects against cascading failures when Supabase is down.
 # States: CLOSED (normal) → OPEN (reject fast) → HALF_OPEN (probe)
@@ -126,11 +158,13 @@ class _CircuitBreaker:
                 )
                 log.warning("circuit breaker: half-open probe failed — OPEN (next probe in %ds)",
                             int(self._current_recovery_timeout))
+                self._emit_cb_telemetry("half_open_failed", len(self._failures))
             elif len(self._failures) >= self.failure_threshold:
                 self.state = self.OPEN
                 self._opened_at = now
                 log.warning("circuit breaker: %d failures in %ds window — OPEN",
                             len(self._failures), int(self._window_seconds))
+                self._emit_cb_telemetry("threshold_exceeded", len(self._failures))
 
     @property
     def is_open(self) -> bool:
@@ -165,6 +199,18 @@ class _CircuitBreaker:
     def _failures_suppressed(self) -> bool:
         return getattr(self._suppress_failures, "active", False)
 
+    @staticmethod
+    def _emit_cb_telemetry(reason: str, failure_count: int) -> None:
+        """JSON telemetry for circuit breaker state changes."""
+        import json as _j, sys as _sys
+        try:
+            record = {"event": "circuit_breaker", "reason": reason,
+                      "failure_count": failure_count, "ts": _time.time()}
+            _sys.stderr.write(f"[meshcode-telemetry] {_j.dumps(record)}\n")
+            _sys.stderr.flush()
+        except Exception:
+            pass
+
 
 _circuit = _CircuitBreaker(failure_threshold=5, recovery_timeout=10.0,
                            max_recovery_timeout=60.0, window_seconds=60.0,
@@ -308,7 +354,8 @@ def _request(method: str, path: str, *, data: Any = None, prefer: Optional[str]
              _max_retries: int = 3) -> Any:
     import random as _random
     if not _circuit.can_execute():
-        return {"_error": "circuit breaker open — Supabase temporarily unavailable", "_code": 503}
+        return _make_error("circuit breaker open — Supabase temporarily unavailable",
+                           code="503", source="circuit_breaker")
     rest_path = f"/rest/v1/{path}"
     body = json.dumps(data).encode("utf-8") if data else None
     hdrs = _headers(prefer=prefer)
@@ -324,9 +371,10 @@ def _request(method: str, path: str, *, data: Any = None, prefer: Optional[str]
                 _circuit.record_success()
                 try:
                     err_obj = json.loads(raw)
-                    return {"_error": err_obj.get("message", raw[:200]), "_code": status}
+                    return _make_error(err_obj.get("message", raw[:200]),
+                                       code=str(status), source="http")
                 except Exception:
-                    return {"_error": raw[:200], "_code": status}
+                    return _make_error(raw[:200], code=str(status), source="http")
             else:
                 # 5xx — transient, retry
                 last_err = raw[:200]
@@ -340,7 +388,8 @@ def _request(method: str, path: str, *, data: Any = None, prefer: Optional[str]
             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}
+    return _make_error(str(last_err)[:200] if last_err else "request failed after retries",
+                       code="0", source="network")
 
 
 def sb_select(table: str, filters: str = "", order: Optional[str] = None, limit: Optional[int] = None) -> List[Dict]:
@@ -353,7 +402,7 @@ def sb_select(table: str, filters: str = "", order: Optional[str] = None, limit:
         params.append(f"limit={limit}")
     path = f"{table}?{'&'.join(params)}" if params else table
     result = _request("GET", path)
-    if isinstance(result, dict) and result.get("_error"):
+    if is_error(result):
         return []
     return result or []
 
@@ -404,7 +453,8 @@ def enable_recording(api_key: str, project_id: str, agent_name: str, session_id:
 def sb_rpc(fn_name: str, params: Dict, *, _max_retries: int = 3) -> Any:
     import random as _random
     if not _circuit.can_execute():
-        return {"_error": "circuit breaker open — Supabase temporarily unavailable", "_circuit": "open"}
+        return _make_error("circuit breaker open — Supabase temporarily unavailable",
+                           code="503", source="circuit_breaker")
     last_err = None
     rpc_path = f"/rest/v1/rpc/{fn_name}"
     body = json.dumps(params).encode("utf-8")
@@ -421,12 +471,12 @@ def sb_rpc(fn_name: str, params: Dict, *, _max_retries: int = 3) -> Any:
             elif 400 <= status < 500:
                 _circuit.record_success()
                 try:
-                    result = {"_error": json.loads(raw).get("message", raw[:200])}
+                    msg = json.loads(raw).get("message", raw[:200])
                 except Exception:
-                    result = {"_error": raw[:200]}
+                    msg = raw[:200]
                 if _recording_enabled and fn_name not in _SKIP_RECORDING:
                     _bg_record("error", {"rpc": fn_name, "error": raw[:200]})
-                return result
+                return _make_error(msg, code=str(status), source="rpc")
             else:
                 last_err = raw[:200]
         except (KeyboardInterrupt, SystemExit):
@@ -444,7 +494,8 @@ def sb_rpc(fn_name: str, params: Dict, *, _max_retries: int = 3) -> Any:
     _circuit.record_failure()
     if _recording_enabled and fn_name not in _SKIP_RECORDING:
         _bg_record("error", {"rpc": fn_name, "error": str(last_err)[:200], "retries_exhausted": True})
-    return {"_error": str(last_err)[:200] if last_err else "request failed after retries"}
+    return _make_error(str(last_err)[:200] if last_err else "request failed after retries",
+                       code="0", source="network")
 
 
 def _bg_record(event_type: str, payload: dict):
@@ -519,8 +570,8 @@ def register_agent(project: str, name: str, role: str = "", api_key: Optional[st
         params["p_api_key"] = api_key
     result = sb_rpc("mc_register_agent", params)
 
-    if not result or (isinstance(result, dict) and result.get("error")):
-        return result or {"error": "Failed to register agent"}
+    if not result or is_error(result):
+        return {"error": get_error_message(result) or "Failed to register agent"}
 
     # Prefer SECURITY DEFINER RPC for mc_agents update
     _ak = api_key or _get_api_key()
@@ -694,8 +745,8 @@ def send_message(project_id: str, from_agent: str, to_agent: str, payload: Any,
             return out
         # If RPC returned an error, propagate it — do NOT fall through to
         # direct insert (RLS blocks anon INSERT since migration 089).
-        if isinstance(result, dict) and result.get("error"):
-            return {"error": result["error"]}
+        if is_error(result):
+            return {"error": get_error_message(result)}
         # RPC returned unexpected shape but didn't error — treat as success
         if result is not None:
             return {"sent": True}
@@ -717,8 +768,8 @@ def send_message(project_id: str, from_agent: str, to_agent: str, payload: Any,
     if sensitive:
         msg["is_sensitive"] = True
     result = sb_insert("mc_messages", msg)
-    if isinstance(result, dict) and result.get("_error"):
-        return {"error": result["_error"]}
+    if is_error(result):
+        return {"error": get_error_message(result)}
     if isinstance(result, list) and result:
         return {"sent": True, "msg_id": result[0].get("id")}
     return {"sent": True}
@@ -1013,8 +1064,8 @@ def set_status(project_id: str, agent: str, status: str, task: str = "", api_key
             return {"ok": True, "status": status}
     # Final fallback: direct PATCH (may silently fail with anon key if RLS blocks)
     result = sb_update("mc_agents", f"project_id=eq.{project_id}&name=eq.{quote(agent)}", fields)
-    if isinstance(result, dict) and result.get("_error"):
-        return {"error": result["_error"]}
+    if is_error(result):
+        return {"error": get_error_message(result)}
     return {"ok": True, "status": status}
 
 
@@ -1107,7 +1158,7 @@ def get_message_by_id(project_id: str, msg_id: str, api_key: Optional[str] = Non
         })
         if isinstance(rpc_result, dict) and rpc_result.get("ok"):
             return rpc_result.get("message")
-        if isinstance(rpc_result, dict) and rpc_result.get("error"):
+        if is_error(rpc_result):
             return None
         # Fall through to direct query if RPC doesn't exist yet
 

{meshcode-2.10.57 → meshcode-2.10.59}/meshcode/meshcode_mcp/realtime.py

@@ -385,14 +385,41 @@ class RealtimeListener:
         except asyncio.TimeoutError:
             return False
 
+    # Restart circuit breaker: prevent infinite restart cascades.
+    # After 3 restarts in 120s, enter cooldown (no restarts for 60s).
+    _restart_times: list = []
+    _restart_cooldown_until: float = 0.0
+    _RESTART_MAX = 3
+    _RESTART_WINDOW = 120.0
+    _RESTART_COOLDOWN = 60.0
+
     async def restart(self) -> None:
         """Stop and restart the Realtime connection.
 
         Called by the heartbeat thread when it detects the subscription
-        dropped (is_subscribed=False). The outer _run() loop handles
-        reconnect with exponential backoff.
+        dropped (is_subscribed=False). Has a circuit breaker: after 3
+        restarts in 120s, enters 60s cooldown to prevent cascade.
         """
-        log.info(f"Realtime restart requested for {self.agent_name}")
+        import time as _t
+        now = _t.time()
+        # Cooldown check
+        if now < self._restart_cooldown_until:
+            log.warning(
+                f"Realtime restart SUPPRESSED — in cooldown until "
+                f"{self._restart_cooldown_until - now:.0f}s from now"
+            )
+            return
+        # Prune old restart times
+        self._restart_times = [t for t in self._restart_times if now - t < self._RESTART_WINDOW]
+        if len(self._restart_times) >= self._RESTART_MAX:
+            self._restart_cooldown_until = now + self._RESTART_COOLDOWN
+            log.error(
+                f"Realtime restart cascade detected ({self._RESTART_MAX} restarts in "
+                f"{self._RESTART_WINDOW}s) — entering {self._RESTART_COOLDOWN}s cooldown"
+            )
+            return
+        self._restart_times.append(now)
+        log.info(f"Realtime restart requested for {self.agent_name} (#{len(self._restart_times)})")
         await self.stop()
         await self.start()
 
@@ -424,8 +451,9 @@ class RealtimeListener:
     @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
+        any events for >120s. Raised from 60s to prevent restart cascades
+        for agents in persistent wait (e.g. commander always in meshcode_wait)."""
+        return self.is_subscribed and self.seconds_since_last_event > 120.0
 
     @property
     def deaf_restart_count(self) -> int: