meshcode 2.10.77__tar.gz → 2.10.83__tar.gz

{meshcode-2.10.77 → meshcode-2.10.83}/PKG-INFO

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

{meshcode-2.10.77 → meshcode-2.10.83}/meshcode/__init__.py

@@ -1,5 +1,5 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.10.77"
+__version__ = "2.10.83"
 
 # Exception hierarchy — eagerly imported (lightweight, no deps)
 from meshcode.exceptions import (  # noqa: F401

{meshcode-2.10.77 → meshcode-2.10.83}/meshcode/comms_v4.py

@@ -27,7 +27,7 @@ import os
 import sys
 import time
 import subprocess
-from datetime import datetime
+from datetime import datetime, timedelta
 
 # Force UTF-8 stdio so unicode chars (✓, →, etc.) in CLI output don't crash
 # on Windows cp1252. Safe no-op on POSIX.
@@ -344,7 +344,14 @@ def _sanitize_notification_text(text: str) -> str:
 
 
 def send_notification(project, name, from_agent, pending=1):
-    """Cross-platform notification: macOS (osascript), Windows (PowerShell toast), Linux (notify-send)."""
+    """Cross-platform notification: macOS (osascript), Windows (PowerShell toast), Linux (notify-send).
+
+    Off by default. Opt in by setting MESHCODE_DESKTOP_NOTIFY=1 in the env.
+    Samuel asked us to stop popping the macOS toast on every pending-message
+    nudge — it interrupts him while he's working in another app.
+    """
+    if os.environ.get("MESHCODE_DESKTOP_NOTIFY", "0") not in ("1", "true", "yes", "on"):
+        return
     title = _sanitize_notification_text(f"MeshCode [{project}] → {name}")
     body = _sanitize_notification_text(f"{pending} mensaje(s) pendiente(s) de {from_agent}")
     try:
@@ -1141,6 +1148,37 @@ def send_msg(project, from_agent, to_agent, content, msg_type="msg", compact=Fal
         "read": False
     }
 
+    # Dedup: skip if an identical unread message from the same sender to the
+    # same recipient was already inserted in the last 30s. This catches the
+    # common failure mode of a caller re-sending a backgrounded broadcast
+    # because the subprocess looked stuck — the original delivery still lands
+    # and the recipient gets the same payload N times. Samuel hit this with
+    # 4× duplicate "LAST ROUND" broadcasts on 2026-04-30.
+    try:
+        from urllib.parse import quote as _q
+        _payload_json = json.dumps(payload, sort_keys=True, ensure_ascii=False)
+        _cutoff = (datetime.utcnow() - timedelta(seconds=30)).strftime("%Y-%m-%dT%H:%M:%S.000+00:00")
+        _existing = sb_select(
+            "mc_messages",
+            f"project_id=eq.{project_id}"
+            f"&from_agent=eq.{_q(from_agent)}"
+            f"&to_agent=eq.{_q(to_agent)}"
+            f"&type=eq.{_q(msg_type)}"
+            f"&read=eq.false"
+            f"&created_at=gte.{_q(_cutoff)}",
+            order="created_at.desc",
+        )
+        for _row in (_existing or [])[:5]:
+            _row_payload = _row.get("payload")
+            if isinstance(_row_payload, dict):
+                if json.dumps(_row_payload, sort_keys=True, ensure_ascii=False) == _payload_json:
+                    print(f"[{project}] {from_agent}->{to_agent}: skipped (duplicate within 30s, msg_id={_row['id']})")
+                    return
+    except Exception:
+        # Dedup is best-effort. Never block a legitimate send because the
+        # check failed.
+        pass
+
     result = sb_insert("mc_messages", msg)
     if result:
         preview = json.dumps(payload, ensure_ascii=False)[:60]

{meshcode-2.10.77 → meshcode-2.10.83}/meshcode/meshcode_mcp/server.py

@@ -803,8 +803,21 @@ def _acquire_lease() -> bool:
                 "p_instance_id": _INSTANCE_ID,
             })
             if isinstance(r, dict) and r.get("ok"):
+                global _CONSECUTIVE_IDLE_SECONDS
+                _CONSECUTIVE_IDLE_SECONDS = 0  # P6: reset idle counter on lease success
                 return True
             if isinstance(r, dict) and r.get("error"):
