railmux 0.4.0.dev9__tar.gz → 0.4.0.dev10__tar.gz

{railmux-0.4.0.dev9/src/railmux.egg-info → railmux-0.4.0.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev9
+Version: 0.4.0.dev10
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

railmux-0.4.0.dev10/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.0.dev10"

{railmux-0.4.0.dev9 → railmux-0.4.0.dev10}/src/railmux/cli.py

@@ -20,6 +20,7 @@ from railmux.runtime_config import (
 )
 from railmux import tmux_health
 from railmux import tmux_server
+from railmux import windows_tmux_lifecycle
 from railmux.system_deps import ensure_tmux_available
 from railmux.ssh_args import AppendSshArgument, ExtendSshArguments
 
@@ -126,7 +127,16 @@ def _run_tmux_client_with_watchdog(
                     file=sys.stderr,
                 )
                 return 2
+        # tmux may leave the client TTY in raw mode even after its process
+        # exits. Restore it before a bounded recovery probe or user message.
+        _restore_terminal(attributes)
         returncode = process.returncode or 0
+        if windows_tmux_lifecycle.recover_abandoned_socket():
+            print(
+                "info: cleaned an abandoned Windows tmux socket; Codex and "
+                "Claude session files were not changed",
+                file=sys.stderr,
+            )
         if returncode and expected_target is not None:
             try:
                 current_target = tmux_server.discover_target(timeout=1.0)
@@ -367,6 +377,12 @@ def main(argv: list[str] | None = None) -> int:
         # Validate before any command can address a tmux server. ``tmux -V``
         # above is server-independent.
         tmux_server.socket_label()
+        if windows_tmux_lifecycle.recover_abandoned_socket():
+            print(
+                "info: cleaned an abandoned Windows tmux socket; Codex and "
+                "Claude session files were not changed",
+                file=sys.stderr,
+            )
         dedicated_target = tmux_server.discover_target()
         on_dedicated_server = tmux_server.is_current_server(dedicated_target)
     except tmux_server.TmuxServerError as exc:

{railmux-0.4.0.dev9 → railmux-0.4.0.dev10}/src/railmux/codex_index.py

@@ -25,7 +25,7 @@ from railmux.models import (
     Project,
     SessionMeta,
 )
-from railmux.provider_paths import provider_path
+from railmux.provider_paths import private_mode_is_safe, provider_path
 from railmux.renames import Renames
 
 # Codex has no reliable provider-neutral signal that distinguishes a long
@@ -461,7 +461,7 @@ class CodexIndex:
             if (
                 not stat.S_ISREG(info.st_mode)
                 or info.st_uid != os.getuid()
-                or info.st_mode & 0o077
+                or not private_mode_is_safe(info.st_mode)
                 or info.st_size > _PERSISTENT_CACHE_MAX_BYTES
             ):
                 return

{railmux-0.4.0.dev9 → railmux-0.4.0.dev10}/src/railmux/discovery.py

@@ -10,6 +10,7 @@ from pathlib import Path
 from railmux.atomic_file import atomic_write_text
 from railmux.models import Project
 from railmux.path_codec import decode, is_encoded_project_name
+from railmux.provider_paths import private_mode_is_safe
 from railmux.session_index import _looks_like_uuid, _scan_session
 
 
@@ -55,7 +56,7 @@ def _load_persistent_validity(claude_home: Path) -> None:
             not stat.S_ISREG(info.st_mode)
             or info.st_uid != os.getuid()
             or info.st_size > _VALIDITY_CACHE_LIMIT
-            or info.st_mode & 0o077
+            or not private_mode_is_safe(info.st_mode)
         ):
             return
         raw = json.loads(path.read_text(encoding="utf-8"))

{railmux-0.4.0.dev9 → railmux-0.4.0.dev10}/src/railmux/fast_display_server.py

