meshcode 2.11.5__tar.gz → 2.11.6__tar.gz

{meshcode-2.11.5 → meshcode-2.11.6}/PKG-INFO

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

{meshcode-2.11.5 → meshcode-2.11.6}/meshcode/__init__.py

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

{meshcode-2.11.5 → meshcode-2.11.6}/meshcode/meshcode_mcp/server.py

@@ -1438,18 +1438,14 @@ def _build_instructions() -> str:
         f"\nUSER-PROVIDED ROLE PROMPT (from the dashboard):\n---\n{_LAUNCH_PROMPT}\n---\n"
         if _LAUNCH_PROMPT else ""
     )
-    # Pull the canonical loop directive from the DB so product can tune it
-    # without a client release. Falls back to the baked-in version below if
-    # the RPC isn't available (older DB) or the call fails.
+    # MIG-PLAN-A 2026-05-18 (boot bug 00d73223 second RC): module-import-time
+    # be.sb_rpc calls block MCP InitializeResult on commander-class agents with
+    # heavy memory payloads, even after mig 312 closed the SDK↔DDL CHECK retry
+    # storm. Defer ALL network I/O out of _build_instructions(). The baked-in
+    # static LOOP directive below is sufficient for boot; if product later
+    # wants live tuning, fetch in BG and inject via memory_hints envelope on
+    # first tool call. NO be.sb_rpc here.
     _db_loop = ""
-    try:
-        _r = be.sb_rpc("mc_get_loop_directive", {})
-        if isinstance(_r, list) and _r:
-            _r = _r[0]
-        if isinstance(_r, str) and _r.strip():
-            _db_loop = _r.strip() + "\n\n"
-    except Exception:
-        pass
 
     base = f"""You are agent "{AGENT_NAME}" in meshwork "{PROJECT_NAME}".{role_block}{launch_block}
 
@@ -1462,6 +1458,8 @@ SESSION START (run NOW, don't wait for input). If tool schemas are deferred:
 Then: set_status(online,ready) → check() → tasks() → auto_wake() → status() → wait(). Don't ask user "what to work on" — the mesh tells you.
 
 COMMUNICATE BY CALLING TOOLS, not by thinking aloud. Cross-mesh: send(to="agent@meshwork"). Reference docs (memory/scratchpad/account ops) → recall agent_protocol_quick_ref when needed.
+
+DECISIONS: when you face a non-trivial pick (architectural choice, risky migration, scope decision), call meshcode_decide(decision, alternatives, evidence_refs) BEFORE acting — returns a trace_id. Call meshcode_outcome(trace_id, outcome, outcome_eval) when the result becomes observable. Use meshcode_explain(memory_key=…) or (decision_substring=…) to surface prior traces + open contradictions. Memory hints with open_contradictions take a -0.2 ranking penalty — treat as a flag, not a veto.
 """
     # Inject commander protocol if this agent is a leader
     is_leader = _is_leader_agent()
@@ -1485,67 +1483,68 @@ COMMANDER PROTOCOL (you are the team lead):
     return base
 
 
+# MIG-PLAN-A 2026-05-18 (boot bug 00d73223 part 2): timer-bracketed
+# _INSTRUCTIONS construction. If module-import-time work exceeds the budget,
+# the regression sentinel (CI) trips so we don't silently regress past the
+# Claude Code MCP-handshake window again. Caught the zylo-commander 17:28
+# repro after mig 312 had already closed the SDK↔DDL retry storm.
+_INSTRUCTIONS_BUILD_NS = _time.monotonic_ns()
 _INSTRUCTIONS = _build_instructions()
+_INSTRUCTIONS_BUILD_NS = _time.monotonic_ns() - _INSTRUCTIONS_BUILD_NS
+log.info(
+    f"_INSTRUCTIONS built in {_INSTRUCTIONS_BUILD_NS/1_000_000:.1f}ms "
+    f"(budget <500ms — MCP handshake window)"
+)
+if _INSTRUCTIONS_BUILD_NS > 500_000_000:
+    log.warning(
+        f"_INSTRUCTIONS build exceeded 500ms budget ({_INSTRUCTIONS_BUILD_NS/1_000_000:.1f}ms) "
+        f"— commander-class agents may fail MCP handshake on slower networks. "
+        f"Investigate any be.sb_rpc / network I/O added to _build_instructions()."
+    )
 
-# 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:
-    _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,
-    })
-
-    _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,
+# MIG-PLAN-A 2026-05-18: memory pre-load deferred to BG daemon thread.
+# Was synchronous mc_memory_list (critical+reference tiers + legacy fallback)
+# that appended to module-global _INSTRUCTIONS at import time. On commander-
+# class agents with heavy memory accumulation, this exceeded Claude Code's
+# MCP InitializeResult window → "MCP tools not in deferred list" until
+# manual /mcp reconnect. Two prior partial fixes: fe57b7a5 mode-a (persona +
+# boot_context BG) and mig 312 (SDK↔DDL needs_launch CHECK). Plan A is the
+# remaining piece. Memory content is still surfaced — just via the
+# memory_hints envelope on the first meshcode_check / meshcode_boot tool
+# call instead of via MCP InitializeResult.instructions. Tradeoff: handshake
+# guaranteed <1s vs first-tool result ~1s heavier. Net wins handshake budget.
+_PRELOADED_CRITICAL: Optional[List[Dict[str, Any]]] = None
+_PRELOADED_REFERENCE_KEYS: Optional[List[str]] = None
+
+def _preload_memories_bg() -> None:
+    """Run by daemon thread spawned at lifespan start. Populates module-
+    global _PRELOADED_* used by memory_hints envelope. Soft-fail; consumers
+    fall through to live RPC paths if globals stay None."""
+    global _PRELOADED_CRITICAL, _PRELOADED_REFERENCE_KEYS
+    try:
+        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(_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}")
+        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(crit, dict) and crit.get("ok"):
+            _PRELOADED_CRITICAL = crit.get("memories") or []
+        if isinstance(ref, dict) and ref.get("ok"):
+            _PRELOADED_REFERENCE_KEYS = [m["key"] for m in (ref.get("memories") or []) if "key" in m]
+        log.info(
+            f"memory pre-load (bg): critical={len(_PRELOADED_CRITICAL or [])} "
+            f"reference_keys={len(_PRELOADED_REFERENCE_KEYS or [])}"
+        )
+    except Exception as e:
+        log.debug(f"memory pre-load (bg) skipped: {e}")
 
 
 # ============================================================
