meshcode 2.10.35__tar.gz → 2.10.37__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.10.35
+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.35 → meshcode-2.10.37}/meshcode/__init__.py

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

{meshcode-2.10.35 → meshcode-2.10.37}/meshcode/comms_v4.py

@@ -1730,10 +1730,21 @@ SETUP (advanced):
   register <proj> <name> [role]              Register agent manually
   setup <client> <proj> <name> [role]        Legacy: global MCP config
 
+AGENT CONTROL:
+  scan                                       Scan identicon from clipboard → run
+  kill <proj> <name>                         Force disconnect agent
+  wake <proj> <name>                         Send wake signal
+  sleep <proj> <name>                        Send sleep signal
+  disconnect <proj> <name>                   Graceful disconnect
+  whoami                                     Show logged-in identity
+  profile [agent]                            Show/set agent profile
+  connect <proj> <name>                      Connect existing agent
+
 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
@@ -1856,6 +1867,80 @@ Clear inbox: marks all unread messages as read for an agent.
     "unregister": """meshcode unregister <project> <name>
 
 Remove an agent from a meshwork (deletes the row from mc_agents).
+""",
+    "setup": """meshcode setup <project> <agent> [role]
+
+Create an isolated workspace at ~/meshcode/<project>-<agent>/ with
+.mcp.json configured for the agent's MCP server. Usually auto-created
+by `meshcode go`.
+
+EXAMPLES:
+  meshcode setup my-app backend "Backend Engineer"
+""",
+    "run": """meshcode run <agent> [--project <name>] [--editor claude|cursor|code]
+
+Launch an agent in your preferred editor. Detects Claude Code, Cursor,
+VS Code, Windsurf, or Codex. Use <project>/<agent> to disambiguate.
+
+EXAMPLES:
+  meshcode run backend
+  meshcode run my-app/backend --editor cursor
+""",
+    "go": """meshcode go <agent> [--project <name>]
+
+Shortcut for setup + run. Creates workspace if needed, then launches.
+
+EXAMPLES:
+  meshcode go backend
+  meshcode go my-app/frontend
+""",
+    "scan": """meshcode scan
+
+Read an agent identicon from clipboard (or stdin) and launch the agent.
+The identicon must contain a ⟨ project/agent ⟩ tag.
+
+EXAMPLES:
+  meshcode scan                    # reads from clipboard
+  cat identicon.txt | meshcode scan
+""",
+    "invite": """meshcode invite <project> <agent> [--role "..."] [--days 7]
+
+Generate an invite token for a teammate to join as a specific agent.
+--days 0 = permanent (never expires).
+
+EXAMPLES:
+  meshcode invite my-app frontend --role "React Developer" --days 7
+""",
+    "join": """meshcode join <token> [--display-name "alice"]
+
+Accept an invite and create a workspace for the assigned agent.
+
+EXAMPLES:
+  meshcode join mc_invite_abc123 --display-name "Alice"
+""",
+    "invites": """meshcode invites <project>
+
+List outstanding and redeemed invites for a meshwork.
+""",
+    "members": """meshcode members <project>
+
+List all members (owner + invited) of a meshwork.
+""",
+    "whoami": """meshcode whoami
+
+Show the currently logged-in user (email, user_id, profile).
+""",
+    "prefs": """meshcode prefs [key] [value]
+
+View or set preferences (permission-mode, auto-update, etc.).
+
+EXAMPLES:
+  meshcode prefs                          # show all
+  meshcode prefs permission-mode bypass   # set
+""",
+    "profiles": """meshcode profiles
+
+List all stored keychain profiles (default + per-meshwork guest keys).
 """,
 }
 
@@ -1981,6 +2066,9 @@ if __name__ == "__main__":
                 from_a, to_a = target.split(":", 1)
             else:
                 from_a, to_a = "?", target
+            if not message.strip():
+                print("[meshcode] ERROR: message cannot be empty. Usage: meshcode send <project> <from>:<to> <message>")
+                sys.exit(1)
             send_msg(proj, from_a, to_a, message, compact=compact)
 
     elif cmd == "broadcast":
@@ -1989,12 +2077,15 @@ if __name__ == "__main__":
             from_a = flags["from"]
             message = flags.get("msg", flags.get("message", " ".join(pos)))
             msg_type = flags.get("type", "broadcast")
-            broadcast(proj, from_a, message, msg_type)
         else:
             proj = pos[0] if len(pos) > 0 else "default"
             from_a = pos[1] if len(pos) > 1 else "?"
             message = " ".join(pos[2:]) if len(pos) > 2 else ""
