meshcode 2.11.155__tar.gz → 2.11.158__tar.gz

{meshcode-2.11.155 → meshcode-2.11.158}/PKG-INFO

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

{meshcode-2.11.155 → meshcode-2.11.158}/meshcode/__init__.py

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

{meshcode-2.11.155 → meshcode-2.11.158}/meshcode/hostd.py

@@ -1497,57 +1497,47 @@ def _terminal_window_marker(target: str) -> str:
 
 
 def _list_dead_terminal_windows(target: str) -> list:
-    """macOS: ids of Terminal windows that belonged to `target`'s launcher and
-    whose tab is NO LONGER BUSY — the '[Process completed]' orphans a rotation
-    leaves behind (task 70ac6d25). busy=false means no process runs in the tab,
-    so a live agent can never match; the marker filter keeps every non-meshcode
-    window (user shells, other apps' tabs) out of reach. The marker is built
-    from a sanitized charset ([A-Za-z0-9_.-]) so it can't inject AppleScript.
-    Returns [] on non-macOS, no Automation permission, or any error."""
-    if sys.platform != "darwin":
-        return []
-    marker = _terminal_window_marker(target)
-    if not marker:
-        return []
-    script = (
-        'set out to ""\n'
-        'tell application "Terminal"\n'
-        '  repeat with w in (every window)\n'
-        '    try\n'
-        f'      if (busy of selected tab of w) is false and (name of w contains "{marker}") then\n'
-        '        set out to out & (id of w) & linefeed\n'
-        '      end if\n'
-        '    end try\n'
-        '  end repeat\n'
-        'end tell\n'
-        'return out')
-    try:
-        out = subprocess.run(["/usr/bin/osascript", "-e", script],
-                             capture_output=True, text=True, timeout=10).stdout or ""
-        return [int(x) for x in out.split() if x.strip().isdigit()]
-    except Exception:
-        return []
+    """DISABLED no-op (macOS TCC fix, task e0465408 / Prong 1 #2).
+
+    This used to enumerate Terminal windows via `osascript -e 'tell application
+    "Terminal" ...'` to find '[Process completed]' rotation orphans (task
+    70ac6d25 / 2.11.157). That Apple Event fired from python3.11 on the hostd
+    lifecycle sweep and was RC-1 of the recurring macOS consent prompt
+    "python3.11 would like to access data from other apps"
+    (kTCCServiceAppleEvents). Because the interpreter is ad-hoc signed (bare
+    cdhash, no Designated Requirement) the grant never stuck across versions, so
+    it re-prompted on every sweep. The `.command` launcher already self-closes
+    its OWN tab on any exit (clean / recycle / crash) via a tty-targeted close
+    run from the agent's shell (see protocol_handler._write_fleet_native_agent),
+    so this hostd-side reaper was a redundant belt. Removing it takes Apple
+    Events off the python sweep path with no dead-tab regression — only
+    un-trappable SIGKILL orphans may linger, which are rare and cannot be closed
+    without Apple Events anyway. Kept as a no-op so the call sites stay harmless.
+    NEVER reintroduce osascript here — guarded by
+    tests/test_no_appleevents_on_sweep.py."""
+    return []
 
 
 def _close_dead_terminal_windows(target: str, window_ids) -> int:
