meshcode 2.11.75__tar.gz → 2.11.76__tar.gz

{meshcode-2.11.75 → meshcode-2.11.76}/PKG-INFO

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

{meshcode-2.11.75 → meshcode-2.11.76}/meshcode/__init__.py

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

{meshcode-2.11.75 → meshcode-2.11.76}/meshcode/hostd.py

@@ -212,10 +212,13 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
         # background, NO terminal — UNIVERSAL macOS/Linux/Windows (task c1a6c6a8, mesh-dev specs).
         # Clean env (a stale CLAUDECODE aborts `meshcode run`); keep crash logs in a per-agent logfile
         # (NOT DEVNULL — we want to debug headless agents that die on boot).
+        # task 14782bb4: spawned agents DO auto-update (non-blocking) — strip any inherited
+        # NO_*UPDATE so the agent's launch runs the bg updater (the daemon launcher stays disabled).
+        # No hang: run_agent now uses the NON-blocking updater + we spawn via `python -m meshcode`
+        # (not the .exe shim) so a bg `pip install -U` can replace meshcode.exe on Windows.
         env = {k: v for k, v in os.environ.items()
-               if k not in ("CLAUDECODE", "CLAUDE_CODE_SESSION")}
-        env["MESHCODE_NO_AUTO_UPDATE"] = "1"
-        env["MESHCODE_NO_UPDATE"] = "1"  # belt-and-suspenders: var honored pre-2.11.74 (no launch-hang)
+               if k not in ("CLAUDECODE", "CLAUDE_CODE_SESSION",
+                            "MESHCODE_NO_UPDATE", "MESHCODE_NO_AUTO_UPDATE")}
         log_dir = STATE_DIR / "logs"
         try:
             log_dir.mkdir(parents=True, exist_ok=True)
@@ -236,11 +239,11 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
         }
         if sys.platform == "win32":
             # CREATE_NO_WINDOW (0x08000000) | DETACHED_PROCESS (0x08): no console window, fully
-            # detached from this daemon. Use the console entry-point (meshcode.exe), NEVER pythonw
-            # (it swallows stderr). Ensure venv Scripts + System32 on PATH (Windows PATH cap ~32k).
+            # detached from this daemon. NEVER pythonw (swallows stderr). Ensure venv Scripts +
+            # System32 on PATH (Windows PATH cap ~32k).
             kwargs["creationflags"] = 0x08000000 | 0x00000008
             try:
-                scripts = str(Path(bin_).resolve().parent)
+                scripts = str(Path(sys.executable).resolve().parent)  # venv Scripts dir
             except Exception:
                 scripts = ""
             sysroot = os.environ.get("SystemRoot", r"C:\Windows")
@@ -250,7 +253,9 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
             # POSIX: detach into its own session so it survives the daemon + has no controlling tty.
             kwargs["start_new_session"] = True
         try:
-            subprocess.Popen([bin_, "run", target], **kwargs)
+            # `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).
+            subprocess.Popen([sys.executable, "-m", "meshcode", "run", target], **kwargs)
             _log(f"spawned {target} HEADLESS (no window, {sys.platform}; log={log_path})")
             return True
         except Exception as e:
@@ -267,13 +272,15 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
     # command PER-PLATFORM (mesh-core FIX1, 0x80070002): cmd.exe uses & (NOT ';'), set "V=" to clear
     # (NOT bash unset/export), double-quotes (NOT shlex POSIX), no exec — else Windows Terminal splits
     # on ';' -> file-not-found. Layered ON TOP of the 2.11.72 headless-flags fix (visible branch only).
+    # task 14782bb4: CLEAR any inherited NO_*UPDATE (so the agent auto-updates non-blocking) and run
+    # via `python -m meshcode` (NOT the .exe shim) so a bg `pip install -U` can replace meshcode.exe.
     if sys.platform == "win32":
         cmd = (f'set "CLAUDECODE=" & set "CLAUDE_CODE_SESSION=" & '
-               f'set "MESHCODE_NO_AUTO_UPDATE=1" & set "MESHCODE_NO_UPDATE=1" & '
-               f'"{bin_}" run "{target}"')
+               f'set "MESHCODE_NO_UPDATE=" & set "MESHCODE_NO_AUTO_UPDATE=" & '
+               f'"{sys.executable}" -m meshcode run "{target}"')
     else:
