railmux 0.4.0.dev16__tar.gz → 0.4.0.dev18__tar.gz

{railmux-0.4.0.dev16/src/railmux.egg-info → railmux-0.4.0.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev16
+Version: 0.4.0.dev18
 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.dev18/src/railmux/__init__.py

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

{railmux-0.4.0.dev16 → railmux-0.4.0.dev18}/src/railmux/cli.py

@@ -593,14 +593,28 @@ def main(argv: list[str] | None = None) -> int:
             if Path(sys.argv[0]).name == "__main__.py"
             else [sys.argv[0]]
         )
-        cmd = tmux_server.launcher_argv(launch_prefix, raw_args)
+        client_env = tmux_server.exec_environment()
         dedicated_session_id = (
             tmux_server.target_session_id(dedicated_target, "railmux")
             if dedicated_target is not None else None
         )
+        if dedicated_target is not None and dedicated_session_id is None:
+            from railmux.provider_paths import (
+                running_in_managed_windows_wrapper,
+            )
+            if running_in_managed_windows_wrapper():
+                dedicated_session_id = (
+                    tmux_server.ensure_detached_launcher_session(
+                        dedicated_target,
+                        launch_prefix,
+                        raw_args,
+                        env=client_env,
+                    )
+                )
+        cmd = tmux_server.launcher_argv(launch_prefix, raw_args)
         return _run_tmux_client_with_watchdog(
             cmd,
-            tmux_server.exec_environment(),
+            client_env,
             expected_target=dedicated_target,
             expected_session_id=dedicated_session_id,
         )

{railmux-0.4.0.dev16 → railmux-0.4.0.dev18}/src/railmux/fast_display_history.py

@@ -287,15 +287,17 @@ class LocalHistoryView:
                 # intermediate output above the current screen.
                 lines = incoming.lines
             else:
-                # A full-screen TUI redraw can leave no trustworthy text
-                # anchor. Preserve the known history and replace only the
-                # mutable live viewport. Appending every unaligned 300-line
-                # prefetch would duplicate a full screen every three seconds.
-                live_count = min(incoming.height, len(incoming.lines))
-                retained = previous.lines[
-                    : -min(previous.height, len(previous.lines))
-                ]
-                lines = retained + incoming.lines[-live_count:]
+                # Never splice two captures whose timelines cannot be aligned.
+                # Retaining old history and replacing only the live viewport
+                # looked conservative, but it silently omitted every row
+                # produced between those two pieces. That false seam appeared
+                # as discontinuous SSH history until returning to the bottom
+                # forced a fresh deep capture. Keep the newest internally
+                # contiguous hot capture instead; the first wheel-up requests
+                # a cumulative deep page and can recover older rows safely.
+                # An already-frozen viewport owns its immutable snapshot and
+                # therefore remains undisturbed by this cache replacement.
+                lines = incoming.lines
         else:
             start = min(0, delta)
             incoming_end = delta + len(incoming.lines)

{railmux-0.4.0.dev16 → railmux-0.4.0.dev18}/src/railmux/tmux_binding_manager.py

@@ -540,7 +540,6 @@ class SharedTmuxBindingManager:
                                     )
                                     break
                             return False
-                        self._registered = True
                         self._prefix_tab_managed = state["prefix_tab_managed"]
                         self._right_click_managed = (
                             state["right_click_managed"])
@@ -552,6 +551,10 @@ class SharedTmuxBindingManager:
                             state["status_click_managed"])
                         self._termux_tap_managed = (
                             state["termux_tap_managed"])
+                        # Publish registration only after every capability is
+                        # final so concurrent readers cannot observe a torn
+                        # lease during managed-Windows background setup.
+                        self._registered = True
                         return True
 
                 backup = tmux_ctl.prepare_root_function_bindings()
@@ -701,13 +704,13 @@ class SharedTmuxBindingManager:
                             state["termux_tap_backup"], token=token)
                     self._remove_state()
                     return False
-                self._registered = True
                 self._prefix_tab_managed = state["prefix_tab_managed"]
                 self._right_click_managed = state["right_click_managed"]
                 self._selection_hook_managed = state["selection_hook_managed"]
                 self._selection_hook_index = state["selection_hook_index"]
                 self._status_click_managed = state["status_click_managed"]
                 self._termux_tap_managed = state["termux_tap_managed"]
+                self._registered = True
                 return True
         except OSError:
             return False

{railmux-0.4.0.dev16 → railmux-0.4.0.dev18}/src/railmux/tmux_server.py

