meshcode 2.11.131__tar.gz → 2.11.132__tar.gz

{meshcode-2.11.131 → meshcode-2.11.132}/PKG-INFO

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

{meshcode-2.11.131 → meshcode-2.11.132}/meshcode/__init__.py

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

{meshcode-2.11.131 → meshcode-2.11.132}/meshcode/hostd.py

@@ -473,6 +473,30 @@ def _rpc(fn: str, payload: dict) -> Optional[dict]:
         return None
 
 
+# SDK-EFF (task ab1f9f5a): mc_host_config_get was ~75k calls in the prod audit
+# because every sweep helper fetched the full roster independently. One fetch
+# now serves the whole ~10s sweep via a short TTL cache. TTL stays under
+# POLL_INTERVAL_SEC so each sweep still sees a fresh roster — an etag scheme
+# would never hit anyway: the payload embeds live heartbeat_age_s, so the
+# server-side hash changes on every call by construction.
+_HOST_CFG_CACHE: dict = {"key": None, "at": 0.0, "cfg": None}
+
+
+def _host_cfg(api_key: str, host_id: str) -> Optional[dict]:
+    """mc_host_config_get with a per-sweep TTL cache. Failures are NOT cached."""
+    ttl = max(3.0, min(float(POLL_INTERVAL_SEC) - 1.0, 8.0))
+    now = time.monotonic()
+    c = _HOST_CFG_CACHE
+    if c["cfg"] is not None and c["key"] == (api_key, host_id) and now - c["at"] < ttl:
+        return c["cfg"]
+    cfg = _rpc("mc_host_config_get", {"p_api_key": api_key, "p_host_id": host_id})
+    if cfg and cfg.get("ok"):
+        c["key"] = (api_key, host_id)
+        c["at"] = now
+        c["cfg"] = cfg
+    return cfg
+
+
 # ------------------------------------------------------------------
 # Respawn
 # ------------------------------------------------------------------
