meshcode 2.11.104__tar.gz → 2.11.105__tar.gz

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

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

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

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

meshcode-2.11.105/meshcode/_session_handoff_template.py

@@ -0,0 +1,296 @@
+"""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:
+
+  * PreCompact  -> session_handoff_write.py: dump a compact snapshot of the
+    recent transcript tail to .claude/handoff.json BEFORE the context is
+    compacted/the session exits. Pure local file I/O — no creds, no network,
+    no MCP — so it is safe to run in any hook subprocess on any platform.
+  * SessionStart -> session_handoff_read.py: on the next (fresh) session,
+    inject that snapshot back as additionalContext so the agent resumes the
+    thread, then archive it so it is injected exactly once.
+
+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.
+"""
+
+# Shared constants kept in sync between the two bodies.
+_HANDOFF_FILENAME = "handoff.json"
+_HANDOFF_MAX_TURNS = 24          # transcript tail entries to preserve
+_HANDOFF_MAX_CHARS_PER_TURN = 1200
+_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.
+
+CTX-CLOSE-RELAUNCH (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.
+
+Claude Code passes a JSON event on stdin:
+  {"hook_event_name":"PreCompact","session_id":..,"transcript_path":..,
+   "trigger":"auto"|"manual", ...}
+"""
+import json
+import os
+import sys
+from pathlib import Path
+
+MAX_TURNS = 24
+MAX_CHARS_PER_TURN = 1200
+
+
+def _project_dir() -> Path:
+    # Claude Code exports CLAUDE_PROJECT_DIR for hooks; fall back to cwd.
+    return Path(os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd())
+
+
+def _text_from_message(msg) -> str:
+    """Flatten a transcript message's content into plain text + tool markers."""
+    if isinstance(msg, str):
+        return msg
+    if not isinstance(msg, dict):
+        return ""
+    content = msg.get("content")
+    if isinstance(content, str):
+        return content
+    parts = []
+    if isinstance(content, list):
+        for block in content:
+            if not isinstance(block, dict):
+                continue
+            btype = block.get("type")
+            if btype == "text" and block.get("text"):
+                parts.append(str(block["text"]))
+            elif btype == "tool_use":
+                parts.append(f"[tool_use:{block.get('name','?')}]")
+            elif btype == "tool_result":
+                parts.append("[tool_result]")
+    return " ".join(parts).strip()
+
+
+def _extract_tail(transcript_path: str):
+    """Return up to MAX_TURNS (role, text) tuples from the end of the JSONL
+    transcript, skipping empty / meta-only entries."""
+    p = Path(transcript_path) if transcript_path else None
+    if not p or not p.exists():
+        return []
+    rows = []
+    try:
+        with p.open("r", encoding="utf-8", errors="replace") as fh:
+            for line in fh:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    obj = json.loads(line)
+                except (json.JSONDecodeError, ValueError):
+                    continue
+                msg = obj.get("message") if isinstance(obj, dict) else None
+                role = (obj.get("type") or (msg or {}).get("role") or "").strip()
+                if role not in ("user", "assistant", "human"):
+                    continue
+                text = _text_from_message(msg if msg is not None else obj)
+                if not text:
+                    continue
+                if len(text) > MAX_CHARS_PER_TURN:
+                    text = text[:MAX_CHARS_PER_TURN] + " …[truncated]"
+                rows.append(("user" if role in ("user", "human") else "assistant", text))
+    except OSError:
+        return []
+    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 main() -> int:
+    try:
+        raw = sys.stdin.read()
+        event = json.loads(raw) if raw.strip() else {}
+    except (json.JSONDecodeError, ValueError):
+        event = {}
+
+    tail = _extract_tail(event.get("transcript_path", ""))
+    handoff = {
+        "schema": 1,
+        "session_id": event.get("session_id"),
+        "trigger": event.get("trigger") or event.get("hook_event_name") or "precompact",
+        "agent": os.environ.get("MESHCODE_AGENT"),
+        "project": os.environ.get("MESHCODE_PROJECT"),
+        "turns": [{"role": r, "text": t} for (r, t) in tail],
+    }
+    try:
+        d = _project_dir() / ".claude"
+        d.mkdir(parents=True, exist_ok=True)
+        tmp = d / "handoff.json.tmp"
+        tmp.write_text(json.dumps(handoff, ensure_ascii=False, indent=2), encoding="utf-8")
+        tmp.replace(d / "handoff.json")
+    except OSError as e:
+        sys.stderr.write(f"[session_handoff_write] skipped: {e}\\n")
+    # 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
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as e:  # never break compaction
+        sys.stderr.write(f"[session_handoff_write] error: {e}\\n")
+        sys.exit(0)
+'''
+
+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,
+then archive it so it is injected exactly once.
+
+CTX-CLOSE-RELAUNCH (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.
+
+Claude Code passes a JSON event on stdin:
+  {"hook_event_name":"SessionStart","source":"startup"|"resume"|"compact",..}
+and reads our additionalContext from this hook's stdout JSON:
+  {"hookSpecificOutput":{"hookEventName":"SessionStart","additionalContext":..}}
+"""
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+MAX_AGE_S = 24 * 3600
+
+
+def _project_dir() -> Path:
+    return Path(os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd())
+
+
+def _emit(context: str) -> None:
+    sys.stdout.write(json.dumps({
+        "hookSpecificOutput": {
+            "hookEventName": "SessionStart",
+            "additionalContext": context,
+        }
+    }))
+
+
+def _render(handoff: dict) -> str:
+    turns = handoff.get("turns") or []
+    if not turns:
+        return ""
+    lines = [
+        "## Recovered session handoff (CTX-CLOSE-RELAUNCH)",
+        "",
+        "Your previous session was recycled 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.",
+        "",
+        f"_trigger: {handoff.get('trigger','?')} · turns preserved: {len(turns)}_",
+        "",
+    ]
+    for t in turns:
+        role = (t.get("role") or "?").upper()
+        text = (t.get("text") or "").strip()
+        if text:
+            lines.append(f"**{role}:** {text}")
+            lines.append("")
+    return "\\n".join(lines).strip()
+
+
+def main() -> int:
+    path = _project_dir() / ".claude" / "handoff.json"
+    if not path.exists():
+        return 0
+    try:
+        handoff = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, ValueError, OSError):
+        return 0
+
+    # Ignore stale snapshots (mtime-based; avoids resurrecting old threads).
+    try:
+        if (time.time() - path.stat().st_mtime) > MAX_AGE_S:
+            path.replace(path.with_suffix(".stale.json"))
+            return 0
+    except OSError:
+        pass
+
+    context = _render(handoff)
+    if context:
+        _emit(context)
+    # Archive so the handoff is injected exactly once.
+    try:
+        path.replace(path.with_suffix(".consumed.json"))
+    except OSError:
+        pass
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as e:
+        sys.stderr.write(f"[session_handoff_read] error: {e}\\n")
+        sys.exit(0)
+'''

meshcode-2.11.105/meshcode/claude_update.py

@@ -0,0 +1,258 @@
+"""Synchronous Claude Code CLI auto-update for `meshcode run`.
+
+Companion to self_update.py (which handles the `meshcode` Python package).
+When `meshcode run` launches an agent, this module probes the npm registry
+for the latest @anthropic-ai/claude-code release and runs `npm install -g`
+inline if the installed version is older. The launch BLOCKS until the
+upgrade finishes (or times out).
+
+This is intentional: Samuel's requirement is "siempre arrancar con la
+ultima version". The two-launch async model in self_update.py cannot
+satisfy that — it always uses the old binary on launch N. The blocking
+model trades ~5-30s extra latency on launches where an upgrade is
+available for the guarantee that the freshly-spawned editor uses the
+newest CLI.
+
+Skip conditions (any one → no-op):
+  - MESHCODE_NO_UPDATE=1 / --no-update on argv
+  - Inside an existing Claude Code session (CLAUDECODE=1)
+  - User pinned a specific version via env / prefs (let _resolve_pinned_claude handle it)
+  - Editor is not `claude` (cursor / code / codex / windsurf)
+  - npm not in PATH
+  - Network unreachable / npm registry down
+  - Already at latest version
+
+Failures are best-effort: any error prints a single WARN line and lets
+launch continue with whatever version is installed.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Optional, Tuple
+
+NPM_PKG = "@anthropic-ai/claude-code"
+NPM_REGISTRY_URL = f"https://registry.npmjs.org/{NPM_PKG}/latest"
+NETWORK_TIMEOUT_SEC = 2.5
+INSTALL_TIMEOUT_SEC = 90  # npm i -g can be slow on cold-cache machines
+
+STATE_DIR = Path.home() / ".meshcode"
+LOG_PATH = STATE_DIR / "claude_update.log"
+
+
+# ============================================================
+# Skip-condition helpers
+# ============================================================
+
+def _is_claude_session() -> bool:
+    """True if we're being called from inside an existing Claude Code session.
+
+    Replacing the npm binary while claude is running is unsafe and pointless
+    — the running claude won't pick up the new code anyway.
+    """
+    return os.environ.get("CLAUDECODE") == "1" or bool(os.environ.get("CLAUDE_CODE_SESSION"))
+
+
+def _update_disabled() -> bool:
+    # task 399d7b51 FIX A (unify): honor MESHCODE_NO_AUTO_UPDATE too. hostd launcher / run_agent /
+    # schtasks set that var to disable ALL launch-time auto-update; previously only the meshcode-pip
+    # path checked MESHCODE_NO_UPDATE, so the claude-CLI blocking update still fired (extra hang).
+    if os.environ.get("MESHCODE_NO_UPDATE") == "1":
+        return True
+    if os.environ.get("MESHCODE_NO_AUTO_UPDATE") == "1":
+        return True
+    if "--no-update" in sys.argv or "--no-auto-update" in sys.argv:
+        return True
+    return False
+
+
+def _resolve_user_pin() -> Optional[str]:
+    """Return a specific version pin if set; None if 'latest' / unset.
+
+    Sources checked (first non-empty wins):
+      1. MESHCODE_CLAUDE_VERSION env var
+      2. prefs['claude_version']
+
+    Note: 'latest' / 'none' / 'skip' values are treated as "no pin" — the
+    user wants whatever is current. We do NOT consult the global admin
+    config from mc_global_config here; if an admin pins a specific
+    version, _resolve_pinned_claude in run_agent.py will route through
+    npx regardless of what's installed locally.
+    """
+    pinned = (os.environ.get("MESHCODE_CLAUDE_VERSION") or "").strip()
+    if not pinned:
+        try:
+            from .preferences import load_prefs
+            pinned = (load_prefs().get("claude_version") or "").strip()
+        except Exception:
+            pinned = ""
+    if not pinned:
+        return None
+    if pinned.lower() in ("latest", "none", "skip"):
+        return None
+    return pinned
+
+
+# ============================================================
+# Version probes
+# ============================================================
+
+def _get_installed_version(editor_cmd: str) -> Optional[str]:
+    """Run `<editor_cmd> --version` and pull the first semver from stdout."""
+    try:
+        use_shell = sys.platform == "win32" and editor_cmd.lower().endswith((".cmd", ".bat"))
+        r = subprocess.run(
+            [editor_cmd, "--version"],
+            capture_output=True, text=True, timeout=10,
+            shell=use_shell,
+        )
+        m = re.search(r"\d+\.\d+\.\d+", r.stdout or "")
+        return m.group(0) if m else None
+    except Exception:
+        return None
+
+
+def _fetch_npm_latest() -> Optional[str]:
+    """GET https://registry.npmjs.org/<pkg>/latest — returns the JSON manifest
+    of the version tagged `latest`, with a `version` field.
+
+    Do NOT send the `application/vnd.npm.install-v1+json` Accept header
+    here: the slim-manifest content type is only valid on the package
+    ROOT (/<pkg>), not on /<pkg>/<tag>. Sending it on the tag endpoint
+    returns HTTP 406. Default Accept (*/*) gets the canonical JSON.
+    """
+    try:
+        import urllib.request
+        req = urllib.request.Request(NPM_REGISTRY_URL)
+        with urllib.request.urlopen(req, timeout=NETWORK_TIMEOUT_SEC) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+        v = data.get("version")
+        if isinstance(v, str):
+            return v
+    except Exception:
+        pass
+    return None
+
+
+def _version_tuple(v: str) -> Tuple[int, ...]:
+    parts = []
+    for p in v.split("."):
+        digits = "".join(c for c in p if c.isdigit())
+        parts.append(int(digits) if digits else 0)
+    return tuple(parts)
+
+
+def _is_newer(remote: str, local: str) -> bool:
+    try:
+        return _version_tuple(remote) > _version_tuple(local)
+    except Exception:
+        return False
+
+
+# ============================================================
+# Editor-stem detection (only act when editor is claude)
+# ============================================================
+
+def _editor_is_claude(editor_cmd: str) -> bool:
+    name = os.path.basename(editor_cmd).lower()
+    if sys.platform == "win32":
+        name = name.rsplit(".", 1)[0] if "." in name else name
+    return name == "claude"
+
+
+# ============================================================
+# Public entrypoint
+# ============================================================
+
+def check_and_maybe_update_claude_blocking(
+    editor_cmd: str,
+    verbose: bool = True,
+    timeout_sec: int = INSTALL_TIMEOUT_SEC,
+) -> Optional[str]:
+    """Probe npm + foreground-install latest claude if newer.
+
+    Returns the new version on successful upgrade, None otherwise.
+    Never raises — all errors are swallowed and logged via WARN line.
+    """
+    if _update_disabled():
+        return None
+    if _is_claude_session():
+        return None
+    if _resolve_user_pin():
+        return None
+    if not _editor_is_claude(editor_cmd):
+        return None
+
+    current = _get_installed_version(editor_cmd)
+    latest = _fetch_npm_latest()
+    if not current:
+        if verbose:
+            print(f"[meshcode] (Could not read claude --version; skipping auto-update)", file=sys.stderr)
+        return None
+    if not latest:
+        if verbose:
+            print(f"[meshcode] (Could not reach npm registry; staying on claude {current})", file=sys.stderr)
+        return None
+    if not _is_newer(latest, current):
+        if verbose:
+            print(f"[meshcode] claude {current} (already latest)", file=sys.stderr)
+        return None
+
+    npm = shutil.which("npm")
+    if not npm:
+        if verbose:
+            print(
+                f"[meshcode] WARN: claude {current} < {latest} on npm, but `npm` not in PATH; "
+                f"continuing on {current}",
+                file=sys.stderr,
+            )
+        return None
+
+    if verbose:
+        print(
+            f"[meshcode] Upgrading claude {current} -> {latest} (blocking, can take ~30s)...",
+            file=sys.stderr,
+        )
+
+    cmd = [npm, "install", "-g", f"{NPM_PKG}@{latest}"]
+    try:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        with open(LOG_PATH, "ab") as logf:
+            logf.write(
+                f"\n=== {time.strftime('%Y-%m-%d %H:%M:%S')} blocking "
+                f"npm i -g {NPM_PKG}@{latest} ===\n".encode()
+            )
+            logf.flush()
+            proc = subprocess.run(cmd, stdout=logf, stderr=logf, timeout=timeout_sec)
+        if proc.returncode == 0:
+            if verbose:
+                print(f"[meshcode]   claude upgraded to {latest}", file=sys.stderr)
+            return latest
+        if verbose:
+            print(
+                f"[meshcode] WARN: npm install exit {proc.returncode}; "
+                f"continuing on {current} (log: {LOG_PATH})",
+                file=sys.stderr,
+            )
+        return None
+    except subprocess.TimeoutExpired:
+        if verbose:
+            print(
+                f"[meshcode] WARN: npm install timed out after {timeout_sec}s; "
+                f"continuing on {current}",
+                file=sys.stderr,
+            )
+        return None
+    except Exception as e:
+        if verbose:
+            print(
+                f"[meshcode] WARN: npm install failed: {e}; continuing on {current}",
+                file=sys.stderr,
+            )
+        return None

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

@@ -895,9 +895,27 @@ def _do_reap(api_key: str, host_id: str) -> int:
                 seen.pop(target, None)
         else:
             seen.pop(target, None)  # recovered / running / gone — clear the grace clock
-    # prune grace entries for agents no longer in the roster
+    # (C) DELETED-AGENT ORPHAN (commander Gap 2 / folds 6125f14a): a recorded headless PID whose agent is
+    # GONE from the roster — mc_agent_kill bare-DELETEs the row but ORPHANS the process ('lo cerré y sigue
+    # ahí'). Reap it, with the SAME grace so a transient roster-read miss can't kill a healthy agent.
+    for target in list(pids.keys()):
+        if target in live_targets:
+            continue
+        pid = pids.get(target)
+        if not _alive(pid):
+            seen.pop(target, None)
+            continue
+        first = seen.get(target)
+        if first is None:
+            seen[target] = now
+            _log(f"REAP-PENDING {target}: gone from roster but pid {pid} alive (mc_agent_kill orphan?) — "
+                 f"{_REAP_ORPHAN_GRACE_SEC}s grace before reap")
+        elif now - float(first) >= _REAP_ORPHAN_GRACE_SEC:
+            n += _reap(target, pid, f"deleted-agent orphan; alive {int(now-float(first))}s after roster removal")
+            seen.pop(target, None)
+    # prune grace clocks only for targets that are BOTH gone from the roster AND have no alive recorded PID
     for t in list(seen.keys()):
-        if t not in live_targets:
+        if t not in live_targets and not _alive(pids.get(t)):
             seen.pop(t, None)
     st["headless_pids"] = pids
     st["reapseen"] = seen

{meshcode-2.11.104 → meshcode-2.11.105}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.104 → meshcode-2.11.105}/meshcode.egg-info/SOURCES.txt

@@ -3,11 +3,13 @@ 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
@@ -216,6 +218,7 @@ tests/test_autonomous_closegap_1.py
 tests/test_autonomous_closegap_2.py
 tests/test_autonomous_closegap_3.py
 tests/test_autonomous_prompt_inject 2.py
+tests/test_autonomous_prompt_inject 3.py
 tests/test_autonomous_prompt_inject.py
 tests/test_boot_bug_regression.py
 tests/test_color_truecolor.py

{meshcode-2.11.104 → meshcode-2.11.105}/pyproject.toml

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