meshcode 2.11.134__tar.gz → 2.11.136__tar.gz

{meshcode-2.11.134 → meshcode-2.11.136}/PKG-INFO

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

{meshcode-2.11.134 → meshcode-2.11.136}/meshcode/__init__.py

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

{meshcode-2.11.134 → meshcode-2.11.136}/meshcode/hostd.py

@@ -1037,26 +1037,6 @@ def _recycle_blocked(st, target, now=None):
     return None
 
 
-# Samuel rule 2026-06-04: never recycle a CONNECTED agent (live MCP session) except
-# the >3h uptime lifecycle. BUSY_STATUSES (working/online/busy) MISSES a connected-
-# but-idle agent (status idle/standby, window open, heartbeat fresh) — a fresh
-# heartbeat is the stronger 'live session' signal, so an idle-but-connected agent
-# was being version-recycled out from under the user (the storm he kept seeing).
-_CONNECTED_HEARTBEAT_S = _env_int("MESHCODE_CONNECTED_HEARTBEAT_SEC", 60, 10)
-
-
-def _agent_connected(a) -> bool:
-    """True if the agent has a live MCP session: an explicitly-busy status OR a
-    very-recent heartbeat (window open even when idle/standby)."""
-    if (a.get("status") or "") in BUSY_STATUSES:
-        return True
-    hb = a.get("heartbeat_age_s")
-    try:
-        return hb is not None and float(hb) < _CONNECTED_HEARTBEAT_S
-    except (TypeError, ValueError):
-        return False
-
-
 # Part 2 (Samuel req #2 2026-06-04): on a VISIBLE recycle, close the OLD window so
 # old+new don't both stay open (audit gap 6a203baa). DRY-RUN first (commander q2 +
 # reaper safe-arm pattern): log-only until the logs confirm it's ONLY the old pid.
@@ -1350,6 +1330,46 @@ def _own_ancestry_pids() -> set:
     return anc
 
 
