meshcode 2.11.124__tar.gz → 2.11.126__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.124
+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.124 → meshcode-2.11.126}/meshcode/__init__.py

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

{meshcode-2.11.124 → 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.124 → meshcode-2.11.126}/meshcode/meshcode_mcp/sleep_signals.py

@@ -136,18 +136,32 @@ def _is_human_authored(m: Dict[str, Any]) -> bool:
     return False
 
 
+def _sender_may_order_sleep(m: Dict[str, Any]) -> bool:
+    """Samuel directive 2026-06-10 (msg 54eec209): a RUNNING agent is only
+    slept by an order from the USER or the COMMANDER. True when the message
+    is human-authored OR carries the SERVER-VERIFIED commander stamp
+    (payload.sender_is_commander, mig 483 — stamped by mc_send_message, never
+    client-claimed). A plain ai peer can no longer must_exit a sibling."""
+    if _is_human_authored(m):
+        return True
+    pl = m.get("payload") or {}
+    return isinstance(pl, dict) and pl.get("sender_is_commander") is True
+
+
 def _looks_like_sleep_signal(m: Dict[str, Any]) -> bool:
     """Detect mesh messages that authorize the wait-loop exit.
 
     See module docstring for the two valid encodings and the rationale
-    for ignoring idiom matches from AI-role senders.
+    for ignoring idiom matches from AI-role senders. Since mig 483 + .125,
+    structured directives additionally require an authorized sender
+    (human or server-stamped commander) — see _sender_may_order_sleep.
     """
     pl = m.get("payload") or {}
     if isinstance(pl, dict):
-        if str(pl.get("type", "")).lower() in _SLEEP_PAYLOAD_TYPES:
-            return True
-        if str(pl.get("directive", "")).lower() in _SLEEP_PAYLOAD_TYPES:
-            return True
+        structured = (str(pl.get("type", "")).lower() in _SLEEP_PAYLOAD_TYPES
+                      or str(pl.get("directive", "")).lower() in _SLEEP_PAYLOAD_TYPES)
+        if structured:
+            return _sender_may_order_sleep(m)
         text = str(pl.get("text", "")).lower()
         if text and any(marker in text for marker in _SLEEP_TEXT_MARKERS):
             if _is_human_authored(m) and _human_text_is_directive(text):
@@ -194,7 +208,9 @@ def _split_messages(messages: List[Dict[str, Any]]) -> Dict[str, Any]:
         t = m.get("type", "msg")
         if t == "ack":
             acks.append(m)
-        elif (t == "done" or _looks_like_sleep_signal(m)) and _recent_enough(m):
+        elif ((t == "done" and _sender_may_order_sleep(m)) or _looks_like_sleep_signal(m)) \
+                and _recent_enough(m):
+            # type='done' rows are sleep-class too — same sender gate applies
             dones.append(m)
         else:
             real.append(m)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.124
+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.124 → meshcode-2.11.126}/pyproject.toml

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

{meshcode-2.11.124 → meshcode-2.11.126}/tests/test_sleep_signals.py

