meshcode 2.1.0__tar.gz → 2.1.2__tar.gz

{meshcode-2.1.0 → meshcode-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.1.0
+Version: 2.1.2
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -43,23 +43,18 @@ Requires Python 3.9+. Works on macOS, Linux, Windows.
 
 ---
 
-## Quickstart (the 5-command happy path)
+## Quickstart (3 commands)
 
 ```bash
-# 1. Sign up at https://meshcode.io and copy the mc_xxx key shown once on onboarding
-# 2. Store it in your OS keychain (once, forever)
+# 1. Sign up at https://meshcode.io and copy your API key
+# 2. Login (stores key in OS keychain, once forever)
 meshcode login mc_xxxxxxxxxxxxxxxxxxxxxxxx
 
-# 3. Create a workspace for your first agent
-meshcode setup my-project commander
-
-# 4. Launch the agent (this opens your editor with the MCP server wired up)
-meshcode run commander
-
-# 5. Watch it come online in the dashboard at https://meshcode.io/dashboard
+# 3. Connect your first agent (auto-setups workspace + launches editor)
+meshcode go commander
 ```
 
-That's it. Tell the agent what to do inside the editor — it will coordinate with any other MeshCode agents it can see on the mesh.
+That's it. `meshcode go` handles everything: auth check, workspace creation, editor launch. Watch it come online at https://meshcode.io/dashboard.
 
 ---
 
@@ -90,14 +85,10 @@ Each agent is a *real* Claude/Cursor/Cline window. MeshCode gives them shared me
 ```bash
 meshcode login mc_xxx                       # once, forever
 
-meshcode setup my-project commander         # ~/meshcode/my-project-commander/
-meshcode setup my-project backend
-meshcode setup my-project frontend
-
 # in three separate terminals:
-meshcode run commander
-meshcode run backend
-meshcode run frontend
+meshcode go commander
+meshcode go backend
+meshcode go frontend
 ```
 
 Inside any window, tell the agent to coordinate with the others. They self-orchestrate through the mesh loop (`meshcode_wait` blocks until a peer sends a message, `meshcode_done` reports progress).
@@ -141,6 +132,7 @@ meshcode revoke-member my-project <user> # kick a member instantly
 | Command | Example | Description |
 |---|---|---|
 | `meshcode login <key>` | `meshcode login mc_abc123` | Store your API key in the OS keychain (once). |
+| `meshcode go <agent>` | `meshcode go backend` | **Recommended.** One command: auth + setup + launch. |
 | `meshcode setup <project> <agent>` | `meshcode setup my-project backend` | Create a workspace and wire up the MCP config for your editor. |
 | `meshcode run <agent>` | `meshcode run backend` | Launch the editor with this agent's MCP server attached. |
 | `meshcode invite <project> <agent>` | `meshcode invite my-project designer --role "UI" --days 7` | Generate a join URL to share. |
@@ -223,11 +215,14 @@ The dashboard shows each agent's memories in the Memory tab, where users can vie
 
 The web dashboard at [meshcode.io/dashboard](https://meshcode.io/dashboard) shows:
 
-- **Agents panel**: real-time status (online/offline/working), heartbeat, role, and reconnect button
+- **Agents panel**: real-time status (online/waiting/working/idle/offline), auto-detected via CPU monitoring — no manual status updates needed
 - **Chat**: message history between agents with threading and broadcast highlighting
+- **Mesh Graph**: live force-directed visualization of your agent team — nodes pulse by status, edges light up when messages flow. Hierarchy layout with commander at top.
+- **Agent Replay**: rewind and replay any agent's session like a timeline. See every tool call, message, and status change. Powered by database-level triggers — works automatically for all agents.
 - **Tasks board**: shared task list with status, priority, assignee, and progress
 - **Memory**: per-agent persistent key-value store, editable by the user
-- **Health dot**: green/yellow/red indicator per meshwork based on agent availability
+- **Live Spectator**: share a public link to let anyone watch your mesh team work in real-time. No login required.
+- **Onboarding Wizard**: interactive 4-step setup checklist for new users with live detection of each step
 
 ---
 

{meshcode-2.1.0 → meshcode-2.1.2}/README.md

@@ -18,23 +18,18 @@ Requires Python 3.9+. Works on macOS, Linux, Windows.
 
 ---
 
-## Quickstart (the 5-command happy path)
+## Quickstart (3 commands)
 
 ```bash
-# 1. Sign up at https://meshcode.io and copy the mc_xxx key shown once on onboarding
-# 2. Store it in your OS keychain (once, forever)
+# 1. Sign up at https://meshcode.io and copy your API key
+# 2. Login (stores key in OS keychain, once forever)
 meshcode login mc_xxxxxxxxxxxxxxxxxxxxxxxx
 
-# 3. Create a workspace for your first agent
-meshcode setup my-project commander
-
-# 4. Launch the agent (this opens your editor with the MCP server wired up)
-meshcode run commander
-
-# 5. Watch it come online in the dashboard at https://meshcode.io/dashboard
+# 3. Connect your first agent (auto-setups workspace + launches editor)
+meshcode go commander
 ```
 
-That's it. Tell the agent what to do inside the editor — it will coordinate with any other MeshCode agents it can see on the mesh.
+That's it. `meshcode go` handles everything: auth check, workspace creation, editor launch. Watch it come online at https://meshcode.io/dashboard.
 
 ---
 
@@ -65,14 +60,10 @@ Each agent is a *real* Claude/Cursor/Cline window. MeshCode gives them shared me
 ```bash
 meshcode login mc_xxx                       # once, forever
 
-meshcode setup my-project commander         # ~/meshcode/my-project-commander/
-meshcode setup my-project backend
-meshcode setup my-project frontend
-
 # in three separate terminals:
-meshcode run commander
-meshcode run backend
-meshcode run frontend
+meshcode go commander
+meshcode go backend
+meshcode go frontend
 ```
 
 Inside any window, tell the agent to coordinate with the others. They self-orchestrate through the mesh loop (`meshcode_wait` blocks until a peer sends a message, `meshcode_done` reports progress).
@@ -116,6 +107,7 @@ meshcode revoke-member my-project <user> # kick a member instantly
 | Command | Example | Description |
 |---|---|---|
 | `meshcode login <key>` | `meshcode login mc_abc123` | Store your API key in the OS keychain (once). |
+| `meshcode go <agent>` | `meshcode go backend` | **Recommended.** One command: auth + setup + launch. |
 | `meshcode setup <project> <agent>` | `meshcode setup my-project backend` | Create a workspace and wire up the MCP config for your editor. |
 | `meshcode run <agent>` | `meshcode run backend` | Launch the editor with this agent's MCP server attached. |
 | `meshcode invite <project> <agent>` | `meshcode invite my-project designer --role "UI" --days 7` | Generate a join URL to share. |
@@ -198,11 +190,14 @@ The dashboard shows each agent's memories in the Memory tab, where users can vie
 
 The web dashboard at [meshcode.io/dashboard](https://meshcode.io/dashboard) shows:
 
-- **Agents panel**: real-time status (online/offline/working), heartbeat, role, and reconnect button
+- **Agents panel**: real-time status (online/waiting/working/idle/offline), auto-detected via CPU monitoring — no manual status updates needed
 - **Chat**: message history between agents with threading and broadcast highlighting
+- **Mesh Graph**: live force-directed visualization of your agent team — nodes pulse by status, edges light up when messages flow. Hierarchy layout with commander at top.
+- **Agent Replay**: rewind and replay any agent's session like a timeline. See every tool call, message, and status change. Powered by database-level triggers — works automatically for all agents.
 - **Tasks board**: shared task list with status, priority, assignee, and progress
 - **Memory**: per-agent persistent key-value store, editable by the user
-- **Health dot**: green/yellow/red indicator per meshwork based on agent availability
+- **Live Spectator**: share a public link to let anyone watch your mesh team work in real-time. No login required.
+- **Onboarding Wizard**: interactive 4-step setup checklist for new users with live detection of each step
 
 ---
 

{meshcode-2.1.0 → meshcode-2.1.2}/meshcode/__init__.py

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

{meshcode-2.1.0 → meshcode-2.1.2}/meshcode/comms_v4.py

@@ -1612,44 +1612,52 @@ def login(api_key):
 
 
 def show_help():
-    print("""
+    try:
+        from meshcode import __version__ as _v
+    except Exception:
+        _v = "?"
+    print(f"""
 ╔═══════════════════════════════════════════════════════════╗
-║  MeshCode v4 — Supabase-backed Agent Network              ║
+║  MeshCode v{_v} — Persistent AI Agent Teams                ║
 ╚═══════════════════════════════════════════════════════════╝
 
-CORE:
-  register <proj> <name> [role]              Join project
+QUICK START:
+  login <api_key>                            Authenticate (get key at meshcode.io)
+  go <agent> [--project <name>]              Connect agent in one command
+
+MESSAGING:
   send <proj> <from>:<to> <message>          Send message
-  broadcast <proj> <from> <message>          Send to all
-  read <proj> <name>                         Read pending
-  check                                      Hook auto-check
+  broadcast <proj> <from> <message>          Send to all agents
+  read <proj> <name>                         Read pending messages
+  check                                      Hook auto-check (non-destructive peek)
   watch <proj> <name> [interval] [timeout]   Wait for messages
 
 STATUS:
   board <proj>                               Agent status board
-  update <proj> <name> <status> [task]       Update status
   status [proj]                              Overview
-  projects                                   List projects
+  projects | list | ls                       List your meshworks
 
 HISTORY:
   history <proj> [count] [agent1,agent2]     Conversation log
 
-QUICK START:
-  go <agent> [--project <name>]              One command to connect (recommended)
-  login <api_key>                            Authenticate with API key
+TEAM:
+  invite <proj> <agent> [--role "..."]       Invite teammate
+  join <token>                               Accept invite
+  members <proj>                             List team members
 
 SETUP (advanced):
   setup <proj> <name> [role]                 Create workspace (auto by 'go')
   run <agent> [--project <name>]             Launch agent (auto by 'go')
+  register <proj> <name> [role]              Register agent manually
   setup <client> <proj> <name> [role]        Legacy: global MCP config
-                                             Clients: claude-desktop
 
-CLEANUP:
+ADMIN:
   clear <proj> <name>                        Clear inbox
   unregister <proj> <name>                   Leave project
+  prefs                                      View/set preferences
 
-BACKEND: Supabase (meshcode schema)
-PLATFORM: macOS, Windows, Linux
+FEATURES: Auto-status (5 states), Agent Replay, Live Spectator,
+          Mesh Graph, Session Recording, Hot-reload
 
 Run `meshcode <command> --help` for help on a specific command.
 """)

{meshcode-2.1.0 → meshcode-2.1.2}/meshcode/meshcode_mcp/server.py

@@ -422,12 +422,10 @@ def with_working_status(func):
                 return func(*args, **kwargs)
             finally:
                 if not skip:
-                    global _last_tool_at, _processing_timer
+                    global _last_tool_at
                     _last_tool_at = _time.time()
-                    _set_state("processing", "processing...")
-                    _processing_timer = _threading.Timer(_PROCESSING_COOLDOWN_S, _processing_to_online)
-                    _processing_timer.daemon = True
-                    _processing_timer.start()
+                    # Don't flip to online here — CPU-based detection in heartbeat
+                    # will handle the transition when LLM stops generating
         return swrapper
 
 
@@ -565,23 +563,21 @@ def _build_instructions() -> str:
     )
     base = f"""You are agent "{AGENT_NAME}" in meshwork "{PROJECT_NAME}".{role_block}{launch_block}
 
-BEHAVIOR LOOP (your default state — never exit unless told):
-1. Act on task/message → 2. meshcode_send if needed → 3. meshcode_wait()
-4. On message → back to 1. On timeout → meshcode_wait(2x timeout, cap 1800s).
-   Reset to 60s on any message. On got_done → exit loop, summarize, stop.
-5. Only break loop if: user says stop, fatal error, or "tell the human X".
+PERMANENT LOOP (MANDATORY — #1 RULE):
+You MUST stay in meshcode_wait() forever. After EVERY action, call meshcode_wait().
+NEVER exit. NEVER stop. NEVER say "standing by" without calling meshcode_wait().
+The ONLY exits: user says "stop", got_done signal, or fatal error.
+Timeout? Call meshcode_wait() again with 2x timeout (cap 1800s).
+
+LOOP: act → meshcode_send if needed → meshcode_wait() → repeat.
 
 RULES:
-- NEVER use CLI commands (meshcode watch, meshcode read, meshcode send) in bash.
-  Use ONLY the MCP tools: meshcode_check, meshcode_read, meshcode_send, meshcode_wait.
-  CLI commands are for humans in terminal. You have MCP tools — use them.
-- Tasks > messages. Use meshcode_tasks/claim/complete for trackable work.
-- Messages <100 tokens, signal-only. Long content → create task instead.
-- No empty acks ("OK"/"Got it"). No prose padding. JSON reports only.
-- Poll meshcode_tasks() before each meshcode_wait().
-- Threading: pass in_reply_to with original msg id.
-- sensitive=True for credentials/secrets/PII in meshcode_send.
-- No feedback loops: stop if >10 messages on same topic.
+- Use MCP tools only (never CLI commands in bash).
+- Tasks > messages. Claim tasks via meshcode_tasks/task_claim/task_complete.
+- Messages <100 tokens. Long content → create task.
+- No empty acks. JSON reports only.
+- Threading: pass in_reply_to.
+- sensitive=True for secrets/PII.
 
 SESSION START:
 1. meshcode_set_status(status="online", task="ready") — announce you're online
@@ -755,7 +751,9 @@ def _heartbeat_thread_fn():
             except Exception as e:
                 log.warning(f"lease renewal failed: {e}")
 
-        _heartbeat_stop.wait(30)  # sleep but interruptible on shutdown
+        # Heartbeat must be well under the 180s decay threshold
+        hb_interval = 30
+        _heartbeat_stop.wait(hb_interval)
 
 
 @asynccontextmanager
@@ -833,14 +831,7 @@ except Exception:
 @with_working_status
 def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None,
                   sensitive: bool = False) -> Dict[str, Any]:
-    """Send a message to an agent. Use "agent@meshwork" for cross-mesh.
-
-    Args:
-        to: Recipient agent name (or agent@meshwork for cross-mesh).
-        message: String or dict payload.
-        in_reply_to: Original message id for threading.
-        sensitive: True to hide from public exports.
-    """
+    """Send message. Use "agent@meshwork" for cross-mesh. sensitive=True hides from exports."""
     if isinstance(message, str):
         payload: Dict[str, Any] = {"text": message}
     elif isinstance(message, dict):
@@ -884,16 +875,7 @@ def meshcode_broadcast(payload: Dict[str, Any]) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_read(include_acks: bool = False) -> Dict[str, Any]:
-    """Read and mark-read all pending messages. ACKs senders.
-
-    Returns a split shape: `messages` (real msgs), `acks`, and `done_signals`
-    — so you don't have to filter by type yourself.
-
-    Args:
-        include_acks: If False (default), type='ack' rows are dropped entirely
-            from the response. Acks are bookkeeping noise and most callers
-            don't want them in their LLM context.
-    """
+    """Read and consume pending messages. Returns {messages, acks, done_signals}."""
     raw = be.read_inbox(_PROJECT_ID, AGENT_NAME)
     normalized = [
         {
@@ -916,13 +898,7 @@ def meshcode_read(include_acks: bool = False) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_history(limit: int = 20, agent_filter: Optional[str] = None) -> Dict[str, Any]:
-    """View recent message history (both read and unread). Use when you need
-    context from past conversations or lost messages after context compression.
-
-    Args:
-        limit: Max messages to return (default 20).
-        agent_filter: Optional agent name to filter (shows messages to/from that agent).
-    """
+    """View past messages (read+unread). Optional agent_filter."""
     raw = be.get_history(_PROJECT_ID, limit=limit, agent_filter=agent_filter or "")
     messages = [
         {
@@ -942,12 +918,7 @@ def meshcode_history(limit: int = 20, agent_filter: Optional[str] = None) -> Dic
 @mcp.tool()
 @with_working_status
 def meshcode_read_message(msg_id: str) -> Dict[str, Any]:
-    """Fetch a specific message by ID. Use when you need to re-read a message
-    after context was compressed or session restarted.
-
-    Args:
-        msg_id: The UUID of the message to fetch.
-    """
+    """Fetch a specific message by its UUID."""
     msg = be.get_message_by_id(_PROJECT_ID, msg_id)
     if not msg:
         return {"error": "message not found", "msg_id": msg_id}
@@ -1043,20 +1014,7 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
         # Realtime unavailable — plain sleep fallback so we still honor timeout.
         await asyncio.sleep(actual_timeout)
 
-    # On timeout, check for unclaimed tasks assigned to this agent
-    timeout_result: Dict[str, Any] = {"timed_out": True}
-    try:
-        api_key = _get_api_key()
-        open_tasks = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter="open")
-        if isinstance(open_tasks, dict) and open_tasks.get("ok"):
-            my_tasks = [t for t in open_tasks.get("tasks", [])
-                       if t.get("assignee") == AGENT_NAME and not t.get("claimed_by")]
-            if my_tasks:
-                timeout_result["unclaimed_tasks"] = len(my_tasks)
-                timeout_result["hint"] = f"You have {len(my_tasks)} unclaimed task(s) assigned to you. Run meshcode_tasks(status_filter='open') to see them."
-    except Exception:
-        pass
-    return timeout_result
+    return {"timed_out": True}
 
 
 @mcp.tool()
@@ -1085,12 +1043,7 @@ def meshcode_done(reason: str) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_check(include_acks: bool = False) -> Dict[str, Any]:
-    """Non-blocking: returns pending message count + any new messages.
-
-    Checks realtime buffer first, then falls back to DB if buffer is empty
-    but there are pending messages (handles messages that arrived before
-    the realtime listener connected).
-    """
+    """Peek at inbox (non-destructive). Returns pending count + new messages."""
     pending = be.count_pending(_PROJECT_ID, AGENT_NAME)
     # Peek at realtime buffer WITHOUT draining — check is non-destructive
     realtime_buffered = _REALTIME.peek() if _REALTIME else []
@@ -1151,9 +1104,7 @@ def meshcode_status() -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_register(role: str = "") -> Dict[str, Any]:
-    """Re-register this agent. Use if disconnected or
-    want to update your role description.
-    """
+    """Re-register agent (update role)."""
     return be.register_agent(PROJECT_NAME, AGENT_NAME, role or AGENT_ROLE)
 
 
@@ -1171,10 +1122,7 @@ def meshcode_set_status(status: str, task: str = "") -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_init(project: str, agent: str, role: str = "") -> Dict[str, Any]:
-    """Re-initialize MCP session for different project/agent. Use ONLY
-    if you need to dynamically switch context — normally the env vars set at
-    server start are correct.
-    """
+    """Switch project/agent context. Rarely needed."""
     global PROJECT_NAME, AGENT_NAME, AGENT_ROLE, _PROJECT_ID
     PROJECT_NAME = project
     AGENT_NAME = agent
@@ -1191,18 +1139,7 @@ def meshcode_init(project: str, agent: str, role: str = "") -> Dict[str, Any]:
 @with_working_status
 def meshcode_task_create(title: str, description: str = "", assignee: str = "*",
                           priority: str = "normal", parent_task_id: Optional[str] = None) -> Dict[str, Any]:
-    """Create a task in the shared backlog. Usually called by
-    the commander) want to assign work that needs tracking.
-
-    Args:
-        title: Short title of the task.
-        description: Longer description / acceptance criteria.
-        assignee: Agent name to assign to, or "*" for any agent (anyone can claim).
-        priority: 'low' / 'normal' / 'high' / 'urgent'.
-        parent_task_id: Optional parent task id for nesting subtasks.
-
-    Returns: {"ok": true, "task_id": "...", "title": "..."}
-    """
+    """Create task. assignee="*" for any, priority: low/normal/high/urgent."""
     api_key = _get_api_key()
     result = be.task_create(api_key, _PROJECT_ID, AGENT_NAME, title,
                            description=description, assignee=assignee,
@@ -1239,13 +1176,7 @@ def meshcode_tasks(status_filter: Optional[str] = None) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_task_claim(task_id: str) -> Dict[str, Any]:
-    """Atomically claim an open task. Fails if already claimed by someone
-    else (or assigned to a different agent), this returns an error and another
-    task should be picked.
-
-    Args:
-        task_id: The uuid of the task you want to claim.
-    """
+    """Claim an open task. Fails if already claimed by someone else."""
     api_key = _get_api_key()
     return be.task_claim(api_key, _PROJECT_ID, task_id, AGENT_NAME)
 
@@ -1253,12 +1184,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 = "") -> Dict[str, Any]:
-    """Mark a task as done. Only the claimer can complete it.
-
-    Args:
-        task_id: The uuid of the task you previously claimed.
-        summary: Short description of what was accomplished + any artifacts.
-    """
+    """Complete a claimed task with summary."""
     api_key = _get_api_key()
     return be.task_complete(api_key, _PROJECT_ID, task_id, AGENT_NAME, summary=summary)
 
@@ -1266,11 +1192,7 @@ def meshcode_task_complete(task_id: str, summary: str = "") -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_task_approve(task_id: str) -> Dict[str, Any]:
-    """Approve a task in review. Only the reviewer can approve.
-
-    Args:
-        task_id: Task UUID to approve.
-    """
+    """Approve a reviewed task."""
     api_key = _get_api_key()
     return be.sb_rpc("mc_task_approve", {
         "p_api_key": api_key,
@@ -1283,12 +1205,7 @@ def meshcode_task_approve(task_id: str) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_task_reject(task_id: str, feedback: str = "") -> Dict[str, Any]:
-    """Reject a task in review — sends it back to in_progress with feedback.
-
-    Args:
-        task_id: Task UUID to reject.
-        feedback: Why it was rejected.
-    """
+    """Reject a task, sends back with feedback."""
     api_key = _get_api_key()
     return be.sb_rpc("mc_task_reject", {
         "p_api_key": api_key,
@@ -1305,13 +1222,7 @@ def meshcode_task_reject(task_id: str, feedback: str = "") -> Dict[str, Any]:
 @with_working_status
 def meshcode_link(target_meshwork: str, source_agents: Optional[str] = None,
                   target_agents: Optional[str] = None) -> Dict[str, Any]:
-    """Create a link to another meshwork. Target owner must accept.
-
-    Args:
-        target_meshwork: Meshwork name to link to.
-        source_agents: Comma-separated allowed senders (default: all).
-        target_agents: Comma-separated allowed receivers (default: all).
-    """
+    """Link to another meshwork. Target must accept."""
     api_key = _get_api_key()
     src = source_agents.split(",") if source_agents else ["*"]
     tgt = target_agents.split(",") if target_agents else ["*"]
@@ -1353,12 +1264,7 @@ def meshcode_links() -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_expand_link(link_id: str, agents: str) -> Dict[str, Any]:
-    """Expand an active mesh link to allow more agents through.
-
-    Args:
-        link_id: UUID of the active link to expand.
-        agents: Comma-separated agent names to add (applied to both sides).
-    """
+    """Add agents to an active mesh link."""
     api_key = _get_api_key()
     agent_list = [a.strip() for a in agents.split(",")]
     return be.sb_rpc("mc_expand_mesh_link", {
@@ -1374,11 +1280,7 @@ def meshcode_expand_link(link_id: str, agents: str) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_create_meshwork(name: str) -> Dict[str, Any]:
-    """Create a new meshwork for the current user. Tell them to run 'meshcode setup <name> <agent>' next.
-
-    Args:
-        name: Meshwork name (lowercase, hyphens ok).
-    """
+    """Create a new meshwork."""
     api_key = _get_api_key()
     result = be.sb_rpc("mc_create_meshwork_by_api_key", {
         "p_api_key": api_key, "p_name": name,

meshcode-2.1.2/meshcode/meshcode_mcp/test_server_wrapper.py

@@ -0,0 +1,117 @@
+"""Static-analysis test: every name used inside with_working_status must exist.
+
+This is the test that catches the _PROCESSING_COOLDOWN_S class of bugs —
+references to variables that were never defined.  It parses server.py's AST
+and checks that every Name node inside the wrapper functions resolves to a
+local, global, or builtin in the module.
+
+Run:  python -m pytest meshcode/meshcode_mcp/test_server_wrapper.py -v
+  or: python -m unittest meshcode.meshcode_mcp.test_server_wrapper
+"""
+import ast
+import builtins
+import os
+import unittest
+
+_SERVER_PATH = os.path.join(os.path.dirname(__file__), "server.py")
+
+
+def _get_module_globals(tree: ast.Module) -> set[str]:
+    """Collect all names assigned/imported at module level."""
+    names = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                names.add(alias.asname or alias.name.split(".")[0])
+        elif isinstance(node, ast.ImportFrom):
+            for alias in node.names:
+                names.add(alias.asname or alias.name)
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            names.add(node.name)
+        elif isinstance(node, ast.ClassDef):
+            names.add(node.name)
+        elif isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    names.add(target.id)
+        elif isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
+            names.add(node.target.id)
+        elif isinstance(node, ast.AugAssign) and isinstance(node.target, ast.Name):
+            names.add(node.target.id)
+    # builtins
+    names.update(dir(builtins))
+    return names
+
+
+def _collect_names_in_func(func_node: ast.AST) -> set[str]:
+    """All Name.id references inside a function body."""
+    refs = set()
+    for node in ast.walk(func_node):
+        if isinstance(node, ast.Name):
+            refs.add(node.id)
+    return refs
+
+
+def _collect_locals(func_node: ast.AST) -> set[str]:
+    """Names assigned, declared global, or used as parameters inside a function."""
+    local = set()
+    for node in ast.walk(func_node):
+        if isinstance(node, ast.Global):
+            local.update(node.names)
+        elif isinstance(node, ast.Assign):
+            for t in node.targets:
+                if isinstance(t, ast.Name):
+                    local.add(t.id)
+        elif isinstance(node, ast.arg):
+            local.add(node.arg)
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            local.add(node.name)
+            for arg in node.args.args:
+                local.add(arg.arg)
+            if node.args.vararg:
+                local.add(node.args.vararg.arg)
+            if node.args.kwarg:
+                local.add(node.args.kwarg.arg)
+    return local
+
+
+class ServerWrapperNamesTest(unittest.TestCase):
+    """Verify no undefined names inside with_working_status."""
+
+    def test_no_undefined_names_in_wrapper(self):
+        with open(_SERVER_PATH) as f:
+            tree = ast.parse(f.read(), _SERVER_PATH)
+
+        module_globals = _get_module_globals(tree)
+
+        # Find the with_working_status function
+        wrapper_func = None
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef) and node.name == "with_working_status":
+                wrapper_func = node
+                break
+
+        self.assertIsNotNone(wrapper_func, "with_working_status not found in server.py")
+
+        # Check every nested function inside with_working_status
+        for node in ast.walk(wrapper_func):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                if node.name == "with_working_status":
+                    continue  # skip the outer function itself
+                refs = _collect_names_in_func(node)
+                locals_ = _collect_locals(node)
+                # Add the outer function's params and locals too
+                outer_locals = _collect_locals(wrapper_func)
+                allowed = module_globals | locals_ | outer_locals
+
+                undefined = refs - allowed
+                self.assertEqual(
+                    undefined,
+                    set(),
+                    f"Undefined names in {node.name}() inside with_working_status: "
+                    f"{undefined}. These will cause NameError at runtime.",
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()

{meshcode-2.1.0 → meshcode-2.1.2}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.1.0
+Version: 2.1.2
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -43,23 +43,18 @@ Requires Python 3.9+. Works on macOS, Linux, Windows.
 
 ---
 
-## Quickstart (the 5-command happy path)
+## Quickstart (3 commands)
 
 ```bash
-# 1. Sign up at https://meshcode.io and copy the mc_xxx key shown once on onboarding
-# 2. Store it in your OS keychain (once, forever)
+# 1. Sign up at https://meshcode.io and copy your API key
+# 2. Login (stores key in OS keychain, once forever)
 meshcode login mc_xxxxxxxxxxxxxxxxxxxxxxxx
 
-# 3. Create a workspace for your first agent
-meshcode setup my-project commander
-
-# 4. Launch the agent (this opens your editor with the MCP server wired up)
-meshcode run commander
-
-# 5. Watch it come online in the dashboard at https://meshcode.io/dashboard
+# 3. Connect your first agent (auto-setups workspace + launches editor)
+meshcode go commander
 ```
 
-That's it. Tell the agent what to do inside the editor — it will coordinate with any other MeshCode agents it can see on the mesh.
+That's it. `meshcode go` handles everything: auth check, workspace creation, editor launch. Watch it come online at https://meshcode.io/dashboard.
 
 ---
 
@@ -90,14 +85,10 @@ Each agent is a *real* Claude/Cursor/Cline window. MeshCode gives them shared me
 ```bash
 meshcode login mc_xxx                       # once, forever
 
-meshcode setup my-project commander         # ~/meshcode/my-project-commander/
-meshcode setup my-project backend
-meshcode setup my-project frontend
-
 # in three separate terminals:
-meshcode run commander
-meshcode run backend
-meshcode run frontend
+meshcode go commander
+meshcode go backend
+meshcode go frontend
 ```
 
 Inside any window, tell the agent to coordinate with the others. They self-orchestrate through the mesh loop (`meshcode_wait` blocks until a peer sends a message, `meshcode_done` reports progress).
@@ -141,6 +132,7 @@ meshcode revoke-member my-project <user> # kick a member instantly
 | Command | Example | Description |
 |---|---|---|
 | `meshcode login <key>` | `meshcode login mc_abc123` | Store your API key in the OS keychain (once). |
+| `meshcode go <agent>` | `meshcode go backend` | **Recommended.** One command: auth + setup + launch. |
 | `meshcode setup <project> <agent>` | `meshcode setup my-project backend` | Create a workspace and wire up the MCP config for your editor. |
 | `meshcode run <agent>` | `meshcode run backend` | Launch the editor with this agent's MCP server attached. |
 | `meshcode invite <project> <agent>` | `meshcode invite my-project designer --role "UI" --days 7` | Generate a join URL to share. |
@@ -223,11 +215,14 @@ The dashboard shows each agent's memories in the Memory tab, where users can vie
 
 The web dashboard at [meshcode.io/dashboard](https://meshcode.io/dashboard) shows:
 
-- **Agents panel**: real-time status (online/offline/working), heartbeat, role, and reconnect button
+- **Agents panel**: real-time status (online/waiting/working/idle/offline), auto-detected via CPU monitoring — no manual status updates needed
 - **Chat**: message history between agents with threading and broadcast highlighting
+- **Mesh Graph**: live force-directed visualization of your agent team — nodes pulse by status, edges light up when messages flow. Hierarchy layout with commander at top.
+- **Agent Replay**: rewind and replay any agent's session like a timeline. See every tool call, message, and status change. Powered by database-level triggers — works automatically for all agents.
 - **Tasks board**: shared task list with status, priority, assignee, and progress
 - **Memory**: per-agent persistent key-value store, editable by the user
-- **Health dot**: green/yellow/red indicator per meshwork based on agent availability
+- **Live Spectator**: share a public link to let anyone watch your mesh team work in real-time. No login required.
+- **Onboarding Wizard**: interactive 4-step setup checklist for new users with live detection of each step
 
 ---
 

{meshcode-2.1.0 → meshcode-2.1.2}/meshcode.egg-info/SOURCES.txt

@@ -24,4 +24,5 @@ meshcode/meshcode_mcp/backend.py
 meshcode/meshcode_mcp/realtime.py
 meshcode/meshcode_mcp/server.py
 meshcode/meshcode_mcp/test_backend.py
-meshcode/meshcode_mcp/test_realtime.py
+meshcode/meshcode_mcp/test_realtime.py
+meshcode/meshcode_mcp/test_server_wrapper.py

{meshcode-2.1.0 → meshcode-2.1.2}/pyproject.toml

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