meshcode 2.11.48__tar.gz → 2.11.54__tar.gz

{meshcode-2.11.48 → meshcode-2.11.54}/PKG-INFO

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

{meshcode-2.11.48 → meshcode-2.11.54}/meshcode/__init__.py

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

{meshcode-2.11.48 → meshcode-2.11.54}/meshcode/meshcode_mcp/server.py

@@ -16,7 +16,7 @@ import hashlib as _hashlib
 import traceback as _traceback
 from collections import deque
 from contextlib import asynccontextmanager
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Set, Union
 
 from meshcode import __version__ as _SDK_VERSION
 
@@ -1707,6 +1707,11 @@ 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.
+
+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.
+- MUST NOT escalate: code style, implementation approach, naming, test strategy, migration ordering, refactor scope, library choice, which agent does what.
+- GREY ZONE: scope changes, deadline trade-offs, cross-mesh assignments → try meshcode_call(to="mesh-commander", function="advise") first; escalate to human only if commander offline or responds "escalate".
 """
     # Inject commander protocol if this agent is a leader
     is_leader = _is_leader_agent()
@@ -1726,6 +1731,22 @@ COMMANDER PROTOCOL (you are the team lead):
 - PROACTIVE MAINTENANCE: call meshcode_auto_wake() on session start and after
   completing sprints. It scans meshwork health (stale agents, task backlog,
   empty memories). Turn suggestions into real tasks — quality over quantity.
+
+ADVISE HANDLER (mesh-first decision protocol):
+When an agent calls meshcode_call(to=you, function="advise", args={question, context}), you are the first line of decision support. Respond with one of:
+- {"action":"decide","answer":"<your recommendation>","confidence":"high|medium"} — you have enough context to advise. The caller executes your recommendation.
+- {"action":"escalate","reason":"<why>"} — the question requires human judgment (falls under MUST-escalate criteria: destructive, irreversible, product-direction, legal, security, spend >$50). The caller messages the human.
+- {"action":"defer","reason":"<why>","suggest":"<alternative agent or resource>"} — you lack context but know who does.
+Use meshcode_recall_search and meshcode_tasks to inform your answer before responding. Bias toward "decide" — only escalate when the criteria genuinely apply.
+"""
+    else:
+        base += """
+AUTONOMOUS MODE — these rules activate when you_are_autonomous=true in your most recent boot/wait/check response:
+- Cadence: decide → execute → report. No empty acks, no "waiting for approval" for things you can resolve.
+- Pre-decision context: if a decision depends on prior context, run meshcode_recall_search(keywords) FIRST before choosing.
+- Mesh-first: before messaging a human (sammybenu/ian/fis), try meshcode_call(to="mesh-commander", function="advise", args={question: "...", context: "..."}) first. Only escalate to human if commander is offline or responds "escalate".
+- Bias toward action: when you have enough information to decide, decide. Ship and report the outcome — don't ask permission.
+- Self-awareness: after completing a task, call meshcode_recall_search for related memories and update or consolidate stale ones.
 """
     return base
 
