meshcode 2.11.115__tar.gz → 2.11.117__tar.gz

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

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

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

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

{meshcode-2.11.115 → meshcode-2.11.117}/meshcode/_session_handoff_template.py

@@ -161,6 +161,53 @@ def _request_recycle_if_marked(project_dir) -> None:
         sys.stderr.write(f"[session_handoff_write] recycle-request skipped: {e}\\n")
 
 
+def _persist_handoff_to_memory(project_dir, handoff) -> None:
+    """L6 M6.1 (task 84c426d4, 2.11.114): mirror the handoff into
+    mc_agent_memory key='session_handoff' so the server-side boot
+    continuity_capsule (mig 456) can surface it on the NEXT session even
+    when the local handoff.json is gone (new host, wiped workspace).
+    Same best-effort creds pattern as _request_recycle_if_marked —
+    any failure silently skips; handoff.json already covers the local path.
+    """
+    try:
+        mcp = json.loads((project_dir / ".mcp.json").read_text(encoding="utf-8"))
+        env = (next(iter((mcp.get("mcpServers") or {}).values()), {}) or {}).get("env", {}) or {}
+        url = env.get("SUPABASE_URL"); key = env.get("SUPABASE_KEY")
+        agent = env.get("MESHCODE_AGENT"); project = env.get("MESHCODE_PROJECT")
+        if not (url and key and agent):
+            return
+        api_key = os.environ.get("MESHCODE_API_KEY")
+        if not api_key:
+            try:
+                import importlib
+                api_key = importlib.import_module("meshcode.secrets").get_api_key(
+                    profile=env.get("MESHCODE_KEYCHAIN_PROFILE") or "default")
+            except Exception:
+                api_key = None
+        if not api_key:
+            return
+        turns = handoff.get("turns") or []
+        compact = {
+            "trigger": handoff.get("trigger"),
+            "captured_at_session": handoff.get("session_id"),
+            "tail": [{"role": t["role"], "text": t["text"][:400]} for t in turns[-8:]],
+        }
+        import urllib.request as _u
+        body = json.dumps({
+            "p_api_key": api_key, "p_agent_name": agent,
+            "p_key": "session_handoff", "p_value": compact,
+            "p_tier": "episodic", "p_project_name": project,
+        }).encode("utf-8")
+        req = _u.Request(
+            url.rstrip("/") + "/rest/v1/rpc/mc_memory_set",
+            data=body, method="POST",
+            headers={"apikey": key, "Authorization": "Bearer " + key,
+                     "Content-Type": "application/json"})
+        _u.urlopen(req, timeout=5).read()
+    except Exception as e:  # noqa: BLE001 — never block compaction
+        sys.stderr.write(f"[session_handoff_write] memory-persist skipped: {e}\\n")
+
+
 def main() -> int:
     try:
         raw = sys.stdin.read()
@@ -185,6 +232,8 @@ def main() -> int:
         tmp.replace(d / "handoff.json")
     except OSError as e:
         sys.stderr.write(f"[session_handoff_write] skipped: {e}\\n")
+    # L6 M6.1: mirror to server-side memory for the boot continuity capsule.
+    _persist_handoff_to_memory(_project_dir(), handoff)
     # CTX-CLOSE-RELAUNCH (task 400fc536): now that the thread is snapshotted,
     # commander-tier sessions ask the server to recycle at the next task-edge.
     _request_recycle_if_marked(_project_dir())

{meshcode-2.11.115 → meshcode-2.11.117}/meshcode/comms_v4.py

@@ -1886,7 +1886,7 @@ def _start_heartbeat_daemon(project, name, agent_pid=None):
         "        if not check_still_leased(pid):\n"
         "            sys.exit(0)\n"
         "        post('/rest/v1/rpc/mc_heartbeat', {'p_project_id':pid,'p_agent_name':name})\n"