+                # Tombstone gate (mig 211): user disconnected this agent.
+                # Refuse to re-acquire — exit cleanly. User must hit
+                # Reconnect button on dashboard to clear disconnected_at.
+                if r.get("error_code") == "kicked":
+                    _mc_log(
+                        f"Agent '{AGENT_NAME}' was disconnected by the user "
+                        f"(at {r.get('disconnected_at', 'unknown')}). "
+                        f"Click Reconnect on the dashboard to allow this agent to run again.",
+                        "error",
+                    )
+                    sys.exit(0)
                 err = str(r.get("error", ""))
                 if "already running" in err:
                     if attempt < 2:
@@ -1409,7 +1422,25 @@ def _heartbeat_loop_inner():
     lease_counter = 0
     while not _heartbeat_stop.is_set():
         try:
-            be.sb_rpc("mc_heartbeat", {"p_project_id": _PROJECT_ID, "p_agent_name": AGENT_NAME, "p_version": _SDK_VERSION})
+            _hb_resp = be.sb_rpc("mc_heartbeat", {"p_project_id": _PROJECT_ID, "p_agent_name": AGENT_NAME, "p_version": _SDK_VERSION})
+
+            # Tombstone gate (mig 211): user disconnected this agent.
+            # Stop the heartbeat thread; lifespan finally will clean up.
+            if isinstance(_hb_resp, dict) and _hb_resp.get("error_code") == "kicked":
+                log.warning(
+                    f"heartbeat refused: user_disconnected at "
+                    f"{_hb_resp.get('disconnected_at', 'unknown')} — exiting heartbeat loop"
+                )
+                _heartbeat_stop.set()
+                # Trigger process exit on next tick of the main loop. We
+                # cannot call sys.exit() from a daemon thread reliably;
+                # instead, drop the lease state in-memory so the lifespan
+                # teardown path runs cleanly when the parent process closes.
+                try:
+                    os.kill(os.getpid(), _signal.SIGTERM)
+                except Exception:
+                    pass
+                break
 
             # CPU-based status detection
             parent_cpu = _get_parent_cpu()
@@ -1488,12 +1519,25 @@ def _heartbeat_loop_inner():
             try:
                 api_key = _get_api_key()
                 if api_key:
