meshcode 2.11.114rc1__tar.gz → 2.11.115__tar.gz

{meshcode-2.11.114rc1 → meshcode-2.11.115}/PKG-INFO

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

{meshcode-2.11.114rc1 → meshcode-2.11.115}/meshcode/__init__.py

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

{meshcode-2.11.114rc1 → meshcode-2.11.115}/meshcode/hostd.py

@@ -816,32 +816,6 @@ def _pid_cmdline(pid: int) -> str:
         return ""
 
 
-def _pid_alive(pid: int) -> bool:
-    """True iff `pid` is a live process. Signal-0 probe on POSIX; tasklist on Windows.
-    Best-effort — on any unexpected error returns False (treat unknown as not-alive so
-    the ghost detector never mis-reports). PermissionError means the process exists but
-    isn't ours = alive; ProcessLookupError means dead."""
-    try:
-        pid = int(pid)
-        if pid <= 0:
-            return False
-        if sys.platform == "win32":
-            # /FO CSV so the pid is a quoted field — anchor on `"<pid>"` instead of a bare
-            # substring (a bare pid can match a memory/session column → false-positive).
-            out = subprocess.run(["tasklist", "/FI", f"PID eq {pid}", "/NH", "/FO", "CSV"],
-                                 capture_output=True, text=True, timeout=5).stdout or ""
-            return f'"{pid}"' in out
-        try:
-            os.kill(pid, 0)
-        except ProcessLookupError:
-            return False
-        except PermissionError:
-            return True
-        return True
-    except Exception:
-        return False
-
-
 def _discover_agent_pids(target: str) -> list:
     """Fallback PID discovery by command line, for agents spawned before this hostd
     (no recorded PID) or after a state-file loss. Matches `meshcode run <target>`.
@@ -1228,215 +1202,6 @@ def _do_recycle_enforce(api_key: str, host_id: str) -> int:
     return n
 
 
-# ------------------------------------------------------------------
-# FOCUS-1 GHOST SESSIONS (back-2, task 09fca8fe) — dead-MCP detector.
-#
-# OS-ghost = a `claude` agent process still ALIVE but its `meshcode_mcp serve`
-# child DEAD → no heartbeat → the dashboard shows it offline/invisible while a
-# terminal window is still open ("connected-but-invisible"). Two local pidfiles
-# correlate it, no roster RPC needed for detection:
-#   S3 claude alive — ~/.meshcode/pids/<project>__<agent>.pid, stamped by
-#      run_agent right before os.execvp (the pid survives exec => == claude pid).
-#   S2 mcp dead    — {tempdir}/meshcode_mcp_<project>_<agent>.pid, written by the
-#      MCP server (meshcode_mcp/server.py). If that pid is dead/missing, mcp died.
-# A ghost = S3 alive AND S2 dead. The eventual reap (kill the orphaned claude so
-# the respawn sweep relaunches it clean) ALSO needs S1 = the server's is_ghost /
-# effective_status='offline' (prod mc_agent_liveness) as a third independent
-# guard, plus the cmdline reuse-guard — wired when arming.
-#
-# SHIPS LOG-ONLY (_GHOST_REAP_DRYRUN=True): logs GHOST-DRYRUN candidates so we can
-# confirm ZERO false positives across the live fleet BEFORE flipping to a real
-# kill (commander-mandated staged arming). Kills NOTHING while dry-run.
-#
-# GUARDS folded from back's cross-review (HIGH_1/HIGH_2) — all enforced even in the
-# DRY-RUN classification so the logs only ever show TRUE ghosts:
-#   - boot-grace: skip until spawned_age (pidfile mtime) > GHOST_BOOT_GRACE_SEC, so a
-#     freshly-booting agent (claude up, MCP still connecting) is NOT mis-flagged.
-#   - cwd-guard: the live pid's working dir MUST equal the agent's recorded launch cwd
-#     (pidfile {cwd}, or the workspace as legacy fallback). Anti PID-reuse mis-kill —
-#     post-execvp claude's cmdline loses <target>, so cwd is the stable correlator. If
-#     cwd is unreadable on this platform → fail-SAFE (skip, never reap on uncertainty).
-# ------------------------------------------------------------------
-_GHOST_REAP_DRYRUN = True
-GHOST_BOOT_GRACE_SEC = _env_int("MESHCODE_GHOST_BOOT_GRACE_SEC", 120, 30)  # mac boots slow; >> _REAP grace + MCP reconnect
-GHOST_PERSIST_SEC = _env_int("MESHCODE_GHOST_PERSIST_SEC", 90, 30)         # ghost must hold this long → a brief mcp restart doesn't count (MED_restart)
-
-
-def _mcp_serve_pid(project: str, agent: str) -> Optional[int]:
-    """Read the MCP server's recorded pid for this agent (meshcode_mcp/server.py
-    lockfile). Returns the pid, or None if the lockfile is missing/unparseable.
-    Path + JSON|bare-int format mirror _pid_lockfile_path()/_read_pid_lockfile()."""
-    try:
-        import tempfile as _tf
-        safe = f"meshcode_mcp_{project}_{agent}.pid".replace("/", "_").replace(" ", "_")
-        path = os.path.join(_tf.gettempdir(), safe)
-        if not os.path.exists(path):
-            return None
-        raw = open(path, "r").read().strip()
-        if not raw:
-            return None
-        try:
-            data = json.loads(raw)
-            if isinstance(data, dict) and "pid" in data:
-                return int(data["pid"])
-        except (ValueError, TypeError):
-            pass
-        return int(raw)
-    except Exception:
-        return None
-
-
-def _agent_launcher_record(project: str, agent: str):
-    """Read run_agent's pre-execvp pidfile (~/.meshcode/pids/<project>__<agent>.pid).
-    Returns (pid:int|None, cwd:str|None). New format is JSON {"pid","cwd"}; tolerates
-    the legacy bare-int (no recorded cwd)."""
-    try:
-        safe = f"{project}__{agent}".replace("/", "_").replace("\\", "_").replace(" ", "_")
-        path = STATE_DIR / "pids" / f"{safe}.pid"
-        if not path.exists():
-            return None, None
-        raw = path.read_text(encoding="utf-8").strip()
-        if not raw:
-            return None, None
-        try:
-            data = json.loads(raw)
-            if isinstance(data, dict) and "pid" in data:
-                return int(data["pid"]), (data.get("cwd") or None)
-        except (ValueError, TypeError):
-            pass
-        return int(raw), None
-    except Exception:
-        return None, None
-
-
-def _read_pid_cwd(pid: int) -> Optional[str]:
-    """Best-effort working directory of a live pid (time-boxed). None if unreadable.
-      linux : /proc/<pid>/cwd symlink
-      macOS : lsof -a -p <pid> -d cwd -Fn  → the 'n' line (no Full Disk Access needed)
-      win   : None (run_agent does NOT execvp there; cmdline keeps `run <target>`, so
-              the existing cmdline token-guard already correlates — cwd not needed)."""
-    try:
-        if sys.platform == "win32":
-            return None
-        if sys.platform == "darwin":
-            out = subprocess.run(["lsof", "-a", "-p", str(int(pid)), "-d", "cwd", "-Fn"],
-                                 capture_output=True, text=True, timeout=5).stdout or ""
-            for line in out.splitlines():
-                if line.startswith("n"):
-                    return line[1:].strip() or None
-            return None
-        return os.readlink(f"/proc/{int(pid)}/cwd")  # linux
-    except Exception:
-        return None
-
-
-def _pid_cwd_matches(pid: int, expected_cwd: Optional[str], project: str, agent: str):
-    """Tri-state: True if the pid's live cwd == the agent's launch cwd; False if it
-    differs; None if unreadable. `expected_cwd` is the pidfile-recorded cwd; when absent
-    (legacy pidfile) fall back to the canonical workspace dir. realpath both sides
-    (mac /Users vs /private symlinks, --repo dirs). Autonomous reap requires True."""
-    live = _read_pid_cwd(pid)
-    if not live:
-        return None                                    # unreadable → unknown → fail-safe skip
-    exp = set()
-    if expected_cwd:
-        try: exp.add(os.path.realpath(os.path.expanduser(expected_cwd)))
-        except Exception: pass
-    try:
-        exp.add(os.path.realpath(os.path.join(os.path.expanduser("~"), "meshcode", f"{project}-{agent}")))
-    except Exception:
-        pass
-    try:
-        return os.path.realpath(live) in exp
-    except Exception:
-        return None
-
-
-def _do_ghost_reap(api_key: str, host_id: str) -> int:
-    """Detect dead-MCP ghosts (claude ALIVE + mcp_serve DEAD) from local pidfiles.
-    LOG-ONLY while _GHOST_REAP_DRYRUN — confirm zero false positives in the fleet logs
-    before arming. Returns the count that WOULD be reaped.
-
-    Self-contained: enumerates this host's launcher pidfiles (agents WE launched), so
-    no roster RPC is needed for detection. All HIGH guards (boot-grace + cwd-match) are
-    enforced here so DRYRUN logs only ever show TRUE ghosts. Fail-open at the top level
-    so a bug here can never wedge the sweep."""
-    n = 0
-    try:
-        pid_dir = STATE_DIR / "pids"
-        if not pid_dir.is_dir():
-            return 0
-        now = time.time()
-        st = _load_state()
-        seen = dict(st.get("ghost_seen") or {})        # {target: first_candidate_ts} — MED_restart persistence
-        still = set()                                  # targets that are candidates THIS sweep (others get cleared)
-        for pf in sorted(pid_dir.glob("*.pid")):
-            try:
-                stem = pf.stem                         # "<project>__<agent>"
-                if "__" not in stem:
-                    continue
-                project, agent = stem.split("__", 1)
-                target = f"{project}/{agent}"
-                claude_pid, rec_cwd = _agent_launcher_record(project, agent)
-                if not claude_pid or not _pid_alive(claude_pid):
-                    # MED_pidfile_stale: the agent exited (run_agent execvp'd, can't self-clean) →
-                    # the launcher pid is dead. Prune the stale pidfile so a future reused pid can't FP.
-                    try:
-                        pf.unlink()
-                    except Exception:
-                        pass
-                    continue                           # S3 fail: no live claude → not a ghost
-                # HIGH_2 boot-grace: pidfile mtime ≈ spawn time (written just before execvp).
-                try:
-                    spawned_age = now - pf.stat().st_mtime
-                except Exception:
-                    spawned_age = 1e9
-                if spawned_age < GHOST_BOOT_GRACE_SEC:
-                    continue                           # still booting / MCP may be connecting → never reap
-                mcp_pid = _mcp_serve_pid(project, agent)
-                if mcp_pid and _pid_alive(mcp_pid):
-                    continue                           # S2 fail: mcp_serve alive → healthy
-                mcp_state = (f"pid {mcp_pid} DEAD" if mcp_pid else "lockfile MISSING")
-                # HIGH_1 cwd-guard: the live pid MUST be running in this agent's launch cwd.
-                live_cwd = _read_pid_cwd(claude_pid)
-                cwd_match = _pid_cwd_matches(claude_pid, rec_cwd, project, agent)
-                if cwd_match is not True:
-                    _log(f"GHOST-SKIP {target}: claude pid {claude_pid} + mcp {mcp_state} but cwd-guard "
-                         f"{'UNREADABLE' if cwd_match is None else 'MISMATCH'} "
-                         f"(live_cwd={live_cwd!r} expected~{rec_cwd!r}) — NOT a confirmed ghost, no reap.")
-                    continue                           # fail-SAFE: never reap on cwd uncertainty/mismatch
-                # Candidate (S3 alive ∧ boot-grace ∧ S2 dead ∧ cwd-match). MED_restart persistence:
-                # only COUNT after the ghost has held GHOST_PERSIST_SEC, so a brief mcp restart
-                # (dead for one sweep) never registers.
-                still.add(target)
-                first_ts = seen.get(target) or now
-                seen[target] = first_ts
-                held = now - first_ts
-                if held < GHOST_PERSIST_SEC:
-                    _log(f"GHOST-PENDING {target}: dead-MCP candidate held {int(held)}s (< {GHOST_PERSIST_SEC}s) "
-                         f"— waiting for persistence before counting (guards against a brief mcp restart).")
-                    continue
-                # CONFIRMED, PERSISTENT dead-MCP ghost.
-                n += 1
-                cmdline = _pid_cmdline(claude_pid).strip()[:120]
-                _log(f"GHOST-DRYRUN {target}: claude pid {claude_pid} ALIVE (cwd={live_cwd!r}, "
-                     f"spawned_age={int(spawned_age)}s, ghost_held={int(held)}s) but meshcode_mcp serve "
-                     f"{mcp_state} — connected-but-invisible. WOULD reap claude → respawn relaunches clean "
-                     f"[log-only; arming also needs S1 is_ghost + human-defer + spawn-breaker]. cmdline={cmdline!r}")
-                # ARMED PATH (not yet enabled): AND S1 (roster is_ghost) AND not _human_recently_active(target)
-                # AND _spawn_rate_ok(target), then _kill_headless_pid(target, claude_pid) → respawn relaunches.
-            except Exception:
-                continue
-        # Clear persistence for targets that recovered (mcp back, agent gone) so a future
-        # transient doesn't inherit a stale clock.
-        seen = {t: ts for t, ts in seen.items() if t in still}
-        st["ghost_seen"] = seen
-        _save_state(st)
-    except Exception:
-        pass
-    return n
-
-
 def _do_recycles(api_key: str, host_id: str) -> int:
     """Uptime-based recycle at task boundary. Returns number recycled."""
     # DEAD-FEATURE (task 222b1b02, Samuel 2026-06-04): the RECYCLE feature is disabled in
@@ -1994,7 +1759,6 @@ def cmd_hostd(args: list) -> int:
                         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
-                        ghosts = _do_ghost_reap(api_key, host_id)  # FOCUS-1 09fca8fe: dead-MCP ghost detector (LOG-ONLY)
                         _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 or force_killed:

{meshcode-2.11.114rc1 → meshcode-2.11.115}/meshcode/meshcode_mcp/server.py

@@ -2898,6 +2898,13 @@ def meshcode_send(to: Union[str, List[str]], message: Any, in_reply_to: Optional
     msg_ids[], count}. Cross-mesh '@' is single-recipient only (mixed lists rejected v1).
     sensitive=True hides from exports. encrypted=True for secrets (AES-256-GCM, cross-mesh only).
     type= optional typed-catalog tag; soft-validates, never refuses."""