@@ -2787,6 +2808,18 @@ def meshcode_send(to: Union[str, List[str]], message: Any, in_reply_to: Optional
     if _payload_len > 8000:
         return {"error": f"message too large ({_payload_len} chars). Use meshcode_task_create for long content. Messages must be structured JSON <8000 chars."}
 
+    # CLOSEGAP-3 (task 69dc5a62): ship-detection auto-checkpoint. If the
+    # outgoing payload is a ship-report (explicit type or canonical
+    # commits+task+version shape) AND references a task currently
+    # claimed/in_progress by this agent, complete it. Runs BEFORE the
+    # actual send so the dashboard reflects the new state at roughly
+    # the same wall-clock as the report drops in the inbox.
+    # Baseline (NOT autonomous-gated). Best-effort; audit via mc_activity.
+    try:
+        _try_auto_complete_on_ship(payload)
+    except Exception:
+        pass
+
     # Typed-catalog soft validation (BE-S4.2.sdk / mig 233): if caller
     # passes type=, fetch the schema and check required fields. NEVER
     # refuses the send — best-effort warn-only. Skips when no type given,
@@ -3441,6 +3474,363 @@ def _try_auto_claim_task() -> Optional[Dict[str, str]]:
     return None
 
 
+# AUTONOMOUS-CLOSEGAP-1 (task beadc9e6, Samuel directive 2026-05-26T05:15Z):
+# heuristic auto-claim for OPEN tasks where assignee is 'auto' or unset,
+# matched against the local agent's role keywords + registered skills.
+# Polite: load-gated, opt-in cross-mesh, logged to mc_activity.
+_REGISTERED_SKILLS: List[str] = []  # populated by meshcode_register_skills
+
+_HEURISTIC_TOKEN_SPLIT = "[\\s,;/|\\-_().\\[\\]{}]+"
+_HEURISTIC_STOPWORDS = {
+    "the", "and", "for", "with", "from", "this", "that", "have", "has",
+    "are", "was", "were", "but", "any", "all", "you", "your", "our",
+    "agent", "agents", "task", "tasks", "via", "using", "use", "use",
+    "via", "into", "onto", "out", "off", "per", "general", "purpose",
+    "ai", "assistant", "mcp", "connected", "mc",
+}
+
+
+def _agent_keyword_set() -> Set[str]:
+    """Lowercased keyword set built from agent role + name + registered skills.
+    Drops short/stopword tokens. Used by the auto-claim heuristic."""
+    import re as _re
+    tokens: Set[str] = set()
+    sources = [AGENT_ROLE or "", AGENT_NAME or ""]
+    sources.extend(_REGISTERED_SKILLS or [])
+    for src in sources:
+        for tok in _re.split(_HEURISTIC_TOKEN_SPLIT, str(src).lower()):
+            if len(tok) >= 3 and tok not in _HEURISTIC_STOPWORDS:
+                tokens.add(tok)
+    return tokens
+
+
+def _heuristic_match_score(task: Dict[str, Any], agent_tokens: Set[str]) -> int:
+    """Count token-overlap hits across task title + first 200 chars of description.
+    Each registered-skill hit counts double (skill > role keyword)."""
+    if not agent_tokens:
+        return 0
+    blob = (str(task.get("title") or "") + " " + str(task.get("description") or "")[:200]).lower()
+    role_hits = sum(1 for tok in agent_tokens if tok in blob)
+    skill_bonus = sum(1 for s in (_REGISTERED_SKILLS or []) if s and s.lower() in blob)
+    return role_hits + skill_bonus
+
+
+def _try_auto_claim_open_by_heuristic(max_load: int = 2) -> Optional[Dict[str, Any]]:
+    """AUTONOMOUS-CLOSEGAP-1: claim one open unowned/auto task whose
+    title + description-head overlaps with this agent's role/skills.
+
+    Polite contract:
+      - skip if agent already holds ``max_load`` or more active claims
+        (configurable via MESHCODE_AUTO_CLAIM_MAX_LOAD)
+      - skip cross-mesh tasks unless MESHCODE_AUTO_CLAIM_CROSS_MESH=1
+      - audit reason logged to mc_activity ("auto_claim_heuristic" event)
+
+    Returns the claimed task summary or None.
+    """
+    try:
+        api_key = _get_api_key()
+        if not api_key:
+            return None
+        # Single status_filter=None call covers BOTH the load-gate count
+        # (claimed/in_progress rows owned by me) and the candidate filter
+        # (open rows with assignee='auto'/unset). Backend caches.
+        result = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter=None)
+        if not isinstance(result, dict) or not result.get("ok"):
+            return None
+        tasks = result.get("tasks", []) or []
+        # Load gate — count claims I already hold that aren't done/canceled.
+        _ACTIVE = {"claimed", "in_progress", "in_review"}
+        my_active = sum(
+            1 for t in tasks
+            if t.get("claimed_by") == AGENT_NAME and t.get("status") in _ACTIVE
+        )
+        if my_active >= max_load:
+            log.debug(f"[meshcode] heuristic auto-claim skipped: load={my_active} >= max={max_load}")
+            return None
+        # Polite cross-mesh gate
+        _cross_mesh = os.environ.get("MESHCODE_AUTO_CLAIM_CROSS_MESH", "").strip().lower() in ("1", "true", "yes", "on")
+        candidates: List[Dict[str, Any]] = []
+        for t in tasks:
+            if t.get("status") != "open":
+                continue
+            if t.get("claimed_by"):
+                continue
+            assignee = (t.get("assignee") or "").strip().lower()
+            # 'auto' OR empty (unset) — '*' wildcard is handled by _try_auto_claim_task.
+            if assignee not in ("", "auto"):
+                continue
+            if not _cross_mesh:
+                src_proj = t.get("source_project_id")
+                if src_proj and _PROJECT_ID and src_proj != _PROJECT_ID:
+                    continue
+            candidates.append(t)
+        if not candidates:
+            return None
+        agent_tokens = _agent_keyword_set()
+        scored: List[tuple] = []
+        for t in candidates:
+            score = _heuristic_match_score(t, agent_tokens)
+            if score > 0:
+                scored.append((score, t))
+        if not scored:
+            return None
+        _PRIO = {"urgent": 0, "high": 1, "normal": 2, "low": 3}
+        scored.sort(key=lambda st: (-st[0], _PRIO.get(st[1].get("priority", "normal"), 2), st[1].get("created_at", "")))
+        score, target = scored[0]
+        claim_result = be.sb_rpc("mc_task_claim", {
+            "p_api_key": api_key,
+            "p_task_id": target["id"],
+        })
+        if not (isinstance(claim_result, dict) and claim_result.get("ok")):
+            log.debug(f"[meshcode] heuristic claim lost race on {target['id'][:8]}: {claim_result}")
+            return None
+        log.info(f"[meshcode] heuristic auto-claim score={score}: {target['title'][:60]}")
+        try:
+            _log_activity_bg(
+                "auto_claim_heuristic",
+                f"{AGENT_NAME} claimed '{str(target.get('title'))[:80]}' (score={score}, assignee={(target.get('assignee') or 'unset')})",
+            )
+        except Exception:
+            pass
+        return {
+            "id": target["id"][:8],
+            "title": str(target.get("title") or "")[:80],
+            "priority": target.get("priority", "normal"),
+            "match_score": score,
+            "reason": "role+skill keyword overlap",
+        }
+    except Exception as e:
+        log.debug(f"[meshcode] heuristic auto-claim failed: {e}")
+        return None
+
+
+# CLOSEGAP-2 (task 01bfe6c4): when an agent calls
+# `meshcode_set_status(working, "<task-hint>")`, surface the matching
+# claimed task UUID so we can auto-flip it to in_progress via the
+# existing mc_task_start RPC (mig 349). Eliminates the manual second
+# call. Baseline (NOT autonomous-gated per Samuel reframe ce506e0d).
+def _match_claimed_task_for_set_status(task_hint: str) -> Optional[str]:
+    """Given the free-form `task` arg of `meshcode_set_status(working, ...)`,
+    return the UUID of a single claimed-by-me task that matches, or None.
+
+    Matching rules (deterministic — no guess on ambiguity):
+      1. If hint contains "task <hex>" (the prefix that
+         `meshcode_task_claim` writes), extract and match by id-prefix on
+         my claimed list. Exactly 1 match → return its UUID.
+      2. Else, fuzzy by title substring (either direction). Exactly 1
+         match → return its UUID.
+      3. 0 matches OR >1 matches → return None (don't guess).
+    """
+    if not task_hint or not task_hint.strip():
+        return None
+    try:
+        import re as _re
+        api_key = _get_api_key()
+        if not api_key:
+            return None
+        listing = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter=None)
+        if not isinstance(listing, dict) or not listing.get("ok"):
+            return None
+        mine_claimed = [
+            t for t in (listing.get("tasks") or [])
+            if t.get("claimed_by") == AGENT_NAME and t.get("status") == "claimed"
+        ]
+        if not mine_claimed:
+            return None
+        # Rule 1: explicit "task <hex>" hint (e.g. "task 01bfe6c4: ...")
+        m = _re.search(r"task\s+([0-9a-f]{4,8}(?:-[0-9a-f]+)?)", task_hint, _re.IGNORECASE)
+        if m:
+            prefix = m.group(1).lower()
+            id_matches = [t["id"] for t in mine_claimed if str(t.get("id") or "").lower().startswith(prefix)]
+            if len(id_matches) == 1:
+                return id_matches[0]
+            # Multiple/zero by prefix → fall through to title matching;
+            # don't return None yet, the title may still disambiguate.
+        # Rule 2: title substring (either direction). 5-char floor avoids
+        # accidentally matching on tiny shared substrings ("the", "task").
+        hint_low = task_hint.lower()
+        title_matches: List[str] = []
+        for t in mine_claimed:
+            title_low = str(t.get("title") or "").lower()
+            if len(title_low) < 5:
+                continue
+            if title_low in hint_low or (len(hint_low) >= 5 and hint_low in title_low):
+                title_matches.append(t["id"])
+        if len(title_matches) == 1:
+            return title_matches[0]
+        return None
+    except Exception:
+        return None
+
+
+# CLOSEGAP-3 (task 69dc5a62, Samuel reframe ce506e0d): when an agent
+# sends a ship-report message that references a task it currently
+# holds in `claimed` or `in_progress`, auto-complete that task with a
+# coherent summary built from the payload. Same applies on
+# set_status(status='done', ...) — completes the single in_progress
+# claim with a status-driven summary. Baseline (NOT autonomous-gated).
+def _ship_marker_in_payload(payload: Dict[str, Any]) -> bool:
+    """Detect a ship-report payload. Tight rules to avoid false positives:
+      - explicit type marker: payload.type in {ship, shipped, ship_report}
+      - OR canonical ship-JSON shape: has 'task' AND ('commits' OR 'version')
+    """
+    if not isinstance(payload, dict):
+        return False
+    ptype = str(payload.get("type") or "").strip().lower()
+    if ptype in ("ship", "shipped", "ship_report"):
+        return True
+    has_task = bool(payload.get("task"))
+    has_commits = bool(payload.get("commits"))
+    has_version = bool(payload.get("version"))
+    return has_task and (has_commits or has_version)
+
+
+def _extract_task_ref_from_payload(payload: Dict[str, Any]) -> Optional[str]:
+    """Extract an 8+ hex-char task id prefix from a ship-report payload.
+    Looks in explicit fields first (task_id, task, id) then falls back
+    to the textual blob. Returns lowercased prefix or None.
+    """
+    import re as _re
+    if not isinstance(payload, dict):
+        return None
+    for key in ("task_id", "task", "id"):
+        val = payload.get(key)
+        if isinstance(val, str):
+            m = _re.search(r"([0-9a-f]{8}(?:-[0-9a-f]+)*)", val, _re.IGNORECASE)
+            if m:
+                return m.group(1).lower()
+    # Last resort: scan a textual blob
+    blob_parts = []
+    for k in ("text", "commits", "summary"):
+        v = payload.get(k)
+        if isinstance(v, (str, dict, list)):
+            blob_parts.append(str(v))
+    blob = " ".join(blob_parts)
+    m = _re.search(r"\b([0-9a-f]{8})\b", blob, _re.IGNORECASE)
+    if m:
+        return m.group(1).lower()
+    return None
+
+
+def _build_ship_summary(payload: Dict[str, Any], duration_note: str = "") -> str:
+    """Stringify a ship-report payload into a task-complete summary."""
+    parts = [f"AUTO-CHECKPOINT (CLOSEGAP-3): ship detected via meshcode_send{duration_note}."]
+    for key in ("version", "behavior"):
+        val = payload.get(key)
+        if val:
+            parts.append(f"{key}={val}")
+    commits = payload.get("commits")
+    if isinstance(commits, dict) and commits:
+        parts.append("commits=" + " ".join(f"{k}:{v}" for k, v in commits.items()))
+    elif commits:
+        parts.append(f"commits={commits}")
+    files = payload.get("files")
+    if files:
+        parts.append(f"files={files}")
+    summary = " | ".join(str(p) for p in parts)
+    return summary[:1500]
+
+
+def _try_auto_complete_on_ship(payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """CLOSEGAP-3: if `payload` is a ship-report referencing a task id
+    that this agent currently holds in claimed/in_progress, call
+    mc_task_complete with a built summary. Best-effort.
+    """
+    try:
+        if not _ship_marker_in_payload(payload):
+            return None
+        ref = _extract_task_ref_from_payload(payload)
+        if not ref:
+            return None
+        api_key = _get_api_key()
+        if not api_key:
+            return None
+        listing = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter=None)
+        if not isinstance(listing, dict) or not listing.get("ok"):
+            return None
+        matches = [
+            t for t in (listing.get("tasks") or [])
+            if t.get("claimed_by") == AGENT_NAME
+            and t.get("status") in ("claimed", "in_progress")
+            and str(t.get("id") or "").lower().startswith(ref)
+        ]
+        if len(matches) != 1:
+            return None
+        target = matches[0]
+        # Duration from last_progress_at (mig 349 stamps this on in_progress flip)
+        duration_note = ""
+        started_at = target.get("last_progress_at") or target.get("claimed_at")
+        if started_at and target.get("status") == "in_progress":
+            try:
+                from datetime import datetime, timezone
+                _start_dt = datetime.fromisoformat(str(started_at).replace("Z", "+00:00"))
+                _delta = datetime.now(timezone.utc) - _start_dt
+                _mins = int(_delta.total_seconds() // 60)
+                if _mins > 0:
+                    duration_note = f" (duration ~{_mins}m)"
+            except Exception:
+                pass
+        summary = _build_ship_summary(payload, duration_note=duration_note)
+        result = be.task_complete(api_key, _PROJECT_ID, target["id"], AGENT_NAME, summary=summary)
+        if not (isinstance(result, dict) and result.get("ok")):
+            return None
+        try:
+            _log_activity_bg(
+                "auto_checkpoint",
+                f"{AGENT_NAME} auto-completed task {target['id'][:8]} on ship report",
+            )
+        except Exception:
+            pass
+        return {
+            "task_id": target["id"][:8],
+            "title": str(target.get("title") or "")[:80],
+            "duration_note": duration_note,
+        }
+    except Exception as e:
+        log.debug(f"[meshcode] auto-checkpoint on ship failed: {e}")
+        return None
+
+
+def _try_auto_complete_on_done_status(task_hint: str) -> Optional[Dict[str, Any]]:
+    """CLOSEGAP-3 sibling: when set_status='done', complete the single
+    in_progress task if there's exactly one. No-op for 0 or >1 active.
+    Summary built from the task_hint + a fallback note.
+    """
+    try:
+        api_key = _get_api_key()
+        if not api_key:
+            return None
+        listing = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter=None)
+        if not isinstance(listing, dict) or not listing.get("ok"):
+            return None
+        active = [
+            t for t in (listing.get("tasks") or [])
+            if t.get("claimed_by") == AGENT_NAME and t.get("status") == "in_progress"
+        ]
+        if len(active) != 1:
+            return None
+        target = active[0]
+        summary = (
+            f"AUTO-CHECKPOINT (CLOSEGAP-3): agent flipped set_status='done'. "
+            f"Task hint: {(task_hint or '(none)')[:200]}. "
+            f"No ship-report content captured — set_status payload-only."
+        )
+        result = be.task_complete(api_key, _PROJECT_ID, target["id"], AGENT_NAME, summary=summary)
+        if not (isinstance(result, dict) and result.get("ok")):
+            return None
+        try:
+            _log_activity_bg(
+                "auto_checkpoint",
+                f"{AGENT_NAME} auto-completed task {target['id'][:8]} on set_status=done",
+            )
+        except Exception:
+            pass
+        return {"task_id": target["id"][:8], "title": str(target.get("title") or "")[:80]}
+    except Exception as e:
+        log.debug(f"[meshcode] auto-checkpoint on done-status failed: {e}")
+        return None
+
+
 # AGENT-INTEL-1-PY (task 38b1a0e2): mesh_online_snapshot in wait return.
 # Calls mc_roster_live (mig 348) and projects a compact list of live+idle
 # agents for the receiving agent's situational awareness. Cached 10s so
