railmux 0.3.3.dev3__tar.gz → 0.3.3.dev4__tar.gz

{railmux-0.3.3.dev3/src/railmux.egg-info → railmux-0.3.3.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.3.3.dev3
+Version: 0.3.3.dev4
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -373,7 +373,9 @@ messages, tool calls, and abbreviated tool output are colour-coded, while
 internal context and encrypted reasoning are hidden. Codex rewind lineages and
 Claude Code `parentUuid` branches are projected onto the provider's current
 conversation: the retained prefix and replacement suffix remain visible, while
-the abandoned suffix is hidden.
+the abandoned suffix is hidden. When Railmux observes a running Codex session
+advance to its rewind child, it also removes the abandoned terminal screen and
+tmux scrollback before Codex redraws the live pane.
 
 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

{railmux-0.3.3.dev3 → railmux-0.3.3.dev4}/README.md

@@ -331,7 +331,9 @@ messages, tool calls, and abbreviated tool output are colour-coded, while
 internal context and encrypted reasoning are hidden. Codex rewind lineages and
 Claude Code `parentUuid` branches are projected onto the provider's current
 conversation: the retained prefix and replacement suffix remain visible, while
-the abandoned suffix is hidden.
+the abandoned suffix is hidden. When Railmux observes a running Codex session
+advance to its rewind child, it also removes the abandoned terminal screen and
+tmux scrollback before Codex redraws the live pane.
 
 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

railmux-0.3.3.dev4/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.3.dev4"

{railmux-0.3.3.dev3 → railmux-0.3.3.dev4}/src/railmux/fast_display_client.py

@@ -1074,7 +1074,7 @@ class TerminalSurface:
         self,
         requested: TerminalMode,
     ) -> TerminalMode:
-        """Mirror only input-affecting modes explicitly carried by protocol v14."""
+        """Mirror only input-affecting modes explicitly carried by protocol v15."""
         disabled = self.terminal_modes & ~requested
         enabled = requested & ~self.terminal_modes
         controls: list[bytes] = []
@@ -2013,7 +2013,7 @@ def _finish_remote_attach(
         raise ProbeError("remote display helper failed before attaching")
 
     _stop_unstarted_remote(process)
-    # A current v14 helper holds the mutex only while registering its exact tmux
+    # A current v15 helper holds the mutex only while registering its exact tmux
     # child. Give that ordinary race one fresh SSH process before presenting
     # the explicit legacy-lock takeover choice.
     time.sleep(_REMOTE_ATTACH_RETRY_DELAY)

{railmux-0.3.3.dev3 → railmux-0.3.3.dev4}/src/railmux/fast_display_history.py

@@ -207,7 +207,11 @@ class LocalHistoryView:
         restore_live = False
         for pane_id, viewport in tuple(self.viewports.items()):
             route = routes.get(pane_id)
-            if route is None or not self._same_geometry(viewport.snapshot, route):
+            if (
+                route is None
+                or not self._same_geometry(viewport.snapshot, route)
+                or not self._history_source_matches(viewport.snapshot, route)
+            ):
                 self.cancel_pane(pane_id)
                 restore_live = True
         return HistoryAction(restore_live=restore_live)
@@ -217,10 +221,11 @@ class LocalHistoryView:
         left: HistorySnapshot,
         right: HistorySnapshot,
     ) -> bool:
-        """Do not combine native, transcript, and undecided history."""
+        """Do not combine different providers or terminal generations."""
         return (
             left.transcript_backed == right.transcript_backed
             and left.history_choice_required == right.history_choice_required
+            and left.generation == right.generation
         )
 
     @staticmethod
@@ -813,7 +818,11 @@ class LocalHistoryView:
             ),
             None,
         )
-        if route is None or not self._same_geometry(route, snapshot):
+        if (
+            route is None
+            or not self._same_geometry(route, snapshot)
+            or not self._history_source_matches(route, snapshot)
+        ):
             return HistoryAction()
         viewport = self.viewports.get(pending.pane_id)
         if viewport is None:

{railmux-0.3.3.dev3 → railmux-0.3.3.dev4}/src/railmux/fast_display_protocol.py

@@ -1,4 +1,4 @@
-"""Private v14 framing for the coalesced full-window SSH display."""
+"""Private v15 framing for the coalesced full-window SSH display."""
 
 from __future__ import annotations
 
@@ -8,9 +8,9 @@ from dataclasses import dataclass
 from enum import IntEnum, IntFlag
 
 
-DISPLAY_MAGIC = b"RMUXD14\x00"
-INPUT_MAGIC = b"RMUXK14\x00"
-PROTOCOL_VERSION = 14
+DISPLAY_MAGIC = b"RMUXD15\x00"
+INPUT_MAGIC = b"RMUXK15\x00"
+PROTOCOL_VERSION = 15
 REMOTE_CONFIG_PROTOCOL = 1
 LENGTH_BYTES = 4
 REMOTE_HELLO_PREFIX = b"RAILMUX-REMOTE/1 "
@@ -28,10 +28,10 @@ MAX_HISTORY_PANES = 8
 MAX_CLIPBOARD_BYTES = 64 * 1024
 MAX_PATH_BYTES = 4096
 _UPDATE_METADATA = struct.Struct(">BIHHHHBHI")
-_HISTORY_METADATA = struct.Struct(">IIHHHHBI")
+_HISTORY_METADATA = struct.Struct(">IIHHHHBQI")
 _HISTORY_REQUEST = struct.Struct(">IHHH")
 _HISTORY_BATCH_METADATA = struct.Struct(">II")
-_HISTORY_PANE_METADATA = struct.Struct(">IHHHHB")
+_HISTORY_PANE_METADATA = struct.Struct(">IHHHHBQ")
 _PREFETCH_HISTORY_REQUEST = struct.Struct(">IH")
 _PATH_REQUEST = struct.Struct(">IIH")
 _PATH_RESULT = struct.Struct(">IBBH")
@@ -143,6 +143,7 @@ class HistorySnapshot:
     more_available: bool = False
     transcript_available: bool = False
     history_choice_required: bool = False
+    generation: int = 0
 
 
 @dataclass(frozen=True)
@@ -302,6 +303,7 @@ def encode_history_snapshot(snapshot: HistorySnapshot) -> bytes:
             snapshot.more_available,
             snapshot.transcript_available,
             snapshot.history_choice_required,
+            snapshot.generation,
         )):
             raise ValueError("a rejected history response must be empty")
         pane_number = 0
@@ -317,6 +319,8 @@ def encode_history_snapshot(snapshot: HistorySnapshot) -> bytes:
             raise ValueError("invalid history position")
         if len(snapshot.lines) < snapshot.height:
             raise ValueError("history snapshot is shorter than its viewport")
+        if not 0 <= snapshot.generation <= 0xFFFFFFFFFFFFFFFF:
+            raise ValueError("invalid history generation")
     raw_lines = _pack_history_lines(snapshot.lines)
     compressed = zlib.compress(raw_lines, level=3)
     metadata = _HISTORY_METADATA.pack(
@@ -327,6 +331,7 @@ def encode_history_snapshot(snapshot: HistorySnapshot) -> bytes:
         snapshot.width,
         snapshot.height,
         _history_capabilities(snapshot),
+        snapshot.generation,
         len(raw_lines),
     )
     payload = bytes((int(OutputKind.HISTORY),)) + metadata + compressed
@@ -360,6 +365,8 @@ def encode_history_batch(batch: HistoryBatch) -> bytes:
             raise ValueError("invalid history position")
         if len(snapshot.lines) < snapshot.height:
             raise ValueError("history snapshot is shorter than its viewport")
+        if not 0 <= snapshot.generation <= 0xFFFFFFFFFFFFFFFF:
+            raise ValueError("invalid history generation")
         packed_lines = _pack_history_lines(snapshot.lines)
         pane_metadata = _HISTORY_PANE_METADATA.pack(
             pane_number,
@@ -368,6 +375,7 @@ def encode_history_batch(batch: HistoryBatch) -> bytes:
             snapshot.width,
             snapshot.height,
             _history_capabilities(snapshot),
+            snapshot.generation,
         )
         total += len(pane_metadata) + len(packed_lines)
         if total > MAX_SCREEN_BYTES:
@@ -611,6 +619,7 @@ class ServerMessageDecoder:
                         width,
                         height,
                         raw_capabilities,
+                        generation,
                         raw_size,
                     ) = (
                         _HISTORY_METADATA.unpack(body[:_HISTORY_METADATA.size])
@@ -628,6 +637,7 @@ class ServerMessageDecoder:
                             height,
                             lines,
                             raw_capabilities,
+                            generation,
                         )):
                             raise ValueError("invalid rejected history response")
                         pane_id = None
@@ -662,6 +672,7 @@ class ServerMessageDecoder:
                         history_choice_required=bool(
                             raw_capabilities & _HISTORY_CHOICE_REQUIRED
                         ),