@@ -1493,7 +1493,7 @@ def _acquire_display_lock(
         if (
             not stat.S_ISREG(info.st_mode)
             or info.st_uid != os.getuid()
-            or info.st_mode & 0o077
+            or not restart_state.private_mode_is_safe(info.st_mode)
         ):
             raise OSError("unsafe display lock")
         deadline = time.monotonic() + max(0.0, timeout)

{railmux-0.4.0.dev9 → railmux-0.4.0.dev10}/src/railmux/mouse_manager.py

@@ -60,7 +60,7 @@ class RootWheelForwardingManager:
             info = self._state_path.lstat()
             if (not stat.S_ISREG(info.st_mode)
                     or info.st_uid != os.getuid()
-                    or info.st_mode & 0o077
+                    or not restart_state.private_mode_is_safe(info.st_mode)
                     or info.st_size > _MAX_STATE_BYTES):
                 return None
             raw = json.loads(self._state_path.read_text(encoding="utf-8"))

{railmux-0.4.0.dev9 → railmux-0.4.0.dev10}/src/railmux/orphan_marker.py

@@ -231,7 +231,7 @@ def claim_owner(
         parent = lock_path.parent.stat()
         if (not stat.S_ISDIR(parent.st_mode)
                 or parent.st_uid != os.getuid()
-                or parent.st_mode & 0o077):
+                or not restart_state.private_mode_is_safe(parent.st_mode)):
             return None
         flags = os.O_CREAT | os.O_RDWR
         if hasattr(os, "O_NOFOLLOW"):
@@ -243,7 +243,7 @@ def claim_owner(
         info = os.fstat(fd)
         if (not stat.S_ISREG(info.st_mode)
                 or info.st_uid != os.getuid()
-                or info.st_mode & 0o077):
+                or not restart_state.private_mode_is_safe(info.st_mode)):
             return None
         try:
             fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)

{railmux-0.4.0.dev9 → railmux-0.4.0.dev10}/src/railmux/provider_paths.py

@@ -1,13 +1,17 @@
 """Translate provider-owned native Windows paths inside the MSYS2 preview."""
 from __future__ import annotations
 
+import json
 import os
 import re
+import stat
+import sys
 from collections.abc import Mapping
 from pathlib import Path
 
 
 _DRIVE_PATH = re.compile(r"^(?:\\\\\?\\)?([A-Za-z]):[\\/](.*)\Z")
+_MANAGED_RUNTIME_MARKER = Path("/railmux-runtime.json")
 
 
 def running_in_windows_wrapper(environ: Mapping[str, str] = os.environ) -> bool:
@@ -15,6 +19,41 @@ def running_in_windows_wrapper(environ: Mapping[str, str] = os.environ) -> bool:
     return environ.get("RAILMUX_WINDOWS_RUNTIME") == "msys2"
 
 