-            broadcast(proj, from_a, message)
+            msg_type = "broadcast"
+        if not message.strip():
+            print("[meshcode] ERROR: message cannot be empty. Usage: meshcode broadcast <project> <from> <message>")
+            sys.exit(1)
+        broadcast(proj, from_a, message, msg_type)
 
     elif cmd == "read":
         proj = flags.get("project", pos[0] if len(pos) > 0 else "default")
@@ -2007,8 +2098,14 @@ if __name__ == "__main__":
     elif cmd == "watch":
         proj = flags.get("project", pos[0] if len(pos) > 0 else "default")
         name = flags.get("name", pos[1] if len(pos) > 1 else "agent")
-        interval = int(flags.get("interval", pos[2] if len(pos) > 2 else "10"))
-        timeout = int(flags.get("timeout", pos[3] if len(pos) > 3 else "0"))
+        try:
+            interval = int(flags.get("interval", pos[2] if len(pos) > 2 else "10"))
+        except (ValueError, TypeError):
+            interval = 10
+        try:
+            timeout = int(flags.get("timeout", pos[3] if len(pos) > 3 else "0"))
+        except (ValueError, TypeError):
+            timeout = 0
         watch(proj, name, interval, timeout)
 
     elif cmd == "board":
@@ -2230,12 +2327,15 @@ if __name__ == "__main__":
             print("    meshcode scan                  # reads from clipboard")
             print("    cat identicon.txt | meshcode scan  # reads from stdin")
             sys.exit(1)
-        # Look for ⟨ agent ⟩ or ⟨ meshwork/agent ⟩
-        match = _re.search(r'⟨\s*(\S+)\s*⟩', art_text)
-        if not match:
+        # Find ALL identicon tags, prefer the one with project/agent format.
+        # Identicons contain two tags: ⟨ agent ⟩ and ⟨ project/agent ⟩.
+        # re.search returns the first (agent-only), missing the project.
+        all_tags = _re.findall(r'⟨\s*(\S+)\s*⟩', art_text)
+        if not all_tags:
             print("[meshcode] No identicon tag found. Expected: ⟨ agent_name ⟩")
             sys.exit(1)
-        tag = match.group(1)
+        # Prefer project/agent tag, fall back to agent-only
+        tag = next((t for t in all_tags if "/" in t), all_tags[0])
         if "/" in tag:
             _proj, _agent = tag.split("/", 1)
         else:

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

@@ -65,7 +65,7 @@ class _CircuitBreaker:
         return self.state == self.OPEN
 
 
-_circuit = _CircuitBreaker(failure_threshold=5, recovery_timeout=30.0)
+_circuit = _CircuitBreaker(failure_threshold=5, recovery_timeout=10.0)
 
 # Bake in production defaults — RLS-protected publishable key, safe to ship.
 _DEFAULT_SUPABASE_URL = "https://gjinagyyjttyxnaoavnz.supabase.co"
@@ -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.35 → 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.35 → 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.
 
@@ -923,7 +936,9 @@ meshcode_expand_link(). No sensitive msgs cross-mesh.
 
 MEMORY: meshcode_remember(key, value) persists across sessions.
 meshcode_recall(key?) retrieves. meshcode_forget(key) deletes.
-Auto-remember after each task: mistakes, feedback, patterns, preferences.
+Only remember reusable learnings: mistakes, feedback, patterns, preferences.
+Do NOT save task summaries — tasks already persist in the task system.
+Do NOT use memory for session state or ephemeral data.
 Save reusable code patterns as template_* keys for instant recall.
 
 SCRATCHPAD: meshcode_scratchpad_set/get for shared meshwork-level context