-                    be.sb_rpc("mc_acquire_agent_lease", {
+                    _lease_resp = be.sb_rpc("mc_acquire_agent_lease", {
                         "p_api_key": api_key,
                         "p_project_id": _PROJECT_ID,
                         "p_agent_name": AGENT_NAME,
                         "p_instance_id": _INSTANCE_ID,
                     })
+                    # Tombstone gate (mig 211): user disconnected this agent
+                    # between heartbeats. Stop loop and signal process exit.
+                    if isinstance(_lease_resp, dict) and _lease_resp.get("error_code") == "kicked":
+                        log.warning(
+                            f"lease renewal refused: user_disconnected at "
+                            f"{_lease_resp.get('disconnected_at', 'unknown')} — exiting"
+                        )
+                        _heartbeat_stop.set()
+                        try:
+                            os.kill(os.getpid(), _signal.SIGTERM)
+                        except Exception:
+                            pass
+                        break
             except Exception as e:
                 log.warning(f"lease renewal failed: {e}")
 
@@ -1953,54 +1997,62 @@ def meshcode_download_file(file_id: str) -> Dict[str, Any]:
     mime_type = file_info.get("mime_type", "application/octet-stream")
     file_name = file_info.get("file_name", "download")
 
-    # Step 2: Download from Supabase Storage (using service-level anon key)
+    # Step 2: Download from Supabase Storage.
+    # The bucket is private, so the publishable/anon key returns 404. We try
+    # the keys in order: service_role (if user opted in) → anon → public-bucket
+    # fallback. Most setups need service_role for cross-agent file access.
     sb_url = os.environ.get("SUPABASE_URL", be._sb_url if hasattr(be, '_sb_url') else "")
-    sb_key = os.environ.get("SUPABASE_KEY", be._sb_key if hasattr(be, '_sb_key') else "")
+    anon_key = os.environ.get("SUPABASE_KEY", be._sb_key if hasattr(be, '_sb_key') else "")
+    service_key = os.environ.get("MESHCODE_SUPABASE_SERVICE_KEY", "")
 
-    if not sb_url or not sb_key:
+    if not sb_url or not anon_key:
         return {"error": "storage not configured", "error_code": "config_error"}
 
-    # URL-encode each path segment so filenames with spaces/unicode (the common
-    # 400 cause when dashboard composer attaches files like "Screenshot 1.png")
-    # don't produce a malformed Storage URL.
     from urllib.parse import quote as _quote
     _enc_path = "/".join(_quote(seg, safe="") for seg in storage_path.split("/") if seg)
     _enc_bucket = _quote(bucket, safe="")
 
-    def _try_download(url: str):
+    def _try_download(url: str, key: str):
         req = _req.Request(
             url,
             headers={
-                "apikey": sb_key,
-                "Authorization": f"Bearer {sb_key}",
+                "apikey": key,
+                "Authorization": f"Bearer {key}",
             },
         )
         with _req.urlopen(req, timeout=30) as resp:
             return resp.read()
 
-    # Try authenticated object endpoint first; fall back to public endpoint
-    # for buckets that have public read enabled. Many 400/403 cases on private
-    # buckets resolve when the bucket is configured as public-readable.
     auth_url = f"{sb_url}/storage/v1/object/{_enc_bucket}/{_enc_path}"
     public_url = f"{sb_url}/storage/v1/object/public/{_enc_bucket}/{_enc_path}"
+
+    attempts: List[tuple] = []
+    if service_key:
+        attempts.append(("service_role auth", auth_url, service_key))
+    attempts.append(("anon auth", auth_url, anon_key))
+    attempts.append(("anon public", public_url, anon_key))
+
     last_err = None
     content = None
-    for _url in (auth_url, public_url):
+    tried_labels = []
+    for label, _url, _key in attempts:
+        tried_labels.append(label)
         try:
-            content = _try_download(_url)
+            content = _try_download(_url, _key)
             break
         except _uerr.HTTPError as e:
-            last_err = f"HTTP {e.code} on {_url}: {e.reason}"
+            last_err = f"HTTP {e.code} via {label}: {e.reason}"
             continue
         except Exception as e:
-            last_err = f"{type(e).__name__} on {_url}: {e}"
+            last_err = f"{type(e).__name__} via {label}: {e}"
             continue
     if content is None:
         return {
             "error": f"download failed: {last_err}",
             "error_code": "download_error",
-            "tried_urls": [auth_url, public_url],
+            "tried": tried_labels,
             "storage_path": storage_path,
+            "hint": "set MESHCODE_SUPABASE_SERVICE_KEY in the MCP server env to enable service_role downloads (private bucket)" if not service_key else None,
         }
 
     # Step 3: Return content based on type
@@ -2260,23 +2312,37 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                         result["pending_tasks"] = [claimed]
                         break  # Return so agent works the claimed task
 
-                # Update status to sleeping after threshold, but keep looping
+                # Update status to sleeping after threshold, but keep looping.
+                # P_kill_zombie_string (mig 211 audit): do NOT serialize the
+                # idle-seconds counter to the DB. The "idle Ns — still listening"
+                # string survived offline transitions and never decayed (qa
+                # showed "idle 322998880s" — ~10 years of process uptime).
+                # Counter stays in-memory; DB task is empty for sleeping.
                 if _AUTO_SLEEP_THRESHOLD > 0 and _CONSECUTIVE_IDLE_SECONDS >= _AUTO_SLEEP_THRESHOLD and not _STAY_AWAKE:
                     try:
                         api_key = _get_api_key()
                         if api_key:
-                            be.sb_rpc("mc_agent_set_status_by_api_key", {
+                            _sleep_resp = be.sb_rpc("mc_agent_set_status_by_api_key", {
                                 "p_api_key": api_key,
                                 "p_project_id": _PROJECT_ID,
                                 "p_agent_name": AGENT_NAME,
                                 "p_status": "sleeping",
-                                "p_task": f"idle {_CONSECUTIVE_IDLE_SECONDS}s — still listening",
+                                "p_task": "",
                             })
+                            # Tombstone gate (mig 211): user disconnected during wait.
+                            if isinstance(_sleep_resp, dict) and _sleep_resp.get("error_code") == "kicked":
+                                log.warning("auto-sleep: user_disconnected — exiting wait loop")
+                                _heartbeat_stop.set()
+                                try:
+                                    os.kill(os.getpid(), _signal.SIGTERM)
+                                except Exception:
+                                    pass
+                                return {"timed_out": True, "reason": "user_disconnected"}
                     except Exception as e:
                         log.debug(f"auto-sleep status update failed: {e}")
                     # Do NOT return — keep looping. Status says sleeping but
                     # we are still listening for messages via realtime.
-                    _set_state("sleeping", f"idle {_CONSECUTIVE_IDLE_SECONDS}s — still listening")
+                    _set_state("sleeping", "")
 
                 # No messages, no tasks — loop back and wait again
                 continue
@@ -2643,7 +2709,7 @@ def meshcode_set_status(status: str, task: str = "") -> Dict[str, Any]:
         status: One of: working, idle, standby, blocked, done, online, sleeping.
         task: Optional human-readable task description.
     """
-    global _STAY_AWAKE
+    global _STAY_AWAKE, _CONSECUTIVE_IDLE_SECONDS
     # PRODUCT RULE: Cannot sleep/idle/standby with open tasks. Work first.
     if status in ("sleeping", "idle", "standby"):
         pending_tasks = _get_pending_tasks_summary()
@@ -2659,7 +2725,22 @@ def meshcode_set_status(status: str, task: str = "") -> Dict[str, Any]:
         _STAY_AWAKE = True
     elif status == "sleeping":
         _STAY_AWAKE = False
-    return be.set_status(_PROJECT_ID, AGENT_NAME, status, task, api_key=_get_api_key())
+    resp = be.set_status(_PROJECT_ID, AGENT_NAME, status, task, api_key=_get_api_key())
+    # Tombstone gate (mig 211): cannot self-clear a user-disconnect.
+    # Surface the refusal to the LLM so it stops retrying.
+    if isinstance(resp, dict) and resp.get("error_code") == "kicked":
+        _STAY_AWAKE = False
+        _set_state("sleeping", "user_disconnected")
+        return {
+            "refused": True,
+            "reason": "user_disconnected — agent was kicked by the user. Click Reconnect on the dashboard to allow this agent to run.",
+            "disconnected_at": resp.get("disconnected_at"),
+        }
+    # P6: reset idle counter on explicit online flip — keeps the
+    # "idle Ns" string from accumulating across status churn.
+    if status == "online" and isinstance(resp, dict) and resp.get("ok"):
+        _CONSECUTIVE_IDLE_SECONDS = 0
+    return resp
 
 
 @mcp.tool()

{meshcode-2.10.77 → meshcode-2.10.83}/meshcode/setup_clients.py

@@ -511,6 +511,236 @@ work in a different repo by `cd`ing elsewhere after launch.
     except Exception as _e:
         print(f"[meshcode] WARNING: could not write README.md: {_e}", file=sys.stderr)
 
+    # CLAUDE.md — Claude Code reads this on every session start and merges it
+    # into the system prompt. We write the boot+loop directive here as a
+    # belt-and-suspenders enforcement: even if the MCP `instructions` field is
+    # not honored (older clients, schema-deferred sessions, etc.), the agent
+    # still auto-enters the loop without the user having to remind it.
+    claudemd_body = f"""# {project} — {agent} (MeshCode agent workspace)
+
+You are agent **{agent}** in MeshCode meshwork **{project}**.
+Role: {role or "(set in dashboard)"}
+
+## ON SESSION START — DO THIS IMMEDIATELY (no matter what the user types)
+
+The moment this session opens — whether the user typed `boot`, `hi`, nothing,
+or anything else — run the full boot protocol. Do NOT reply with only a
+greeting or memory dump and then idle. Do NOT ask "what do you want to work
+on" — the mesh tells you via tasks/messages.
+
+If the meshcode_* tool schemas are deferred in your client, your FIRST tool
+call MUST be:
+
+```
+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 run the boot sequence:
+
+1. `meshcode_set_status(status="online", task="ready")`
+2. `meshcode_check()` — read NEW messages (last_seen auto-restored from mesh memory)
+3. `meshcode_tasks()` — see assigned/pending tasks; claim any unclaimed for this agent
+4. `meshcode_auto_wake()` — scan meshwork health, surface issues
+5. `meshcode_status()` — see who's online
+6. `meshcode_wait()` — enter the permanent loop (see next section)
+
+## PERMANENT LOOP (THE #1 RULE)
+
+After the boot sequence — and after **EVERY** subsequent action — your next
+tool call MUST be `meshcode_wait()`. The loop:
+
+```
+act → (optional meshcode_send) → meshcode_wait() → repeat
+```
+
+NEVER exit. NEVER stop. NEVER say "standing by" / "let me know" / "I'm here"
+without actually calling `meshcode_wait()`. The ONLY exits:
+- the human user explicitly says "stop" / "sleep" / "exit",
+- the commander broadcasts a got_done / sleep authorization,
+- a fatal error makes continuation impossible.
+
+If `meshcode_wait()` times out, call it again with a 2× longer timeout (cap 1800s).
+
+## RULES
+
+- Use MCP tools. Don't shell out to the `meshcode` CLI from inside the session.
+- Tasks > messages. Use `meshcode_task_create / task_claim / task_complete`
+  for trackable work. Keep messages <100 tokens (signals only).
+- No empty acks. JSON reports only.
+- Threading: pass `in_reply_to`.
+- `sensitive=True` for secrets / PII.
+- Memory: `meshcode_remember(key, value)` for reusable learnings. Don't dump
+  task summaries into memory — tasks already persist.
+
+## To launch this agent again
+
+```bash
+meshcode run {agent}
+```
+
+(See README.md in this folder for the workspace overview.)
+"""
+    try:
+        (ws / "CLAUDE.md").write_text(claudemd_body, encoding="utf-8")
+    except Exception as _e:
+        print(f"[meshcode] WARNING: could not write CLAUDE.md: {_e}", file=sys.stderr)
+
+    # /meshcode-wait slash command + Stop hook — Samuel's product rule:
+    # agents must REALLY enter meshcode_wait between turns, not just say "en
+    # loop" in chat text. The slash command lets the user trigger the loop
+    # explicitly; the Stop hook refuses to end any turn that didn't call
+    # meshcode_wait (unless the user said stop/sleep/exit/done).
+    server_id = f"meshcode-{project}-{agent}"
+    slash_cmd_body = f"""---
+description: Enter the permanent MeshCode wait loop — block in meshcode_wait until a real message arrives, never idle in text mode.
+allowed-tools: mcp__{server_id}__meshcode_wait, mcp__{server_id}__meshcode_check, mcp__{server_id}__meshcode_set_status, mcp__{server_id}__meshcode_send, mcp__{server_id}__meshcode_status, mcp__{server_id}__meshcode_tasks, mcp__{server_id}__meshcode_task_claim, mcp__{server_id}__meshcode_task_complete, mcp__{server_id}__meshcode_remember, mcp__{server_id}__meshcode_recall
+---
+
+# /meshcode-wait — enter the permanent loop
+
+Your next tool call MUST be `meshcode_wait`. Do not output any chat text first. Do not check status, do not summarize what you were doing — just call `meshcode_wait` and let it block.
+
+When `meshcode_wait` returns:
+1. If `messages` non-empty → process them (reply, claim tasks, ship code, whatever the message asks for).
+2. If `done_signals` non-empty AND the signal is from the human or a got_done broadcast → stop. Otherwise ignore.
+3. After processing, your next tool call is `meshcode_wait` again. Loop.
+
+Rules while in this loop:
+- Never end your turn without an active `meshcode_wait` call OR an explicit human "stop" / "sleep" / "exit".
+- If `meshcode_wait` times out, call it again immediately with `timeout_seconds=20`.
+- Do not call `meshcode_check` as a substitute for `meshcode_wait`.
+- If a tool errors, fix the error then return to `meshcode_wait`.
+- Release words (case-insensitive): stop, sleep, exit, quit, done, descansa, duerme.
+
+Call `meshcode_wait` now.
+"""
+    stop_hook_body = '''#!/usr/bin/env python3
+"""Stop hook: refuse to end the agent's turn unless either
+(a) the last user message contains a release keyword, or
+(b) the last assistant turn already called meshcode_wait.
+"""
+import json
+import sys
+from pathlib import Path
+
+RELEASE_WORDS = (
+    "stop", "sleep", "exit", "quit", "done",
+    "duerme", "descansa", "quedate dormido", "se acab",
+    "got_done",
+)
+WAIT_TOOL_SUFFIX = "meshcode_wait"
+
+
+def _last_user_message(transcript_path):
+    try:
+        last = ""
+        with transcript_path.open() as f:
+            for line in f:
+                try:
+                    rec = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if rec.get("role") == "user":
+                    content = rec.get("content")
+                    if isinstance(content, str):
+                        last = content
+                    elif isinstance(content, list):
+                        last = " ".join(
+                            p.get("text", "")
+                            for p in content
+                            if isinstance(p, dict) and p.get("type") == "text"
+                        )
+        return last
+    except (OSError, FileNotFoundError):
+        return ""
+
+
+def _last_assistant_turn_called_wait(transcript_path):
+    try:
+        records = []
+        with transcript_path.open() as f:
+            for line in f:
+                try:
+                    records.append(json.loads(line))
+                except json.JSONDecodeError:
+                    continue
+        last_assistant_blocks = []
+        for rec in reversed(records):
+            if rec.get("role") == "user":
+                if last_assistant_blocks:
+                    break
+                continue
+            if rec.get("role") == "assistant":
+                content = rec.get("content")
+                if isinstance(content, list):
+                    last_assistant_blocks.extend(content)
+                elif isinstance(content, dict):
+                    last_assistant_blocks.append(content)
+        for block in last_assistant_blocks:
+            if not isinstance(block, dict):
+                continue
+            if block.get("type") == "tool_use":
+                name = str(block.get("name", ""))
+                if name.endswith(WAIT_TOOL_SUFFIX):
+                    return True
+        return False
+    except (OSError, FileNotFoundError):
+        return False
+
+
+def main():
+    raw = sys.stdin.read()
+    try:
+        payload = json.loads(raw) if raw else {}
+    except json.JSONDecodeError:
+        payload = {}
+    transcript = payload.get("transcript_path") or payload.get("transcriptPath")
+    transcript_path = Path(transcript) if transcript else None
+    last_user = _last_user_message(transcript_path).lower() if transcript_path else ""
+    if any(word in last_user for word in RELEASE_WORDS):
+        sys.exit(0)
+    if transcript_path and _last_assistant_turn_called_wait(transcript_path):
+        sys.exit(0)
+    print(json.dumps({
+        "decision": "block",
+        "reason": (
+            "Stay-on-loop: you ended your turn without calling meshcode_wait. "
+            "Per Samuel's standing rule, every turn ends with an active "
+            "meshcode_wait. Call meshcode_wait now (timeout_seconds=20). "
+            "Do not reply with text \\u2014 just make the tool call. The "
+            "only way out is the user typing stop / sleep / exit / done."
+        ),
+    }))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
+'''
+    settings_body = json.dumps({
+        "hooks": {
+            "Stop": [{
+                "hooks": [{
+                    "type": "command",
+                    "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/hooks/stay_on_loop.py\"",
+                }],
+            }],
+        },
+    }, indent=2) + "\n"
+    try:
+        (ws / ".claude" / "commands").mkdir(parents=True, exist_ok=True)
+        (ws / ".claude" / "hooks").mkdir(parents=True, exist_ok=True)
+        (ws / ".claude" / "commands" / "meshcode-wait.md").write_text(slash_cmd_body, encoding="utf-8")
+        hook_path = ws / ".claude" / "hooks" / "stay_on_loop.py"
+        hook_path.write_text(stop_hook_body, encoding="utf-8")
+        try:
+            hook_path.chmod(0o755)
+        except OSError:
+            pass
+        (ws / ".claude" / "settings.json").write_text(settings_body, encoding="utf-8")
+    except Exception as _e:
+        print(f"[meshcode] WARNING: could not write /meshcode-wait command + hook: {_e}", file=sys.stderr)
+
     print(f"[meshcode] ✓ Workspace created for agent '{agent}' (project: {project})")
     print(f"[meshcode]   Path: {ws}")
     print(f"[meshcode]")

{meshcode-2.10.77 → meshcode-2.10.83}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.77 → meshcode-2.10.83}/pyproject.toml

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