+    # mode-2 soft-fail (R2-3): a malformed in_reply_to (not a valid uuid) would hit
+    # the uuid cast at the RPC boundary and reject the WHOLE message. Drop it so the
+    # message still sends (pairs with mig463's nonexistent-but-valid-uuid soft-fail).
+    if in_reply_to is not None and not re.fullmatch(
+        r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}",
+        str(in_reply_to)):
+        in_reply_to = None
     # ── Normalize `to` into a recipients list ──────────────────────────────
     if isinstance(to, list):
         recipients: List[str] = [str(t).strip() for t in to if str(t).strip()]
@@ -3514,6 +3521,58 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
         return None
 
 
+def _pending_filter(tasks: List[Dict[str, Any]]) -> Optional[List[Dict[str, str]]]:
+    """The _get_pending_tasks_summary filter, applied to a task list we already
+    have (e.g. from mc_wait_poll) so we don't re-fetch. Identical output shape."""
+    pending = [
+        {"id": t["id"][:8], "title": t["title"][:80], "priority": t.get("priority", "normal"), "status": t["status"]}
+        for t in tasks
+        if t.get("status") in ("open", "in_progress")
+        and (t.get("claimed_by") == AGENT_NAME or t.get("assignee") == AGENT_NAME)
+    ]
+    if _is_leader_agent():
+        pending.extend([
+            {"id": t["id"][:8], "title": t["title"][:80], "priority": t.get("priority", "normal"), "status": t["status"]}
+            for t in tasks
+            if t.get("status") == "open" and t.get("assignee") == "*" and not t.get("claimed_by")
+        ])
+    _PRIORITY_ORDER = {"urgent": 0, "high": 1, "normal": 2, "low": 3}
+    pending.sort(key=lambda t: _PRIORITY_ORDER.get(t.get("priority", "normal"), 2))
+    return pending if pending else None
+
+
+def _wait_poll_or_legacy() -> Dict[str, Any]:
+    """R2-1: ONE mc_wait_poll replaces _check_recycle_request + _check_stop_request
+    + _get_pending_tasks_summary (3 RPCs + 3 api_key resolves -> 1). Semantics are
+    identical (recycle = mig446 guard, stop = desired_state, tasks via the same
+    filter). Falls back to the 3 legacy RPCs on ANY error so a mixed old-SDK/new-RPC
+    fleet never breaks. recycle-first order is preserved by the caller."""
+    try:
+        api_key = _get_api_key()
+        if api_key:
+            resp = be.sb_rpc("mc_wait_poll", {
+                "p_api_key": api_key,
+                "p_project_id": _PROJECT_ID,
+                "p_agent_name": AGENT_NAME,
+            })
+            if isinstance(resp, dict) and resp.get("ok"):
+                return {
+                    "recycle": bool(resp.get("recycle")),
+                    "stop": bool(resp.get("stop")),
+                    "tasks": _pending_filter(resp.get("tasks") or []),
+                    "_via": "mc_wait_poll",
+                }
+    except Exception as e:
+        log.debug(f"[meshcode] mc_wait_poll failed; legacy fallback: {e}")
+    # Legacy fallback — the 3 separate RPCs (old behavior, never breaks).
+    return {
+        "recycle": _check_recycle_request(),
+        "stop": _check_stop_request(),
+        "tasks": _get_pending_tasks_summary(),
+        "_via": "legacy",
+    }
+
+
 def _check_recycle_request() -> bool:
     """Server-authorized recycle (task 548c863e, mig 364).
 
@@ -3598,7 +3657,9 @@ def _try_auto_claim_self_assigned_tasks(max_claims: int = 20) -> List[Dict[str,
         for target in candidates[:max_claims]:
             claim_result = be.sb_rpc("mc_task_claim", {
                 "p_api_key": api_key,
+                "p_project_id": _PROJECT_ID,
                 "p_task_id": target["id"],
+                "p_claiming_agent": AGENT_NAME,
             })
             if isinstance(claim_result, dict) and claim_result.get("ok"):
                 log.info(f"[meshcode] auto-claimed self-assigned task: {target['title'][:60]}")
@@ -3643,7 +3704,9 @@ def _try_auto_claim_task() -> Optional[Dict[str, str]]:
         # Claim it
         claim_result = be.sb_rpc("mc_task_claim", {
             "p_api_key": api_key,
+            "p_project_id": _PROJECT_ID,
             "p_task_id": target["id"],
+            "p_claiming_agent": AGENT_NAME,
         })
         if isinstance(claim_result, dict) and claim_result.get("ok"):
             log.info(f"[meshcode] auto-claimed task: {target['title'][:60]}")
@@ -3758,7 +3821,9 @@ def _try_auto_claim_open_by_heuristic(max_load: int = 2) -> Optional[Dict[str, A
         score, target = scored[0]
         claim_result = be.sb_rpc("mc_task_claim", {
             "p_api_key": api_key,
+            "p_project_id": _PROJECT_ID,
             "p_task_id": target["id"],
+            "p_claiming_agent": AGENT_NAME,
         })
         if not (isinstance(claim_result, dict) and claim_result.get("ok")):
             log.debug(f"[meshcode] heuristic claim lost race on {target['id'][:8]}: {claim_result}")
@@ -4196,11 +4261,11 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
             "count": len(pending_tasks),
             "you_are_autonomous": _get_autonomous_mode(),
             "task_pull_active": True,
-            "hint": "Work the highest-priority task with meshcode_task_start, then meshcode_task_complete. Wait will surface the next one automatically.",
+            "hint": "Work highest-priority task; wait surfaces the next one.",
         }
         if _auto_started:
             out["auto_started_task"] = _auto_started
-            out["hint"] = f"Task '{_auto_started['title'][:60]}' auto-started (in_progress). Work it NOW, then meshcode_task_complete when done."
+            out["hint"] = f"Task '{_auto_started['title'][:60]}' auto-started — work it, then task_complete."
         if _wait_entry_auto_claimed:
             out["auto_claimed_at_wait_entry"] = _wait_entry_auto_claimed
         return out
@@ -4223,6 +4288,11 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 pass  # All messages already seen — fall through to wait loop
             else:
                 split = _split_messages(deduped)
+                # L5-P3 (task 96d5f2e9): honor include_acks on the refused path too —
+                # this was the only delivery path that leaked acks into the payload,
+                # billing a turn's worth of "X read your message" noise to every agent.
+                if not include_acks:
+                    split["acks"] = []
                 # Only refuse for real messages — ack-only batches should not block wait
                 if split["messages"] or split["done_signals"]:
                     resp = {
@@ -4299,7 +4369,8 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 # us fresh. Checked BEFORE pending_tasks: the fresh session
                 # re-attacks any open tasks on boot, so an outstanding backlog
                 # must not pin a stale, context-heavy session alive.
-                if _check_recycle_request():
+                _wp = _wait_poll_or_legacy()  # R2-1: 3 RPCs -> 1 (legacy fallback inside)
+                if _wp["recycle"]:
                     _set_state("sleeping", "recycle")
                     result["must_exit"] = True
                     result["exit_reason"] = (
@@ -4312,7 +4383,7 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 # toggled this agent OFF (desired_state='stopped'). Exit CLEAN — sticky
                 # 'stopped' means hostd will NOT respawn us (unlike recycle). Checked
                 # right after recycle so a power-off wins over auto-claim/pending-tasks.
-                if _check_stop_request():
+                if _wp["stop"]:
                     _set_state("sleeping", "stopped")
                     result["must_exit"] = True
                     result["exit_reason"] = (
@@ -4322,8 +4393,8 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                     result["stopped"] = True
                     break
 
-                # Check if new tasks appeared while we waited
-                pending_tasks = _get_pending_tasks_summary()
+                # New tasks that appeared while we waited (from the same poll)
+                pending_tasks = _wp["tasks"]
                 if pending_tasks:
                     result["pending_tasks"] = pending_tasks
                     break  # Return so agent can work tasks
@@ -4405,7 +4476,8 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
         # `you_are_autonomous` is the canonical field per commander memo
         # decisions msg 29cae7f9; `autonomous_mode` retained for back-compat.
         if isinstance(result, dict):
-            result["autonomous_mode"] = _autonomous
+            # L5-P4: `you_are_autonomous` is canonical (commander memo 29cae7f9);
+            # the duplicate `autonomous_mode` alias was dropped from the envelope.
             result["you_are_autonomous"] = _autonomous
         return result
     finally:
@@ -6056,6 +6128,19 @@ def meshcode_boot() -> Dict[str, Any]:
         # Non-fatal: surface that the hints are unavailable but boot succeeds.
         resp.setdefault("time_context_available", False)
 
+    # L5-P4 (task 96d5f2e9): offline agents' mc_agents.task often holds their
+    # FULL registration role text (150+ tokens each), re-billed on every boot.
+    # The peer roster only needs a glanceable line.
+    try:
+        _mesh = resp.get("mesh_status")
+        if isinstance(_mesh, list):
+            for _row in _mesh:
+                _ct = _row.get("current_task") if isinstance(_row, dict) else None
+                if isinstance(_ct, str) and len(_ct) > 120:
+                    _row["current_task"] = _ct[:117] + "..."
+    except Exception:
+        pass
+
     # c0ab14c1 Phase 2: open-promise time-awareness (what I owe / what I'm
     # waiting on, with overdue/elapsed minutes). Soft-fail; only added when
     # there's something open.
@@ -7247,6 +7332,25 @@ def meshcode_recall_search(query: str) -> Dict[str, Any]:
         query: Plain English search query.
     """
     api_key = _get_api_key()
