meshcode 2.11.134__tar.gz → 2.11.135__tar.gz

{meshcode-2.11.134 → meshcode-2.11.135}/PKG-INFO

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

{meshcode-2.11.134 → meshcode-2.11.135}/meshcode/__init__.py

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

{meshcode-2.11.134 → meshcode-2.11.135}/meshcode/hostd.py

@@ -1037,26 +1037,6 @@ def _recycle_blocked(st, target, now=None):
     return None
 
 
-# Samuel rule 2026-06-04: never recycle a CONNECTED agent (live MCP session) except
-# the >3h uptime lifecycle. BUSY_STATUSES (working/online/busy) MISSES a connected-
-# but-idle agent (status idle/standby, window open, heartbeat fresh) — a fresh
-# heartbeat is the stronger 'live session' signal, so an idle-but-connected agent
-# was being version-recycled out from under the user (the storm he kept seeing).
-_CONNECTED_HEARTBEAT_S = _env_int("MESHCODE_CONNECTED_HEARTBEAT_SEC", 60, 10)
-
-
-def _agent_connected(a) -> bool:
-    """True if the agent has a live MCP session: an explicitly-busy status OR a
-    very-recent heartbeat (window open even when idle/standby)."""
-    if (a.get("status") or "") in BUSY_STATUSES:
-        return True
-    hb = a.get("heartbeat_age_s")
-    try:
-        return hb is not None and float(hb) < _CONNECTED_HEARTBEAT_S
-    except (TypeError, ValueError):
-        return False
-
-
 # Part 2 (Samuel req #2 2026-06-04): on a VISIBLE recycle, close the OLD window so
 # old+new don't both stay open (audit gap 6a203baa). DRY-RUN first (commander q2 +
 # reaper safe-arm pattern): log-only until the logs confirm it's ONLY the old pid.
@@ -2122,57 +2102,6 @@ def _do_recycles(api_key: str, host_id: str) -> int:
     # it stays dead even if a schedule row reappears. Crash-RESPAWN (_do_respawns) is
     # UNAFFECTED — only RECYCLE triggers are killed.
     return 0
-    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
 
 
 # ------------------------------------------------------------------
@@ -2502,10 +2431,6 @@ def _hostd_bootstrap(verbose: bool = False) -> bool:
         return False
 
 
