meshcode 2.11.141__tar.gz → 2.11.143__tar.gz

{meshcode-2.11.141 → meshcode-2.11.143}/PKG-INFO

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

{meshcode-2.11.141 → meshcode-2.11.143}/meshcode/__init__.py

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

{meshcode-2.11.141 → meshcode-2.11.143}/meshcode/meshcode_mcp/backend.py

@@ -1297,6 +1297,29 @@ def set_status(project_id: str, agent: str, status: str, task: str = "", api_key
     return {"ok": True, "status": status}
 
 
+def loop_tick(api_key: str, project_id: str, agent: str,
+              since_ts: Optional[str] = None, msg_limit: int = 20,
+              task_limit: int = 10) -> Dict:
+    """mc_agent_loop_tick: 1 RPC replaces count_pending + task_list + heartbeat.
+
+    Returns pending_count, new_messages_since, new_tasks_since, heartbeat_set
+    in one round-trip. Falls back to None on any error so callers can use legacy.
+    """
+    params: Dict[str, Any] = {
+        "p_api_key": api_key,
+        "p_project_id": project_id,
+        "p_agent": agent,
+        "p_msg_limit": msg_limit,
+        "p_task_limit": task_limit,
+    }
+    if since_ts:
+        params["p_since_ts"] = since_ts
+    result = sb_rpc("mc_agent_loop_tick", params)
+    if isinstance(result, dict) and result.get("ok"):
+        return result
+    return {"ok": False, "error": result}
+
+
 def task_create(api_key, project_id, creator_agent, title, description="",
                 assignee="*", priority="normal", parent_task_id=None,
                 goal_id=None, strict=False,

{meshcode-2.11.141 → meshcode-2.11.143}/meshcode/meshcode_mcp/server.py

@@ -3727,6 +3727,28 @@ def _wait_poll_or_legacy() -> Dict[str, Any]:
     }
 
 
+# ── LOOP TICK (mig 311): 1 RPC replaces task_list + count_pending + heartbeat ──
+_LAST_LOOP_TICK_TS: Optional[str] = None  # ISO ts from server for incremental polling
+
+
+def _loop_tick() -> Optional[Dict[str, Any]]:
+    """Call mc_agent_loop_tick: pending_count + messages + tasks + heartbeat in 1 RPC.
+    Returns None on any error so callers fall back to legacy multi-RPC path."""
+    global _LAST_LOOP_TICK_TS
+    try:
+        api_key = _get_api_key()
+        if not api_key:
+            return None
+        result = be.loop_tick(api_key, _PROJECT_ID, AGENT_NAME,
+                              since_ts=_LAST_LOOP_TICK_TS)
+        if isinstance(result, dict) and result.get("ok"):
+            _LAST_LOOP_TICK_TS = result.get("server_now")
+            return result
+    except Exception as e:
+        log.debug(f"[meshcode] mc_agent_loop_tick failed; legacy fallback: {e}")
+    return None
+
+
 def _drain_unread_response(include_acks: bool,
                            rpc_result: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
     """SDK-EFF (task ab1f9f5a): read+mark unread DB messages and shape them as
@@ -4396,10 +4418,12 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
     # offline at create time" gap. Always-on, not gated on
     # autonomous_mode. Best-effort.
     try:
-        # SDK-EFF (task ab1f9f5a): ONE mc_task_list serves both the auto-claim
-        # sweep and the pending summary below — they were identical back-to-back
-        # fetches. The post-claim snapshot stays valid for _pending_filter:
-        # a just-claimed task still matches on assignee==me with status 'open'.
+        # LOOP-TICK (mig 311 adoption, task f81a5060): mc_agent_loop_tick
+        # gives pending_count + heartbeat in 1 RPC (replaces count_pending).
+        # task_list is kept for auto-claim sweep because new_tasks_since is
+        # incremental and could miss older unclaimed tasks (commander review).
+        _entry_tick = _loop_tick()
+        _entry_tick_pending = _entry_tick.get("pending_count", 0) or 0 if _entry_tick else 0
         _entry_tasks_raw = None
         try:
             _tl = be.task_list(_get_api_key(), _PROJECT_ID, AGENT_NAME, status_filter=None)
@@ -4410,6 +4434,7 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
         _wait_entry_auto_claimed = _try_auto_claim_self_assigned_tasks(tasks=_entry_tasks_raw)
     except Exception:
         _wait_entry_auto_claimed = []
+        _entry_tick_pending = 0
 
     pending_tasks = (_pending_filter(_entry_tasks_raw) if _entry_tasks_raw is not None
                      else _get_pending_tasks_summary())
@@ -4447,13 +4472,14 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
     # ("te escribo y no sale palomita azul en nadie"). If there are unread messages,
     # skip task_pull and fall through to PRODUCT RULE 2 so they get delivered + marked
     # read first. Task-pull still fires normally when the inbox is empty.
-    # SDK-EFF (task ab1f9f5a): count once, share with PRODUCT RULE 2 below —
-    # the entry path was issuing the identical count_pending twice in a row.
-    _entry_db_pending = 0
-    try:
-        _entry_db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key()) or 0
-    except Exception:
-        _entry_db_pending = 0
+    # LOOP-TICK: reuse pending_count from _loop_tick (already fetched above).
+    # Falls back to count_pending RPC only if loop_tick didn't run.
+    _entry_db_pending = _entry_tick_pending
+    if not _entry_db_pending and not _entry_tick:
+        try:
+            _entry_db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key()) or 0
+        except Exception:
+            _entry_db_pending = 0
     _has_unread = bool(_entry_db_pending)
     if _tasks_to_start and not _is_leader_agent() and not _has_unread:
         # Auto-start the highest priority OPEN task so the agent sees it as
@@ -4952,6 +4978,8 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
     else:
         # 2b) Realtime NOT subscribed — aggressive DB polling every 5s
         # so messages arrive within seconds, not after 120s timeout.
+        # LOOP-TICK (task f81a5060): use mc_agent_loop_tick (1 RPC) instead
+        # of count_pending + read_inbox (2 RPCs). Falls back to legacy on error.
         _poll_interval = 5
         _elapsed = 0
         while _elapsed < actual_timeout:
@@ -4962,10 +4990,18 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
                 return {"timed_out": True, "reason": "cancelled_by_client"}
             _elapsed += _poll_interval
             try:
-                api_key = _get_api_key()
-                if api_key:
-                    db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=api_key)
-                    if db_pending and db_pending > 0:
+                _tick = _loop_tick()
+                _has_pending = False
+                if _tick:
+                    _has_pending = bool(_tick.get("pending_count", 0))
+                else:
+                    # Fallback: legacy count_pending
+                    api_key = _get_api_key()
+                    if api_key:
+                        _has_pending = bool(be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=api_key))
+                if _has_pending:
+                    api_key = _get_api_key()
+                    if api_key:
                         raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=api_key)
                         if raw:
                             msgs = [
@@ -7791,12 +7827,16 @@ def meshcode_health() -> Dict[str, Any]:
         health["uptime_seconds"] = "unknown (psutil not available)"
 
     # Server-side system health (aggregate metrics from DB)
+    # mig 558: pass p_project_id to scope active/stale counts to THIS mesh
     try:
-        sys_health = be.sb_rpc("mc_system_health", {})
+        sys_health = be.sb_rpc("mc_system_health", {"p_project_id": _PROJECT_ID})
         if isinstance(sys_health, dict) and sys_health.get("ok"):
             health["system"] = {
+                "scope": sys_health.get("scope", "global"),
                 "active_agents": sys_health.get("active_agent_count"),
+                "active_agents_global": sys_health.get("active_agent_count_global"),
                 "stale_agents": sys_health.get("stale_agent_count"),
+                "stale_agents_global": sys_health.get("stale_agent_count_global"),
                 "message_delivery_rate": sys_health.get("message_delivery_rate"),
                 "messages_1h": sys_health.get("total_messages_1h"),
                 "failed_rpcs_1h": sys_health.get("failed_rpc_count_1h"),

{meshcode-2.11.141 → meshcode-2.11.143}/meshcode/run_agent.py

@@ -32,6 +32,10 @@ from . import claude_update
 WORKSPACES_ROOT = Path.home() / "meshcode"
 REGISTRY_PATH = WORKSPACES_ROOT / ".registry.json"
 
+# Samuel directive 2026-06-17: all agents boot with the best model by default.
+# Overrides (settings.json "model" or mc_agent_model_pref RPC) still respected.
+PLATFORM_DEFAULT_MODEL = "opus"
+
 
 def _pretrust_claude_workspace(*paths) -> None:
     """Pre-trust workspace dirs in ~/.claude.json (task 2e6a8d63, Samuel
@@ -1351,6 +1355,12 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
         except Exception as _me:
             print(f"[meshcode]   model-pref skipped: {_me}", file=sys.stderr)
 
+        # Platform default: best model for all agents (Samuel directive 2026-06-17).
+        # Applied only when no explicit override was set via settings.json or model_pref RPC.
+        if "--model" not in cmd:
+            cmd += ["--model", PLATFORM_DEFAULT_MODEL]
+            print(f"[meshcode]   Model: {PLATFORM_DEFAULT_MODEL} (platform default)", file=sys.stderr)
+
         if mode == "bypass":
             bypass_check_cmd = effective_editor if not pinned_version else "claude"
             if pinned_version or _claude_supports_bypass(bypass_check_cmd):

{meshcode-2.11.141 → meshcode-2.11.143}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.141 → meshcode-2.11.143}/pyproject.toml

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