+                        generation=generation,
                     ))
                     continue
                 if output_kind is OutputKind.HISTORY_BATCH:
@@ -691,6 +702,7 @@ class ServerMessageDecoder:
                             width,
                             height,
                             raw_capabilities,
+                            generation,
                         ) = _HISTORY_PANE_METADATA.unpack(
                             raw[offset:offset + _HISTORY_PANE_METADATA.size]
                         )
@@ -729,6 +741,7 @@ class ServerMessageDecoder:
                             history_choice_required=bool(
                                 raw_capabilities & _HISTORY_CHOICE_REQUIRED
                             ),
+                            generation=generation,
                         ))
                     if offset != len(raw):
                         raise ValueError("trailing history batch data")
@@ -843,7 +856,7 @@ class ServerMessageDecoder:
 
 
 class ScreenUpdateDecoder:
-    """Compatibility view which ignores v14 control-response messages."""
+    """Compatibility view which ignores v15 control-response messages."""
 
     def __init__(self) -> None:
         self._decoder = ServerMessageDecoder()

{railmux-0.3.3.dev3 → railmux-0.3.3.dev4}/src/railmux/fast_display_server.py

@@ -45,6 +45,7 @@ from railmux import (
     __version__,
     local_open,
     restart_state,
+    tmux_ctl,
     tmux_health,
     tmux_server,
 )
@@ -403,6 +404,7 @@ class _PaneGeometry:
     transcript_source: str | None = None
     transcript_backed: bool = False
     claude_history_policy: str = "ask"
+    history_generation: int = 0
 
 
 @dataclass(frozen=True)
@@ -421,6 +423,24 @@ _INFERRED_TRANSCRIPT_LIMIT = 8
 _TRANSCRIPT_MAX_BYTES = 32 * 1024 * 1024
 _SESSION_BINDING_OPTION = "@railmux_binding_v1"
 _SWAP_OPTIONS = ("@railmux_swap_primary", "@railmux_swap_secondary")
+_HISTORY_GENERATION_RE = re.compile(
+    r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-"
+    r"[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+)
+
+
+def _history_generation(marker: str) -> int:
+    """Map one validated provider UUID to a bounded opaque wire epoch."""
+    if not _HISTORY_GENERATION_RE.fullmatch(marker):
+        return 0
+    return int.from_bytes(
+        hashlib.blake2b(
+            marker.lower().encode("ascii"),
+            digest_size=8,
+            person=b"railmux-history",
+        ).digest(),
+        "big",
+    )
 
 
 _ANSI_FG = {
@@ -834,6 +854,7 @@ def _list_agent_panes(
                 "#{history_size} #{alternate_on} #{mouse_any_flag} "
                 f"#{{{tmux_server.HISTORY_SOURCE_OPTION}}} "
                 f"#{{{tmux_server.TRANSCRIPT_SOURCE_OPTION}}} "
+                f"#{{{tmux_ctl.RAILMUX_HISTORY_GENERATION_OPTION}}} "
                 f"#{{{TOOL_PANE_OPTION}}}",
             ),
             stderr=subprocess.DEVNULL,
@@ -849,7 +870,7 @@ def _list_agent_panes(
     for raw_row in output.splitlines():
         fields = raw_row.split(" ")
         if (
-            len(fields) != 16
+            len(fields) != 17
             or fields[0] != session_id
             or fields[2] not in ("0", "1")
             or fields[3] not in ("0", "1")
@@ -880,7 +901,7 @@ def _list_agent_panes(
         ):
             return ()
         seen.add(pane_id)
-        if is_tool_pane_marker(fields[15], outer_session_id=session_id):
+        if is_tool_pane_marker(fields[16], outer_session_id=session_id):
             continue
         history_server = None
         history_pane_id = None
@@ -931,6 +952,7 @@ def _list_agent_panes(
                     transcript_source=transcript_marker,
                     transcript_backed=transcript_backed,
                     claude_history_policy=claude_history_policy,
+                    history_generation=_history_generation(fields[15]),
                 ),
             )
         )
@@ -1376,6 +1398,7 @@ def _capture_pane_history(
                 else pane.history_size + pane.height > len(lines)
             )
         ),
+        generation=pane.history_generation,
     )
 
 
@@ -1916,7 +1939,7 @@ def render_rows(screen: object) -> tuple[bytes, ...]:
 
 
 def terminal_modes_for_screen(screen: object) -> TerminalMode:
-    """Project pyte's private-mode set onto the bounded v14 wire allowlist."""
+    """Project pyte's private-mode set onto the bounded v15 wire allowlist."""
     terminal_modes = TerminalMode.NONE
     if 2004 << 5 in screen.mode:
         terminal_modes |= TerminalMode.BRACKETED_PASTE

{railmux-0.3.3.dev3 → railmux-0.3.3.dev4}/src/railmux/tmux_ctl.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import os
 import re
+import signal
 import shlex
 import shutil
 import subprocess
@@ -302,6 +303,12 @@ _ROLLOUT_UUID_RE = re.compile(
 )
 
 
+def rollout_uuid_from_path(path: Path) -> str | None:
+    """Return the filename UUID for a canonical Codex rollout path."""
+    match = _ROLLOUT_UUID_RE.search(path.name)
+    return match.group(1) if match is not None else None
+
+
 def pane_pid_for_session(session_name: str) -> int | None:
     """Return the first pane's PID for *session_name*, or None.
 
@@ -1818,6 +1825,7 @@ _PREFIX_TARGET_MARKER = "railmux-target-toggle-v1"
 RAILMUX_CONTROLLER_OPTION = "@railmux_controller_pane"
 RAILMUX_TARGET_OPTION = "@railmux_target_pane"
 RAILMUX_HISTORY_PREVIEW_OPTION = "@railmux_history_preview_v1"
+RAILMUX_HISTORY_GENERATION_OPTION = "@railmux_history_generation_v1"
 # tmux names function keys only through F12. Private controller routes use
 # canonical xterm sequences in literal mode, so they cannot be confused with
 # user input forwarded to an agent pane.
@@ -3347,6 +3355,47 @@ def exact_pane_alive(identity: PaneIdentity) -> bool:
     )
 
 
+def reset_pane_history(identity: PaneIdentity) -> bool:
+    """Reset visible bytes and scrollback for the exact observed live pane.
+
+    Revalidate the immutable session, pane process, and window before issuing
+    one tmux command queue that resets the terminal model and clears history.
+    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.
+    """
+    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,
+                ";", "clear-history", "-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)

{railmux-0.3.3.dev3 → railmux-0.3.3.dev4}/src/railmux/ui/app.py

@@ -365,6 +365,12 @@ class _Running:
     legacy_server: tmux_server.TmuxServerTarget | None = None
     legacy_session_id: str | None = None
     provider_session_id: str | None = None
+    # Last canonical Codex rollout observed for this live pane.  Rewind creates
+    # a child rollout while leaving tmux's byte scrollback intact; tracking the
+    # provider generation lets the refresh path discard only that stale
+    # presentation cache when the exact live writer advances to its child.
+    codex_canonical_session_id: str | None = None
+    codex_history_generation_stamped: bool = False
 
     @property
     def is_placeholder(self) -> bool:
@@ -8530,6 +8536,9 @@ class App:
                 meta = self._session_cache.get(
                     r.project, r.logical_session_id or r.key)
             if meta is not None:
+                if session_type == "codex":
+                    self._sync_codex_rewind_scrollback(
+                        r, meta, server, codex_rollout_probes)
                 if meta.title:
                     r.label = f"{meta.project.display_name}/{meta.display_title}"
                 r.status = self._effective_status(
@@ -8548,6 +8557,86 @@ class App:
         self._maybe_resort_running()
         self._render_running_pane()
 
+    def _sync_codex_rewind_scrollback(
+        self,
+        running: _Running,
+        meta: SessionMeta,
+        server: tmux_ctl.ServerSnapshot | None,
+        codex_rollout_probes: dict[str, set[str] | None] | None,
+    ) -> None:
+        """Drop stale tmux bytes after an exact live Codex rewind transition.
+
+        The provider rollout is the history authority, but Codex keeps using
+        the same terminal pane after a rewind.  Its abandoned suffix can
+        therefore survive in tmux scrollback even though the canonical JSONL
+        is already correct.  Baseline the first observed rollout, then clear
+        only when the next canonical rollout names that baseline as its parent.
+        On procfs systems the new rollout must also be open in this exact pane's
+        process tree; an unavailable probe degrades to the provider lineage
+        link, while a negative probe waits for a later refresh.
+        """
+        current_id = meta.session_id
+        previous_id = running.codex_canonical_session_id
+        if previous_id is None:
+            running.codex_canonical_session_id = current_id
+            self._stamp_codex_history_generation(running, current_id)
+            return
+        if current_id == previous_id:
+            if not running.codex_history_generation_stamped:
+                self._stamp_codex_history_generation(running, current_id)
+            return
+        if (running.is_legacy or meta.forked_from_id != previous_id
+                or current_id not in self._codex_lineage_ids(previous_id)):
+            return
+
+        rollout_id = tmux_ctl.rollout_uuid_from_path(meta.jsonl_path)
+        if rollout_id != current_id:
+            return
+        probes = codex_rollout_probes if codex_rollout_probes is not None else {}
+        if running.tmux_name in probes:
+            open_ids = probes[running.tmux_name]
+        else:
+            open_ids = self._codex_rollout_ids(running, server)
+            probes[running.tmux_name] = open_ids
+        if open_ids is not None and current_id not in open_ids:
+            return
+
+        identity = self._codex_real_pane_identity(running)
+        if identity is None or not tmux_ctl.reset_pane_history(identity):
+            return
+        running.codex_canonical_session_id = current_id
+        running.codex_history_generation_stamped = tmux_ctl.set_pane_user_option(
+            identity.pane_id,
+            tmux_ctl.RAILMUX_HISTORY_GENERATION_OPTION,
+            current_id,
+        )
+
+    def _codex_real_pane_identity(
+        self, running: _Running,
+    ) -> tmux_ctl.PaneIdentity | None:
+        """Resolve a Codex pane across its detached home or swap location."""
+        real_pane = self._display_transport().displayed_real_pane(
+            running.tmux_name)
+        if real_pane is not None:
+            return tmux_ctl.pane_identity(real_pane)
+        topology = tmux_ctl.session_topology(running.tmux_name)
+        return topology.single_live_pane if topology is not None else None
+
+    def _stamp_codex_history_generation(
+        self, running: _Running, session_id: str,
+    ) -> None:
+        """Publish a content-free epoch for full-window SSH history caches."""
+        if running.is_legacy:
+            return
+        identity = self._codex_real_pane_identity(running)
+        if identity is None:
+            return
+        running.codex_history_generation_stamped = tmux_ctl.set_pane_user_option(
+            identity.pane_id,
+            tmux_ctl.RAILMUX_HISTORY_GENERATION_OPTION,
+            session_id,
+        )
+
     def _maybe_resort_running(self) -> None:
         """Re-order the Running registry by recency, at most once per minute.
 

