meshcode 2.11.31__tar.gz → 2.11.33__tar.gz

{meshcode-2.11.31 → meshcode-2.11.33}/PKG-INFO

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

{meshcode-2.11.31 → meshcode-2.11.33}/meshcode/__init__.py

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

{meshcode-2.11.31 → meshcode-2.11.33}/meshcode/meshcode_mcp/backend.py

@@ -428,10 +428,16 @@ _recording_project_id = ""
 _recording_agent_name = ""
 _recording_session_id = ""
 
-# RPCs that should NOT be recorded (internal/heartbeat/recording itself)
+# RPCs that should NOT be recorded (internal/heartbeat/recording itself).
+# M3a (SUPABASE-PROD-QUOTA-CRITICAL 2026-05-22): added mc_task_list +
+# mc_count_pending + mc_mark_message_read — these were generating 87% of
+# all session_events (~46k of 53k in last 6h) as null-tool tool_call rows
+# from the wait-loop polling. Pure infrastructure noise — no analytic
+# value. The session_events table was 1.2 GB driven mostly by these.
 _SKIP_RECORDING = {"mc_heartbeat", "mc_record_event", "mc_agent_set_status_by_api_key",
                     "mc_acquire_agent_lease", "mc_release_agent_lease",
-                    "mc_update_agent", "mc_get_agents"}
+                    "mc_update_agent", "mc_get_agents",
+                    "mc_task_list", "mc_count_pending", "mc_mark_message_read"}
 
 
 def _get_api_key() -> Optional[str]:

{meshcode-2.11.31 → meshcode-2.11.33}/meshcode/meshcode_mcp/server.py

