meshcode 2.11.28__tar.gz → 2.11.32__tar.gz

{meshcode-2.11.28 → meshcode-2.11.32}/PKG-INFO

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

{meshcode-2.11.28 → meshcode-2.11.32}/meshcode/__init__.py

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

{meshcode-2.11.28 → meshcode-2.11.32}/meshcode/meshcode_mcp/server.py

@@ -227,18 +227,18 @@ def _kill_stale_mcp_process() -> None:
             _force_clear_lease_by_name(reason="legacy-lockfile-orphan")
         return
     _mc_log(f"Killing stale MCP process (PID {old_pid})")
+    # 2026-05-21 (Samuel directive RCA): the dying MCP server installs
+    # _diag_ignore for SIGTERM to keep the channel alive during tool
+    # cancellation (see run_server). SIGTERM is therefore always ignored
+    # by stale meshcode servers — sending it + sleeping 1s before SIGKILL
+    # was pure dead weight on the lifespan pre-yield critical path. Going
+    # straight to SIGKILL saves ~1s on every cold boot where a stale
+    # process exists. SIGKILL is uncatchable, so the kill is instant.
     try:
-        os.kill(old_pid, _signal.SIGTERM)
-    except OSError:
-        pass
-    import time
-    time.sleep(1)
-    try:
-        os.kill(old_pid, 0)
         os.kill(old_pid, _signal.SIGKILL)
         _mc_log(f"Force-killed stale MCP process (PID {old_pid})")
     except OSError:
-        pass  # already dead after SIGTERM (rare — handler ignores it)
+        pass  # already dead — race with previous process's own shutdown
     if old_instance_id:
         _release_lease_for_instance(old_instance_id, reason="post-sigkill")
     else:
@@ -3299,6 +3299,83 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
         return None
 
 