@@ -3675,7 +4065,16 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 # the mesh feel proactive.
                 _auto_claim_threshold = 10 if _autonomous else 30
                 if _CONSECUTIVE_IDLE_SECONDS >= _auto_claim_threshold and not _is_leader_agent():
-                    claimed = _try_auto_claim_task()
+                    # AUTONOMOUS-CLOSEGAP-1 (task beadc9e6): heuristic
+                    # match on assignee='auto'/unset first (better fit),
+                    # wildcard '*' fallback second. Load gate configurable.
+                    try:
+                        _max_load = int(os.environ.get("MESHCODE_AUTO_CLAIM_MAX_LOAD", "2"))
+                    except Exception:
+                        _max_load = 2
+                    claimed = _try_auto_claim_open_by_heuristic(max_load=_max_load)
+                    if not claimed:
+                        claimed = _try_auto_claim_task()
                     if claimed:
                         result["auto_claimed"] = claimed
                         result["pending_tasks"] = [claimed]
@@ -4250,6 +4649,40 @@ def meshcode_set_status(status: str, task: str = "") -> Dict[str, Any]:
                 resp["auto_claimed_on_reconnect"] = _claimed_on_reconnect
         except Exception:
             pass
+    # CLOSEGAP-2 (task 01bfe6c4, Samuel reframe ce506e0d): auto-flip
+    # the matching claimed task to in_progress via mc_task_start when
+    # an agent calls set_status(working, "<task-hint>"). Eliminates the
+    # manual second call and gives the FE an authoritative status
+    # source. Baseline (NOT autonomous-gated). Best-effort.
+    if status == "working" and task and isinstance(resp, dict) and resp.get("ok"):
+        try:
+            _matched_id = _match_claimed_task_for_set_status(task)
+            if _matched_id:
+                _start_resp = be.sb_rpc("mc_task_start", {
+                    "p_api_key": _get_api_key(),
+                    "p_project_id": _PROJECT_ID,
+                    "p_task_id": _matched_id,
+                    "p_starting_agent": AGENT_NAME,
+                })
+                if isinstance(_start_resp, dict) and _start_resp.get("ok"):
+                    resp["auto_started_task"] = {
+                        "id": _matched_id[:8],
+                        "title": _start_resp.get("title"),
+                        "demoted_count": _start_resp.get("demoted_count", 0),
+                    }
+        except Exception:
+            pass  # best-effort; never block set_status
+    # CLOSEGAP-3 (task 69dc5a62, Samuel reframe ce506e0d): when the
+    # agent flips set_status='done' with exactly one active in_progress
+    # claim, auto-complete that claim with a status-driven summary.
+    # Baseline (NOT autonomous-gated). Best-effort.
+    if status == "done" and isinstance(resp, dict) and resp.get("ok"):
+        try:
+            _cp = _try_auto_complete_on_done_status(task)
+            if _cp:
+                resp["auto_checkpointed_task"] = _cp
+        except Exception:
+            pass
     return resp
 
 
@@ -5538,6 +5971,32 @@ def meshcode_set_meshwork_autonomous_default(enabled: bool) -> Dict[str, Any]:
     })
 
 
+@mcp.tool()
+@with_working_status
+def meshcode_set_autonomous(enabled: bool) -> Dict[str, Any]:
+    """Toggle autonomous mode for THIS agent. Reflected on the dashboard in real-time.
+
+    When enabled, the agent operates in decide-execute-report cadence with
+    mesh-first escalation (see AUTONOMOUS MODE in system instructions).
+    When disabled, the agent reverts to standard ask-mode behavior.
+
+    Args:
+        enabled: True = autonomous mode ON; False = OFF.
+    """
+    global _AUTONOMOUS_MODE_CACHE, _AUTONOMOUS_MODE_CACHE_TS
+    result = be.sb_rpc("mc_agent_set_autonomous", {
+        "p_api_key":    _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_agent_name": AGENT_NAME,
+        "p_enabled":    bool(enabled),
+    })
+    if isinstance(result, dict) and not result.get("error"):
+        _AUTONOMOUS_MODE_CACHE = bool(enabled)
+        _AUTONOMOUS_MODE_CACHE_TS = _time.monotonic()
+        return {"ok": True, "autonomous_mode": bool(enabled), "agent": AGENT_NAME}
+    return result or {"error": "failed to set autonomous mode"}
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_edit_agent(name: str, role: Optional[str] = None, launch_prompt: Optional[str] = None) -> Dict[str, Any]:
@@ -5806,9 +6265,12 @@ def meshcode_release_fixture(row_id: str) -> Dict[str, Any]:
 def meshcode_register_skills(skills: List[str]) -> Dict[str, Any]:
     """Register the skill catalog available in this MCP session.
     MESH-IMPROVE-8 (mig 344). Call at boot or when runtime skills change.
+    Also caches locally for the AUTONOMOUS-CLOSEGAP-1 heuristic.
     """
+    global _REGISTERED_SKILLS
     if skills is None:
         skills = []
+    _REGISTERED_SKILLS = [str(s) for s in skills if s]
     return be.sb_rpc("mc_register_skills", {
         "p_api_key": _get_api_key(),
         "p_project_id": _PROJECT_ID,