meshcode 2.11.133__tar.gz → 2.11.135__tar.gz

{meshcode-2.11.133 → meshcode-2.11.135}/PKG-INFO

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

{meshcode-2.11.133 → meshcode-2.11.135}/meshcode/__init__.py

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

{meshcode-2.11.133 → meshcode-2.11.135}/meshcode/hostd.py

@@ -1037,26 +1037,6 @@ def _recycle_blocked(st, target, now=None):
     return None
 
 
-# Samuel rule 2026-06-04: never recycle a CONNECTED agent (live MCP session) except
-# the >3h uptime lifecycle. BUSY_STATUSES (working/online/busy) MISSES a connected-
-# but-idle agent (status idle/standby, window open, heartbeat fresh) — a fresh
-# heartbeat is the stronger 'live session' signal, so an idle-but-connected agent
-# was being version-recycled out from under the user (the storm he kept seeing).
-_CONNECTED_HEARTBEAT_S = _env_int("MESHCODE_CONNECTED_HEARTBEAT_SEC", 60, 10)
-
-
-def _agent_connected(a) -> bool:
-    """True if the agent has a live MCP session: an explicitly-busy status OR a
-    very-recent heartbeat (window open even when idle/standby)."""
-    if (a.get("status") or "") in BUSY_STATUSES:
-        return True
-    hb = a.get("heartbeat_age_s")
-    try:
-        return hb is not None and float(hb) < _CONNECTED_HEARTBEAT_S
-    except (TypeError, ValueError):
-        return False
-
-
 # Part 2 (Samuel req #2 2026-06-04): on a VISIBLE recycle, close the OLD window so
 # old+new don't both stay open (audit gap 6a203baa). DRY-RUN first (commander q2 +
 # reaper safe-arm pattern): log-only until the logs confirm it's ONLY the old pid.
@@ -2122,57 +2102,6 @@ def _do_recycles(api_key: str, host_id: str) -> int:
     # it stays dead even if a schedule row reappears. Crash-RESPAWN (_do_respawns) is
     # UNAFFECTED — only RECYCLE triggers are killed.
     return 0