-        cmd = (f"unset CLAUDECODE CLAUDE_CODE_SESSION; export MESHCODE_NO_AUTO_UPDATE=1; "
-               f"export MESHCODE_NO_UPDATE=1; exec {shlex.quote(bin_)} run {shlex.quote(target)}")
+        cmd = (f"unset CLAUDECODE CLAUDE_CODE_SESSION MESHCODE_NO_UPDATE MESHCODE_NO_AUTO_UPDATE; "
+               f"exec {shlex.quote(sys.executable)} -m meshcode run {shlex.quote(target)}")
     try:
         from meshcode import protocol_handler as _ph
         ok, info = _ph._spawn_terminal(cmd)

{meshcode-2.11.75 → meshcode-2.11.76}/meshcode/run_agent.py

@@ -698,13 +698,14 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
     # Propagate autonomous flag to the editor + MCP child via env var.
     if autonomous:
         os.environ["MESHCODE_AUTONOMOUS"] = "1"
-    # Blocking self-update: pip install -U meshcode BEFORE spawning the
-    # editor so the child MCP subprocess loads the freshest server.py off
-    # disk. Skip in dry-run — CI / pre-publish smokes must not fork pip.
-    # See claude_update_blocking below for the npm/Claude Code half.
+    # NON-BLOCKING self-update (task 14782bb4): kick a detached background `pip install -U meshcode`
+    # and return IMMEDIATELY — the launch NEVER waits/hangs (Samuel req; the old blocking variant hung
+    # every Windows launch on WinError 32). This launch runs the current version; the next spawn/recycle
+    # picks up the new one (two-launch async). Skip in dry-run (CI/pre-publish smokes must not fork pip).
+    # Fully opt-out via MESHCODE_NO_UPDATE / MESHCODE_NO_AUTO_UPDATE (handled inside check_and_maybe_update).
     if not dry_run:
         try:
-            self_update.check_and_maybe_update_blocking()
+            self_update.check_and_maybe_update()
         except Exception:
             pass
 

{meshcode-2.11.75 → meshcode-2.11.76}/meshcode.egg-info/PKG-INFO

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

meshcode-2.11.75/meshcode.egg-info/SOURCES 2.txt → meshcode-2.11.76/meshcode.egg-info/SOURCES.txt

@@ -5,9 +5,6 @@ meshcode/__main__.py
 meshcode/_stop_hook_template.py
 meshcode/ascii_art.py
 meshcode/atomic_push.py
-meshcode/claude_update 2.py
-meshcode/claude_update 3.py
-meshcode/claude_update 4.py
 meshcode/claude_update.py
 meshcode/cli.py
 meshcode/comms_v4.py
@@ -17,9 +14,6 @@ meshcode/date_parse.py
 meshcode/doctor.py
 meshcode/error_hints.py
 meshcode/exceptions.py
-meshcode/hostd 2.py
-meshcode/hostd 3.py
-meshcode/hostd 4.py
 meshcode/hostd.py
 meshcode/invites.py
 meshcode/launcher.py
@@ -34,8 +28,6 @@ meshcode/secrets.py
 meshcode/self_update.py
 meshcode/setup_clients.py
 meshcode/supervisor.py
-meshcode/up 2.py
-meshcode/up 3.py
 meshcode/up.py
 meshcode/upload.py
 meshcode-backend-wt/comms_v4.py
@@ -212,10 +204,6 @@ tests/test_auto_update_hardening.py
 tests/test_autonomous_closegap_1.py
 tests/test_autonomous_closegap_2.py
 tests/test_autonomous_closegap_3.py
-tests/test_autonomous_prompt_inject 2.py
-tests/test_autonomous_prompt_inject 3.py
-tests/test_autonomous_prompt_inject 4.py
-tests/test_autonomous_prompt_inject 5.py
 tests/test_autonomous_prompt_inject.py
 tests/test_boot_bug_regression.py
 tests/test_color_truecolor.py

{meshcode-2.11.75 → meshcode-2.11.76}/pyproject.toml

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

meshcode-2.11.75/meshcode/hostd 3.py