-    """Close (saving no) a pre-collected set of dead launcher windows. The ids
-    come from _list_dead_terminal_windows BEFORE the fresh spawn, so the new
-    window is excluded by construction (same snapshot discipline as
-    _close_old_visible_recycle). 'every window whose id is N' no-ops harmlessly
-    if the user already closed it. Best-effort; returns count closed."""
-    n = 0
-    for wid in window_ids:
-        try:
-            r = subprocess.run(
-                ["/usr/bin/osascript", "-e",
-                 f'tell application "Terminal" to close (every window whose id is {int(wid)}) saving no'],
-                capture_output=True, text=True, timeout=10)
-            if r.returncode == 0:
-                _log(f"DEAD-WINDOW-REAP {target}: closed dead terminal window id {wid} (rotation orphan)")
-                n += 1
-        except Exception:
-            pass
-    return n
+    """DISABLED no-op (macOS TCC fix, task e0465408 / Prong 1 #2).
+
+    Previously closed dead launcher windows by firing
+    `osascript -e 'tell application "Terminal" to close ...'` from python3.11.
+    That Apple Event was RC-1 of the recurring TCC prompt
+    ("python3.11 would like to access data from other apps") — the adhoc python
+    interpreter has no stable Designated Requirement, so the kTCCServiceAppleEvents
+    grant never persists across per-version cdhash changes and re-prompts forever.
+
+    The `.command` launcher already self-closes its OWN tab on any exit
+    (clean/recycle/crash) via a tty-targeted close run from the agent's SHELL
+    (not python — different TCC attribution), so this hostd-side reaper was a
+    redundant belt. Removing it takes Apple Events off the python sweep path with
+    no dead-tab regression — only un-trappable SIGKILL orphans may linger, which
+    are rare and cannot be closed without Apple Events anyway. Kept as a no-op so
+    the call sites stay harmless.
+    NEVER reintroduce osascript here — guarded by
+    tests/test_no_appleevents_on_sweep.py."""
+    return 0
 
 
 def _spawn_rate_ok(target: str):

{meshcode-2.11.155 → meshcode-2.11.158}/meshcode/meshcode_mcp/server.py

@@ -491,9 +491,61 @@ def _try_auto_wake(from_agent: str, preview: str, urgent: bool = False) -> None:
     # configurations, pipelines, tmux without termguicolors) render the raw
     # bytes — "[91m[1m[mesh][0m …" — which is worse UX than no color at all.
     nudge = f"[mesh] {safe_agent} > {safe_preview} — meshcode_check()"
+    # tmux fast-path (task 780d7397): the fleet runs inside a tmux session, so the
+    # MCP serve process (a child of `claude` in the pane) inherits TMUX_PANE. When
+    # it's present, prefer `tmux send-keys` over the window-activation fallbacks —
+    # only tmux can ACTUALLY interrupt Claude's current turn (Escape) and then
+    # inject+submit the nudge, so an urgent message reaches a mid-step agent in
+    # ~1-2s instead of waiting for its next tool-call boundary. AppleScript/
+    # PowerShell/xdotool below cannot interrupt generation; they only help a truly
+    # idle agent and so remain the fallback when we're not inside tmux.
+    tmux_pane = os.environ.get("TMUX_PANE", "")
+    if tmux_pane and re.match(r'^%[0-9]+$', tmux_pane):
+        # Urgent gets a short, unambiguous marker that forces a meshcode_check —
+        # never the full payload (the agent reads the real message via the check).
+        marker = (f"[URGENT] {safe_agent} - run meshcode_check()"
+                  if urgent else nudge)
+        try:
+            # 1) Escape interrupts Claude's in-flight generation/turn.
+            subprocess.run(["tmux", "send-keys", "-t", tmux_pane, "Escape"],
+                           stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                           timeout=5)
+            # 2) brief pause so the interrupt registers before we type.
+            _time.sleep(0.2)
+            # 3) inject the marker literally (-l so it is never parsed as a key
+            #    name), then submit with a separate Enter so Claude reads it now.
+            subprocess.run(["tmux", "send-keys", "-t", tmux_pane, "-l", marker],
+                           stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                           timeout=5)
+            _time.sleep(0.15)  # let the TUI register the typed text before submit
+            subprocess.run(["tmux", "send-keys", "-t", tmux_pane, "Enter"],
+                           stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                           timeout=5)
+            log.info(f"auto-wake: interrupted+injected via tmux pane {tmux_pane}")
+            return
+        except Exception as e:
+            log.debug(f"auto-wake tmux path failed, falling back: {e}")
     system = platform.system()
     try:
         if system == "Darwin":
