meshcode 2.10.36__tar.gz → 2.10.38__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.10.36
+Version: 2.10.38
 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.38}/meshcode/__init__.py

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

{meshcode-2.10.36 → meshcode-2.10.38}/meshcode/comms_v4.py

@@ -615,7 +615,7 @@ def spawn_headless_agent(project, name, project_id, message_body, from_agent):
         # The agent is identity-only at rest; next message wakes it again.
         sb_update("mc_agents",
                   f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-                  {"status": "sleeping", "task": "Esperando mensajes...",
+                  {"status": "sleeping", "task": "Waiting for messages...",
                    "last_active_at": now_iso(), "last_heartbeat": now_iso()})
     except Exception:
         pass
@@ -865,7 +865,7 @@ def register(project, name, role=""):
     ensure_sessions()
     project_id = get_project_id(project)
     if not project_id:
-        print(f"[ERROR] No se pudo crear/encontrar proyecto '{project}'")
+        print(f"[ERROR] Could not create/find project '{project}'")
         return
 
     ppid = os.getppid()
@@ -946,7 +946,7 @@ def register(project, name, role=""):
         order="created_at.desc", limit=10)
     if recent:
         recent.reverse()
-        print(f"\n[COMMS] Últimos {len(recent)} mensajes del equipo:")
+        print(f"\n[COMMS] Last {len(recent)} team messages:")
         for msg in recent:
             ts = msg.get("created_at", "")[-8:]
             fr = msg["from_agent"]
@@ -1132,7 +1132,7 @@ def watch(project, name, interval=10, timeout=0):
     # Update status to standby
     sb_update("mc_agents",
         f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-        {"status": "standby", "task": "Esperando mensajes...", "last_heartbeat": now_iso()})
+        {"status": "standby", "task": "Waiting for messages...", "last_heartbeat": now_iso()})
 
     cycle = timeout if timeout > 0 else 600
     print(f"[{project}] {name} en watch — poll cada {interval}s, ciclo {cycle}s (auto-loop)")
@@ -1161,10 +1161,10 @@ def watch(project, name, interval=10, timeout=0):
             time.sleep(interval)
 
         # Cycle ended without messages — check user context, then AUTO-RESTART watch
-        print(f"[{project}] Otro ciclo sin mensajes. Watch activo, sigue corriendo. En standby.")
+        print(f"[{project}] No messages this cycle. Watch active, still running. Standby.")
         sb_update("mc_agents",
             f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-            {"status": "standby", "task": "Esperando mensajes...", "last_heartbeat": now_iso()})
+            {"status": "standby", "task": "Waiting for messages...", "last_heartbeat": now_iso()})
 
 
 def update_board(project, name, status, task=""):
@@ -1183,7 +1183,7 @@ def update_board(project, name, status, task=""):
             print(f"[{project}] {name}: NO puedes estar idle — tienes {count} mensaje(s) pendientes.")
             print(f"[{project}] Ejecuta: python3 ~/Desktop/meshcode/comms_v4.py read {project} {name}")
             status = "working"
-            task = f"{count} mensajes pendientes"
+            task = f"{count} pending messages"
 
     updates = {"status": status, "last_heartbeat": now_iso()}
     if task:
@@ -1197,7 +1197,7 @@ def update_board(project, name, status, task=""):
 def show_board(project):
     project_id = get_project_id(project)
     if not project_id:
-        print(f"[{project}] Sin proyecto")
+        print(f"[{project}] Project not found")
         return
 
     agents = sb_select("mc_agents", f"project_id=eq.{project_id}", order="registered_at.asc")
@@ -1221,7 +1221,7 @@ def show_status(project=None):
         projects_data = sb_select("mc_projects", "", order="created_at.asc")
 
     if not projects_data:
-        print("[COMMS] Sin proyectos activos")
+        print("[COMMS] No active projects")
         return
 
     print(f"\n{'='*60}")
@@ -1266,7 +1266,7 @@ def show_history(project, last_n=20, between=None):
     messages.reverse()
 
     print(f"\n{'='*60}")
-    print(f" {project.upper()} — Historial ({len(messages)} mensajes)")
+    print(f" {project.upper()} — History ({len(messages)} messages)")
     if between:
         print(f" Filtro: {between}")
     print(f"{'='*60}\n")
@@ -1472,7 +1472,7 @@ def connect_terminal(project, name, role=""):
     ensure_sessions()
     project_id = get_project_id(project)
     if not project_id:
