meshcode 2.10.35__tar.gz → 2.10.36__tar.gz

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

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

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

{meshcode-2.10.35 → meshcode-2.10.36}/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.36}/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"

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

@@ -923,7 +923,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
@@ -1398,6 +1400,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 +1610,22 @@ 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.
+        _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 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)
         return pending if pending else None
     except Exception:
         return None
@@ -1630,14 +1651,22 @@ 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),
-        }
+        _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:
+            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 +2079,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 +2153,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 +2179,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 +2282,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 +2622,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):

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

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

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