+def _check_task_dedupe(title: str, assignee: str) -> Optional[Dict[str, Any]]:
+    """Find an open/in_progress task with similar title + same assignee.
+
+    Samuel directive 2026-05-21T23:41Z (`commander_dedupe_before_task_from_status_msg`):
+    commanders kept creating duplicate tasks when reacting to status msgs from
+    agents that had already claimed/shipped the same work. The 5ac1d9fe /
+    dd41054d MOBILE-FIRST-3/4 dupes sat OPEN since 2026-05-20 because nobody
+    deduped before creating new ones. Server-side soft guard surfaces a
+    `dedupe_warning` in task_create responses when a likely duplicate
+    exists — non-blocking, so legitimate near-titles still create, but the
+    commander sees the dupe candidate and can cancel + reuse instead.
+    """
+    try:
+        api_key = _get_api_key()
+        if not api_key:
+            return None
+        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", [])
+        target = (title or "").strip().lower()
+        if not target:
+            return None
+        target_prefix = target[:40]
+        for t in tasks:
+            if t.get("status") not in ("open", "in_progress"):
+                continue
+            if t.get("assignee") != assignee:
+                continue
+            t_title = (t.get("title") or "").strip().lower()
+            if not t_title:
+                continue
+            t_prefix = t_title[:40]
+            match = None
+            if t_prefix == target_prefix:
+                match = "prefix-40"
+            elif target in t_title or t_title in target:
+                match = "substring"
+            if match:
+                return {
+                    "dupe_task_id": t.get("id"),
+                    "dupe_title": t.get("title"),
+                    "dupe_status": t.get("status"),
+                    "match_type": match,
+                }
+    except Exception:
+        pass
+    return None
+
+
+def _attach_pending_tasks_to_resp(resp: Dict[str, Any]) -> Dict[str, Any]:
+    """Surface this agent's open/in_progress assigned tasks on EVERY wait response.
+
+    Samuel directive 2026-05-21T23:54Z: agents must always advance open tasks.
+    Previously `pending_tasks` only appeared in the timeout branch; when
+    messages kept arriving the agent ping-ponged replies and never saw the
+    hint, so tasks piled up. Now: every wait response (refused-by-messages,
+    got_message, timeout) carries pending_tasks + pending_directive when
+    this agent has open work. The agent's instruction prompt treats the
+    directive as priority-1 over optional message replies.
+    """
+    try:
+        pending = _get_pending_tasks_summary()
+        if pending and isinstance(resp, dict):
+            resp["pending_tasks"] = pending
+            resp["pending_tasks_count"] = len(pending)
+            titles = ", ".join(t.get("title", "")[:40] for t in pending[:3])
+            resp["pending_directive"] = (
+                f"You have {len(pending)} open task(s) assigned. Advance at least one "
+                f"(claim / progress / complete) BEFORE processing optional messages or "
+                f"re-entering wait. Tasks: {titles}"
+            )
+    except Exception:
+        pass
+    return resp
+
+
 def _try_auto_claim_task() -> Optional[Dict[str, str]]:
     """Auto-claim the oldest open task matching this agent's role.
 
@@ -3405,7 +3482,7 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                     if split["done_signals"]:
                         resp["must_exit"] = True
                         resp["exit_reason"] = "sleep authorization received — set status=sleeping and end session"
-                    return resp
+                    return _attach_pending_tasks_to_resp(resp)
                 # Ack-only batch — fall through to wait loop
     except Exception:
         pass
@@ -3516,7 +3593,7 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
             result.setdefault("must_exit", True)
             result.setdefault("exit_reason",
                               "sleep authorization received — set status=sleeping and end session")
-        return result
+        return _attach_pending_tasks_to_resp(result) if isinstance(result, dict) else result
     finally:
         _IN_WAIT = False
 
@@ -4049,11 +4126,24 @@ def meshcode_task_create(title: str, description: str = "", assignee: Optional[s
         except Exception as _de:
             return {"error": f"due_parse_failed: {_de}"}
     api_key = _get_api_key()
+    # Soft dedupe guard (Samuel directive 2026-05-21): surface likely-duplicate
+    # open/in_progress task with same assignee + similar title. Non-blocking —
+    # caller still gets the new task_id, but sees `dedupe_warning` and can
+    # cancel + reuse the existing task instead of accumulating dupes.
+    dedupe_hit = _check_task_dedupe(title.strip(), assignee) if assignee != "auto" else None
     result = be.task_create(api_key, _PROJECT_ID, AGENT_NAME, title.strip(),
                            description=description, assignee=assignee,
                            priority=priority, parent_task_id=parent_task_id,
                            due_at=parsed_due_at, due_label=parsed_due_label,
                            depends_on=depends_on or None)
+    if isinstance(result, dict) and result.get("ok") and dedupe_hit:
+        result["dedupe_warning"] = (
+            f"Possible duplicate of task {dedupe_hit['dupe_task_id'][:8]} "
+            f"('{dedupe_hit['dupe_title'][:60]}', status={dedupe_hit['dupe_status']}, "
+            f"match={dedupe_hit['match_type']}). Consider canceling this new task "
+            f"and reusing the existing one."
+        )
+        result["dedupe_candidate"] = dedupe_hit
     # Auto-notify the resolved assignee so they wake from meshcode_wait.
     # Read result["assignee"] (server may have resolved 'auto' to a real name).
     if isinstance(result, dict) and result.get("ok"):

{meshcode-2.11.28 → meshcode-2.11.32}/meshcode/setup_clients.py

@@ -565,6 +565,46 @@ errors when the source actually broke. Lovable build then ships the
 broken bundle.
 
 **Why:** practiced manually for weeks; codify so new FE agents inherit.
+""",
+    "mobile-first-verify.md": """# /mobile-first-verify — 3-viewport check before task_complete
+
+Before calling `meshcode_task_complete` on any UI-touching task, run
+Playwright at three viewports and attach the result in the summary.
+
+Viewports (canonical):
+- iPhone SE     375 x 667
+- iPhone 15 Pro 390 x 844
+- iPad          768 x 1024
+
+Recipe (load `mcp__playwright__browser_*` via ToolSearch first):
+
+```
+for w,h in [(375,667),(390,844),(768,1024)]:
+    browser_resize(width=w, height=h)
+    browser_navigate(url=<route>)
+    browser_take_screenshot(filename=f"verify_{w}x{h}.png")
+    browser_console_messages()  # capture errors
+```
+
+Then `meshcode_task_complete(task_id, summary=<<EOF
+verified: 3-viewport playwright
+- 375x667: <path>
+- 390x844: <path>
+- 768x1024: <path>
+console_errors: <count or "none">
+EOF)`.
+
+If the task is backend-only (DDL, RPCs, RLS, hooks, scripts — no user
+surface), skip the playwright run but state `verified: backend-only,
+no UI surface` in the summary so the auditor knows it was considered.
+
+Reopen path: Samuel reviews; if visuals are broken he calls
+`meshcode_task_reject(task_id, feedback=...)` which reopens with
+review_feedback. No new RPC needed.
+
+**Why:** MOBILE-FIRST-2 + Samuel mobile directive. Catches mobile
+breakage at the agent before it reaches Samuel as a screenshot in
+chat. Pairs with `/playwright-self-test` which covers desktop only.
 """,
 }
 
@@ -764,6 +804,134 @@ incidents from rapid-fire publish without bundling.
 """,
 }
 
+# ============================================================
+# SKILLS-6 — mobile-qa role bundle (MOBILE-FIRST-5)
+# ============================================================
+# Parallel verify lane: while front-end/front-2 ship code, a mobile-qa
+# agent independently re-renders the affected route at 3 mobile/tablet
+# viewports, captures screenshots + console errors, and reports findings
+# back to the ship-er agent + commander. Removes verify-bottleneck from
+# the coding agents and gives Samuel a second pair of eyes on every
+# UI-touching commit.
+#
+# Agent type does NOT ship code. Pure verifier.
+_MOBILE_QA_SKILLS = {
+    "mobile-qa-boot-loop.md": """# /mobile-qa-boot-loop — verify-only agent boot workflow
+
+You are a mobile-qa agent. You DO NOT ship code. Your only job is to
+re-render UI changes that other agents shipped, at three viewports,
+and report what you see.
+
+Boot sequence (after the standard meshcode boot):
+
+1. `meshcode_tasks(status_filter="open")` filter assignee == this agent
+   OR title/description mentions `needs_mobile_qa` / `verify` / `qa`.
+2. For each candidate task: claim → fetch the route or commit referenced
+   → run `/viewports-3-recipe` → assemble `/mobile-qa-report-format` →
+   `meshcode_send` the report to the original ship-er (look at
+   parent_task_id chain or claimed_by on the parent task) AND to
+   commander.
+3. `meshcode_task_complete` with the report inlined in summary.
+
+If no verify tasks are queued: `meshcode_wait` and sit.
+
+DO NOT:
+- write code into `src/`
+- propose RPC / DDL changes
+- broadcast opinions about design
+
+DO:
+- screenshot + console + network requests
+- report objective signals: layout overflow, console errors, network
+  500s, missing assets
+
+**Why:** MOBILE-FIRST-5. Parallel verify lane keeps shipping agents
+unblocked while still catching mobile regressions before Samuel does.
+""",
+    "viewports-3-recipe.md": """# /viewports-3-recipe — canonical 3-viewport playwright run
+
+Three viewports, every time, in this order:
+
+| Device         |  Width | Height |
+|----------------|-------:|-------:|
+| iPhone SE      |    375 |    667 |
+| iPhone 15 Pro  |    390 |    844 |
+| iPad           |    768 |   1024 |
+
+Recipe (load `mcp__playwright__browser_*` via ToolSearch if deferred):
+
+```python
+for w, h in [(375, 667), (390, 844), (768, 1024)]:
+    browser_resize(width=w, height=h)
+    browser_navigate(url=<route>)
+    browser_wait_for(time=2)            # let layout settle
+    browser_take_screenshot(filename=f"mqa_{w}x{h}.png")
+    console = browser_console_messages()
+    network = browser_network_requests()
+    # capture: scrollWidth > clientWidth → horizontal overflow flag
+    overflow = browser_evaluate(
+        function="() => document.documentElement.scrollWidth > "
+                 "document.documentElement.clientWidth"
+    )
+```
+
+For each viewport collect:
+- screenshot path
+- console_messages count + first-3 errors verbatim
+- network_requests with status >= 400 (path + status)
+- horizontal_overflow: bool
+
+**Why:** standard viewports make reports comparable across days /
+across agents. Console + network + overflow are the cheap signals that
+catch ~80% of mobile regressions.
+""",
+    "mobile-qa-report-format.md": """# /mobile-qa-report-format — canonical report shape
+
+Report back to ship-er + commander in this exact JSON shape so consumers
+can parse without LLM cost:
+
+```json
+{
+  "type": "mobile_qa_report",
+  "parent_task_id": "<task that requested verify>",
+  "verified_commit": "<short sha>",
+  "route": "<path verified>",
+  "viewports": [
+    {
+      "label": "iPhone SE",
+      "size": "375x667",
+      "screenshot": "<abs path>",
+      "console_errors": 0,
+      "first_errors": [],
+      "network_4xx_5xx": [],
+      "horizontal_overflow": false
+    },
+    { "label": "iPhone 15 Pro", "size": "390x844", "...": "..." },
+    { "label": "iPad",          "size": "768x1024", "...": "..." }
+  ],
+  "verdict": "pass" | "fail" | "warn",
+  "fail_reasons": [],
+  "samuel_status_line": "mobile-qa: <route> OK on 3 viewports / FAIL on iPhone SE (horizontal overflow + 2 console errors)"
+}
+```
+
+Verdict rubric:
+- **pass**: 0 console_errors AND 0 network 4xx/5xx AND 0
+  horizontal_overflow on all 3 viewports.
+- **warn**: any viewport has 1-2 console_errors that are clearly
+  third-party (analytics, etc) AND no overflow.
+- **fail**: any console error from app code, any network 4xx/5xx, any
+  horizontal_overflow, OR layout clearly visually broken.
+
+`samuel_status_line` is the 1-line summary Samuel sees in his feed;
+make it actionable.
+
+**Why:** structured reports let the FE agents auto-handle warn/fail
+without commander intervention. Free-form text needs LLM parse on
+every consumer; JSON does not.
+""",
+}
+
 
 def _write_generic_skills_bundle(ws: Path, role: str = "") -> None:
     """Write skill bundles to {ws}/.claude/skills/.
