meshcode 2.11.102__tar.gz → 2.11.104__tar.gz

{meshcode-2.11.102 → meshcode-2.11.104}/PKG-INFO

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

{meshcode-2.11.102 → meshcode-2.11.104}/meshcode/__init__.py

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

{meshcode-2.11.102 → meshcode-2.11.104}/meshcode/hostd.py

@@ -801,19 +801,28 @@ def _do_stops(api_key: str, host_id: str) -> int:
     return n
 
 
+# 38523a98 reaper. Commander guardrail #1: DRY-RUN FIRST — ship LOG-ONLY, confirm ZERO false positives in
+# the logs (REAP-DRYRUN lines), THEN flip _REAP_DRYRUN=False to actually kill. Protects against mis-killing
+# a live agent (Samuel's trauma). Guardrail #2: the orphan grace before reaping a stopped-but-alive zombie.
+_REAP_DRYRUN = True
+_REAP_ORPHAN_GRACE_SEC = 90  # don't reap a just-stopped agent — give the cooperative self-exit time first
+
+
 def _do_reap(api_key: str, host_id: str) -> int:
-    """Reaper (38523a98) — kill headless processes that should NOT be running. CONSERVATIVE: a no-op in
-    normal operation. Both cases are protected by _kill_headless_pid's cmdline reuse-guard (final safety):
-      (A) DUP ghosts: an agent with >1 live `meshcode run <target>` process (a double-spawn left ghost
-          terminals — Samuel's 'se traslapan y desconectan otro'). Kill the EXTRAS, KEEP the recorded PID
-          — but ONLY when that recorded PID is itself confirmed ALIVE, so a known-good survivor stays. If
-          the recorded PID is dead we do NOT guess a survivor (leave it to _do_respawns/_do_stops).
-      (B) ORPHAN: a headless agent the owner set to a TERMINAL state (desired_state in stopped/crashed)
-          whose recorded PID is still alive AND heartbeat is stale (>=90s, so NOT a just-recovered agent)
-          — the 'offline but still reading' case. _do_stops (runs first) already kills stopped+FRESH; this
-          catches the stale-but-alive gap + 'crashed'.
-    NEVER reaps: a VISIBLE agent (user owns the window), a FRESH-heartbeat agent (genuinely alive), or a
-    desired_state='running' agent. Returns number of processes killed."""
+    """Reaper (38523a98) — identify headless processes that should NOT be running. CONSERVATIVE + currently
+    DRY-RUN (LOG-ONLY, _REAP_DRYRUN=True): logs what it WOULD kill, kills nothing, until verified. Cases,
+    both protected by _kill_headless_pid's cmdline reuse-guard (final safety):
+      (A) DUP ghosts: an agent with >1 live `meshcode run <target>` process (double-spawn ghost terminals —
+          Samuel's 'se traslapan y desconectan otro'). Reap the EXTRAS, KEEP the recorded PID — only when
+          that recorded PID is confirmed ALIVE (known-good survivor). Dead recorded PID => don't guess.
+      (B) ORPHAN ZOMBIE: a headless agent the owner set to a TERMINAL state (desired_state stopped/crashed)
+          whose recorded PID is STILL ALIVE — the 'offline-but-still-reading' / 'lo cerré y sigue ahí' case.
+          A FRESH heartbeat here IS the zombie (still reading despite stop). Reap it, but only AFTER a
+          ~90s grace from first-sighting (commander guardrail #2) so the cooperative self-exit
+          (mc_consume_stop -> must_exit) gets first crack. Grace tracked in hostd_state (reapseen/*).
+    NEVER touches: a VISIBLE agent (user owns the window), or a desired_state='running' agent (workers are
+    sacred — only the dup-EXTRA of a running agent is reapable, never its live survivor). Returns count
+    actually killed (0 while DRY-RUN)."""
     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
@@ -834,35 +843,64 @@ def _do_reap(api_key: str, host_id: str) -> int:
         except Exception:
             return False
 
+    def _reap(target, pid, reason):
+        """LOG-ONLY while _REAP_DRYRUN; else hard-kill (reuse-guard inside). Returns 1 if killed."""
+        nonlocal pids
+        if _REAP_DRYRUN:
+            _log(f"REAP-DRYRUN {target}: WOULD kill pid {pid} ({reason}) — log-only, no kill. "
+                 f"Flip _REAP_DRYRUN=False after confirming zero false positives.")
+            return 0
+        if _kill_headless_pid(target, pid):
+            if pids.get(target) == pid:
+                pids.pop(target, None)
+            _log(f"REAP {target}: killed pid {pid} ({reason})")
+            return 1
+        return 0
+
     st = _load_state()
     pids = st.get("headless_pids") or {}
