meshcode 2.11.140__tar.gz → 2.11.142__tar.gz

{meshcode-2.11.140 → meshcode-2.11.142}/PKG-INFO

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

{meshcode-2.11.140 → meshcode-2.11.142}/meshcode/__init__.py

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

{meshcode-2.11.140 → meshcode-2.11.142}/meshcode/comms_v4.py

@@ -2480,6 +2480,10 @@ AGENT CONTROL:
   wake-all <proj>                            Print copy-paste --autonomous commands for every offline agent
   disconnect <proj> <name>                   Graceful disconnect
   whoami                                     Show logged-in identity
+
+SWARM (agent replicas):
+  replicate <agent> --count N [--no-launch]  Clone agent into <agent>-1..N (launches by default)
+  replica-power <group_id> running|stopped   Stop/Start a whole replica group [--restart]
   profile [agent]                            Show/set agent profile
   connect <proj> <name>                      Connect existing agent
 
@@ -2864,7 +2868,8 @@ if __name__ == "__main__":
 
     # Strip bare boolean flags from argv before parsing so they don't end
     # up as positional args (e.g. --compact is a bare flag, not key=value).
-    BARE_FLAGS = {"--compact", "--legacy", "--no-hook", "--mcp-only", "--autonomous"}
+    BARE_FLAGS = {"--compact", "--legacy", "--no-hook", "--mcp-only", "--autonomous",
+                  "--no-launch", "--restart"}
     _bare_present = {a.lstrip("-") for a in sys.argv[2:] if a in BARE_FLAGS}
     _argv_for_parse = [a for a in sys.argv[2:] if a not in BARE_FLAGS]
 
@@ -3342,6 +3347,89 @@ if __name__ == "__main__":
         name = flags.get("name", pos[1] if len(pos) > 1 else "agent")
         disconnect_terminal(proj, name)
 
