railmux 0.4.0.dev18__tar.gz → 0.4.0.dev20__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev18
+Version: 0.4.0.dev20
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -384,10 +384,9 @@ Scrolling a live agent does not enter Preview. Direct `railmux` uses the
 terminal/tmux scrolling behavior; `railmux ssh` keeps its own bounded,
 per-pane history and normally preserves the live terminal's captured styling.
 When Railmux confirms that a running Codex session advanced after rewind or
-steering, it resets only the current terminal view before Codex redraws and
-invalidates that pane's SSH history generation. Retained tmux scrollback is not
-erased; the SSH history for that branched generation uses the canonical
-rollout so its abandoned suffix stays hidden.
+steering, it leaves the live terminal untouched and advances only that pane's
+SSH history generation. The SSH history for that branched generation uses the
+canonical rollout so its abandoned suffix stays hidden.
 
 Preview opens at the latest activity in `less`; large sessions are limited to
 their latest 2,000 saved records. Press `/` to search, `n`/`N` to move between
@@ -446,7 +445,8 @@ Each opened agent runs in a detached tmux session, so switching sessions does
 not interrupt it. To leave agents running when you quit Railmux, press `s` for
 soft quit in the confirmation popup; restarting the same Railmux instance then
 restores the usable workspace when those sessions are still available. A normal
-quit confirmation ends all running sessions instead.
+quit ends all running sessions instead and therefore requires a second
+confirmation; `y` and Enter keep their existing confirm meaning in both steps.
 
 All terminals attached to one managed Railmux window view the same UI process.
 Soft Quit therefore closes that shared UI for every attached view, although it

{railmux-0.4.0.dev18 → railmux-0.4.0.dev20}/README.md

@@ -341,10 +341,9 @@ Scrolling a live agent does not enter Preview. Direct `railmux` uses the
 terminal/tmux scrolling behavior; `railmux ssh` keeps its own bounded,
 per-pane history and normally preserves the live terminal's captured styling.
 When Railmux confirms that a running Codex session advanced after rewind or
-steering, it resets only the current terminal view before Codex redraws and
-invalidates that pane's SSH history generation. Retained tmux scrollback is not
-erased; the SSH history for that branched generation uses the canonical
-rollout so its abandoned suffix stays hidden.
+steering, it leaves the live terminal untouched and advances only that pane's
+SSH history generation. The SSH history for that branched generation uses the
+canonical rollout so its abandoned suffix stays hidden.
 
 Preview opens at the latest activity in `less`; large sessions are limited to
 their latest 2,000 saved records. Press `/` to search, `n`/`N` to move between
@@ -403,7 +402,8 @@ Each opened agent runs in a detached tmux session, so switching sessions does
 not interrupt it. To leave agents running when you quit Railmux, press `s` for
 soft quit in the confirmation popup; restarting the same Railmux instance then
 restores the usable workspace when those sessions are still available. A normal
-quit confirmation ends all running sessions instead.
+quit ends all running sessions instead and therefore requires a second
+confirmation; `y` and Enter keep their existing confirm meaning in both steps.
 
 All terminals attached to one managed Railmux window view the same UI process.
 Soft Quit therefore closes that shared UI for every attached view, although it

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

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

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