@@ -789,6 +957,8 @@ def _write_generic_skills_bundle(ws: Path, role: str = "") -> None:
     elif role_norm in ("commander", "mesh-commander", "zylo-commander",
                        "bemate-commander"):
         role_bundle = _COMMANDER_SKILLS
+    elif role_norm in ("mobile-qa", "mobile_qa", "mobileqa", "mqa"):
+        role_bundle = _MOBILE_QA_SKILLS
 
     for fname, body in role_bundle.items():
         (skills_dir / fname).write_text(body, encoding="utf-8")
@@ -1004,6 +1174,44 @@ If `meshcode_wait()` times out, call it again with a 2× longer timeout (cap 180
 - Memory: `meshcode_remember(key, value)` for reusable learnings. Don't dump
   task summaries into memory — tasks already persist.
 
+## Mobile-first UI verification (before task_complete)
+
+Before calling `meshcode_task_complete` on ANY task that touches user-visible
+UI (routes, components, layouts, styles, mobile chrome), you MUST run
+Playwright at three viewports and attach the result in the completion summary.
+
+Viewports (canonical):
+- iPhone SE     375 x 667
+- iPhone 15 Pro 390 x 844
+- iPad          768 x 1024
+
+Workflow (uses `mcp__playwright__browser_*` — load via ToolSearch if deferred):
+
+1. For each viewport: `browser_resize` → `browser_navigate(<route>)` →
+   `browser_take_screenshot(filename="verify_<W>x<H>.png")` →
+   `browser_console_messages()`.
+2. Pass the three screenshot paths + console-error count in the
+   `summary` arg of `meshcode_task_complete`:
+
+   ```
+   verified: 3-viewport playwright
+   - 375x667: <path>
+   - 390x844: <path>
+   - 768x1024: <path>
+   console_errors: <count or "none">
+   ```
+
+3. Samuel reviews the summary. If visuals are broken he calls
+   `meshcode_task_reject(task_id, feedback=...)` which reopens the task with
+   `review_feedback`. No new RPC needed — uses the existing pipeline.
+
+If the task is backend-only (DDL, RPCs, RLS, hooks, scripts — no UI surface)
+the playwright run is skipped, but state `verified: backend-only, no UI
+surface` in the summary so the rule is acknowledged.
+
+**Why:** Samuel mobile directive (MOBILE-FIRST-2). Catches mobile breakage at
+the agent before it reaches Samuel as a screenshot in chat.
+
 ## When to use sync vs async
 
 | Pattern | Tool | Why |

{meshcode-2.11.28 → meshcode-2.11.32}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.28 → meshcode-2.11.32}/pyproject.toml

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