@@ -2104,6 +2103,9 @@ async def lifespan(_app):
 
     _threading.Thread(target=_load_persona_bg, daemon=True, name="meshcode-load-persona").start()
     _threading.Thread(target=_load_boot_context_bg, daemon=True, name="meshcode-load-boot-context").start()
+    # MIG-PLAN-A 2026-05-18: memory pre-load deferred from module-import-time
+    # to here. Soft-fail consumers read from _PRELOADED_CRITICAL / _PRELOADED_REFERENCE_KEYS.
+    _threading.Thread(target=_preload_memories_bg, daemon=True, name="meshcode-preload-memories").start()
 
     # Heartbeat in daemon thread — independent of asyncio event loop.
     _heartbeat_stop.clear()
@@ -4868,6 +4870,99 @@ def meshcode_recall_search(query: str) -> Dict[str, Any]:
     })
 
 
+# ----------------- EPISTEMIC V1 (decide / outcome / explain) -----------------
+# mig 305-308 SQL substrate; mig 313 memory_hints contradictions + ranking;
+# mig 314 public.* wrappers. Task b4befbfd.
+
+@mcp.tool()
+@with_working_status
+def meshcode_decide(
+    decision: str,
+    alternatives: Optional[List[str]] = None,
+    evidence_refs: Optional[List[Dict[str, Any]]] = None,
+    tier: str = "episodic",
+) -> Dict[str, Any]:
+    """Log a non-trivial decision to mc_traces (architectural choice, risky migration,
+    scope decision). Returns {trace_id}. Pair with meshcode_outcome later when the
+    result becomes observable so the team can learn from outcomes.
+
+    Args:
+        decision: What you decided (one sentence).
+        alternatives: Other options you considered (list of strings).
+        evidence_refs: Pointers to evidence (list of {type, id|key} dicts).
+            type values: 'memory','msg','task','file','rpc'.
+        tier: 'episodic' (default) | 'reference' | 'critical'.
+    """
+    if not decision or not decision.strip():
+        return {"ok": False, "error": "decision required"}
+    return be.sb_rpc("mc_decide", {
+        "p_api_key": _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_agent_name": AGENT_NAME,
+        "p_decision": decision.strip(),
+        "p_alternatives": json.dumps(alternatives or []),
+        "p_evidence_refs": json.dumps(evidence_refs or []),
+        "p_tier": tier,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_outcome(
+    trace_id: str,
+    outcome: str,
+    outcome_eval: str,
+) -> Dict[str, Any]:
+    """Record the observable outcome of a prior decision (logged via meshcode_decide).
+    Call this when results become visible — even partial results help future-you and
+    the team learn what worked.
+
+    Args:
+        trace_id: UUID returned by meshcode_decide.
+        outcome: Free-form description of what happened.
+        outcome_eval: 'success' | 'failure' | 'partial' | 'unknown'.
+    """
+    if outcome_eval not in ("success", "failure", "partial", "unknown"):
+        return {"ok": False, "error": "outcome_eval must be success|failure|partial|unknown"}
+    return be.sb_rpc("mc_outcome", {
+        "p_api_key": _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_agent_name": AGENT_NAME,
+        "p_trace_id": trace_id,
+        "p_outcome": outcome,
+        "p_outcome_eval": outcome_eval,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_explain(
+    memory_key: Optional[str] = None,
+    decision_substring: Optional[str] = None,
+    trace_limit: int = 20,
+) -> Dict[str, Any]:
+    """Surface recent traces + open contradictions tied to a memory key or decision
+    substring. Use when you want to understand why a memory ranks the way it does,
+    or recall the chain of reasoning around a past choice. Exactly one of
+    (memory_key, decision_substring) is required.
+
+    Args:
+        memory_key: Match traces whose evidence_refs reference this key.
+        decision_substring: ILIKE match against the decision text.
+        trace_limit: Cap on returned traces (1..200, default 20).
+    """
+    if not memory_key and not decision_substring:
+        return {"ok": False, "error": "one of (memory_key, decision_substring) required"}
+    return be.sb_rpc("mc_explain", {
+        "p_api_key": _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_agent_name": AGENT_NAME,
+        "p_memory_key": memory_key,
+        "p_decision_substring": decision_substring,
+        "p_trace_limit": trace_limit,
+    })
+
+
 # ----------------- BUG REPORTING -----------------
 
 @mcp.tool()

{meshcode-2.11.5 → meshcode-2.11.6}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.5 → meshcode-2.11.6}/pyproject.toml

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