meshcode 2.4.5__tar.gz → 2.4.7__tar.gz

{meshcode-2.4.5 → meshcode-2.4.7}/PKG-INFO

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

{meshcode-2.4.5 → meshcode-2.4.7}/meshcode/__init__.py

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

{meshcode-2.4.5 → meshcode-2.4.7}/meshcode/meshcode_mcp/server.py

@@ -45,18 +45,34 @@ def _try_auto_wake(from_agent: str, preview: str) -> None:
 
     Conditions to fire (ALL must be true):
     - _AUTO_WAKE is enabled
+    - from_agent != self  (never wake yourself on self-echo)
     - NOT in meshcode_wait (wait loop already handles delivery)
     - _current_state is 'sleeping' (truly idle, not working, not just online)
+    - No tool calls in the last 30 seconds (broad idle window)
     - LLM CPU is low (not actively generating)
     Otherwise the keystroke would interrupt the user's typing or
     the LLM mid-thought.
     """
     if not _AUTO_WAKE or _IN_WAIT:
         return
+    # Self-echo guard: never wake on a message you sent yourself.
+    # Realtime can echo INSERTs back to the sender (or to all subscribers
+    # in some routing paths) — without this guard, every meshcode_send by
+    # the agent would inject AppleScript into its own terminal mid-session.
+    if from_agent and AGENT_NAME and from_agent == AGENT_NAME:
+        return
     # Only fire when agent is actually sleeping — never when working or online
     # (working = LLM generating; online = brief post-tool window; both would be interrupted)
     if _current_state != 'sleeping':
         return
+    # Recent-activity guard: even if state says 'sleeping', any tool call
+    # in the last 30s means the LLM was just typing or about to type. The
+    # _IN_WAIT + state check has gaps between tool calls; this widens it.
+    try:
+        if (_time.time() - _last_tool_at) < 30.0:
+            return
+    except Exception:
+        pass
     # Belt-and-suspenders: also check parent CPU is low (LLM not generating right now)
     try:
         if _get_parent_cpu() > 5.0:
@@ -678,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,
     })
-    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")
+    _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,
+    })
+
+    _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}")
 
@@ -1630,6 +1690,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.5 → meshcode-2.4.7}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.4.5 → meshcode-2.4.7}/pyproject.toml

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