meshcode 2.10.21__tar.gz → 2.10.25__tar.gz

{meshcode-2.10.21 → meshcode-2.10.25}/PKG-INFO

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

{meshcode-2.10.21 → meshcode-2.10.25}/meshcode/__init__.py

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

{meshcode-2.10.21 → meshcode-2.10.25}/meshcode/meshcode_mcp/server.py

@@ -866,6 +866,12 @@ RULES:
 - sensitive=True for secrets/PII.
 
 SESSION START (do these IMMEDIATELY — don't wait for user input):
+The moment you see these instructions — whether the user said "boot", "hi",
+nothing at all, or anything else — run the full protocol. Never reply with
+only a memory summary and then idle. If your client defers MCP tool schemas
+(shows tool names without parameters), your FIRST action is to load them:
+  ToolSearch(query="select:meshcode_set_status,meshcode_check,meshcode_tasks,meshcode_auto_wake,meshcode_status,meshcode_wait,meshcode_send,meshcode_task_claim,meshcode_task_complete,meshcode_remember,meshcode_recall")
+Then execute:
 1. meshcode_set_status(status="online", task="ready")
 2. meshcode_check() — read NEW messages only (last_seen is auto-restored from mesh memory on boot, old messages are skipped automatically)
 3. meshcode_tasks() — check for assigned/pending tasks and claim any unclaimed ones
@@ -873,6 +879,7 @@ SESSION START (do these IMMEDIATELY — don't wait for user input):
 5. meshcode_status() — see who's online
 6. If other agents are online → meshcode_send them a greeting
 7. meshcode_wait() — enter the loop
+DO NOT ASK THE USER "what do you want to work on" — the mesh tells you via tasks/messages.
 
 CRITICAL: You communicate by CALLING TOOLS, not by thinking or writing text.
 To talk to another agent → call meshcode_send(to="agent", message="...")
@@ -1338,14 +1345,12 @@ def meshcode_broadcast(payload: Any) -> Dict[str, Any]:
     elif not isinstance(payload, dict):
         return {"error": "payload must be a string or object", "got_type": type(payload).__name__}
 
-    agents = be.get_board(_PROJECT_ID)
-    sent = 0
-    for a in agents:
-        if a["name"] != AGENT_NAME:
-            be.send_message(_PROJECT_ID, AGENT_NAME, a["name"], payload, msg_type="broadcast",
-                               api_key=_get_api_key())
-            sent += 1
-    return {"broadcast": True, "agents_notified": sent}
+    # Canonical broadcast: one row with to_agent='*'. Every agent's inbox
+    # query includes `to_agent = '*'` so all recipients see it, without the
+    # N-row fanout that caused duplicate-render bugs.
+    be.send_message(_PROJECT_ID, AGENT_NAME, "*", payload, msg_type="broadcast",
+                    api_key=_get_api_key())
+    return {"broadcast": True, "to": "*"}
 
 
 @mcp.tool()
@@ -1481,7 +1486,7 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
 
 @mcp.tool()
 @with_working_status
-async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False) -> Dict[str, Any]:
+async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -> Dict[str, Any]:
     """Block until a mesh message arrives or a task needs attention.
 
     INTERNAL LOOP: This function loops internally and only returns when
@@ -1491,7 +1496,10 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
     accidentally using ScheduleWakeup or exiting the loop.
 
     Args:
-        timeout_seconds: Max wait time per poll cycle (default 120, hard cap 120).
+        timeout_seconds: Max wait time per poll cycle (default 20, hard cap 20).
+            Short cap keeps the outer tool call bounded so the user can press
+            ESC in Claude Code without killing the MCP server — the inner
+            loop continues polling across cycles at zero token cost.
     """
     global _IN_WAIT, _CONSECUTIVE_IDLE_SECONDS, _LAST_SEEN_TS
 
@@ -1534,7 +1542,7 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
 
     _IN_WAIT = True
     _set_state("waiting", "listening for messages")
-    capped_timeout = min(max(1, int(timeout_seconds)), 120)
+    capped_timeout = min(max(1, int(timeout_seconds)), 20)
     try:
         # ── INTERNAL LOOP ──────────────────────────────────────────
         # Keep polling until something actionable arrives.
@@ -1937,17 +1945,44 @@ def meshcode_task_create(title: str, description: str = "", assignee: str = "*",
 
 @mcp.tool()
 @with_working_status
-def meshcode_tasks(status_filter: Optional[str] = None) -> Dict[str, Any]:
+def meshcode_tasks(status_filter: Optional[str] = None, verbose: bool = False) -> Dict[str, Any]:
     """List tasks. Filter by status to find work.
 
     Args:
         status_filter: 'open' / 'in_progress' / 'done' / etc. None = all.
+        verbose: When False (default), descriptions are truncated to 200 chars
+            and null/empty fields are dropped to save tokens. Pass True for
+            the full payload.
 
     Returns: {"ok": true, "tasks": [...]}
     """
     api_key = _get_api_key()
     include_done = status_filter == "done"
-    return be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter=status_filter, include_done=include_done)
+    result = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter=status_filter, include_done=include_done)
+    if verbose or not isinstance(result, dict) or not result.get("ok"):
+        return result
+    compact: List[Dict[str, Any]] = []
+    for t in result.get("tasks", []):
+        desc = t.get("description") or ""
+        row: Dict[str, Any] = {
+            "id": t.get("id"),
+            "title": t.get("title"),
+            "status": t.get("status"),
+            "priority": t.get("priority"),
+            "assignee": t.get("assignee"),
+        }
+        if t.get("claimed_by"):
+            row["claimed_by"] = t["claimed_by"]
+        if t.get("parent_task_id"):
+            row["parent_task_id"] = t["parent_task_id"]
+        if desc:
+            if len(desc) > 200:
+                row["description"] = desc[:200]
+                row["_description_truncated"] = True
+            else:
+                row["description"] = desc
+        compact.append(row)
+    return {"ok": True, "tasks": compact}
 
 
 @mcp.tool()
