meshcode 2.11.125__tar.gz → 2.11.126__tar.gz

{meshcode-2.11.125 → meshcode-2.11.126}/PKG-INFO

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

{meshcode-2.11.125 → meshcode-2.11.126}/meshcode/__init__.py

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

{meshcode-2.11.125 → meshcode-2.11.126}/meshcode/hostd.py

@@ -209,6 +209,34 @@ SPAWN_MIN_INTERVAL_SEC = _env_int("MESHCODE_SPAWN_MIN_INTERVAL_SEC", 45, 5)    #
 SPAWN_BURST_CAP        = _env_int("MESHCODE_SPAWN_BURST_CAP", 5, 2)            # max spawns ...
 SPAWN_BURST_WINDOW_SEC = _env_int("MESHCODE_SPAWN_BURST_WINDOW_SEC", 600, 60)  # ... within this rolling window before tripping
 
+# ------------------------------------------------------------------
+# Plain-respawn guards (Samuel P0 2026-06-10, terminal storm): the burst
+# breaker above NEVER saw the overnight storm — hostd respawned zylo-bemate
+# every ~16 min for 13 h (125 terminals): slow boots under load kept resetting
+# the server-side respawn cap (the agent heartbeats briefly, count -> 0), the
+# ~16 min cadence stays under 5 spawns/10 min, and every respawn STACKED a new
+# window on top of the still-alive previous session, adding load that made the
+# next boot even slower. Two guards on the plain-respawn path in _do_respawns:
+#
+#   LIVE-SESSION GUARD — never open a second terminal while the previous
+#   session's process is still alive: HOLD (spawn nothing), hard-kill the stuck
+#   session after _RESPAWN_STUCK_KILL_S, and relaunch only once it is fully
+#   gone. An explicit Start (fresh spawned_at) kills the old session at once —
+#   a restart the human asked for must first fully close the old terminal.
+#
+#   CONVERGENCE GUARD — mirror of the recycle guard (451d33a0) for plain
+#   respawns, keyed on time BETWEEN consecutive respawns so it catches ANY
+#   cadence: _RESPAWN_CONVERGE_MAX consecutive respawns each started less than
+#   _RESPAWN_CONVERGE_LIFETIME_S after the previous one -> BLOCK further
+#   respawns for _RESPAWN_CONVERGE_BLOCK_TTL_S + resolve the pending launch as
+#   failed (FE toast). An explicit Start clears the block.
+# ------------------------------------------------------------------
+_RESPAWN_STUCK_KILL_S         = _env_int("MESHCODE_RESPAWN_STUCK_KILL_SEC", 600, 60)       # kill a stale-but-alive session after this hold
+_RESPAWN_CONVERGE_MAX         = _env_int("MESHCODE_RESPAWN_CONVERGE_MAX", 3, 2)            # consecutive short-lived respawns before blocking
+_RESPAWN_CONVERGE_LIFETIME_S  = _env_int("MESHCODE_RESPAWN_CONVERGE_LIFETIME_SEC", 1800, 120)   # "short-lived" = next respawn needed within this
+_RESPAWN_CONVERGE_BLOCK_TTL_S = _env_int("MESHCODE_RESPAWN_CONVERGE_BLOCK_TTL_SEC", 21600, 600)  # block duration before one clean retry
+_RESPAWN_FRESH_CLICK_S        = _env_int("MESHCODE_RESPAWN_FRESH_CLICK_SEC", 90, 30)       # spawned_age_s under this = explicit Start click
+
 
 def _log(msg: str) -> None:
     line = f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {msg}"
@@ -535,6 +563,88 @@ def _do_respawns(api_key: str, host_id: str) -> int:
             _rrall[_target] = _rr
             _rst["recyrespawn"] = _rrall
             _save_state(_rst)
