meshcode 2.11.93__tar.gz → 2.11.96__tar.gz

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

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

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

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

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

@@ -446,9 +446,15 @@ def _do_respawns(api_key: str, host_id: str) -> int:
         # 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"))
+        # 798dd1bd: on-demand recycle with recycle_visible -> reopen a FRESH VISIBLE window
+        # (Samuel's "terminals reopen fresh"); else PRESERVE the agent's headless state
+        # (don't silently un-headless a headless fleet — backend2 A2). One-shot: mc_record_recycle
+        # clears recycle_visible so subsequent respawns use the normal headless flag.
+        _visible = _is_recycle and bool(c.get("recycle_visible"))
+        _hl = False if _visible else bool(c.get("headless"))
         _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"))):
+             f"({'VISIBLE ' if _visible else ''}stale {c.get('heartbeat_age_s')}s, count={c.get('respawn_count')})")
+        if _spawn_agent(proj, agent, headless=_hl):
             if _is_recycle:
                 _rpc("mc_record_recycle",
                      {"p_api_key": api_key, "p_project_id": c.get("project_id"), "p_agent_name": agent})
@@ -515,13 +521,38 @@ def _record_headless_pid(target: str, pid: int) -> None:
     try:
         st = _load_state()
         pids = st.get("headless_pids") or {}
-        pids[target] = pid
+        pids[target] = pid          # overwrite any stale entry for this target (refresh on respawn)
         st["headless_pids"] = pids
         _save_state(st)
     except Exception:
         pass
 
 
+def _gc_headless_pids() -> None:
+    """GC dead PIDs from headless_pids (cb90b058) so a stale entry can't mask a live agent +
+    the recorded PID stays accurate for enforce. Cheap; runs once per sweep. Best-effort."""
+    try:
+        st = _load_state()
+        pids = st.get("headless_pids") or {}
+        if not pids:
+            return
+        live = {}
+        for target, pid in pids.items():
+            try:
+                os.kill(int(pid), 0)   # raises ProcessLookupError if the PID is gone
+                live[target] = pid
+            except (ProcessLookupError, ValueError):
+                pass                    # dead / bad -> drop
+            except Exception:
+                live[target] = pid      # alive (PermissionError) or unknown -> keep (reuse-guard covers kill-time)
+        if len(live) != len(pids):
+            st["headless_pids"] = live
+            _save_state(st)
+            _log(f"GC headless_pids: dropped {len(pids)-len(live)} dead PID(s)")
+    except Exception:
+        pass
+
+
 def _pid_cmdline(pid: int) -> str:
     """Best-effort command line for a pid (to avoid killing a reused PID). '' on failure."""
     try:
@@ -1206,6 +1237,7 @@ def cmd_hostd(args: list) -> int:
                         recycled = _do_recycles(api_key, host_id)
                         ver_recycled = _do_version_recycles(api_key, host_id)
                         stopped = _do_stops(api_key, host_id)
+                        _gc_headless_pids()  # cb90b058: drop dead PIDs (stale entry can't mask a live agent)
                         _up = int(time.monotonic() - _spawn_mono)
                         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")

{meshcode-2.11.93 → meshcode-2.11.96}/meshcode/meshcode_mcp/server.py

@@ -621,6 +621,37 @@ def _record_event_bg(event_type: str, payload: dict = None) -> None:
         pass
 
 
+# FLEET-RECYCLE P0 (task 798dd1bd): stamp mc_agents.last_active_at on FOREGROUND
+# model activity (every tool call, incl meshcode_wait) so the recycle enforce
+# sweep (mc_recycle_enforce_candidates, mig419) can distinguish a genuinely-HUNG
+# agent — model stopped calling tools -> last_active_at goes STALE -> enforce —
+# from an attended/busy-looping one — still cycling -> FRESH -> defer. CRUX
+# (commander hard requirement): this MUST be triggered by foreground tool calls,
+# NEVER the bg heartbeat thread (which beats even when the model is hung; that
+# would keep last_active_at fresh forever and defeat the whole defer). Client-
+# throttled to <=1/30s to avoid write amplification on rapid tool bursts; fired
+# in a daemon thread so it adds zero latency to the tool call.
+_last_active_stamp_mono: float = 0.0
+
+
+def _touch_active_bg() -> None:
+    """Fire-and-forget foreground last_active_at stamp, throttled to <=1 per 30s."""
+    global _last_active_stamp_mono
+    try:
+        now = _time.monotonic()
+        if now - _last_active_stamp_mono < 30:
+            return
+        _last_active_stamp_mono = now
+        import threading
+        threading.Thread(
+            target=be.sb_rpc,
+            args=("mc_touch_active", {"p_project_id": _PROJECT_ID, "p_agent_name": AGENT_NAME}),
+            daemon=True,
+        ).start()
+    except Exception:
+        pass
+
+
 # ============================================================
 # Hot-reload: detect when backend.py changes on disk (e.g. after
 # pip install --upgrade meshcode) and reload without restart.
@@ -1005,6 +1036,7 @@ def with_working_status(func):
         async def awrapper(*args, **kwargs):
             _check_hot_reload()
             _capture_session()  # stash session on first tool call for silent auto-wake
+            _touch_active_bg()  # FLEET-RECYCLE P0: foreground last_active_at stamp (covers wait too, before skip)
             if not skip:
                 global _CONSECUTIVE_IDLE_SECONDS
                 _CONSECUTIVE_IDLE_SECONDS = 0  # any non-wait tool resets idle timer
@@ -1052,6 +1084,7 @@ def with_working_status(func):
         def swrapper(*args, **kwargs):
             _check_hot_reload()
             _capture_session()  # stash session on first tool call for silent auto-wake
+            _touch_active_bg()  # FLEET-RECYCLE P0: foreground last_active_at stamp (covers wait too, before skip)
             if not skip:
                 global _CONSECUTIVE_IDLE_SECONDS
                 _CONSECUTIVE_IDLE_SECONDS = 0  # any non-wait tool resets idle timer
@@ -6090,6 +6123,54 @@ def meshcode_agent_stop(name: str) -> Dict[str, Any]:
     })
 
 
+@mcp.tool()
+@with_working_status
+def meshcode_recycle_agent(name: str, visible: bool = False) -> Dict[str, Any]:
+    """Recycle (close + relaunch FRESH) another agent in YOUR meshwork — to
+    clear a degraded/high-context session and bring it back clean.
+
+    FLEET-RECYCLE (task 798dd1bd). Requests a recycle: the agent consumes it at
+    a task-edge, exits, and the host daemon respawns it fresh with its handoff
+    restored (SessionStart). Cloud-driven so it works remotely. Commander agent
+    (or human owner) only, scoped to your own meshwork — enforced server-side by
+    mc_recycle_as_agent (same authz as mc_agent_power_as_agent).
+
+    Args:
+        name: target agent name in your meshwork.
+        visible: True = respawn as a visible focused window; default False =
+            preserve the agent's current headless/visible state.
+    """
+    return be.sb_rpc("mc_recycle_as_agent", {
+        "p_api_key":    _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_agent":      name,
+        "p_visible":    bool(visible),
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_recycle_fleet(visible: bool = False) -> Dict[str, Any]:
+    """Recycle (close + relaunch FRESH) ALL running agents in YOUR meshwork —
+    a clean-slate sweep of the whole fleet.
+
+    FLEET-RECYCLE (task 798dd1bd). Each agent consumes the recycle at its own
+    task-edge, exits, and respawns fresh with handoff restored — no agent is
+    killed mid-task. Cloud-driven (remote-capable). Commander agent (or human
+    owner) only, scoped to your own meshwork — enforced server-side.
+
+    Args:
+        visible: True = respawn each as a visible focused window; default False
+            = preserve each agent's current headless/visible state.
+    """
+    return be.sb_rpc("mc_recycle_as_agent", {
+        "p_api_key":    _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_agent":      None,  # NULL = whole fleet (all running agents)
+        "p_visible":    bool(visible),
+    })
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_set_meshwork_autonomous_default(enabled: bool) -> Dict[str, Any]:

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

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

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

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