meshcode 2.10.36__tar.gz → 2.10.37__tar.gz

{meshcode-2.10.36 → meshcode-2.10.37}/PKG-INFO

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

{meshcode-2.10.36 → meshcode-2.10.37}/meshcode/__init__.py

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

{meshcode-2.10.36 → meshcode-2.10.37}/meshcode/meshcode_mcp/backend.py

@@ -105,69 +105,81 @@ SCHEMA = "meshcode"
 # ── Persistent HTTPS Connection Pool ──────────────────────────────
 # Each urlopen() opens a new TCP+TLS connection (~1-2s overhead).
 # This pool reuses connections, cutting typical latency from ~3s to ~100ms.
+# Pool of N connections (default 3) to avoid lock contention between the
+# heartbeat thread, tool call handlers, and background recording thread.
 class _ConnectionPool:
-    """Thread-safe persistent HTTPS connection to Supabase."""
+    """Thread-safe HTTPS connection pool to Supabase (N connections, round-robin)."""
 
-    def __init__(self, url: str, max_idle: float = 30.0):
+    def __init__(self, url: str, pool_size: int = 3, max_idle: float = 30.0):
         parsed = urlparse(url)
         self._host = parsed.hostname
         self._port = parsed.port or 443
-        self._conn: Optional[http.client.HTTPSConnection] = None
-        self._lock = _threading.Lock()
+        self._pool_size = pool_size
+        self._conns: List[Optional[http.client.HTTPSConnection]] = [None] * pool_size
+        self._locks = [_threading.Lock() for _ in range(pool_size)]
+        self._last_used = [0.0] * pool_size
         self._max_idle = max_idle
-        self._last_used = 0.0
         self._ctx = ssl.create_default_context()
+        self._counter = 0
+        self._counter_lock = _threading.Lock()
+
+    def _pick_slot(self) -> int:
+        """Round-robin slot selection."""
+        with self._counter_lock:
+            slot = self._counter % self._pool_size
+            self._counter += 1
+        return slot
 
-    def _get_conn(self) -> http.client.HTTPSConnection:
+    def _get_conn(self, slot: int) -> http.client.HTTPSConnection:
         now = _time.monotonic()
-        if self._conn is not None:
-            # Close stale connections
-            if now - self._last_used > self._max_idle:
+        if self._conns[slot] is not None:
+            if now - self._last_used[slot] > self._max_idle:
                 try:
-                    self._conn.close()
+                    self._conns[slot].close()
                 except Exception:
                     pass
-                self._conn = None
-        if self._conn is None:
-            self._conn = http.client.HTTPSConnection(
+                self._conns[slot] = None
+        if self._conns[slot] is None:
+            self._conns[slot] = http.client.HTTPSConnection(
                 self._host, self._port, timeout=10, context=self._ctx
             )
-        return self._conn
+        return self._conns[slot]
 
     def request(self, method: str, path: str, body: Optional[bytes], headers: Dict[str, str]) -> tuple:
-        """Returns (status, response_body_str). Thread-safe with retry on broken pipe."""
-        with self._lock:
+        """Returns (status, response_body_str). Thread-safe with per-slot locking."""
+        slot = self._pick_slot()
+        with self._locks[slot]:
             for attempt in range(2):
-                conn = self._get_conn()
+                conn = self._get_conn(slot)
                 try:
                     conn.request(method, path, body=body, headers=headers)
                     resp = conn.getresponse()
                     data = resp.read().decode("utf-8")
-                    self._last_used = _time.monotonic()
+                    self._last_used[slot] = _time.monotonic()
                     return resp.status, data
                 except (http.client.RemoteDisconnected, BrokenPipeError,
                         ConnectionResetError, OSError) as e:
-                    # Connection went stale — close and retry once
                     try:
-                        self._conn.close()
+                        self._conns[slot].close()
                     except Exception:
                         pass
-                    self._conn = None
+                    self._conns[slot] = None
                     if attempt == 0:
                         continue
                     raise
 
     def close(self):
-        with self._lock:
-            if self._conn:
-                try:
-                    self._conn.close()
-                except Exception:
-                    pass
-                self._conn = None
+        for i in range(self._pool_size):
+            with self._locks[i]:
+                if self._conns[i]:
+                    try:
+                        self._conns[i].close()
+                    except Exception:
+                        pass
+                    self._conns[i] = None
 
 
-_pool = _ConnectionPool(SUPABASE_URL)
+_pool = _ConnectionPool(SUPABASE_URL, pool_size=3)
 
 
 def _now_iso() -> str:

{meshcode-2.10.36 → meshcode-2.10.37}/meshcode/meshcode_mcp/realtime.py

@@ -53,9 +53,12 @@ class RealtimeListener:
         self.notify_callback = notify_callback
         self.service_role_key = service_role_key
 
-        # Last 500 unread messages — drained by meshcode_check tool
-        self.queue: Deque[Dict] = deque(maxlen=500)
+        # Message queue — drained by meshcode_check/meshcode_wait.
+        # Cap at 2000 (was 500). When full, oldest messages are dropped
+        # and _dropped_count is incremented so the agent knows.
+        self.queue: Deque[Dict] = deque(maxlen=2000)
         self._overflow_warned = False
+        self._dropped_count = 0
         self._task: Optional[asyncio.Task] = None
         # asyncio.Event() in Py3.10+ no longer requires a running loop, but
         # on older Python or certain Windows event-loop policies it can
@@ -272,9 +275,14 @@ class RealtimeListener:
                         "id": record.get("id"),
                         "parent_id": record.get("parent_msg_id"),
                     }
-                    if len(self.queue) >= 400 and not self._overflow_warned:
-                        log.warning(f"Message queue at {len(self.queue)}/500 — risk of dropping messages")
-                        self._overflow_warned = True
+                    if len(self.queue) >= self.queue.maxlen:
+                        # Queue is full — this append will drop the oldest message
+                        self._dropped_count += 1
+                        if not self._overflow_warned:
+                            log.warning(f"Message queue FULL ({self.queue.maxlen}) — dropping oldest messages ({self._dropped_count} dropped so far)")
+                            self._overflow_warned = True
+                    elif len(self.queue) >= self.queue.maxlen * 0.8 and not self._overflow_warned:
+                        log.warning(f"Message queue at {len(self.queue)}/{self.queue.maxlen} — approaching limit")
                     self.queue.append(enriched)
                     # Wake any meshcode_wait blocked on this event.
                     try:
@@ -327,6 +335,10 @@ class RealtimeListener:
         await self.stop()
         await self.start()
 
+    @property
+    def dropped_count(self) -> int:
+        return self._dropped_count
+
     @property
     def is_connected(self) -> bool:
         return self._connected

{meshcode-2.10.36 → meshcode-2.10.37}/meshcode/meshcode_mcp/server.py

@@ -864,6 +864,19 @@ except Exception as _e:
     log.warning(f"could not fetch agent profile: {_e}")
 
 
+# ── Leader/commander detection (single source of truth) ───────
+_LEADER_KEYWORDS = (
+    'commander', 'lead', 'orchestrat', 'coordinator', 'coordinat',
+    'coordinad', 'jefe', 'líder', 'lider', 'director', 'manager',
+    'chief', 'captain', 'boss', 'head agent',
+)
+
+def _is_leader_agent() -> bool:
+    """Check if this agent is a leader/commander based on name + role keywords."""
+    haystack = ((_ROLE_DESCRIPTION or '') + ' ' + AGENT_NAME).lower()
+    return any(k in haystack for k in _LEADER_KEYWORDS)
+
+
 def _build_instructions() -> str:
     """Build the system-instructions block injected via the MCP InitializeResult.
 
@@ -939,15 +952,7 @@ what CLI command to run next (e.g. "meshcode run backend in a new terminal").
 Setup help → README.md or https://meshcode.io/docs
 """
     # Inject commander protocol if this agent is a leader