+    # L6 M4 (task 84c426d4): hybrid semantic+FTS recall via the mc-embed edge
+    # function (embeds the query with gte-small, then calls mc_memory_search v2
+    # with p_query_embedding — RRF fusion server-side). Soft-fail to the direct
+    # RPC (FTS+substring arms of the same v2 fn) if the edge fn is unreachable.
+    try:
+        import urllib.request as _url
+        _req = _url.Request(
+            f"{be.SUPABASE_URL}/functions/v1/mc-embed",
+            data=json.dumps({"search": {
+                "api_key": api_key, "agent_name": AGENT_NAME,
+                "query": query, "project_name": PROJECT_NAME, "limit": 20,
+            }}).encode(),
+            headers={"Content-Type": "application/json"}, method="POST")
+        with _url.urlopen(_req, timeout=8) as _resp:
+            _out = json.loads(_resp.read().decode())
+        if isinstance(_out, dict) and _out.get("ok"):
+            return _out
+    except Exception as _e:
+        log.debug(f"mc-embed search fallback to direct RPC: {_e}")
     return be.sb_rpc("mc_memory_search", {
         "p_api_key": api_key,
         "p_agent_name": AGENT_NAME,

{meshcode-2.11.114rc1 → meshcode-2.11.115}/meshcode/protocol_handler.py

@@ -207,7 +207,40 @@ def _spawn_terminal_macos(cmd: str) -> tuple[bool, str]:
              'cd "$HOME" 2>/dev/null || cd /']   # neutral, non-TCC-protected cwd
     if venv_bin:
         lines.append(f'export PATH={shlex.quote(venv_bin)}:"$PATH"')
-    lines.append(cmd)                            # ends in `exec … meshcode run …`
+    # RECYCLE-KILL-OLD-TERMINAL (task 2094ff3d, Samuel "que se cierre la terminal
+    # pasada"). A recycle/stop ends the agent cleanly but macOS Terminal leaves the
+    # window open as "[Process completed]" — an orphan. Run the agent WITHOUT `exec`
+    # so bash survives its exit and can close THIS window. `cmd` ends in
+    # `exec … meshcode run …`; strip the leading `exec ` so the agent runs as a child
+    # (it still execvp's claude internally — that becomes the window's foreground proc).
+    lines.append('MC_TTY="$(tty 2>/dev/null)"')
+    # `cmd` is a compound line (`unset …; export PATH=…; exec <py> -m meshcode run …`),
+    # so the `exec` is NOT leading. Drop the LAST `exec ` token (the one before the
+    # interpreter) so the agent runs as a CHILD and bash survives to close the window.
+    if "exec " in cmd:
+        _head, _, _tail = cmd.rpartition("exec ")
+        _run = _head + _tail
+    else:
+        _run = cmd
+    lines.append(_run)
+    lines.append('MC_RC=$?')
+    # Close THIS Terminal window ONLY on a clean exit (recycle/stop => 0). On a CRASH
+    # (non-zero) leave it OPEN so the scrollback is available for debugging (commander
+    # condition: debugging > clean window). The own-$MC_TTY filter closes ONLY this
+    # window — never another agent's. saving no => no "close?" prompt. macOS-only path.
+    lines.append('if [ "$MC_RC" = "0" ] && [ -n "$MC_TTY" ]; then')
+    lines.append(
+        "  /usr/bin/osascript"
+        " -e 'tell application \"Terminal\"'"
+        " -e 'repeat with w in windows'"
+        " -e 'try'"
+        " -e \"if (tty of selected tab of w) is \\\"$MC_TTY\\\" then\""
+        " -e 'close w saving no'"
+        " -e 'end if'"
+        " -e 'end try'"
+        " -e 'end repeat'"
+        " -e 'end tell' >/dev/null 2>&1")
+    lines.append('fi')
     try:
         launch_dir.mkdir(parents=True, exist_ok=True)
         script_path.write_text("\n".join(lines) + "\n", encoding="utf-8")

{meshcode-2.11.114rc1 → meshcode-2.11.115}/meshcode/run_agent.py

@@ -1246,23 +1246,6 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
             result = _sp.run(cmd, **_kwargs)
             sys.exit(result.returncode)
         else:
-            # FOCUS-1 ghost reap (back-2, 09fca8fe): stamp THIS pid so hostd can correlate
-            # the agent's visible session for dead-MCP / ghost detection + reap-by-PID. execvp
-            # PRESERVES the pid, so this file's pid == the claude session pid exactly. Without a
-            # recorded visible pid, hostd's reap/enforce/close-old can't anchor a visible agent
-            # (the root gap behind orphaned recycle windows + connected-but-invisible ghosts).
-            # Record {pid, cwd}: cwd is the exact launch dir (os.chdir(ws) above, or the
-            # --repo dir) so hostd's kill-time cwd-guard can compare the LIVE pid's cwd to
-            # THIS recorded cwd — anti PID-reuse mis-kill (a reused pid running a different
-            # agent's claude has a different cwd → no match → never killed).
-            try:
-                _pdir = Path.home() / ".meshcode" / "pids"
-                _pdir.mkdir(parents=True, exist_ok=True)
-                _safe = f"{resolved_project}__{agent}".replace("/", "_").replace("\\", "_").replace(" ", "_")
-                (_pdir / f"{_safe}.pid").write_text(
-                    json.dumps({"pid": os.getpid(), "cwd": os.getcwd()}), encoding="utf-8")
-            except Exception:
-                pass
             # Unix: replace this process with the editor
             os.execvp(cmd[0], cmd)
     except FileNotFoundError:

{meshcode-2.11.114rc1 → meshcode-2.11.115}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.114rc1 → meshcode-2.11.115}/meshcode.egg-info/SOURCES.txt