{railmux-0.3.3.dev3 → railmux-0.3.3.dev4/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.3.3.dev3
+Version: 0.3.3.dev4
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -373,7 +373,9 @@ messages, tool calls, and abbreviated tool output are colour-coded, while
 internal context and encrypted reasoning are hidden. Codex rewind lineages and
 Claude Code `parentUuid` branches are projected onto the provider's current
 conversation: the retained prefix and replacement suffix remain visible, while
-the abandoned suffix is hidden.
+the abandoned suffix is hidden. When Railmux observes a running Codex session
+advance to its rewind child, it also removes the abandoned terminal screen and
+tmux scrollback before Codex redraws the live pane.
 
 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

railmux-0.3.3.dev4/tests/test_codex_lineage.py

@@ -0,0 +1,157 @@
+"""App-level identity tests for Codex rewind/fork lineages."""
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from railmux import tmux_ctl
+from railmux.favorites import Favorites
+from railmux.models import Project, SessionMeta
+from railmux.ui.app import App, _Running
+
+
+class _LineageIndex:
+    def lineage_ids(self, session_id: str, *, refresh: bool = True):
+        if session_id in {"root", "middle", "leaf"}:
+            return frozenset({"root", "middle", "leaf"})
+        return frozenset()
+
+
+def _app_with_running_root() -> tuple[App, _Running]:
+    app = App.__new__(App)
+    project = Project(Path("/project"), "-project", Path(), 1, 0.0)
+    running = _Running(
+        key="root",
+        tmux_name="cx-root",
+        label="project/conversation",
+        project=project,
+        session_type="codex",
+    )
+    app._running = {"root": running}
+    app._codex_index = _LineageIndex()
+    return app, running
+
+
+def test_codex_fork_uuid_resolves_to_existing_running_owner() -> None:
+    app, running = _app_with_running_root()
+
+    assert app._by_session_id("leaf") is running
+    assert app._by_session_id("middle") is running
+    assert app._by_session_id("unrelated") is None
+
+
+def test_running_ids_include_every_codex_lineage_alias() -> None:
+    app, _ = _app_with_running_root()
+
+    assert app._running_session_ids() == {"root", "middle", "leaf"}
+
+
+def test_live_writer_matches_any_rewind_alias() -> None:
+    app, _ = _app_with_running_root()
+
+    assert app._codex_writer_matches("root", {"leaf"})
+    assert not app._codex_writer_matches("root", {"unrelated"})
+
+
+def test_existing_root_favorite_marks_visible_leaf(
+    tmp_path, monkeypatch,
+) -> None:
+    favorites_path = tmp_path / "favorites.json"
+    monkeypatch.setattr(
+        "railmux.favorites._favorites_path", lambda: favorites_path)
+    app, _ = _app_with_running_root()
+    app._favorites = Favorites()
+    app._favorites.set_many({"root"}, True)
+
+    assert app._favorite_ids_for_view() == {"root", "middle", "leaf"}
+
+
+def test_live_rewind_clears_only_exact_new_rollout_scrollback(
+    monkeypatch, tmp_path,
+) -> None:
+    root_id = "019fc605-5188-7212-bc48-ea023fe8b73c"
+    leaf_id = "019fc7c1-a27c-7ae0-9937-7570552a112a"
+    project = Project(tmp_path, "-project", Path(), 1, 0.0)
+    running = _Running(
+        key=root_id,
+        tmux_name="cx-live",
+        label="project/conversation",
+        project=project,
+        session_type="codex",
+        codex_canonical_session_id=root_id,
+    )
+    meta = SessionMeta(
+        project=project,
+        session_id=leaf_id,
+        jsonl_path=tmp_path / (
+            f"rollout-2026-08-03T13-13-03-{leaf_id}.jsonl"),
+        title="current",
+        message_count=2,
+        token_total=0,
+        last_mtime=2.0,
+        session_type="codex",
+        forked_from_id=root_id,
+    )
+    identity = tmux_ctl.PaneIdentity(
+        "%9", 123, "railmux", "$4", "@5", False, 80, 24)
+    app = App.__new__(App)
+    app._codex_lineage_ids = MagicMock(return_value={root_id, leaf_id})
+    app._codex_rollout_ids = MagicMock(return_value={root_id})
+    transport = MagicMock()
+    transport.displayed_real_pane.return_value = "%9"
+    app._display_transport = MagicMock(return_value=transport)
+    monkeypatch.setattr(tmux_ctl, "pane_identity", lambda _pane: identity)
+    cleared = MagicMock(return_value=True)
+    monkeypatch.setattr(tmux_ctl, "reset_pane_history", cleared)
+    stamped = MagicMock(return_value=True)
+    monkeypatch.setattr(tmux_ctl, "set_pane_user_option", stamped)
+    probes: dict[str, set[str] | None] = {}
+
+    # An indexed child is not enough: on procfs the exact live writer must
+    # first expose that rollout through its open file descriptors.
+    app._sync_codex_rewind_scrollback(running, meta, None, probes)
+    cleared.assert_not_called()
+    assert running.codex_canonical_session_id == root_id
+
+    probes.clear()
+    app._codex_rollout_ids.return_value = {root_id, leaf_id}
+    app._sync_codex_rewind_scrollback(running, meta, None, probes)
+
+    cleared.assert_called_once_with(identity)
+    assert running.codex_canonical_session_id == leaf_id
+    stamped.assert_called_once_with(
+        "%9", tmux_ctl.RAILMUX_HISTORY_GENERATION_OPTION, leaf_id)
+
+
+def test_first_codex_generation_only_establishes_scrollback_baseline(
+    monkeypatch, tmp_path,
+) -> None:
+    session_id = "019fc605-5188-7212-bc48-ea023fe8b73c"
+    project = Project(tmp_path, "-project", Path(), 1, 0.0)
+    running = _Running(
+        key=session_id,
+        tmux_name="cx-live",
+        label="project/conversation",
+        project=project,
+        session_type="codex",
+    )
+    meta = SessionMeta(
+        project=project,
+        session_id=session_id,
+        jsonl_path=tmp_path / (
+            f"rollout-2026-08-03T13-09-08-{session_id}.jsonl"),
+        title="root",
+        message_count=1,
+        token_total=0,
+        last_mtime=1.0,
+        session_type="codex",
+    )
+    app = App.__new__(App)
+    app._stamp_codex_history_generation = MagicMock()
+    cleared = MagicMock(return_value=True)
+    monkeypatch.setattr(tmux_ctl, "reset_pane_history", cleared)
+
+    app._sync_codex_rewind_scrollback(running, meta, None, {})
+
+    assert running.codex_canonical_session_id == session_id
+    cleared.assert_not_called()