+def _run_token_rx(target: str):
+    """`meshcode run <target>` token regex accepting BOTH spawn forms (task 3ed8781d).
+
+    BARE-NAME GAP (the Windows stop-por-RPC zombie, Samuel 2026-06-11): hostd spawns
+    `run "project/agent"` but the FE Start click goes through protocol_handler's
+    cmd_launch_batch, which spawns `run "agent"` (bare). The old per-call-site token
+    (`run <project/agent>`) could NEVER match a bare-spawned session, so stop/force-kill/
+    reap/reconcile discovery silently found nothing for protocol-launched agents — the
+    session survived every Stop, the relaunch opened a NEW wt tab on top, and Samuel's
+    box accumulated up to 3 sessions/tabs per agent.
+
+    - target 'proj/agent': matches `run [\"']?(proj/)?agent` — both qualified and bare.
+    - target 'agent' (bare, the protocol reconcile caller): matches `run [\"']?(<any>/)?agent`
+      — both forms again, since a survivor may have been hostd-spawned.
+    All forms keep the optional opening quote (QUOTED-TARGET FIX 14e0760c) and the
+    trailing lookahead, so 'qa' can never prefix-match 'qa-2'."""
+    proj, _, agent = target.rpartition("/")
+    if proj:
+        pfx = r"(?:" + re.escape(proj) + r"/)?"
+    else:
+        pfx = r"(?:[^\s\"']*/)?"
+    return re.compile(r"run\s+[\"']?" + pfx + re.escape(agent) + r"(?=\s|$|[\"'])")
+
+
+def _bare_match_is_foreign(cl: str, cwd: str, target: str) -> bool:
+    """Cross-project guard for BARE-token matches (task 3ed8781d). When `target` is
+    project-qualified but the candidate cmdline only carries the bare agent name,
+    a same-named agent of ANOTHER mesh on this box could collide. The workspace
+    cwd (`~/meshcode/<project>-<agent>`) disambiguates: if the cwd basename looks
+    like a workspace of this agent but a DIFFERENT project, skip it. Unreadable
+    cwd or qualified-token matches are never rejected (best-effort guard only)."""
+    proj, _, agent = target.rpartition("/")
+    if not proj or f"{proj}/{agent}" in (cl or ""):
+        return False  # qualified match — unambiguous
+    # separator-agnostic last path component (a Windows cwd seen from tests/tools
+    # running under POSIX must split the same way)
+    base = re.split(r"[\\/]", (cwd or "").rstrip("/\\"))[-1]
+    return base.endswith(f"-{agent}") and base != f"{proj}-{agent}"
+
+
 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>`.
@@ -1373,9 +1393,16 @@ def _discover_agent_pids(target: str) -> list:
     (`run\\s+<target>`) NEVER matched on Windows — stop/force-kill discovery silently
     found nothing, which is how stopped sessions survived as zombies. The token now
     accepts one optional opening quote; the trailing lookahead still forbids any
-    'qa' vs 'qa-2' prefix collision."""
+    'qa' vs 'qa-2' prefix collision.
+
+    BARE-NAME FIX (task 3ed8781d): the token now comes from _run_token_rx, which ALSO
+    matches protocol-handler bare-name spawns (`run "agent"`) — the form every FE Start
+    click produces. Bare matches are cwd-guarded against same-named agents of another
+    mesh (psutil path only; the native fallbacks accept the regex as-is, documented
+    tradeoff: a zombie that survives every stop is the live bug, the cross-mesh
+    same-name collision is the rare one)."""
     pids = []
-    tok = re.compile(r"run\s+[\"']?" + re.escape(target) + r"(?=\s|$|[\"'])")
+    tok = _run_token_rx(target)
     ps = _psutil()
     if ps is not None:
         try:
@@ -1386,10 +1413,23 @@ def _discover_agent_pids(target: str) -> list:
                         continue
                     cl = " ".join(p.cmdline() or [])
                     if "meshcode" in cl and tok.search(cl) and "python" in (p.name() or "").lower():
+                        try:
+                            cwd = p.cwd() or ""
+                        except Exception:
+                            cwd = ""
+                        if _bare_match_is_foreign(cl, cwd, target):
+                            _log(f"DISCOVER {target}: pid {p.pid} bare-name match belongs to "
+                                 f"another project (cwd {cwd!r}) — skip")
+                            continue
                         pids.append(p.pid)
                 except Exception:
                     continue
-            return pids
+            # GHOST-TERMINAL fix (91201315) APPLIES HERE TOO (task 3ed8781d): the old
+            # `return pids` skipped the POSIX launcher-children fallback whenever
+            # psutil was importable — re-defeating the '0 stopped forever' hole on
+            # every box with psutil. Fall through to the shared tail instead.
+            return pids + ([p for p in _discover_launcher_child_pids(target)
+                            if p not in pids] if sys.platform != "win32" else [])
         except Exception:
             pids = []  # psutil enumeration itself broke — fall through to native
     try:
@@ -1409,8 +1449,11 @@ def _discover_agent_pids(target: str) -> list:
                         pass
                     block_pid = None
         else:
+            # task 3ed8781d: pattern WITHOUT the target so bare-name spawns
+            # (`run "agent"`) are candidates too; the exact tok filter below
+            # keeps the kill set tight.
             out = subprocess.run(
-                ["pgrep", "-f", f"meshcode run {target}"],
+                ["pgrep", "-f", "meshcode.* run "],
                 capture_output=True, text=True, timeout=8).stdout
             for ln in out.split():
                 try:
@@ -1494,12 +1537,17 @@ def _discover_serve_pids(target: str) -> list:
     sibling agent's serve (same project, different agent) can never match. psutil-only
     (environ() needs a real process handle); without psutil returns [] — degraded but
     safe, and the session-root tree kill still takes any serve that is STILL parented
-    under the session."""
+    under the session.
+
+    BARE-TARGET support (task 3ed8781d): a bare `agent` target (the protocol-handler
+    relaunch reconcile) matches on MESHCODE_AGENT alone — the relaunch click means
+    'fresh session of THIS agent on this box', so any project's orphan of that name
+    is a survivor to clear. Qualified targets keep the exact two-field match."""
     ps = _psutil()
     if ps is None:
         return []
-    proj, _, agent = target.partition("/")
-    if not proj or not agent:
+    proj, _, agent = target.rpartition("/")
+    if not agent:
         return []
     own = _own_pid()
     out = []
@@ -1512,7 +1560,8 @@ def _discover_serve_pids(target: str) -> list:
                 if "meshcode" not in cl or "serve" not in cl or "meshcode_mcp" not in cl:
                     continue
                 env = p.environ() or {}
-                if env.get("MESHCODE_PROJECT") == proj and env.get("MESHCODE_AGENT") == agent:
+                if env.get("MESHCODE_AGENT") == agent and \
+                        (not proj or env.get("MESHCODE_PROJECT") == proj):
                     out.append(p.pid)
             except Exception:
                 continue  # process vanished / access denied — never block the sweep
@@ -1527,10 +1576,16 @@ def _kill_heartbeat_fork(target: str) -> None:
     would keep POSTing and show a stopped agent 'online'. Stop it by its pidfile
     heartbeat_<proj>_<name>.pid. Best-effort."""
     try:
-        proj, _, agent = target.partition("/")
+        proj, _, agent = target.rpartition("/")
         if not agent:
             return
-        pidf = STATE_DIR / f"heartbeat_{proj}_{agent}.pid"
+        if proj:
+            pidf = STATE_DIR / f"heartbeat_{proj}_{agent}.pid"
+        else:
+            # bare target (task 3ed8781d, protocol-handler reconcile): project
+            # unknown — glob the agent's pidfile across projects (first hit).
+            cands = sorted(STATE_DIR.glob(f"heartbeat_*_{agent}.pid"))
+            pidf = cands[0] if cands else STATE_DIR / f"heartbeat__{agent}.pid"
         if not pidf.exists():
             return
         try:
@@ -1562,15 +1617,25 @@ def _write_stop_marker(target: str) -> None:
     (6/6 needed SIGKILL), so the wrapper sees rc=137 — indistinguishable from
     a crash by exit code alone. The wrapper treats a non-zero rc as a CLEAN
     stop (closes its own tab) only when this marker exists and is fresh;
-    real crashes have no marker and keep their scrollback open. Best-effort."""
+    real crashes have no marker and keep their scrollback open. Best-effort.
+
+    DUAL-LABEL FIX (task 3ed8781d, Windows tab accumulation): the launcher script
+    computes its marker name from ITS OWN spawn cmd — hostd spawns carry
+    'project/agent' (label 'project_agent') but protocol-handler launch-batch spawns
+    carry the BARE agent name (label 'agent'). A stop that only stamped the
+    target-form marker left a bare-spawned wrapper seeing rc!=0 WITHOUT its marker
+    -> `pause` -> dead wt tab held open forever; relaunch then added a fresh tab
+    (Samuel: 'demasiadas tabs'). Stamp BOTH labels — both are consumed/GC'd."""
     try:
-        # EXACT mirror of protocol_handler._launcher_label's sanitization —
-        # the wrapper computes the same name at generation time.
-        safe = re.sub(r"[^A-Za-z0-9_.-]", "_", target.strip()).strip("_")[:80]
-        if not safe:
-            return
         STATE_DIR.mkdir(parents=True, exist_ok=True)
-        (STATE_DIR / f"stopmark_{safe}").write_text(str(time.time()), encoding="utf-8")
+        labels = {target.strip(), target.rpartition("/")[2].strip()}
+        for raw in labels:
+            # EXACT mirror of protocol_handler._launcher_label's sanitization —
+            # the wrapper computes the same name at generation time.
+            safe = re.sub(r"[^A-Za-z0-9_.-]", "_", raw).strip("_")[:80]
+            if not safe:
+                continue
+            (STATE_DIR / f"stopmark_{safe}").write_text(str(time.time()), encoding="utf-8")
     except Exception:
         pass
 
@@ -1589,9 +1654,10 @@ def _session_root_pid(target: str, pid: int) -> int:
     ps = _psutil()
     if ps is None:
         return pid
-    # optional opening quote: the Windows spawn cmdline quotes the target (see
-    # _discover_agent_pids QUOTED-TARGET FIX) — same token everywhere.
-    tok = re.compile(r"run\s+[\"']?" + re.escape(target) + r"(?=\s|$|[\"'])")
+    # Same token everywhere (task 3ed8781d): _run_token_rx accepts the quoted AND the
+    # bare-name spawn forms, so the climb also reaches the wrapper of a protocol-
+    # handler-launched session (`run "agent"`).
+    tok = _run_token_rx(target)
     anc = _own_ancestry_pids()
     root = pid
     try:
@@ -2122,57 +2188,6 @@ def _do_recycles(api_key: str, host_id: str) -> int:
     # it stays dead even if a schedule row reappears. Crash-RESPAWN (_do_respawns) is
     # UNAFFECTED — only RECYCLE triggers are killed.
     return 0
-    cfg = _rpc("mc_host_config_get", {"p_api_key": api_key, "p_host_id": host_id})
-    if not cfg or not cfg.get("ok"):
-        return 0
-    pol = _rpc("mc_host_recycle_policy", {"p_api_key": api_key, "p_host_id": host_id})
-    mode = (pol or {}).get("recycle_mode")
-    value = (pol or {}).get("recycle_value")
-    if mode != "time" or not value:
-        return 0  # context-recycle is agent-cooperative; only time is daemon-driven
-    st = _load_state()
-    now = time.time()
-    n = 0
-    seen = set()
-    for a in cfg.get("agents", []):
-        if a.get("desired_state") != "running":
-            continue
-        proj, agent = a.get("project_name"), a.get("name")
-        if not proj or not agent:
-            continue
-        key = f"{a.get('project_id')}/{agent}"
-        seen.add(key)
-        first = st.get(key)
-        if first is None:
-            st[key] = now  # start the uptime clock on first observation
-            continue
-        if (a.get("status") or "") in BUSY_STATUSES:
-            continue  # task boundary only — never mid-task
-        if (now - first) >= float(value) * 3600.0:
-            _log(f"RECYCLE {proj}/{agent} (uptime {(now-first)/3600:.1f}h >= {value}h)")
-            # Server-authorized clean-exit (task 548c863e, mig 364): SIGNAL the
-            # recycle instead of spawning. A direct _spawn_agent here duplicates
-            # the still-alive process. mc_request_recycle sets a flag; the
-            # agent's wait-loop consumes it, returns must_exit/reason=recycle,
-            # exits CLEAN (Stop-hook writes the handoff), then the respawn path
-            # (_do_respawns) relaunches it fresh. Recorded via mc_record_recycle
-            # so it's NEVER counted against the crash respawn cap.
-            req = _rpc("mc_request_recycle",
-                       {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
-            if req and req.get("ok") and req.get("requested"):
-                _rpc("mc_record_recycle",
-                     {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
-                st[key] = now  # reset clock after signaling recycle
-                n += 1
-            elif req and req.get("ok") and not req.get("requested"):
-                # Agent flipped busy between the roster read and the request —
-                # skip; retry next sweep at the next task boundary.
-                _log(f"SKIP recycle {proj}/{agent}: {req.get('reason','not_requested')}")
-    # prune state for agents no longer managed on this host
-    for k in [k for k in st if k not in seen]:
-        st.pop(k, None)
-    _save_state(st)
-    return n
 
 
 # ------------------------------------------------------------------
@@ -2502,10 +2517,6 @@ def _hostd_bootstrap(verbose: bool = False) -> bool:
         return False
 
 
-# a69ac010-C: after this many version-recycles at the SAME cv with no advance, STOP (env won't converge).
-_VERREC_MAX_ATTEMPTS = 3
-
-
 def _do_version_recycles(api_key: str, host_id: str) -> int:
     """Recycle managed agents running an OLDER meshcode than what's installed on disk so they pick up
     the auto-updated version (task 14782bb4 D). GRACIOUS (guardrail #5): idle-only (NEVER a BUSY agent /
@@ -2516,77 +2527,6 @@ def _do_version_recycles(api_key: str, host_id: str) -> int:
     # This was the env-mismatch storm source; fixed-at-source via run_agent env-sync, but the
     # whole recycle feature is being removed per owner. Crash-RESPAWN is unaffected.
     return 0
-    cfg = _rpc("mc_host_config_get", {"p_api_key": api_key, "p_host_id": host_id})
-    if not cfg or not cfg.get("ok"):
-        return 0
-    try:
-        from meshcode import self_update as _su
-        disk = _su._current_version()
-    except Exception:
-        return 0
-    if not disk:
-        return 0
-    st = _load_state()
-    now = time.time()
-    n = 0
-    for a in cfg.get("agents", []):
-        if a.get("desired_state") != "running":
-            continue
-        cv = a.get("cli_version")
-        if not cv:
-            continue
-        try:
-            if not _su._is_newer(disk, cv):
-                continue  # agent already on the on-disk version (or newer) — nothing to do
-        except Exception:
-            continue
-        if _agent_connected(a):
-            continue  # Samuel rule: never version-recycle a CONNECTED agent (live MCP session,
-                      # even if idle/standby) — the >3h uptime lifecycle (_do_recycles) is the
-                      # only recycle that may touch a connected agent.
-        proj, agent = a.get("project_name"), a.get("name")
-        if not proj or not agent:
-            continue
-        if _recycle_blocked(st, f"{proj}/{agent}", now):
-            continue  # 451d33a0 unify: already blocked as a non-converging recycle — don't also version-recycle it
-        key = f"verrec/{a.get('project_id')}/{agent}"
-        if now - float(st.get(key, 0) or 0) < 1800:
-            continue  # rate-limit: <=1 version-recycle per agent / 30min (no recycle-storm)
-        # a69ac010-C CONVERGENCE GUARD: if we've already version-recycled this agent _VERREC_MAX_ATTEMPTS
-        # times at THIS exact cv and it never advanced, the agent's spawn env is OLDER than hostd's disk
-        # and recycling will NEVER converge (respawn pulls the same stale env -> same cv -> recycle again).
-        # STOP + alert ONCE instead of version-recycling every 30min forever (the env-mismatch storm RC).
-        conv_key = f"verrec_conv/{a.get('project_id')}/{agent}"
-        conv = dict(st.get(conv_key) or {})
-        if conv.get("cv") == cv and int(conv.get("count", 0)) >= _VERREC_MAX_ATTEMPTS:
-            if not conv.get("alerted"):
-                conv["alerted"] = True
-                st[conv_key] = conv
-                _save_state(st)
-                _log(f"VERSION-RECYCLE STUCK {proj}/{agent}: still {cv} after {conv['count']} recycles "
-                     f"(disk {disk}); spawn env older than hostd — align it (e.g. "
-                     f"~/meshcode-env/bin/pip install -U meshcode). BLOCKING further version-recycles "
-                     f"until cv advances. [recycle_blocked_reason=version_no_converge]")
-            continue
-        req = _rpc("mc_request_recycle",
-                   {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
-        if req and req.get("ok") and req.get("requested"):
-            _rpc("mc_record_recycle",
-                 {"p_api_key": api_key, "p_project_id": a.get("project_id"), "p_agent_name": agent})
-            st[key] = now
-            # advance convergence counter for THIS cv; a cv change (env fixed) resets + releases the guard.
-            if conv.get("cv") == cv:
-                conv["count"] = int(conv.get("count", 0)) + 1
-            else:
-                conv = {"cv": cv, "count": 1}
-            conv["alerted"] = False
-            st[conv_key] = conv
-            n += 1
-            _log(f"VERSION-RECYCLE {proj}/{agent}: running {cv} < disk {disk} — recycle at idle to update "
-                 f"(attempt {conv['count']}/{_VERREC_MAX_ATTEMPTS})")
-    if n:
-        _save_state(st)
-    return n
 
 
 # c301be69: hold the singleton lock handle for the daemon's lifetime — module

{meshcode-2.11.134 → meshcode-2.11.136}/meshcode/meshcode_mcp/backend.py

@@ -907,16 +907,21 @@ def take_memory_hints() -> List[Dict]:
     return out
 
 
-def read_inbox(project_id: str, agent: str, mark_read: bool = True, api_key: Optional[str] = None) -> List[Dict]:
-    # Use SECURITY DEFINER RPC when api_key is available (bypasses RLS safely)
+def read_inbox(project_id: str, agent: str, mark_read: bool = True, api_key: Optional[str] = None,
+               rpc_result: Optional[Dict] = None) -> List[Dict]:
+    # Use SECURITY DEFINER RPC when api_key is available (bypasses RLS safely).
+    # rpc_result (mig 521 wait-drain): a pre-fetched mc_read_inbox payload (the
+    # 'inbox' field of mc_wait_poll v5). When given, skip the RPC and run the
+    # identical post-process (decrypt, memory_hints, ack) on it.
     global _LAST_MEMORY_HINTS
     if api_key:
-        rpc_result = sb_rpc("mc_read_inbox", {
-            "p_api_key": api_key,
-            "p_project_id": project_id,
-            "p_agent_name": agent,
-            "p_mark_read": mark_read,
-        })
+        if rpc_result is None:
+            rpc_result = sb_rpc("mc_read_inbox", {
+                "p_api_key": api_key,
+                "p_project_id": project_id,
+                "p_agent_name": agent,
+                "p_mark_read": mark_read,
+            })
         if isinstance(rpc_result, dict) and rpc_result.get("ok"):
             # mig 220: stash memory_hints so the calling tool can attach
             # them to its response. Reset on every call so stale hints

{meshcode-2.11.134 → meshcode-2.11.136}/meshcode/meshcode_mcp/server.py

@@ -3665,6 +3665,11 @@ def _wait_poll_or_legacy() -> Dict[str, Any]:
                 "p_api_key": api_key,
                 "p_project_id": _PROJECT_ID,
                 "p_agent_name": AGENT_NAME,
+                # wait-loop fase 2 (proposal 0bd63160, mig 521): the server
+                # folds read_inbox INTO the poll when there is pending mail —
+                # a message-carrying cycle is 1 RPC instead of 2. mc_wait_poll
+                # v5 (5-arg, default false) serves old SDKs unchanged.
+                "p_drain_inbox": True,
             })
             if isinstance(resp, dict) and resp.get("ok"):
                 return {
@@ -3677,6 +3682,9 @@ def _wait_poll_or_legacy() -> Dict[str, Any]:
                     # Surface it so the caller folds that RPC away. None on
                     # the legacy path = caller must count_pending itself.
                     "pending_count": resp.get("pending_count"),
+                    # mig 521: pre-drained mc_read_inbox result (same shape the
+                    # RPC returns) — present only when pending_count>0.
+                    "inbox": resp.get("inbox"),
                     "_via": "mc_wait_poll",
                 }
     except Exception as e:
@@ -3687,21 +3695,30 @@ def _wait_poll_or_legacy() -> Dict[str, Any]:
         "stop": _check_stop_request(),
         "tasks": _get_pending_tasks_summary(),
         "pending_count": None,
+        "inbox": None,
         "_via": "legacy",
     }
 
 
-def _drain_unread_response(include_acks: bool) -> Optional[Dict[str, Any]]:
+def _drain_unread_response(include_acks: bool,
+                           rpc_result: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
     """SDK-EFF (task ab1f9f5a): read+mark unread DB messages and shape them as
     a wait response. Extracted from the inner-loop's old final-fallback tail so
     the outer loop can invoke it only when mc_wait_poll reports pending_count>0
     (was: an unconditional count_pending every idle cycle). Returns None when
-    nothing real (acks only / already seen) was found."""
+    nothing real (acks only / already seen) was found.
+
+    rpc_result (mig 521, proposal 0bd63160): pre-drained mc_read_inbox payload
+    embedded in the mc_wait_poll v5 response ('inbox' key). When given, NO
+    read_inbox RPC fires — backend.read_inbox still runs its full post-process
+    (decrypt, memory_hints, ack) on the embedded payload, so semantics are
+    byte-identical to the 2-RPC path."""
     try:
         api_key = _get_api_key()
         if not api_key:
             return None
-        raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=api_key)
+        raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=api_key,
+                            rpc_result=rpc_result)
         if not raw:
             return None
         msgs = [
@@ -4591,7 +4608,10 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                     except Exception:
                         _db_pending = 0
                 if _db_pending > 0:
-                    _drained = _drain_unread_response(include_acks)
+                    # mig 521: the poll already drained the inbox server-side
+                    # (1 RPC); pass it through. None => classic read_inbox RPC.
+                    _drained = _drain_unread_response(include_acks,
+                                                      rpc_result=_wp.get("inbox"))
                     if _drained:
                         result = _drained
                         _set_state("online", "")

{meshcode-2.11.134 → meshcode-2.11.136}/meshcode/protocol_handler.py

@@ -1047,6 +1047,7 @@ def cmd_launch_batch(agent_names: Iterable[str], repo_path: Optional[str] = None
 
     launched: list[str] = []
     skipped: list[dict] = []
+    reconciled: dict = {}   # agent -> surviving session trees killed pre-spawn (3ed8781d)
 
     # Resolve `meshcode` binary path (CLI wrapper installed by pip).
     mc_bin = shutil.which("meshcode") or "meshcode"
@@ -1094,6 +1095,22 @@ def cmd_launch_batch(agent_names: Iterable[str], repo_path: Optional[str] = None
             skipped.append({"agent": name,
                             "reason": f"cooldown {_LAUNCH_COOLDOWN_S}s (recently launched)"})
             continue
+        # RELAUNCH RECONCILIATION (task 3ed8781d — the hostd respawn path has had this
+        # since 14e0760c, but THIS path — every FE Start click — never did): a
+        # stopped-but-surviving session (stale heartbeat, so DEDUP 1 doesn't see it)
+        # would get a fresh session spawned ON TOP, splitting the inbox and stacking
+        # wt tabs (Samuel's Windows box: up to 3 sessions/tabs per agent). Kill any
+        # surviving session tree of this agent BEFORE opening the new one — strictly
+        # pre-spawn, so the fresh session can never be in the kill set. hostd's
+        # machinery (token discovery + tree kill + stop-marker so the old tab
+        # self-closes) accepts bare names since task 3ed8781d. Best-effort.
+        try:
+            from meshcode import hostd as _hostd
+            _rec = _hostd._reconcile_target(name)
+            if _rec:
+                reconciled[name] = _rec
+        except Exception:
+            pass
         # PER-PLATFORM quoting (mesh-core FIX2): cmd.exe wants double-quotes, not POSIX shlex
         # single-quotes (cmd.exe passes single-quotes through literally -> file-not-found).
         if sys.platform == "win32":
@@ -1113,6 +1130,8 @@ def cmd_launch_batch(agent_names: Iterable[str], repo_path: Optional[str] = None
         "agents": launched,
         "skipped": skipped,
     }
+    if reconciled:
+        out["reconciled"] = reconciled
     print(json.dumps(out))
     return 0 if not skipped else 1
 

{meshcode-2.11.134 → meshcode-2.11.136}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.134 → meshcode-2.11.136}/pyproject.toml

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

{meshcode-2.11.134 → meshcode-2.11.136}/tests/test_hostd_zombie_sessions.py

@@ -34,13 +34,17 @@ class FakeNoSuchProcess(Exception):
 
 
 class FakeProc:
-    def __init__(self, table, pid, ppid, cmdline, name="", env=None):
+    def __init__(self, table, pid, ppid, cmdline, name="", env=None, cwd=""):
         self._table = table
         self.pid = pid
         self._ppid = ppid
         self._cmdline = cmdline
         self._name = name or (cmdline.split()[0] if cmdline else "")
         self._env = env or {}
+        self._cwd = cwd
+
+    def cwd(self):
+        return self._cwd
 
     # --- psutil.Process API surface used by hostd ---
     def cmdline(self):
@@ -81,8 +85,8 @@ class FakePsutil:
         self.live = set()
         self.killed = []   # kill order, for pre-spawn ordering assertions
 
-    def add(self, pid, ppid, cmdline, name="", env=None):
-        self.procs[pid] = FakeProc(self, pid, ppid, cmdline, name=name, env=env)
+    def add(self, pid, ppid, cmdline, name="", env=None, cwd=""):
+        self.procs[pid] = FakeProc(self, pid, ppid, cmdline, name=name, env=env, cwd=cwd)
         self.live.add(pid)
         return self.procs[pid]
 
@@ -427,5 +431,139 @@ class DiscoveryTests(ZombieFixBase):
         self.assertEqual(hostd._discover_agent_pids(TARGET), [qa["run"]])
 
 
+class BareNameSpawnTests(ZombieFixBase):
+    """task 3ed8781d — the Windows stop-por-RPC + relaunch zombie. protocol_handler's
+    cmd_launch_batch (every FE Start click) spawns `meshcode run "agent"` (BARE name);
+    the old per-site token (`run <project/agent>`) never matched it, so stop/reap/
+    reconcile found nothing -> sessions + wt tabs stacked up to 3 per agent."""
+
+    def add_bare_session(self, base, agent="qa", cwd=""):
+        """Protocol-handler-shaped tree: cmd wrapper runs the launcher SCRIPT (no
+        token in its cmdline post-a4001d59) -> python `run "<agent>"` (bare)."""
+        self.ps.add(50, 1, "WindowsTerminal.exe", name="WindowsTerminal.exe")
+        self.ps.add(base, 50,
+                    f'cmd /c C:\\u\\.meshcode\\launchers\\{agent}.cmd',
+                    name="cmd.exe")
+        self.ps.add(base + 1, base, f'C:\\py\\python.exe -m meshcode run "{agent}"',
+                    name="python.exe", cwd=cwd)
+        self.ps.add(base + 2, base + 1, "C:\\claude\\claude.exe --session x",
+                    name="claude.exe")
+        return {"cmd": base, "run": base + 1, "claude": base + 2}
+
+    def test_qualified_target_discovers_bare_spawn(self):
+        """LOAD-BEARING: hostd stop sweeps (target 'proj/agent') must find a
+        protocol-launched session whose cmdline is `run "agent"`."""
+        self.add_hostd()
+        s = self.add_bare_session(100)
+        self.assertEqual(hostd._discover_agent_pids(TARGET), [s["run"]])
+
+    def test_bare_target_discovers_qualified_spawn(self):
+        """Reverse direction: the protocol-handler relaunch reconcile (bare 'qa')
+        must find a hostd-spawned session (`run "mesh-core/qa"`)."""
+        self.add_hostd()
+        qa = self.add_session(100)
+        self.assertEqual(hostd._discover_agent_pids("qa"), [qa["run"]])
+
+    def test_bare_forms_keep_prefix_safety(self):
+        """'qa' must never match 'qa-2' in either form."""
+        self.add_hostd()
+        self.ps.add(601, 1, 'python.exe -m meshcode run "qa-2"', name="python.exe")
+        self.ps.add(602, 1, 'python.exe -m meshcode run "mesh-core/qa-2"', name="python.exe")
+        self.assertEqual(hostd._discover_agent_pids(TARGET), [])
+        self.assertEqual(hostd._discover_agent_pids("qa"), [])
+
+    def test_bare_match_foreign_project_cwd_is_skipped(self):
+        """Cross-mesh guard: a bare-spawned 'qa' whose cwd is ANOTHER project's
+        workspace (~/meshcode/<other>-qa) is not killable via 'mesh-core/qa'."""
+        self.add_hostd()
+        self.add_bare_session(100, cwd="C:\\u\\meshcode\\other-mesh-qa")
+        self.assertEqual(hostd._discover_agent_pids(TARGET), [])
+
+    def test_bare_match_own_project_cwd_is_accepted(self):
+        self.add_hostd()
+        s = self.add_bare_session(100, cwd="C:\\u\\meshcode\\mesh-core-qa")
+        self.assertEqual(hostd._discover_agent_pids(TARGET), [s["run"]])
+
+    def test_stop_kills_bare_spawned_session_tree(self):
+        """End-to-end: desired_state='stopped' takes down the protocol-launched
+        tree (python run + claude); the launcher cmd wrapper SURVIVES by design
+        (no token in its cmdline) to run the stopmark epilogue -> tab self-closes."""
+        self.add_hostd()
+        s = self.add_bare_session(100)
+        self.rpc.script("mc_agents_to_stop",
+                        {"ok": True, "agents": [{"project_name": "mesh-core", "agent": "qa"}]})
+        n = hostd._do_stops("k", "h")
+        self.assertEqual(n, 1)
+        self.assertNotIn(s["run"], self.ps.live, "bare-spawned run survived the stop")
+        self.assertNotIn(s["claude"], self.ps.live, "bare-spawned claude survived the stop")
+        self.assertIn(50, self.ps.live, "terminal host was killed")
+
+    def test_serve_discovery_bare_target_matches_agent_env(self):
+        self.ps.add(200, 1, "python.exe -m meshcode.meshcode_mcp serve", name="python.exe",
+                    env={"MESHCODE_PROJECT": "mesh-core", "MESHCODE_AGENT": "qa"})
+        self.assertEqual(hostd._discover_serve_pids("qa"), [200])
+        self.assertEqual(hostd._discover_serve_pids("backend"), [])
+
+
+class StopMarkerDualLabelTests(unittest.TestCase):
+    """task 3ed8781d — _write_stop_marker must stamp BOTH the target-form label
+    (hostd spawns) and the bare-agent label (protocol-handler spawns): the launcher
+    script checks the label derived from ITS OWN spawn cmd, and a missing marker
+    flips an intentional stop into a `pause`-held dead wt tab."""
+
+    def test_writes_both_labels(self):
+        import tempfile
+        from pathlib import Path
+        with tempfile.TemporaryDirectory() as td:
+            with mock.patch.object(hostd, "STATE_DIR", Path(td)):
+                hostd._write_stop_marker("mesh-core/qa")
+                names = sorted(p.name for p in Path(td).glob("stopmark_*"))
+        self.assertEqual(names, ["stopmark_mesh-core_qa", "stopmark_qa"])
+
+    def test_bare_target_writes_single_label(self):
+        import tempfile
+        from pathlib import Path
+        with tempfile.TemporaryDirectory() as td:
+            with mock.patch.object(hostd, "STATE_DIR", Path(td)):
+                hostd._write_stop_marker("qa")
+                names = sorted(p.name for p in Path(td).glob("stopmark_*"))
+        self.assertEqual(names, ["stopmark_qa"])
+
+
+class LaunchBatchReconcileTests(unittest.TestCase):
+    """task 3ed8781d — cmd_launch_batch (every FE Start click / launch-url) must
+    reconcile surviving sessions pre-spawn, like the hostd respawn path has since
+    14e0760c."""
+
+    def _run(self, reconcile_side_effect):
+        from meshcode import protocol_handler as ph
+        import json as _json
+        printed = []
+        with mock.patch.object(ph, "live_agent_names", lambda names, project=None: set()), \
+             mock.patch.object(ph, "_read_cooldowns", lambda: {}), \
+             mock.patch.object(ph, "_record_spawn", lambda n, now=None: None), \
+             mock.patch.object(ph, "_spawn_terminal", lambda cmd: (True, "wt(fleet-tab)")), \
+             mock.patch.object(hostd, "_reconcile_target", reconcile_side_effect), \
+             mock.patch("builtins.print", lambda *a, **k: printed.append(a[0] if a else "")):
+            rc = ph.cmd_launch_batch(["qa"])
+        return rc, _json.loads(printed[-1])
+
+    def test_reconcile_called_before_spawn_and_reported(self):
+        calls = []
+        rc, out = self._run(lambda name: calls.append(name) or 2)
+        self.assertEqual(rc, 0)
+        self.assertEqual(calls, ["qa"])
+        self.assertEqual(out.get("reconciled"), {"qa": 2})
+        self.assertEqual(out["agents"], ["qa"])
+
+    def test_reconcile_failure_never_blocks_launch(self):
+        def boom(name):
+            raise RuntimeError("psutil exploded")
+        rc, out = self._run(boom)
+        self.assertEqual(rc, 0)
+        self.assertEqual(out["agents"], ["qa"])
+        self.assertNotIn("reconciled", out)
+
+
 if __name__ == "__main__":
     unittest.main()