meshcode 2.11.90__tar.gz → 2.11.93__tar.gz

{meshcode-2.11.90 → meshcode-2.11.93}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.90
+Version: 2.11.93
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -442,6 +442,14 @@ CDN propagation. Wait ~60s and force-fetch directly from the origin:
 pip install --no-cache-dir -i https://pypi.org/simple/ meshcode
 ```
 
+**12. Upgrading to v2.11.88+: relaunch already-running agents and host ONCE**
+From v2.11.88 the host daemon (hostd) auto-restarts itself when a newer SDK lands on disk, so the Stop/kill sweep and launch fixes pick up automatically — and managed agents version-recycle cooperatively to follow. But an agent (or hostd) **already running an older SDK** carries that old code in memory and can't be auto-recycled (old code doesn't honor the recycle signal). Cross the gap once:
+```bash
+pip install --upgrade meshcode          # writes the new wheel to disk
+meshcode login                          # restarts a stale hostd (v2.11.90+ does this only if provably stale)
+```
+Then relaunch each still-old agent once (`meshcode run <project>/<agent>`, or close + reopen its Claude Code session). After this one-time relaunch, every agent obeys cooperative recycle and stays current automatically — no manual restarts thereafter.
+
 ---
 
 ## Links

{meshcode-2.11.90 → meshcode-2.11.93}/README.md

@@ -410,6 +410,14 @@ CDN propagation. Wait ~60s and force-fetch directly from the origin:
 pip install --no-cache-dir -i https://pypi.org/simple/ meshcode
 ```
 
+**12. Upgrading to v2.11.88+: relaunch already-running agents and host ONCE**
+From v2.11.88 the host daemon (hostd) auto-restarts itself when a newer SDK lands on disk, so the Stop/kill sweep and launch fixes pick up automatically — and managed agents version-recycle cooperatively to follow. But an agent (or hostd) **already running an older SDK** carries that old code in memory and can't be auto-recycled (old code doesn't honor the recycle signal). Cross the gap once:
+```bash
+pip install --upgrade meshcode          # writes the new wheel to disk
+meshcode login                          # restarts a stale hostd (v2.11.90+ does this only if provably stale)
+```
+Then relaunch each still-old agent once (`meshcode run <project>/<agent>`, or close + reopen its Claude Code session). After this one-time relaunch, every agent obeys cooperative recycle and stays current automatically — no manual restarts thereafter.
+
 ---
 
 ## Links

{meshcode-2.11.90 → meshcode-2.11.93}/meshcode/__init__.py

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

{meshcode-2.11.90 → meshcode-2.11.93}/meshcode/ascii_art.py

@@ -12,6 +12,7 @@ Identicons are GUARANTEED unique — SHA-256 produces 2^256 patterns.
 The embedded tag ⟨ meshwork/agent ⟩ enables paste-to-run.
 """
 import hashlib
+import os
 
 # ── Block characters ────────────────────────────────────────────────
 BLOCKS = {
@@ -316,6 +317,187 @@ def hex_to_ansi(hex_color: str) -> str:
             best_dist = dist
             best_idx = i
     return COLORS[best_idx]
+
+
+# ── TERMINAL-BOOT-REAL-SPRITE (task 8e2e14d1) ───────────────────────
+# Render each agent's REAL dashboard sprite in 24-bit TRUECOLOR so the
+# terminal banner matches the dashboard PixelMascot "igualito". The body/
+# eyes/mouth are a faithful port of src/components/PixelMascot.tsx
+# generateConfig(name) — derived purely from the name hash (the dashboard
+# does NOT use the stored mascot_config for the body), and the color is the
+# agent's exact profile hex (not a nearest-16 approximation).
+
+# 8 body templates — LEFT HALF (4 cols), mirrored to 7 wide. 7 rows.
+# 0=empty 1=body 2=highlight 3=shadow. Exact copy of PixelMascot.tsx BODIES.
+_DASH_BODIES = [
+    [[0,0,1,1],[0,1,1,1],[1,1,1,1],[1,1,2,1],[1,1,1,1],[0,1,1,1],[0,0,1,0]],  # round blob
+    [[0,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,2,1],[1,1,1,1],[1,1,1,1],[0,1,0,1]],  # square bot
+    [[0,0,1,1],[0,1,1,1],[0,1,1,1],[1,1,2,1],[1,1,1,1],[0,1,1,0],[0,1,0,1]],  # tall
+    [[0,0,0,0],[0,1,1,1],[1,1,1,1],[1,1,2,1],[1,1,1,1],[1,1,1,1],[1,0,0,1]],  # wide toad
+    [[0,0,1,1],[0,1,1,1],[1,1,1,1],[1,1,2,1],[1,1,1,1],[1,1,1,1],[1,0,1,0]],  # ghost
+    [[1,0,0,0],[1,1,1,1],[0,1,1,1],[1,1,2,1],[1,1,1,1],[0,1,1,0],[0,1,0,1]],  # cat-ish
+    [[0,1,1,1],[1,1,1,1],[1,1,1,1],[0,0,1,1],[0,1,2,1],[0,1,1,1],[0,1,0,1]],  # mushroom
+    [[0,0,1,0],[0,1,1,1],[1,1,1,1],[1,1,2,1],[1,1,1,1],[0,1,1,1],[0,0,1,0]],  # star
+]
+# {row, col} of the eyes (mirrored across the 7-wide grid). Exact copy.
+_DASH_EYES = [
+    (3,1),(3,1),(3,1),(3,1),(2,1),(2,1),(3,1),(3,1),
+]
+# Mouth present? (none/smile/dot/open → bool). Exact copy of MOUTHS.
+_DASH_MOUTH = [False, True, True, True, False, True]
+# Hash-derived accessory the dashboard draws BY DEFAULT (renderMascot,
+# pick(ACCESSORIES,h,8)). Exact copy of PixelMascot.tsx ACCESSORIES types.
+_DASH_ACCESSORIES = ["none", "none", "hat", "antenna", "horns", "crown", "bowtie", "none"]
+
+
+def _js_hash(s: str) -> int:
+    """Port of PixelMascot.tsx hashStr: h=((h<<5)-h+c)|0 == 31*h+c (mod 2^32),
+    returned as Math.abs of the signed int32. Must match the dashboard so the
+    same name picks the same body/eyes/mouth."""
+    h = 0
+    for ch in s:
+        h = (h * 31 + ord(ch)) & 0xFFFFFFFF
+    if h >= 0x80000000:
+        h -= 0x100000000
+    return abs(h)
+
+
+def _js_pick(arr, h: int, offset: int):
+    """Port of pick(arr, hash, offset) = arr[(hash >>> offset) % len]."""
+    return arr[(h >> offset) % len(arr)]
+
+
+def _mirror_body(half):
+    """Port of mirrorBody: row -> reverse(row[0:3]) + row  (4 cols -> 7 cols)."""
+    return [list(reversed(row[0:3])) + list(row) for row in half]
+
+
+def _hsl_to_rgb(h: float, s: float, l: float):
+    c = (1 - abs(2 * l - 1)) * s
+    x = c * (1 - abs((h / 60.0) % 2 - 1))
+    m = l - c / 2
+    if h < 60:    r, g, b = c, x, 0
+    elif h < 120: r, g, b = x, c, 0
+    elif h < 180: r, g, b = 0, c, x
+    elif h < 240: r, g, b = 0, x, c
+    elif h < 300: r, g, b = x, 0, c
+    else:         r, g, b = c, 0, x
+    return (round((r + m) * 255), round((g + m) * 255), round((b + m) * 255))
+
+
+def _agent_color_rgb(name: str, profile_color: str = None):
+    """Exact profile hex when present, else the dashboard hashAgentColor(name)
+    fallback: hsl(abs(hash)%360, 70%, 65%) — keeps terminal == dashboard."""
+    if profile_color:
+        hx = profile_color.strip().lstrip("#")
+        if len(hx) == 6:
+            try:
+                return (int(hx[0:2], 16), int(hx[2:4], 16), int(hx[4:6], 16))
+            except ValueError:
+                pass
+    hue = _js_hash(name) % 360
+    return _hsl_to_rgb(hue, 0.70, 0.65)
+
+
+def _supports_truecolor() -> bool:
+    """24-bit detection. Force on/off via env for testing + dumb-terminal safety."""
+    if os.environ.get("MESHCODE_FORCE_TRUECOLOR") == "1":
+        return True
+    if os.environ.get("MESHCODE_NO_TRUECOLOR") or os.environ.get("NO_COLOR"):
+        return False
+    ct = os.environ.get("COLORTERM", "").lower()
+    if "truecolor" in ct or "24bit" in ct:
+        return True
+    term = os.environ.get("TERM", "").lower()
+    if "truecolor" in term or "24bit" in term or "direct" in term:
+        return True
+    if os.environ.get("TERM_PROGRAM") in ("iTerm.app", "Apple_Terminal", "vscode", "WezTerm", "ghostty"):
+        return True
+    return False
+
+
+def render_pixel_mascot_truecolor(agent_name: str, profile_color: str = None,
+                                   mascot_config: dict = None) -> str:
+    """The agent's REAL dashboard sprite in 24-bit truecolor. Each dashboard
+    pixel = two block chars (≈ square in a terminal cell). Falls back to the
+    nearest-16 single-color path via the caller when truecolor is unavailable."""
+    h = _js_hash(agent_name)
+    half = _js_pick(_DASH_BODIES, h, 0)
+    eye_row, eye_col = _js_pick(_DASH_EYES, h, 4)
+    has_mouth = _js_pick(_DASH_MOUTH, h, 12)
+    acc = _js_pick(_DASH_ACCESSORIES, h, 8)
+
+    grid = [list(r) for r in _mirror_body(half)]
+    rows = len(grid)
+    cols = len(grid[0])
+    # Overlay eyes (mirrored) + mouth as dark pixels, exactly like the canvas.
+    if 0 <= eye_row < rows:
+        if 0 <= eye_col < cols:
+            grid[eye_row][eye_col] = 9
+        if 0 <= cols - 1 - eye_col < cols:
+            grid[eye_row][cols - 1 - eye_col] = 9
+    mouth_row = eye_row + 2
+    if has_mouth and 0 <= mouth_row < rows:
+        grid[mouth_row][cols // 2] = 9
+
+    # Accessories — the dashboard draws one hash-derived accessory by default
+    # (codes: 4=hat 5=horns 6=crown 7=bowtie 8=antenna-tip). bowtie sits below
+    # the face inside the body; hat/antenna/horns/crown need headroom, so we
+    # prepend 2 rows and draw above the body's first filled row, matching the
+    # canvas geometry (relative to topRow).
+    if acc == "bowtie":
+        bow = eye_row + 3   # canvas bowY = (eyes.row + 3)
+        if 0 <= bow < len(grid):
+            for c in (cols // 2 - 1, cols // 2, cols // 2 + 1):
+                if 0 <= c < cols:
+                    grid[bow][c] = 7
+    elif acc in ("hat", "antenna", "horns", "crown"):
+        grid = [[0] * cols, [0] * cols] + grid
+        top = next((i for i, rw in enumerate(grid) if any(rw)), 2)
+        cc = cols // 2
+        if acc == "hat":
+            for x in range(1, cols - 1):
+                grid[top - 1][x] = 4          # brim
+            for x in range(2, cols - 2):
+                grid[top - 2][x] = 4          # crown top
+        elif acc == "horns":
+            grid[top - 1][1] = 5
+            grid[top - 1][cols - 2] = 5
+        elif acc == "crown":
+            for x in range(1, cols - 1):
+                grid[top - 1][x] = 6          # band
+            for x in (1, cc, cols - 2):
+                grid[top - 2][x] = 6          # spikes
+        elif acc == "antenna":
+            grid[top - 1][cc] = 1             # stalk = body color
+            grid[top - 2][cc] = 8             # white tip
+
+    r, g, b = _agent_color_rgb(agent_name, profile_color)
+    palette = {
+        1: (r, g, b),
+        2: (min(255, r + 60), min(255, g + 60), min(255, b + 60)),   # highlight
+        3: (max(0, r - 40), max(0, g - 40), max(0, b - 40)),         # shadow
+        4: (max(0, r - 30), max(0, g - 30), max(0, b - 30)),         # hat (canvas r-30)
+        5: (min(255, r + 40), min(255, g + 40), min(255, b + 40)),   # horns (canvas r+40)
+        6: (251, 191, 36),                                           # crown #fbbf24
+        7: (244, 63, 94),                                            # bowtie #f43f5e
+        8: (255, 255, 255),                                          # antenna tip
+        9: (10, 10, 20),                                             # eyes/mouth #0a0a14
+    }
+
+    out = []
+    for grow in grid:
+        cells = []
+        for v in grow:
+            if v == 0:
+                cells.append("  ")
+            else:
+                cr, cg, cb = palette[v]
+                cells.append(f"\x1b[38;2;{cr};{cg};{cb}m██\x1b[0m")
+        out.append("    " + "".join(cells))
+    return "\n".join(out)
+
+
 YELLOW = "\033[33m"
 STAR = "★"
 
@@ -595,11 +777,17 @@ def render_welcome(agent_name: str, meshwork_name: str, ascii_art: str,
     lines.append(f"{color}{BOLD}  ╚══════════════════════════════════════════╝{RESET}")
     lines.append("")
 
-    # Always use pixel mascot — generates deterministic defaults from agent name if no config
-    art_to_render = render_pixel_mascot(agent_name, mascot_config)
-
-    for line in art_to_render.split("\n"):
-        lines.append(f"  {color}{line}{RESET}")
+    # TERMINAL-BOOT-REAL-SPRITE (8e2e14d1): render the agent's REAL dashboard
+    # sprite in 24-bit truecolor so the boot banner matches the dashboard
+    # PixelMascot "igualito" (exact profile-color, real body/eyes/mouth). Fall
+    # back to the nearest-16 single-color Unicode mascot on dumb terminals.
+    if _supports_truecolor():
+        for line in render_pixel_mascot_truecolor(agent_name, profile_color, mascot_config).split("\n"):
+            lines.append(line)
+    else:
+        art_to_render = render_pixel_mascot(agent_name, mascot_config)
+        for line in art_to_render.split("\n"):
+            lines.append(f"  {color}{line}{RESET}")
 
     lines.append("")
     lines.append(f"  {BOLD}{color}●{RESET} {BOLD}{agent_name}{RESET}{commander_badge} {DIM}{greeting}{RESET}")

{meshcode-2.11.90 → meshcode-2.11.93}/meshcode/hostd.py

@@ -55,6 +55,27 @@ try:
 except Exception:
     _RUNNING_VERSION = "0.0.0"
 _LAST_UPDATE_KICK_MONO = 0.0
+_REEXEC_GUARD_LOGGED = False
+
+
+def _has_supervisor() -> bool:
+    """True if an OS supervisor (launchd/systemd/Task Scheduler) manages this hostd and will
+    relaunch it on clean exit. Field data (Samuel Mac): os.execv is BLOCKED in the sandboxed
+    runtime, so where a supervisor exists we PREFER exit-and-relaunch over execv."""
+    import platform
+    try:
+        s = platform.system()
+        if s == "Darwin":
+            return _hostd_plist_path().exists()
+        if s == "Windows":
+            return subprocess.run(["schtasks", "/Query", "/TN", _HOSTD_TASK_NAME],
+                                  capture_output=True, text=True).returncode == 0
+        if shutil.which("systemctl"):
+            return subprocess.run(["systemctl", "--user", "is-enabled", _HOSTD_SYSTEMD_UNIT],
+                                  capture_output=True, text=True).returncode == 0
+    except Exception:
+        pass
+    return False
 
 
 def _maybe_self_restart_on_version_drift() -> None:
@@ -96,13 +117,42 @@ def _maybe_self_restart_on_version_drift() -> None:
             newer = False
     if not newer:
         return
-    _log(f"VERSION DRIFT: running {_RUNNING_VERSION}, on-disk {ondisk} -> self-reexec to load "
-         f"new code (Stop kill sweep + daemon fixes). headless_pids persisted; KeepAlive re-attaches.")
+    # Loop-guard (backend2 finding): in a source/dev run, importlib.metadata can report a
+    # pip-installed wheel NEWER than the __init__.py actually executing, so the drift would
+    # PERSIST across restart -> storm. Persist the attempt; if we already tried to reach this
+    # exact on-disk target recently and didn't advance, skip until the guard window passes.
+    global _REEXEC_GUARD_LOGGED
+    try:
+        _st = _load_state()
+    except Exception:
+        _st = {}
+    _att = _st.get("reexec_attempt") or {}
+    if _att.get("target") == ondisk and (time.time() - float(_att.get("at", 0) or 0)) < 600:
+        if not _REEXEC_GUARD_LOGGED:
+            _REEXEC_GUARD_LOGGED = True
+            _log(f"version drift {_RUNNING_VERSION}->{ondisk} but a recent restart didn't advance the "
+                 f"running version (source/dev run?). Skipping to avoid a restart storm; retry after 600s.")
+        return
+    _st["reexec_attempt"] = {"target": ondisk, "at": time.time()}
+    try:
+        _save_state(_st)
+    except Exception:
+        pass
+    _log(f"VERSION DRIFT: running {_RUNNING_VERSION}, on-disk {ondisk} -> restart to load new code "
+         f"(Stop kill sweep + daemon fixes). headless_pids persisted.")
+    # Prefer supervisor-restart where one manages hostd: field data (Samuel Mac) showed os.execv
+    # is BLOCKED in the sandboxed runtime and the os._exit->KeepAlive fallback is what actually
+    # restarts. So when a supervisor exists, exit cleanly and let it relaunch on the new wheel.
+    if _has_supervisor():
+        _log("supervisor present -> clean exit; launchd/systemd/schtasks relaunches on new code")
+        os._exit(0)
+    # No supervisor (e.g. dev foreground run): execv is the only in-place restart. If it's blocked,
+    # do NOT self-destruct (nothing would relaunch us) — stay on old code, retry after the guard window.
     try:
         os.execv(sys.executable, [sys.executable, "-m", "meshcode"] + sys.argv[1:])
     except Exception as e:
-        _log(f"WARN: self-reexec failed ({e}); exiting so the supervisor restarts us")
-        os._exit(0)
+        _log(f"WARN: no supervisor + execv failed ({e}); staying on {_RUNNING_VERSION}, retry after guard window")
+        return
 
 STATE_DIR = Path.home() / ".meshcode"
 HOST_ID_PATH = STATE_DIR / "host_id"
@@ -317,6 +367,16 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
         else:
             # POSIX: detach into its own session so it survives the daemon + has no controlling tty.
             kwargs["start_new_session"] = True
+            # RELIABILITY (commander field finding): a headless respawn died with "meshcode not on
+            # PATH" — the spawned `meshcode run` (and its `meshcode mcp` MCP child) needs the
+            # `meshcode` console script findable. Prepend sys.executable's bin dir (where the
+            # console script lives) to PATH, mirroring the win32 venv-Scripts injection above.
+            try:
+                bindir = str(Path(sys.executable).resolve().parent)
+                if bindir and bindir not in env.get("PATH", "").split(os.pathsep):
+                    env["PATH"] = bindir + os.pathsep + env.get("PATH", "")
+            except Exception:
+                pass
         try:
             # `python -m meshcode` (NOT the meshcode.exe shim) so the .exe isn't held open by the
             # agent -> a background `pip install -U` can replace it on Windows (task 14782bb4 #4).
@@ -382,8 +442,18 @@ def _do_respawns(api_key: str, host_id: str) -> int:
             # do NOT re-record here (that would inflate the count on a mere rate-limit skip).
             _log(f"SKIP respawn {proj}/{agent}: not allowed (count={c.get('respawn_count')}, rate-limited/at-cap)")
             continue
-        _log(f"RESPAWN {proj}/{agent} (stale {c.get('heartbeat_age_s')}s, count={c.get('respawn_count')})")
+        # 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.
+        _is_recycle = bool(c.get("recycle_fast"))
+        _log(f"{'RECYCLE-RESPAWN' if _is_recycle else 'RESPAWN'} {proj}/{agent} "
+             f"(stale {c.get('heartbeat_age_s')}s, count={c.get('respawn_count')})")
         if _spawn_agent(proj, agent, headless=bool(c.get("headless"))):
+            if _is_recycle:
+                _rpc("mc_record_recycle",
+                     {"p_api_key": api_key, "p_project_id": c.get("project_id"), "p_agent_name": agent})
+                n += 1
+                continue
             rec = _rpc("mc_record_respawn",
                        {"p_api_key": api_key, "p_project_id": c.get("project_id"), "p_agent_name": agent})
             # mig404: give-up is ATOMIC inside mc_record_respawn (sets desired_state='crashed').
@@ -578,6 +648,50 @@ def _do_stops(api_key: str, host_id: str) -> int:
     return n
 
 
+def _do_recycle_enforce(api_key: str, host_id: str) -> int:
+    """RECYCLE-MUST-GUARANTEE-RESPAWN (task c0fc5597). An interactive claude (no --print) can't
+    self-exit on must_exit=recycle: the model leaves its loop but the process idles + the MCP
+    heartbeat keeps it non-stale, so hostd never respawns it -> recycle degrades to a silent
+    sleep. ENFORCE it: an agent that CONSUMED a recycle (mc_recycle_enforce_candidates: marker set
+    >= grace ago so its PreCompact handoff already wrote, but STILL ALIVE = didn't exit) gets its
+    process FORCE-KILLED. Per commander conditions: kill ONLY the recorded headless PID for THAT
+    agent (headless_pids, with _kill_headless_pid's reuse-guard) — NEVER blind cmdline. After the
+    kill it goes stale and the recycle FAST-PATH in _do_respawns relaunches it within seconds ->
+    SessionStart restores the handoff. Returns number force-killed."""
+    res = _rpc("mc_recycle_enforce_candidates", {"p_api_key": api_key, "p_host_id": host_id})
+    if not res or not res.get("ok"):
+        return 0
+    cands = res.get("candidates") or []
+    if not cands:
+        return 0
+    st = _load_state()
+    pids = st.get("headless_pids") or {}
+    n = 0
+    for c in cands:
+        proj, agent = c.get("project_name"), c.get("agent")
+        if not proj or not agent:
+            continue
+        target = f"{proj}/{agent}"
+        pid = pids.get(target)
+        if not pid:
+            # commander condition #1: recorded-PID ONLY, never blind cmdline (agents are identical
+            # `claude -- boot` on POSIX -> a cmdline guess would kill a HEALTHY agent). An agent
+            # spawned by an older hostd has no recorded PID -> can't safely enforce; it needs the
+            # one-time relaunch (README #12), after which hostd records its PID + enforce works.
+            _log(f"RECYCLE-ENFORCE SKIP {target}: consumed recycle {c.get('recycled_age_s')}s ago "
+                 f"but still alive and NO recorded PID — needs a one-time relaunch (README #12).")
+            continue
+        if _kill_headless_pid(target, pid):
+            pids.pop(target, None)
+            _log(f"RECYCLE-ENFORCE {target}: force-killed stuck-alive recycling agent (pid {pid}, "
+                 f"recycled {c.get('recycled_age_s')}s ago, hb {c.get('heartbeat_age_s')}s) "
+                 f"-> fast-path respawn will relaunch it.")
+            n += 1
+    st["headless_pids"] = pids
+    _save_state(st)
+    return n
+
+
 def _do_recycles(api_key: str, host_id: str) -> int:
     """Uptime-based recycle at task boundary. Returns number recycled."""
     cfg = _rpc("mc_host_config_get", {"p_api_key": api_key, "p_host_id": host_id})
@@ -1084,13 +1198,17 @@ def cmd_hostd(args: list) -> int:
                         # re-exec NOW (before doing work) so Stop's kill sweep + launch fixes
                         # always run on a stale-running host without manual intervention.
                         _maybe_self_restart_on_version_drift()
+                        # c0fc5597: enforce recycle BEFORE respawn — force-kill a stuck-alive
+                        # recycling agent so it goes stale, then _do_respawns' recycle fast-path
+                        # relaunches it within seconds (guaranteed reappearance, no silent sleep).
+                        enforced = _do_recycle_enforce(api_key, host_id)
                         relaunched = _do_respawns(api_key, host_id)
                         recycled = _do_recycles(api_key, host_id)
                         ver_recycled = _do_version_recycles(api_key, host_id)
                         stopped = _do_stops(api_key, host_id)
                         _up = int(time.monotonic() - _spawn_mono)
-                        if relaunched or recycled or ver_recycled or stopped:
-                            _log(f"sweep done (uptime={_up}s) — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled, {stopped} stopped")
+                        if relaunched or recycled or ver_recycled or stopped or enforced:
+                            _log(f"sweep done (uptime={_up}s) — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled, {stopped} stopped, {enforced} recycle-enforced")
                         elif time.monotonic() - _last_alive_log >= 60:
                             _log(f"alive — uptime={_up}s")
                             _last_alive_log = time.monotonic()

{meshcode-2.11.90 → meshcode-2.11.93}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.90
+Version: 2.11.93
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -442,6 +442,14 @@ CDN propagation. Wait ~60s and force-fetch directly from the origin:
 pip install --no-cache-dir -i https://pypi.org/simple/ meshcode
 ```
 
+**12. Upgrading to v2.11.88+: relaunch already-running agents and host ONCE**
+From v2.11.88 the host daemon (hostd) auto-restarts itself when a newer SDK lands on disk, so the Stop/kill sweep and launch fixes pick up automatically — and managed agents version-recycle cooperatively to follow. But an agent (or hostd) **already running an older SDK** carries that old code in memory and can't be auto-recycled (old code doesn't honor the recycle signal). Cross the gap once:
+```bash
+pip install --upgrade meshcode          # writes the new wheel to disk
+meshcode login                          # restarts a stale hostd (v2.11.90+ does this only if provably stale)
+```
+Then relaunch each still-old agent once (`meshcode run <project>/<agent>`, or close + reopen its Claude Code session). After this one-time relaunch, every agent obeys cooperative recycle and stays current automatically — no manual restarts thereafter.
+
 ---
 
 ## Links

{meshcode-2.11.90 → meshcode-2.11.93}/pyproject.toml

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