@@ -1808,7 +1832,7 @@ def _do_stopped_ghost_sweep(api_key: str, host_id: str) -> int:
     <target>' cmdlines (token-safe) or direct children of the target's own
     hostd launcher .command — a human `claude --resume` in a plain tab can't
     match either. Returns number of ghosts killed."""
-    cfg = _rpc("mc_host_config_get", {"p_api_key": api_key, "p_host_id": host_id})
+    cfg = _host_cfg(api_key, host_id)  # SDK-EFF ab1f9f5a: per-sweep TTL cache
     if not cfg or not cfg.get("ok"):
         return 0
     st = _load_state()
@@ -1932,7 +1956,7 @@ def _do_reap(api_key: str, host_id: str) -> int:
     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})
+    cfg = _host_cfg(api_key, host_id)  # SDK-EFF ab1f9f5a: per-sweep TTL cache
     if not cfg or not cfg.get("ok"):
         return 0
     agents = cfg.get("agents") or []

{meshcode-2.11.131 → meshcode-2.11.132}/meshcode/meshcode_mcp/backend.py

@@ -444,7 +444,13 @@ _SKIP_RECORDING = {"mc_heartbeat", "mc_record_event", "mc_agent_set_status_by_ap
                     # ~18k err/12h log pollution. The two call sites already
                     # treat it as soft-fail. Silence telemetry until Samuel
                     # approves the public-wrapper DDL.
-                    "mc_tasks_due_soon"}
+                    "mc_tasks_due_soon",
+                    # SDK-EFF (task ab1f9f5a): the consolidated wait-loop poll and
+                    # the two consume RPCs it superseded are pure infrastructure —
+                    # recording them re-creates the exact null-value noise the
+                    # task_list/count_pending skip above was added to kill
+                    # (1 mc_record_event per idle cycle, fleet-wide).
+                    "mc_wait_poll", "mc_consume_stop", "mc_consume_recycle"}
 
 
 def _get_api_key() -> Optional[str]:
@@ -511,22 +517,78 @@ def sb_rpc(fn_name: str, params: Dict, *, _max_retries: int = 3) -> Any:
                        code="0", source="network")
 
 
-def _bg_record(event_type: str, payload: dict):
-    """Background-thread recording — never blocks the caller."""
-    import threading
-    def _do():
+# SDK-EFF batching (task ab1f9f5a, audit c81c3b20): mc_record_event was the #1
+# RPC in prod (~353k calls/wk) because _bg_record fired one RPC AND one thread
+# per recorded event. Events now buffer in-process and a single daemon flusher
+# ships them as ONE mc_record_events_batch call (live in prod, server caps 50
+# events/batch) every _EVENT_FLUSH_SECS or as soon as _EVENT_FLUSH_MAX pile up.
+# Recording stays best-effort: a failed flush drops that slice (the per-event
+# path dropped on failure too) — a dead DB must never grow memory unbounded.
+_EVENT_BUF: List[Dict] = []
+_EVENT_BUF_LOCK = _threading.Lock()
+_EVENT_FLUSH_SECS = 5.0
+_EVENT_FLUSH_MAX = 40          # flush-early threshold, under the 50 server cap
+_EVENT_BUF_HARD_CAP = 400      # runaway guard: beyond this, oldest events drop
+_EVENT_FLUSH_WAKE = _threading.Event()
+_event_flusher_started = False
+
+
+def _flush_events_now():
+    """Drain the buffer in <=50-event slices (server batch cap). Best-effort."""
+    while True:
+        with _EVENT_BUF_LOCK:
+            if not _EVENT_BUF:
+                return
+            batch = _EVENT_BUF[:50]
+            del _EVENT_BUF[:50]
+        resp = sb_rpc_raw("mc_record_events_batch", {
+            "p_api_key": _recording_api_key,
+            "p_project_id": _recording_project_id,
+            "p_agent_name": _recording_agent_name,
+            "p_events": batch,
+        })
+        if resp is None or not (isinstance(resp, dict) and resp.get("ok")):
+            log.debug("event batch flush failed; %d events dropped", len(batch))
+
+
+def _event_flusher_loop():
+    while True:
+        _EVENT_FLUSH_WAKE.wait(timeout=_EVENT_FLUSH_SECS)
+        _EVENT_FLUSH_WAKE.clear()
         try:
-            sb_rpc_raw("mc_record_event", {
-                "p_api_key": _recording_api_key,
-                "p_project_id": _recording_project_id,
-                "p_agent_name": _recording_agent_name,
-                "p_session_id": _recording_session_id,
-                "p_event_type": event_type,
-                "p_payload": payload,
-            })
+            _flush_events_now()
         except Exception as e:
-            log.debug(f"bg_record failed ({event_type}): {e}")
-    threading.Thread(target=_do, daemon=True).start()
+            log.debug(f"event flusher error: {e}")
+
+
+def _ensure_event_flusher():
+    global _event_flusher_started
+    if _event_flusher_started:
+        return
+    with _EVENT_BUF_LOCK:
+        if _event_flusher_started:
+            return
+        _event_flusher_started = True
+    _threading.Thread(target=_event_flusher_loop, daemon=True,
+                      name="mc-event-flusher").start()
+    import atexit
+    atexit.register(_flush_events_now)
+
+
+def _bg_record(event_type: str, payload: dict):
+    """Buffer a session event for batched recording — never blocks the caller."""
+    with _EVENT_BUF_LOCK:
+        if len(_EVENT_BUF) >= _EVENT_BUF_HARD_CAP:
+            del _EVENT_BUF[:_EVENT_FLUSH_MAX]
+        _EVENT_BUF.append({
+            "session_id": _recording_session_id,
+            "event_type": event_type,
+            "payload": payload,
+        })
+        buffered = len(_EVENT_BUF)
+    _ensure_event_flusher()
+    if buffered >= _EVENT_FLUSH_MAX:
+        _EVENT_FLUSH_WAKE.set()
 
 
 def sb_rpc_raw(fn_name: str, params: Dict) -> Any:

{meshcode-2.11.131 → meshcode-2.11.132}/meshcode/meshcode_mcp/server.py

@@ -3671,6 +3671,12 @@ def _wait_poll_or_legacy() -> Dict[str, Any]:
                     "recycle": bool(resp.get("recycle")),
                     "stop": bool(resp.get("stop")),
                     "tasks": _pending_filter(resp.get("tasks") or []),
+                    # SDK-EFF (task ab1f9f5a): mc_wait_poll has returned the
+                    # unread count since mig 457, but the SDK ignored it and
+                    # kept its own count_pending in the inner-loop tail.
+                    # 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"),
                     "_via": "mc_wait_poll",
                 }
     except Exception as e:
@@ -3680,10 +3686,48 @@ def _wait_poll_or_legacy() -> Dict[str, Any]:
         "recycle": _check_recycle_request(),
         "stop": _check_stop_request(),
         "tasks": _get_pending_tasks_summary(),
+        "pending_count": None,
         "_via": "legacy",
     }
 
 
+def _drain_unread_response(include_acks: bool) -> 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."""
+    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)
+        if not raw:
+            return None
+        msgs = [
+            {"from": m["from_agent"], "type": m.get("type", "msg"),
+             "ts": m.get("created_at"), "payload": m.get("payload", {}),
+             "id": m.get("id"), "parent_id": m.get("parent_msg_id")}
+            for m in raw
+        ]
+        deduped = _filter_and_mark(msgs)
+        if not deduped:
+            return None
+        split = _split_messages(deduped)
+        if not include_acks:
+            split["acks"] = []
+        if split["messages"] or split["done_signals"]:
+            return {
+                "got_message": True,
+                **split,
+                "auto_marked": len(deduped),
+                "types_seen": sorted({m.get("type", "msg") for m in deduped}),
+            }
+    except Exception as e:
+        log.debug(f"drain_unread error: {e}")
+    return None
+
+
 def _check_recycle_request() -> bool:
     """Server-authorized recycle (task 548c863e, mig 364).
 
@@ -3735,7 +3779,8 @@ def _check_stop_request() -> bool:
         return False
 
 
-def _try_auto_claim_self_assigned_tasks(max_claims: int = 20) -> List[Dict[str, str]]:
+def _try_auto_claim_self_assigned_tasks(max_claims: int = 20,
+                                        tasks: Optional[List[Dict[str, Any]]] = None) -> List[Dict[str, str]]:
     """URGENT_RUNTIME_FIX_TASK_PULL (Samuel directive 2026-05-26T04:20Z msg
     a15d7ed4 + commander msg 0cfca3f3 AUTOCLAIM_ON_RECONNECT): claim every
     OPEN task already ASSIGNED to me but not yet claimed by anyone. Closes
