railmux 0.3.6.dev1__tar.gz → 0.3.6.dev2__tar.gz

{railmux-0.3.6.dev1/src/railmux.egg-info → railmux-0.3.6.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.3.6.dev1
+Version: 0.3.6.dev2
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -383,10 +383,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
@@ -445,7 +444,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.3.6.dev1 → railmux-0.3.6.dev2}/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.3.6.dev2/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.6.dev2"

{railmux-0.3.6.dev1 → railmux-0.3.6.dev2}/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:
@@ -353,6 +357,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 +483,29 @@ 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 < target_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
+            # Keep the live pane intact until one internally contiguous deep
+            # capture arrives. Entering history atomically from that response
+            # removes the hot/deep seam and needs no moving-live anchor.
+            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 +516,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,7 +525,6 @@ 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),
@@ -602,6 +613,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 +878,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)

{railmux-0.3.6.dev1 → railmux-0.3.6.dev2}/src/railmux/tmux_binding_manager.py

@@ -502,7 +502,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"])
@@ -514,6 +513,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()
@@ -662,13 +665,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.3.6.dev1 → railmux-0.3.6.dev2}/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
@@ -1840,7 +1839,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.
@@ -3330,45 +3335,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)