@@ -26,6 +26,7 @@ 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
+from railmux.terminal_status import command_status
 
 
 def _show_startup_message(
@@ -44,6 +45,20 @@ _LOCAL_WATCHDOG_INTERVAL = 5.0
 _LOCAL_WATCHDOG_FAILURES = 3
 
 
+def _interactive_terminal_size() -> tuple[int, int] | None:
+    """Return an exact entry TTY size without manufacturing a fallback."""
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        return None
+    for stream in (sys.stdout, sys.stdin):
+        try:
+            size = os.get_terminal_size(stream.fileno())
+        except (AttributeError, OSError):
+            continue
+        if 0 < size.columns <= 65535 and 0 < size.lines <= 65535:
+            return size.columns, size.lines
+    return None
+
+
 def _restore_terminal(attributes: list | None) -> None:
     if attributes is None:
         return
@@ -85,6 +100,9 @@ def _run_tmux_client_with_watchdog(
     expected_session_id: str | None = None,
 ) -> int:
     """Keep one monitor outside tmux so a frozen server cannot trap the TTY."""
+    from railmux.provider_paths import running_in_managed_windows_wrapper
+
+    managed_windows = running_in_managed_windows_wrapper()
     attributes = None
     if sys.stdin.isatty():
         try:
@@ -93,7 +111,14 @@ def _run_tmux_client_with_watchdog(
             pass
     started_at = time.monotonic()
     try:
-        process: object = subprocess.Popen(argv, env=env)
+        popen_kwargs: dict[str, object] = {"env": env}
+        if managed_windows and expected_target is not None:
+            # A fast direct-client rejection is an implementation detail when
+            # the server-origin bridge succeeds. Suppress tmux's raw
+            # ``open terminal failed`` line and emit one Railmux-owned status
+            # below; bridge failures still receive an actionable error.
+            popen_kwargs["stderr"] = subprocess.DEVNULL
+        process: object = subprocess.Popen(argv, **popen_kwargs)
     except OSError as exc:
         print(f"error: could not start tmux client: {exc}", file=sys.stderr)
         return 2
@@ -204,10 +229,6 @@ def _run_tmux_client_with_watchdog(
                 expected_session_id = tmux_server.target_session_id(
                     expected_target, "railmux", timeout=0.5)
 
-            from railmux.provider_paths import running_in_managed_windows_wrapper
-
-            managed_windows = running_in_managed_windows_wrapper()
-
             can_relay = bool(
                 current_target == expected_target
                 and expected_session_id is not None
@@ -223,13 +244,7 @@ def _run_tmux_client_with_watchdog(
                     start_relay_client,
                 )
 
-                print(
-                    "info: direct tmux attach was unavailable; reconnecting "
-                    "through the Windows terminal bridge",
-                    file=sys.stderr,
-                )
                 try:
-                    tty.setraw(sys.stdin.fileno())
                     relay = start_relay_client(
                         target=expected_target,
                         session_id=expected_session_id,
@@ -237,6 +252,15 @@ def _run_tmux_client_with_watchdog(
                         stdin_fd=sys.stdin.fileno(),
                         stdout_fd=sys.stdout.fileno(),
                     )
+                    print(
+                        command_status(
+                            "info",
+                            "connected through the Windows terminal bridge",
+                            stream=sys.stderr,
+                        ),
+                        file=sys.stderr,
+                    )
+                    tty.setraw(sys.stdin.fileno())
                     process = relay
                     returncode, watchdog_failed = monitor_client(
                         asynchronous_probe=True)
@@ -296,6 +320,14 @@ def _run_tmux_client_with_watchdog(
                     ),
                     consecutive_failures=1,
                 )
+                if not relay_attempted:
+                    print(
+                        "error: direct tmux attach was rejected and the "
+                        "Windows terminal bridge was unavailable; the "
+                        "existing workspace was left running; run "
+                        "'railmux doctor' for diagnostics",
+                        file=sys.stderr,
+                    )
         # Routine post-exit removal of a proof-authorized last-session socket
         # is housekeeping. Only pre-launch recovery is user-visible.
         windows_tmux_lifecycle.recover_abandoned_socket()
@@ -609,6 +641,7 @@ def main(argv: list[str] | None = None) -> int:
                         launch_prefix,
                         raw_args,
                         env=client_env,
+                        initial_size=_interactive_terminal_size(),
                     )
                 )
         cmd = tmux_server.launcher_argv(launch_prefix, raw_args)

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

@@ -109,6 +109,10 @@ class _PendingHistory:
     pane_id: str
     target_lines: int
     requested_at: float
+    # A first wheel-up waits for one cumulative snapshot before freezing the
+    # viewport. This avoids exposing a short hot suffix whose later deep page
+    # may not share a stable anchor while the provider is actively repainting.
+    initial_offset: int | None = None
 
 
 class LocalHistoryView:
@@ -266,8 +270,6 @@ class LocalHistoryView:
         self,
         previous: HistorySnapshot,
         incoming: HistorySnapshot,
-        *,
-        prefer_deeper: bool = False,
     ) -> HistorySnapshot:
         """Retain already-fetched history when a later hot capture shrinks."""
         if not self._same_geometry(
@@ -276,28 +278,13 @@ class LocalHistoryView:
             return incoming
         delta = self._timeline_delta(previous.lines, incoming.lines)
         if delta is None:
-            if prefer_deeper and len(incoming.lines) > len(previous.lines):
-                # A deep response reaches here only after accept() proved that
-                # the user's immutable frozen viewport still exists in it.
-                # Rewind/full-screen diff output can make every individual
-                # line in that viewport non-unique, leaving the generic
-                # timeline voter without two anchors.  The larger cumulative
-                # capture is nevertheless stronger than the 300-line hot
-                # cache; keeping only its live tail would silently discard all
-                # intermediate output above the current screen.
-                lines = incoming.lines
-            else:
-                # 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
+            # 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. Keep the newest internally contiguous
+            # capture instead. An already-frozen viewport owns its immutable
+            # snapshot and therefore remains undisturbed by cache replacement.
+            lines = incoming.lines
         else:
             start = min(0, delta)
             incoming_end = delta + len(incoming.lines)
@@ -325,8 +312,6 @@ class LocalHistoryView:
     def _remember_content(
         self,
         snapshot: HistorySnapshot,
-        *,
-        prefer_deeper: bool = False,
     ) -> HistorySnapshot:
         assert snapshot.pane_id is not None
         previous = self.content_cache.get(snapshot.pane_id)
@@ -344,8 +329,7 @@ class LocalHistoryView:
             stored = self._merge_content(previous, snapshot) if anchored else snapshot
             self._unverified_after_reconnect.discard(snapshot.pane_id)
         else:
-            stored = self._merge_content(
-                previous, snapshot, prefer_deeper=prefer_deeper)
+            stored = self._merge_content(previous, snapshot)
         # Reinsert an existing pane to keep insertion order as recency order.
         self.content_cache.pop(snapshot.pane_id, None)
         self.content_cache[snapshot.pane_id] = stored
@@ -353,6 +337,15 @@ class LocalHistoryView:
             del self.content_cache[next(iter(self.content_cache))]
         return stored
 
+    def _replace_content(self, snapshot: HistorySnapshot) -> HistorySnapshot:
+        """Install one verified contiguous capture without timeline merging."""
+        assert snapshot.pane_id is not None
+        self.content_cache.pop(snapshot.pane_id, None)
+        self.content_cache[snapshot.pane_id] = snapshot
+        while len(self.content_cache) > _HISTORY_CONTENT_PANES:
+            del self.content_cache[next(iter(self.content_cache))]
+        return snapshot
+
     def invalidate_routes(self) -> bool:
         """Drop pointer authority without discarding bounded pane content."""
         was_active = self.cancel()
@@ -470,29 +463,32 @@ class LocalHistoryView:
         cached = self.content_cache.get(route.pane_id, route)
         if not self._same_geometry(cached, route):
             cached = route
+        loaded_limit = min(len(cached.lines), self.history_limit)
+        target_lines = min(self.history_limit, _HISTORY_INITIAL_LINES)
+        if (
+            cached.more_available
+            and loaded_limit < min(target_lines, _HISTORY_PREFETCH_LINES)
+        ):
+            self.cancel_pane(route.pane_id)
+            request_id = self._allocate_request_id()
+            self._deep_pending[request_id] = _PendingHistory(
+                self.route_epoch,
+                route.pane_id,
+                target_lines,
+                time.monotonic() if now is None else now,
+                max(1, initial_offset),
+            )
+            self._deep_requests += 1
+            # A byte-budgeted or older peer may return less than the normal
+            # coherent routing capture. Keep the live pane intact until one
+            # cumulative response arrives rather than expose a short suffix.
+            return HistoryAction(
+                protocol_frame=encode_history_request(
+                    request_id, event.x, event.y, target_lines
+                )
+            )
         maximum = max(0, len(cached.lines) - cached.height)
         if maximum == 0:
-            if cached.more_available:
-                self.cancel_pane(route.pane_id)
-                target_lines = min(self.history_limit, _HISTORY_INITIAL_LINES)
-                self.viewports[route.pane_id] = _HistoryViewport(
-                    cached,
-                    0,
-                    min(len(cached.lines), self.history_limit),
-                )
-                request_id = self._allocate_request_id()
-                self._deep_pending[request_id] = _PendingHistory(
-                    self.route_epoch,
-                    route.pane_id,
-                    target_lines,
-                    time.monotonic() if now is None else now,
-                )
-                self._deep_requests += 1
-                return HistoryAction(
-                    protocol_frame=encode_history_request(
-                        request_id, event.x, event.y, target_lines
-                    )
-                )
             if cached.transcript_backed:
                 # Claude may not have written its first transcript record yet.
                 # This is a normal transient state, not a Railmux status event:
@@ -503,7 +499,6 @@ class LocalHistoryView:
                 forwarded_input=event.raw if cached.mouse_forwardable else b""
             )
         self.cancel_pane(route.pane_id)
-        loaded_limit = min(len(cached.lines), self.history_limit)
         viewport = _HistoryViewport(
             cached,
             min(maximum, max(1, initial_offset)),
@@ -513,23 +508,15 @@ class LocalHistoryView:
             ),
         )
         self.viewports[route.pane_id] = viewport