@@ -2,14 +2,10 @@ README.md
 pyproject.toml
 meshcode/__init__.py
 meshcode/__main__.py
-meshcode/_session_handoff_template 2.py
-meshcode/_session_handoff_template 3.py
 meshcode/_session_handoff_template.py
 meshcode/_stop_hook_template.py
 meshcode/ascii_art.py
 meshcode/atomic_push.py
-meshcode/claude_update 2.py
-meshcode/claude_update 3.py
 meshcode/claude_update.py
 meshcode/cli.py
 meshcode/comms_v4.py
@@ -19,7 +15,6 @@ meshcode/date_parse.py
 meshcode/doctor.py
 meshcode/error_hints.py
 meshcode/exceptions.py
-meshcode/hostd 2.py
 meshcode/hostd.py
 meshcode/invites.py
 meshcode/launcher.py
@@ -34,7 +29,6 @@ meshcode/secrets.py
 meshcode/self_update.py
 meshcode/setup_clients.py
 meshcode/supervisor.py
-meshcode/up 2.py
 meshcode/up.py
 meshcode/upload.py
 meshcode.egg-info/PKG-INFO
@@ -58,4 +52,40 @@ meshcode/meshcode_mcp/test_prefs_claude_version.py
 meshcode/meshcode_mcp/test_realtime.py
 meshcode/meshcode_mcp/test_server_wrapper.py
 meshcode/scripts/check_secrets.py