-        print(f"[ERROR] No se pudo crear/encontrar proyecto '{project}'")
+        print(f"[ERROR] Could not create/find project '{project}'")
         return
 
     tty, owning = _capture_tty_for_pid(os.getppid())
@@ -1542,7 +1542,7 @@ 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] proyecto '{project}' no encontrado")
+        print(f"[ERROR] project '{project}' not found")
         return
     rpc_result = sb_rpc("mc_disconnect_agent", {
         "p_project_id": project_id,
@@ -2177,7 +2177,7 @@ if __name__ == "__main__":
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
-            print(f"[ERROR] proyecto '{proj}' no encontrado")
+            print(f"[ERROR] project '{proj}' not found")
             sys.exit(1)
         ok = spawn_headless_agent(proj, name, project_id,
                                   "ping: synthetic wake-headless test message", "test-harness")
@@ -2193,7 +2193,7 @@ if __name__ == "__main__":
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
-            print(f"[ERROR] proyecto '{proj}' no encontrado")
+            print(f"[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})
@@ -2212,7 +2212,7 @@ if __name__ == "__main__":
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
-            print(f"[ERROR] proyecto '{proj}' no encontrado")
+            print(f"[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})
@@ -2425,7 +2425,30 @@ if __name__ == "__main__":
             sys.exit(1)
         login(key)
 
-    elif cmd in ("profiles", "whoami"):
+    elif cmd == "whoami":
+        # Show the logged-in user identity from profile_meta.json
+        meta_path = Path.home() / ".meshcode" / "profile_meta.json"
+        if meta_path.exists():
+            try:
+                meta = json.loads(meta_path.read_text(encoding="utf-8"))
+                print()
+                print(f"[meshcode] Logged in as:")
+                if meta.get("email"):
+                    print(f"  email:        {meta['email']}")
+                if meta.get("display_name"):
+                    print(f"  display name: {meta['display_name']}")
+                if meta.get("user_id"):
+                    print(f"  user ID:      {meta['user_id']}")
+                active = os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or "default"
+                print(f"  profile:      {active}")
+                print()
+            except Exception:
+                print("[meshcode] Could not read profile. Run `meshcode login <api_key>`.")
+        else:
+            print("[meshcode] Not logged in. Run `meshcode login <api_key>`.")
+        sys.exit(0)
+
+    elif cmd == "profiles":
         # List all stored keychain profiles with metadata
         try:
             import importlib as _il

{meshcode-2.10.36 → meshcode-2.10.38}/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.38}/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.38}/meshcode/meshcode_mcp/server.py

@@ -601,7 +601,9 @@ def with_working_status(func):
                 global _CONSECUTIVE_IDLE_SECONDS
                 _CONSECUTIVE_IDLE_SECONDS = 0  # any non-wait tool resets idle timer
                 _set_state("working", name)
-                _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys())})
+                # Estimate input tokens (chars/4) for usage tracking
+                _est_tokens = sum(len(str(v)) for v in kwargs.values()) // 4
+                _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys()), "estimated_tokens": _est_tokens})
             try:
                 return await func(*args, **kwargs)
             except Exception as e:
@@ -622,7 +624,8 @@ def with_working_status(func):
                 global _CONSECUTIVE_IDLE_SECONDS
                 _CONSECUTIVE_IDLE_SECONDS = 0  # any non-wait tool resets idle timer
                 _set_state("working", name)
-                _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys())})
+                _est_tokens = sum(len(str(v)) for v in kwargs.values()) // 4
+                _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys()), "estimated_tokens": _est_tokens})
             try:
                 return func(*args, **kwargs)
             except Exception as e:
@@ -864,6 +867,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 +955,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):
@@ -1507,6 +1515,88 @@ def meshcode_read(include_acks: bool = False) -> Dict[str, Any]:
     return split
 
 