@@ -3745,6 +3790,10 @@ def _try_auto_claim_self_assigned_tasks(max_claims: int = 20) -> List[Dict[str,
     "antes siempre que habia task assigned el agente sabia que tenia un
     task assigned pendiente y no paraba hasta completar todos").
 
+    SDK-EFF (task ab1f9f5a): pass `tasks` (full task rows already fetched by
+    the caller) to skip this function's own mc_task_list round-trip — the
+    wait-entry path was fetching the identical list twice back-to-back.
+
     Returns the list of claimed task summaries (may be empty).
     """
     claimed: List[Dict[str, str]] = []
@@ -3752,10 +3801,11 @@ def _try_auto_claim_self_assigned_tasks(max_claims: int = 20) -> List[Dict[str,
         api_key = _get_api_key()
         if not api_key:
             return claimed
-        result = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter="open")
-        if not isinstance(result, dict) or not result.get("ok"):
-            return claimed
-        tasks = result.get("tasks", [])
+        if tasks is None:
+            result = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter="open")
+            if not isinstance(result, dict) or not result.get("ok"):
+                return claimed
+            tasks = result.get("tasks", [])
         candidates = [
             t for t in tasks
             if t.get("assignee") == AGENT_NAME
@@ -4302,11 +4352,23 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
     # offline at create time" gap. Always-on, not gated on
     # autonomous_mode. Best-effort.
     try:
-        _wait_entry_auto_claimed = _try_auto_claim_self_assigned_tasks()
+        # SDK-EFF (task ab1f9f5a): ONE mc_task_list serves both the auto-claim
+        # sweep and the pending summary below — they were identical back-to-back
+        # fetches. The post-claim snapshot stays valid for _pending_filter:
+        # a just-claimed task still matches on assignee==me with status 'open'.
+        _entry_tasks_raw = None
+        try:
+            _tl = be.task_list(_get_api_key(), _PROJECT_ID, AGENT_NAME, status_filter=None)
+            if isinstance(_tl, dict) and _tl.get("ok"):
+                _entry_tasks_raw = _tl.get("tasks", [])
+        except Exception:
+            _entry_tasks_raw = None
+        _wait_entry_auto_claimed = _try_auto_claim_self_assigned_tasks(tasks=_entry_tasks_raw)
     except Exception:
         _wait_entry_auto_claimed = []
 
-    pending_tasks = _get_pending_tasks_summary()
+    pending_tasks = (_pending_filter(_entry_tasks_raw) if _entry_tasks_raw is not None
+                     else _get_pending_tasks_summary())
     if pending_tasks and os.environ.get("MESHCODE_WAIT_BLOCKS_ON_TASKS", "").lower() in ("1", "true", "yes"):
         if not _is_leader_agent():
             return {
@@ -4341,11 +4403,14 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
     # ("te escribo y no sale palomita azul en nadie"). If there are unread messages,
     # skip task_pull and fall through to PRODUCT RULE 2 so they get delivered + marked
     # read first. Task-pull still fires normally when the inbox is empty.
-    _has_unread = False
+    # SDK-EFF (task ab1f9f5a): count once, share with PRODUCT RULE 2 below —
+    # the entry path was issuing the identical count_pending twice in a row.
+    _entry_db_pending = 0
     try:
-        _has_unread = bool(be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key()))
+        _entry_db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key()) or 0
     except Exception:
-        _has_unread = False
+        _entry_db_pending = 0
+    _has_unread = bool(_entry_db_pending)
     if _tasks_to_start and not _is_leader_agent() and not _has_unread:
         # Auto-start the highest priority OPEN task so the agent sees it as
         # in_progress and works it immediately. Samuel directive: "agents
@@ -4392,7 +4457,10 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
 
     # PRODUCT RULE 2: If agent has unread messages in DB, refuse to wait.
     try:
-        db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key())
+        # SDK-EFF (task ab1f9f5a): reuse the entry count from above. read_inbox
+        # is the authoritative drain; a message landing in the microseconds
+        # between the two counts was equally invisible to the old double-count.
+        db_pending = _entry_db_pending
         if db_pending and db_pending > 0:
             raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_get_api_key())
             msgs = [
@@ -4507,6 +4575,32 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                     result["stopped"] = True
                     break
 
+                # SDK-EFF (task ab1f9f5a): realtime-missed messages. This drain
+                # used to live in the inner-loop tail as its own count_pending;
+                # mc_wait_poll already reports the unread count, so only the
+                # actual read_inbox costs an RPC — and only when there IS mail.
+                # Ordering note: recycle/stop now win over a missed message
+                # (mc_wait_poll consumed the recycle flag, so it must be
+                # honored); the message stays unread and redelivers after the
+                # respawn / power-on. Legacy path (pending_count=None) keeps
+                # the explicit count so old-RPC fleets lose no coverage.
+                _db_pending = _wp.get("pending_count")
+                if _db_pending is None:
+                    try:
+                        _db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key()) or 0
+                    except Exception:
+                        _db_pending = 0
+                if _db_pending > 0:
+                    _drained = _drain_unread_response(include_acks)
+                    if _drained:
+                        result = _drained
+                        _set_state("online", "")
+                        _CONSECUTIVE_IDLE_SECONDS = 0
+                        _msg_count = len(result.get("messages", []))
+                        if _msg_count:
+                            _log_activity_bg("message_delivered", f"{AGENT_NAME} received {_msg_count} message(s)")
+                        break
+
                 # New tasks that appeared while we waited (from the same poll)
                 pending_tasks = _wp["tasks"]
                 if pending_tasks:
@@ -4562,6 +4656,17 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 continue
         # ── END INTERNAL LOOP ──────────────────────────────────────
 
+        # CAL-3 calendar context — SDK-EFF (task ab1f9f5a) moved it here from
+        # the inner-loop tail: once per RETURNED wait instead of once per idle
+        # cycle (it was a guaranteed RPC every ~20s that the outer loop usually
+        # threw away on `continue`).
+        if isinstance(result, dict) and result.get("timed_out"):
+            try:
+                _cal_ctx = _calendar_context_for_self()
+                if _cal_ctx is not None:
+                    result["calendar_context"] = _cal_ctx
+            except Exception:
+                pass
         # _LAST_SEEN_TS persist removed (2026-05-28) — UUID dedup cache is sufficient
         # Surface memory_hints from mig 220 if a read_inbox happened during
         # this wait cycle (PRODUCT RULE 2 path) or inside _meshcode_wait_inner.
@@ -4829,43 +4934,15 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
             except Exception as e:
                 log.debug(f"DB poll fallback error: {e}")
 
-    # Final fallback: one last DB check (covers realtime path missing msgs)
-    try:
-        api_key = _get_api_key()
-        if api_key:
-            db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=api_key)
-            if db_pending and db_pending > 0:
-                raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=api_key)
-                if raw:
-                    msgs = [
-                        {"from": m["from_agent"], "type": m.get("type", "msg"),
-                         "ts": m.get("created_at"), "payload": m.get("payload", {}),
-                         "id": m.get("id"), "parent_id": m.get("parent_msg_id")}
-                        for m in raw
-                    ]
-                    deduped = _filter_and_mark(msgs)
-                    if deduped:
-                        split = _split_messages(deduped)
-                        if not include_acks:
-                            split["acks"] = []
-                        if split["messages"] or split["done_signals"]:
-                            return {"got_message": True, **split}
-    except Exception as e:
-        log.debug(f"final DB fallback error: {e}")
-
-    # Check if there's any pending work before returning timeout
-    pending_tasks = _get_pending_tasks_summary()
-    out: Dict[str, Any] = {"timed_out": True}
-    if pending_tasks:
-        out["pending_tasks"] = pending_tasks
-    else:
-        out["no_work"] = True
-    # CAL-3 calendar context — surface due/overdue/next_due on timeouts so the
-    # agent knows whether to nudge work even when no new msg arrived.
-    _ctx = _calendar_context_for_self()
-    if _ctx is not None:
-        out["calendar_context"] = _ctx
-    return out
+    # SDK-EFF (task ab1f9f5a): the tail here used to fire 3 more RPCs per idle
+    # cycle — count_pending (realtime-missed-message fallback), task_list (via
+    # _get_pending_tasks_summary) and mc_tasks_due_soon (calendar) — right
+    # before the OUTER loop issued mc_wait_poll, which already answers the
+    # first two. The missed-message drain now lives in the outer loop (driven
+    # by mc_wait_poll's pending_count), tasks come from the same poll, and the
+    # calendar snapshot is attached once per RETURNED wait instead of once per
+    # cycle. Net: 4 RPCs/idle-cycle -> 1.
+    return {"timed_out": True}
 
 
 @mcp.tool()

{meshcode-2.11.131 → meshcode-2.11.132}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.131 → meshcode-2.11.132}/pyproject.toml

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

{meshcode-2.11.131 → meshcode-2.11.132}/tests/test_stop_ghost_terminal.py

@@ -178,7 +178,10 @@ class TestGhostSweep:
         assert re.search(r"heartbeat_age_s", self.SRC) and "90" in self.SRC
 
     def test_uses_roster_not_heartbeat_gated_rpc(self):
-        assert "mc_host_config_get" in self.SRC
+        # SDK-EFF (task ab1f9f5a): the sweep now reads the roster through
+        # _host_cfg, the per-sweep TTL cache over mc_host_config_get — same
+        # no-heartbeat-gate source, one RPC per sweep instead of one per helper.
+        assert "mc_host_config_get" in self.SRC or "_host_cfg(" in self.SRC
         assert "mc_agents_to_stop" not in self.SRC
 
     def test_wired_into_poll_loop(self):

{meshcode-2.11.131 → meshcode-2.11.132}/tests/test_wait_open_tasks_contradiction.py

@@ -63,7 +63,11 @@ class TestWaitContradictionFix(unittest.TestCase):
     def test_pending_tasks_hint_path_unchanged(self):
         # Existing hint surface in the timeout path must remain — that's
         # how the agent now sees open tasks without being blocked.
-        idx = self.source.find('out["pending_tasks"] = pending_tasks')
+        # SDK-EFF (task ab1f9f5a): the hint moved from the inner-loop tail
+        # (out[...]) to the outer loop's mc_wait_poll branch (result[...]) —
+        # same surface, fed by one consolidated RPC instead of a task_list
+        # per idle cycle.
+        idx = self.source.find('result["pending_tasks"] = pending_tasks')
         self.assertGreater(idx, 0,
                            "fallback timeout path must still surface "
                            "pending_tasks as a hint so the agent sees "