-    # Match leader-like agent names and roles across languages.
-    # Substring match: "orchestrator" hits on "orchestrat", "coordinador" hits on "coordinat".
-    _leader_haystack = ((_ROLE_DESCRIPTION or '') + ' ' + AGENT_NAME).lower()
-    _LEADER_KEYWORDS = (
-        'commander', 'lead', 'orchestrat', 'coordinator', 'coordinat',
-        'coordinad', 'jefe', 'líder', 'lider', 'director', 'manager',
-        'chief', 'captain', 'boss', 'head agent',
-    )
-    is_leader = any(k in _leader_haystack for k in _LEADER_KEYWORDS)
+    is_leader = _is_leader_agent()
     if is_leader:
         base += """
 COMMANDER PROTOCOL (you are the team lead):
@@ -1612,11 +1617,7 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
         ]
         # For leader agents: also include unclaimed '*' tasks as pending
         # so commanders auto-triage them instead of letting them pile up.
-        _leader_haystack = ((_ROLE_DESCRIPTION or '') + ' ' + AGENT_NAME).lower()
-        _LEADER_KW = ('commander', 'lead', 'orchestrat', 'coordinator', 'coordinat',
-                       'coordinad', 'jefe', 'líder', 'lider', 'director', 'manager',
-                       'chief', 'captain', 'boss', 'head agent')
-        is_leader = any(k in _leader_haystack for k in _LEADER_KW)
+        is_leader = _is_leader_agent()
         if is_leader:
             wildcard_tasks = [
                 {"id": t["id"][:8], "title": t["title"][:80], "priority": t.get("priority", "normal"), "status": t["status"]}
@@ -1626,6 +1627,9 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
                 and not t.get("claimed_by")
             ]
             pending.extend(wildcard_tasks)
+        # Sort by priority so urgent tasks surface first
+        _PRIORITY_ORDER = {"urgent": 0, "high": 1, "normal": 2, "low": 3}
+        pending.sort(key=lambda t: _PRIORITY_ORDER.get(t.get("priority", "normal"), 2))
         return pending if pending else None
     except Exception:
         return None
@@ -1655,12 +1659,7 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
     # delegate tasks and need to stay in the wait loop to receive reports.
     pending_tasks = _get_pending_tasks_summary()
     if pending_tasks:
-        _leader_haystack = ((_ROLE_DESCRIPTION or '') + ' ' + AGENT_NAME).lower()
-        _LEADER_KW = ('commander', 'lead', 'orchestrat', 'coordinator', 'coordinat',
-                       'coordinad', 'jefe', 'líder', 'lider', 'director', 'manager',
-                       'chief', 'captain', 'boss', 'head agent')
-        _is_leader = any(k in _leader_haystack for k in _LEADER_KW)
-        if not _is_leader:
+        if not _is_leader_agent():
             return {
                 "refused": True,
                 "reason": "You have open tasks. Work them before entering wait.",
@@ -2671,12 +2670,29 @@ def meshcode_recall(key: Optional[str] = None) -> Dict[str, Any]:
             "p_key": key,
         })
     else:
-        return be.sb_rpc("mc_memory_list", {
+        # Return critical tier (full content) + counts of other tiers.
+        # Episodic memories are large and should be searched on demand
+        # via meshcode_recall_search(), not dumped into context.
+        critical = be.sb_rpc("mc_memory_list", {
             "p_api_key": api_key,
             "p_agent_name": AGENT_NAME,
             "p_tier": "critical",
             "p_project_name": PROJECT_NAME,
         })
+        # Also fetch reference tier keys (lightweight, useful context)
+        reference = be.sb_rpc("mc_memory_list", {
+            "p_api_key": api_key,
+            "p_agent_name": AGENT_NAME,
+            "p_tier": "reference",
+            "p_project_name": PROJECT_NAME,
+        })
+        if isinstance(critical, dict) and critical.get("ok"):
+            ref_keys = []
+            if isinstance(reference, dict) and reference.get("ok"):
+                ref_keys = [m.get("key") for m in reference.get("memories", [])]
+            critical["reference_keys"] = ref_keys
+            critical["tip"] = "Use meshcode_recall_search(query) to search episodic memories."
+        return critical
 
 
 @mcp.tool()

{meshcode-2.10.36 → meshcode-2.10.37}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.36 → meshcode-2.10.37}/pyproject.toml

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