+        # ---- plain-respawn guards (Samuel P0 2026-06-10, terminal storm; see
+        # ---- constants block above for the full incident rationale) ----
+        if not _is_recycle:
+            _now2 = time.time()
+            _st2 = _load_state()
+            try:
+                _fresh_click = float(c.get("spawned_age_s")) < _RESPAWN_FRESH_CLICK_S
+            except (TypeError, ValueError):
+                _fresh_click = False
+            _cv_all = dict(_st2.get("respawn_conv") or {})
+            _cv = dict(_cv_all.get(_target) or {})
+            if _fresh_click and (_cv or _target in (_st2.get("respawn_hold") or {})):
+                # explicit Start (fresh spawned_at) = human permission: clear guard state
+                _cv = {}
+                _cv_all.pop(_target, None)
+                _hh = dict(_st2.get("respawn_hold") or {})
+                _hh.pop(_target, None)
+                _st2["respawn_conv"] = _cv_all
+                _st2["respawn_hold"] = _hh
+                _save_state(_st2)
+                _log(f"RESPAWN-GUARD {_target}: explicit Start — cleared hold/convergence state")
+            elif _cv.get("blocked_ts"):
+                if (_now2 - float(_cv["blocked_ts"])) < _RESPAWN_CONVERGE_BLOCK_TTL_S:
+                    _log(f"SKIP respawn {_target}: BLOCKED (respawn_no_converge, "
+                         f"{_cv.get('count')} short-lived respawns) — holding until TTL or a manual Start")
+                    continue
+                _cv.pop("blocked_ts", None)
+                _cv["count"] = 0  # TTL elapsed -> one clean retry; re-blocks if it storms again
+            # LIVE-SESSION GUARD: never stack a second terminal on a still-alive session.
+            _live = [p for p in _discover_agent_pids(_target) if _pid_alive(p)]
+            if _live:
+                _hold_all = dict(_st2.get("respawn_hold") or {})
+                _hold = dict(_hold_all.get(_target) or {})
+                _first = float(_hold.get("first_ts") or _now2)
+                if _fresh_click or (_now2 - _first) >= _RESPAWN_STUCK_KILL_S:
+                    _killed = sum(1 for _p in _live if _kill_headless_pid(_target, _p))
+                    _hold_all.pop(_target, None)
+                    _log(f"RESPAWN-STUCK-KILL {_target}: closed {_killed}/{len(_live)} stale-but-alive "
+                         f"session pid(s) {_live} "
+                         f"({'explicit Start' if _fresh_click else 'stuck > ' + str(_RESPAWN_STUCK_KILL_S) + 's'}) "
+                         f"— relaunch on next sweep once fully gone")
+                else:
+                    _hold["first_ts"] = _first
+                    _hold_all[_target] = _hold
+                    _log(f"RESPAWN-HOLD {_target}: previous session still ALIVE (pids {_live}) — "
+                         f"NOT opening another terminal; stuck-kill in "
+                         f"{int(_RESPAWN_STUCK_KILL_S - (_now2 - _first))}s unless it heartbeats")
+                _st2["respawn_hold"] = _hold_all
+                _save_state(_st2)
+                continue
+            # previous session fully gone — count this relaunch against convergence
+            _hold_all = dict(_st2.get("respawn_hold") or {})
+            if _target in _hold_all:
+                _hold_all.pop(_target, None)
+                _st2["respawn_hold"] = _hold_all
+            if _cv.get("last_ts") and (_now2 - float(_cv["last_ts"])) <= _RESPAWN_CONVERGE_LIFETIME_S:
+                _cv["count"] = int(_cv.get("count", 0)) + 1
+            else:
+                _cv = {"count": 1}  # converged/idle long enough -> fresh count
+            _cv["last_ts"] = _now2
+            if _cv["count"] >= _RESPAWN_CONVERGE_MAX:
+                _cv["blocked_ts"] = _now2
+                _cv_all[_target] = _cv
+                _st2["respawn_conv"] = _cv_all
+                _save_state(_st2)
+                _log(f"ALERT {_target}: respawn NOT CONVERGING — {_cv['count']} consecutive respawns "
+                     f"each <{_RESPAWN_CONVERGE_LIFETIME_S}s apart; BLOCKING respawns for "
+                     f"{_RESPAWN_CONVERGE_BLOCK_TTL_S}s (a manual Start clears the block). "
+                     f"[respawn_blocked_reason=respawn_no_converge]")
+                try:  # stop the dashboard's eternal 'launching…' spinner + actionable toast
+                    _rpc("mc_resolve_launch", {
+                        "p_api_key": api_key, "p_project_id": c.get("project_id"), "p_agent": agent,
+                        "p_status": "failed", "p_reason": "respawn_no_converge",
+                        "p_detail": f"agent kept dying or booting too slowly {_cv['count']}x in a row — "
+                                    f"respawns paused to protect your machine and tokens; press Start "
+                                    f"to retry when ready"})
+                except Exception:
+                    pass
+                continue
+            _cv_all[_target] = _cv
+            _st2["respawn_conv"] = _cv_all
+            _save_state(_st2)
         _ok, _burst, _why = _spawn_rate_ok(_target)
         if not _ok:
             _log(f"SKIP {'recycle-' if _is_recycle else ''}respawn {_target}: rate-limited ({_why})")

{meshcode-2.11.125 → meshcode-2.11.126}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.125 → meshcode-2.11.126}/pyproject.toml

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