+    seen = st.get("reapseen") or {}
+    now = time.time()
     n = 0
+    live_targets = set()
     for a in agents:
-        if not a.get("headless"):
-            continue  # NEVER reap a visible agent — the user closes its window
         proj, agent = a.get("project_name"), a.get("name")
         if not proj or not agent:
             continue
         target = f"{proj}/{agent}"
-        hb = a.get("heartbeat_age_s")
-        fresh = (hb is not None and hb < 90)        # genuinely alive => never reap
+        live_targets.add(target)
+        if not a.get("headless"):
+            continue  # NEVER reap a visible agent — the user closes its window
+        ds = a.get("desired_state")
         keep = pids.get(target)
         keep_alive = _alive(keep)
-        # (A) DEDUP — only with a CONFIRMED-ALIVE survivor to keep.
+        # (A) DEDUP — only with a CONFIRMED-ALIVE survivor to keep. (Applies to running agents too: we only
+        # ever reap the EXTRA ghost, never the live survivor.)
         if keep_alive:
             discovered = _discover_agent_pids(target)
             if len(discovered) > 1:
                 for p in discovered:
-                    if p != keep and _kill_headless_pid(target, p):
-                        n += 1
-                        _log(f"REAP-DUP {target}: killed duplicate ghost pid {p} (kept live {keep})")
-        # (B) ORPHAN — owner set it stopped/crashed, it's not a recovered (fresh-hb) agent.
-        if keep_alive and (a.get("desired_state") in ("stopped", "crashed")) and not fresh:
-            if _kill_headless_pid(target, keep):
-                pids.pop(target, None)
-                n += 1
-                _log(f"REAP {target}: killed orphan (desired={a.get('desired_state')}, hb={hb}s) headless pid {keep}")
+                    if p != keep:
+                        n += _reap(target, p, f"duplicate ghost; kept live {keep}")
+        # (B) ORPHAN ZOMBIE — owner set stopped/crashed but the proc is still alive. NEVER for running.
+        if ds in ("stopped", "crashed") and keep_alive:
+            first = seen.get(target)
+            if first is None:
+                seen[target] = now  # start the grace clock; self-exit gets first crack
+                _log(f"REAP-PENDING {target}: desired={ds} but pid {keep} alive (hb={a.get('heartbeat_age_s')}s) "
+                     f"— {_REAP_ORPHAN_GRACE_SEC}s grace for cooperative self-exit before reap")
+            elif now - float(first) >= _REAP_ORPHAN_GRACE_SEC:
+                n += _reap(target, keep, f"orphan zombie desired={ds}, hb={a.get('heartbeat_age_s')}s, "
+                                         f"alive {int(now-float(first))}s past stop")
+                seen.pop(target, None)
+        else:
+            seen.pop(target, None)  # recovered / running / gone — clear the grace clock
+    # prune grace entries for agents no longer in the roster
+    for t in list(seen.keys()):
+        if t not in live_targets:
+            seen.pop(t, None)
     st["headless_pids"] = pids
+    st["reapseen"] = seen
     _save_state(st)
     return n
 
@@ -906,6 +944,15 @@ def _do_recycle_enforce(api_key: str, host_id: str) -> int:
                  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
+            # mig425 companion (49fd4ebf, anti kill-loop): a 'requested_never_consumed' candidate was
+            # killed for NEVER consuming its recycle (last_recycle_at still NULL). Record the recycle NOW
+            # so the respawn does NOT immediately re-match mig425 branch 2 (which keys on last_recycle_at
+            # IS NULL) -> it would otherwise force-kill the fresh process every sweep forever. Recording
+            # moves it into branch 1's window, which ages out. NO-OP until mig425 lands: mig419 candidates
+            # carry no enforce_reason, so this is skipped (the consumed-still-alive path already records).
+            if c.get("enforce_reason") == "requested_never_consumed":
+                _rpc("mc_record_recycle",
+                     {"p_api_key": api_key, "p_project_id": c.get("project_id"), "p_agent_name": agent})
     st["headless_pids"] = pids
     _save_state(st)
     return n

{meshcode-2.11.102 → meshcode-2.11.104}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.102 → meshcode-2.11.104}/pyproject.toml

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