+            # macOS TCC fix (task e0465408 / Prong 1 #3): the AppleScript
+            # keystroke fallback fires osascript from python3.11, which triggers
+            # the recurring "python3.11 would like to access data from other apps"
+            # consent prompt (kTCCServiceAppleEvents; adhoc python has no stable
+            # Designated Requirement so the grant never persists). tmux send-keys
+            # (the fast-path above) is the durable, prompt-free wake mechanism.
+            # The AppleScript fallback is OFF by default and only re-enabled by
+            # operators who explicitly opt into Apple Events:
+            #   MESHCODE_AUTOWAKE_APPLESCRIPT=1
+            # When off and tmux was unavailable/failed, we skip keystroke
+            # injection entirely (no prompt, no wake) rather than re-prompt Samuel.
+            if os.environ.get("MESHCODE_AUTOWAKE_APPLESCRIPT", "").strip().lower() \
+                    not in ("1", "true", "yes", "on"):
+                log.debug(
+                    "auto-wake: tmux unavailable and AppleScript fallback "
+                    "disabled (MESHCODE_AUTOWAKE_APPLESCRIPT off) — skipping "
+                    "keystroke injection to avoid macOS TCC prompt")
+                return
             # Sanitize app_name — TERM_PROGRAM is an env var, not DB-sourced,
             # but defense-in-depth: only allow known terminal app names.
             parent_app = os.environ.get("TERM_PROGRAM", "Terminal")

{meshcode-2.11.155 → meshcode-2.11.158}/meshcode/protocol_handler.py

@@ -356,8 +356,12 @@ def _fleet_attach_macos(tmux: str) -> tuple[bool, str]:
     ]
     try:
         launch_dir.mkdir(parents=True, exist_ok=True)
+        # macOS TCC fix (task e0465408) security guardrail: launcher dir +
+        # .command owner-only (0o700). These scripts are LaunchServices-executed
+        # via `open -a` and must never be world-readable/-writable.
+        _harden_launcher_dir(launch_dir)
         script_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
