meshcode 2.11.114__tar.gz → 2.11.115__tar.gz

{meshcode-2.11.114 → meshcode-2.11.115}/PKG-INFO

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

{meshcode-2.11.114 → meshcode-2.11.115}/meshcode/__init__.py

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

{meshcode-2.11.114 → meshcode-2.11.115}/meshcode/meshcode_mcp/server.py

@@ -2898,6 +2898,13 @@ def meshcode_send(to: Union[str, List[str]], message: Any, in_reply_to: Optional
     msg_ids[], count}. Cross-mesh '@' is single-recipient only (mixed lists rejected v1).
     sensitive=True hides from exports. encrypted=True for secrets (AES-256-GCM, cross-mesh only).
     type= optional typed-catalog tag; soft-validates, never refuses."""
+    # mode-2 soft-fail (R2-3): a malformed in_reply_to (not a valid uuid) would hit
+    # the uuid cast at the RPC boundary and reject the WHOLE message. Drop it so the
+    # message still sends (pairs with mig463's nonexistent-but-valid-uuid soft-fail).
+    if in_reply_to is not None and not re.fullmatch(
+        r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}",
+        str(in_reply_to)):
+        in_reply_to = None
     # ── Normalize `to` into a recipients list ──────────────────────────────
     if isinstance(to, list):
         recipients: List[str] = [str(t).strip() for t in to if str(t).strip()]
@@ -3514,6 +3521,58 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
         return None
 
 
+def _pending_filter(tasks: List[Dict[str, Any]]) -> Optional[List[Dict[str, str]]]:
+    """The _get_pending_tasks_summary filter, applied to a task list we already
+    have (e.g. from mc_wait_poll) so we don't re-fetch. Identical output shape."""
+    pending = [
+        {"id": t["id"][:8], "title": t["title"][:80], "priority": t.get("priority", "normal"), "status": t["status"]}
+        for t in tasks
+        if t.get("status") in ("open", "in_progress")
+        and (t.get("claimed_by") == AGENT_NAME or t.get("assignee") == AGENT_NAME)
+    ]
+    if _is_leader_agent():
+        pending.extend([
+            {"id": t["id"][:8], "title": t["title"][:80], "priority": t.get("priority", "normal"), "status": t["status"]}
+            for t in tasks
+            if t.get("status") == "open" and t.get("assignee") == "*" and not t.get("claimed_by")
+        ])
+    _PRIORITY_ORDER = {"urgent": 0, "high": 1, "normal": 2, "low": 3}
+    pending.sort(key=lambda t: _PRIORITY_ORDER.get(t.get("priority", "normal"), 2))
+    return pending if pending else None
+
+
+def _wait_poll_or_legacy() -> Dict[str, Any]:
+    """R2-1: ONE mc_wait_poll replaces _check_recycle_request + _check_stop_request
+    + _get_pending_tasks_summary (3 RPCs + 3 api_key resolves -> 1). Semantics are
+    identical (recycle = mig446 guard, stop = desired_state, tasks via the same
+    filter). Falls back to the 3 legacy RPCs on ANY error so a mixed old-SDK/new-RPC
+    fleet never breaks. recycle-first order is preserved by the caller."""
+    try:
+        api_key = _get_api_key()
+        if api_key:
+            resp = be.sb_rpc("mc_wait_poll", {
+                "p_api_key": api_key,
+                "p_project_id": _PROJECT_ID,
+                "p_agent_name": AGENT_NAME,
+            })
+            if isinstance(resp, dict) and resp.get("ok"):
+                return {
+                    "recycle": bool(resp.get("recycle")),
+                    "stop": bool(resp.get("stop")),
+                    "tasks": _pending_filter(resp.get("tasks") or []),
+                    "_via": "mc_wait_poll",
+                }
+    except Exception as e:
+        log.debug(f"[meshcode] mc_wait_poll failed; legacy fallback: {e}")
+    # Legacy fallback — the 3 separate RPCs (old behavior, never breaks).
+    return {
+        "recycle": _check_recycle_request(),
+        "stop": _check_stop_request(),
+        "tasks": _get_pending_tasks_summary(),
+        "_via": "legacy",
+    }
+
+
 def _check_recycle_request() -> bool:
     """Server-authorized recycle (task 548c863e, mig 364).
 
@@ -4202,11 +4261,11 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
             "count": len(pending_tasks),
             "you_are_autonomous": _get_autonomous_mode(),
             "task_pull_active": True,
-            "hint": "Work the highest-priority task with meshcode_task_start, then meshcode_task_complete. Wait will surface the next one automatically.",
+            "hint": "Work highest-priority task; wait surfaces the next one.",
         }
         if _auto_started:
             out["auto_started_task"] = _auto_started
-            out["hint"] = f"Task '{_auto_started['title'][:60]}' auto-started (in_progress). Work it NOW, then meshcode_task_complete when done."
+            out["hint"] = f"Task '{_auto_started['title'][:60]}' auto-started — work it, then task_complete."
         if _wait_entry_auto_claimed:
             out["auto_claimed_at_wait_entry"] = _wait_entry_auto_claimed
         return out
@@ -4229,6 +4288,11 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 pass  # All messages already seen — fall through to wait loop
             else:
                 split = _split_messages(deduped)
+                # L5-P3 (task 96d5f2e9): honor include_acks on the refused path too —
+                # this was the only delivery path that leaked acks into the payload,
+                # billing a turn's worth of "X read your message" noise to every agent.
+                if not include_acks:
+                    split["acks"] = []
                 # Only refuse for real messages — ack-only batches should not block wait
                 if split["messages"] or split["done_signals"]:
                     resp = {
@@ -4305,7 +4369,8 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 # us fresh. Checked BEFORE pending_tasks: the fresh session
                 # re-attacks any open tasks on boot, so an outstanding backlog
                 # must not pin a stale, context-heavy session alive.
-                if _check_recycle_request():
+                _wp = _wait_poll_or_legacy()  # R2-1: 3 RPCs -> 1 (legacy fallback inside)
+                if _wp["recycle"]:
                     _set_state("sleeping", "recycle")
                     result["must_exit"] = True
                     result["exit_reason"] = (
@@ -4318,7 +4383,7 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 # toggled this agent OFF (desired_state='stopped'). Exit CLEAN — sticky
                 # 'stopped' means hostd will NOT respawn us (unlike recycle). Checked
                 # right after recycle so a power-off wins over auto-claim/pending-tasks.
-                if _check_stop_request():
+                if _wp["stop"]:
                     _set_state("sleeping", "stopped")
                     result["must_exit"] = True
                     result["exit_reason"] = (
@@ -4328,8 +4393,8 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                     result["stopped"] = True
                     break
 
-                # Check if new tasks appeared while we waited
-                pending_tasks = _get_pending_tasks_summary()
+                # New tasks that appeared while we waited (from the same poll)
+                pending_tasks = _wp["tasks"]
                 if pending_tasks:
                     result["pending_tasks"] = pending_tasks
                     break  # Return so agent can work tasks
@@ -4411,7 +4476,8 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
         # `you_are_autonomous` is the canonical field per commander memo
         # decisions msg 29cae7f9; `autonomous_mode` retained for back-compat.
         if isinstance(result, dict):
-            result["autonomous_mode"] = _autonomous
+            # L5-P4: `you_are_autonomous` is canonical (commander memo 29cae7f9);
+            # the duplicate `autonomous_mode` alias was dropped from the envelope.
             result["you_are_autonomous"] = _autonomous
         return result
     finally:
@@ -6062,6 +6128,19 @@ def meshcode_boot() -> Dict[str, Any]:
         # Non-fatal: surface that the hints are unavailable but boot succeeds.
         resp.setdefault("time_context_available", False)
 
+    # L5-P4 (task 96d5f2e9): offline agents' mc_agents.task often holds their
+    # FULL registration role text (150+ tokens each), re-billed on every boot.
+    # The peer roster only needs a glanceable line.
+    try:
+        _mesh = resp.get("mesh_status")
+        if isinstance(_mesh, list):
+            for _row in _mesh:
+                _ct = _row.get("current_task") if isinstance(_row, dict) else None
+                if isinstance(_ct, str) and len(_ct) > 120:
+                    _row["current_task"] = _ct[:117] + "..."
+    except Exception:
+        pass
+
     # c0ab14c1 Phase 2: open-promise time-awareness (what I owe / what I'm
     # waiting on, with overdue/elapsed minutes). Soft-fail; only added when
     # there's something open.
@@ -7253,6 +7332,25 @@ def meshcode_recall_search(query: str) -> Dict[str, Any]:
         query: Plain English search query.
     """
     api_key = _get_api_key()