-        "    time.sleep(30)\n"
+        "    time.sleep(30)\n"  # .117: back to 30s (commander 2026-06-09 — 10s tripled hb RPC volume; Fix A already bounds the stale window)
     )
     # Windows: start_new_session kwarg doesn't exist. Use creationflags.
     _popen_kwargs = {

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

@@ -1160,6 +1160,11 @@ def _is_consequential(tool_name: str) -> bool:
 
 
 def _check_decision_gate(tool_name: str) -> Optional[Dict[str, Any]]:
+    # R2-4 kill-list (.116): epistemic suite removed (meshcode_decide is gone) —
+    # the gate would otherwise block consequential tools demanding a tool that
+    # no longer exists. Permanently open.
+    return None
+
     """Returns None when the gate is open; returns an error dict to be
     surfaced as the tool result when the gate is closed. Soft-fail on RPC
     error (gate opens) so a transient DB blip doesn't trap the agent."""
@@ -1842,7 +1847,7 @@ Then: set_status(online,ready) → check() → tasks() → auto_wake() → statu
 
 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.
+Memory hints with open_contradictions take a -0.2 ranking penalty — treat as a flag, not a veto.
 
 ESCALATION RULES:
 - MUST escalate to human: destructive ops (drop/delete/rm -rf), irreversible changes (force-push main, mig without rollback), product-direction decisions (what feature next), legal/compliance, security (auth/secrets/PII), spend > $50 USD.
@@ -4316,13 +4321,7 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                     # surface autonomy on the refused-path too so check
                     # parity holds when wait short-circuits on unread msgs.
                     resp["you_are_autonomous"] = _get_autonomous_mode()
-                    # c0ab14c1 Phase 2: time-awareness on the wait delivery path.
-                    try:
-                        _pa = _promise_awareness(_get_api_key())
-                        if _pa:
-                            resp["time_awareness"] = _pa
-                    except Exception:
-                        pass
+                    # time_awareness removed with promise infra (R2-4 kill-list, .116)
                     return resp
                 # Ack-only batch — fall through to wait loop
     except Exception:
@@ -6141,15 +6140,6 @@ def meshcode_boot() -> Dict[str, Any]:
     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.
-    try:
-        _pa = _promise_awareness(api_key)
-        if _pa:
-            resp["time_awareness"] = _pa
-    except Exception:
-        pass
 
     return resp
 
@@ -6724,115 +6714,6 @@ def _promise_expires_iso(eta_minutes: int) -> Optional[str]:
     return (_dt.now(_tz.utc) + _td(minutes=eta_minutes)).isoformat()
 
 
-def _promise_awareness(api_key: str) -> Optional[Dict[str, Any]]:
-    """Compact time-awareness block for boot/wait payloads: what I owe + what I'm
-    waiting on, with overdue/elapsed minutes. None when there's nothing open."""
-    try:
-        r = be.sb_rpc("mc_promises_involving", {
-            "p_api_key": api_key,
-            "p_agent_name": AGENT_NAME,
-        })
-    except Exception:
-        return None
-    if not isinstance(r, dict) or not r.get("ok"):
-        return None
-    owe = r.get("i_owe") or []
-    waiting = r.get("waiting_on") or []
-    if not owe and not waiting:
-        return None
-    return {
-        "i_owe": owe,
-        "waiting_on": waiting,
-        "overdue_i_owe": sum(1 for p in owe if isinstance(p, dict) and p.get("overdue")),
-        "overdue_waiting_on": sum(1 for p in waiting if isinstance(p, dict) and p.get("overdue")),
-        "hint": "Act on overdue items you owe; for items you're waiting on, the server is already nudging the responsible agent. meshcode_fulfill(promise_id) when done.",
-    }
-
-
-@mcp.tool()
-@with_working_status
-def meshcode_promise(to: str, what: str, eta_minutes: int) -> Dict[str, Any]:
-    """Register a time-bound commitment YOU are responsible for: "I'll do <what>
-    for <to> within <eta_minutes>". If the ETA passes unfulfilled, the server
-    proactively pings YOU (exponential backoff, auto-mutes) so nothing stalls
-    waiting on you. Call meshcode_fulfill(promise_id) when done.
-
-    Use this whenever you tell another agent an ETA. Horizon cap = 24h
-    (1440 min) — for longer commitments create a task instead.
-
-    Args:
-        to: the agent you're committing to (the waiter / beneficiary).
-        what: short description of what you'll deliver.
-        eta_minutes: minutes from now until you expect to deliver (1..1440).
-    """
-    if not to or not to.strip():
-        return {"ok": False, "error": "to (recipient agent) is required"}
-    if not what or not what.strip():
-        return {"ok": False, "error": "what (promise text) is required"}
-    expires = _promise_expires_iso(eta_minutes)
-    if expires is None:
-        return {"ok": False, "error": "eta_minutes must be an integer 1..1440 (24h); use a task for longer"}
-    return be.sb_rpc("mc_record_promise", {
-        "p_api_key": _get_api_key(),
-        "p_to_target": to.strip(),
-        "p_text": what.strip(),
-        "p_expires_at": expires,
-        "p_source_msg_id": None,
-        "p_agent_name": AGENT_NAME,   # responsible = me
-    })
-
-
-@mcp.tool()
-@with_working_status
-def meshcode_expect(of: str, what: str, eta_minutes: int) -> Dict[str, Any]:
-    """Register that you are WAITING on another agent: "<of> will do <what>
-    within <eta_minutes>". If it doesn't happen in time, the server nudges
-    <of> (the RESPONSIBLE agent) — not you. This is the anti-stalemate path:
-    use it whenever you're blocked on someone else (e.g. "you push first, then
-    I deploy"). Cancel with meshcode_fulfill(promise_id) once they deliver.
-
-    Args:
-        of: the agent you're waiting on (the responsible party).
-        what: short description of what you expect them to do.
-        eta_minutes: minutes from now you expect it by (1..1440).
-    """
-    if not of or not of.strip():
-        return {"ok": False, "error": "of (agent you're waiting on) is required"}
-    if not what or not what.strip():
-        return {"ok": False, "error": "what (expectation text) is required"}
-    expires = _promise_expires_iso(eta_minutes)
-    if expires is None:
-        return {"ok": False, "error": "eta_minutes must be an integer 1..1440 (24h); use a task for longer"}
-    # responsible = `of`; waiter = me. Server nudges `of` when overdue.
-    return be.sb_rpc("mc_record_promise", {
-        "p_api_key": _get_api_key(),
-        "p_to_target": AGENT_NAME,
-        "p_text": what.strip(),
-        "p_expires_at": expires,
-        "p_source_msg_id": None,
-        "p_agent_name": of.strip(),   # responsible = the other agent
-    })
-
-
-@mcp.tool()
-@with_working_status
-def meshcode_fulfill(promise_id: str) -> Dict[str, Any]:
-    """Mark a promise/expectation fulfilled — stops all follow-up nudges
-    immediately. Call this the moment the committed work is delivered (or the
-    thing you were waiting on arrives).
-
-    Args:
-        promise_id: the id returned by meshcode_promise / meshcode_expect (or
-            surfaced in a promise_overdue nudge or the boot/wait time_awareness block).
-    """
-    if not promise_id or not str(promise_id).strip():
-        return {"ok": False, "error": "promise_id is required"}
-    return be.sb_rpc("mc_fulfill_promise", {
-        "p_api_key": _get_api_key(),
-        "p_promise_id": str(promise_id).strip(),
-    })
-
-
 # ----------------- PENDING APPROVALS (flagship: GO/no-go gate) -----------------
 # Task bb396c9b. The agent asks for a GO/no-go before a gated action; a human (or an
 # autonomous commander) approves/rejects with one button in the dashboard panel.
@@ -7363,120 +7244,6 @@ def meshcode_recall_search(query: str) -> Dict[str, Any]:
 # 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"}
-    # MESH-IMPROVE-9 soft-gate: warn if a prior trace is missing its outcome
-    # >24h. v1 = warning only (continues). v2 followup tightens to refuse.
-    api_key = _get_api_key()
-    warning = None
-    try:
-        _gate = be.sb_rpc("mc_check_unwritten_outcome", {
-            "p_api_key": api_key,
-            "p_project_id": _PROJECT_ID,
-            "p_agent_name": AGENT_NAME,
-            "p_age_hours": 24,
-        })
-        if isinstance(_gate, dict) and _gate.get("ok") and _gate.get("has_unwritten"):
-            warning = {
-                "type": "unwritten_outcome",
-                "open_trace_id": _gate.get("oldest_trace_id"),
-                "open_trace_decision": _gate.get("decision"),
-                "open_trace_age_seconds": _gate.get("age_seconds"),
-                "hint": _gate.get("hint"),
-                "note": "soft-gate v1: this WARNS but does not block. v2 will refuse. Close prior trace with meshcode_outcome().",
-            }
-    except Exception:
-        pass  # Soft-fail when mig 340 not yet deployed
-    result = be.sb_rpc("mc_decide", {
-        "p_api_key": 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,
-    })
-    if warning and isinstance(result, dict):
-        result["outcome_gate_warning"] = warning
-    return result
-
-
-@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()
@@ -7845,6 +7612,24 @@ def run_server():
         )
         # Stash for the heartbeat thread to relay to commander on first beat.
         os.environ["_MESHCODE_BOOT_DRIFT"] = f"{_installed}->{_loaded}"