-# a69ac010-C: after this many version-recycles at the SAME cv with no advance, STOP (env won't converge).
-_VERREC_MAX_ATTEMPTS = 3
-
-
 def _do_version_recycles(api_key: str, host_id: str) -> int:
     """Recycle managed agents running an OLDER meshcode than what's installed on disk so they pick up
     the auto-updated version (task 14782bb4 D). GRACIOUS (guardrail #5): idle-only (NEVER a BUSY agent /
@@ -2516,77 +2441,6 @@ def _do_version_recycles(api_key: str, host_id: str) -> int:
     # This was the env-mismatch storm source; fixed-at-source via run_agent env-sync, but the
     # whole recycle feature is being removed per owner. Crash-RESPAWN is unaffected.
     return 0
-    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
-    try:
-        from meshcode import self_update as _su
-        disk = _su._current_version()
-    except Exception:
-        return 0
-    if not disk:
-        return 0
-    st = _load_state()
-    now = time.time()
-    n = 0
-    for a in cfg.get("agents", []):
-        if a.get("desired_state") != "running":
-            continue
-        cv = a.get("cli_version")
-        if not cv:
-            continue
-        try:
-            if not _su._is_newer(disk, cv):
-                continue  # agent already on the on-disk version (or newer) — nothing to do
-        except Exception:
-            continue
-        if _agent_connected(a):
-            continue  # Samuel rule: never version-recycle a CONNECTED agent (live MCP session,
-                      # even if idle/standby) — the >3h uptime lifecycle (_do_recycles) is the
-                      # only recycle that may touch a connected agent.
-        proj, agent = a.get("project_name"), a.get("name")
-        if not proj or not agent:
-            continue
-        if _recycle_blocked(st, f"{proj}/{agent}", now):
-            continue  # 451d33a0 unify: already blocked as a non-converging recycle — don't also version-recycle it
-        key = f"verrec/{a.get('project_id')}/{agent}"
-        if now - float(st.get(key, 0) or 0) < 1800:
-            continue  # rate-limit: <=1 version-recycle per agent / 30min (no recycle-storm)
-        # a69ac010-C CONVERGENCE GUARD: if we've already version-recycled this agent _VERREC_MAX_ATTEMPTS
-        # times at THIS exact cv and it never advanced, the agent's spawn env is OLDER than hostd's disk
-        # and recycling will NEVER converge (respawn pulls the same stale env -> same cv -> recycle again).
-        # STOP + alert ONCE instead of version-recycling every 30min forever (the env-mismatch storm RC).
-        conv_key = f"verrec_conv/{a.get('project_id')}/{agent}"
-        conv = dict(st.get(conv_key) or {})
-        if conv.get("cv") == cv and int(conv.get("count", 0)) >= _VERREC_MAX_ATTEMPTS:
-            if not conv.get("alerted"):
-                conv["alerted"] = True
-                st[conv_key] = conv
-                _save_state(st)
-                _log(f"VERSION-RECYCLE STUCK {proj}/{agent}: still {cv} after {conv['count']} recycles "
-                     f"(disk {disk}); spawn env older than hostd — align it (e.g. "
-                     f"~/meshcode-env/bin/pip install -U meshcode). BLOCKING further version-recycles "
-                     f"until cv advances. [recycle_blocked_reason=version_no_converge]")
-            continue
-        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
-            # advance convergence counter for THIS cv; a cv change (env fixed) resets + releases the guard.
-            if conv.get("cv") == cv:
-                conv["count"] = int(conv.get("count", 0)) + 1
-            else:
-                conv = {"cv": cv, "count": 1}
-            conv["alerted"] = False
-            st[conv_key] = conv
-            n += 1
-            _log(f"VERSION-RECYCLE {proj}/{agent}: running {cv} < disk {disk} — recycle at idle to update "
-                 f"(attempt {conv['count']}/{_VERREC_MAX_ATTEMPTS})")
-    if n:
-        _save_state(st)
-    return n
 
 
 # c301be69: hold the singleton lock handle for the daemon's lifetime — module

{meshcode-2.11.134 → meshcode-2.11.135}/meshcode/meshcode_mcp/backend.py

@@ -907,16 +907,21 @@ def take_memory_hints() -> List[Dict]:
     return out
 
 
-def read_inbox(project_id: str, agent: str, mark_read: bool = True, api_key: Optional[str] = None) -> List[Dict]:
-    # Use SECURITY DEFINER RPC when api_key is available (bypasses RLS safely)
+def read_inbox(project_id: str, agent: str, mark_read: bool = True, api_key: Optional[str] = None,
+               rpc_result: Optional[Dict] = None) -> List[Dict]:
+    # Use SECURITY DEFINER RPC when api_key is available (bypasses RLS safely).
+    # rpc_result (mig 521 wait-drain): a pre-fetched mc_read_inbox payload (the
+    # 'inbox' field of mc_wait_poll v5). When given, skip the RPC and run the
+    # identical post-process (decrypt, memory_hints, ack) on it.
     global _LAST_MEMORY_HINTS
     if api_key:
-        rpc_result = sb_rpc("mc_read_inbox", {
-            "p_api_key": api_key,
-            "p_project_id": project_id,
-            "p_agent_name": agent,
-            "p_mark_read": mark_read,
-        })
+        if rpc_result is None:
+            rpc_result = sb_rpc("mc_read_inbox", {
+                "p_api_key": api_key,
+                "p_project_id": project_id,
+                "p_agent_name": agent,
+                "p_mark_read": mark_read,
+            })
         if isinstance(rpc_result, dict) and rpc_result.get("ok"):
             # mig 220: stash memory_hints so the calling tool can attach
             # them to its response. Reset on every call so stale hints

{meshcode-2.11.134 → meshcode-2.11.135}/meshcode/meshcode_mcp/server.py

@@ -3665,6 +3665,11 @@ def _wait_poll_or_legacy() -> Dict[str, Any]:
                 "p_api_key": api_key,
                 "p_project_id": _PROJECT_ID,
                 "p_agent_name": AGENT_NAME,
+                # wait-loop fase 2 (proposal 0bd63160, mig 521): the server
+                # folds read_inbox INTO the poll when there is pending mail —
+                # a message-carrying cycle is 1 RPC instead of 2. mc_wait_poll
+                # v5 (5-arg, default false) serves old SDKs unchanged.
+                "p_drain_inbox": True,
             })
             if isinstance(resp, dict) and resp.get("ok"):
                 return {
@@ -3677,6 +3682,9 @@ def _wait_poll_or_legacy() -> Dict[str, Any]:
                     # Surface it so the caller folds that RPC away. None on
                     # the legacy path = caller must count_pending itself.
                     "pending_count": resp.get("pending_count"),
+                    # mig 521: pre-drained mc_read_inbox result (same shape the
+                    # RPC returns) — present only when pending_count>0.
+                    "inbox": resp.get("inbox"),
                     "_via": "mc_wait_poll",
                 }
     except Exception as e:
@@ -3687,21 +3695,30 @@ def _wait_poll_or_legacy() -> Dict[str, Any]:
         "stop": _check_stop_request(),
         "tasks": _get_pending_tasks_summary(),
         "pending_count": None,
+        "inbox": None,
         "_via": "legacy",
     }
 
 
-def _drain_unread_response(include_acks: bool) -> Optional[Dict[str, Any]]:
+def _drain_unread_response(include_acks: bool,
+                           rpc_result: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
     """SDK-EFF (task ab1f9f5a): read+mark unread DB messages and shape them as
     a wait response. Extracted from the inner-loop's old final-fallback tail so
     the outer loop can invoke it only when mc_wait_poll reports pending_count>0
     (was: an unconditional count_pending every idle cycle). Returns None when
-    nothing real (acks only / already seen) was found."""
+    nothing real (acks only / already seen) was found.
+
+    rpc_result (mig 521, proposal 0bd63160): pre-drained mc_read_inbox payload
+    embedded in the mc_wait_poll v5 response ('inbox' key). When given, NO
+    read_inbox RPC fires — backend.read_inbox still runs its full post-process
+    (decrypt, memory_hints, ack) on the embedded payload, so semantics are
+    byte-identical to the 2-RPC path."""
     try:
         api_key = _get_api_key()
         if not api_key:
             return None
-        raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=api_key)
+        raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=api_key,
+                            rpc_result=rpc_result)
         if not raw:
             return None
         msgs = [
@@ -4591,7 +4608,10 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                     except Exception:
                         _db_pending = 0
                 if _db_pending > 0:
-                    _drained = _drain_unread_response(include_acks)
+                    # mig 521: the poll already drained the inbox server-side
+                    # (1 RPC); pass it through. None => classic read_inbox RPC.
+                    _drained = _drain_unread_response(include_acks,
+                                                      rpc_result=_wp.get("inbox"))
                     if _drained:
                         result = _drained
                         _set_state("online", "")

{meshcode-2.11.134 → meshcode-2.11.135}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.134 → meshcode-2.11.135}/pyproject.toml

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