meshcode 2.11.37__tar.gz → 2.11.38__tar.gz

{meshcode-2.11.37 → meshcode-2.11.38}/PKG-INFO

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

{meshcode-2.11.37 → meshcode-2.11.38}/meshcode/__init__.py

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

{meshcode-2.11.37 → meshcode-2.11.38}/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 — race with previous process's own shutdown
+        pass  # already dead after SIGTERM (rare — handler ignores it)
     if old_instance_id:
         _release_lease_for_instance(old_instance_id, reason="post-sigkill")
     else:
@@ -1646,6 +1646,8 @@ def _build_instructions() -> str:
 
 RULES: MCP tools only. Tasks > messages. Messages <100 tokens (long → task). No empty acks, JSON only. Thread via in_reply_to. sensitive=True for secrets. Sync vs async: for turn-based/shared-state work (chess, lock-step, "who goes first"), use meshcode_call (sync RPC, 30s) — async meshcode_send crosses ~50%/turn between same-model agents and yields-pongs.
 
+CLOSE TASKS IMMEDIATELY (#2 rule, sammybenu 2026-05-22T21:06Z): every time you finish/ship/deliver work for a claimed task, call meshcode_task_complete BEFORE re-entering wait. NO "I'll close it after one more thing." NO leaving claimed tasks lingering in_progress while you do something else — that creates phantom in-progress on the dashboard and the human gets angry. If the work needs human review, set requires_approval=true at task_create OR call meshcode_task_complete (it routes to in_review if reviewer set). The mesh dashboard reflects mc_tasks.status in real-time; stale in_progress = lying to the human.
+
 SESSION START (run NOW, don't wait for input). If tool schemas are deferred:
   ToolSearch(query="select:meshcode_set_status,meshcode_check,meshcode_tasks,meshcode_auto_wake,meshcode_status,meshcode_wait,meshcode_send,meshcode_call,meshcode_claim,meshcode_task_claim,meshcode_task_complete,meshcode_remember,meshcode_recall")
 Then: set_status(online,ready) → check() → tasks() → auto_wake() → status() → wait(). Don't ask user "what to work on" — the mesh tells you.
@@ -2835,36 +2837,10 @@ def meshcode_send(to: Union[str, List[str]], message: Any, in_reply_to: Optional
             result["encrypted"] = True
         return result
 
-    _result = be.send_message(_PROJECT_ID, AGENT_NAME, to, payload,
-                              msg_type=type or "msg",
-                              parent_msg_id=in_reply_to, sensitive=sensitive,
-                              api_key=_get_api_key(), encrypted=encrypted)
-
-    # C2 (BACKEND-AUDIT-TASK-FRICTION F4, 2026-05-22): detect payloads that
-    # look like the agent is trying to "claim" a task via a status message
-    # instead of calling meshcode_task_claim. The status_msg path does NOT
-    # update mc_tasks.claimed_by → task sits open while the agent believes
-    # it's working it. Soft hint, never refuse.
-    try:
-        if isinstance(_result, dict) and _result.get("sent"):
-            _ptype = str(payload.get("type", "")).lower()
-            _ptext = str(payload.get("text", "")).lower()
-            _has_task_ref = any(k in payload for k in ("task", "task_id"))
-            _looks_like_claim = (
-                _ptype in {"claim", "claim_status", "status_claim"}
-                or ("claim" in _ptext and _has_task_ref)
-                or (_ptype.startswith("status") and "claim" in _ptext)
-            )
-            if _looks_like_claim:
-                _result["hint"] = (
-                    "claim_via_status_msg_does_not_update_task_table — "
-                    "call meshcode_task_claim(<task_id>) for the actual "
-                    "claim. status_msg is fine as a peer notification "
-                    "but is not the system-of-record."
-                )
-    except Exception:
-        pass
-    return _result
+    return be.send_message(_PROJECT_ID, AGENT_NAME, to, payload,
+                           msg_type=type or "msg",
+                           parent_msg_id=in_reply_to, sensitive=sensitive,
+                           api_key=_get_api_key(), encrypted=encrypted)
 
 
 @mcp.tool()
@@ -3262,14 +3238,6 @@ _AUTO_SLEEP_THRESHOLD = int(os.environ.get("MESHCODE_AUTO_SLEEP_SECONDS", "600")
 _STAY_AWAKE = False  # Set by meshcode_set_status("online") — prevents auto-sleep
 _LAST_SEEN_TS: Optional[str] = None  # auto-persisted for message dedup
 
-# M2 (SUPABASE-PROD-QUOTA-CRITICAL 2026-05-22): when an agent has been idle
-# longer than _M2_IDLE_THRESHOLD seconds, skip the per-tick mc_tasks poll on
-# (n-1)/n of timeouts — effective task-poll rate drops 1/N. Cuts mc_tasks
-# RPC volume which accounted for ~26.95M cumulative calls in the audit.
-_M2_IDLE_THRESHOLD = int(os.environ.get("MESHCODE_WAIT_IDLE_TASK_POLL_SKIP", "300"))  # secs
-_M2_POLL_EVERY_N  = int(os.environ.get("MESHCODE_WAIT_IDLE_POLL_EVERY_N", "3"))
-_M2_TICK_COUNTER = 0
-
 # Hydrate _LAST_SEEN_TS from mesh memory on boot so restarts skip old messages
 try:
     _ls_result = be.sb_rpc("mc_memory_get", {
@@ -3333,83 +3301,6 @@ 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.
 
@@ -3451,6 +3342,53 @@ def _try_auto_claim_task() -> Optional[Dict[str, str]]:
     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
+# the common case (rapid wait cycles) doesn't hammer the roster RPC.
+_LAST_ROSTER_SNAPSHOT: Optional[List[Dict[str, Any]]] = None
+_LAST_ROSTER_SNAPSHOT_TS: float = 0.0
+
+
+def _get_mesh_online_snapshot(max_age_s: float = 10.0) -> Optional[List[Dict[str, Any]]]:
+    global _LAST_ROSTER_SNAPSHOT, _LAST_ROSTER_SNAPSHOT_TS
+    now_ts = _time.monotonic()
+    if _LAST_ROSTER_SNAPSHOT is not None and (now_ts - _LAST_ROSTER_SNAPSHOT_TS) < max_age_s:
+        return _LAST_ROSTER_SNAPSHOT
+    try:
+        api_key = _get_api_key()
+        if not api_key:
+            return None
+        roster = be.sb_rpc("mc_roster_live", {
+            "p_api_key": api_key,
+            "p_project_id": _PROJECT_ID,
+        })
+        if not isinstance(roster, dict) or not roster.get("ok"):
+            return None
+        by_lane = (roster.get("roster") or {}).get("by_lane") or {}
+        out: List[Dict[str, Any]] = []
+        for lane, bucket in by_lane.items():
+            if not isinstance(bucket, dict):
+                continue
+            for liveness in ("live", "idle"):
+                for a in bucket.get(liveness) or []:
+                    if not isinstance(a, dict):
+                        continue
+                    out.append({
+                        "name": a.get("name"),
+                        "status": a.get("status"),
+                        "lane": lane,
+                        "last_heartbeat_age_s": a.get("hb_age_s"),
+                    })
+        out.sort(key=lambda x: (x.get("lane") or "", x.get("name") or ""))
+        _LAST_ROSTER_SNAPSHOT = out
+        _LAST_ROSTER_SNAPSHOT_TS = now_ts
+        return out
+    except Exception as e:
+        log.debug(f"[meshcode] mesh_online_snapshot fetch failed: {e}")
+        return None
+
+
 @mcp.tool()
 @with_working_status
 async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -> Dict[str, Any]:
@@ -3516,7 +3454,12 @@ 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 _attach_pending_tasks_to_resp(resp)
+                    # AGENT-INTEL-1-PY: snapshot on refused-path too.
+                    if os.environ.get("MESHCODE_WAIT_NO_SNAPSHOT", "").lower() not in ("1", "true", "yes"):
+                        _snap = _get_mesh_online_snapshot()
+                        if _snap is not None:
+                            resp["mesh_online_snapshot"] = _snap
+                    return resp
                 # Ack-only batch — fall through to wait loop
     except Exception:
         pass
@@ -3549,16 +3492,8 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
             if result.get("timed_out"):
                 _CONSECUTIVE_IDLE_SECONDS += capped_timeout
 
-                # M2 (2026-05-22): when idle >5min, poll mc_tasks every Nth
-                # tick instead of every tick. Active agents (recent msg)
-                # keep checking every tick.
-                global _M2_TICK_COUNTER
-                _check_tasks = True
-                if _CONSECUTIVE_IDLE_SECONDS >= _M2_IDLE_THRESHOLD and _M2_POLL_EVERY_N > 1:
-                    _M2_TICK_COUNTER = (_M2_TICK_COUNTER + 1) % _M2_POLL_EVERY_N
-                    _check_tasks = (_M2_TICK_COUNTER == 0)
                 # Check if new tasks appeared while we waited
-                pending_tasks = _get_pending_tasks_summary() if _check_tasks else None
+                pending_tasks = _get_pending_tasks_summary()
                 if pending_tasks:
                     result["pending_tasks"] = pending_tasks
                     break  # Return so agent can work tasks
@@ -3635,7 +3570,13 @@ 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 _attach_pending_tasks_to_resp(result) if isinstance(result, dict) else result
+        # AGENT-INTEL-1-PY: attach mesh_online_snapshot for situational
+        # awareness (cached 10s). Env opt-out: MESHCODE_WAIT_NO_SNAPSHOT=1.
+        if isinstance(result, dict) and os.environ.get("MESHCODE_WAIT_NO_SNAPSHOT", "").lower() not in ("1", "true", "yes"):
+            _snapshot = _get_mesh_online_snapshot()
+            if _snapshot is not None:
+                result["mesh_online_snapshot"] = _snapshot
+        return result
     finally:
         _IN_WAIT = False
 
@@ -4073,18 +4014,13 @@ def meshcode_set_status(status: str, task: str = "") -> Dict[str, Any]:
         task: Optional human-readable task description.
     """
     global _STAY_AWAKE, _CONSECUTIVE_IDLE_SECONDS
-    # PRODUCT RULE: Cannot sleep/idle/standby with ANY open tasks (claimed
-    # or just assigned). Samuel directive 2026-05-22T01:01Z confirmed the
-    # strict rule is intentional — agents MUST work their assigned queue
-    # before sleeping. Reverting the 2026-05-22T00:55Z "claimed-only" relax
-    # (2.11.34) per Samuel's correction. The wake-cron is BACKUP for
-    # disconnected sessions, NOT a license to sleep on assignments.
+    # PRODUCT RULE: Cannot sleep/idle/standby with open tasks. Work first.
     if status in ("sleeping", "idle", "standby"):
         pending_tasks = _get_pending_tasks_summary()
         if pending_tasks:
             return {
                 "refused": True,
-                "reason": f"Cannot set status '{status}' — you have {len(pending_tasks)} open task(s) assigned or claimed. Work them first (claim → progress → complete) or task_reject to release.",
+                "reason": f"Cannot set status '{status}' — you have {len(pending_tasks)} open tasks. Work them first.",
                 "pending_tasks": pending_tasks,
             }
     # Setting online/working = stay awake (prevent auto-sleep)
@@ -4173,24 +4109,11 @@ 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.37 → meshcode-2.11.38}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.37 → meshcode-2.11.38}/pyproject.toml

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