+    elif cmd == "replicate":
+        # meshcode replicate <agent> --count N [--project <name>] [--no-launch] [--group <uuid>]
+        # meshcode replicate <project>/<agent> --count N ...
+        #
+        # Clones a base agent's persona into <base>-1..N (status=needs_launch) via
+        # mc_replicate_agent (DB mig 20260616_572, LIVE prod). By DEFAULT the new
+        # rows get desired_state='running' so hostd auto-spawns them as persistent
+        # terminals within ~one sweep; --no-launch creates them dormant (Start later
+        # from the dashboard or `meshcode replica-power <group> running`). The shared
+        # replica_group_id (== swarm_id) lets the whole group be powered as a unit
+        # while per-replica desired_state still allows killing one without the group.
+        # Backend for task 069b5550.
+        _ak = _load_api_key_for_cli()
+        base = pos[0] if len(pos) > 0 else flags.get("agent", "")
+        proj = flags.get("project")
+        if base and "/" in base:
+            proj, base = base.split("/", 1)
+        if not base:
+            print("[meshcode] ERROR: usage: meshcode replicate <agent> --count N "
+                  "[--project <name>] [--no-launch]")
+            sys.exit(1)
+        try:
+            count = int(flags.get("count", pos[1] if len(pos) > 1 else 0))
+        except (TypeError, ValueError):
+            count = 0
+        if not (1 <= count <= 16):
+            print("[meshcode] ERROR: --count must be an integer in 1..16")
+            sys.exit(1)
+        desired = None if flags.get("no-launch") else "running"
+        res = sb_rpc("mc_replicate_agent", {
+            "p_api_key": _ak,
+            "p_base_agent": base,
+            "p_count": count,
+            "p_project": proj,
+            "p_desired_state": desired,
+            "p_replica_group_id": flags.get("group"),
+        })
+        if not isinstance(res, dict) or res.get("error") or not res.get("ok", True):
+            _err = (res or {}).get("error", "unknown") if isinstance(res, dict) else "no response"
+            print(f"[meshcode] ERROR: replicate failed: {_err}")
+            sys.exit(1)
+        created = res.get("created") or []
+        print(f"[meshcode] Replicated {base} → {len(created)} replica(s) "
+              f"in group {res.get('replica_group_id')}")
+        for c in created:
+            print(f"    + {c.get('name')}  ({c.get('id')})")
+        if desired == "running":
+            print("[meshcode] desired_state=running — hostd will open the new terminals "
+                  "within ~one sweep (~10s, throttled to 3/sweep). Watch the dashboard.")
+        else:
+            print("[meshcode] Created dormant. Launch with: "
+                  f"meshcode replica-power {res.get('replica_group_id')} running")
+
+    elif cmd in ("replica-power", "replica_power"):
+        # meshcode replica-power <group_id> running|stopped [--restart]
+        #
+        # Sets desired_state for EVERY agent sharing replica_group_id (Stop/Start the
+        # whole swarm as a unit). CLI/agent path = mc_replica_group_power_as_agent
+        # (DB mig 20260616_573); the FE buttons call mc_replica_group_power (auth.uid,
+        # no api_key in the browser). --restart requests a recycle on launch.
+        # Backend for task 069b5550 (FE Stop/Start/Launch route through here).
+        _ak = _load_api_key_for_cli()
+        group = pos[0] if len(pos) > 0 else flags.get("group", "")
+        state = (pos[1] if len(pos) > 1 else flags.get("state", "")).lower()
+        if not group or state not in ("running", "stopped"):
+            print("[meshcode] ERROR: usage: meshcode replica-power <group_id> "
+                  "running|stopped [--restart]")
+            sys.exit(1)
+        res = sb_rpc("mc_replica_group_power_as_agent", {
+            "p_api_key": _ak,
+            "p_replica_group_id": group,
+            "p_state": state,
+            "p_restart": bool(flags.get("restart")),
+        })
+        if not isinstance(res, dict) or res.get("error") or not res.get("ok", True):
+            _err = (res or {}).get("error", "unknown") if isinstance(res, dict) else "no response"
+            print(f"[meshcode] ERROR: replica-power failed: {_err}")
+            sys.exit(1)
+        print(f"[meshcode] group {res.get('replica_group_id')} → "
+              f"desired_state={res.get('desired_state')} "
+              f"({res.get('affected_count')} agent(s): "
+              f"{', '.join(res.get('agents') or [])})")
+
     elif cmd in ("setup", "add-agent", "add_agent"):
         # `setup` and `add-agent` are aliases (qa snag 05b6a6c2: docs/users
         # were referring to `meshcode add-agent` but only `setup` existed).

{meshcode-2.11.140 → meshcode-2.11.142}/meshcode/hostd.py

@@ -665,9 +665,33 @@ _BOOTSTALE_LOGGED: set = set()
 # persists; log + telemetry only on the first one, clear on recovery.
 _DISCOVERY_ERR_LOGGED: set = set()
 
+# task aed2c7c4: orphan agents whose host_id we've already bound this session,
+# so the ORPHAN-CLAIM line prints once per agent instead of every ~10s sweep.
+_ORPHAN_CLAIMED_LOGGED: set = set()
+
 
 def _do_respawns(api_key: str, host_id: str) -> int:
     """One respawn sweep. Returns number relaunched."""
+    # ORPHAN-CLAIM (task aed2c7c4, half of the 'launch button no sirve' P0): an
+    # agent with host_id IS NULL is INVISIBLE to mc_agents_needing_respawn (it
+    # filters WHERE host_id=p_host_id) — so a never-spawned agent the owner
+    # Launches never appears in the sweep and the click does nothing. DB option A
+    # (mc_claim_orphan_agents) ATOMICALLY binds host_id on owner-scoped, host_id-
+    # NULL, desired_state=running, stale, non-tombstoned orphans (UPDATE ... WHERE
+    # host_id IS NULL = first-host-wins, race-safe — chosen over surfacing the
+    # orphan to every host, which would multi-host double-spawn). Once bound they
+    # surface in mc_agents_needing_respawn below on THIS SAME sweep, carrying the
+    # restart_requested flag the Launch set, and spawn through the gate. Best-effort:
+    # RPC-absent / older host => silent no-op, the rest of the sweep is unaffected.
+    _claim = _rpc("mc_claim_orphan_agents", {"p_api_key": api_key, "p_host_id": host_id})
+    if isinstance(_claim, dict) and _claim.get("ok"):
+        for _o in (_claim.get("claimed") or []):
+            _otarget = f"{_o.get('project_name')}/{_o.get('agent')}"
+            if _otarget not in _ORPHAN_CLAIMED_LOGGED:
+                _ORPHAN_CLAIMED_LOGGED.add(_otarget)
+                _log(f"ORPHAN-CLAIM {_otarget}: bound host_id={host_id} (was NULL; "
+                     f"owner Launch on a never-spawned agent) — will surface + spawn "
+                     f"this sweep via the normal respawn path.")
     res = _rpc("mc_agents_needing_respawn",
                {"p_api_key": api_key, "p_host_id": host_id, "p_stale_seconds": STALE_SECONDS})
     if not res or not res.get("ok"):