-meshcode/scripts/race_rate_harness.py
+meshcode/scripts/race_rate_harness.py
+tests/test_auto_update_hardening.py
+tests/test_autonomous_closegap_1.py
+tests/test_autonomous_closegap_2.py
+tests/test_autonomous_closegap_3.py
+tests/test_autonomous_prompt_inject.py
+tests/test_boot_bug_regression.py
+tests/test_color_truecolor.py
+tests/test_core.py
+tests/test_cross_agent_messaging.py
+tests/test_date_parse.py
+tests/test_doctor.py
+tests/test_epistemic_v1_python_sdk.py
+tests/test_epistemic_v1_stop_conditions.py
+tests/test_esc_deaf_state.py
+tests/test_exceptions.py
+tests/test_file_upload.py
+tests/test_init_device_code.py
+tests/test_install_guard.py
+tests/test_lease_sigterm_release.py
+tests/test_mark_read_batch.py
+tests/test_marketplace_ratings.py
+tests/test_migration_integrity.py
+tests/test_realtime_event_freshness.py
+tests/test_rls_cross_tenant.py
+tests/test_rpc_grants.py
+tests/test_rpc_migrations.py
+tests/test_run_agent_dry_run.py
+tests/test_run_agent_no_server_import.py
+tests/test_security_regressions.py
+tests/test_self_update_user_site.py
+tests/test_sentinel.py
+tests/test_setup_path.py
+tests/test_sleep_signals.py
+tests/test_status_enum_coverage.py
+tests/test_stay_on_loop_hook.py
+tests/test_wait_open_tasks_contradiction.py

{meshcode-2.11.114rc1 → meshcode-2.11.115}/pyproject.toml

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