@@ -937,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):
@@ -1398,6 +1405,9 @@ 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)."""
+    if not to or not to.strip():
+        return {"error": "recipient 'to' cannot be empty"}
+    to = to.strip()
     if isinstance(message, str):
         # Auto-wrap strings into dict. Warn if very long but don't reject.
         if len(message) > 2000:
@@ -1605,6 +1615,21 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
                 or t.get("assignee") == AGENT_NAME  # Directly assigned to me
             )
         ]
+        # For leader agents: also include unclaimed '*' tasks as pending
+        # so commanders auto-triage them instead of letting them pile up.
+        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"]}
+                for t in tasks
+                if t.get("status") == "open"
+                and t.get("assignee") == "*"
+                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
@@ -1630,14 +1655,17 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
     global _IN_WAIT, _CONSECUTIVE_IDLE_SECONDS, _LAST_SEEN_TS
 
     # PRODUCT RULE 1: If agent has open tasks, refuse to wait. Work first.
+    # Exception: commander/leader agents can wait while monitoring — they
+    # delegate tasks and need to stay in the wait loop to receive reports.
     pending_tasks = _get_pending_tasks_summary()
     if pending_tasks:
-        return {
-            "refused": True,
-            "reason": "You have open tasks. Work them before entering wait.",
-            "pending_tasks": pending_tasks,
-            "count": len(pending_tasks),
-        }
+        if not _is_leader_agent():
+            return {
+                "refused": True,
+                "reason": "You have open tasks. Work them before entering wait.",
+                "pending_tasks": pending_tasks,
+                "count": len(pending_tasks),
+            }
 
     # PRODUCT RULE 2: If agent has unread messages in DB, refuse to wait.
     try:
@@ -2050,8 +2078,10 @@ def meshcode_init(project: str, agent: str, role: str = "") -> Dict[str, Any]:
 def meshcode_task_create(title: str, description: str = "", assignee: str = "*",
                           priority: str = "normal", parent_task_id: Optional[str] = None) -> Dict[str, Any]:
     """Create task. assignee="*" for any, priority: low/normal/high/urgent."""
+    if not title or not title.strip():
+        return {"error": "title cannot be empty"}
     api_key = _get_api_key()
-    result = be.task_create(api_key, _PROJECT_ID, AGENT_NAME, title,
+    result = be.task_create(api_key, _PROJECT_ID, AGENT_NAME, title.strip(),
                            description=description, assignee=assignee,
                            priority=priority, parent_task_id=parent_task_id)
     # Auto-notify assignee so they wake from meshcode_wait
@@ -2122,7 +2152,7 @@ def meshcode_task_claim(task_id: str) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_task_complete(task_id: str, summary: str = "", force: bool = False) -> Dict[str, Any]:
-    """Complete a claimed task with summary. Auto-remembers the task summary.
+    """Complete a claimed task with summary.
 
     Refuses if the task has open subtasks, unless force=True is passed with a
     reason in `summary`. This prevents closing a parent while lanes are still
@@ -2148,25 +2178,8 @@ def meshcode_task_complete(task_id: str, summary: str = "", force: bool = False)
         except Exception:
             pass  # Best-effort check; don't block on listing failure.
     result = be.task_complete(api_key, _PROJECT_ID, task_id, AGENT_NAME, summary=summary)
-    # Auto-remember task completion for future context
-    if isinstance(result, dict) and result.get("ok") and summary:
-        try:
-            import threading
-            def _auto_remember():
-                try:
-                    be.sb_rpc("mc_memory_set", {
-                        "p_api_key": api_key,
-                        "p_agent_name": AGENT_NAME,
-                        "p_key": f"task_{task_id[:8]}",
-                        "p_value": {"title": result.get("title", ""), "summary": summary, "completed": True},
-                        "p_tier": "episodic",
-                        "p_project_name": PROJECT_NAME,
-                    })
-                except Exception:
-                    pass
-            threading.Thread(target=_auto_remember, daemon=True).start()
-        except Exception:
-            pass
+    # Task data persists in the task system — do NOT duplicate to memory.
+    # Samuel: "los tasks no deben guardarse en memoria, para eso salen en tasks"
     return result
 
 
@@ -2268,6 +2281,7 @@ def meshcode_auto_wake() -> Dict[str, Any]:
     suggestions: List[Dict[str, str]] = []
 
     # 1. Check for stale agents (heartbeat >10 min, not offline/sleeping)
+    agents = []  # Initialize before try so downstream checks don't NameError
     try:
         agents = be.get_board(_PROJECT_ID)
         import datetime as _dt
@@ -2607,12 +2621,15 @@ source: meshcode
 @mcp.tool()
 @with_working_status
 def meshcode_remember(key: str, value: Any) -> Dict[str, Any]:
-    """Store a persistent memory (survives restarts). Auto-remember after each task.
+    """Store a persistent memory (survives restarts). Only for reusable learnings, NOT task data.
 
     Args:
         key: Short key (e.g. "team_conventions").
         value: Any JSON-serializable value.
     """
+    if not key or not key.strip():
+        return {"error": "key cannot be empty"}
+    key = key.strip()
     api_key = _get_api_key()
     json_value = value if isinstance(value, (dict, list)) else json.dumps(value)
     if isinstance(json_value, str):
@@ -2653,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.35 → meshcode-2.10.37}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.10.35
+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.35 → meshcode-2.10.37}/pyproject.toml

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