meshcode 2.11.157__tar.gz → 2.11.159__tar.gz

{meshcode-2.11.157 → meshcode-2.11.159}/PKG-INFO

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

{meshcode-2.11.157 → meshcode-2.11.159}/meshcode/__init__.py

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

{meshcode-2.11.157 → meshcode-2.11.159}/meshcode/__main__.py

@@ -13,7 +13,7 @@ def main():
     # (comms_v4), not just setup-path. hostd spawns agents via `python -m meshcode run <target>`
     # (so a bg pip can replace the .exe) — that MUST route to the `run` dispatch, NOT fall through
     # to the PATH-help error. Previously only setup-path dispatched, so every `python -m meshcode
-    # run` died with the misleading "meshcode not on PATH" message (qa/recycle-demo/respawn boots).
+    # run` died with the misleading "meshcode not on PATH" message (qa/respawn boots).
     if len(sys.argv) > 1:
         # runpy imports + executes comms_v4 as __main__; do NOT pre-import it here (a prior
         # `import meshcode.comms_v4` triggers a runpy "found in sys.modules" double-exec warning).

{meshcode-2.11.157 → meshcode-2.11.159}/meshcode/_session_handoff_template.py

@@ -1,12 +1,12 @@
 """Session-handoff hook templates — single source of truth for the
 PreCompact (write) + SessionStart (read) hooks.
 
-CTX-CLOSE-RELAUNCH (task bcd157a9, backend2): when a commander/agent session
-gets recycled at high context — either by Claude Code's in-place autocompact
-or by a clean close+relaunch — the IN-FLIGHT working context (which task I was
-mid-executing, what I just edited/decided this session) is lost. meshcode_boot
-restores mesh state (tasks, inbox, memory) authoritatively, but NOT the
-conversational thread. These two hooks bridge that gap:
+SESSION HANDOFF (task bcd157a9, backend2): when a session ends or compacts at
+high context — either by Claude Code's in-place autocompact or by a manual
+relaunch — the IN-FLIGHT working context (which task I was mid-executing, what
+I just edited/decided this session) is lost. meshcode_boot restores mesh state
+(tasks, inbox, memory) authoritatively, but NOT the conversational thread.
+These two hooks bridge that gap:
 
   * PreCompact  -> session_handoff_write.py: dump a compact snapshot of the
     recent transcript tail to .claude/handoff.json BEFORE the context is
@@ -18,11 +18,8 @@ conversational thread. These two hooks bridge that gap:
 
 Stored as string constants (same pattern as _stop_hook_template.py) so
 `meshcode patch-hooks` can backfill existing workspaces without a full
-re-scaffold. The recycle TRIGGER itself (mc_request_recycle / wait-loop
-must_exit=recycle / hostd context branch) is owned by the daemon/server side
-and is intentionally NOT in these scripts — handoff preservation is decoupled
-from whatever causes the restart, so it works for autocompact, clean recycle,
-crash-respawn, or a manual relaunch alike.
+re-scaffold. Handoff preservation is decoupled from whatever causes the
+restart, so it works for autocompact, crash-respawn, or a manual relaunch alike.
 """
 
 # Shared constants kept in sync between the two bodies.
