railmux 0.3.3.dev2__tar.gz → 0.3.3.dev3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.3.3.dev2
+Version: 0.3.3.dev3
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -169,12 +169,14 @@ for focus and layout limits.
 |--------|--------|
 | Left-click (non-running) | Preview session history in the Target pane |
 | Left-click (running) | Switch the Target pane to that session |
+| Wheel up over a live agent | Open its canonical current-branch history |
 | Double-click | Open/attach in the Target pane and move focus there |
 | Right-click | Context menu (Open, Preview, Info, Rename, Star, Copy title, Kill, Term, Delete) |
 
 Unavailable context-menu actions are hidden for the selected session state.
-Single-click and `␣` act in the Target pane without moving keyboard focus;
-double-click and `Enter` also move focus there. The terminal must report mouse
+Single-click and `␣` act in the Target pane without moving keyboard focus, but
+`␣` always means history while a click on a running row means live attach.
+Double-click and `Enter` also move focus there. The terminal must report mouse
 buttons to applications for these actions to reach Railmux. Right-click
 reporting is sometimes a separate setting from ordinary mouse reporting; see
 [FAQ 2](#2-mouse-buttons-or-f8f9-dont-work--whats-wrong).
@@ -207,7 +209,7 @@ see [FAQ 1](#1-how-do-i-copy-text-from-the-agent-pane).
 | `T` | Return to that agent's managed Vim viewer, when open |
 | `m` | Switch agent mode (Claude Code ⇄ Codex) |
 | `o` | Open persistent Railmux options |
-| `␣` | Preview stopped or switch running target (like single-click) |
+| `␣` | Preview canonical history for the selected stopped or running session |
 | `F8` | Cycle agent layout: single → side-by-side → stacked |
 | `F9` | Fullscreen the focused agent, managed terminal, or Vim (toggle) |
 | `?` | Full help popup with all keybindings |
@@ -299,7 +301,8 @@ to single leaves Pane 2's agent running in the background.
 
 In a split, focus an agent pane to make it the Target pane. After focus returns
 to the sidebar, single-click or `␣` acts in that pane without moving keyboard
-focus; double-click or `Enter` opens there and transfers focus. The status bar
+focus; a running-row click attaches live while `␣` previews history.
+Double-click or `Enter` opens there and transfers focus. The status bar
 at the bottom-left shows the current layout and Target pane:
 
 | Symbol | Meaning |
@@ -363,15 +366,20 @@ sessions move ahead of the other results.
 ## History preview
 
 For a stopped session, left-click or press `␣` to view conversation history in
-the Target pane without starting or resuming the agent. Preview is read-only: it
-cannot send a message or change the session. User and assistant messages, tool
-calls, and abbreviated tool output are colour-coded, while internal context and
-encrypted reasoning are hidden.
+the Target pane without starting or resuming the agent. For a running session,
+press `␣`, choose **Preview**, or wheel up over its live pane. Preview is
+read-only: it cannot send a message or change the session. User and assistant
+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.
 
 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
-matches, and `q` to exit and restore the pane. Double-click to skip preview and
-open the session directly.
+matches, and `q` to exit. If preview began from a live pane, `q` restores that
+exact session; otherwise it restores the prior Target pane. Double-click to
+skip preview and open the session directly.
 
 ## Status indicators
 

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

@@ -127,12 +127,14 @@ for focus and layout limits.
 |--------|--------|
 | Left-click (non-running) | Preview session history in the Target pane |
 | Left-click (running) | Switch the Target pane to that session |
+| Wheel up over a live agent | Open its canonical current-branch history |
 | Double-click | Open/attach in the Target pane and move focus there |
 | Right-click | Context menu (Open, Preview, Info, Rename, Star, Copy title, Kill, Term, Delete) |
 
 Unavailable context-menu actions are hidden for the selected session state.
-Single-click and `␣` act in the Target pane without moving keyboard focus;
-double-click and `Enter` also move focus there. The terminal must report mouse
+Single-click and `␣` act in the Target pane without moving keyboard focus, but
+`␣` always means history while a click on a running row means live attach.
+Double-click and `Enter` also move focus there. The terminal must report mouse
 buttons to applications for these actions to reach Railmux. Right-click
 reporting is sometimes a separate setting from ordinary mouse reporting; see
 [FAQ 2](#2-mouse-buttons-or-f8f9-dont-work--whats-wrong).
@@ -165,7 +167,7 @@ see [FAQ 1](#1-how-do-i-copy-text-from-the-agent-pane).
 | `T` | Return to that agent's managed Vim viewer, when open |
 | `m` | Switch agent mode (Claude Code ⇄ Codex) |
 | `o` | Open persistent Railmux options |
-| `␣` | Preview stopped or switch running target (like single-click) |
+| `␣` | Preview canonical history for the selected stopped or running session |
 | `F8` | Cycle agent layout: single → side-by-side → stacked |
 | `F9` | Fullscreen the focused agent, managed terminal, or Vim (toggle) |
 | `?` | Full help popup with all keybindings |
@@ -257,7 +259,8 @@ to single leaves Pane 2's agent running in the background.
 
 In a split, focus an agent pane to make it the Target pane. After focus returns
 to the sidebar, single-click or `␣` acts in that pane without moving keyboard
-focus; double-click or `Enter` opens there and transfers focus. The status bar
+focus; a running-row click attaches live while `␣` previews history.
+Double-click or `Enter` opens there and transfers focus. The status bar
 at the bottom-left shows the current layout and Target pane:
 
 | Symbol | Meaning |
@@ -321,15 +324,20 @@ sessions move ahead of the other results.
 ## History preview
 
 For a stopped session, left-click or press `␣` to view conversation history in
-the Target pane without starting or resuming the agent. Preview is read-only: it
-cannot send a message or change the session. User and assistant messages, tool
-calls, and abbreviated tool output are colour-coded, while internal context and
-encrypted reasoning are hidden.
+the Target pane without starting or resuming the agent. For a running session,
+press `␣`, choose **Preview**, or wheel up over its live pane. Preview is
+read-only: it cannot send a message or change the session. User and assistant
+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.
 
 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
-matches, and `q` to exit and restore the pane. Double-click to skip preview and
-open the session directly.
+matches, and `q` to exit. If preview began from a live pane, `q` restores that
+exact session; otherwise it restores the prior Target pane. Double-click to
+skip preview and open the session directly.
 
 ## Status indicators
 

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

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

{railmux-0.3.3.dev2 → railmux-0.3.3.dev3}/src/railmux/mouse_manager.py

@@ -157,6 +157,14 @@ class RootWheelForwardingManager:
                             state["backup"], token=token)
                         self._remove_state()
                         state = None
+                    elif not tmux_ctl.root_wheel_bindings_are_current(token):
+                        # The ownership transaction can survive a soft upgrade
+                        # in the same tmux pane. Refresh only an exactly-owned
+                        # wrapper so the new pane-local history route becomes
+                        # active without treating it as a user binding.
+                        if not tmux_ctl.set_root_wheel_forwarding(
+                                state["backup"], token):
+                            return False
                     if state is not None:
                         state["owners"] = sorted(
                             {*state["owners"], self._owner_pane_id})

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

@@ -1817,6 +1817,18 @@ _PREFIX_TARGET_KEY = "Tab"
 _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"
+# 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.
+RAILMUX_HISTORY_PREVIEW_KEYS = {
+    "primary": ("F21", "\x1b[35~"),
+    "secondary": ("F22", "\x1b[36~"),
+}
+RAILMUX_HISTORY_RESTORE_KEYS = {
+    "primary": ("F23", "\x1b[42~"),
+    "secondary": ("F24", "\x1b[43~"),
+}
 RAILMUX_SELECTION_KEY_OPTION = "@railmux_selection_key"
 RAILMUX_SELECTION_PEER_OPTION = "@railmux_selection_peer"
 RAILMUX_SELECTION_FROZEN_OPTION = "@railmux_selection_frozen_by"
@@ -2145,28 +2157,69 @@ def set_root_wheel_forwarding(
     backup: RootWheelBindingBackup,
     token: str,
 ) -> bool:
-    """Forward both wheel directions to mouse-aware pane applications.
+    """Open canonical live history on wheel-up, otherwise preserve tmux input.
 
     The literal marker makes crash recovery able to distinguish Railmux's
     wrapper from a binding the user installed while Railmux was running.
+    A pane-local primary/secondary marker routes the first live-agent wheel-up
+    to Railmux's controller; the transcript viewer clears that marker, so its
+    subsequent wheel events are forwarded normally.
     Non-mouse-aware panes retain the exact stock fallback; WheelDownPane was
     unbound by default and therefore has no false branch.
     """
     marker = f"{_ROOT_WHEEL_MARKER}-{token}"
-    condition = (
+    mouse_condition = (
         "#{&&:#{mouse_any_flag},"
         f"#{{==:{marker},{marker}}}}}"
     )
+    controller_present = f"#{{!=:#{{{RAILMUX_CONTROLLER_OPTION}}},}}"
+
+    def _preview_condition(slot_key: str) -> str:
+        return (
+            "#{&&:"
+            f"#{{==:#{{{RAILMUX_HISTORY_PREVIEW_OPTION}}},{slot_key}}},"
+            f"{controller_present}}}"
+        )
+
+    def _send_preview(slot_key: str) -> str:
+        _key, sequence = RAILMUX_HISTORY_PREVIEW_KEYS[slot_key]
+        return (
+            f"send-keys -l -t '#{{{RAILMUX_CONTROLLER_OPTION}}}' -- "
+            f"'{sequence}'"
+        )
+
     try:
         for key in _ROOT_WHEEL_KEYS:
+            binding = backup.get(key)
+            fallback = _binding_command(binding) if binding is not None else ""
+            mouse_fallback = (
+                f"if-shell -F -t = '{mouse_condition}' 'send-keys -M'"
+            )
+            if fallback:
+                mouse_fallback += f" '{fallback}'"
             args = [
                 "tmux", "bind-key", "-T", "root", key,
-                "if-shell", "-F", "-t", "=", condition,
-                "send-keys -M",
             ]
-            binding = backup.get(key)
-            if binding is not None:
-                args.append(_binding_command(binding))
+            if key == "WheelUpPane":
+                secondary_fallback = (
+                    "if-shell -F -t = "
+                    f"'{_preview_condition('secondary')}' "
+                    f"\"{_send_preview('secondary')}\" "
+                    f"\"{mouse_fallback}\""
+                )
+                args.extend([
+                    "if-shell", "-F", "-t", "=",
+                    _preview_condition("primary"),
+                    _send_preview("primary"),
+                    secondary_fallback,
+                ])
+            else:
+                args.extend([
+                    "if-shell", "-F", "-t", "=", mouse_condition,
+                    "send-keys -M",
+                ])
+                if fallback:
+                    args.append(fallback)
             subprocess.check_call(
                 args, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
     except (ValueError, subprocess.CalledProcessError, FileNotFoundError):
@@ -2186,6 +2239,28 @@ def root_wheel_bindings_owned_by(token: str) -> bool:
     )
 
 
+def root_wheel_bindings_are_current(token: str) -> bool:
+    """Whether the owned wrapper includes canonical-history routing."""
+    bindings = read_root_wheel_bindings()
+    up = bindings.get("WheelUpPane")
+    marker = f"{_ROOT_WHEEL_MARKER}-{token}"
+    return (
+        all(
+            binding is not None
+            and marker in binding
+            and "mouse_any_flag" in binding
+            and "send-keys -M" in binding
+            for binding in bindings.values()
+        )
+        and up is not None
+        and RAILMUX_HISTORY_PREVIEW_OPTION in up
+        and all(
+            sequence in up or sequence.replace("\x1b", r"\033") in up
+            for _key, sequence in RAILMUX_HISTORY_PREVIEW_KEYS.values()
+        )
+    )
+
+
 def root_wheel_binding_is_original_or_owned(
     key: str,
     binding: str | None,

{railmux-0.3.3.dev2 → railmux-0.3.3.dev3}/src/railmux/transcript.py

@@ -295,6 +295,81 @@ def _render_claude_native_tool_results(
         yield RESET
 
 
+def _claude_current_branch(records: list[dict]) -> list[dict]:
+    """Project an append-only Claude JSONL onto its current main branch.
+
+    Claude Code links semantic records with ``uuid`` / ``parentUuid``. Editing
+    or rewinding a prompt appends a second child instead of removing the old
+    suffix, so file order is not conversation order. The newest non-sidechain
+    UUID is the active tip; walking its parents retains the shared prefix and
+    the replacement suffix while excluding abandoned and sub-agent branches.
+
+    UUID-less metadata is retained for the normal renderer filters. If the
+    input is a bounded tail, walking stops safely at the first missing parent.
+    """
+    by_uuid: dict[str, dict] = {}
+    tip: str | None = None
+    for record in records:
+        uuid = record.get("uuid")
+        if not isinstance(uuid, str) or not uuid:
+            continue
+        by_uuid[uuid] = record
+        if record.get("isSidechain") is not True:
+            tip = uuid
+    if tip is None:
+        return records
+
+    current: set[str] = set()
+    cursor: str | None = tip
+    while cursor and cursor not in current:
+        record = by_uuid.get(cursor)
+        if record is None:
+            break
+        current.add(cursor)
+        parent = record.get("parentUuid")
+        cursor = parent if isinstance(parent, str) and parent else None
+
+    return [
+        record for record in records
+        if not isinstance(record.get("uuid"), str)
+        or not record.get("uuid")
+        or record["uuid"] in current
+    ]
+
+
+def _render_claude_records(
+    records: list[dict], *, claude_native: bool,
+):
+    """Render only the active Claude branch from buffered JSONL records."""
+    calls: dict[str, str] = {}
+    for record in _claude_current_branch(records):
+        rtype = record.get("type", "")
+        if rtype in _SKIP_TYPES:
+            continue
+        if _is_real_user(record):
+            rendered = (
+                _render_claude_native_user(record)
+                if claude_native
+                else _render_user(record)
+            )
+            if rendered:
+                yield rendered
+        if rtype == "user":
+            renderer = (
+                _render_claude_native_tool_results
+                if claude_native
+                else _render_claude_tool_results
+            )
+            yield from renderer(record, calls)
+        elif rtype == "assistant":
+            renderer = (
+                _render_claude_native_assistant
+                if claude_native
+                else _render_assistant_blocks
+            )
+            yield from renderer(record, calls)
+
+
 def format_transcript(
     source: Path | object,
     fmt: str | None = None,
@@ -326,7 +401,10 @@ def format_transcript(
     # call_id -> tool name, so Codex tool outputs can be labelled with the
     # call that produced them (issue #3).
     codex_calls: dict[str, str] = {}
-    claude_calls: dict[str, str] = {}
+    # Claude rewind/edit branches live in one append-only JSONL, so those
+    # records must be buffered until the active tip is known. Production
+    # callers bound the input to the latest 2,000 records.
+    claude_records: list[dict] = []
     try:
         if isinstance(source, Path):
             fh = open(source, "r", encoding="utf-8")
@@ -360,33 +438,10 @@ def format_transcript(
             if _codex:
                 yield from _render_codex(record, codex_calls)
                 continue
-
-            # -- Claude format (legacy) --------------------------------
-            if rtype in _SKIP_TYPES:
-                continue
-
-            if _is_real_user(record):
-                rendered = (
-                    _render_claude_native_user(record)
-                    if claude_native
-                    else _render_user(record)
-                )
-                if rendered:
-                    yield rendered
-            if rtype == "user":
-                renderer = (
-                    _render_claude_native_tool_results
-                    if claude_native
-                    else _render_claude_tool_results
-                )
-                yield from renderer(record, claude_calls)
-            elif rtype == "assistant":
-                renderer = (
-                    _render_claude_native_assistant
-                    if claude_native
-                    else _render_assistant_blocks
-                )
-                yield from renderer(record, claude_calls)
+            claude_records.append(record)
+        if _codex is False:
+            yield from _render_claude_records(
+                claude_records, claude_native=claude_native)
     except OSError:
         yield f"{YELLOW}Could not read: {source}{RESET}\n"
     finally:

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

@@ -1072,7 +1072,7 @@ class App:
         session_id: str | None,
         tmux_name: str | None,
     ) -> None:
-        """Stamp the exact Claude transcript used by fast SSH local history."""
+        """Stamp transcript/history routing for the displayed live agent."""
         pane_id = slot.pane_id
         if pane_id is None or not pane_id.startswith("%"):
             return
@@ -1098,6 +1098,19 @@ class App:
             tmux_server.TRANSCRIPT_SOURCE_OPTION,
             marker,
         )
+        history_slot = None
+        if (
+            running is not None
+            and running.session_type in ("claude", "codex")
+            and logical_id is not None
+            and not running.is_placeholder
+        ):
+            history_slot = slot.key
+        tmux_ctl.set_pane_user_option(
+            pane_id,
+            tmux_ctl.RAILMUX_HISTORY_PREVIEW_OPTION,
+            history_slot,
+        )
 
     def _paint_slot_active_target(
         self,
@@ -1900,11 +1913,16 @@ class App:
         self._on_session_preview(session)
 
     def _on_session_preview(self, session: SessionMeta) -> None:
-        """Show session history in the right pane without launching Claude.
+        """Show the provider's canonical current-branch history.
 
-        Stopped-row clicks, Space, and the context action preview history. Live
-        rows are filtered by _on_session_row_preview before reaching this path.
+        Stopped-row clicks, Space, context Preview, and live-pane wheel-up use
+        this read-only projection. A Codex rewind lineage is represented by its
+        newest rollout; Claude branches are projected by ``transcript``.
         """
+        if session.session_type == "codex":
+            representative = self._codex_representative(session.session_id)
+            if representative is not None:
+                session = representative
         slot = self._agent_workspace().target
         self._cancel_pending_double_focus()
         if not self._has_less:
@@ -1939,7 +1957,65 @@ class App:
                     slot, session.session_id, None, **target_kwargs)
             if not self._show_attention_status(session.attention):
                 self._set_status(
-                    f"≡ Previewing {session.display_title} (history)")
+                    f"≡ Previewing {session.display_title} (current history)")
+
+    def _preview_running_history(self, entry: RunningEntry) -> None:
+        """Preview the exact live entry's canonical provider history."""
+        running = self._by_tmux(entry.tmux_name)
+        if (running is None or running.is_placeholder
+                or not self._agent_session_alive(entry.tmux_name)):
+            self._set_status("Live history is no longer available.", "warn")
+            return
+        session_id = running.logical_session_id
+        if session_id is None:
+            self._set_status("Waiting for the provider history file…", "tip")
+            return
+        session = self._find_session_meta(
+            session_id, running.project, running.session_type)
+        if session is None:
+            self._set_status("Waiting for the provider history file…", "tip")
+            return
+        slot = (self._agent_workspace().slot_for_agent(entry.tmux_name)
+                or self._agent_workspace().target)
+        self._set_workspace_target(slot.key)
+        self._on_session_preview(session)
+
+    def _preview_slot_history(self, slot: AgentSlot) -> None:
+        """Handle a pane-local wheel-up routed through the controller."""
+        tmux_name = slot.agent_tmux_name
+        if tmux_name is None:
+            return
+        running = self._by_tmux(tmux_name)
+        if running is None:
+            return
+        self._preview_running_history(RunningEntry(
+            tmux_name=tmux_name,
+            label=running.label,
+            status=running.status,
+        ))
+
+    def _restore_history_slot(self, slot: AgentSlot) -> None:
+        """Return a closed live-history viewer to the exact saved agent."""
+        if not slot.in_history_mode:
+            return
+        restore = slot.restore_state
+        if (restore is None or restore.kind != "agent"
+                or restore.tmux_name is None):
+            return
+        running = self._by_tmux(restore.tmux_name)
+        if (running is None
+                or not self._agent_session_alive(restore.tmux_name)):
+            self._set_status("The previewed live session has ended.", "warn")
+            return
+        self._on_running_select(
+            RunningEntry(
+                tmux_name=running.tmux_name,
+                label=running.label,
+                status=running.status,
+            ),
+            steal_focus=False,
+            slot=slot,
+        )
 
     def _save_restore_state(self, slot: AgentSlot | None = None) -> None:
         """Remember what's in the right pane before taking it over for history."""
@@ -1981,6 +2057,7 @@ class App:
         import shlex
         import sys as _sys
         mouse = self._less_mouse_flag
+        slot = slot or self._agent_workspace().target
         # Tail the last 2000 lines so large sessions appear instantly. Tailing
         # drops the leading ``session_meta`` record, so a long Codex rollout
         # would otherwise be auto-detected as Claude and render blank. Pass the
@@ -1998,7 +2075,17 @@ class App:
                f"{python} -m railmux.transcript --format {fmt} "
                f"--preview-limit 2000 - | "
                f"{less_env} less -R +G {mouse}").rstrip()
