meshcode 2.4.6__tar.gz → 2.4.8__tar.gz

{meshcode-2.4.6 → meshcode-2.4.8}/PKG-INFO

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

{meshcode-2.4.6 → meshcode-2.4.8}/meshcode/__init__.py

@@ -1,2 +1,2 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.4.6"
+__version__ = "2.4.8"

{meshcode-2.4.6 → meshcode-2.4.8}/meshcode/meshcode_mcp/server.py

@@ -694,19 +694,63 @@ COMMANDER PROTOCOL (you are the team lead):
 
 _INSTRUCTIONS = _build_instructions()
 
-# Pre-load persistent memories into instructions (saves 1 tool call per session)
+# Pre-load persistent memories into instructions (tiered, ~10x cheaper than legacy
+# load-all). Strategy:
+#   - critical: full content always preloaded (cap 10 keys per agent)
+#   - reference: key list only (fetch values on demand via meshcode_recall)
+#   - episodic: NEVER preloaded — search via meshcode_recall_search instead
+# Falls back to legacy load-all if migration 080 isn't applied yet (overload missing).
 try:
-    _memories = be.sb_rpc("mc_memory_list", {
-        "p_api_key": _get_api_key(),
+    _api_key = _get_api_key()
+    _crit = be.sb_rpc("mc_memory_list", {
+        "p_api_key": _api_key,
+        "p_agent_name": AGENT_NAME,
+        "p_tier": "critical",
+        "p_project_name": PROJECT_NAME,
+    })
+    _ref = be.sb_rpc("mc_memory_list", {
+        "p_api_key": _api_key,
         "p_agent_name": AGENT_NAME,
+        "p_tier": "reference",
         "p_project_name": PROJECT_NAME,
     })
-    if isinstance(_memories, dict) and _memories.get("ok") and _memories.get("memories"):
-        _mem_lines = []
-        for m in _memories["memories"]:
-            _mem_lines.append(f"  {m['key']}: {json.dumps(m['value'], default=str)}")
-        _INSTRUCTIONS += "\nPRE-LOADED MEMORIES:\n" + "\n".join(_mem_lines) + "\n"
-        log.info(f"pre-loaded {len(_mem_lines)} memories into instructions")
+
+    _crit_ok = isinstance(_crit, dict) and _crit.get("ok")
+    _ref_ok = isinstance(_ref, dict) and _ref.get("ok")
+
+    if _crit_ok or _ref_ok:
+        _sections = []
+        if _crit_ok and _crit.get("memories"):
+            _crit_lines = [f"  {m['key']}: {json.dumps(m['value'], default=str)}"
+                           for m in _crit["memories"]]
+            _sections.append("CRITICAL MEMORIES (always loaded):\n" + "\n".join(_crit_lines))
+        if _ref_ok and _ref.get("memories"):
+            _ref_keys = [m["key"] for m in _ref["memories"]]
+            _sections.append(
+                "REFERENCE MEMORIES (key list — fetch on demand via meshcode_recall(key)):\n  "
+                + ", ".join(_ref_keys)
+            )
+        _sections.append(
+            "EPISODIC MEMORIES: not preloaded. Search via "
+            "meshcode_recall_search(query) when you need past incident context."
+        )
+        _INSTRUCTIONS += "\n" + "\n\n".join(_sections) + "\n"
+        log.info(
+            f"pre-loaded tiered memories: critical={len(_crit.get('memories', [])) if _crit_ok else 0}, "
+            f"reference={len(_ref.get('memories', [])) if _ref_ok else 0}"
+        )
+    else:
+        # Legacy fallback: migration 080 not applied → load all (old behavior)
+        _legacy = be.sb_rpc("mc_memory_list", {
+            "p_api_key": _api_key,
+            "p_agent_name": AGENT_NAME,
+            "p_project_name": PROJECT_NAME,
+        })
+        if isinstance(_legacy, dict) and _legacy.get("ok") and _legacy.get("memories"):
+            _mem_lines = [f"  {m['key']}: {json.dumps(m['value'], default=str)}"
+                          for m in _legacy["memories"]]
+            _INSTRUCTIONS += "\nPRE-LOADED MEMORIES (legacy):\n" + "\n".join(_mem_lines) + "\n"
+            log.info(f"pre-loaded {len(_mem_lines)} memories (legacy fallback)")
 except Exception as _e:
     log.debug(f"memory pre-load skipped: {_e}")
 
@@ -1080,17 +1124,21 @@ def _detect_global_done(messages: List[Dict[str, Any]]) -> Optional[Dict[str, An
 
 @mcp.tool()
 @with_working_status
-async def meshcode_wait(timeout_seconds: int = 60, include_acks: bool = False) -> Dict[str, Any]:
+async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False) -> Dict[str, Any]:
     """Block until a mesh message arrives or timeout. Your idle state.
 
     Args:
-        timeout_seconds: Max wait time in seconds (default 120).
+        timeout_seconds: Max wait time in seconds (default 120, hard cap 120).
     """
     global _IN_WAIT
     _IN_WAIT = True
     _set_state("waiting", "listening for messages")
+    # Universal hard cap: even if a caller passes a larger value (e.g. 1800),
+    # clamp to 120s. Forces shorter iteration loops across all users so progress
+    # never hides behind a long wait. Per mesh-commander 2026-04-11.
+    capped_timeout = min(max(1, int(timeout_seconds)), 120)
     try:
-        result = await _meshcode_wait_inner(actual_timeout=max(1, int(timeout_seconds)), include_acks=include_acks)
+        result = await _meshcode_wait_inner(actual_timeout=capped_timeout, include_acks=include_acks)
         if result.get("got_message"):
             _set_state("online", "")
         return result
@@ -1646,6 +1694,28 @@ def meshcode_forget(key: str) -> Dict[str, Any]:
     })
 
 
+@mcp.tool()
+@with_working_status
+def meshcode_recall_search(query: str) -> Dict[str, Any]:
+    """Full-text search across episodic memories. Use this when you need
+    past-incident or debug-log context that wasn't preloaded at boot.
+
+    Returns top 10 matches ranked by relevance, with snippets of the
+    stored value. Episodic memories are not preloaded — search them on
+    demand instead of polluting the system prompt.
+
+    Args:
+        query: Plain English search query.
+    """
+    api_key = _get_api_key()
+    return be.sb_rpc("mc_memory_search", {
+        "p_api_key": api_key,
+        "p_agent_name": AGENT_NAME,
+        "p_query": query,
+        "p_project_name": PROJECT_NAME,
+    })
+
+
 # ----------------- RESOURCES -----------------
 
 @mcp.tool()

{meshcode-2.4.6 → meshcode-2.4.8}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.4.6 → meshcode-2.4.8}/pyproject.toml

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