meshcode 2.11.105__tar.gz → 2.11.107__tar.gz

{meshcode-2.11.105 → meshcode-2.11.107}/PKG-INFO

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

{meshcode-2.11.105 → meshcode-2.11.107}/meshcode/__init__.py

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

{meshcode-2.11.105 → meshcode-2.11.107}/meshcode/hostd.py

@@ -801,6 +801,51 @@ def _do_stops(api_key: str, host_id: str) -> int:
     return n
 
 
+# 38523a98 Gap 1: explicit human force-kill of VISIBLE agents. DRY-RUN first (same gate as the reaper).
+_FORCE_KILL_DRYRUN = True
+
+
+def _do_force_kills(api_key: str, host_id: str) -> int:
+    """38523a98 Gap 1 — EXPLICIT human force-kill of VISIBLE agents. The user clicked Stop/Remove
+    (desired_state='stopped' via mc_agent_power) but the visible agent didn't close/self-exit -> kill its
+    process ('lo cerré y sigue ahí'). Reads mc_agents_to_force_kill (visible + stopped + alive; ONLY this
+    new hostd calls that RPC, old hostd ignores it -> the DDL is safe to apply ahead of the deploy). This
+    fires ONLY on an explicit human stop — the AUTONOMOUS reaper (_do_reap) NEVER touches visible. DRY-RUN
+    (log-only) until verified. Returns count killed (0 while dry-run)."""
+    res = _rpc("mc_agents_to_force_kill", {"p_api_key": api_key, "p_host_id": host_id})
+    if not res or not res.get("ok"):
+        return 0  # old DB without the RPC -> {} -> no-op
+    agents = res.get("agents") or []
+    if not agents:
+        return 0
+    st = _load_state()
+    pids = st.get("headless_pids") or {}
+    n = 0
+    for a in agents:
+        proj, agent = a.get("project_name"), a.get("agent")
+        if not proj or not agent:
+            continue
+        target = f"{proj}/{agent}"
+        # recorded PID first, else discover by cmdline (visible agents aren't always in headless_pids).
+        cands = []
+        if pids.get(target):
+            cands.append(pids.get(target))
+        cands += [p for p in _discover_agent_pids(target) if p not in cands]
+        for pid in cands:
+            if not pid:
+                continue
+            if _FORCE_KILL_DRYRUN:
+                _log(f"FORCE-KILL-DRYRUN {target}: WOULD kill visible pid {pid} (explicit human stop, "
+                     f"hb {a.get('heartbeat_age_s')}s) — log-only. Flip _FORCE_KILL_DRYRUN=False to enforce.")
+            elif _kill_headless_pid(target, pid):
+                pids.pop(target, None)
+                n += 1
+                _log(f"FORCE-KILL {target}: killed visible pid {pid} (explicit human stop)")
+    st["headless_pids"] = pids
+    _save_state(st)
+    return n
+
+
 # 38523a98 reaper. Commander guardrail #1: DRY-RUN FIRST — ship LOG-ONLY, confirm ZERO false positives in
 # the logs (REAP-DRYRUN lines), THEN flip _REAP_DRYRUN=False to actually kill. Protects against mis-killing
 # a live agent (Samuel's trauma). Guardrail #2: the orphan grace before reaping a stopped-but-alive zombie.
@@ -1518,11 +1563,12 @@ def cmd_hostd(args: list) -> int:
                         recycled = _do_recycles(api_key, host_id)
                         ver_recycled = _do_version_recycles(api_key, host_id)
                         stopped = _do_stops(api_key, host_id)
+                        force_killed = _do_force_kills(api_key, host_id)  # 38523a98 Gap1: visible explicit human stop
                         reaped = _do_reap(api_key, host_id)  # 38523a98: kill ghosts/dup-PIDs/crashed-orphans
                         _gc_headless_pids()  # cb90b058: drop dead PIDs (stale entry can't mask a live agent)
                         _up = int(time.monotonic() - _spawn_mono)
-                        if relaunched or recycled or ver_recycled or stopped or enforced or reaped:
-                            _log(f"sweep done (uptime={_up}s) — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled, {stopped} stopped, {enforced} recycle-enforced, {reaped} reaped")
+                        if relaunched or recycled or ver_recycled or stopped or enforced or reaped or force_killed:
+                            _log(f"sweep done (uptime={_up}s) — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled, {stopped} stopped, {force_killed} force-killed, {enforced} recycle-enforced, {reaped} reaped")
                         elif time.monotonic() - _last_alive_log >= 60:
                             _log(f"alive — uptime={_up}s")
                             _last_alive_log = time.monotonic()

{meshcode-2.11.105 → meshcode-2.11.107}/meshcode/meshcode_mcp/server.py

@@ -4030,14 +4030,36 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
     # legacy "no paraba hasta completar todos" cadence. Non-leader
     # agents only — leaders need to stay in wait to triage wildcard
     # tasks for the mesh.
-    if pending_tasks and not _is_leader_agent():
-        # Auto-start the highest priority claimed task so the agent
-        # sees it as in_progress and works it immediately. Samuel
-        # directive: "agents should claim and work right away one by one."
+    # DURABLE-NO-IDLE-SPIN (task 2adb1705): the task-pull short-circuit must
+    # only fire for tasks that still need STARTING (status 'open'). A task
+    # already in_progress by THIS agent means it has been started and is being
+    # worked — or is BLOCKED on an external gate (e.g. a missing credential).
+    # Re-emitting the pull every wait for an in_progress task is exactly the
+    # idle-spin that burned ~45min/148k tokens re-printing "holding". So we
+    # only short-circuit on _tasks_to_start; in_progress tasks fall through to
+    # the normal message-blocking wait (surfaced as a non-blocking reminder).
+    _tasks_to_start = [t for t in (pending_tasks or []) if t.get("status") == "open"]
+    _in_progress_mine = [t for t in (pending_tasks or []) if t.get("status") == "in_progress"]
+    # CHAT-DELIVERY-FIX (2026-06-04, Samuel "fix now"): message delivery MUST take
+    # priority over the task-pull short-circuit. Previously this block returned BEFORE
+    # PRODUCT RULE 2 (below), so any agent holding an OPEN task went DEAF to incoming
+    # messages — never read them, no blue check, the human's chat appeared broken
+    # ("te escribo y no sale palomita azul en nadie"). If there are unread messages,
+    # skip task_pull and fall through to PRODUCT RULE 2 so they get delivered + marked
+    # read first. Task-pull still fires normally when the inbox is empty.
+    _has_unread = False
+    try:
+        _has_unread = bool(be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key()))
+    except Exception:
+        _has_unread = False
+    if _tasks_to_start and not _is_leader_agent() and not _has_unread:
+        # Auto-start the highest priority OPEN task so the agent sees it as
+        # in_progress and works it immediately. Samuel directive: "agents
+        # should claim and work right away one by one."
         _auto_started = None
         _PRIO_ORDER = {"urgent": 0, "high": 1, "normal": 2, "low": 3}
         _sorted_pending = sorted(
-            pending_tasks,
+            _tasks_to_start,
             key=lambda t: (_PRIO_ORDER.get(t.get("priority", "normal"), 2), t.get("id", "")),
         )
         for _pt in _sorted_pending: