meshcode 2.11.114rc1__tar.gz → 2.11.116__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.114rc1
+Version: 2.11.116
 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.116}/meshcode/__init__.py

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

{meshcode-2.11.114rc1 → meshcode-2.11.116}/meshcode/_session_handoff_template.py

@@ -161,6 +161,53 @@ def _request_recycle_if_marked(project_dir) -> None:
         sys.stderr.write(f"[session_handoff_write] recycle-request skipped: {e}\\n")
 
 
+def _persist_handoff_to_memory(project_dir, handoff) -> None:
+    """L6 M6.1 (task 84c426d4, 2.11.114): mirror the handoff into
+    mc_agent_memory key='session_handoff' so the server-side boot
+    continuity_capsule (mig 456) can surface it on the NEXT session even
+    when the local handoff.json is gone (new host, wiped workspace).
+    Same best-effort creds pattern as _request_recycle_if_marked —
+    any failure silently skips; handoff.json already covers the local path.
+    """
+    try:
+        mcp = json.loads((project_dir / ".mcp.json").read_text(encoding="utf-8"))
+        env = (next(iter((mcp.get("mcpServers") or {}).values()), {}) or {}).get("env", {}) or {}
+        url = env.get("SUPABASE_URL"); key = env.get("SUPABASE_KEY")
+        agent = env.get("MESHCODE_AGENT"); project = env.get("MESHCODE_PROJECT")
+        if not (url and key and agent):
+            return
+        api_key = os.environ.get("MESHCODE_API_KEY")
+        if not api_key:
+            try:
+                import importlib
+                api_key = importlib.import_module("meshcode.secrets").get_api_key(
+                    profile=env.get("MESHCODE_KEYCHAIN_PROFILE") or "default")
+            except Exception:
+                api_key = None
+        if not api_key:
+            return
+        turns = handoff.get("turns") or []
+        compact = {
+            "trigger": handoff.get("trigger"),
+            "captured_at_session": handoff.get("session_id"),
+            "tail": [{"role": t["role"], "text": t["text"][:400]} for t in turns[-8:]],
+        }
+        import urllib.request as _u
+        body = json.dumps({
+            "p_api_key": api_key, "p_agent_name": agent,
+            "p_key": "session_handoff", "p_value": compact,
+            "p_tier": "episodic", "p_project_name": project,
+        }).encode("utf-8")
+        req = _u.Request(
+            url.rstrip("/") + "/rest/v1/rpc/mc_memory_set",
+            data=body, method="POST",
+            headers={"apikey": key, "Authorization": "Bearer " + key,
+                     "Content-Type": "application/json"})
+        _u.urlopen(req, timeout=5).read()
+    except Exception as e:  # noqa: BLE001 — never block compaction
+        sys.stderr.write(f"[session_handoff_write] memory-persist skipped: {e}\\n")
+
+
 def main() -> int:
     try:
         raw = sys.stdin.read()
@@ -185,6 +232,8 @@ def main() -> int:
         tmp.replace(d / "handoff.json")
     except OSError as e:
         sys.stderr.write(f"[session_handoff_write] skipped: {e}\\n")
+    # L6 M6.1: mirror to server-side memory for the boot continuity capsule.
+    _persist_handoff_to_memory(_project_dir(), handoff)
     # CTX-CLOSE-RELAUNCH (task 400fc536): now that the thread is snapshotted,
     # commander-tier sessions ask the server to recycle at the next task-edge.
     _request_recycle_if_marked(_project_dir())

{meshcode-2.11.114rc1 → meshcode-2.11.116}/meshcode/comms_v4.py

@@ -1886,7 +1886,7 @@ def _start_heartbeat_daemon(project, name, agent_pid=None):
         "        if not check_still_leased(pid):\n"
         "            sys.exit(0)\n"
         "        post('/rest/v1/rpc/mc_heartbeat', {'p_project_id':pid,'p_agent_name':name})\n"
-        "    time.sleep(30)\n"
+        "    time.sleep(10)\n"  # R2-3 (.116): 30s->10s so the fork's agent-alive check (self-exit on recycle/stop) tightens the stale-heartbeat window to <=10s
     )
     # Windows: start_new_session kwarg doesn't exist. Use creationflags.
     _popen_kwargs = {

{meshcode-2.11.114rc1 → meshcode-2.11.116}/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: