meshcode 2.11.133__tar.gz → 2.11.134__tar.gz

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

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

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

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

@@ -1389,6 +1389,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.134}/meshcode/meshcode_mcp/server.py

@@ -5348,6 +5348,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 +5426,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 +5459,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 +5492,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.134}/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.134}/meshcode.egg-info/PKG-INFO

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

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

meshcode-2.11.134/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()