+    # R2-5 (2.11.117) boot drift self-check: the launcher stamps the version it
+    # RESOLVED for this agent (pin else latest PyPI) into the .mcp.json env as
+    # MESHCODE_EXPECTED_VERSION. If what actually loaded differs, the spawn env
+    # is stale/mismatched — report it to the mesh (first-heartbeat relay picks
+    # up the sentinel) instead of degrading into "weird behavior".
+    _expected = os.environ.get("MESHCODE_EXPECTED_VERSION", "").strip()
+    if _expected and _expected != _SDK_VERSION:
+        print(
+            f"[meshcode] WARN boot_version_drift: expected={_expected} "
+            f"loaded={_SDK_VERSION} — this agent's spawn env does not serve the "
+            f"version the launcher resolved. Check ~/.meshcode/envs/{_expected}.",
+            file=sys.stderr,
+        )
+        _prev = os.environ.get("_MESHCODE_BOOT_DRIFT", "")
+        os.environ["_MESHCODE_BOOT_DRIFT"] = (
+            (_prev + " " if _prev else "")
+            + f"expected:{_expected}->loaded:{_SDK_VERSION}"
+        )
     if sys.platform == "win32":
         # Windows can't execv-preserve stdio; auto-update defers to next boot.
         # Always announce so Windows users know why their first launch may