+    # L6 M4 (task 84c426d4): hybrid semantic+FTS recall via the mc-embed edge
+    # function (embeds the query with gte-small, then calls mc_memory_search v2
+    # with p_query_embedding — RRF fusion server-side). Soft-fail to the direct
+    # RPC (FTS+substring arms of the same v2 fn) if the edge fn is unreachable.
+    try:
+        import urllib.request as _url
+        _req = _url.Request(
+            f"{be.SUPABASE_URL}/functions/v1/mc-embed",
+            data=json.dumps({"search": {
+                "api_key": api_key, "agent_name": AGENT_NAME,
+                "query": query, "project_name": PROJECT_NAME, "limit": 20,
+            }}).encode(),
+            headers={"Content-Type": "application/json"}, method="POST")
+        with _url.urlopen(_req, timeout=8) as _resp:
+            _out = json.loads(_resp.read().decode())
+        if isinstance(_out, dict) and _out.get("ok"):
+            return _out
+    except Exception as _e:
+        log.debug(f"mc-embed search fallback to direct RPC: {_e}")
     return be.sb_rpc("mc_memory_search", {
         "p_api_key": api_key,
         "p_agent_name": AGENT_NAME,

{meshcode-2.11.114 → meshcode-2.11.115}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.114 → meshcode-2.11.115}/pyproject.toml

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