-        target_lines = min(self.history_limit, _HISTORY_INITIAL_LINES)
-        if loaded_limit >= target_lines:
-            return HistoryAction(
-                protocol_frame=self._extend_history(viewport, now=now),
-                render_history=True,
-            )
-        request_id = self._allocate_request_id()
-        self._deep_pending[request_id] = _PendingHistory(
-            self.route_epoch,
-            route.pane_id,
-            target_lines,
-            time.monotonic() if now is None else now,
-        )
-        self._deep_requests += 1
+        # A complete 300-row routing capture is already one coherent history
+        # source. Paint it synchronously, then fetch a cumulative page only as
+        # the viewport approaches its top. This removes an SSH round trip from
+        # the first wheel tick without reintroducing a hot/deep splice.
         return HistoryAction(
-            protocol_frame=encode_history_request(
-                request_id, event.x, event.y, target_lines
+            protocol_frame=self._extend_history(
+                viewport,
+                now=now,
+                request_position=(event.x, event.y),
             ),
             render_history=True,
         )
@@ -539,6 +526,7 @@ class LocalHistoryView:
         viewport: _HistoryViewport,
         *,
         now: float | None = None,
+        request_position: tuple[int, int] | None = None,
     ) -> bytes:
         """Request the next cumulative page when a viewport nears its top."""
         snapshot = viewport.snapshot