@@ -645,3 +645,53 @@ def launcher_argv(
         "--inside-tmux",
         *forwarded_args,
     )
+
+
+def ensure_detached_launcher_session(
+    target: TmuxServerTarget,
+    launch_prefix: Sequence[str],
+    forwarded_args: Sequence[str],
+    *,
+    env: Mapping[str, str] | None = None,
+    timeout: float = 5.0,
+) -> str | None:
+    """Create the outer UI detached on one already-proven server.
+
+    Managed Windows uses this only when a proven existing server has no outer
+    UI, commonly because Soft Quit left provider sessions alive in another
+    Terminal Services session.  A new tmux client can then reject
+    ``new-session -A`` before the outer session exists, so the server-origin
+    terminal bridge has no immutable session to attach.
+
+    An exact pre/post server-PID check fences the mutation.  A concurrent
+    launcher may win the create race; resolving one exact resulting session is
+    success regardless of this client's ``new-session`` return code.
+    """
+    existing = target_session_id(target, "railmux", timeout=0.5)
+    if existing is not None:
+        return existing
+    if not launch_prefix or not target_is_live(target, timeout=1.0, env=env):
+        return None
+    try:
+        subprocess.run(
+            target_argv(
+                target,
+                "new-session",
+                "-d",
+                "-s",
+                "railmux",
+                *launch_prefix,
+                "--inside-tmux",
+                *forwarded_args,
+            ),
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=timeout,
+            check=False,
+            env=None if env is None else dict(env),
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if not target_is_live(target, timeout=1.0, env=env):
+        return None
+    return target_session_id(target, "railmux", timeout=1.0)

{railmux-0.4.0.dev16 → railmux-0.4.0.dev18}/src/railmux/ui/app.py

@@ -125,6 +125,20 @@ _CODEX_ROLLOUT_PROBE_TTL_S = 2.0
 _SESSION_LEASE_PROBE_TTL_S = 2.0
 
 
+def _tmux_batch_argv(commands: list[list[str]]) -> list[str]:
+    """Encode independent tmux commands into one client invocation."""
+    argv = ["tmux"]
+    first = True
+    for command in commands:
+        if not command:
+            continue
+        if not first:
+            argv.append(";")
+        argv.extend(command)
+        first = False
+    return argv
+
+
 PALETTE = [
     # Status-bar message levels. Idle tips are dim; info neutral green;
     # warn/error escalate so failures stand out from routine feedback.
@@ -769,6 +783,11 @@ class App:
         self._delete_progress_text: str = "Deleting…"
         self._rendered_status_text: str | None = None
         self._rendered_status_level: str = "tip"
+        # Applying one logical status-bar frame used to spawn five tmux
+        # clients.  Keep the last complete frame so repeated focus/resize
+        # callbacks do not rewrite identical options, which is especially
+        # expensive under MSYS2 on Windows.
+        self._applied_tmux_bar_state: tuple[str, str, str, int, int] | None = None
         self._status_feedback_alarm: object | None = None
         self._attention_notice_key: tuple[str, int] | None = None
         self._tip_index: int = 0
@@ -857,6 +876,16 @@ class App:
                 identity.server_digest, identity.pane_id)
             if identity is not None else None
         )