-    cfg = _rpc("mc_host_config_get", {"p_api_key": api_key, "p_host_id": host_id})
-    if not cfg or not cfg.get("ok"):
-        return 0
-    pol = _rpc("mc_host_recycle_policy", {"p_api_key": api_key, "p_host_id": host_id})
-    mode = (pol or {}).get("recycle_mode")
-    value = (pol or {}).get("recycle_value")
-    if mode != "time" or not value:
-        return 0  # context-recycle is agent-cooperative; only time is daemon-driven
-    st = _load_state()
-    now = time.time()
-    n = 0
-    seen = set()
-    for a in cfg.get("agents", []):
-        if a.get("desired_state") != "running":
-            continue
-        proj, agent = a.get("project_name"), a.get("name")
-        if not proj or not agent:
-            continue
-        key = f"{a.get('project_id')}/{agent}"
-        seen.add(key)
-        first = st.get(key)
-        if first is None:
-            st[key] = now  # start the uptime clock on first observation
-            continue
-        if (a.get("status") or "") in BUSY_STATUSES:
-            continue  # task boundary only — never mid-task
-        if (now - first) >= float(value) * 3600.0:
-            _log(f"RECYCLE {proj}/{agent} (uptime {(now-first)/3600:.1f}h >= {value}h)")
-            # Server-authorized clean-exit (task 548c863e, mig 364): SIGNAL the
-            # recycle instead of spawning. A direct _spawn_agent here duplicates
-            # the still-alive process. mc_request_recycle sets a flag; the
-            # agent's wait-loop consumes it, returns must_exit/reason=recycle,
-            # exits CLEAN (Stop-hook writes the handoff), then the respawn path
-            # (_do_respawns) relaunches it fresh. Recorded via mc_record_recycle
-            # so it's NEVER counted against the crash respawn cap.
-            req = _rpc("mc_request_recycle",
-                       {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
-            if req and req.get("ok") and req.get("requested"):
-                _rpc("mc_record_recycle",
-                     {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
-                st[key] = now  # reset clock after signaling recycle
-                n += 1
-            elif req and req.get("ok") and not req.get("requested"):
-                # Agent flipped busy between the roster read and the request —
-                # skip; retry next sweep at the next task boundary.
-                _log(f"SKIP recycle {proj}/{agent}: {req.get('reason','not_requested')}")
-    # prune state for agents no longer managed on this host
-    for k in [k for k in st if k not in seen]:
-        st.pop(k, None)
-    _save_state(st)
-    return n
 
 
 # ------------------------------------------------------------------
@@ -2502,10 +2431,6 @@ def _hostd_bootstrap(verbose: bool = False) -> bool:
         return False
 
 
-# a69ac010-C: after this many version-recycles at the SAME cv with no advance, STOP (env won't converge).
-_VERREC_MAX_ATTEMPTS = 3
-
-
 def _do_version_recycles(api_key: str, host_id: str) -> int:
     """Recycle managed agents running an OLDER meshcode than what's installed on disk so they pick up
     the auto-updated version (task 14782bb4 D). GRACIOUS (guardrail #5): idle-only (NEVER a BUSY agent /
@@ -2516,77 +2441,6 @@ def _do_version_recycles(api_key: str, host_id: str) -> int:
     # This was the env-mismatch storm source; fixed-at-source via run_agent env-sync, but the
     # whole recycle feature is being removed per owner. Crash-RESPAWN is unaffected.
     return 0
-    cfg = _rpc("mc_host_config_get", {"p_api_key": api_key, "p_host_id": host_id})
-    if not cfg or not cfg.get("ok"):
-        return 0
-    try:
-        from meshcode import self_update as _su
-        disk = _su._current_version()
-    except Exception:
-        return 0
-    if not disk:
-        return 0
-    st = _load_state()
-    now = time.time()
-    n = 0
-    for a in cfg.get("agents", []):
-        if a.get("desired_state") != "running":
-            continue
-        cv = a.get("cli_version")
-        if not cv:
-            continue
-        try:
-            if not _su._is_newer(disk, cv):
-                continue  # agent already on the on-disk version (or newer) — nothing to do
-        except Exception:
-            continue
-        if _agent_connected(a):
-            continue  # Samuel rule: never version-recycle a CONNECTED agent (live MCP session,
-                      # even if idle/standby) — the >3h uptime lifecycle (_do_recycles) is the
-                      # only recycle that may touch a connected agent.
-        proj, agent = a.get("project_name"), a.get("name")
-        if not proj or not agent:
-            continue
-        if _recycle_blocked(st, f"{proj}/{agent}", now):
-            continue  # 451d33a0 unify: already blocked as a non-converging recycle — don't also version-recycle it
-        key = f"verrec/{a.get('project_id')}/{agent}"
-        if now - float(st.get(key, 0) or 0) < 1800:
-            continue  # rate-limit: <=1 version-recycle per agent / 30min (no recycle-storm)
-        # a69ac010-C CONVERGENCE GUARD: if we've already version-recycled this agent _VERREC_MAX_ATTEMPTS
-        # times at THIS exact cv and it never advanced, the agent's spawn env is OLDER than hostd's disk
-        # and recycling will NEVER converge (respawn pulls the same stale env -> same cv -> recycle again).
-        # STOP + alert ONCE instead of version-recycling every 30min forever (the env-mismatch storm RC).
-        conv_key = f"verrec_conv/{a.get('project_id')}/{agent}"
-        conv = dict(st.get(conv_key) or {})
-        if conv.get("cv") == cv and int(conv.get("count", 0)) >= _VERREC_MAX_ATTEMPTS:
-            if not conv.get("alerted"):
-                conv["alerted"] = True
-                st[conv_key] = conv
-                _save_state(st)
-                _log(f"VERSION-RECYCLE STUCK {proj}/{agent}: still {cv} after {conv['count']} recycles "
-                     f"(disk {disk}); spawn env older than hostd — align it (e.g. "
-                     f"~/meshcode-env/bin/pip install -U meshcode). BLOCKING further version-recycles "
-                     f"until cv advances. [recycle_blocked_reason=version_no_converge]")
-            continue
-        req = _rpc("mc_request_recycle",
-                   {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
-        if req and req.get("ok") and req.get("requested"):
-            _rpc("mc_record_recycle",
-                 {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
-            st[key] = now
-            # advance convergence counter for THIS cv; a cv change (env fixed) resets + releases the guard.
-            if conv.get("cv") == cv:
-                conv["count"] = int(conv.get("count", 0)) + 1
-            else:
-                conv = {"cv": cv, "count": 1}
-            conv["alerted"] = False
-            st[conv_key] = conv
-            n += 1
-            _log(f"VERSION-RECYCLE {proj}/{agent}: running {cv} < disk {disk} — recycle at idle to update "
-                 f"(attempt {conv['count']}/{_VERREC_MAX_ATTEMPTS})")
-    if n:
-        _save_state(st)
-    return n
 
 
 # c301be69: hold the singleton lock handle for the daemon's lifetime — module

{meshcode-2.11.133 → meshcode-2.11.135}/meshcode/meshcode_mcp/backend.py

@@ -907,16 +907,21 @@ def take_memory_hints() -> List[Dict]:
     return out
 
 
-def read_inbox(project_id: str, agent: str, mark_read: bool = True, api_key: Optional[str] = None) -> List[Dict]:
-    # Use SECURITY DEFINER RPC when api_key is available (bypasses RLS safely)
+def read_inbox(project_id: str, agent: str, mark_read: bool = True, api_key: Optional[str] = None,
+               rpc_result: Optional[Dict] = None) -> List[Dict]:
+    # Use SECURITY DEFINER RPC when api_key is available (bypasses RLS safely).
+    # rpc_result (mig 521 wait-drain): a pre-fetched mc_read_inbox payload (the
+    # 'inbox' field of mc_wait_poll v5). When given, skip the RPC and run the
+    # identical post-process (decrypt, memory_hints, ack) on it.
     global _LAST_MEMORY_HINTS
     if api_key:
-        rpc_result = sb_rpc("mc_read_inbox", {
-            "p_api_key": api_key,
-            "p_project_id": project_id,
-            "p_agent_name": agent,
-            "p_mark_read": mark_read,
-        })
+        if rpc_result is None:
+            rpc_result = sb_rpc("mc_read_inbox", {
+                "p_api_key": api_key,
+                "p_project_id": project_id,
+                "p_agent_name": agent,
+                "p_mark_read": mark_read,
+            })
         if isinstance(rpc_result, dict) and rpc_result.get("ok"):
             # mig 220: stash memory_hints so the calling tool can attach
             # them to its response. Reset on every call so stale hints
@@ -1389,6 +1394,22 @@ def task_complete(api_key, project_id, task_id, completing_agent, summary=""):
     })
 
 
+def task_progress(api_key, project_id, task_id, pct, note=None):
+    """Report real progress pct (0-100) on a claimed/in_progress/in_review task.
+
+    Server-side: public.mc_task_progress (mig 516) — claim-holder or owner;
+    updates progress_pct/note/last_progress_at, extends the claim lease 4h,
+    appends to deliverables.progress_log. The dashboard pbar reads this as
+    progress_source='reported' (task 6b2afa5d: pbar accuracy)."""
+    return sb_rpc("mc_task_progress", {
+        "p_api_key": api_key,
+        "p_project_id": project_id,
+        "p_task_id": task_id,
+        "p_pct": pct,
+        "p_note": note,
+    })
+
+
 def feature_flag_enabled(api_key, flag_name):
     """Agent-facing feature-flag check (mig478). The FE's mc_check_feature_flag
     is auth.uid()-only, so agents use this api-key variant. Returns the raw

{meshcode-2.11.133 → meshcode-2.11.135}/meshcode/meshcode_mcp/server.py

@@ -3665,6 +3665,11 @@ def _wait_poll_or_legacy() -> Dict[str, Any]:
                 "p_api_key": api_key,
                 "p_project_id": _PROJECT_ID,
                 "p_agent_name": AGENT_NAME,
+                # wait-loop fase 2 (proposal 0bd63160, mig 521): the server
+                # folds read_inbox INTO the poll when there is pending mail —
+                # a message-carrying cycle is 1 RPC instead of 2. mc_wait_poll
+                # v5 (5-arg, default false) serves old SDKs unchanged.
+                "p_drain_inbox": True,
             })
             if isinstance(resp, dict) and resp.get("ok"):
                 return {
@@ -3677,6 +3682,9 @@ def _wait_poll_or_legacy() -> Dict[str, Any]:
                     # Surface it so the caller folds that RPC away. None on
                     # the legacy path = caller must count_pending itself.
                     "pending_count": resp.get("pending_count"),
+                    # mig 521: pre-drained mc_read_inbox result (same shape the
+                    # RPC returns) — present only when pending_count>0.
+                    "inbox": resp.get("inbox"),
                     "_via": "mc_wait_poll",
                 }
     except Exception as e:
@@ -3687,21 +3695,30 @@ def _wait_poll_or_legacy() -> Dict[str, Any]:
         "stop": _check_stop_request(),
         "tasks": _get_pending_tasks_summary(),
         "pending_count": None,
+        "inbox": None,
         "_via": "legacy",
     }
 
 
-def _drain_unread_response(include_acks: bool) -> Optional[Dict[str, Any]]:
+def _drain_unread_response(include_acks: bool,
+                           rpc_result: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
     """SDK-EFF (task ab1f9f5a): read+mark unread DB messages and shape them as
     a wait response. Extracted from the inner-loop's old final-fallback tail so
     the outer loop can invoke it only when mc_wait_poll reports pending_count>0
     (was: an unconditional count_pending every idle cycle). Returns None when
-    nothing real (acks only / already seen) was found."""
+    nothing real (acks only / already seen) was found.
+
+    rpc_result (mig 521, proposal 0bd63160): pre-drained mc_read_inbox payload
+    embedded in the mc_wait_poll v5 response ('inbox' key). When given, NO
+    read_inbox RPC fires — backend.read_inbox still runs its full post-process
+    (decrypt, memory_hints, ack) on the embedded payload, so semantics are
+    byte-identical to the 2-RPC path."""
     try:
         api_key = _get_api_key()
         if not api_key:
             return None
-        raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=api_key)
+        raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=api_key,
+                            rpc_result=rpc_result)
         if not raw:
             return None
         msgs = [
@@ -4591,7 +4608,10 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                     except Exception:
                         _db_pending = 0
                 if _db_pending > 0:
-                    _drained = _drain_unread_response(include_acks)
+                    # mig 521: the poll already drained the inbox server-side
+                    # (1 RPC); pass it through. None => classic read_inbox RPC.
+                    _drained = _drain_unread_response(include_acks,
+                                                      rpc_result=_wp.get("inbox"))
                     if _drained:
                         result = _drained
                         _set_state("online", "")
@@ -5348,6 +5368,64 @@ def meshcode_tasks(status_filter: Optional[str] = None, verbose: bool = False) -
     return {"ok": True, "tasks": compact}
 
 
+def _auto_task_progress(task_id: str, pct: int, note: str) -> None:
+    """Best-effort lifecycle progress floor (task 6b2afa5d: pbar accuracy).
+
+    Writes pct via mc_task_progress (mig 516) ONLY if the task's current
+    reported pct is unknown or lower — a re-claimed task that was already at
+    60% must never get reset to the claim/start milestone. Swallows every
+    failure (RPC missing pre-mig-516, auth, state): the lifecycle action this
+    rides on must never be blocked by progress telemetry.
+    """
+    try:
+        api_key = _get_api_key()
+        if pct < 100:  # 100 is monotonic by definition — skip the read
+            listing = be.task_list(api_key, _PROJECT_ID, AGENT_NAME,
+                                   status_filter=None, include_done=False)
+            if isinstance(listing, dict) and listing.get("ok"):
+                for t in listing.get("tasks", []):
+                    if t.get("id") == task_id:
+                        current = t.get("progress_pct")
+                        if isinstance(current, int) and current >= pct:
+                            return  # real progress already reported — keep it
+                        break
+        be.task_progress(api_key, _PROJECT_ID, task_id, pct, note)
+    except Exception:
+        pass  # auto-progress is a fallback, never a dependency
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_task_progress(task_id: str, pct: int, note: str = "") -> Dict[str, Any]:
+    """Report REAL progress (0-100) on your claimed/in_progress task — feeds the dashboard pbar.
+
+    Samuel directive (250e131e / msg d88bb9c7): every in_progress task must
+    report advance at real milestones, not vibes. Call at meaningful points
+    (e.g. 10 on claim, 25-40 design done, 70 code+tests, 90 smoke green).
+    Server-side mc_task_progress (mig 516) also extends your claim lease 4h
+    and appends {ts, by, pct, note} to deliverables.progress_log.
+
+    Args:
+        task_id: task you hold the claim on (UUID or 8-char prefix NOT
+            accepted — pass the full UUID).
+        pct: integer 0-100. Monotonicity is NOT enforced — you can correct
+            an overestimate downward.
+        note: short human-readable milestone (shows in the panel tooltip).
+    """
+    if not isinstance(pct, int) or pct < 0 or pct > 100:
+        return {"ok": False, "error": "pct must be an integer 0-100",
+                "error_code": "invalid_arg"}
+    api_key = _get_api_key()
+    result = be.task_progress(api_key, _PROJECT_ID, task_id, pct, note or None)
+    if isinstance(result, dict) and result.get("error"):
+        err = result.get("error")
+        msg = err.get("message", "") if isinstance(err, dict) else str(err)
+        if "Could not find the function" in msg or "PGRST202" in msg:
+            return {"ok": False, "error_code": "rpc_missing",
+                    "error": "mc_task_progress RPC not deployed (mig 516 not applied) — progress not recorded, work unaffected"}
+    return result
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_task_claim(task_id: str) -> Dict[str, Any]:
@@ -5368,6 +5446,8 @@ def meshcode_task_claim(task_id: str) -> Dict[str, Any]:
                           api_key=api_key)
         except Exception:
             pass  # status surfacing is best-effort
+        # pbar accuracy fallback (task 6b2afa5d): claim = at least 10%
+        _auto_task_progress(resp.get("task_id") or task_id, 10, "auto: claimed")
     return resp
 
 
@@ -5399,6 +5479,10 @@ def meshcode_task_complete(task_id: str, summary: str = "", force: bool = False)
                     }
         except Exception:
             pass  # Best-effort check; don't block on listing failure.
+    # pbar accuracy (task 6b2afa5d): stamp 100 BEFORE complete — mc_task_progress
+    # only accepts claimed/in_progress/in_review, so post-complete is too late,
+    # and a done task otherwise freezes at its last reported pct on the panel.
+    _auto_task_progress(task_id, 100, "auto: completed")
     result = be.task_complete(api_key, _PROJECT_ID, task_id, AGENT_NAME, summary=summary)
     # Task data persists in the task system — do NOT duplicate to memory.
     # Samuel: "los tasks no deben guardarse en memoria, para eso salen en tasks"
@@ -5428,12 +5512,16 @@ def meshcode_task_complete(task_id: str, summary: str = "", force: bool = False)
 def meshcode_task_start(task_id: str) -> Dict[str, Any]:
     """Flip a claimed task to in_progress (mig 349 invariant: one in_progress per agent — any sibling in_progress for this agent is demoted to 'claimed' atomically)."""
     api_key = _get_api_key()
-    return be.sb_rpc("mc_task_start", {
+    result = be.sb_rpc("mc_task_start", {
         "p_api_key": api_key,
         "p_project_id": _PROJECT_ID,
         "p_task_id": task_id,
         "p_starting_agent": AGENT_NAME,
     })
+    if isinstance(result, dict) and result.get("ok"):
+        # pbar accuracy fallback (task 6b2afa5d): started = at least 25%
+        _auto_task_progress(task_id, 25, "auto: started")
+    return result
 
 
 @mcp.tool()

{meshcode-2.11.133 → meshcode-2.11.135}/meshcode/rpc_allowlist.py

@@ -31,6 +31,7 @@ AGENT_CALLABLE_RPCS = [
     "mc_task_reject",
     "mc_task_approve",
     "mc_task_search",
+    "mc_task_progress",         # mig 516 — pbar accuracy (task 6b2afa5d)
     "mc_task_reschedule",       # mig 330
     "mc_task_get_deps",         # mig 330
     "mc_tasks_due_soon",        # mig 329

{meshcode-2.11.133 → meshcode-2.11.135}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.133 → meshcode-2.11.135}/meshcode.egg-info/SOURCES.txt

@@ -95,5 +95,6 @@ tests/test_status_enum_coverage.py
 tests/test_stay_on_loop_hook.py
 tests/test_stop_ghost_terminal.py
 tests/test_swarm_events.py
+tests/test_task_progress.py
 tests/test_terminal_lifecycle.py
 tests/test_wait_open_tasks_contradiction.py

{meshcode-2.11.133 → meshcode-2.11.135}/pyproject.toml

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

meshcode-2.11.135/tests/test_task_progress.py

@@ -0,0 +1,147 @@
+"""Tests for the pbar-accuracy wheel half (task 6b2afa5d).
+
+Samuel (msg d88bb9c7): "la barra de progreso no es accurate". Root cause:
+mig 516 shipped the server-side RPC public.mc_task_progress, but the wheel
+MCP never exposed a wrapper (QA msg ba932abc) — agents physically could not
+report real pct, so the panel pbar showed elapsed-time guesses or froze.
+
+This file asserts the contract of the fix:
+  1. backend.task_progress maps args to the mig-516 RPC signature.
+  2. server.py exposes the meshcode_task_progress MCP tool.
+  3. Lifecycle auto-progress fallback exists: claim->10, start->25,
+     complete->100 — all routed through _auto_task_progress, which is
+     monotonic-guarded (never resets a re-claimed 60% task to 10%) and
+     best-effort (never blocks the lifecycle action).
+  4. The complete->100 stamp happens BEFORE be.task_complete in source
+     order (mc_task_progress refuses status='done', so after is too late).
+  5. mc_task_progress is on the agent-callable RPC allowlist.
+
+server.py has module-level side effects requiring live Supabase, so the
+server-side assertions are static (source/AST) — same pattern as
+test_wait_open_tasks_contradiction.py. backend.py imports clean, so the
+param-mapping test runs the real function with sb_rpc monkeypatched.
+"""
+
+from __future__ import annotations
+
+import unittest
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parent.parent
+SERVER_PY = REPO / "meshcode" / "meshcode_mcp" / "server.py"
+
+
+class TestBackendTaskProgress(unittest.TestCase):
+    """backend.task_progress → mc_task_progress param mapping (mocked RPC)."""
+
+    def test_param_mapping_matches_mig_516_signature(self):
+        from meshcode.meshcode_mcp import backend as be
+        captured = {}
+
+        def fake_rpc(fn_name, params, **kw):
+            captured["fn"] = fn_name
+            captured["params"] = params
+            return {"ok": True, "task_id": params["p_task_id"], "progress_pct": params["p_pct"]}
+
+        orig = be.sb_rpc
+        be.sb_rpc = fake_rpc
+        try:
+            out = be.task_progress("key-x", "proj-1", "task-1", 40, "mitad")
+        finally:
+            be.sb_rpc = orig
+
+        self.assertEqual(captured["fn"], "mc_task_progress")
+        self.assertEqual(captured["params"], {
+            "p_api_key": "key-x",
+            "p_project_id": "proj-1",
+            "p_task_id": "task-1",
+            "p_pct": 40,
+            "p_note": "mitad",
+        })
+        self.assertTrue(out["ok"])
+
+    def test_note_defaults_to_none(self):
+        from meshcode.meshcode_mcp import backend as be
+        captured = {}
+
+        def fake_rpc(fn_name, params, **kw):
+            captured["params"] = params
+            return {"ok": True}
+
+        orig = be.sb_rpc
+        be.sb_rpc = fake_rpc
+        try:
+            be.task_progress("k", "p", "t", 70)
+        finally:
+            be.sb_rpc = orig
+        self.assertIsNone(captured["params"]["p_note"])
+
+
+class TestServerWiring(unittest.TestCase):
+    """Static assertions on server.py — tool + lifecycle hooks."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.src = SERVER_PY.read_text(encoding="utf-8")
+
+    def test_tool_exposed(self):
+        self.assertIn("def meshcode_task_progress(", self.src,
+                      "wheel must expose the meshcode_task_progress MCP tool "
+                      "(the missing wrapper WAS the bug — QA msg ba932abc)")
+
+    def test_tool_validates_pct_client_side(self):
+        body = self._fn_body("def meshcode_task_progress(")
+        self.assertIn("pct must be an integer 0-100", body,
+                      "tool must reject bad pct before burning an RPC")
+
+    def test_auto_progress_helper_exists_and_is_guarded(self):
+        self.assertIn("def _auto_task_progress(", self.src)
+        body = self._fn_body("def _auto_task_progress(")
+        self.assertIn("current >= pct", body,
+                      "monotonic guard: a re-claimed task at 60% must not be "
+                      "reset to the 10/25 lifecycle floor")
+        self.assertIn("except Exception", body,
+                      "auto-progress must swallow all failures — it is a "
+                      "fallback, never a dependency")
+
+    def test_lifecycle_hooks_present(self):
+        self.assertIn('"auto: claimed"', self.src, "claim → 10 hook missing")
+        self.assertIn('"auto: started"', self.src, "start → 25 hook missing")
+        self.assertIn('"auto: completed"', self.src, "complete → 100 hook missing")
+
+    def test_complete_stamps_100_before_rpc(self):
+        # mc_task_progress refuses status='done' — the 100 stamp must come
+        # BEFORE be.task_complete in meshcode_task_complete's body.
+        body = self._fn_body("def meshcode_task_complete(")
+        idx_stamp = body.find('_auto_task_progress(task_id, 100')
+        idx_complete = body.find("be.task_complete(")
+        self.assertGreater(idx_stamp, 0, "complete must stamp 100")
+        self.assertGreater(idx_complete, idx_stamp,
+                           "100 stamp must precede be.task_complete — after "
+                           "complete the task is 'done' and the RPC refuses")
+
+    def test_task_marker_present(self):
+        self.assertIn("6b2afa5d", self.src,
+                      "code must reference the task id for future git-blame")
+
+    def _fn_body(self, needle: str) -> str:
+        start = self.src.find(needle)
+        assert start > 0, f"{needle!r} not found"
+        # body ends at the next top-level decorator/def
+        end = self.src.find("\n@mcp.tool()", start)
+        if end < 0:
+            end = self.src.find("\ndef ", start + 1)
+        return self.src[start:end if end > 0 else len(self.src)]
+
+
+class TestAllowlist(unittest.TestCase):
+
+    def test_mc_task_progress_on_allowlist(self):
+        from meshcode.rpc_allowlist import AGENT_CALLABLE_RPCS
+        self.assertIn("mc_task_progress", AGENT_CALLABLE_RPCS,
+                      "mig 516 grants it to anon — the allowlist is the "
+                      "single source of truth and must agree")
+
+
+if __name__ == "__main__":
+    unittest.main()