+def running_in_managed_windows_wrapper(
+    environ: Mapping[str, str] = os.environ,
+) -> bool:
+    """Verify the installed MSYS2 runtime, not merely its environment hint."""
+    if sys.platform != "cygwin" or not running_in_windows_wrapper(environ):
+        return False
+    marker = _MANAGED_RUNTIME_MARKER
+    try:
+        info = marker.lstat()
+        if (
+            not stat.S_ISREG(info.st_mode)
+            or info.st_uid != os.getuid()
+            or info.st_mode & 0o022
+            or info.st_size > 4096
+        ):
+            return False
+        payload = json.loads(marker.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return False
+    from railmux import __version__
+    runtime_id = environ.get("RAILMUX_MSYS2_RUNTIME_ID")
+    return isinstance(runtime_id, str) and bool(runtime_id) and payload == {
+        "schema": 1,
+        "runtime": runtime_id,
+        "railmux": __version__,
+    }
+
+
+def private_mode_is_safe(mode: int) -> bool:
+    """Accept strict POSIX modes or the verified MSYS2 noacl projection."""
+    return not mode & 0o077 or (
+        running_in_managed_windows_wrapper() and not mode & 0o022
+    )
+
+
 def provider_path(
     raw: str,
     *,

{railmux-0.4.0.dev9 → railmux-0.4.0.dev10}/src/railmux/restart_state.py

@@ -17,6 +17,7 @@ from pathlib import Path
 from railmux import tmux_ctl
 from railmux.atomic_file import atomic_write_text
 from railmux.config import default_config_path
+from railmux.provider_paths import private_mode_is_safe
 
 
 SCHEMA_VERSION = 1
@@ -164,10 +165,15 @@ def legacy_state_path() -> Path:
 def _ensure_private_dir(path: Path) -> None:
     """Create and verify a Railmux-owned 0700 runtime directory."""
     path.mkdir(mode=0o700, parents=True, exist_ok=True)
-    info = path.stat()
+    info = path.lstat()
+    # MSYS2's default noacl projection reports user-owned NTFS directories as
+    # 0755 even after chmod(0700). The managed runtime itself lives below the
+    # Windows user's LocalAppData ACL. Accept that projection only on the real
+    # Cygwin/MSYS Python platform, and still reject symlinks, foreign owners,
+    # and any group/world-writable directory. POSIX platforms retain 0700.
     if (not stat.S_ISDIR(info.st_mode)
             or info.st_uid != os.getuid()
-            or info.st_mode & 0o077):
+            or not private_mode_is_safe(info.st_mode)):
         raise OSError("Railmux runtime state directory is not private")
 
 

{railmux-0.4.0.dev9 → railmux-0.4.0.dev10}/src/railmux/tmux_binding_manager.py

@@ -85,7 +85,7 @@ class SharedTmuxBindingManager:
             info = self._state_path.lstat()
             if (not stat.S_ISREG(info.st_mode)
                     or info.st_uid != os.getuid()
-                    or info.st_mode & 0o077
+                    or not restart_state.private_mode_is_safe(info.st_mode)
                     or info.st_size > _MAX_STATE_BYTES):
                 return None
             raw = json.loads(self._state_path.read_text(encoding="utf-8"))

{railmux-0.4.0.dev9 → railmux-0.4.0.dev10}/src/railmux/ui/app.py

@@ -25,6 +25,7 @@ from railmux import (
     tmux_ctl,
     tmux_health,
     tmux_server,
+    windows_tmux_lifecycle,
 )
 from railmux.atomic_file import atomic_write_text
 from railmux.background_index import BackgroundCodexIndex
@@ -713,6 +714,9 @@ class App:
         # digest plus immutable pane id namespaces local recovery state across
         # windows, sessions, and private tmux servers.
         self._restart_identity = restart_state.capture_outer_identity()
+        # A newly live UI revokes any cleanup proof from the preceding
+        # lifecycle before it can create provider sessions.
+        windows_tmux_lifecycle.clear_empty_server_exit()
         self._claude_home = claude_home
         self._config = config
         self._auto_launched = auto_launched
@@ -8061,10 +8065,25 @@ class App:
         if defer_outer or getattr(self, "_outer_teardown_done", False):
             return
         self._outer_teardown_done = True
+        identity = getattr(self, "_restart_identity", None)
+        if (
+            self._auto_launched
+            and identity is not None
+            and running_in_windows_wrapper()
+            and tmux_ctl.current_session_name() == "railmux"
+            and tmux_ctl.current_session_id() == identity.session_id
+        ):
+            # MSYS2 can retain an AF_UNIX pathname after its last session
+            # exits. Arm cleanup only when the server-wide immutable-ID
+            # inventory proves that no provider or unknown session exists.
+            windows_tmux_lifecycle.arm_empty_server_exit(
+                server_pid=identity.server_pid,
+                session_id=identity.session_id,
+                pane_id=identity.pane_id,
+            )
         if not self._soft_quit_flag and self._auto_launched:
             session_name = tmux_ctl.current_session_name()
             if session_name == "railmux":
-                identity = getattr(self, "_restart_identity", None)
                 current_id = tmux_ctl.current_session_id()
                 intent = bool(
                     identity is not None
@@ -8080,6 +8099,7 @@ class App:
                     killed = False
                 if intent and not killed:
                     tmux_health.clear_clean_exit()
+                    windows_tmux_lifecycle.clear_empty_server_exit()
 
     def _enter_filter_mode(self) -> None:
         # Borrow the button row (footer index 1) for a filter Edit — both are a

{railmux-0.4.0.dev9 → railmux-0.4.0.dev10}/src/railmux/windows_msys2.py

@@ -414,6 +414,10 @@ class Msys2Runtime:
         # providers, whose POSIX cwd arguments do require MSYS conversion.
         child["MSYS2_ARG_CONV_EXCL"] = "*"
         child["RAILMUX_WINDOWS_RUNTIME"] = "msys2"
+        if self.managed:
+            # The MSYS-side privacy exception independently verifies the
+            # matching on-disk runtime marker before trusting this identifier.
+            child["RAILMUX_MSYS2_RUNTIME_ID"] = MSYS2_RUNTIME_ID
         # Native PowerShell commonly has no TERM; OpenSSH-hosted PowerShell
         # can explicitly inherit ``dumb``, which makes tmux reject attach.
         if not child.get("TERM") or child.get("TERM") == "dumb":

railmux-0.4.0.dev10/src/railmux/windows_tmux_lifecycle.py

@@ -0,0 +1,259 @@
+"""Fail-closed cleanup for abandoned MSYS2 tmux socket files.
+
+MSYS2 tmux can leave its AF_UNIX socket behind after the last session exits.
+The next tmux client then waits on an endpoint with no listener. Cleanup is
+authorized only while the live server proves that Railmux's outer UI is its
+sole session; provider histories are never opened or modified here.
+"""
+from __future__ import annotations
+
+import errno
+import json
+import os
+import socket
+import stat
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+from railmux import restart_state, tmux_server
+from railmux.atomic_file import atomic_write_text
+from railmux.provider_paths import running_in_windows_wrapper
+
+
+_SCHEMA_VERSION = 1
+_KIND = "windows-empty-tmux-exit"
+_EXIT_SETTLE_NS = 500_000_000
+
+
+@dataclass(frozen=True)
+class _SocketIdentity:
+    socket_dev: int
+    socket_ino: int
+    socket_ctime_ns: int
+    parent_dev: int
+    parent_ino: int
+
+
+def _marker_name(label: str) -> str:
+    return f"windows-empty-tmux-exit-{label}.json"
+
+
+def _expected_socket_path(label: str) -> Path | None:
+    root = Path(os.environ.get("TMUX_TMPDIR", "/tmp"))
+    if not root.is_absolute() or ".." in root.parts:
+        return None
+    return root / f"tmux-{os.getuid()}" / label
+
+
+def _socket_identity(path: Path) -> _SocketIdentity | None:
+    """Describe one same-user socket without following either final path."""
+    try:
+        parent = path.parent.lstat()
+        endpoint = path.lstat()
+    except OSError:
+        return None
+    if (
+        not stat.S_ISDIR(parent.st_mode)
+        or stat.S_ISLNK(parent.st_mode)
+        or parent.st_uid != os.getuid()
+        or parent.st_mode & 0o022
+        or not stat.S_ISSOCK(endpoint.st_mode)
+        or endpoint.st_uid != os.getuid()
+        or endpoint.st_mode & 0o022
+    ):
+        return None
+    return _SocketIdentity(
+        socket_dev=endpoint.st_dev,
+        socket_ino=endpoint.st_ino,
+        socket_ctime_ns=endpoint.st_ctime_ns,
+        parent_dev=parent.st_dev,
+        parent_ino=parent.st_ino,
+    )
+
+
+def arm_empty_server_exit(
+    *, server_pid: int, session_id: str, pane_id: str,
+) -> bool:
+    """Authorize later stale-socket removal after an exact empty-server proof."""
+    if not running_in_windows_wrapper() or server_pid <= 0:
+        return False
+    if not session_id.startswith("$") or not session_id[1:].isdigit():
+        return False
+    if not pane_id.startswith("%") or not pane_id[1:].isdigit():
+        return False
+    target = tmux_server.current_target()
+    if target is None or target.server_pid != server_pid:
+        return False
+
+    # Failure to enumerate every server-wide session denies cleanup.
+    from railmux import tmux_ctl
+
+    snapshot = tmux_ctl.server_snapshot()
+    if (
+        os.environ.get("TMUX_PANE") != pane_id
+        or tmux_ctl.current_session_id() != session_id
+        or tmux_ctl.session_ids() != frozenset({session_id})
+        or snapshot is None
+        or snapshot.sessions != frozenset({"railmux"})
+        or snapshot.panes != frozenset({pane_id})
+    ):
+        return False
+    try:
+        label = tmux_server.socket_label()
+    except tmux_server.TmuxServerError:
+        return False
+    expected = _expected_socket_path(label)
+    if expected is None or Path(target.socket_path) != expected:
+        return False
+    identity = _socket_identity(expected)
+    if identity is None:
+        return False
+    payload = {
+        "schema_version": _SCHEMA_VERSION,
+        "kind": _KIND,
+        "label": label,
+        "server_pid": server_pid,
+        "session_id": session_id,
+        "pane_id": pane_id,
+        "recorded_at_ns": time.time_ns(),
+        "socket_path": str(expected),
+        **asdict(identity),
+    }
+    try:
+        atomic_write_text(
+            restart_state.runtime_state_dir() / _marker_name(label),
+            json.dumps(payload, separators=(",", ":"), sort_keys=True),
+            encoding="utf-8",
+        )
+        return True
+    except OSError:
+        return False
+
+
+def clear_empty_server_exit() -> None:
+    """Revoke an older exit proof once a Railmux UI is live again."""
+    if not running_in_windows_wrapper():
+        return
+    try:
+        label = tmux_server.socket_label()
+        marker = restart_state.runtime_state_dir() / _marker_name(label)
+        marker.unlink(missing_ok=True)
+    except (OSError, tmux_server.TmuxServerError):
+        pass
+
+
+def _server_pid_is_gone(server_pid: int) -> bool:
+    """Return true only when the recorded MSYS2 process no longer exists."""
+    try:
+        os.kill(server_pid, 0)
+    except ProcessLookupError:
+        return True
+    except (OSError, ValueError):
+        # Permission errors and unsupported/ambiguous pid probes deny cleanup.
+        return False
+    return False
+
+
+def recover_abandoned_socket() -> bool:
+    """Remove one proven-dead MSYS2 socket; never act on a live endpoint."""
+    if not running_in_windows_wrapper() or os.environ.get("TMUX"):
+        return False
+    try:
+        label = tmux_server.socket_label()
+    except tmux_server.TmuxServerError:
+        return False
+    try:
+        marker = restart_state.runtime_state_dir() / _marker_name(label)
+    except OSError:
+        return False
+    payload = restart_state.read_json_object(marker)
+    required = {
+        "schema_version", "kind", "label", "server_pid", "session_id",
+        "pane_id", "recorded_at_ns", "socket_path", "socket_dev",
+        "socket_ino", "socket_ctime_ns", "parent_dev", "parent_ino",
+    }
+    if not isinstance(payload, dict) or set(payload) != required:
+        return False
+    session_id = payload.get("session_id")
+    pane_id = payload.get("pane_id")
+    identity_fields = (
+        "socket_dev", "socket_ino", "socket_ctime_ns", "parent_dev",
+        "parent_ino",
+    )
+    integer_fields = ("server_pid", "recorded_at_ns", *identity_fields)
+    if (
+        payload.get("schema_version") != _SCHEMA_VERSION
+        or payload.get("kind") != _KIND
+        or payload.get("label") != label
+        or not isinstance(session_id, str)
+        or not session_id.startswith("$")
+        or not session_id[1:].isdigit()
+        or not isinstance(pane_id, str)
+        or not pane_id.startswith("%")
+        or not pane_id[1:].isdigit()
+        or any(
+            not isinstance(payload.get(name), int)
+            or isinstance(payload.get(name), bool)
+            or payload[name] < 0
+            for name in integer_fields
+        )
+        or payload["server_pid"] <= 0
+    ):
+        return False
+    expected = _expected_socket_path(label)
+    if expected is None or payload.get("socket_path") != str(expected):
+        return False
+    recorded = _SocketIdentity(**{
+        name: payload[name] for name in identity_fields
+    })
+    if _socket_identity(expected) != recorded:
+        return False
+
+    def endpoint_state() -> bool | None:
+        """True is live, False is absent/unanswered, None is indeterminate."""
+        client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        client.settimeout(0.25)
+        try:
+            client.connect(str(expected))
+        except (socket.timeout, TimeoutError):
+            # A stale MSYS2 AF_UNIX pathname times out instead of returning
+            # ECONNREFUSED. The prior sole-pane proof is the cleanup authority.
+            return False
+        except OSError as exc:
+            if exc.errno in {errno.ECONNREFUSED, errno.ENOENT}:
+                return False
+            return None
+        else:
+            return True
+        finally:
+            client.close()
+
+    if endpoint_state() is not False:
+        return False
+    now_ns = time.time_ns()
+    recorded_at_ns = payload["recorded_at_ns"]
+    if recorded_at_ns > now_ns:
+        return False
+    remaining_ns = _EXIT_SETTLE_NS - (now_ns - recorded_at_ns)
+    if remaining_ns > 0:
+        time.sleep(remaining_ns / 1_000_000_000)
+    if (
+        _socket_identity(expected) != recorded
+        or endpoint_state() is not False
+        or not _server_pid_is_gone(payload["server_pid"])
+    ):
+        return False
+
+    # Narrow the check/unlink race against pathname replacement. Every normal
+    # Railmux launcher runs this recovery before starting tmux, and a changed
+    # endpoint is retained. An adversarial same-user process can ignore that
+    # convention, but cannot redirect this fixed pathname toward provider data.
+    if _socket_identity(expected) != recorded:
+        return False
+    try:
+        expected.unlink()
+        marker.unlink(missing_ok=True)
+    except OSError:
+        return False
+    return True

{railmux-0.4.0.dev9 → railmux-0.4.0.dev10/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev9
+Version: 0.4.0.dev10
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

{railmux-0.4.0.dev9 → railmux-0.4.0.dev10}/src/railmux.egg-info/SOURCES.txt

@@ -61,6 +61,7 @@ src/railmux/windows_bootstrap.py
 src/railmux/windows_install_log.py
 src/railmux/windows_msys2.py
 src/railmux/windows_pacman.py
+src/railmux/windows_tmux_lifecycle.py
 src/railmux.egg-info/PKG-INFO
 src/railmux.egg-info/SOURCES.txt
 src/railmux.egg-info/dependency_links.txt
@@ -162,6 +163,7 @@ tests/test_windows_bootstrap.py
 tests/test_windows_install_log.py
 tests/test_windows_msys2.py
 tests/test_windows_pacman.py
+tests/test_windows_tmux_lifecycle.py
 tests/test_windows_wrapper_contract.py
 tests/test_yolo_prompt.py
 tools/denested_transport_benchmark.py

railmux-0.4.0.dev10/tests/test_provider_paths.py

@@ -0,0 +1,88 @@
+import json
+import stat
+from pathlib import Path
+from types import SimpleNamespace
+
+from railmux import __version__, provider_paths
+from railmux.provider_paths import (
+    private_mode_is_safe,
+    provider_path,
+    running_in_managed_windows_wrapper,
+)
+
+
+def test_windows_drive_path_is_visible_through_msys_mount():
+    assert provider_path(
+        r"C:\Users\用户\project",
+        environ={"RAILMUX_WINDOWS_RUNTIME": "msys2"},
+    ) == Path("/c/Users/用户/project")
+
+
+def test_extended_windows_drive_path_is_normalized():
+    assert provider_path(
+        r"\\?\D:\work\repo",
+        environ={"RAILMUX_WINDOWS_RUNTIME": "msys2"},
+    ) == Path("/d/work/repo")
+
+
+def test_posix_runtime_preserves_existing_path_behavior():
+    raw = r"C:\Users\Alice\project"
+    assert provider_path(raw, environ={}) == Path(raw)
+
+
+def test_forward_slash_windows_drive_path_is_normalized():
+    assert provider_path(
+        "E:/workspace/project",
+        environ={"RAILMUX_WINDOWS_RUNTIME": "msys2"},
+    ) == Path("/e/workspace/project")
+
+
+def test_noacl_mode_requires_exact_managed_runtime_marker(monkeypatch):
+    payload = json.dumps({
+        "schema": 1,
+        "runtime": "msys2-test",
+        "railmux": __version__,
+    })
+    marker = SimpleNamespace(
+        lstat=lambda: SimpleNamespace(
+            st_mode=stat.S_IFREG | 0o644,
+            st_uid=42,
+            st_size=len(payload),
+        ),
+        read_text=lambda **_kwargs: payload,
+    )
+    monkeypatch.setattr(provider_paths, "_MANAGED_RUNTIME_MARKER", marker)
+    monkeypatch.setattr(provider_paths.sys, "platform", "cygwin")
+    monkeypatch.setattr(
+        provider_paths.os, "getuid", lambda: 42, raising=False,
+    )
+    monkeypatch.setenv("RAILMUX_WINDOWS_RUNTIME", "msys2")
+    monkeypatch.setenv("RAILMUX_MSYS2_RUNTIME_ID", "msys2-test")
+
+    assert running_in_managed_windows_wrapper()
+    assert private_mode_is_safe(0o100644)
+    assert not private_mode_is_safe(0o100666)
+
+    monkeypatch.setenv("RAILMUX_MSYS2_RUNTIME_ID", "other-runtime")
+    assert not running_in_managed_windows_wrapper()
+    assert not private_mode_is_safe(0o100644)
+
+
+def test_managed_runtime_marker_must_be_same_owner(monkeypatch):
+    marker = SimpleNamespace(
+        lstat=lambda: SimpleNamespace(
+            st_mode=stat.S_IFREG | 0o644,
+            st_uid=43,
+            st_size=2,
+        ),
+        read_text=lambda **_kwargs: "{}",
+    )
+    monkeypatch.setattr(provider_paths, "_MANAGED_RUNTIME_MARKER", marker)
+    monkeypatch.setattr(provider_paths.sys, "platform", "cygwin")
+    monkeypatch.setattr(
+        provider_paths.os, "getuid", lambda: 42, raising=False,
+    )
+    monkeypatch.setenv("RAILMUX_WINDOWS_RUNTIME", "msys2")
+    monkeypatch.setenv("RAILMUX_MSYS2_RUNTIME_ID", "msys2-test")
+
+    assert not running_in_managed_windows_wrapper()