+        # MSYS2 pays tens of milliseconds for every tmux client process. The
+        # crash-safe global wheel/function leases are independent from provider
+        # discovery and the first sidebar frame, so Windows prepares them on a
+        # background worker while the UI becomes interactive. Teardown joins
+        # that worker before restoring any lease.
+        self._windows_tmux_setup_lock = threading.Lock()
+        self._windows_tmux_setup_thread: threading.Thread | None = None
+        self._windows_tmux_setup_result: tuple[bool, bool] | None = None
+        self._windows_tmux_setup_done = False
+        self._windows_tmux_setup_cancelled = False
         self._termux_local_touch = bool(
             identity is not None
             and is_termux_environment()
@@ -2467,8 +2496,16 @@ class App:
 
     def _install_tmux_bindings(self) -> None:
         """Ensure global forwarding and the current Target projection exist."""
+        worker = getattr(self, "_windows_tmux_setup_thread", None)
+        if worker is not None and worker.is_alive():
+            return
         manager = getattr(self, "_tmux_binding_manager", None)
         opened = manager is not None and manager.open()
+        self._finish_tmux_bindings(opened)
+
+    def _finish_tmux_bindings(self, opened: bool) -> None:
+        """Project pane-local state after the shared lease is prepared."""
+        manager = getattr(self, "_tmux_binding_manager", None)
         selection = getattr(self, "_selection_isolation_manager", None)
         if selection is not None:
             selection.sync(
@@ -2501,6 +2538,96 @@ class App:
                 )
             self._sync_termux_tap_route()
 
+    def _start_windows_tmux_setup(self) -> None:
+        """Prepare expensive shared tmux leases without delaying first paint."""
+        if not running_in_windows_wrapper():
+            return
+        current = getattr(self, "_windows_tmux_setup_thread", None)
+        if current is not None:
+            return
+        wheel = getattr(self, "_root_wheel_manager", None)
+        manager = getattr(self, "_tmux_binding_manager", None)
+
+        def cancelled() -> bool:
+            with self._windows_tmux_setup_lock:
+                return self._windows_tmux_setup_cancelled
+
+        def prepare() -> None:
+            try:
+                if cancelled():
+                    return
+                try:
+                    wheel_ok = wheel is None or wheel.open()
+                except Exception:
+                    # These leases improve mouse/status routing but are not
+                    # authority for provider discovery or history. Degrade to
+                    # the existing keyboard paths if an unexpected adapter
+                    # error escapes a fail-closed manager.
+                    wheel_ok = False
+                if cancelled():
+                    return
+                try:
+                    bindings_opened = manager is not None and manager.open()
+                except Exception:
+                    bindings_opened = False
+                with self._windows_tmux_setup_lock:
+                    if not self._windows_tmux_setup_cancelled:
+                        self._windows_tmux_setup_result = (
+                            wheel_ok, bindings_opened)
+            finally:
+                # Publish terminal completion even for a BaseException so the
+                # Urwid callback cannot poll a dead worker forever.
+                with self._windows_tmux_setup_lock:
+                    self._windows_tmux_setup_done = True
+
+        worker = threading.Thread(
+            target=prepare,
+            name="railmux-windows-tmux-setup",
+            daemon=False,
+        )
+        self._windows_tmux_setup_thread = worker
+        worker.start()
+
+    def _finish_windows_tmux_setup(self, loop, _user_data) -> None:
+        """Consume background lease setup on the Urwid thread."""
+        with self._windows_tmux_setup_lock:
+            result = self._windows_tmux_setup_result
+            done = self._windows_tmux_setup_done
+            if result is not None:
+                self._windows_tmux_setup_result = None
+        if result is None:
+            worker = getattr(self, "_windows_tmux_setup_thread", None)
+            if not done and worker is not None and worker.is_alive():
+                loop.set_alarm_in(0.05, self._finish_windows_tmux_setup)
+            elif not done:
+                # No worker was created, or it died before publishing its
+                # terminal state. Preserve the pre-deferral one-shot setup
+                # without leaving a 20 Hz alarm behind.
+                self._install_tmux_bindings()
+            return
+        wheel_ok, bindings_opened = result
+        if not wheel_ok:
+            self._set_status(
+                "Mouse-wheel forwarding unavailable; tmux may have custom "
+                "root wheel bindings.",
+                "warn",
+            )
+        self._finish_tmux_bindings(bindings_opened)
+
+    def _cancel_windows_tmux_setup(self) -> None:
+        """Stop starting leases and wait before main-thread cleanup."""
+        worker = getattr(self, "_windows_tmux_setup_thread", None)
+        if worker is None:
+            return
+        with self._windows_tmux_setup_lock:
+            self._windows_tmux_setup_cancelled = True
+        # Waiting here gives teardown sole cleanup ownership and prevents a
+        # late worker write from reinstalling bindings after their originals
+        # were restored. These same manager operations ran synchronously before
+        # deferral; a non-daemon worker keeps that cleanup guarantee if a later
+        # teardown phase raises.
+        worker.join()
+
     def _set_workspace_target(self, slot_key: str) -> AgentSlot:
         """Apply one Target transition and refresh its tmux projection."""
         slot = self._agent_workspace().set_target(slot_key)
@@ -3062,6 +3189,19 @@ class App:
         workspace = self._agent_workspace()
         if workspace.presentation is presentation:
             return True
+        has_agent_page = any(slot.pane_id for slot in workspace.slots)
+        if not has_agent_page:
+            # With only the sidebar pane there is no tmux page to select,
+            # zoom, or preserve.  Avoid a chain of geometry subprocesses on
+            # initial compact terminals; the logical presentation still
+            # drives the responsive footer and status bar.
+            workspace.presentation = presentation
+            workspace.compact_page = WorkspacePage.SIDEBAR
+            self._pre_compact_wide_zoom_pane = None
+            self._pre_compact_layout_profile = None
+            self._remote_compact_prepared = None
+            self._apply_tmux_bar(self._tmux_error_bar)
+            return True
         if presentation is WorkspacePresentation.COMPACT:
             owner = getattr(self, "_railmux_pane_id", None)
             prepared = getattr(self, "_remote_compact_prepared", None)
@@ -8099,6 +8239,7 @@ class App:
             if isinstance(index, BackgroundCodexIndex):
                 index.close(timeout_s=0.2)
             self._teardown_scroll_acceleration()
+            self._cancel_windows_tmux_setup()
             selection = getattr(self, "_selection_isolation_manager", None)
             if selection is not None:
                 selection.close()
@@ -10559,7 +10700,9 @@ class App:
         elif (size_changed and workspace.presentation
               is WorkspacePresentation.COMPACT):
             self._apply_tmux_bar(self._tmux_error_bar)
+        has_agent_page = any(slot.pane_id for slot in workspace.slots)
         if (workspace.presentation is WorkspacePresentation.COMPACT
+                and has_agent_page
                 and self._window_is_zoomed() is False):
             # Retry a transient failed zoom and heal manual/unexpected unzoom;
             # compact presentation is defined by exactly one visible page.
@@ -10795,16 +10938,16 @@ class App:
             self._rendered_status_level = level
         try:
             import subprocess as _sp
-            _sp.run(
-                ["tmux", "set-option", "-t", self._tmux_status_session,
+            commands = [
+                ["set-option", "-t", self._tmux_status_session,
                  "status-right", payload],
+            ]
+            if refresh:
+                commands.append(["refresh-client", "-S"])
+            _sp.run(
+                _tmux_batch_argv(commands),
                 stdout=_sp.DEVNULL, stderr=_sp.DEVNULL,
             )
-            if refresh:
-                _sp.run(
-                    ["tmux", "refresh-client", "-S"],
-                    stdout=_sp.DEVNULL, stderr=_sp.DEVNULL,
-                )
         except Exception:
             pass
 
@@ -10880,23 +11023,35 @@ class App:
                 self._status_layout_indicator(),
                 wrap_action,
             )
+        state = (
+            self._tmux_status_session,
+            bar,
+            brand,
+            left_length,
+            right_length,
+        )
+        if getattr(self, "_applied_tmux_bar_state", None) == state:
+            return
         try:
             import subprocess as _sp
-            for opt, val in (
-                ("status-style", bar),
-                ("status-left", brand),
-                ("status-left-length", str(left_length)),
-                ("status-right-length", str(right_length)),
-            ):
-                _sp.run(
-                    ["tmux", "set-option", "-t", self._tmux_status_session,
-                     opt, val],
-                    stdout=_sp.DEVNULL, stderr=_sp.DEVNULL,
+            commands = [
+                ["set-option", "-t", self._tmux_status_session, opt, val]
+                for opt, val in (
+                    ("status-style", bar),
+                    ("status-left", brand),
+                    ("status-left-length", str(left_length)),
+                    ("status-right-length", str(right_length)),
                 )
+            ]
             # Force an immediate repaint (default status-interval is 15s) so a
             # mode toggle or error flip shows at once, not on the next tick.
-            _sp.run(["tmux", "refresh-client", "-S"],
-                    stdout=_sp.DEVNULL, stderr=_sp.DEVNULL)
+            commands.append(["refresh-client", "-S"])
+            result = _sp.run(
+                _tmux_batch_argv(commands),
+                stdout=_sp.DEVNULL, stderr=_sp.DEVNULL,
+            )
+            if getattr(result, "returncode", 0) == 0:
+                self._applied_tmux_bar_state = state
         except Exception:
             pass
 
@@ -11040,28 +11195,31 @@ class App:
             if tmux_ctl.in_tmux():
                 sess = tmux_ctl.current_session_name() or "railmux"
                 _sp.run(
-                    ["tmux", "set-option", "-t", sess, "set-clipboard", "on"],
+                    _tmux_batch_argv([
+                        ["set-option", "-t", sess, "set-clipboard", "on"],
+                        ["set-option", "-t", sess, "focus-events", "on"],
+                        ["set-option", "-t", sess, "mouse", "on"],
+                    ]),
                     stdout=_sp.DEVNULL, stderr=_sp.DEVNULL,
                 )
                 # Force OSC 52 passthrough so a left-drag selection in either pane
                 # copies to the *local* system clipboard (works over SSH / nested
                 # tmux on OSC-52-capable terminals). Pairs with set-clipboard on.
                 tmux_ctl.enable_clipboard_passthrough()
-                _sp.run(
-                    ["tmux", "set-option", "-t", sess, "focus-events", "on"],
-                    stdout=_sp.DEVNULL, stderr=_sp.DEVNULL,
-                )
-                _sp.run(
-                    ["tmux", "set-option", "-t", sess, "mouse", "on"],
-                    stdout=_sp.DEVNULL, stderr=_sp.DEVNULL,
-                )
-                wheel = getattr(self, "_root_wheel_manager", None)
-                if wheel is not None and not wheel.open():
-                    self._set_status(
-                        "Mouse-wheel forwarding unavailable; tmux may have "
-                        "custom root wheel bindings.",
-                        "warn",
-                    )
+                if running_in_windows_wrapper():
+                    # Root-table lease discovery is particularly expensive in
+                    # MSYS2 because each tmux query launches a Windows process.
+                    # It is independent of provider/session restoration, so
+                    # finish it after the first interactive frame.
+                    self._start_windows_tmux_setup()
+                else:
+                    wheel = getattr(self, "_root_wheel_manager", None)
+                    if wheel is not None and not wheel.open():
+                        self._set_status(
+                            "Mouse-wheel forwarding unavailable; tmux may "
+                            "have custom root wheel bindings.",
+                            "warn",
+                        )
             self._railmux_pane_id = tmux_ctl.current_pane_id()
             if (self._railmux_pane_id is not None
                     and tmux_ctl.current_session_name() == "railmux"
@@ -11077,7 +11235,8 @@ class App:
                 # a saved agent-focused workspace will replace that temporary
                 # topology shortly. Do not expose its misleading row focus.
                 self._frame.set_window_active(False)
-            self._install_tmux_bindings()
+            if getattr(self, "_windows_tmux_setup_thread", None) is None:
+                self._install_tmux_bindings()
             # bracketed_paste_mode: the terminal frames pastes in begin/end markers
             # so _filter_input can drop them — sidebar keys are destructive commands,
             # not text input.
@@ -11111,11 +11270,13 @@ class App:
                 # visually clean.  These overrides remain session-scoped and
                 # teardown reverts them to the dedicated server's hidden
                 # baseline.
-                for opt, val in self._TMUX_BAR_OPTIONS:
-                    _sp.run(
-                        ["tmux", "set-option", "-t", sess, opt, val],
-                        stdout=_sp.DEVNULL, stderr=_sp.DEVNULL,
-                    )
+                _sp.run(
+                    _tmux_batch_argv([
+                        ["set-option", "-t", sess, opt, val]
+                        for opt, val in self._TMUX_BAR_OPTIONS
+                    ]),
+                    stdout=_sp.DEVNULL, stderr=_sp.DEVNULL,
+                )
                 self._tmux_status_session = sess
                 self._tmux_status_enabled = True
                 self._apply_tmux_bar(error=False)  # initial green bar
@@ -11144,6 +11305,12 @@ class App:
             if running_in_windows_wrapper():
                 self._loop.set_alarm_in(
                     0.05, self._report_windows_startup_summary)
+                # Leave one bounded initial-paint interval before consuming
+                # the lease result. Even if the worker completed immediately,
+                # its status/bar projection cannot delay the first frame.
+                if self._windows_tmux_setup_thread is not None:
+                    self._loop.set_alarm_in(
+                        0.1, self._finish_windows_tmux_setup)
             self._loop.run()
         except KeyboardInterrupt:
             # Ctrl-C / SIGINT — fall through to teardown.

{railmux-0.4.0.dev16 → railmux-0.4.0.dev18/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev16
+Version: 0.4.0.dev18
 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.dev16 → railmux-0.4.0.dev18}/tests/test_cli.py

@@ -472,6 +472,73 @@ def test_prelaunch_recovery_is_scoped_to_the_dedicated_server(monkeypatch):
     assert os.environ["TMUX_PANE"] == "%9"
 
 
+def test_managed_windows_precreates_missing_outer_session_for_bridge(
+    monkeypatch,
+):
+    target = TmuxServerTarget("/tmp/tmux-private/railmux", 789)
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.discover_target", lambda: target)
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.is_current_server", lambda _target: False)
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.target_session_id", lambda *_a, **_kw: None)
+    monkeypatch.setattr("railmux.cli.sys.argv", ["/opt/railmux/bin/railmux"])
+    monkeypatch.setattr(
+        "railmux.provider_paths.running_in_managed_windows_wrapper",
+        lambda: True,
+    )
+    prepared = MagicMock(return_value="$9")
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.ensure_detached_launcher_session", prepared)
+    run_client = MagicMock(return_value=0)
+    monkeypatch.setattr(
+        "railmux.cli._run_tmux_client_with_watchdog", run_client)
+
+    assert main(["--project", "/work"]) == 0
+
+    client_env = tmux_server.exec_environment()
+    prepared.assert_called_once_with(
+        target,
+        ["/opt/railmux/bin/railmux"],
+        ["--project", "/work"],
+        env=client_env,
+    )
+    assert run_client.call_args.kwargs == {
+        "expected_target": target,
+        "expected_session_id": "$9",
+    }
+
+
+def test_posix_missing_outer_session_keeps_ordinary_new_session_path(
+    monkeypatch,
+):
+    target = TmuxServerTarget("/tmp/tmux-private/railmux", 789)
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.discover_target", lambda: target)
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.is_current_server", lambda _target: False)
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.target_session_id", lambda *_a, **_kw: None)
+    monkeypatch.setattr(
+        "railmux.provider_paths.running_in_managed_windows_wrapper",
+        lambda: False,
+    )
+    prepared = MagicMock()
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.ensure_detached_launcher_session", prepared)
+    run_client = MagicMock(return_value=0)
+    monkeypatch.setattr(
+        "railmux.cli._run_tmux_client_with_watchdog", run_client)
+
+    assert main([]) == 0
+
+    prepared.assert_not_called()
+    assert run_client.call_args.kwargs == {
+        "expected_target": target,
+        "expected_session_id": None,
+    }
+
+
 def test_local_tmux_watchdog_exits_and_records_after_consecutive_failures(
     monkeypatch, capsys,
 ):

{railmux-0.4.0.dev16 → railmux-0.4.0.dev18}/tests/test_fast_full_window.py

@@ -3576,18 +3576,50 @@ def test_periodic_prefetch_never_moves_an_existing_frozen_viewport():
 
     assert action == HistoryAction()
     assert view.overlays() == before
-    # A redraw without safe anchors updates only the mutable live viewport;
-    # it must not erase already captured history behind the frozen view.
-    assert view.content_cache["%8"].lines == (
-        b"old-0",
-        b"old-1",
-        b"old-2",
-        b"old-3",
-        b"old-4",
-        b"new-5",
-        b"new-6",
-        b"new-7",
+    # A redraw without safe anchors cannot be spliced onto the old capture:
+    # doing so would manufacture a false seam and omit intermediate rows. The
+    # immutable frozen viewport remains visible, while the next history entry
+    # starts from the newest internally contiguous capture.
+    assert view.content_cache["%8"].lines == advanced.lines
+
+
+def test_unaligned_hot_prefetch_never_creates_a_discontinuous_history_seam():
+    view = LocalHistoryView(history_limit=2000)
+    first = InputFrameDecoder().feed(view.begin_prefetch(1.0))[0]
+    first_id, _limit = decode_history_prefetch(first.data)
+    old = HistorySnapshot(
+        first_id,
+        "%8",
+        30,
+        0,
+        30,
+        3,
+        tuple(f"old-{index}".encode() for index in range(300)),
+        more_available=True,
+    )
+    view.accept_prefetch(HistoryBatch(first_id, (old,)))
+
+    second = InputFrameDecoder().feed(view.begin_prefetch(2.0))[0]
+    second_id, _limit = decode_history_prefetch(second.data)
+    current = HistorySnapshot(
+        second_id,
+        "%8",
+        30,
+        0,
+        30,
+        3,
+        tuple(f"new-{index}".encode() for index in range(300)),
+        more_available=True,
     )
+    view.accept_prefetch(HistoryBatch(second_id, (current,)))
+
+    wheel = view.wheel(SgrMouseEvent(b"up", 64, 40, 2, True))
+
+    assert view.viewports["%8"].snapshot.lines == current.lines
+    assert view.overlays()[0][1] == (b"new-296", b"new-297", b"new-298")
+    assert b"old-296" not in view.viewports["%8"].snapshot.lines
+    request = InputFrameDecoder().feed(wheel.protocol_frame)[0]
+    assert decode_history_request(request.data)[3] == 2000
 
 
 def test_temporary_blank_fullscreen_tail_is_removed_after_main_view_returns():