@@ -572,7 +560,9 @@ class LocalHistoryView:
             return b""
         target_lines = min(
             self.history_limit,
-            max(_HISTORY_INITIAL_LINES, viewport.loaded_limit) + _HISTORY_PAGE_LINES,
+            _HISTORY_INITIAL_LINES
+            if viewport.loaded_limit < _HISTORY_INITIAL_LINES
+            else viewport.loaded_limit + _HISTORY_PAGE_LINES,
         )
         request_id = self._allocate_request_id()
         self._deep_pending[request_id] = _PendingHistory(
@@ -582,10 +572,14 @@ class LocalHistoryView:
             requested_at,
         )
         self._deep_requests += 1
-        return encode_history_request(
-            request_id,
+        request_x, request_y = request_position or (
             snapshot.x + 1,
             snapshot.y + 1,
+        )
+        return encode_history_request(
+            request_id,
+            request_x,
+            request_y,
             target_lines,
         )
 
@@ -602,6 +596,45 @@ class LocalHistoryView:
         if direction > 0 and route.history_choice_required:
             return HistoryAction(claude_history_prompt=event.raw)
         viewport = self.viewports.get(route.pane_id)
+        initial_request = next(
+            (
+                (request_id, pending)
+                for request_id, pending in self._deep_pending.items()
+                if pending.pane_id == route.pane_id
+                and pending.initial_offset is not None
+            ),
+            None,
+        )
+        if initial_request is not None:
+            request_id, pending = initial_request
+            requested_at = time.monotonic() if now is None else now
+            if requested_at - pending.requested_at >= _HISTORY_DEEP_TIMEOUT:
+                self._deep_pending.pop(request_id, None)
+                self._timeouts += 1
+                if direction < 0:
+                    return HistoryAction()
+                assert pending.initial_offset is not None
+                distance = min(
+                    self.history_limit,
+                    pending.initial_offset + max(1, distance),
+                )
+                initial_request = None
+        if viewport is None and initial_request is not None:
+            if direction < 0:
+                # The live pane never left the screen, so reversing direction
+                # simply cancels the pending entry. A late response is ignored.
+                self.cancel_pane(route.pane_id)
+                return HistoryAction()
+            request_id, pending = initial_request
+            assert pending.initial_offset is not None
+            self._deep_pending[request_id] = replace(
+                pending,
+                initial_offset=min(
+                    self.history_limit,
+                    pending.initial_offset + max(1, distance),
+                ),
+            )
+            return HistoryAction()
         if viewport is not None:
             maximum = max(0, len(viewport.snapshot.lines) - viewport.snapshot.height)
             viewport.offset = max(
@@ -828,8 +861,26 @@ class LocalHistoryView:
             return HistoryAction()
         viewport = self.viewports.get(pending.pane_id)
         if viewport is None:
-            self._remember_content(snapshot)
-            return HistoryAction()
+            if pending.initial_offset is None:
+                self._remember_content(snapshot)
+                return HistoryAction()
+            maximum = max(0, len(snapshot.lines) - snapshot.height)
+            if maximum == 0:
+                self._remember_content(snapshot)
+                return HistoryAction()
+            stored = self._replace_content(snapshot)
+            maximum = max(0, len(stored.lines) - stored.height)
+            viewport = _HistoryViewport(
+                stored,
+                min(maximum, pending.initial_offset),
+                min(self.history_limit, max(pending.target_lines, len(stored.lines))),
+                exhausted=not snapshot.more_available,
+            )
+            self.viewports[pending.pane_id] = viewport
+            return HistoryAction(
+                protocol_frame=self._extend_history(viewport),
+                render_history=True,
+            )
         maximum = max(0, len(snapshot.lines) - snapshot.height)
         if maximum == 0:
             self._remember_content(snapshot)
@@ -843,7 +894,11 @@ class LocalHistoryView:
             # snapshot instead of jumping to newer or unrelated text.
             self._anchor_rejects += 1
             return HistoryAction()
-        stored = self._remember_content(snapshot, prefer_deeper=True)
+        # The response is one cumulative capture and its exact visible anchor
+        # was just proved above. Replace the cached timeline as a whole instead
+        # of merging it with the older hot generation; this keeps every row's
+        # text and background styling from one server render.
+        stored = self._replace_content(snapshot)
         stored_offset = self._aligned_offset(stored, anchor)
         if stored_offset is None:
             # The raw response was valid, so this can only be an ambiguous
@@ -892,7 +947,7 @@ class LocalHistoryView:
             return matched_offset
 
         # Agent status rows (for example a Codex spinner) can change between
-        # the 300-line hot snapshot and the first deep response. Requiring the
+        # the hot snapshot and a deep response. Requiring the
         # entire visible viewport to remain byte-identical then strands the
         # user at the hot-cache boundary. Align on a majority of stable,
         # non-blank lines instead, but only when each evidence line occurs

{railmux-0.4.0.dev18 → railmux-0.4.0.dev20}/src/railmux/fast_display_server.py

@@ -1171,12 +1171,35 @@ def apply_path_open_request(
     )
 
 
-def _render_history_line(pyte: object, line: bytes, width: int) -> bytes:
-    """Parse one physical tmux line and emit only allowlisted SGR styling."""
+def _render_history_lines(
+    pyte: object,
+    lines: Sequence[bytes],
+    width: int,
+) -> tuple[bytes, ...]:
+    """Render physical tmux rows while retaining cross-row terminal style.
+
+    ``tmux capture-pane -e`` is a terminal stream, not a collection of
+    independently styled strings. In particular, tmux omits an SGR prefix
+    when a row inherits the previous row's foreground, background, or text
+    attributes. Keep one decoder alive for the ordered capture, but clear its
+    one-row cell buffer between rows. :func:`render_rows` then makes every
+    result independently paintable for the local history overlay.
+    """
     screen = pyte.Screen(width, 1)
     stream = pyte.ByteStream(screen)
-    stream.feed(line)
-    return render_rows(screen)[0]
+    rendered: list[bytes] = []
+    for line in lines:
+        screen.buffer[0].clear()
+        screen.cursor.x = 0
+        screen.cursor.y = 0
+        stream.feed(line)
+        rendered.append(render_rows(screen)[0])
+    return tuple(rendered)
+
+
+def _render_history_line(pyte: object, line: bytes, width: int) -> bytes:
+    """Render one self-contained physical row with allowlisted SGR styling."""
+    return _render_history_lines(pyte, (line,), width)[0]
 
 
 def _read_transcript_tail(fd: int) -> tuple[str, bool]:
@@ -1352,7 +1375,8 @@ def _capture_pane_history(
     # Retain the newest suffix when the styled representation reaches its byte
     # budget. Iterate backwards so an oversized response never sacrifices the
     # pane's current viewport merely to retain older scrollback.
-    current_raw = raw_lines[-pane.height :]
+    rendered_raw = _render_history_lines(pyte, raw_lines, pane.width)
+    current_raw = rendered_raw[-pane.height :]
     transcript_entry = None
     # ``None`` is retained only for old/test geometry that predates the
     # provider field; every validated live marker carries an explicit value.
@@ -1383,21 +1407,14 @@ def _capture_pane_history(
         transcript_lines = transcript_entry.rows
         history_count = max(0, max_lines - pane.height)
         source_lines = (
-            tuple((line, True) for line in transcript_lines[-history_count:])
-            if history_count
-            else ()
-        ) + tuple((line, False) for line in current_raw)
+            transcript_lines[-history_count:] if history_count else ()
+        ) + current_raw
     else:
-        source_lines = tuple((line, False) for line in raw_lines)
+        source_lines = rendered_raw
     newest_first: list[bytes] = []
     packed_size = 2  # history line-count prefix
     budget_truncated = False
-    for raw_line, rendered_already in reversed(source_lines[-max_lines:]):
-        rendered = (
-            raw_line
-            if rendered_already
-            else _render_history_line(pyte, raw_line, pane.width)
-        )
+    for rendered in reversed(source_lines[-max_lines:]):
         line_size = 4 + len(rendered)
         if packed_size + line_size > _HISTORY_SNAPSHOT_RAW_BUDGET:
             budget_truncated = True

{railmux-0.4.0.dev18 → railmux-0.4.0.dev20}/src/railmux/tmux_ctl.py

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 import os
 import re
-import signal
 import shlex
 import shutil
 import subprocess
@@ -1849,7 +1848,13 @@ RAILMUX_HISTORY_GENERATION_OPTION = "@railmux_history_generation_v1"
 # A confirmed branch transition prefixes the opaque SSH history cache epoch.
 # Plain generations use native pane history; only this explicit marker permits
 # the canonical transcript fallback that removes an abandoned rewind suffix.
-RAILMUX_CANONICAL_HISTORY_PREFIX = "canonical:"
+# Only the evidence-gated v2 marker authorizes transcript-backed Codex
+# scrolling.  The released v1 marker treated every live direct child rollout
+# as a rewind, but Codex can also create that shape while bootstrapping an
+# ordinary resume.  Keeping the prefix versioned makes existing over-broad
+# markers fail back to raw pane history on upgrade.
+RAILMUX_CANONICAL_HISTORY_PREFIX = "canonical-v2:"
+RAILMUX_LEGACY_CANONICAL_HISTORY_PREFIX = "canonical:"
 # tmux names function keys only through F12. Private restore routes use
 # canonical xterm sequences in literal mode, so they cannot be confused with
 # user input forwarded to an agent pane.
@@ -3432,45 +3437,6 @@ def exact_pane_alive(identity: PaneIdentity) -> bool:
     )
 
 
-def reset_pane_view(identity: PaneIdentity) -> bool:
-    """Reset visible terminal state without deleting retained scrollback.
-
-    Revalidate the immutable session, pane process, and window before issuing
-    tmux's terminal reset. Then send the pane's foreground process group an
-    ordinary same-size ``SIGWINCH`` so its TUI repaints and reasserts terminal
-    modes without a geometry change or injected keyboard input. The reset can
-    push the old viewport into tmux history, but never destroys the retained
-    prefix; managed history surfaces use the provider's canonical transcript.
-    """
-    current = pane_identity(identity.pane_id)
-    if (current is None or current.dead
-            or current.pane_pid != identity.pane_pid
-            or current.session_id != identity.session_id
-            or current.window_id != identity.window_id):
-        return False
-    try:
-        subprocess.check_call(
-            ["tmux", "send-keys", "-R", "-t", identity.pane_id],
-            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
-        )
-    except (OSError, subprocess.CalledProcessError):
-        return False
-
-    current = pane_identity(identity.pane_id)
-    if (current is None or current.dead
-            or current.pane_pid != identity.pane_pid
-            or current.session_id != identity.session_id
-            or current.window_id != identity.window_id):
-        return True
-    try:
-        os.killpg(os.getpgid(current.pane_pid), signal.SIGWINCH)
-    except (OSError, ValueError):
-        # The presentation cache is already clean. A provider that exited or
-        # cannot be signalled will repaint on its next ordinary terminal write.
-        pass
-    return True
-
-
 def kill_session_identity(identity: PaneIdentity) -> bool:
     """Kill an exact immutable tmux session, never a reused session name."""
     current = pane_identity(identity.pane_id)