@@ -2835,10 +2835,36 @@ def meshcode_send(to: Union[str, List[str]], message: Any, in_reply_to: Optional
             result["encrypted"] = True
         return result
 
-    return be.send_message(_PROJECT_ID, AGENT_NAME, to, payload,
-                           msg_type=type or "msg",
-                           parent_msg_id=in_reply_to, sensitive=sensitive,
-                           api_key=_get_api_key(), encrypted=encrypted)
+    _result = be.send_message(_PROJECT_ID, AGENT_NAME, to, payload,
+                              msg_type=type or "msg",
+                              parent_msg_id=in_reply_to, sensitive=sensitive,
+                              api_key=_get_api_key(), encrypted=encrypted)
+
+    # C2 (BACKEND-AUDIT-TASK-FRICTION F4, 2026-05-22): detect payloads that
+    # look like the agent is trying to "claim" a task via a status message
+    # instead of calling meshcode_task_claim. The status_msg path does NOT
+    # update mc_tasks.claimed_by → task sits open while the agent believes
+    # it's working it. Soft hint, never refuse.
+    try:
+        if isinstance(_result, dict) and _result.get("sent"):
+            _ptype = str(payload.get("type", "")).lower()
+            _ptext = str(payload.get("text", "")).lower()
+            _has_task_ref = any(k in payload for k in ("task", "task_id"))
+            _looks_like_claim = (
+                _ptype in {"claim", "claim_status", "status_claim"}
+                or ("claim" in _ptext and _has_task_ref)
+                or (_ptype.startswith("status") and "claim" in _ptext)
+            )
+            if _looks_like_claim:
+                _result["hint"] = (
+                    "claim_via_status_msg_does_not_update_task_table — "
+                    "call meshcode_task_claim(<task_id>) for the actual "
+                    "claim. status_msg is fine as a peer notification "
+                    "but is not the system-of-record."
+                )
+    except Exception:
+        pass
+    return _result
 
 
 @mcp.tool()
@@ -3236,6 +3262,14 @@ _AUTO_SLEEP_THRESHOLD = int(os.environ.get("MESHCODE_AUTO_SLEEP_SECONDS", "600")
 _STAY_AWAKE = False  # Set by meshcode_set_status("online") — prevents auto-sleep
 _LAST_SEEN_TS: Optional[str] = None  # auto-persisted for message dedup
 
+# M2 (SUPABASE-PROD-QUOTA-CRITICAL 2026-05-22): when an agent has been idle
+# longer than _M2_IDLE_THRESHOLD seconds, skip the per-tick mc_tasks poll on
+# (n-1)/n of timeouts — effective task-poll rate drops 1/N. Cuts mc_tasks
+# RPC volume which accounted for ~26.95M cumulative calls in the audit.
+_M2_IDLE_THRESHOLD = int(os.environ.get("MESHCODE_WAIT_IDLE_TASK_POLL_SKIP", "300"))  # secs
+_M2_POLL_EVERY_N  = int(os.environ.get("MESHCODE_WAIT_IDLE_POLL_EVERY_N", "3"))
+_M2_TICK_COUNTER = 0
+
 # Hydrate _LAST_SEEN_TS from mesh memory on boot so restarts skip old messages
 try:
     _ls_result = be.sb_rpc("mc_memory_get", {
@@ -3299,6 +3333,56 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
         return None
 
 
+def _check_task_dedupe(title: str, assignee: str) -> Optional[Dict[str, Any]]:
+    """Find an open/in_progress task with similar title + same assignee.
+
+    Samuel directive 2026-05-21T23:41Z (`commander_dedupe_before_task_from_status_msg`):
+    commanders kept creating duplicate tasks when reacting to status msgs from
+    agents that had already claimed/shipped the same work. The 5ac1d9fe /
+    dd41054d MOBILE-FIRST-3/4 dupes sat OPEN since 2026-05-20 because nobody
+    deduped before creating new ones. Server-side soft guard surfaces a
+    `dedupe_warning` in task_create responses when a likely duplicate
+    exists — non-blocking, so legitimate near-titles still create, but the
+    commander sees the dupe candidate and can cancel + reuse instead.
+    """
+    try:
+        api_key = _get_api_key()
+        if not api_key:
+            return None
+        result = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter=None)
+        if not isinstance(result, dict) or not result.get("ok"):
+            return None
+        tasks = result.get("tasks", [])
+        target = (title or "").strip().lower()
+        if not target:
+            return None
+        target_prefix = target[:40]
+        for t in tasks:
+            if t.get("status") not in ("open", "in_progress"):
+                continue
+            if t.get("assignee") != assignee:
+                continue
+            t_title = (t.get("title") or "").strip().lower()
+            if not t_title:
+                continue
+            t_prefix = t_title[:40]
+            match = None
+            if t_prefix == target_prefix:
+                match = "prefix-40"
+            elif target in t_title or t_title in target:
+                match = "substring"
+            if match:
+                return {
+                    "dupe_task_id": t.get("id"),
+                    "dupe_title": t.get("title"),
+                    "dupe_status": t.get("status"),
+                    "match_type": match,
+                }
+    except Exception:
+        pass
+    return None
+
+
 def _attach_pending_tasks_to_resp(resp: Dict[str, Any]) -> Dict[str, Any]:
     """Surface this agent's open/in_progress assigned tasks on EVERY wait response.
 
@@ -3465,8 +3549,16 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
             if result.get("timed_out"):
                 _CONSECUTIVE_IDLE_SECONDS += capped_timeout
 
+                # M2 (2026-05-22): when idle >5min, poll mc_tasks every Nth
+                # tick instead of every tick. Active agents (recent msg)
+                # keep checking every tick.
+                global _M2_TICK_COUNTER
+                _check_tasks = True
+                if _CONSECUTIVE_IDLE_SECONDS >= _M2_IDLE_THRESHOLD and _M2_POLL_EVERY_N > 1:
+                    _M2_TICK_COUNTER = (_M2_TICK_COUNTER + 1) % _M2_POLL_EVERY_N
+                    _check_tasks = (_M2_TICK_COUNTER == 0)
                 # Check if new tasks appeared while we waited
-                pending_tasks = _get_pending_tasks_summary()
+                pending_tasks = _get_pending_tasks_summary() if _check_tasks else None
                 if pending_tasks:
                     result["pending_tasks"] = pending_tasks
                     break  # Return so agent can work tasks
@@ -4076,11 +4168,24 @@ def meshcode_task_create(title: str, description: str = "", assignee: Optional[s
         except Exception as _de:
             return {"error": f"due_parse_failed: {_de}"}
     api_key = _get_api_key()
+    # Soft dedupe guard (Samuel directive 2026-05-21): surface likely-duplicate
+    # open/in_progress task with same assignee + similar title. Non-blocking —
+    # caller still gets the new task_id, but sees `dedupe_warning` and can
+    # cancel + reuse the existing task instead of accumulating dupes.
+    dedupe_hit = _check_task_dedupe(title.strip(), assignee) if assignee != "auto" else None
     result = be.task_create(api_key, _PROJECT_ID, AGENT_NAME, title.strip(),
                            description=description, assignee=assignee,
                            priority=priority, parent_task_id=parent_task_id,
                            due_at=parsed_due_at, due_label=parsed_due_label,
                            depends_on=depends_on or None)
+    if isinstance(result, dict) and result.get("ok") and dedupe_hit:
+        result["dedupe_warning"] = (
+            f"Possible duplicate of task {dedupe_hit['dupe_task_id'][:8]} "
+            f"('{dedupe_hit['dupe_title'][:60]}', status={dedupe_hit['dupe_status']}, "
+            f"match={dedupe_hit['match_type']}). Consider canceling this new task "
+            f"and reusing the existing one."
+        )
+        result["dedupe_candidate"] = dedupe_hit
     # Auto-notify the resolved assignee so they wake from meshcode_wait.
     # Read result["assignee"] (server may have resolved 'auto' to a real name).
     if isinstance(result, dict) and result.get("ok"):

{meshcode-2.11.31 → meshcode-2.11.33}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.31 → meshcode-2.11.33}/pyproject.toml

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