-        slot = slot or self._agent_workspace().target
+        restore = slot.restore_state
+        controller = getattr(self, "_railmux_pane_id", None)
+        if (restore is not None and restore.kind == "agent" and controller
+                and slot.key in tmux_ctl.RAILMUX_HISTORY_RESTORE_KEYS):
+            _restore_key, restore_sequence = (
+                tmux_ctl.RAILMUX_HISTORY_RESTORE_KEYS[slot.key])
+            cmd += (
+                "; tmux send-keys -l -t "
+                f"{shlex.quote(controller)} -- "
+                f"{shlex.quote(restore_sequence)}"
+            )
         # In swap mode ``slot.pane_id`` is the real provider pane. Return it
         # home before the destructive ``respawn-pane -k`` below; only the
         # display placeholder may be replaced by the transcript viewer.
@@ -3697,7 +3784,7 @@ class App:
         return None
 
     def _preview_focused_target(self) -> None:
-        """Mirror a single-click for the focused Sessions/Running target."""
+        """Preview canonical history for the focused session or live entry."""
         target = self._focused_pane_menu_target()
         if target is None:
             self._set_status(
@@ -3706,9 +3793,9 @@ class App:
             return
         kind, value, _label = target
         if kind == "session" and isinstance(value, SessionMeta):
-            self._on_session_row_preview(value)
+            self._on_session_preview(value)
         elif kind == "running" and isinstance(value, RunningEntry):
-            self._on_running_select(value, steal_focus=False)
+            self._preview_running_history(value)
 
     def _close_secondary_split(self, *, announce: bool = True) -> bool:
         workspace = self._agent_workspace()
@@ -7313,6 +7400,27 @@ class App:
         if key == COMPACT_RESIZE_KEY.lower():
             self._handle_remote_compact_prepare()
             return
+        for slot_key, (preview_key, _sequence) in (
+                tmux_ctl.RAILMUX_HISTORY_PREVIEW_KEYS.items()):
+            if key == preview_key.lower():
+                if (getattr(self, "_loop", None) is not None
+                        and self._loop.widget is not self._frame):
+                    return
+                workspace = self._agent_workspace()
+                self._preview_slot_history(
+                    workspace.primary
+                    if slot_key == AgentWorkspace.PRIMARY
+                    else workspace.secondary)
+                return
+        for slot_key, (restore_key, _sequence) in (
+                tmux_ctl.RAILMUX_HISTORY_RESTORE_KEYS.items()):
+            if key == restore_key.lower():
+                workspace = self._agent_workspace()
+                self._restore_history_slot(
+                    workspace.primary
+                    if slot_key == AgentWorkspace.PRIMARY
+                    else workspace.secondary)
+                return
         # F9 is routed here by a global tmux binding and must remain available
         # while a modal is open (notably Help's fullscreen copy workflow).
         if key == "f9":
@@ -8518,7 +8626,7 @@ class App:
         # Index visible projects by real_path. A Claude placeholder becomes
         # resolvable once its first real session makes the project visible;
         # Codex New Project can use its in-memory synthetic project earlier.
-        by_path = {p.real_path: p for p in projects}
+        by_path = {self._path_key(p.real_path): p for p in projects}
         claimed = self._running_session_ids() | set(self._running)
         resolved_any = False
         for r in placeholders:
@@ -8526,7 +8634,11 @@ class App:
             # first rollout makes that cwd visible in the Codex index. Claude
             # placeholders continue to wait for discovery to supply the real
             # encoded project directory.
-            project = by_path.get(r.placeholder_path) or r.project
+            placeholder_key = (
+                self._path_key(r.placeholder_path)
+                if r.placeholder_path is not None else None
+            )
+            project = by_path.get(placeholder_key) or r.project
             if project is None:
                 continue
             registered_mode = self._modes().for_tmux_name(r.tmux_name)
@@ -8599,11 +8711,25 @@ class App:
                 if not self._write_orphan_marker(resolved_marker):
                     continue
                 r.orphan = resolved_marker
+            # Codex metadata always carries its synthetic ``-cx-`` project
+            # key, while the Projects pane reuses a discovered Claude project
+            # object when the same cwd exists in both providers.  Preserve the
+            # currently-published project identity across promotion: replacing
+            # it with the metadata object for one tick makes the later
+            # encoded-name match fail, briefly clearing Sessions to its
+            # "Select a project" state before path-based selection recovers.
+            promoted_project = (
+                by_path.get(self._path_key(candidate.project.real_path))
+                or project
+                or candidate.project
+            )
             # Re-key the entry from the placeholder to the real session_id.
             del self._running[r.key]
             r.key = candidate.session_id
-            r.label = f"{candidate.project.display_name}/{candidate.display_title}"
-            r.project = candidate.project
+            r.label = (
+                f"{promoted_project.display_name}/{candidate.display_title}"
+            )
+            r.project = promoted_project
             r.placeholder_path = None
             r.created_at = 0.0
             # Publish the same provider generation atomically to Running.  The
@@ -8622,7 +8748,7 @@ class App:
                 self._set_slot_active_target(
                     displayed_slot, candidate.session_id, r.tmux_name)
                 if displayed_slot is self._agent_workspace().target:
-                    self._set_current_project(candidate.project)
+                    self._set_current_project(promoted_project)
         if resolved_any:
             # Placeholder launch time may already have consumed the ordinary
             # one-minute sort budget.  Its first authoritative provider
@@ -9302,7 +9428,7 @@ class App:
             (_context_menu_label("Open", "↵"),
              lambda s=session: self._do_context_open(s)),
             (_context_menu_label("Preview", "␣"), lambda s=session:
-             self._on_session_row_preview(s)),
+             self._on_session_preview(s)),
             (_context_menu_label("Info", "i"),
              lambda s=session: self._do_context_info(s)),
             (_context_menu_label("Rename", "r"),