+@mcp.tool()
+@with_working_status
+async def meshcode_call(to: str, function: str, args: Any = None, timeout_seconds: int = 30) -> Dict[str, Any]:
+    """Synchronous RPC call to another agent. Blocks until response (max 30s).
+
+    Sends a structured request, waits for the callee to respond with a matching
+    call_id. Like gRPC over the mesh — enables agents to ask each other questions
+    and get structured answers.
+
+    Args:
+        to: Target agent name.
+        function: Function/action name the callee should execute.
+        args: Arguments (any JSON-serializable value).
+        timeout_seconds: Max wait time (default 30, max 60).
+    """
+    import uuid as _uuid
+    if not to or not to.strip():
+        return {"error": "recipient 'to' cannot be empty"}
+    call_id = str(_uuid.uuid4())
+    timeout_seconds = min(max(timeout_seconds, 5), 60)
+
+    # Send the RPC request
+    request_payload = {
+        "type": "rpc_request",
+        "call_id": call_id,
+        "function": function,
+        "args": args,
+        "from": AGENT_NAME,
+        "timeout": timeout_seconds,
+    }
+    send_result = be.send_message(
+        _PROJECT_ID, AGENT_NAME, to, request_payload,
+        msg_type="rpc", api_key=_get_api_key()
+    )
+    if not send_result.get("sent") and send_result.get("error"):
+        return {"error": f"failed to send RPC request: {send_result['error']}"}
+
+    # Poll for response with matching call_id
+    import asyncio as _asyncio
+    poll_interval = 1.0
+    elapsed = 0.0
+    while elapsed < timeout_seconds:
+        await _asyncio.sleep(poll_interval)
+        elapsed += poll_interval
+
+        # Check Realtime buffer first
+        if _REALTIME:
+            for msg in _REALTIME.peek():
+                p = msg.get("payload") or {}
+                if isinstance(p, dict) and p.get("type") == "rpc_response" and p.get("call_id") == call_id:
+                    # Found response — drain it
+                    _REALTIME.drain()
+                    return {
+                        "ok": True,
+                        "call_id": call_id,
+                        "from": msg.get("from"),
+                        "result": p.get("result"),
+                        "error": p.get("error"),
+                    }
+
+        # Fallback: check DB
+        try:
+            raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_get_api_key())
+            for m in (raw if isinstance(raw, list) else raw.get("messages", []) if isinstance(raw, dict) else []):
+                p = m.get("payload") or {}
+                if isinstance(p, dict) and p.get("type") == "rpc_response" and p.get("call_id") == call_id:
+                    return {
+                        "ok": True,
+                        "call_id": call_id,
+                        "from": m.get("from_agent") or m.get("from"),
+                        "result": p.get("result"),
+                        "error": p.get("error"),
+                    }
+        except Exception:
+            pass
+
+        # Exponential backoff on polling (1s → 2s → 3s, cap 3s)
+        poll_interval = min(poll_interval + 0.5, 3.0)
+
+    return {"error": f"RPC call to {to}.{function} timed out after {timeout_seconds}s", "call_id": call_id}
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_history(limit: int = 20, agent_filter: Optional[str] = None) -> Dict[str, Any]:
@@ -1612,11 +1702,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 +1712,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 +1744,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.",
@@ -2267,6 +2351,49 @@ def meshcode_task_reassign(task_id: str, new_assignee: str) -> Dict[str, Any]:
     })
 
 
+# ----------------- SCHEDULED TASKS -----------------
+
+@mcp.tool()
+@with_working_status
+def meshcode_schedule(title: str, cron_expression: str, assignee: str = "*",
+                      description: str = "", priority: str = "normal") -> Dict[str, Any]:
+    """Create a recurring scheduled task. Fires on cron schedule.
+
+    Args:
+        title: Task title (created each time it fires).
+        cron_expression: Standard cron (e.g. "0 9 * * 1-5" = 9am weekdays).
+        assignee: Agent name or "*" for any.
+        description: Task description template.
+        priority: low/normal/high/urgent.
+    """
+    if not title or not title.strip():
+        return {"error": "title cannot be empty"}
+    if not cron_expression or not cron_expression.strip():
+        return {"error": "cron_expression cannot be empty"}
+    api_key = _get_api_key()
+    return be.sb_rpc("mc_schedule_create", {
+        "p_api_key": api_key,
+        "p_project_id": _PROJECT_ID,
+        "p_creator_agent": AGENT_NAME,
+        "p_title": title.strip(),
+        "p_cron_expression": cron_expression.strip(),
+        "p_description": description,
+        "p_assignee": assignee,
+        "p_priority": priority,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_schedule_list() -> Dict[str, Any]:
+    """List all scheduled/recurring tasks for this meshwork."""
+    api_key = _get_api_key()
+    return be.sb_rpc("mc_schedule_list", {
+        "p_api_key": api_key,
+        "p_project_id": _PROJECT_ID,
+    })
+
+
 # ----------------- PROACTIVE HEALTH SCAN -----------------
 
 @mcp.tool()
@@ -2671,12 +2798,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.38}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.10.36
+Version: 2.10.38
 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.38}/pyproject.toml

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