@@ -77,17 +77,23 @@ class TestStructuredDirective(unittest.TestCase):
     of sender — these are deliberately-shaped directives."""
 
     def test_got_done_broadcast_from_commander(self):
+        # post-mig-483 reality: the server stamps sender_is_commander
         m = _msg(sender="mesh-commander", mtype="broadcast",
-                 payload={"type": "got_done"})
+                 payload={"type": "got_done", "sender_is_commander": True})
         self.assertTrue(_looks_like_sleep_signal(m))
 
     def test_payload_type_sleep_from_ai(self):
+        # POLICY CHANGE (54eec209): bare ai sleep directive is ignored
         m = _msg(sender="any-agent", payload={"type": "sleep"})
-        self.assertTrue(_looks_like_sleep_signal(m))
+        self.assertFalse(_looks_like_sleep_signal(m))
 
     def test_payload_directive_shutdown(self):
+        # POLICY CHANGE (54eec209): a plain ai peer cannot order shutdown
         m = _msg(sender="any-agent", payload={"directive": "shutdown"})
-        self.assertTrue(_looks_like_sleep_signal(m))
+        self.assertFalse(_looks_like_sleep_signal(m))
+        m2 = _msg(sender="any-agent",
+                  payload={"directive": "shutdown", "sender_is_commander": True})
+        self.assertTrue(_looks_like_sleep_signal(m2))
 
     def test_payload_type_unknown_is_not_sleep(self):
         m = _msg(sender="any-agent", payload={"type": "msg"})
@@ -132,7 +138,7 @@ class TestSplitMessages(unittest.TestCase):
 
     def test_got_done_broadcast_lands_in_dones(self):
         msgs = [_msg(sender="mesh-commander", mtype="broadcast",
-                     payload={"type": "got_done"})]
+                     payload={"type": "got_done", "sender_is_commander": True})]
         out = _split_messages(msgs)
         self.assertEqual(len(out["done_signals"]), 1)
 
@@ -146,7 +152,8 @@ class TestSplitMessages(unittest.TestCase):
         msgs = [
             _msg(sender="ai", payload={"text": "a dormir is what Samuel said"}),
             _msg(sender="sammybenu", payload={"text": "a dormir"}),
-            _msg(sender="commander", mtype="broadcast", payload={"type": "got_done"}),
+            _msg(sender="commander", mtype="broadcast",
+                 payload={"type": "got_done", "sender_is_commander": True}),
             _msg(sender="other", payload={"text": "normal chatter"}),
             _msg(mtype="ack", payload={}),
         ]
@@ -204,5 +211,44 @@ class TestCasualSpanishComplaintGuards(unittest.TestCase):
     def test_structured_directive_untouched_by_guards(self):
         # dashboard-button path: payload.type fires regardless of text shape
         m = _msg(sender="mesh-commander",
-                 payload={"type": "got_done", "text": self.REPRO})
+                 payload={"type": "got_done", "text": self.REPRO,
+                          "sender_is_commander": True})
+        self.assertTrue(_looks_like_sleep_signal(m))
+
+
+class TestOnlyCommanderOrHumanMayOrderSleep(unittest.TestCase):
+    """Samuel directive 2026-06-10 (msg 54eec209) + mig 483: structured sleep
+    directives and type='done' messages from a plain AI peer must NOT
+    must_exit; only humans or the server-stamped commander may order sleep."""
+
+    def test_ai_peer_structured_sleep_ignored(self):
+        m = _msg(sender="backend2", payload={"type": "got_done", "sender_role": "ai"})
+        self.assertFalse(_looks_like_sleep_signal(m))
+
+    def test_commander_stamp_authorizes(self):
+        m = _msg(sender="mesh-commander",
+                 payload={"type": "got_done", "sender_role": "ai",
+                          "sender_is_commander": True})
         self.assertTrue(_looks_like_sleep_signal(m))
+
+    def test_client_claimed_stamp_string_rejected(self):
+        # only boolean True (server-stamped) counts
+        m = _msg(sender="rogue", payload={"type": "stop", "sender_is_commander": "true"})
+        self.assertFalse(_looks_like_sleep_signal(m))
+
+    def test_human_structured_still_works(self):
+        m = _msg(sender="sammybenu", payload={"type": "sleep"})
+        self.assertTrue(_looks_like_sleep_signal(m))
+
+    def test_done_type_from_ai_peer_not_sleep(self):
+        m = _msg(sender="backend2", mtype="done",
+                 payload={"text": "task xyz done", "sender_role": "ai"})
+        split = _split_messages([m])
+        self.assertEqual(len(split["done_signals"]), 0)
+        self.assertEqual(len(split["messages"]), 1)
+
+    def test_done_type_from_commander_is_sleep(self):
+        m = _msg(sender="mesh-commander", mtype="done",
+                 payload={"text": "got_done", "sender_is_commander": True})
+        split = _split_messages([m])
+        self.assertEqual(len(split["done_signals"]), 1)