@@ -33,9 +30,9 @@ _HANDOFF_MAX_AGE_S = 24 * 3600   # ignore stale handoffs on read
 
 HANDOFF_WRITE_BODY = '''#!/usr/bin/env python3
 """PreCompact hook: snapshot the recent transcript tail to .claude/handoff.json
-so a fresh post-recycle session can resume the in-flight thread.
+so a fresh post-restart session can resume the in-flight thread.
 
-CTX-CLOSE-RELAUNCH (task bcd157a9). Pure local file I/O — never touches the
+SESSION HANDOFF (task bcd157a9). Pure local file I/O — never touches the
 network, never imports meshcode, never blocks. Any failure is swallowed and the
 hook exits 0 so it can NEVER stall or break a Claude Code compaction/exit.
 
@@ -113,61 +110,13 @@ def _extract_tail(transcript_path: str):
     return rows[-MAX_TURNS:]
 
 
-def _request_recycle_if_marked(project_dir) -> None:
-    """CTX-CLOSE-RELAUNCH (task 400fc536): commander-tier sessions ask the
-    server to recycle (close+relaunch fresh) at the next task-edge, right after
-    the handoff is snapshotted. Gated by the scaffold-baked
-    .claude/meshcode_hook_ctx.json recycle_on_compact flag (commander-only v1).
-
-    Best-effort in every dimension: missing marker/flag, missing creds, import
-    failure, network error -> silently skip. handoff.json is already written, so
-    a context-recycle still relaunches WITH context; and the actual exit is the
-    server's call (mc_consume_recycle at a task boundary), never this hook.
-    """
-    try:
-        ctx_path = project_dir / ".claude" / "meshcode_hook_ctx.json"
-        if not ctx_path.exists():
-            return
-        if not json.loads(ctx_path.read_text(encoding="utf-8")).get("recycle_on_compact"):
-            return  # non-commander -> in-place autocompact, no recycle
-        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")
-        pid = env.get("MESHCODE_PROJECT_ID"); agent = env.get("MESHCODE_AGENT")
-        if not (url and key and pid 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
-        import urllib.request as _u
-        body = json.dumps({
-            "p_api_key": api_key, "p_project_id": pid,
-            "p_agent_name": agent, "p_allow_busy": True,  # flag-now; exit deferred to wait-loop
-        }).encode("utf-8")
-        req = _u.Request(
-            url.rstrip("/") + "/rest/v1/rpc/mc_request_recycle",
-            data=body, method="POST",
-            headers={"apikey": key, "Authorization": "Bearer " + key,
-                     "Content-Type": "application/json"})
-        _u.urlopen(req, timeout=5).read()  # best-effort; ignore result per backend contract
-    except Exception as e:  # noqa: BLE001 — never block compaction
-        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.
+    Best-effort creds pattern — any failure silently skips; handoff.json
+    already covers the local path.
     """
     try:
         mcp = json.loads((project_dir / ".mcp.json").read_text(encoding="utf-8"))
@@ -305,9 +254,6 @@ def main() -> int:
     _persist_handoff_to_memory(_project_dir(), handoff)
     # py-half 4aee4739: dedicated handoff capsule -> mc_boot continuity_capsule.last_handoff.
     _send_session_handoff_capsule(_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())
     return 0
 
 
@@ -321,10 +267,10 @@ if __name__ == "__main__":
 
 HANDOFF_READ_BODY = '''#!/usr/bin/env python3
 """SessionStart hook: if a handoff snapshot exists, inject it as
-additionalContext so a freshly-recycled session resumes the in-flight thread,
+additionalContext so a freshly-relaunched session resumes the in-flight thread,
 then archive it so it is injected exactly once.
 
-CTX-CLOSE-RELAUNCH (task bcd157a9). Pure local file I/O — no network, no
+SESSION HANDOFF (task bcd157a9). Pure local file I/O — no network, no
 meshcode import, never blocks. meshcode_boot remains authoritative for mesh
 state; this only restores the conversational thread.
 
@@ -360,9 +306,9 @@ def _render(handoff: dict) -> str:
     if not turns:
         return ""
     lines = [
-        "## Recovered session handoff (CTX-CLOSE-RELAUNCH)",
+        "## Recovered session handoff",
         "",
-        "Your previous session was recycled at high context. meshcode_boot has "
+        "Your previous session ended or compacted at high context. meshcode_boot has "
         "the authoritative mesh state (tasks/inbox/memory); the thread tail "
         "below is the in-flight context that boot does not restore. Use it to "
         "resume what you were mid-doing, then run the normal boot loop.",

{meshcode-2.11.157 → meshcode-2.11.159}/meshcode/comms_v4.py

@@ -2509,7 +2509,7 @@ AGENT CONTROL:
   disconnect <proj> <name>                   Graceful disconnect
   whoami                                     Show logged-in identity
 
-SWARM (agent replicas):
+REPLICAS (agent clones):
   replicate <agent> --count N [--no-launch]  Clone agent into <agent>-1..N (launches by default)
   replica-power <group_id> running|stopped   Stop/Start a whole replica group [--restart]
   profile [agent]                            Show/set agent profile
@@ -2540,16 +2540,14 @@ Run `meshcode <command> --help` for help on a specific command.
 
 # Per-subcommand help texts
 SUBCOMMAND_HELP = {
-    "up": """meshcode up <project> [--agents a,b] [--recycle <ctx%|Nh>] [--visible]
+    "up": """meshcode up <project> [--agents a,b] [--visible]
 
 Launch-All: opens a visible terminal for each agent in the project and
 registers them as hostd-managed (so the watchdog daemon auto-relaunches
-and recycles them). The fast way to bring a whole team online at once.
+them if they crash). The fast way to bring a whole team online at once.
 
   meshcode up myproject                 launch every agent in the roster
   meshcode up myproject --agents a,b     launch only a and b
-  meshcode up myproject --recycle 80     set context-% recycle policy
-  meshcode up myproject --recycle 12h    set uptime recycle policy
 
 Roster comes from the cloud (exact names). Pair with `meshcode hostd
 install` so the launched team stays alive across crashes.
@@ -2557,18 +2555,16 @@ install` so the launched team stays alive across crashes.
     "hostd": """meshcode hostd run|status|install|uninstall
 
 Host-side watchdog daemon: auto-relaunches dead/stale managed agents