@@ -1,509 +0,0 @@
-"""meshcode hostd — host-side daemon: respawn + recycle managed agents.
-
-Complements supervisor.py (launchd KeepAlive = process-exit restart only).
-hostd polls the CLOUD for staleness (heartbeat) + recycle triggers that
-launchd cannot see:
-
-  - RESPAWN: agent's heartbeat is stale (process/daemon-thread dead) and
-    desired_state='running' → relaunch. Loop-guard cap 3/10min → 'crashed'.
-  - RECYCLE: managed agent exceeds its recycle policy (context% or uptime)
-    → relaunch at a task boundary (never mid-task). Recorded separately
-    from the crash cap.
-
-Contract (mig366/367/368/369, DBA-cleared):
-  mc_register_host, mc_agents_needing_respawn, mc_record_respawn,
-  mc_record_recycle, mc_set_desired_state, mc_host_recycle_policy.
-
-Source of truth is the cloud (mc_agents / mc_host_config), never local
-folders. host_id lives in ~/.meshcode/host_id (generated once).
-
-    meshcode hostd run       — run the daemon loop (foreground)
-    meshcode hostd status    — show this host's managed agents
-    meshcode hostd install   — install launchd trigger-start plist
-    meshcode hostd uninstall — remove it
-
-Design invariants:
-  - NEVER respawn desired_state != 'running' (NULL=unmanaged, stopped=
-    intentional, crashed=gave-up). The cloud RPC enforces this; we trust it.
-  - Single retry / capped respawn — never an infinite relaunch loop.
-  - Recycle only at task boundary: we relaunch a recycle candidate only
-    when it is NOT actively working (status not in working/online-busy) OR
-    the agent has self-flagged 'recycling'. Mid-task agents are skipped.
-"""
-from __future__ import annotations
-
-import json
-import os
-import shlex
-import subprocess
-import sys
-import time
-import urllib.request
-import uuid
-from pathlib import Path
-from typing import Optional
-
-STATE_DIR = Path.home() / ".meshcode"
-HOST_ID_PATH = STATE_DIR / "host_id"
-LOG_PATH = STATE_DIR / "hostd.log"
-
-POLL_INTERVAL_SEC = 45
-STALE_SECONDS = 150          # heartbeat liveness cutoff (QA #3)
-RESPAWN_TIMEOUT_SEC = 30
-# statuses that mean "actively working" → never recycle mid-task
-BUSY_STATUSES = {"working", "online", "busy"}
-
-
-def _log(msg: str) -> None:
-    line = f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {msg}"
-    print(line, file=sys.stderr)
-    try:
-        STATE_DIR.mkdir(parents=True, exist_ok=True)
-        with open(LOG_PATH, "a", encoding="utf-8") as f:
-            f.write(line + "\n")
-    except Exception:
-        pass
-
-
-def get_host_id() -> str:
-    """Read ~/.meshcode/host_id, generating a stable UUID on first use."""
-    try:
-        if HOST_ID_PATH.exists():
-            v = HOST_ID_PATH.read_text(encoding="utf-8").strip()
-            if v:
-                return v
-    except Exception:
-        pass
-    new_id = str(uuid.uuid4())
-    try:
-        STATE_DIR.mkdir(parents=True, exist_ok=True)
-        HOST_ID_PATH.write_text(new_id, encoding="utf-8")
-    except Exception:
-        pass
-    return new_id
-
-
-# ------------------------------------------------------------------
-# Cloud RPC (PostgREST) — self-contained urllib, no internal client dep
-# ------------------------------------------------------------------
-
-def _supabase_cfg() -> tuple:
-    # env first (explicit override), then fall back to the SAME resolution the
-    # rest of the CLI uses (comms_v4: env -> ~/.meshcode/env -> baked publishable
-    # default). hostd runs under launchd with NO env, so the old env-only lookup
-    # left it unable to reach the cloud at all ("SUPABASE_URL/KEY not set").
-    url = os.environ.get("SUPABASE_URL", "").rstrip("/")
-    key = os.environ.get("SUPABASE_KEY") or os.environ.get("MESHCODE_SUPABASE_ANON_KEY") or ""
-    if url and key:
-        return url, key
-    try:
-        from meshcode import comms_v4 as _c  # type: ignore
-        return (url or _c.SUPABASE_URL).rstrip("/"), (key or _c.SUPABASE_KEY)
-    except Exception:
-        return url, key
-
-
-def _api_key() -> Optional[str]:
-    """The meshcode agent/user api key, used as p_api_key in mc_ RPCs.
-
-    Resolution mirrors comms_v4._load_api_key_for_cli so hostd authenticates
-    the same way `meshcode run` does. CRITICAL: launchd starts hostd with NO
-    environment, so the key MUST be resolvable from the keychain (where
-    `meshcode login` stores it). The old code only checked env + a
-    wrong-shaped profiles.json, so launchd-started hostd always FATAL'd
-    ("no api key") and never registered -> dashboard launch had no host.
-    """
-    # 1) explicit env override
-    k = os.environ.get("MESHCODE_API_KEY")
-    if k:
-        return k
-    # 2) keychain — the actual store `meshcode login` writes to. Same source
-    #    comms_v4._load_api_key_for_cli() uses. This is the launchd fix.
-    try:
-        from meshcode import secrets as _secrets  # type: ignore
-        profile = os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or _secrets.DEFAULT_PROFILE
-        key = _secrets.get_api_key(profile=profile) or ""
-        if key:
-            return key
-    except Exception:
-        pass
-    # 3) legacy per-profile state file fallback. Handles BOTH the flat
-    #    {name: {api_key}} and nested {"profiles": {name: {api_key}}} shapes
-    #    (the flat-only scan silently missed the nested writer).
-    try:
-        prof = STATE_DIR / "profiles.json"
-        if prof.exists():
-            data = json.loads(prof.read_text(encoding="utf-8"))
-            roots = []
-            if isinstance(data, dict):
-                roots.append(data)
-                if isinstance(data.get("profiles"), dict):
-                    roots.append(data["profiles"])
-            for root in roots:
-                for v in root.values():
-                    if isinstance(v, dict) and v.get("api_key"):
-                        return v["api_key"]
-    except Exception:
-        pass
-    return None
-
-
-def _rpc(fn: str, payload: dict) -> Optional[dict]:
-    """Call a PostgREST RPC. Returns parsed JSON or None on any failure."""
-    url, key = _supabase_cfg()
-    if not url or not key:
-        _log("WARN: SUPABASE_URL/KEY not set — cannot reach cloud")
-        return None
-    try:
-        req = urllib.request.Request(
-            f"{url}/rest/v1/rpc/{fn}",
-            data=json.dumps(payload).encode("utf-8"),
-            headers={
-                "apikey": key,
-                "Authorization": f"Bearer {key}",
-                "Content-Type": "application/json",
-            },
-            method="POST",
-        )
-        with urllib.request.urlopen(req, timeout=15) as resp:
-            return json.loads(resp.read().decode("utf-8"))
-    except Exception as e:
-        _log(f"WARN: rpc {fn} failed: {e}")
-        return None
-
-
-# ------------------------------------------------------------------
-# Respawn
-# ------------------------------------------------------------------
-
-def _meshcode_bin() -> str:
-    cand = Path(sys.argv[0]).resolve()
-    if cand.exists() and cand.name.startswith("meshcode"):
-        return str(cand)
-    return "meshcode"
-
-
-def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
-    """Relaunch `meshcode run <project>/<agent>`.
-
-    headless=False (default): VISIBLE terminal window. Samuel must SEE it — we
-    delegate to protocol_handler._spawn_terminal, the canonical visible spawner
-    (macOS: osascript-if-Automation-granted else `open` a .command wrapper, no TCC
-    needed; Linux/Windows: native terminals). On failure we WARN loudly and return
-    False — we NEVER silently fall back to headless when visible was asked.
-
-    headless=True (Fleet Control mig404 per-agent flag): background process, NO
-    window — for fleet agents that don't need a terminal (like the qa launch).
-    """
-    target = f"{project}/{agent}"
-    bin_ = _meshcode_bin()
-    if headless:
-        # background, NO terminal — UNIVERSAL macOS/Linux/Windows (task c1a6c6a8, mesh-dev specs).
-        # Clean env (a stale CLAUDECODE aborts `meshcode run`); keep crash logs in a per-agent logfile
-        # (NOT DEVNULL — we want to debug headless agents that die on boot).
-        env = {k: v for k, v in os.environ.items()
-               if k not in ("CLAUDECODE", "CLAUDE_CODE_SESSION")}
-        env["MESHCODE_NO_AUTO_UPDATE"] = "1"
-        log_dir = STATE_DIR / "logs"
-        try:
-            log_dir.mkdir(parents=True, exist_ok=True)
-        except Exception:
-            pass
-        safe = f"{project}__{agent}".replace("/", "_").replace("\\", "_")
-        log_path = log_dir / f"{safe}.headless.log"
-        logf = None
-        try:
-            logf = open(log_path, "ab")
-        except Exception:
-            logf = None
-        kwargs = {
-            "stdin": subprocess.DEVNULL,
-            "stdout": (logf if logf is not None else subprocess.DEVNULL),
-            "stderr": subprocess.STDOUT,
-            "env": env,
-        }
-        if sys.platform == "win32":
-            # CREATE_NO_WINDOW (0x08000000) | DETACHED_PROCESS (0x08): no console window, fully
-            # detached from this daemon. Use the console entry-point (meshcode.exe), NEVER pythonw
-            # (it swallows stderr). Ensure venv Scripts + System32 on PATH (Windows PATH cap ~32k).
-            kwargs["creationflags"] = 0x08000000 | 0x00000008
-            try:
-                scripts = str(Path(bin_).resolve().parent)
-            except Exception:
-                scripts = ""
-            sysroot = os.environ.get("SystemRoot", r"C:\Windows")
-            base_path = os.pathsep.join(p for p in (scripts, sysroot + r"\System32", sysroot) if p)
-            env["PATH"] = (base_path + os.pathsep + env.get("PATH", ""))[:30000]
-        else:
-            # POSIX: detach into its own session so it survives the daemon + has no controlling tty.
-            kwargs["start_new_session"] = True
-        try:
-            subprocess.Popen([bin_, "run", target], **kwargs)
-            _log(f"spawned {target} HEADLESS (no window, {sys.platform}; log={log_path})")
-            return True
-        except Exception as e:
-            _log(f"WARN: headless spawn {target} failed: {e}")
-            return False
-        finally:
-            # child inherited its own fd; safe to drop the daemon's handle.
-            if logf is not None:
-                try:
-                    logf.close()
-                except Exception:
-                    pass
-    # env hygiene (item1 RC): a stale CLAUDECODE aborts `meshcode run` (exit2).
-    # Prefix the shell command so the spawned terminal starts with a clean env.
-    cmd = (f"unset CLAUDECODE CLAUDE_CODE_SESSION; export MESHCODE_NO_AUTO_UPDATE=1; "
-           f"exec {shlex.quote(bin_)} run {shlex.quote(target)}")
-    try:
-        from meshcode import protocol_handler as _ph
-        ok, info = _ph._spawn_terminal(cmd)
-        if ok:
-            _log(f"spawned {target} in visible terminal ({info})")
-            return True
-        _log(f"WARN: visible spawn {target} FAILED ({info}) — agent NOT launched. "
-             f"macOS: grant Terminal Automation (System Settings > Privacy & Security "
-             f"> Automation), or ensure `open` works. NOT falling back to headless.")
-        return False
-    except Exception as e:
-        _log(f"WARN: spawn {target} failed: {e}")
-        return False
-
-
-def _do_respawns(api_key: str, host_id: str) -> int:
-    """One respawn sweep. Returns number relaunched."""
-    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"):
-        return 0
-    n = 0
-    for c in res.get("candidates", []):
-        proj, agent = c.get("project_name"), c.get("agent")
-        if not proj or not agent:
-            continue
-        if not c.get("respawn_allowed", True):
-            # mig404: not allowed = rate-limited (<60s since last respawn) or at the cap.
-            # mc_record_respawn v2 sets desired_state='crashed' ATOMICALLY at the cap, so we
-            # 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')})")
-        if _spawn_agent(proj, agent, headless=bool(c.get("headless"))):
-            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').
-            # The old mc_set_desired_state(p_state=crashed) call passed NO agent id = no-op; dropped.
-            if rec and rec.get("give_up"):
-                _log(f"ALERT {proj}/{agent}: respawn cap hit — marked crashed (atomic). No more respawns.")
-            n += 1
-    return n
-
-
-# ------------------------------------------------------------------
-# Recycle — relaunch a managed agent at a TASK BOUNDARY when it exceeds
-# its recycle policy. Uptime-recycle is daemon-driven (needs mig370's
-# project_name in the roster). Context-recycle is agent-cooperative (the
-# agent self-persists handoff + exits at a boundary; our respawn path then
-# relaunches it). Recorded via mc_record_recycle — NEVER counted against
-# the crash respawn cap.
-# ------------------------------------------------------------------
-
-_HOSTD_STATE_PATH = STATE_DIR / "hostd_state.json"
-
-
-def _load_state() -> dict:
-    try:
-        if _HOSTD_STATE_PATH.exists():
-            return json.loads(_HOSTD_STATE_PATH.read_text(encoding="utf-8"))
-    except Exception:
-        pass
-    return {}
-
-
-def _save_state(st: dict) -> None:
-    try:
-        STATE_DIR.mkdir(parents=True, exist_ok=True)
-        _HOSTD_STATE_PATH.write_text(json.dumps(st), encoding="utf-8")
-    except Exception:
-        pass
-
-
-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})
-    if not cfg or not cfg.get("ok"):
-        return 0
-    pol = _rpc("mc_host_recycle_policy", {"p_api_key": api_key, "p_host_id": host_id})
-    mode = (pol or {}).get("recycle_mode")
-    value = (pol or {}).get("recycle_value")
-    if mode != "time" or not value:
-        return 0  # context-recycle is agent-cooperative; only time is daemon-driven
-    st = _load_state()
-    now = time.time()
-    n = 0
-    seen = set()
-    for a in cfg.get("agents", []):
-        if a.get("desired_state") != "running":
-            continue
-        proj, agent = a.get("project_name"), a.get("name")
-        if not proj or not agent:
-            continue
-        key = f"{a.get('project_id')}/{agent}"
-        seen.add(key)
-        first = st.get(key)
-        if first is None:
-            st[key] = now  # start the uptime clock on first observation
-            continue
-        if (a.get("status") or "") in BUSY_STATUSES:
-            continue  # task boundary only — never mid-task
-        if (now - first) >= float(value) * 3600.0:
-            _log(f"RECYCLE {proj}/{agent} (uptime {(now-first)/3600:.1f}h >= {value}h)")
-            # Server-authorized clean-exit (task 548c863e, mig 364): SIGNAL the
-            # recycle instead of spawning. A direct _spawn_agent here duplicates
-            # the still-alive process. mc_request_recycle sets a flag; the
-            # agent's wait-loop consumes it, returns must_exit/reason=recycle,
-            # exits CLEAN (Stop-hook writes the handoff), then the respawn path
-            # (_do_respawns) relaunches it fresh. Recorded via mc_record_recycle
-            # so it's NEVER counted against the crash respawn cap.
-            req = _rpc("mc_request_recycle",
-                       {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
-            if req and req.get("ok") and req.get("requested"):
-                _rpc("mc_record_recycle",
-                     {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
-                st[key] = now  # reset clock after signaling recycle
-                n += 1
-            elif req and req.get("ok") and not req.get("requested"):
-                # Agent flipped busy between the roster read and the request —
-                # skip; retry next sweep at the next task boundary.
-                _log(f"SKIP recycle {proj}/{agent}: {req.get('reason','not_requested')}")
-    # prune state for agents no longer managed on this host
-    for k in [k for k in st if k not in seen]:
-        st.pop(k, None)
-    _save_state(st)
-    return n
-
-
-# ------------------------------------------------------------------
-# launchd trigger-start (macOS) — extends supervisor.py pattern.
-# The hostd daemon is NOT autostart-at-login: RunAtLoad=false. It is
-# kicked off on demand (button -> meshcode:// -> `launchctl kickstart`)
-# and KeepAlive keeps it alive while it runs. One job per host.
-# ------------------------------------------------------------------
-
-_HOSTD_PLIST_LABEL = "io.meshcode.hostd"
-
-
-def _hostd_plist_path():
-    return Path.home() / "Library" / "LaunchAgents" / f"{_HOSTD_PLIST_LABEL}.plist"
-
-
-def _hostd_plist_xml() -> str:
-    import shutil
-    mc = shutil.which("meshcode") or f"{sys.executable} -m meshcode"
-    args = (mc.split() + ["hostd", "run"]) if " -m " in mc else [mc, "hostd", "run"]
-    args_xml = "\n".join(f"        <string>{a}</string>" for a in args)
-    logdir = STATE_DIR / "logs"
-    logdir.mkdir(parents=True, exist_ok=True)
-    return f"""<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key><string>{_HOSTD_PLIST_LABEL}</string>
-    <key>ProgramArguments</key>
-    <array>
-{args_xml}
-    </array>
-    <key>RunAtLoad</key><false/>
-    <key>KeepAlive</key><true/>
-    <key>ThrottleInterval</key><integer>10</integer>
-    <key>StandardOutPath</key><string>{logdir / "hostd.stdout.log"}</string>
-    <key>StandardErrorPath</key><string>{logdir / "hostd.stderr.log"}</string>
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key><string>/usr/local/bin:/usr/bin:/bin:{os.path.dirname(sys.executable)}</string>
-        <key>MESHCODE_NO_AUTO_UPDATE</key><string>1</string>
-    </dict>
-</dict>
-</plist>
-"""
-
-
-def _hostd_install() -> int:
-    import platform
-    if platform.system() != "Darwin":
-        print("[hostd] launchd install is macOS only (Linux: use systemd --user; or run `meshcode hostd run` under your own supervisor).", file=sys.stderr)
-        return 2
-    plist = _hostd_plist_path()
-    plist.parent.mkdir(parents=True, exist_ok=True)
-    plist.write_text(_hostd_plist_xml(), encoding="utf-8")
-    subprocess.run(["launchctl", "unload", str(plist)], capture_output=True, text=True)
-    r = subprocess.run(["launchctl", "load", str(plist)], capture_output=True, text=True)
-    if r.returncode != 0:
-        print(f"[hostd] launchctl load failed: {r.stderr.strip()}", file=sys.stderr)
-        return 1
-    print(f"[hostd] installed (RunAtLoad=false, trigger-start). plist: {plist}")
-    print(f"[hostd] start now:  launchctl kickstart gui/$(id -u)/{_HOSTD_PLIST_LABEL}")
-    return 0
-
-
-def _hostd_uninstall() -> int:
-    plist = _hostd_plist_path()
-    if not plist.exists():
-        print("[hostd] not installed")
-        return 0
-    subprocess.run(["launchctl", "unload", str(plist)], capture_output=True, text=True)
-    plist.unlink(missing_ok=True)
-    print("[hostd] uninstalled")
-    return 0
-
-
-def cmd_hostd(args: list) -> int:
-    """Entry point for `meshcode hostd ...`."""
-    if not args or args[0] in ("-h", "--help"):
-        print(__doc__)
-        return 0
-    sub = args[0]
-    host_id = get_host_id()
-    api_key = _api_key()
-
-    if sub == "status":
-        if not api_key:
-            print("[hostd] no api key configured", file=sys.stderr)
-            return 1
-        res = _rpc("mc_agents_needing_respawn",
-                   {"p_api_key": api_key, "p_host_id": host_id, "p_stale_seconds": STALE_SECONDS})
-        print(json.dumps({"host_id": host_id, "needing_respawn": res}, indent=2))
-        return 0
-
-    if sub == "install":
-        return _hostd_install()
-
-    if sub == "uninstall":
-        return _hostd_uninstall()
-
-    if sub == "run":
-        if not api_key:
-            _log("FATAL: no api key — run `meshcode login` (key is read from the keychain)")
-            return 1
-        # Register this host in mc_host_config so the dashboard can list it as a
-        # launch target (Path2 canonical: dashboard -> mc_host_set_agents ->
-        # mc_agents.desired_state='running' -> this daemon polls + spawns).
-        # mc_host_config_set upserts (host_id, owner_user_id) idempotently.
-        _reg = _rpc("mc_host_config_set", {"p_api_key": api_key, "p_host_id": host_id})
-        if _reg and _reg.get("ok"):
-            _log(f"registered host {host_id} in mc_host_config")
-        else:
-            _log(f"WARN: host registration failed (dashboard may not list this host): {_reg}")
-        _log(f"hostd starting — host_id={host_id} interval={POLL_INTERVAL_SEC}s stale={STALE_SECONDS}s")
-        while True:
-            try:
-                relaunched = _do_respawns(api_key, host_id)
-                recycled = _do_recycles(api_key, host_id)
-                if relaunched or recycled:
-                    _log(f"sweep done — {relaunched} respawned, {recycled} recycled")
-            except Exception as e:
-                _log(f"WARN: sweep error: {e}")
-            time.sleep(POLL_INTERVAL_SEC)
-
-    print(f"[hostd] unknown subcommand: {sub}", file=sys.stderr)
-    return 1