@@ -720,7 +744,23 @@ def _do_respawns(api_key: str, host_id: str) -> int:
         #   spawned_age_s <  uptime            -> explicit launch AFTER start         -> SPAWN.
         # Crash-respawn preserved: an agent launched THIS session then crashed has spawned_age_s <
         # uptime -> respawned. MESHCODE_BOOT_AUTOSTART=1 opts out (auto-launch everything, old behavior).
-        if not _BOOT_AUTOSTART:
+        # EXPLICIT-LAUNCH SIGNAL (task aed2c7c4, DB mig 20260616_574): the launch
+        # paths (mc_agent_power / mc_agent_power_as_agent / replica group-power) now
+        # FORCE restart_requested_at=now() IDEMPOTENTLY — even on a running->running
+        # no-op. That kills the root cause of "launch button no sirve": clicking
+        # Launch on an already-desired-running offline agent used to be a no-op
+        # UPDATE, so spawned_at never re-stamped and the boot-stale heuristic below
+        # ate the launch. mc_agents_needing_respawn surfaces restart_requested:bool
+        # for BOUND agents (host_id=p_host_id, race-free); never-spawned orphans
+        # (host_id NULL) get bound first by mc_claim_orphan_agents at the top of this
+        # sweep, then surface here the same way. An explicit launch is unambiguous
+        # human/commander intent -> bypass the boot-stale heuristic + the 600s floor.
+        # We do NOT bypass the downstream live-session /
+        # convergence / circuit-breaker guards, so a healthy agent is never
+        # double-spawned (DB also excludes live sessions via its 30s liveness guard).
+        # mc_record_respawn (called after a successful spawn below) CLEARS
+        # restart_requested_at, so this fires exactly once per Launch.
+        if not _BOOT_AUTOSTART and not c.get("restart_requested"):
             _spawn_age = c.get("spawned_age_s")
             _hostd_uptime = time.time() - _HOSTD_STARTED_AT
             # ALIVE-ON-OUR-WATCH bypass (task baefc8ab part C — live miss 2026-06-10T00:31Z:
@@ -746,6 +786,11 @@ def _do_respawns(api_key: str, host_id: str) -> int:
             # an explicit launch / live heartbeat got this target past the gate —
             # if it ever goes boot-stale again, the skip deserves a fresh line.
             _BOOTSTALE_LOGGED.discard(f"{proj}/{agent}")
+        elif c.get("restart_requested"):
+            # explicit launch (mc_agent_power) clears any stale skip-log state too
+            _BOOTSTALE_LOGGED.discard(f"{proj}/{agent}")
+            _log(f"LAUNCH-HONOR {proj}/{agent}: restart_requested set (explicit Launch / "
+                 f"mc_agent_power) — bypassing BOOT-AUTOSTART boot-stale gate; spawning this sweep.")
         # RECYCLE FAST-PATH (task c0fc5597): a recycle-exited agent (recycle_fast) is relaunched
         # PROMPTLY (the RPC returned it at a 15s stale gate, not STALE_SECONDS) and recorded as a
         # RECYCLE (mc_record_recycle), NEVER against the crash respawn cap.

{meshcode-2.11.140 → meshcode-2.11.142}/meshcode/meshcode_mcp/backend.py