{meshcode-2.11.115 → meshcode-2.11.117}/meshcode/run_agent.py

@@ -886,12 +886,22 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
             print(f"[meshcode]        Run `meshcode setup {resolved_project} {agent}` to fix.", file=sys.stderr)
             return 2
 
-    # Env-mismatch storm fix (2.11.109): the non-blocking auto-pip above updated the
-    # LAUNCHER env (sys.executable). But THIS agent's MCP server runs from this
-    # workspace's .mcp.json `command` python — that's the env that reports
-    # cli_version. Sync IT to the launcher's installed version so hostd
-    # version-recycle CONVERGES instead of looping forever. Non-blocking, best-effort.
+    # R2-5 (2.11.117) boot-always-latest: resolve target version (explicit pin
+    # else latest PyPI — owner directive sammybenu 2026-06-09), guarantee an
+    # immutable ~/.meshcode/envs/<target>/ env serving exactly it, and point
+    # this workspace's .mcp.json at it. Live agents keep their old env until
+    # recycle (no in-place overwrite → no class#2 clobber). Soft-fail → legacy
+    # sync_agent_env path (2.11.109 env-mismatch storm fix) below.
+    _boot_env_ver = None
     if not dry_run:
+        try:
+            _boot_env_ver = self_update.ensure_boot_env(mcp_json_path)
+            if _boot_env_ver:
+                print(f"[meshcode]   agent env: meshcode {_boot_env_ver} "
+                      f"(boot-always-latest)", file=sys.stderr)
+        except Exception:
+            _boot_env_ver = None
+    if not dry_run and not _boot_env_ver:
         try:
             _doc = json.loads(mcp_json_path.read_text(encoding="utf-8"))
             for _srv in (_doc.get("mcpServers") or {}).values():
@@ -1112,6 +1122,43 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
         else:
             cmd = [effective_editor]
 