-(respawn) and recycles long-running ones (uptime/context, at task
-boundary). Complements supervisor.py (launchd KeepAlive = process-exit
-only); hostd polls the cloud for heartbeat staleness + recycle triggers.
+(respawn). Complements supervisor.py (launchd KeepAlive = process-exit
+only); hostd polls the cloud for heartbeat staleness.
 
   meshcode hostd run        run the poll loop in the foreground
   meshcode hostd status     show agents this host would respawn (JSON)
   meshcode hostd install    install the launchd agent (auto-start, KeepAlive)
   meshcode hostd uninstall  remove the launchd agent
 
-Agents are managed via mc_host_set_agents (desired_state=running) +
-mc_host_config_set (recycle policy). NOT autostart-login; the Launch
-button (meshcode://) kickstarts it.
+Agents are managed via mc_host_set_agents (desired_state=running).
+NOT autostart-login; the Launch button (meshcode://) kickstarts it.
 """,
     "init": """meshcode init
 
@@ -3404,9 +3400,9 @@ if __name__ == "__main__":
         # rows get desired_state='running' so hostd auto-spawns them as persistent
         # terminals within ~one sweep; --no-launch creates them dormant (Start later
         # from the dashboard or `meshcode replica-power <group> running`). The shared
-        # replica_group_id (== swarm_id) lets the whole group be powered as a unit
-        # while per-replica desired_state still allows killing one without the group.
-        # Backend for task 069b5550.
+        # replica_group_id (stored in the swarm_id column) lets the whole group be
+        # powered as a unit while per-replica desired_state still allows killing one
+        # without the group. Backend for task 069b5550.
         _ak = _load_api_key_for_cli()
         base = pos[0] if len(pos) > 0 else flags.get("agent", "")
         proj = flags.get("project")
@@ -3424,9 +3420,9 @@ if __name__ == "__main__":
             print("[meshcode] ERROR: --count must be an integer in 1..16")
             sys.exit(1)
         desired = None if flags.get("no-launch") else "running"
-        # p_mode (task 986947b5): copilotos = shared swarm_id (coordinate via one tray) |
-        # independientes = distinct swarm_id per replica (isolated). Default copilotos
-        # (Samuel's canonical spec). DB mig586 honors it on both overloads.
+        # p_mode (task 986947b5): copilotos = one shared replica group (coordinate
+        # together) | independientes = a distinct group per replica (isolated).
+        # Default copilotos (Samuel's canonical spec). DB mig586 honors it on both overloads.
         mode = str(flags.get("mode", "copilotos")).lower()
         if mode not in ("copilotos", "independientes"):
             print("[meshcode] ERROR: --mode must be 'copilotos' (shared/coordinate) or "
@@ -3475,9 +3471,9 @@ if __name__ == "__main__":
         # meshcode replica-power <group_id> running|stopped [--restart]
         #
         # Sets desired_state for EVERY agent sharing replica_group_id (Stop/Start the
-        # whole swarm as a unit). CLI/agent path = mc_replica_group_power_as_agent
+        # whole replica group as a unit). CLI/agent path = mc_replica_group_power_as_agent
         # (DB mig 20260616_573); the FE buttons call mc_replica_group_power (auth.uid,
-        # no api_key in the browser). --restart requests a recycle on launch.
+        # no api_key in the browser). --restart relaunches the group's terminals on power-on.
         # Backend for task 069b5550 (FE Stop/Start/Launch route through here).
         _ak = _load_api_key_for_cli()
         group = pos[0] if len(pos) > 0 else flags.get("group", "")
@@ -4097,14 +4093,14 @@ if __name__ == "__main__":
             print(f"Usage: meshcode supervisor [start|stop|status|--simple] <project> <agent>")
 
     elif cmd == "hostd":
-        # meshcode hostd run|status — local respawn/recycle watchdog daemon
+        # meshcode hostd run|status — local respawn watchdog daemon
         # (auto-relaunch of stale/dead managed agents; mesh-core incident fix).
         import importlib
         _hostd = importlib.import_module("meshcode.hostd")
         sys.exit(_hostd.cmd_hostd(pos))
 
     elif cmd == "up":
-        # meshcode up <project> [--agents a,b] [--recycle <ctx%|Nh>] — Launch-All:
+        # meshcode up <project> [--agents a,b] — Launch-All:
         # opens a visible terminal per agent + registers them as hostd-managed.
         import importlib
         _up = importlib.import_module("meshcode.up")