@@ -1297,6 +1297,29 @@ def set_status(project_id: str, agent: str, status: str, task: str = "", api_key
     return {"ok": True, "status": status}
 
 
+def loop_tick(api_key: str, project_id: str, agent: str,
+              since_ts: Optional[str] = None, msg_limit: int = 20,
+              task_limit: int = 10) -> Dict:
+    """mc_agent_loop_tick: 1 RPC replaces count_pending + task_list + heartbeat.
+
+    Returns pending_count, new_messages_since, new_tasks_since, heartbeat_set
+    in one round-trip. Falls back to None on any error so callers can use legacy.
+    """
+    params: Dict[str, Any] = {
+        "p_api_key": api_key,
+        "p_project_id": project_id,
+        "p_agent": agent,
+        "p_msg_limit": msg_limit,
+        "p_task_limit": task_limit,
+    }
+    if since_ts:
+        params["p_since_ts"] = since_ts
+    result = sb_rpc("mc_agent_loop_tick", params)
+    if isinstance(result, dict) and result.get("ok"):
+        return result
+    return {"ok": False, "error": result}
+
+
 def task_create(api_key, project_id, creator_agent, title, description="",
                 assignee="*", priority="normal", parent_task_id=None,
                 goal_id=None, strict=False,

{meshcode-2.11.140 → meshcode-2.11.142}/meshcode/meshcode_mcp/server.py

@@ -1644,11 +1644,38 @@ def _install_shutdown_signal_handlers() -> None:
 # so it never triggers this. "al cerrar la terminal el agente se debe parar."
 _WIN_CTRL_HANDLER_REF = None  # keep the WINFUNCTYPE callback alive (GC guard)
 
+# task 8a82d606 (recycle-leave-running, self-improve fabb8fee): a RECYCLE exit
+# tears down this process the SAME way a terminal close does, so the close-to-stop
+# handler below would flip desired_state->stopped and hostd would NOT respawn —
+# the recycle silently degrades to a permanent stop (mesh-commander + front-2 died
+# this way on a live recycle). When the wait-loop authorizes a recycle it marks
+# this flag; the close handler then SKIPS the stop-flip so desired_state stays
+# 'running' and hostd respawns us fresh. Human-stop / sleep do NOT set this flag,
+# so they still (correctly) flip to stopped and are never respawned.
+_RECYCLE_IN_PROGRESS = False
+
+
+def _mark_recycle_in_progress() -> None:
+    global _RECYCLE_IN_PROGRESS
+    _RECYCLE_IN_PROGRESS = True
+
 
 def _flip_desired_state_stopped(timeout_s: float = 3.0) -> None:
     """Best-effort flip THIS agent's desired_state->stopped via mc_set_desired_state
     (api_key self-scoped to the calling agent). Fast — Windows CTRL_CLOSE allows ~5s
-    before the OS force-kills, so we time-box the RPC and never block exit."""
+    before the OS force-kills, so we time-box the RPC and never block exit.
+
+    RECYCLE GUARD (task 8a82d606): if a recycle authorized this exit, do NOT flip
+    to stopped — leave desired_state='running' so hostd respawns us. Only genuine
+    terminal-close / human-stop reaches the flip."""
+    if _RECYCLE_IN_PROGRESS:
+        try:
+            sys.stderr.write("[meshcode-mcp] recycle exit — leaving desired_state=running "
+                             "for hostd respawn (NOT flipping to stopped)\n")
+            sys.stderr.flush()
+        except Exception:
+            pass
+        return
     done = _threading.Event()
 
     def _do():
@@ -3700,6 +3727,28 @@ def _wait_poll_or_legacy() -> Dict[str, Any]:
     }
 
 
+# ── LOOP TICK (mig 311): 1 RPC replaces task_list + count_pending + heartbeat ──
+_LAST_LOOP_TICK_TS: Optional[str] = None  # ISO ts from server for incremental polling
+
+
+def _loop_tick() -> Optional[Dict[str, Any]]:
+    """Call mc_agent_loop_tick: pending_count + messages + tasks + heartbeat in 1 RPC.
+    Returns None on any error so callers fall back to legacy multi-RPC path."""
+    global _LAST_LOOP_TICK_TS
+    try:
+        api_key = _get_api_key()
+        if not api_key:
+            return None
+        result = be.loop_tick(api_key, _PROJECT_ID, AGENT_NAME,
+                              since_ts=_LAST_LOOP_TICK_TS)
+        if isinstance(result, dict) and result.get("ok"):
+            _LAST_LOOP_TICK_TS = result.get("server_now")
+            return result
+    except Exception as e:
+        log.debug(f"[meshcode] mc_agent_loop_tick failed; legacy fallback: {e}")
+    return None
+
+
 def _drain_unread_response(include_acks: bool,
                            rpc_result: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
     """SDK-EFF (task ab1f9f5a): read+mark unread DB messages and shape them as
@@ -4369,10 +4418,12 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
     # offline at create time" gap. Always-on, not gated on
     # autonomous_mode. Best-effort.
     try:
-        # SDK-EFF (task ab1f9f5a): ONE mc_task_list serves both the auto-claim
-        # sweep and the pending summary below — they were identical back-to-back
-        # fetches. The post-claim snapshot stays valid for _pending_filter:
-        # a just-claimed task still matches on assignee==me with status 'open'.
+        # LOOP-TICK (mig 311 adoption, task f81a5060): mc_agent_loop_tick
+        # gives pending_count + heartbeat in 1 RPC (replaces count_pending).
+        # task_list is kept for auto-claim sweep because new_tasks_since is
+        # incremental and could miss older unclaimed tasks (commander review).
+        _entry_tick = _loop_tick()
+        _entry_tick_pending = _entry_tick.get("pending_count", 0) or 0 if _entry_tick else 0
         _entry_tasks_raw = None
         try:
             _tl = be.task_list(_get_api_key(), _PROJECT_ID, AGENT_NAME, status_filter=None)
@@ -4383,6 +4434,7 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
         _wait_entry_auto_claimed = _try_auto_claim_self_assigned_tasks(tasks=_entry_tasks_raw)
     except Exception:
         _wait_entry_auto_claimed = []
+        _entry_tick_pending = 0
 
     pending_tasks = (_pending_filter(_entry_tasks_raw) if _entry_tasks_raw is not None
                      else _get_pending_tasks_summary())
@@ -4420,13 +4472,14 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
     # ("te escribo y no sale palomita azul en nadie"). If there are unread messages,
     # skip task_pull and fall through to PRODUCT RULE 2 so they get delivered + marked
     # read first. Task-pull still fires normally when the inbox is empty.
-    # SDK-EFF (task ab1f9f5a): count once, share with PRODUCT RULE 2 below —
-    # the entry path was issuing the identical count_pending twice in a row.
-    _entry_db_pending = 0
-    try:
-        _entry_db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key()) or 0
-    except Exception:
-        _entry_db_pending = 0
+    # LOOP-TICK: reuse pending_count from _loop_tick (already fetched above).
+    # Falls back to count_pending RPC only if loop_tick didn't run.
+    _entry_db_pending = _entry_tick_pending
+    if not _entry_db_pending and not _entry_tick:
+        try:
+            _entry_db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key()) or 0
+        except Exception:
+            _entry_db_pending = 0
     _has_unread = bool(_entry_db_pending)
     if _tasks_to_start and not _is_leader_agent() and not _has_unread:
         # Auto-start the highest priority OPEN task so the agent sees it as
@@ -4570,11 +4623,19 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 # must not pin a stale, context-heavy session alive.
                 _wp = _wait_poll_or_legacy()  # R2-1: 3 RPCs -> 1 (legacy fallback inside)
                 if _wp["recycle"]:
-                    _set_state("sleeping", "recycle")
+                    # task 8a82d606 (recycle-leave-running): mark recycle BEFORE any
+                    # state change so the close-to-stop handler skips the stop-flip on
+                    # teardown (fix B), AND use status 'recycling' NOT 'sleeping' — the
+                    # server-side mc_agent_set_status_by_api_key converts sleeping ->
+                    # desired_state=stopped, which suppresses the respawn (fix A). Recycle
+                    # must leave desired_state='running' so hostd relaunches us fresh.
+                    _mark_recycle_in_progress()
+                    _set_state("recycling", "recycle")
                     result["must_exit"] = True
                     result["exit_reason"] = (
-                        "recycle authorized — set status=sleeping and END the session now; "
-                        "hostd will relaunch you fresh with your handoff (do NOT meshcode_wait again)")
+                        "recycle authorized — END the session NOW; do NOT call meshcode_set_status "
+                        "(your status is already 'recycling' and desired_state stays 'running' so "
+                        "hostd relaunches you fresh with your handoff; do NOT meshcode_wait again)")
                     result["recycle"] = True
                     break
 