+        # R2-7 Phase 1 (mig 467): per-agent model preference. settings.json "model"
+        # wins (skip RPC); else mc_agent_model_pref -> append --model. Full soft-fail
+        # (no pref / no creds / network error -> current behavior). 4s RPC timeout.
+        try:
+            _settings_model = None
+            _sp = ws / ".claude" / "settings.json"
+            if _sp.exists():
+                _settings_model = (json.loads(_sp.read_text(encoding="utf-8")) or {}).get("model")
+            if not _settings_model:
+                _mcp_cfg = json.loads(mcp_json_path.read_text(encoding="utf-8"))
+                _env = (next(iter((_mcp_cfg.get("mcpServers") or {}).values()), {}) or {}).get("env", {}) or {}
+                _url = _env.get("SUPABASE_URL"); _anon = _env.get("SUPABASE_KEY")
+                _proj = _env.get("MESHCODE_PROJECT"); _agent_n = _env.get("MESHCODE_AGENT")
+                _ak = os.environ.get("MESHCODE_API_KEY")
+                if not _ak:
+                    try:
+                        from meshcode import secrets as _sec
+                        _ak = _sec.get_api_key(profile=_env.get("MESHCODE_KEYCHAIN_PROFILE") or "default")
+                    except Exception:
+                        _ak = None
+                if _url and _anon and _proj and _agent_n and _ak:
+                    import urllib.request as _u
+                    _req = _u.Request(
+                        _url.rstrip("/") + "/rest/v1/rpc/mc_agent_model_pref",
+                        data=json.dumps({"p_api_key": _ak, "p_project_name": _proj,
+                                         "p_agent_name": _agent_n}).encode(),
+                        method="POST",
+                        headers={"apikey": _anon, "Authorization": "Bearer " + _anon,
+                                 "Content-Type": "application/json"})
+                    with _u.urlopen(_req, timeout=4) as _resp:
+                        _pref = (json.loads(_resp.read().decode()) or {}).get("model_pref")
+                    if _pref:
+                        cmd += ["--model", _pref]
+                        print(f"[meshcode]   Model pref (dashboard): {_pref}", file=sys.stderr)
+        except Exception as _me:
+            print(f"[meshcode]   model-pref skipped: {_me}", file=sys.stderr)
+
         if mode == "bypass":
             bypass_check_cmd = effective_editor if not pinned_version else "claude"
             if pinned_version or _claude_supports_bypass(bypass_check_cmd):

{meshcode-2.11.115 → meshcode-2.11.117}/meshcode/self_update.py

@@ -456,10 +456,18 @@ def check_and_maybe_update(verbose: bool = False) -> None:
 
 
 def _env_version(python_exe: str) -> Optional[str]:
-    """meshcode.__version__ as seen by ANOTHER python env (the agent's MCP server)."""
+    """meshcode.__version__ as seen by ANOTHER python env (the agent's MCP server).
+
+    -I (isolated mode): `python -c` prepends CWD to sys.path, so probing from a
+    dir that contains a meshcode/ package (the SDK repo, any vendored copy)
+    reports THAT tree's version instead of the env's installed one (caught live
+    2026-06-09: env build verify refused a correct env because the probe ran
+    from the .117 worktree). Isolated mode answers the only question this
+    function asks: what does THIS env serve.
+    """
     try:
         out = subprocess.run(
-            [python_exe, "-c", "import meshcode,sys; sys.stdout.write(meshcode.__version__)"],
+            [python_exe, "-I", "-c", "import meshcode,sys; sys.stdout.write(meshcode.__version__)"],
             capture_output=True, text=True, timeout=10).stdout.strip()
         return out or None
     except Exception:
@@ -495,6 +503,144 @@ def sync_agent_env(mcp_python: str, verbose: bool = False) -> None:
         pass
 
 