@@ -1960,9 +1995,32 @@ def meshcode_task_claim(task_id: str) -> Dict[str, Any]:
 
 @mcp.tool()
 @with_working_status
-def meshcode_task_complete(task_id: str, summary: str = "") -> Dict[str, Any]:
-    """Complete a claimed task with summary. Auto-remembers the task summary."""
+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.
+
+    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
+    in flight.
+    """
     api_key = _get_api_key()
+    if not force:
+        try:
+            listing = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter=None, include_done=False)
+            if isinstance(listing, dict) and listing.get("ok"):
+                open_subs = [
+                    {"id": t["id"][:8], "title": t["title"][:80], "status": t["status"]}
+                    for t in listing.get("tasks", [])
+                    if t.get("parent_task_id") == task_id
+                    and t.get("status") in ("open", "in_progress", "in_review")
+                ]
+                if open_subs:
+                    return {
+                        "refused": True,
+                        "reason": f"Cannot complete — {len(open_subs)} open subtasks. Finish them or pass force=True with a reason in summary.",
+                        "open_subtasks": open_subs,
+                    }
+        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:
@@ -2013,6 +2071,62 @@ def meshcode_task_reject(task_id: str, feedback: str = "") -> Dict[str, Any]:
     })
 
 
+@mcp.tool()
+@with_working_status
+def meshcode_task_search(title_contains: Optional[str] = None,
+                         status: Optional[str] = None,
+                         assignee: Optional[str] = None,
+                         limit: int = 20) -> Dict[str, Any]:
+    """Search tasks by title/status/assignee. Use before task_create to dedupe."""
+    return be.sb_rpc("mc_search_tasks", {
+        "p_api_key": _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_caller_agent": AGENT_NAME,
+        "p_title_contains": title_contains,
+        "p_status": status,
+        "p_assignee": assignee,
+        "p_limit": limit,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_agent_list() -> Dict[str, Any]:
+    """Roster of agents in this meshwork with status + last_heartbeat."""
+    return be.sb_rpc("mc_list_agents", {
+        "p_api_key": _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_task_cancel(task_id: str, reason: str = "") -> Dict[str, Any]:
+    """Cancel a task. Creator or commander only. Works on open/in_progress/in_review."""
+    api_key = _get_api_key()
+    return be.sb_rpc("mc_task_cancel", {
+        "p_api_key": api_key,
+        "p_project_id": _PROJECT_ID,
+        "p_task_id": task_id,
+        "p_cancelling_agent": AGENT_NAME,
+        "p_reason": reason,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_task_reassign(task_id: str, new_assignee: str) -> Dict[str, Any]:
+    """Reassign an unclaimed open task to a different agent. Creator or commander only."""
+    api_key = _get_api_key()
+    return be.sb_rpc("mc_task_reassign", {
+        "p_api_key": api_key,
+        "p_project_id": _PROJECT_ID,
+        "p_task_id": task_id,
+        "p_reassigning_agent": AGENT_NAME,
+        "p_new_assignee": new_assignee,
+    })
+
+
 # ----------------- PROACTIVE HEALTH SCAN -----------------
 
 @mcp.tool()
@@ -2142,6 +2256,47 @@ def meshcode_links() -> Dict[str, Any]:
     })
 
 
+@mcp.tool()
+@with_working_status
+def meshcode_link_invite(source_project: str, note: str = "") -> Dict[str, Any]:
+    """Generate a one-time invite token for another meshwork to link in.
+
+    Returns {token, expires_at}. Share the token out-of-band. The recipient
+    calls meshcode_link_redeem(token, their_meshwork) to auto-link
+    (no separate accept step).
+    """
+    return be.sb_rpc("mc_create_link_invite", {
+        "p_source_project": source_project,
+        "p_note": note,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_link_redeem(token: str, target_meshwork: str) -> Dict[str, Any]:
+    """Redeem an invite token — creates an ACTIVE mesh link in one step."""
+    return be.sb_rpc("mc_redeem_link_invite", {
+        "p_token": token,
+        "p_target_project": target_meshwork,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_link_invites(source_project: Optional[str] = None) -> Dict[str, Any]:
+    """List link invites this user has created (active/redeemed/expired/revoked)."""
+    return be.sb_rpc("mc_list_my_link_invites", {
+        "p_source_project": source_project,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_link_invite_revoke(token: str) -> Dict[str, Any]:
+    """Revoke an outstanding (unredeemed) invite token."""
+    return be.sb_rpc("mc_revoke_link_invite", {"p_token": token})
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_expand_link(link_id: str, agents: str) -> Dict[str, Any]:

{meshcode-2.10.21 → meshcode-2.10.25}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.21 → meshcode-2.10.25}/pyproject.toml

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