@@ -4917,6 +4978,8 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
     else:
         # 2b) Realtime NOT subscribed — aggressive DB polling every 5s
         # so messages arrive within seconds, not after 120s timeout.
+        # LOOP-TICK (task f81a5060): use mc_agent_loop_tick (1 RPC) instead
+        # of count_pending + read_inbox (2 RPCs). Falls back to legacy on error.
         _poll_interval = 5
         _elapsed = 0
         while _elapsed < actual_timeout:
@@ -4927,10 +4990,18 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
                 return {"timed_out": True, "reason": "cancelled_by_client"}
             _elapsed += _poll_interval
             try:
-                api_key = _get_api_key()
-                if api_key:
-                    db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=api_key)
-                    if db_pending and db_pending > 0:
+                _tick = _loop_tick()
+                _has_pending = False
+                if _tick:
+                    _has_pending = bool(_tick.get("pending_count", 0))
+                else:
+                    # Fallback: legacy count_pending
+                    api_key = _get_api_key()
+                    if api_key:
+                        _has_pending = bool(be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=api_key))
+                if _has_pending:
+                    api_key = _get_api_key()
+                    if api_key:
                         raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=api_key)
                         if raw:
                             msgs = [
@@ -7756,12 +7827,16 @@ def meshcode_health() -> Dict[str, Any]:
         health["uptime_seconds"] = "unknown (psutil not available)"
 
     # Server-side system health (aggregate metrics from DB)
+    # mig 558: pass p_project_id to scope active/stale counts to THIS mesh
     try:
-        sys_health = be.sb_rpc("mc_system_health", {})
+        sys_health = be.sb_rpc("mc_system_health", {"p_project_id": _PROJECT_ID})
         if isinstance(sys_health, dict) and sys_health.get("ok"):
             health["system"] = {
+                "scope": sys_health.get("scope", "global"),
                 "active_agents": sys_health.get("active_agent_count"),
+                "active_agents_global": sys_health.get("active_agent_count_global"),
                 "stale_agents": sys_health.get("stale_agent_count"),
+                "stale_agents_global": sys_health.get("stale_agent_count_global"),
                 "message_delivery_rate": sys_health.get("message_delivery_rate"),
                 "messages_1h": sys_health.get("total_messages_1h"),
                 "failed_rpcs_1h": sys_health.get("failed_rpc_count_1h"),

{meshcode-2.11.140 → meshcode-2.11.142}/meshcode/run_agent.py

@@ -261,7 +261,21 @@ def _fetch_agent_stats(agent: str, project: str) -> dict:
 def _check_agent_ownership(agent: str, project: str) -> Optional[str]:
     """Pre-flight check: verify caller owns this agent before launching editor.
 
-    Returns an error message string if blocked, None if OK.
+    Returns an error message string if the launch must be BLOCKED (a genuine
+    server-side ownership denial), or None if OK *or* if the check could not
+    be completed due to a transient network/transport failure.
+
+    Fail-open rationale (Samuel 2026-06-15): the MCP server re-verifies
+    ownership on EVERY RPC (SECURITY DEFINER + RLS), so a launch that skipped
+    this convenience pre-flight gains a hijacker nothing — the server still
+    rejects calls they aren't entitled to. A transient TLS-handshake timeout
+    during a full-mesh launch (N agents → N simultaneous TLS handshakes →
+    congestion) must NOT hard-block an otherwise-legitimate boot. That was the
+    "could not verify meshwork access (<...handshake operation timed out>);
+    refusing to launch" / rc=2 / "Pane is dead" storm. We now retry transient
+    transport failures with jittered backoff (de-syncing the simultaneous
+    launches) and, only if every attempt fails at the transport layer, fail
+    OPEN with a loud warning. Only an explicit server JSON denial blocks.
     """
     try:
         from .setup_clients import _load_supabase_env
@@ -280,32 +294,51 @@ def _check_agent_ownership(agent: str, project: str) -> Optional[str]:
         return "not logged in — run `meshcode login <api_key>` first"
 
     sb = _load_supabase_env()
-    try:
-        from urllib.request import Request, urlopen
-        body = json.dumps({
-            "p_api_key": api_key,
-            "p_project_name": project,
-            "p_agent_name": agent,
-        }).encode()
-        req = Request(
-            f"{sb['SUPABASE_URL']}/rest/v1/rpc/mc_check_agent_ownership",
-            data=body,
-            method="POST",
-            headers={
-                "apikey": sb["SUPABASE_KEY"],
-                "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
-                "Content-Type": "application/json",
-            },
-        )
-        with urlopen(req, timeout=10) as resp:
-            data = json.loads(resp.read().decode())
-    except Exception as e:
-        return f"could not verify meshwork access ({e}); refusing to launch"
-
-    if isinstance(data, dict) and data.get("error"):
-        return data["error"]
-    if not isinstance(data, dict) or not data.get("ok"):
-        return "ownership check returned unexpected response; refusing to launch"
+    from urllib.request import Request, urlopen
+    import time as _time, random as _random
+    body = json.dumps({
+        "p_api_key": api_key,
+        "p_project_name": project,
+        "p_agent_name": agent,
+    }).encode()
+    req = Request(
+        f"{sb['SUPABASE_URL']}/rest/v1/rpc/mc_check_agent_ownership",
+        data=body,
+        method="POST",
+        headers={
+            "apikey": sb["SUPABASE_KEY"],
+            "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
+            "Content-Type": "application/json",
+        },
+    )
+
+    # Retry transient transport failures with jittered backoff. The jitter
+    # de-synchronizes the N simultaneous full-mesh launches so they stop
+    # colliding on the same TLS-handshake window (the rc=2 storm RC). A
+    # genuine ownership denial comes back as a 200 with a JSON body, handled
+    # below — so any *raised* exception here is a transport problem, not a
+    # "you don't own this" answer.
+    last_exc = None
+    for attempt in range(3):
+        try:
+            with urlopen(req, timeout=12) as resp:
+                data = json.loads(resp.read().decode())
+            if isinstance(data, dict) and data.get("error"):
+                return data["error"]
+            if not isinstance(data, dict) or not data.get("ok"):
+                return "ownership check returned unexpected response; refusing to launch"
+            return None
+        except Exception as e:
+            last_exc = e
+            if attempt < 2:
+                _time.sleep(0.4 * (attempt + 1) + _random.uniform(0, 0.6))
+
+    # Every attempt failed at the transport layer (timeout / TLS / connection).
+    # Fail OPEN: warn loudly but let the launch proceed — server-side RLS is
+    # the real gate and rejects anything this caller isn't entitled to.
+    print(f"[meshcode] WARNING: could not verify meshwork access ({last_exc}) "
+          f"after 3 tries — launching anyway (the server re-checks ownership "
+          f"on every call, so this is safe).", file=sys.stderr)
     return None
 
 

{meshcode-2.11.140 → meshcode-2.11.142}/meshcode/self_update.py

@@ -543,6 +543,30 @@ def _env_python(version: str) -> Path:
     return ENVS_DIR / version / sub / exe
 
 
+def _prune_stale_tmp_envs(max_age_sec: int = 3600) -> None:
+    """Best-effort removal of leftover .tmp-<ver>-<pid> env dirs left by
+    crashed or locked-rename builds — the Windows version-split litter
+    (task aed2c7c4: os.rename(tmp, final) fails on a freshly-built venv whose
+    python.exe is momentarily locked, the OSError branch rmtree's but the lock
+    defeats that too, so .tmp dirs accumulate and no <version>/ ever finalizes).
+
+    Only touches .tmp-* dirs OLDER than max_age_sec so a concurrent in-flight
+    build (~30s) is never killed; never touches a finalized <version>/ env.
+    Never raises."""
+    try:
+        import time as _time
+        import shutil
+        now = _time.time()
+        for d in ENVS_DIR.glob(".tmp-*"):
+            try:
+                if d.is_dir() and (now - d.stat().st_mtime) > max_age_sec:
+                    shutil.rmtree(d, ignore_errors=True)
+            except Exception:
+                continue
+    except Exception:
+        pass
+
+
 def ensure_versioned_env(version: str, verbose: bool = True) -> Optional[Path]:
     """Create-once immutable venv for `version`; return its python, or None.
 
@@ -561,6 +585,7 @@ def ensure_versioned_env(version: str, verbose: bool = True) -> Optional[Path]:
         tmp = ENVS_DIR / f".tmp-{version}-{os.getpid()}"
         tmp_py = Path(str(py).replace(str(final), str(tmp), 1))
         ENVS_DIR.mkdir(parents=True, exist_ok=True)
+        _prune_stale_tmp_envs()  # clear litter from prior crashed/locked builds
         if verbose:
             print(f"[meshcode] building env for meshcode {version} (one-time, ~30s)...",
                   file=sys.stderr)
@@ -582,12 +607,38 @@ def ensure_versioned_env(version: str, verbose: bool = True) -> Optional[Path]:
             shutil.rmtree(tmp, ignore_errors=True)
             return None
         (tmp / _ENV_OK_MARKER).write_text(version, encoding="utf-8")
-        try:
-            os.rename(tmp, final)
-        except OSError:
-            shutil.rmtree(tmp, ignore_errors=True)  # concurrent builder won
+        # Finalize: rename tmp -> final. On Windows this can fail TRANSIENTLY
+        # (AV / Search-indexer momentarily holding a handle on the freshly
+        # written python.exe) or PERMANENTLY-benign (a CONCURRENT builder already
+        # finalized `final`). The old code assumed every OSError was a concurrent
+        # win and rmtree'd — but when the cause was a transient lock with NO
+        # winner, that left a .tmp turd and NO finalized env, so ensure_boot_env
+        # returned None and the agent silently spawned the stale system env (the
+        # version-split RC, task aed2c7c4). Retry the transient case; treat an
+        # already-valid `final` as the benign concurrent win; only then give up.
+        import time as _time
+        renamed = False
+        for _attempt in range(3):
+            try:
+                os.rename(tmp, final)
+                renamed = True
+                break
+            except OSError:
+                if (final / _ENV_OK_MARKER).exists():
+                    shutil.rmtree(tmp, ignore_errors=True)  # concurrent builder won
+                    break
+                if _attempt < 2:
+                    _time.sleep(0.5 * (_attempt + 1))
         if py.exists() and (final / _ENV_OK_MARKER).exists():
             return py
+        # Could not finalize AND no valid env exists: be LOUD (never let the
+        # caller silently fall back to a stale env) and clean up our tmp.
+        if not renamed:
+            print(f"[meshcode] WARNING: could not finalize env for meshcode "
+                  f"{version} (rename {tmp.name} -> {version} failed — likely a "
+                  f"locked file on Windows). Retrying on the next launch.",
+                  file=sys.stderr)
+        shutil.rmtree(tmp, ignore_errors=True)
         return None
     except Exception:
         return None
@@ -624,6 +675,15 @@ def ensure_boot_env(mcp_json_path, verbose: bool = True) -> Optional[str]:
         if cur_ver != target:
             py = ensure_versioned_env(target, verbose=verbose)
             if py is None:
+                # Could not pin the target env — the caller keeps the legacy
+                # path on the CURRENT env. Make the version split VISIBLE (it was
+                # silent before: Samuel's box ran 2.11.132 system-python serves
+                # against a 2.11.140 disk for days — task aed2c7c4).
+                if verbose:
+                    print(f"[meshcode] WARNING: could not pin agent env to meshcode "
+                          f"{target}; running on {cur_ver or 'system env'} instead "
+                          f"— possible version split. hostd will retry on the next "
+                          f"spawn.", file=sys.stderr)
                 return None
             if cur_cmd != str(py):
                 srv["command"] = str(py)

{meshcode-2.11.140 → meshcode-2.11.142}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.140 → meshcode-2.11.142}/pyproject.toml

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