+# ============================================================
+# R2-5 (2.11.117): versioned immutable envs + boot-always-latest
+#
+# Owner directive (sammybenu 2026-06-09T22:54Z): "al boot SIEMPRE
+# auto-update meshcode a la versión más nueva de PyPI" — per-agent pin
+# only when explicitly set.
+#
+# Instead of upgrading a SHARED live env in place (class#2 clobber —
+# the reason the 8e4f93f9 guard defers forever on a 24/7 fleet), each
+# version gets its own immutable venv under ~/.meshcode/envs/<version>/
+# built exactly once and never touched again. Running agents keep
+# importing their old env until recycle; new spawns point at the
+# resolved target. No overwrite → no clobber → no deferral.
+# ============================================================
+
+ENVS_DIR = STATE_DIR / "envs"
+ENV_BUILD_TIMEOUT_SEC = 240
+_ENV_OK_MARKER = ".build-ok"
+
+
+def resolve_target_version() -> Optional[str]:
+    """Version an agent spawn should run. Resolution order:
+
+      1. MESHCODE_VERSION_PIN env var          (explicit pin wins)
+      2. prefs key "version_pin"               (explicit pin wins)
+      3. latest PyPI (1.5s probe)              (the owner-directive default)
+      4. None → caller keeps current behavior  (offline-safe)
+    """
+    pin = os.environ.get("MESHCODE_VERSION_PIN") or _read_prefs().get("version_pin")
+    if pin:
+        return str(pin).strip()
+    return fetch_latest_version()
+
+
+def _env_python(version: str) -> Path:
+    sub = "Scripts" if sys.platform == "win32" else "bin"
+    exe = "python.exe" if sys.platform == "win32" else "python3"
+    return ENVS_DIR / version / sub / exe
+
+
+def ensure_versioned_env(version: str, verbose: bool = True) -> Optional[Path]:
+    """Create-once immutable venv for `version`; return its python, or None.
+
+    Build is atomic: venv + pip install + import-verify happen in a
+    .tmp-<version>-<pid> dir which is renamed into place only after the
+    installed version is VERIFIED == target (refuse-stale-spawn at the
+    source). Concurrent builders race benignly — first rename wins, the
+    loser falls back to the winner's env. Never raises.
+    """
+    try:
+        final = ENVS_DIR / version
+        py = _env_python(version)
+        if py.exists() and (final / _ENV_OK_MARKER).exists():
+            return py
+
+        tmp = ENVS_DIR / f".tmp-{version}-{os.getpid()}"
+        tmp_py = Path(str(py).replace(str(final), str(tmp), 1))
+        ENVS_DIR.mkdir(parents=True, exist_ok=True)
+        if verbose:
+            print(f"[meshcode] building env for meshcode {version} (one-time, ~30s)...",
+                  file=sys.stderr)
+        import shutil
+        shutil.rmtree(tmp, ignore_errors=True)
+        if subprocess.run([sys.executable, "-m", "venv", str(tmp)],
+                          capture_output=True, timeout=ENV_BUILD_TIMEOUT_SEC).returncode != 0:
+            shutil.rmtree(tmp, ignore_errors=True)
+            return None
+        proc = subprocess.run(
+            [str(tmp_py), "-m", "pip", "install", "--no-cache-dir", "--quiet",
+             "--disable-pip-version-check", f"{PKG_NAME}=={version}"],
+            capture_output=True, timeout=ENV_BUILD_TIMEOUT_SEC)
+        if proc.returncode != 0:
+            shutil.rmtree(tmp, ignore_errors=True)
+            return None
+        got = _env_version(str(tmp_py))
+        if got != version:  # refuse-stale-spawn: never bless a wrong env
+            shutil.rmtree(tmp, ignore_errors=True)
+            return None
+        (tmp / _ENV_OK_MARKER).write_text(version, encoding="utf-8")
+        try:
+            os.rename(tmp, final)
+        except OSError:
+            shutil.rmtree(tmp, ignore_errors=True)  # concurrent builder won
+        if py.exists() and (final / _ENV_OK_MARKER).exists():
+            return py
+        return None
+    except Exception:
+        return None
+
+
+def ensure_boot_env(mcp_json_path, verbose: bool = True) -> Optional[str]:
+    """Boot-always-latest engine, called by `meshcode run` pre-editor-exec.
+
+    Resolves the target version (pin else latest PyPI), guarantees an
+    immutable env serving EXACTLY it, points the workspace .mcp.json
+    command there, and stamps MESHCODE_EXPECTED_VERSION into the server
+    env block (the serve compares it against its loaded __version__ at
+    boot and reports boot_version_drift to the mesh on mismatch).
+
+    Returns the target version on success, None on ANY failure — the
+    caller then keeps the legacy sync_agent_env path. Never raises.
+    """
+    try:
+        if update_disabled() or is_editable_install():
+            return None
+        mcp_json_path = Path(mcp_json_path)
+        target = resolve_target_version()
+        if not target:
+            return None
+        doc = json.loads(mcp_json_path.read_text(encoding="utf-8"))
+        servers = doc.get("mcpServers") or {}
+        if not servers:
+            return None
+        srv = next(iter(servers.values()))
+        cur_cmd = srv.get("command") or ""
+        cur_ver = _env_version(cur_cmd) if cur_cmd else None
+
+        changed = False
+        if cur_ver != target:
+            py = ensure_versioned_env(target, verbose=verbose)
+            if py is None:
+                return None
+            if cur_cmd != str(py):
+                srv["command"] = str(py)
+                changed = True
+        env_block = srv.setdefault("env", {})
+        if env_block.get("MESHCODE_EXPECTED_VERSION") != target:
+            env_block["MESHCODE_EXPECTED_VERSION"] = target
+            changed = True
+        if changed:
+            tmp = mcp_json_path.with_name(mcp_json_path.name + ".tmp")
+            tmp.write_text(json.dumps(doc, indent=2), encoding="utf-8")
+            tmp.replace(mcp_json_path)
+        return target
+    except Exception:
+        return None
+
+
 # ============================================================
 # Blocking variant — used by `meshcode run` to guarantee the editor
 # subprocess inherits the latest meshcode_mcp/server.py on disk.

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

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

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

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