meshcode 2.11.115__tar.gz → 2.11.116__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.115
+Version: 2.11.116
 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.116}/meshcode/__init__.py

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

{meshcode-2.11.115 → meshcode-2.11.116}/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.116}/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(10)\n"  # R2-3 (.116): 30s->10s so the fork's agent-alive check (self-exit on recycle/stop) tightens the stale-heartbeat window to <=10s
     )
     # Windows: start_new_session kwarg doesn't exist. Use creationflags.
     _popen_kwargs = {

{meshcode-2.11.115 → meshcode-2.11.116}/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()

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

@@ -1112,6 +1112,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.116}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.115
+Version: 2.11.116
 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.116}/pyproject.toml

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