-        os.chmod(script_path, 0o755)
+        os.chmod(script_path, 0o700)
     except Exception as e:
         return False, f"could not write fleet launcher: {e}"
     r = subprocess.run(["open", "-a", "Terminal", str(script_path)],
@@ -373,6 +377,60 @@ def _fleet_attach_linux(tmux: str) -> tuple[bool, str]:
     return _spawn_terminal_linux(attach)
 
 
+def _reap_dead_fleet_windows(tmux: str, cap: Optional[int] = None) -> int:
+    """Reap accumulated DEAD windows from the fleet tmux session (task 22fcdb21,
+    Samuel P1: dead panes stacked to 51).
+
+    The RAII trap in _fleet_wrap closes a window on a CLEAN / SIGTERM exit, but
+    a SIGKILL (rc=137: force-kill / OOM / recycle) cannot be trapped, so the
+    per-window `remain-on-exit=failed` keeps that dead pane forever. Over days
+    these pile up and `#{session_windows}` (the 'N agents' counter) counts
+    cadavers, not live agents.
+
+    Sweeps every fleet window whose panes are ALL dead, KEEPING only the `cap`
+    most-recently-dead (bounded crash-retention for debugging) and killing the
+    rest. It NEVER touches a window with a live pane, so it can never close a
+    running agent. Returns the count reaped. Best-effort; never raises. Tunable
+    via MESHCODE_FLEET_DEAD_CAP (default 3; 0 = reap every dead pane)."""
+    if cap is None:
+        try:
+            cap = int(os.environ.get("MESHCODE_FLEET_DEAD_CAP", "3") or 3)
+        except ValueError:
+            cap = 3
+    cap = max(0, cap)
+    try:
+        r = _tmux(tmux, "list-panes", "-s", "-t", f"={_FLEET_SESSION}",
+                  "-F", "#{window_id}\t#{pane_dead}\t#{pane_dead_time}")
+        if r.returncode != 0:
+            return 0
+        # Group panes by window: a window is dead only if EVERY pane is dead
+        # (fleet windows are single-pane, but stay correct if that changes).
+        wins: dict = {}
+        for line in (r.stdout or "").splitlines():
+            parts = line.split("\t")
+            if len(parts) < 2:
+                continue
+            wid, pdead = parts[0], parts[1]
+            try:
+                pdt = int(parts[2]) if len(parts) > 2 and parts[2] else 0
+            except ValueError:
+                pdt = 0
+            w = wins.setdefault(wid, {"all_dead": True, "dt": 0})
+            if pdead != "1":
+                w["all_dead"] = False
+            else:
+                w["dt"] = max(w["dt"], pdt)
+        dead = sorted(((v["dt"], wid) for wid, v in wins.items() if v["all_dead"]),
+                      reverse=True)  # newest dead first; keep[:cap], reap the tail
+        reaped = 0
+        for _dt, wid in dead[cap:]:
+            if _tmux(tmux, "kill-window", "-t", wid).returncode == 0:
+                reaped += 1
+        return reaped
+    except Exception:
+        return 0
+
+
 def _spawn_fleet_tab(cmd: str) -> tuple[bool, str]:
     """Run `cmd` as a TAB (tmux window) of the shared fleet window.
 
@@ -399,6 +457,11 @@ def _spawn_fleet_tab(cmd: str) -> tuple[bool, str]:
             if r.returncode != 0:  # lost a create race -> join as a tab
                 fresh_session = False
         if not fresh_session:
+            # Sweep-on-launch: reap accumulated dead panes BEFORE adding this
+            # agent's tab, so the fleet bar reflects live agents (not the 51
+            # cadavers Samuel saw) and a respawn reuses the slot (task 22fcdb21).
+            # Only ever touches already-dead windows — never a live agent.
+            _reap_dead_fleet_windows(tmux)
             r = _tmux(tmux, "new-window", "-d", "-t", f"={_FLEET_SESSION}:",
                       "-n", label, "-P", "-F", "#{window_id}", wrapped)
             if r.returncode != 0:
@@ -501,6 +564,19 @@ def _spawn_fleet_tab(cmd: str) -> tuple[bool, str]:
 _FLEET_NATIVE_DISABLED_TTL_S = 1800  # back off after a watcher "fallback"
 
 
+def _harden_launcher_dir(d) -> None:
+    """macOS TCC fix (task e0465408) security guardrail: keep the launcher dir
+    owner-only (0o700). The `.command`/watcher scripts here are executed by
+    LaunchServices via `open -a` and may carry non-secret launch flags; they must
+    never be world-readable/-writable (was 0o755). Secrets are NEVER written into
+    these scripts (they come via .mcp.json / keychain / env-file). Best-effort:
+    a chmod failure must not wedge a launch."""
+    try:
+        os.chmod(str(d), 0o700)
+    except Exception:
+        pass
+
+
 def _fleet_native_paths() -> dict:
     d = Path.home() / ".meshcode" / "launchers"
     return {
@@ -654,10 +730,11 @@ while :; do
 done
 '''
     p["dir"].mkdir(parents=True, exist_ok=True)
+    _harden_launcher_dir(p["dir"])  # owner-only launcher dir (TCC fix e0465408)
     driver = p["dir"] / "fleet-native-driver.applescript"
     driver.write_text(_FLEET_NATIVE_DRIVER_AS + "\n", encoding="utf-8")
     p["watcher"].write_text(body, encoding="utf-8")
-    os.chmod(p["watcher"], 0o755)
+    os.chmod(p["watcher"], 0o700)
     return p["watcher"]
 
 
@@ -737,8 +814,9 @@ def _write_fleet_native_agent(cmd: str) -> Path:
         'esac',
     ]
     p["dir"].mkdir(parents=True, exist_ok=True)
+    _harden_launcher_dir(p["dir"])  # owner-only launcher dir (TCC fix e0465408)
     script_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
-    os.chmod(script_path, 0o755)
+    os.chmod(script_path, 0o700)
     return script_path
 
 
@@ -963,8 +1041,9 @@ def _spawn_terminal_macos(cmd: str) -> tuple[bool, str]:
     lines.append('fi')
     try:
         launch_dir.mkdir(parents=True, exist_ok=True)
+        _harden_launcher_dir(launch_dir)  # owner-only launcher dir (TCC fix e0465408)
         script_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
-        os.chmod(script_path, 0o755)
+        os.chmod(script_path, 0o700)
     except Exception as e:
         return False, f"could not write launcher {script_path}: {e}"
     # Clear any stale start-marker so the poll below can only see a FRESH one

{meshcode-2.11.155 → meshcode-2.11.158}/meshcode/self_update.py

@@ -704,6 +704,16 @@ def ensure_boot_env(mcp_json_path, verbose: bool = True) -> Optional[str]:
         if env_block.get("MESHCODE_EXPECTED_VERSION") != target:
             env_block["MESHCODE_EXPECTED_VERSION"] = target
             changed = True
+        # urgent-wake default-on rollout (task 780d7397): setup_clients bakes
+        # MESHCODE_URGENT_WAKE=1 only for FRESH `meshcode setup`. Existing agents'
+        # .mcp.json is never regenerated on `meshcode run`, so the env-gated
+        # feature would stay OFF forever on installed fleets. Backfill it here —
+        # the one place that mutates an existing server env every boot — but only
+        # when the key is ABSENT, so an explicit user opt-out (set to "0") is
+        # never clobbered.
+        if "MESHCODE_URGENT_WAKE" not in env_block:
+            env_block["MESHCODE_URGENT_WAKE"] = "1"
+            changed = True
         if changed:
             tmp = mcp_json_path.with_name(mcp_json_path.name + ".tmp")
             tmp.write_text(json.dumps(doc, indent=2), encoding="utf-8")

{meshcode-2.11.155 → meshcode-2.11.158}/meshcode/setup_clients.py

@@ -215,6 +215,14 @@ def _build_server_block(project: str, project_id: str, agent: str, role: str,
         # Mark this Python process as the MCP serve subprocess so other
         # parts of the package (e.g. self_update) skip auto-update inside it.
         "MESHCODE_MCP_SERVE": "1",
+        # Urgent-interrupt nudging (task 780d7397, Samuel 2026-06-22): a
+        # priority='urgent' message must INTERRUPT a busy agent and be read
+        # at once, not merely queue until its next meshcode_wait. This opt-in
+        # gates the urgent-only path in server._try_auto_wake (tmux ESC+inject
+        # when in a tmux pane, AppleScript/etc fallback otherwise). Deliberately
+        # urgent-only — we do NOT set MESHCODE_AUTO_WAKE so non-urgent traffic
+        # never injects keystrokes (that stays the conservative default OFF).
+        "MESHCODE_URGENT_WAKE": "1",
     }
     if editor_type:
         env["MESHCODE_EDITOR_TYPE"] = editor_type

{meshcode-2.11.155 → meshcode-2.11.158}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.155 → meshcode-2.11.158}/meshcode.egg-info/SOURCES.txt

@@ -70,11 +70,13 @@ tests/test_core.py
 tests/test_cross_agent_messaging.py
 tests/test_date_parse.py
 tests/test_doctor.py
+tests/test_ensure_boot_env_urgent_wake.py
 tests/test_epistemic_v1_python_sdk.py
 tests/test_epistemic_v1_stop_conditions.py
 tests/test_esc_deaf_state.py
 tests/test_exceptions.py
 tests/test_file_upload.py
+tests/test_fleet_reaper.py
 tests/test_helper_visuals.py
 tests/test_hostd_launch_pinned_env.py
 tests/test_hostd_serve_discovery_split.py
@@ -87,6 +89,7 @@ tests/test_live_mesh_guard.py
 tests/test_mark_read_batch.py
 tests/test_marketplace_ratings.py
 tests/test_migration_integrity.py
+tests/test_no_appleevents_on_sweep.py
 tests/test_preflight_hb_gate.py
 tests/test_pretrust_claude.py
 tests/test_push_guard.py
@@ -113,4 +116,5 @@ tests/test_task_progress.py
 tests/test_terminal_lifecycle.py
 tests/test_up_launch_cmd.py
 tests/test_update_guard.py
+tests/test_urgent_wake_tmux.py
 tests/test_wait_open_tasks_contradiction.py

{meshcode-2.11.155 → meshcode-2.11.158}/pyproject.toml

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

meshcode-2.11.158/tests/test_ensure_boot_env_urgent_wake.py

@@ -0,0 +1,95 @@
+"""
+ensure_boot_env backfills MESHCODE_URGENT_WAKE (task 780d7397 / 2.11.157)
+=========================================================================
+setup_clients bakes MESHCODE_URGENT_WAKE=1 only for a FRESH `meshcode setup`.
+An already-installed agent's .mcp.json is never regenerated on `meshcode run`
+(run_agent only writes it when MISSING), so the env-gated urgent-wake feature
+would stay OFF forever on existing fleets — exactly the gap that would have made
+the front-end smoke fail.
+
+ensure_boot_env is the one place that mutates an existing server env block every
+boot. It must backfill the flag when ABSENT, but must NEVER clobber an explicit
+user opt-out (value "0").
+
+These tests stub the version-resolution surface so no network / env-pin happens;
+they exercise only the .mcp.json mutation.
+"""
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import meshcode.self_update as su
+
+
+def _write_mcp(tmp_path, env_block):
+    p = tmp_path / ".mcp.json"
+    doc = {
+        "mcpServers": {
+            "meshcode-x": {
+                "command": "/fake/envs/9.9.9/bin/python3",
+                "args": ["-m", "meshcode.meshcode_mcp", "serve"],
+                "env": env_block,
+            }
+        }
+    }
+    p.write_text(json.dumps(doc, indent=2), encoding="utf-8")
+    return p
+
+
+def _stub_versions(monkeypatch, target="9.9.9"):
+    """No-network: current env already == target, so no env-pin path runs."""
+    monkeypatch.setattr(su, "update_disabled", lambda: False)
+    monkeypatch.setattr(su, "is_editable_install", lambda: False)
+    monkeypatch.setattr(su, "resolve_target_version", lambda: target)
+    monkeypatch.setattr(su, "_env_version", lambda cmd: target)
+
+
+def _read_env(p):
+    doc = json.loads(p.read_text(encoding="utf-8"))
+    return next(iter(doc["mcpServers"].values()))["env"]
+
+
+def test_backfills_when_absent(tmp_path, monkeypatch):
+    _stub_versions(monkeypatch)
+    p = _write_mcp(tmp_path, {"MESHCODE_EXPECTED_VERSION": "9.9.9"})
+    out = su.ensure_boot_env(p, verbose=False)
+    assert out == "9.9.9"
+    assert _read_env(p)["MESHCODE_URGENT_WAKE"] == "1"
+
+
+def test_does_not_clobber_explicit_optout(tmp_path, monkeypatch):
+    _stub_versions(monkeypatch)
+    p = _write_mcp(tmp_path, {
+        "MESHCODE_EXPECTED_VERSION": "9.9.9",
+        "MESHCODE_URGENT_WAKE": "0",
+    })
+    su.ensure_boot_env(p, verbose=False)
+    assert _read_env(p)["MESHCODE_URGENT_WAKE"] == "0", "user opt-out was clobbered"
+
+
+def test_preserves_existing_on_value(tmp_path, monkeypatch):
+    _stub_versions(monkeypatch)
+    p = _write_mcp(tmp_path, {
+        "MESHCODE_EXPECTED_VERSION": "9.9.9",
+        "MESHCODE_URGENT_WAKE": "1",
+    })
+    su.ensure_boot_env(p, verbose=False)
+    assert _read_env(p)["MESHCODE_URGENT_WAKE"] == "1"
+
+
+def test_idempotent_second_boot_no_rewrite(tmp_path, monkeypatch):
+    _stub_versions(monkeypatch)
+    p = _write_mcp(tmp_path, {"MESHCODE_EXPECTED_VERSION": "9.9.9"})
+    su.ensure_boot_env(p, verbose=False)
+    mtime1 = p.stat().st_mtime_ns
+    # Second boot: everything already in place -> changed=False -> no rewrite.
+    su.ensure_boot_env(p, verbose=False)
+    assert p.stat().st_mtime_ns == mtime1, "rewrote .mcp.json with nothing to change"
+    assert _read_env(p)["MESHCODE_URGENT_WAKE"] == "1"
+
+
+if __name__ == "__main__":
+    import pytest
+    sys.exit(pytest.main([__file__, "-q"]))