gitpane 1.0.0__py3-none-any.whl

gitpane/ui/repository/repository_window.py

@@ -0,0 +1,2580 @@
+"""Show the main window of one open repository, from its commit history to its file readers."""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import os
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from enum import Enum
+from itertools import pairwise
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QByteArray, QEvent, QItemSelectionModel, QModelIndex, QPoint, QRect, QSignalBlocker, QSize, Qt, QTimer, Signal
+from PySide6.QtGui import QAction, QActionGroup, QContextMenuEvent, QIcon, QKeySequence, QPainter, QPalette, QPixmap, QPolygon
+from PySide6.QtWidgets import (
+    QAbstractItemView,
+    QApplication,
+    QFrame,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QLayout,
+    QLineEdit,
+    QMainWindow,
+    QMenu,
+    QMessageBox,
+    QPushButton,
+    QSizePolicy,
+    QSplitter,
+    QStyle,
+    QStyleOptionToolButton,
+    QTableView,
+    QTabWidget,
+    QToolButton,
+    QTreeWidget,
+    QTreeWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+from gitpane.config import (
+    COPY_CONFIRMATION_MS,
+    DETAIL_MIN_HEIGHT,
+    DETAIL_STRETCH,
+    DIFF_FILE_STRETCH,
+    DIFF_TEXT_STRETCH,
+    EMOJI_KEYBOARD_TITLE,
+    FILTER_FIELD_MIN_WIDTH,
+    FIND_SHORTCUT,
+    FIRST_ROW,
+    GRAPH_LANE_WIDTH,
+    HASH_FIELD_MIN_WIDTH,
+    HISTORY_MIN_HEIGHT,
+    HISTORY_STRETCH,
+    LAYOUT_SPACING,
+    MENU_ARROW_AREA_WIDTH,
+    MENU_ARROW_HEIGHT,
+    MENU_ARROW_TEXT_PADDING,
+    MENU_ARROW_WIDTH,
+    MENU_SEPARATOR_WIDTH,
+    NAVIGATION_MIN_WIDTH,
+    NAVIGATION_WIDTH,
+    RECENT_LIMIT,
+    RELATIVE_DATE_REFRESH_MS,
+    REPOSITORY_BUTTON_MAX_WIDTH,
+    REPOSITORY_BUTTON_MIN_TEXT_WIDTH,
+    REPOSITORY_HEIGHT,
+    REPOSITORY_MIN_HEIGHT,
+    REPOSITORY_MIN_WIDTH,
+    REPOSITORY_WIDTH,
+    SEARCH_DEBOUNCE_MS,
+    SPACING_MD,
+    SPACING_XS,
+    TERMINAL_CONTROL_HEIGHT,
+    TOP_BAR_FIELD_STRETCH,
+    SharedText,
+    control_height,
+    fit_window,
+    history_row_height,
+    keep_selection_visible,
+)
+from gitpane.history.file_history import WINDOW_CAPABILITY_BY_MODE, WindowCapability
+from gitpane.history.history_filter import HISTORY_FILTER_INITIAL_MODE, HistoryFilterMode
+from gitpane.history.repository_value import FilePanel, ReferenceKind
+from gitpane.operation.diagnostic import Diagnostic
+from gitpane.preference.preference_store import FETCH_DEFAULT_PREFERENCE_KEY, FETCH_INITIAL_MODE, FetchMode, fetch_mode_preference, saved_recent_dir, saved_recent_identity
+from gitpane.recent.recent_name import repository_display_name
+from gitpane.reference.stash import DROP_OPERATION_LABEL
+from gitpane.reference.stash_list import stash_base_commit, stash_selector
+from gitpane.sequencer.conflict import ConflictState, conflict_count_text, conflict_path_label
+from gitpane.sequencer.merge_state import ABORT_ACTION, CONTINUE_ACTION, MERGE_IN_PROGRESS_TEXT, merge_action_reason
+from gitpane.sequencer.replay_state import ReplayAction, ReplayKind, replay_action_diagnostic, replay_may_be_present
+from gitpane.submodule.submodule_discovery import SubmoduleSnapshot
+from gitpane.system.path_identity import canonical_path
+from gitpane.text.typed_text import typed_value
+from gitpane.tool.system_tool import worktree_filename
+from gitpane.tool.terminal_recipe import TerminalRegistry
+from gitpane.ui.console.error_dialog import ErrorDialog
+from gitpane.ui.look.action_icon import action_icon
+from gitpane.ui.look.theme_color import is_dark_palette, theme_control_color, theme_line_color
+from gitpane.ui.look.theme_look import follow_theme
+from gitpane.ui.reader.commit_panel import CommitPanel, CopiedHash
+from gitpane.ui.reader.diff_panel import DiffPanel
+from gitpane.ui.reader.file_action import FileActionMenu
+from gitpane.ui.reader.file_tree_panel import FileTreePanel
+from gitpane.ui.reader.revision_tree import FOLDER_PATH_ROLE
+from gitpane.ui.reference.branch_selector import BranchSelector
+from gitpane.ui.repository.graph_delegate import AuthorDelegate, GraphDelegate, reference_label
+from gitpane.ui.repository.history_avatar import HistoryAvatar
+from gitpane.ui.repository.history_model import AUTHOR_COLUMN, COLUMN_WIDTHS, MESSAGE_COLUMN, OID_ROLE, HistoryModel
+from gitpane.ui.repository.repository_list_popup import RepositoryListPopup
+from gitpane.ui.widget.commit_date_text import format_commit_date
+from gitpane.ui.widget.long_text import ELLIPSIS, WrappingLabel
+from gitpane.ui.widget.mnemonic import escape_mnemonic
+from gitpane.ui.widget.plain_tooltip import plain_text_tooltip
+from gitpane.ui.widget.result_status_bar import ResultStatusBar
+from gitpane.ui.widget.system_shortcut import refresh_shortcuts
+from gitpane.ui.widget.unavailable_reason import unavailable_reason_text
+from gitpane.ui.window_control.dialog_modality import open_window_modal, prepare_message_box
+from gitpane.ui.window_control.item_activation import activate_current_row
+from gitpane.ui.window_control.window_placement import REPOSITORY_ANCHOR_RANK, centre_on_placement_anchor, mark_placement_anchor
+from gitpane.worktree.file_action_target import FileActionSelection, FileActionTargetKind, FileRestoreTarget
+from gitpane.worktree.file_menu_action import FileAction
+from gitpane.worktree.historical_restore import RESTORE_SELECTED_VERSION_TITLE
+from gitpane.worktree.worktree_snapshot import SUBMODULE_DIRTY_DESCRIPTION, WorktreeColorState, WorktreeKey
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtGui import QClipboard, QCloseEvent, QKeyEvent, QMouseEvent, QPaintEvent, QResizeEvent, QShowEvent
+
+    from gitpane.history.avatar import AvatarService
+    from gitpane.history.file_history import FileHistoryResult
+    from gitpane.history.repository_value import Commit, CommitRelation, HistorySnapshot, RepositoryContext
+    from gitpane.reference.stash_list import StashEntry, StashList
+    from gitpane.sequencer.merge_state import MergeBannerState
+    from gitpane.sequencer.rebase_state import RebaseSnapshot
+    from gitpane.sequencer.replay_state import ReplaySnapshot
+    from gitpane.worktree.historical_restore import HistoricalRestoreRequest
+
+NAVIGATION_COLUMN = 0
+REPOSITORY_ROLE = int(Qt.ItemDataRole.UserRole) + 100
+MINIMUM_COMMIT_PREFIX_LENGTH = 4
+HISTORICAL_SUBJECT_LIMIT = 80
+HISTORICAL_PATH_LABEL_LIMIT = 120
+CONFLICT_BANNER_PATH_LIMIT = 3
+# The background of the conflict banner while a merge waits for its commit: a light blue close to Git Extensions'. Like
+# the orange of the other banners it is fixed and carries black text, so it reads the same in the light and dark themes.
+MERGE_BANNER_COLOR = "#9fcdf5"
+CONFLICT_BANNER_STYLE = "QWidget#conflict_banner { background-color: orange; } QLabel { color: black; }"
+MERGE_BANNER_STYLE = "QWidget#conflict_banner { background-color: " + MERGE_BANNER_COLOR + "; } QLabel { color: black; }"
+# Separates the parts of one status line, such as the history line and a notice kept after it.
+STATUS_PART_SEPARATOR = " — "
+# The kinds of notices kept at the end of the history status line, in the order they are shown: one notice per kind,
+# so a new notice of one kind never hides a notice of another.
+LEGACY_BACKUP_NOTICE_KIND = "legacy_backup"
+COMMIT_NOTICE_KIND = "commit"
+STATUS_NOTICE_KINDS = (LEGACY_BACKUP_NOTICE_KIND, COMMIT_NOTICE_KIND)
+STASH_GROUP_LABEL = "Stashes"
+STASH_UNAVAILABLE_PREFIX = "Stash list unavailable: "
+STASH_CREATED_PREFIX = "Created: "
+STASH_BASE_COMMIT_PREFIX = "Created from: "
+STASH_COMMIT_PREFIX = "Stash commit: "
+REPOSITORY_BUTTON_ACCESSIBLE_NAME = "Current repository"
+# The Commit tab is the first one added to the detail tabs; a window starts on it.
+COMMIT_TAB_INDEX = 0
+# Text of the Commit action until the working tree of the displayed repository has been counted.
+COMMIT_UNKNOWN_COUNT_LABEL = "Commit(?)"
+# Horizontal and vertical scroll offsets of the submodule tree before the user scrolls it: the top left corner.
+SUBMODULE_SCROLL_START = (0, 0)
+# Reference groups of the navigation tree, in the order the tree shows them, each titled with the label of its kind.
+BRANCH_TREE_GROUP_KINDS = (ReferenceKind.HEADS, ReferenceKind.REMOTES, ReferenceKind.TAGS, ReferenceKind.HEAD)
+
+
+def _create_top_bar_separator() -> QFrame:
+    """Separate toolbar groups with the same decorative native frame."""
+    separator = QFrame()
+    separator.setFrameShape(QFrame.Shape.VLine)
+    separator.setFrameShadow(QFrame.Shadow.Sunken)
+    separator.setFocusPolicy(Qt.FocusPolicy.NoFocus)
+    return separator
+
+
+def repository_window_title(repository_dir: str) -> str:
+    """Return the title of a repository window, so opening and changing repository name the window the same way."""
+    return f"{repository_display_name(repository_dir)} — {repository_dir} — GitPane"
+
+
+def repository_menu_dirs(current_dir: str, recent_dirs: list[str]) -> list[str]:
+    """Return the repositories the switch list offers: the current one first, then the history in its order.
+
+    A repository already listed is skipped, compared by the key of the recent history, and the list stops at the history
+    limit. Only the open repository is resolved on disk, into the form the history saves. The history is compared as
+    text, since the preference store already saves it resolved: resolving each entry again would touch the disk, and a
+    disconnected network drive would freeze the window.
+    """
+    menu_dirs = [current_dir]
+    listed_directory_set = {saved_recent_identity(saved_recent_dir(current_dir))}
+    for recent_dir in recent_dirs:
+        if len(menu_dirs) >= RECENT_LIMIT:
+            break
+        directory = saved_recent_identity(recent_dir)
+        if directory in listed_directory_set:
+            continue
+        listed_directory_set.add(directory)
+        menu_dirs.append(recent_dir)
+    return menu_dirs
+
+
+class RepositoryWindowText(Enum):
+    """Texts the window of an open repository shows, one member per text."""
+
+    OPEN_ANOTHER = "Open or clone…"
+    EXPLORER = "Open in file explorer"
+    TERMINAL = "Open terminal"
+    TERMINAL_DETECT = "Detect terminals"
+    TERMINAL_EMPTY = "No terminals available"
+    FILTER_SEARCH_HELP = "Case-insensitive search; * matches any text. Other characters are literal."
+    FILTER_CLEAR = "Clear filter"
+    FILTER_PREVIOUS = "Previous results — searching"
+    HISTORY_LOADING = "Loading history…"
+    REPOSITORY_EMPTY = "No commits in this repository"
+
+
+# Side in pixels of the transparent icon that makes the text-only filter mode button lay its text out beside an icon.
+SPACER_ICON_SIDE = 1
+# Pixels Fusion puts between a tool button's icon and its text.
+FUSION_ICON_TEXT_SPACING = 4
+# Space advances QToolButton adds after its text when it measures it.
+TOOL_BUTTON_TEXT_SPACE_COUNT = 2
+
+
+def terminal_button_style_sheet(palette: QPalette) -> str:
+    """Return the style sheet of the tool bar buttons that have a menu part: Fetch, Open terminal, the repository button and the filter mode button.
+
+    A light theme keeps the palette's mid tone for the hover separator and its mid-light tone for the hover background.
+    In a dark theme those two tones are almost the tool bar's own color and the hover could not be seen, so they take
+    the theme's line grey and control grey, worked out from ``palette``.
+    """
+    separator_color, hover_color = "palette(mid)", "palette(midlight)"
+    if is_dark_palette(palette):
+        separator_color, hover_color = theme_line_color(palette).name(), theme_control_color(palette).name()
+    # Workaround: Fusion draws its own arrow in the menu area and ignores the size asked for it, which shows as a
+    # small grey dot. The style arrow is therefore hidden and paintEvent paints a filled triangle at the measured size.
+    # The menu area keeps a transparent left border when not hovered so that it has the same width in both states
+    # and the triangle does not move when the hover separator appears.
+    # A native button border makes Qt ignore the reserved content padding on Windows, hence "border: none".
+    return (f"QToolButton {{ border: none; padding: {SPACING_XS}px; padding-right: {MENU_ARROW_TEXT_PADDING}px; }} "
+            f"QToolButton::menu-button {{ border: none; border-left: {MENU_SEPARATOR_WIDTH}px solid transparent; width: {MENU_ARROW_AREA_WIDTH}px; }} "
+            f"QToolButton::menu-button:hover {{ border-left: {MENU_SEPARATOR_WIDTH}px solid {separator_color}; }} "
+            "QToolButton::menu-arrow { image: none; } "
+            f"QToolButton:hover {{ background: {hover_color}; }}")
+
+
+class TerminalButton(QToolButton):
+    """Two-zone toolbar button: the text runs the action, the arrow opens the menu.
+
+    Used by Fetch and Open terminal, and by the filter mode button, whose text opens the menu too. The menu stays
+    reachable even while the main action is unavailable.
+    """
+
+    def __init__(self) -> None:
+        """Reserve an independent arrow target and retain native keyboard menu handling."""
+        super().__init__()
+        self.main_enabled = False
+        self.setPopupMode(QToolButton.ToolButtonPopupMode.MenuButtonPopup)
+        self.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
+        self.setMinimumHeight(TERMINAL_CONTROL_HEIGHT)
+        # Workaround: the style sheet hides Fusion's arrow and keeps the menu area's width in both states; see
+        # terminal_button_style_sheet, which the repository window lays again at each theme switch.
+        self.setStyleSheet(terminal_button_style_sheet(QApplication.palette()))
+
+    def menu_area(self) -> QRect:
+        """Return the menu part of the button: where the arrow is painted and where a click opens the menu."""
+        option = QStyleOptionToolButton()
+        self.initStyleOption(option)
+        return self.style().subControlRect(QStyle.ComplexControl.CC_ToolButton, option, QStyle.SubControl.SC_ToolButtonMenu, self)
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        """Paint the native button, then a filled down triangle centred in the menu area in the button text colour."""
+        super().paintEvent(event)
+        menu_rect = self.menu_area()
+        color_group = QPalette.ColorGroup.Normal if self.isEnabled() else QPalette.ColorGroup.Disabled
+        left = menu_rect.left() + (menu_rect.width() - MENU_ARROW_WIDTH) // 2
+        top = menu_rect.top() + (menu_rect.height() - MENU_ARROW_HEIGHT) // 2
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing, False)
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(self.palette().color(color_group, QPalette.ColorRole.ButtonText))
+        painter.drawPolygon(QPolygon([QPoint(left, top), QPoint(left + MENU_ARROW_WIDTH, top), QPoint(left + MENU_ARROW_WIDTH // 2, top + MENU_ARROW_HEIGHT)]))
+        painter.end()
+
+    def mousePressEvent(self, event: QMouseEvent) -> None:
+        """Block only the primary region, preserving the menu when no tool can start."""
+        if not self.main_enabled and not self.menu_area().contains(event.position().toPoint()):
+            event.ignore()
+            return
+        super().mousePressEvent(event)
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:
+        """Allow the menu shortcut even when Enter and Space cannot launch a tool."""
+        if event.key() == Qt.Key.Key_Down and event.modifiers() & Qt.KeyboardModifier.AltModifier:
+            self.showMenu()
+            event.accept()
+            return
+        if not self.main_enabled and event.key() in (Qt.Key.Key_Space, Qt.Key.Key_Return, Qt.Key.Key_Enter):
+            event.ignore()
+            return
+        super().keyPressEvent(event)
+
+
+class FilterModeButton(TerminalButton):
+    """Two-zone button of the top bar that shows what the filter searches; its text and its arrow both open the menu of modes."""
+
+    def __init__(self) -> None:
+        """Open the menu from the text too, since choosing a mode is the button's only use."""
+        super().__init__()
+        self.main_enabled = True
+        self.clicked.connect(self.showMenu)
+        # Workaround: a tool button without an icon centres its text over the whole button, menu area included, so the
+        # text ran under the painted arrow. A transparent icon one pixel wide makes Fusion draw the text beside an
+        # icon, left-aligned, as on Fetch and Open terminal.
+        pixmap = QPixmap(QSize(SPACER_ICON_SIDE, SPACER_ICON_SIDE))
+        pixmap.fill(Qt.GlobalColor.transparent)
+        self.setIcon(QIcon(pixmap))
+        self.setIconSize(QSize(SPACER_ICON_SIDE, SPACER_ICON_SIDE))
+
+    def sizeHint(self) -> QSize:
+        """Ask for the room of the left padding, the spacer icon, the text and its two trailing spaces, the right padding and the menu area.
+
+        Workaround: outside a tool bar, Qt's size hint of this button leaves out most of the menu area, so the arrow
+        covered the end of the text. The width is the layout the menu buttons of the tool bar get, written out here.
+        """
+        native_size = QToolButton.sizeHint(self)
+        text_width = self.fontMetrics().size(Qt.TextFlag.TextShowMnemonic, self.text()).width() + TOOL_BUTTON_TEXT_SPACE_COUNT * self.fontMetrics().horizontalAdvance(" ")
+        menu_area_width = MENU_SEPARATOR_WIDTH + MENU_ARROW_AREA_WIDTH
+        width = SPACING_XS + SPACER_ICON_SIDE + FUSION_ICON_TEXT_SPACING + text_width + MENU_ARROW_TEXT_PADDING + menu_area_width
+        return QSize(max(width, native_size.width()), native_size.height())
+
+
+class RepositorySwitchButton(TerminalButton):
+    """Button showing the current repository, like the working directory button of Git Extensions.
+
+    Both its text and its arrow open the list of recently opened repositories; choosing one opens it in the same window.
+    The button only asks for the list: the window owns it, since the window knows the history.
+    """
+
+    list_requested = Signal()
+
+    # Declared on the class because the base constructor sets a style sheet, whose change event elides the path
+    # before this constructor runs.
+    repository_dir: str = ""
+
+    def __init__(self) -> None:
+        """Make the text zone open the list too, since the button has no action of its own; Space opens it as well."""
+        super().__init__()
+        self.main_enabled = True
+        self.setAccessibleName(REPOSITORY_BUTTON_ACCESSIBLE_NAME)
+        self.clicked.connect(self.list_requested)
+
+    def mousePressEvent(self, event: QMouseEvent) -> None:
+        """Ask for the list on a left press anywhere on the button, text or arrow.
+
+        The native press is not run: the button has no Qt menu, and the native press on the arrow would try to open one
+        and do nothing.
+        """
+        if event.button() != Qt.MouseButton.LeftButton:
+            super().mousePressEvent(event)
+            return
+        event.accept()
+        self.list_requested.emit()
+
+    def showMenu(self) -> None:
+        """Ask for the list where Qt or the keyboard handling would open the menu of the button, as Alt+Down does."""
+        self.list_requested.emit()
+
+    def show_path(self, repository_dir: str) -> None:
+        """Show the path of the repository the window displays: in full in the tooltip and the accessible description,
+        and in the text as far as the button width allows."""
+        self.repository_dir = repository_dir
+        self.setToolTip(plain_text_tooltip([repository_dir]))
+        self.setAccessibleDescription(repository_dir)
+        self._elide_text()
+        self.updateGeometry()
+
+    def _text_width(self, text: str) -> int:
+        """Return the width the button draws for a text, measured as Qt measures a text with mnemonics."""
+        return self.fontMetrics().size(Qt.TextFlag.TextShowMnemonic, text).width()
+
+    def _chrome_width(self) -> int:
+        """Return the width the button takes around its text: padding, icon and menu area, as the native button measures them."""
+        return QToolButton.sizeHint(self).width() - self._text_width(self.text())
+
+    def _elide_text(self) -> None:
+        """Write the path elided in the middle for the current width, so the start of the path and the repository name stay readable.
+
+        The path is elided first and each "&" doubled afterwards, so the elision measures the text the user sees.
+        """
+        available_width = max(self.width() - self._chrome_width(), 0)
+        elided_dir = self.fontMetrics().elidedText(self.repository_dir, Qt.TextElideMode.ElideMiddle, available_width)
+        # Qt returns an empty text when not even the ellipsis fits; the button keeps the ellipsis so that its width
+        # around the text, measured from its current text, stays right.
+        text = escape_mnemonic(elided_dir) if elided_dir or not self.repository_dir else ELLIPSIS
+        if text != self.text():
+            self.setText(text)
+
+    def sizeHint(self) -> QSize:
+        """Ask for the width of the whole path, up to the maximum width of the button, so the fields beside it keep room.
+
+        The size depends only on the repository path, never on the elided text, so eliding does not start a new layout pass.
+        """
+        native_size = QToolButton.sizeHint(self)
+        full_width = self._chrome_width() + self._text_width(escape_mnemonic(self.repository_dir))
+        return QSize(min(full_width, REPOSITORY_BUTTON_MAX_WIDTH), native_size.height())
+
+    def minimumSizeHint(self) -> QSize:
+        """Allow the button to shrink to a few characters of the path, so the fields beside it keep their minimum width."""
+        native_size = QToolButton.sizeHint(self)
+        return QSize(self._chrome_width() + REPOSITORY_BUTTON_MIN_TEXT_WIDTH, native_size.height())
+
+    def resizeEvent(self, event: QResizeEvent) -> None:
+        """Elide the path again for the new width."""
+        super().resizeEvent(event)
+        self._elide_text()
+
+    def changeEvent(self, event: QEvent) -> None:
+        """Elide the path again when the font or the style changes, since both change the width the text takes."""
+        super().changeEvent(event)
+        if event.type() in (QEvent.Type.FontChange, QEvent.Type.StyleChange):
+            self._elide_text()
+
+
+class HistoryView(QTableView):
+    """Provide whole-row keyboard selection over the native history table."""
+
+    menu_requested = Signal(object, object)
+
+    def __init__(self) -> None:
+        """Use available width for subjects while retaining the user's chosen minimum width."""
+        super().__init__()
+        self.subject_width = COLUMN_WIDTHS[MESSAGE_COLUMN]
+        self.graph_width = 0
+        self.resizing_subject = False
+        self.horizontalHeader().sectionResized.connect(self._column_resized)
+
+    def resizeEvent(self, event: QResizeEvent) -> None:
+        """Grow the subject column on wide windows and keep horizontal scrolling on narrow ones."""
+        super().resizeEvent(event)
+        self.resize_subject()
+
+    def resize_subject(self) -> None:
+        """Fill spare viewport space without changing fixed metadata widths."""
+        if self.model() is None or self.resizing_subject:
+            return
+        remaining = self.viewport().width()
+        for column in range(self.model().columnCount()):
+            if column != MESSAGE_COLUMN:
+                remaining -= self.columnWidth(column)
+        self.resizing_subject = True
+        try:
+            self.setColumnWidth(MESSAGE_COLUMN, max(self.subject_width, self.graph_width + LAYOUT_SPACING, remaining))
+        finally:
+            self.resizing_subject = False
+
+    def _column_resized(self, column: int, previous_width: int, width: int) -> None:
+        """Preserve an explicit subject resize and compensate when other columns change."""
+        if self.resizing_subject:
+            return
+        if column == MESSAGE_COLUMN:
+            self.subject_width = width
+        self.resize_subject()
+
+    def contextMenuEvent(self, event: QContextMenuEvent) -> None:
+        """Bind a mouse menu to the clicked row and a keyboard menu to the selection."""
+        if event.reason() == event.Reason.Keyboard:
+            index = self.currentIndex()
+        else:
+            index = self.indexAt(event.pos())
+        self.menu_requested.emit(index, event.globalPos())
+        event.accept()
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:
+        """Open the same menu for Menu and Shift+F10 on every desktop platform."""
+        if event.key() in (Qt.Key.Key_Home, Qt.Key.Key_End) and self.model().rowCount():
+            row = FIRST_ROW if event.key() == Qt.Key.Key_Home else self.model().rowCount() - 1
+            self.setCurrentRow(row)
+            event.accept()
+            return
+        if event.key() == Qt.Key.Key_Menu or (event.key() == Qt.Key.Key_F10 and event.modifiers() & Qt.KeyboardModifier.ShiftModifier):
+            index = self.currentIndex()
+            self.menu_requested.emit(index, self.viewport().mapToGlobal(self.visualRect(index).center()))
+            event.accept()
+            return
+        super().keyPressEvent(event)
+
+    def setCurrentRow(self, row: int) -> None:
+        """Select a complete row and reveal it for programmatic navigation."""
+        self.selectionModel().setCurrentIndex(self.model().index(row, MESSAGE_COLUMN), QItemSelectionModel.SelectionFlag.ClearAndSelect | QItemSelectionModel.SelectionFlag.Rows)
+
+    def count(self) -> int:
+        """Return selectable commits using the same convention as the opening list."""
+        return self.model().rowCount()
+
+
+@dataclass(frozen=True)
+class ViewAnchor:
+    """Remember commit identity and pixel position independently of inserted rows."""
+
+    selected_oid: str | None
+    selected_visible_index: int
+    top_oid: str | None
+    top_visible_index: int
+    top_pixel_offset: int
+    horizontal_offset: int
+    filter_text: str
+    filter_mode: HistoryFilterMode
+
+
+class RepositoryWindow(QMainWindow):
+    """Show a real selected commit and its complete text in a resizable layout."""
+
+    closed = Signal()
+    open_requested = Signal()
+    refresh_requested = Signal()
+    setting_requested = Signal()
+    commit_selected = Signal(str)
+    navigation_requested = Signal(str)
+    repository_activated = Signal(str)
+    repository_switch_requested = Signal(str)
+    filter_changed = Signal(str)
+    search_requested = Signal()
+    detail_retry_requested = Signal(str)
+    explorer_requested = Signal()
+    terminal_requested = Signal(object)
+    file_history_requested = Signal(object)
+    file_folder_requested = Signal(object)
+    file_text_editor_requested = Signal(object)
+    file_save_requested = Signal(object)
+    difftool_requested = Signal()
+    file_history_resume_requested = Signal()
+    reading_preference_requested = Signal(object)
+    commit_requested = Signal()
+    file_restore_requested = Signal(object, object)
+    remove_history_requested = Signal(object)
+    checkout_requested = Signal(str)
+    checkout_commit_requested = Signal(str, object)
+    checkout_branch_requested = Signal(str, str, object)
+    create_branch_requested = Signal(str, object)
+    create_tag_requested = Signal(str, object)
+    remote_requested = Signal()
+    emoji_keyboard_requested = Signal()
+    fetch_requested = Signal()
+    stash_requested = Signal()
+    resolve_requested = Signal(object)
+    merge_continue_requested = Signal()
+    merge_abort_requested = Signal()
+    rebase_requested = Signal()
+    replay_refresh_requested = Signal()
+    replay_resolve_requested = Signal(object)
+    replay_continue_requested = Signal(object)
+    replay_abort_requested = Signal(object)
+    replay_requested = Signal(str, object, object)
+    rebase_start_requested = Signal(str, object)
+    merge_recovery_requested = Signal()
+    stash_pop_requested = Signal()
+    stash_drop_requested = Signal(object)
+    push_requested = Signal()
+    fetch_menu_requested = Signal()
+    fetch_selection_requested = Signal(object)
+    fetch_default_requested = Signal(object)
+    reset_requested = Signal(str, object)
+    move_branch_requested = Signal(str, object)
+    rename_branch_requested = Signal(str, str, object)
+    delete_branch_requested = Signal(str, str, object)
+    delete_tag_requested = Signal(str, str, object)
+
+    def __init__(self, context: RepositoryContext, commit: Commit | None, clipboard: QClipboard | None = None, mode: str = "repository",
+                 placement_anchor: QWidget | None = None, *, clock: Callable[[], datetime] | None = None) -> None:
+        """Present repository data without knowing how Git produced it.
+
+        ``placement_anchor`` is the GitPane window this one was opened from (Open repository, Clone repository, the
+        repository window or Prepare changes asking for a file history); the window opens centred on it, on its screen.
+        ``clock`` gives the current time the history rows and the commit details write their relative dates against; it
+        is injected so those dates can be reproduced, as the window gallery needs, and reads the system time when absent.
+        """
+        super().__init__()
+        # Set before any message, so every message of the window goes through the bar that can colour a failure.
+        self.setStatusBar(ResultStatusBar(self))
+        mark_placement_anchor(self, REPOSITORY_ANCHOR_RANK)
+        self.placement_anchor = placement_anchor
+        self.centred = False
+        self.context = context
+        self.mode = mode
+        self.is_closed = False
+        self.capabilities = WINDOW_CAPABILITY_BY_MODE[mode]
+        self.file_menu: FileActionMenu | None = None
+        # Set by the file action controller, which reads the preferences and the disk; the window only shows the reason it returns.
+        self.text_editor_reason: Callable[[FileActionSelection], str] | None = None
+        self.remove_history_reason: Callable[[FileActionSelection], str] | None = None
+        self.file_history_result: FileHistoryResult | None = None
+        self.clipboard = clipboard
+        self.copy_dialog: ErrorDialog | None = None
+        self.history_menu: QMenu | None = None
+        self.navigation_menu: QMenu | None = None
+        self.commit = commit
+        self.commit_relation: CommitRelation | None = None
+        self.pending_oid: str | None = None
+        # The commit Go to commit hash asked for, drawn in the middle of the graph once its row is revealed. Only that
+        # path centers: centering always scrolls, even for a row already visible, so the graph would jump at every
+        # branch click or Refresh.
+        self.centered_oid: str | None = None
+        self.anchor_oid: str | None = None
+        self.snapshot: HistorySnapshot | None = None
+        self.submodule_snapshot: SubmoduleSnapshot | None = None
+        self.submodule_item_by_key: dict[str, QTreeWidgetItem] = {}
+        self.submodule_expanded_by_key: dict[str, bool] = {}
+        self.submodule_selected_key: str | None = None
+        self.submodule_scroll = SUBMODULE_SCROLL_START
+        # The stashes last read with the references, and the left-panel group showing them.
+        self.stash_list: StashList | None = None
+        # The repository the stash list was read from: a window that moves to a submodule or back to its parent shows
+        # another repository before that repository's stashes are read.
+        self.stash_list_context: RepositoryContext | None = None
+        self.stash_group: QTreeWidgetItem | None = None
+        # The expanded state the user gave the Stashes group by hand in this window, or None while they have not touched
+        # it: the group is then expanded exactly when it holds a stash. Kept here rather than read back from the group,
+        # because the group is rebuilt with every reference read and its label changes with the count.
+        self.stash_group_user_expanded: bool | None = None
+        # True while the window itself expands or collapses the Stashes group. Qt reports those changes through the same
+        # itemExpanded and itemCollapsed signals as a click on the arrow, and they must not be taken for the user's choice.
+        self.applying_stash_expansion = False
+        # The stashes written in the group, in the order of its lines, so their tooltips can be rewritten.
+        self.shown_stash_entries: tuple[StashEntry, ...] = ()
+        self.graph_index_complete = False
+        self.filter_text = ""
+        self.search_pending = False
+        # Notices kept at the end of the history status line until the window closes, each for its own working tree:
+        # the window can navigate to a submodule and back, and a notice only belongs to the repository it names.
+        self.status_notice_by_kind_by_worktree: dict[WorktreeKey, dict[str, str]] = {}
+        self.terminal_registry: TerminalRegistry | None = None
+        self.terminal_busy = False
+        self.terminal_dialog: ErrorDialog | None = None
+        self.setWindowTitle(repository_window_title(context.repository_dir))
+        self.resize(REPOSITORY_WIDTH, REPOSITORY_HEIGHT)
+        file_menu = self.menuBar().addMenu("File")
+        self.open_action = QAction(RepositoryWindowText.OPEN_ANOTHER.value, self)
+        self.open_action.triggered.connect(self.open_requested.emit)
+        self.open_action.setShortcut("Ctrl+O")
+        self.setting_action = QAction(SharedText.SETTING.value, self)
+        self.setting_action.triggered.connect(self.setting_requested.emit)
+        self.close_action = QAction("Close", self)
+        self.close_action.triggered.connect(self.close)
+        self.close_action.setShortcut("Ctrl+W")
+        file_menu.addAction(self.open_action)
+        toolbar = self.addToolBar("Repository")
+        self.action_toolbar = toolbar
+        toolbar.setMovable(False)
+        toolbar.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
+        toolbar.addAction(self.open_action)
+        self.refresh_action = toolbar.addAction(SharedText.REFRESH.value, self.refresh_requested.emit)
+        self.refresh_action.setIcon(action_icon("refresh", self.devicePixelRatioF()))
+        self.branch_selector = BranchSelector(self)
+        self.branch_selector_action = toolbar.addWidget(self.branch_selector)
+        self.branch_selector.activated.connect(self._branch_activated)
+        self.fetch_mode = FETCH_INITIAL_MODE
+        self.fetch_busy = False
+        self.fetch_snapshot = None
+        self.fetch_remote_name = ""
+        self.fetch_button = TerminalButton()
+        self.fetch_button.setText("Fetch")
+        self.fetch_button.setAccessibleName("Fetch")
+        self.fetch_button.main_enabled = WindowCapability.MANAGE in self.capabilities
+        self.fetch_button.clicked.connect(self._request_fetch)
+        self.fetch_menu = QMenu("Fetch", self)
+        self.fetch_menu.setToolTipsVisible(True)
+        self.fetch_menu.setStyleSheet("QMenu { menu-scrollable: 1; }")
+        self.fetch_button.setMenu(self.fetch_menu)
+        self.fetch_choice_action_by_mode: dict[FetchMode, QAction] = {}
+        for fetch_mode in FetchMode:
+            action = self.fetch_menu.addAction(fetch_mode.label)
+            action.setCheckable(True)
+            action.triggered.connect(lambda checked=False, mode=fetch_mode: self._request_fetch_choice(mode))
+            self.fetch_choice_action_by_mode[fetch_mode] = action
+        self.fetch_default_menu = self.fetch_menu.addMenu("Set as default")
+        self.fetch_default_action_by_mode: dict[FetchMode, QAction] = {}
+        for fetch_mode in FetchMode:
+            action = self.fetch_default_menu.addAction(fetch_mode.label)
+            action.setCheckable(True)
+            action.triggered.connect(lambda checked=False, mode=fetch_mode: self.fetch_default_requested.emit(mode))
+            self.fetch_default_action_by_mode[fetch_mode] = action
+        self.fetch_remote_menu = QMenu("Choose a remote", self.fetch_menu)
+        self.fetch_remote_menu.setToolTipsVisible(True)
+        self.fetch_remote_menu.setStyleSheet("QMenu { menu-scrollable: 1; }")
+        self.fetch_menu.aboutToShow.connect(self.fetch_menu_requested.emit)
+        self.fetch_action = toolbar.addWidget(self.fetch_button)
+        self.fetch_action.setText("Fetch")
+        self.fetch_action.triggered.connect(self._request_fetch)
+        self.fetch_action.setVisible(WindowCapability.MANAGE in self.capabilities)
+        self.fetch_action.setEnabled(WindowCapability.MANAGE in self.capabilities)
+        self.apply_fetch_preference({FETCH_DEFAULT_PREFERENCE_KEY: FETCH_INITIAL_MODE.value})
+        self.push_action = toolbar.addAction(action_icon("push", self.devicePixelRatioF()), "Push", self._request_push)
+        self.push_action.setVisible(WindowCapability.MANAGE in self.capabilities)
+        self.push_action.setEnabled(WindowCapability.MANAGE in self.capabilities)
+        self.commit_action = toolbar.addAction(COMMIT_UNKNOWN_COUNT_LABEL, self.commit_requested.emit)
+        self.commit_action.setIcon(action_icon("commit", self.devicePixelRatioF()))
+        self.commit_action.setVisible(WindowCapability.MANAGE in self.capabilities)
+        self.stash_action = toolbar.addAction(action_icon("stash", self.devicePixelRatioF()), "Stash", self._request_stash)
+        self.stash_action.setVisible(WindowCapability.MANAGE in self.capabilities)
+        self.stash_pop_action = toolbar.addAction(action_icon("stash_pop", self.devicePixelRatioF()), "Stash pop", self._request_stash_pop)
+        self.stash_pop_action.setVisible(WindowCapability.MANAGE in self.capabilities)
+        self._apply_repository_capability()
+        refresh_sequences: list[QKeySequence] = []
+        for refresh_shortcut in refresh_shortcuts():
+            refresh_sequences.append(QKeySequence(refresh_shortcut))
+        self.refresh_action.setShortcuts(refresh_sequences)
+        file_menu.addAction(self.refresh_action)
+        file_menu.addAction(self.commit_action)
+        self.explorer_action = toolbar.addAction(RepositoryWindowText.EXPLORER.value, self.explorer_requested.emit)
+        file_menu.addAction(self.explorer_action)
+        self.terminal_button = TerminalButton()
+        self.terminal_button.setText(RepositoryWindowText.TERMINAL.value)
+        self.terminal_button.clicked.connect(self._request_terminal)
+        self.terminal_menu = QMenu(SharedText.TERMINAL_CHOOSE.value, self)
+        self.terminal_menu.setToolTipsVisible(True)
+        self.terminal_menu.setStyleSheet("QMenu { menu-scrollable: 1; }")
+        self.terminal_button.setMenu(self.terminal_menu)
+        self.terminal_action = QAction(RepositoryWindowText.TERMINAL.value, self)
+        self.terminal_action.triggered.connect(self._request_terminal)
+        self.terminal_action.setEnabled(False)
+        self.terminal_group = QActionGroup(self)
+        self.terminal_group.setExclusive(True)
+        self.terminal_choice_actions: list[QAction] = []
+        self.redetect_action = QAction(RepositoryWindowText.TERMINAL_DETECT.value, self)
+        self.redetect_action.triggered.connect(self._redetect_terminal)
+        self.terminal_menu.addAction(self.redetect_action)
+        toolbar.addWidget(self.terminal_button)
+        toolbar.addAction(self.setting_action)
+        file_menu.addAction(self.terminal_action)
+        file_menu.addMenu(self.terminal_menu)
+        file_menu.addAction(self.setting_action)
+        file_menu.addAction(self.close_action)
+        self.addToolBarBreak()
+        filter_toolbar = self.addToolBar("Message filter")
+        filter_toolbar.setMovable(False)
+        # The repositories the switch list offers, as last received; the list is rebuilt from them each time it opens.
+        self.recent_dirs: list[str] = []
+        # Built on the first opening only, since many windows are never switched.
+        self.repository_list_popup: RepositoryListPopup | None = None
+        self.repository_button = RepositorySwitchButton()
+        self.repository_button.list_requested.connect(self._show_repository_list)
+        self.repository_button.show_path(context.repository_dir)
+        # A file history window stays on its repository: the button shows it but cannot change it.
+        self.repository_button.setEnabled(WindowCapability.MANAGE in self.capabilities)
+        follow_theme(self, self._apply_menu_button_look)
+        self.filter_edit = QLineEdit()
+        self.filter_edit.setToolTip(RepositoryWindowText.FILTER_SEARCH_HELP.value)
+        self.filter_edit.setMinimumWidth(FILTER_FIELD_MIN_WIDTH)
+        self.clear_filter_button = QPushButton(RepositoryWindowText.FILTER_CLEAR.value)
+        # What the filter field searches in each commit; never saved, so every opening starts on the initial mode.
+        self.filter_mode = HISTORY_FILTER_INITIAL_MODE
+        self.filter_mode_button = FilterModeButton()
+        self.filter_mode_menu = QMenu(self)
+        self.filter_mode_group = QActionGroup(self)
+        self.filter_mode_group.setExclusive(True)
+        self.filter_mode_action_by_mode: dict[HistoryFilterMode, QAction] = {}
+        for filter_mode in HistoryFilterMode:
+            action = self.filter_mode_menu.addAction(filter_mode.label)
+            action.setCheckable(True)
+            self.filter_mode_group.addAction(action)
+            action.triggered.connect(lambda checked=False, mode=filter_mode: self.choose_filter_mode(mode))
+            self.filter_mode_action_by_mode[filter_mode] = action
+        self.filter_mode_button.setMenu(self.filter_mode_menu)
+        self.show_filter_mode(HISTORY_FILTER_INITIAL_MODE)
+        self.commit_hash_edit = QLineEdit()
+        self.commit_hash_edit.setPlaceholderText("Full hash or unique prefix")
+        self.commit_hash_edit.setAccessibleName("Go to commit hash")
+        self.commit_hash_edit.setMinimumWidth(HASH_FIELD_MIN_WIDTH)
+        hash_label = QLabel("Go to commit hash")
+        hash_label.setBuddy(self.commit_hash_edit)
+        self.go_button = QPushButton("Go")
+        # Workaround: a toolbar never shrinks one of its widgets below the width it asks for, and sends the widgets that
+        # do not fit into its extension menu, so a long repository path pushed the hash field out of sight. The whole bar
+        # is therefore one row widget whose layout shares the width: the fields keep their minimum and the repository
+        # button elides its path in the middle.
+        self.top_bar_row = QWidget()
+        self.top_bar_row.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
+        top_bar_layout = QHBoxLayout(self.top_bar_row)
+        top_bar_layout.setContentsMargins(0, 0, 0, 0)
+        top_bar_layout.setSpacing(SPACING_XS)
+        top_bar_layout.addWidget(self.repository_button)
+        top_bar_layout.addWidget(_create_top_bar_separator())
+        top_bar_layout.addWidget(self.filter_mode_button)
+        top_bar_layout.addWidget(self.filter_edit, TOP_BAR_FIELD_STRETCH)
+        top_bar_layout.addWidget(self.clear_filter_button)
+        top_bar_layout.addWidget(_create_top_bar_separator())
+        top_bar_layout.addWidget(hash_label)
+        top_bar_layout.addWidget(self.commit_hash_edit, TOP_BAR_FIELD_STRETCH)
+        top_bar_layout.addWidget(self.go_button)
+        self.go_button.clicked.connect(self.go_to_commit)
+        self.commit_hash_edit.returnPressed.connect(self.go_to_commit)
+        self.pending_navigation_oid: str | None = None
+        self.search_timer = QTimer(self)
+        self.search_timer.setSingleShot(True)
+        self.search_timer.setInterval(SEARCH_DEBOUNCE_MS)
+        self.search_timer.timeout.connect(self._request_search)
+        self.filter_edit.textChanged.connect(self._filter_edited)
+        self.filter_edit.returnPressed.connect(self._request_search)
+        self.clear_filter_button.clicked.connect(self.clear_filter)
+        self.filter_edit.installEventFilter(self)
+        self.find_action = QAction("Find in active text", self)
+        self.find_action.setShortcut(FIND_SHORTCUT)
+        self.find_action.triggered.connect(self.find_active_content)
+        self.addAction(self.find_action)
+        file_menu.addAction(self.find_action)
+        self.filter_action = QAction("Filter commit history", self)
+        self.filter_action.setShortcut("Ctrl+Shift+F")
+        self.filter_action.triggered.connect(self.focus_filter)
+        file_menu.addAction(self.filter_action)
+        self.clear_filter_action = QAction(RepositoryWindowText.FILTER_CLEAR.value, self)
+        self.clear_filter_action.triggered.connect(self.clear_filter)
+        file_menu.addAction(self.clear_filter_action)
+        self.file_history_resume_action = QAction("Continue reading file history", self)
+        self.file_history_resume_action.triggered.connect(self.file_history_resume_requested.emit)
+        self.file_history_resume_action.setEnabled(False)
+        # Only a file history window can continue reading; the button closes its top bar.
+        self.file_history_resume_button: QToolButton | None = None
+        if mode == "file_history":
+            self.file_history_resume_button = QToolButton()
+            self.file_history_resume_button.setDefaultAction(self.file_history_resume_action)
+            top_bar_layout.addWidget(self.file_history_resume_button)
+        filter_toolbar.addWidget(self.top_bar_row)
+        outer_splitter = QSplitter(Qt.Orientation.Horizontal)
+        self.outer_splitter = outer_splitter
+        outer_splitter.setChildrenCollapsible(False)
+        outer_splitter.setHandleWidth(LAYOUT_SPACING)
+        self.navigation_tree = QTreeWidget()
+        self.navigation_tree.setHeaderLabel(repository_display_name(context.repository_dir))
+        self.navigation_tree.setAccessibleName("Branches, tags and repositories")
+        self.navigation_tree.itemClicked.connect(self._navigate_reference)
+        self.navigation_tree.itemActivated.connect(self._navigate_reference)
+        self.navigation_tree.itemDoubleClicked.connect(self._activate_repository)
+        self.navigation_tree.itemExpanded.connect(lambda item: self._remember_stash_expansion(item, True))
+        self.navigation_tree.itemCollapsed.connect(lambda item: self._remember_stash_expansion(item, False))
+        self.navigation_tree.installEventFilter(self)
+        self.navigation_tree.viewport().installEventFilter(self)
+        self.navigation_tree.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.navigation_tree.customContextMenuRequested.connect(self.show_navigation_menu)
+        self.navigation_tree.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+        self.navigation_tree.header().setStretchLastSection(False)
+        self.navigation_tree.header().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
+        outer_splitter.addWidget(self.navigation_tree)
+        view_menu = self.menuBar().addMenu("View")
+        navigation_action = view_menu.addAction("Navigation")
+        navigation_action.setCheckable(True)
+        navigation_action.setChecked(True)
+        navigation_action.toggled.connect(self.navigation_tree.setVisible)
+        self.navigation_action = navigation_action
+        splitter = QSplitter(Qt.Orientation.Vertical)
+        self.detail_splitter = splitter
+        splitter.setHandleWidth(LAYOUT_SPACING)
+        splitter.setChildrenCollapsible(False)
+        outer_splitter.addWidget(splitter)
+        self.history_model = HistoryModel(clock)
+        self.parent_reference_availability = ""
+        self.commit_list = HistoryView()
+        self.commit_list.setModel(self.history_model)
+        self.history_avatar = HistoryAvatar(self.commit_list)
+        self.commit_list.setItemDelegateForColumn(MESSAGE_COLUMN, GraphDelegate(self.commit_list))
+        self.commit_list.setItemDelegateForColumn(AUTHOR_COLUMN, AuthorDelegate(self.history_avatar))
+        self.commit_list.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        self.commit_list.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
+        self.commit_list.setVerticalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
+        self.commit_list.setHorizontalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
+        self.commit_list.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.commit_list.setTabKeyNavigation(False)
+        self.commit_list.setAlternatingRowColors(True)
+        self.commit_list.setShowGrid(False)
+        self.commit_list.horizontalHeader().hide()
+        self.commit_list.verticalHeader().hide()
+        for column, width in enumerate(COLUMN_WIDTHS):
+            self.commit_list.setColumnWidth(column, width)
+        self.header_action = view_menu.addAction("Column headers")
+        self.header_action.setCheckable(True)
+        self.header_action.toggled.connect(self.commit_list.horizontalHeader().setVisible)
+        self.commit_list.setAccessibleName("Commit history")
+        self.commit_list.menu_requested.connect(self.show_history_menu)
+        self.commit_panel = CommitPanel(self.history_model.clock)
+        self.closed.connect(self.commit_panel.cancel_avatar)
+        self.closed.connect(self.history_avatar.close)
+        self.detail_edit = self.commit_panel.message_edit
+        self.commit_panel.navigation_requested.connect(self.navigation_requested.emit)
+        self.commit_panel.copy_requested.connect(self.copy_hash)
+        self.commit_panel.retry_requested.connect(self.detail_retry_requested.emit)
+        self.detail_tabs = QTabWidget()
+        self.detail_tabs.setAccessibleName("Commit detail tabs")
+        self.detail_tabs.tabBar().setAccessibleName("Commit, Diff and File tree")
+        self.detail_tabs.addTab(self.commit_panel, "Commit")
+        self.diff_panel = DiffPanel()
+        self.detail_tabs.addTab(self.diff_panel, "Diff")
+        self.file_tree_panel = FileTreePanel()
+        self.detail_tabs.addTab(self.file_tree_panel, "File tree")
+        if WindowCapability.FILE_MENU in self.capabilities:
+            self.diff_panel.file_tree.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+            self.diff_panel.file_tree.customContextMenuRequested.connect(self.show_file_menu)
+            self.file_tree_panel.file_tree.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+            self.file_tree_panel.file_tree.customContextMenuRequested.connect(lambda position: self.show_file_menu(position, FilePanel.TREE))
+            for tree in (self.diff_panel.file_tree, self.file_tree_panel.file_tree):
+                tree.installEventFilter(self)
+                tree.viewport().installEventFilter(self)
+        self.date_timer = QTimer(self)
+        self.date_timer.setInterval(RELATIVE_DATE_REFRESH_MS)
+        self.date_timer.timeout.connect(self.history_model.refresh_date)
+        self.date_timer.timeout.connect(self.commit_panel.refresh_date)
+        self.date_timer.timeout.connect(self.refresh_stash_date)
+        self.date_timer.start()
+        history_container = QWidget()
+        self.history_container = history_container
+        history_layout = QVBoxLayout(history_container)
+        self.parent_reference_label = WrappingLabel()
+        self.parent_reference_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.parent_reference_label.setWordWrap(True)
+        self.parent_reference_label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
+        self.parent_reference_label.hide()
+        history_layout.addWidget(self.parent_reference_label)
+        self.conflict_banner = QWidget()
+        self.conflict_banner.setObjectName("conflict_banner")
+        self.conflict_banner.setStyleSheet(CONFLICT_BANNER_STYLE)
+        conflict_layout = QHBoxLayout(self.conflict_banner)
+        self.conflict_label = QLabel()
+        self.conflict_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.conflict_label.setWordWrap(True)
+        conflict_layout.addWidget(self.conflict_label)
+        self.conflict_state: ConflictState | None = None
+        self.resolve_button = QPushButton("Resolve…")
+        self.resolve_button.setIcon(action_icon("resolve", self.devicePixelRatioF()))
+        self.resolve_button.setEnabled(False)
+        self.resolve_button.clicked.connect(lambda: self.resolve_requested.emit(self.conflict_state))
+        conflict_layout.addWidget(self.resolve_button)
+        # The same banner turns blue while a merge waits for its commit, so a merge with conflicts never shows two banners.
+        self.merge_banner_state: MergeBannerState | None = None
+        self.merge_banner_shown = False
+        self.merge_continue_button = QPushButton("Continue")
+        self.merge_continue_button.clicked.connect(self.merge_continue_requested)
+        self.merge_continue_button.hide()
+        conflict_layout.addWidget(self.merge_continue_button)
+        self.merge_abort_button = QPushButton("Abort")
+        self.merge_abort_button.clicked.connect(self.merge_abort_requested)
+        self.merge_abort_button.hide()
+        conflict_layout.addWidget(self.merge_abort_button)
+        self.conflict_banner.hide()
+        history_layout.addWidget(self.conflict_banner)
+        self.rebase_banner = QWidget()
+        self.rebase_banner.setObjectName("rebase_banner")
+        self.rebase_banner.setStyleSheet("QWidget#rebase_banner { background-color: orange; } QLabel { color: black; }")
+        rebase_layout = QHBoxLayout(self.rebase_banner)
+        self.rebase_label = QLabel("Rebase in progress")
+        self.rebase_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.rebase_label.setWordWrap(True)
+        rebase_layout.addWidget(self.rebase_label, 1)
+        self.rebase_button = QPushButton("Open rebase")
+        self.rebase_button.clicked.connect(self.rebase_requested)
+        rebase_layout.addWidget(self.rebase_button)
+        self.rebase_banner.hide()
+        history_layout.addWidget(self.rebase_banner)
+        self.replay_banner = QWidget()
+        self.replay_banner.setObjectName("replay_banner")
+        self.replay_banner.setStyleSheet("QWidget#replay_banner { background-color: orange; } QLabel { color: black; }")
+        replay_layout = QHBoxLayout(self.replay_banner)
+        self.replay_label = QLabel()
+        self.replay_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.replay_label.setWordWrap(True)
+        replay_layout.addWidget(self.replay_label, 1)
+        self.replay_refresh_button = QPushButton("Refresh")
+        self.replay_refresh_button.clicked.connect(self.replay_refresh_requested)
+        replay_layout.addWidget(self.replay_refresh_button)
+        self.replay_resolve_button = QPushButton("Resolve")
+        self.replay_resolve_button.clicked.connect(lambda: self.replay_resolve_requested.emit(self.replay_state))
+        self.replay_continue_button = QPushButton("Continue")
+        self.replay_continue_button.clicked.connect(lambda: self.replay_continue_requested.emit(self.replay_state))
+        self.replay_abort_button = QPushButton("Abort")
+        self.replay_abort_button.clicked.connect(lambda: self.replay_abort_requested.emit(self.replay_state))
+        for button in (self.replay_resolve_button, self.replay_continue_button, self.replay_abort_button):
+            replay_layout.addWidget(button)
+        self.replay_banner.hide()
+        history_layout.addWidget(self.replay_banner)
+        self.history_state_label = QLabel("No commits in this repository\nThis repository has no commits yet. Create one in your terminal, then use Refresh.")
+        self.history_state_label.setWordWrap(True)
+        self.history_state_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.history_state_label.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
+        self.history_state_label.setMaximumHeight(HISTORY_MIN_HEIGHT)
+        self.history_state_label.hide()
+        history_layout.addWidget(self.history_state_label)
+        history_layout.addWidget(self.commit_list)
+        splitter.addWidget(history_container)
+        splitter.addWidget(self.detail_tabs)
+        self.setCentralWidget(outer_splitter)
+        self.layout().setSizeConstraint(QLayout.SizeConstraint.SetNoConstraint)
+        splitter.setStretchFactor(0, HISTORY_STRETCH)
+        splitter.setStretchFactor(1, DETAIL_STRETCH)
+        outer_splitter.setStretchFactor(0, 0)
+        outer_splitter.setStretchFactor(1, 1)
+        outer_splitter.setSizes([NAVIGATION_WIDTH, REPOSITORY_WIDTH - NAVIGATION_WIDTH])
+        splitter.setSizes([HISTORY_STRETCH * HISTORY_MIN_HEIGHT, DETAIL_STRETCH * HISTORY_MIN_HEIGHT])
+        self.resolve_action: QAction | None = None
+        self.refresh_metrics()
+        self._set_tab_order()
+        if WindowCapability.MANAGE not in self.capabilities:
+            for action in (self.open_action, self.refresh_action, self.explorer_action, self.setting_action, self.terminal_action, self.redetect_action):
+                action.setEnabled(False)
+            self.terminal_button.setEnabled(False)
+            self.terminal_menu.setEnabled(False)
+        self.commit_list.selectionModel().currentRowChanged.connect(self._select_commit)
+        self.difftool_action: QAction | None = None
+        self.emoji_keyboard_action: QAction | None = None
+        if WindowCapability.MANAGE in self.capabilities:
+            tool_menu = self.menuBar().addMenu("Tools")
+            self.resolve_action = tool_menu.addAction(action_icon("resolve", self.devicePixelRatioF()), "Solve merge conflicts…")
+            self.resolve_action.setEnabled(False)
+            self.resolve_action.triggered.connect(lambda: self.resolve_requested.emit(self.conflict_state))
+            self.merge_recovery_action = tool_menu.addAction("Retained merge results…")
+            self.merge_recovery_action.triggered.connect(self.merge_recovery_requested.emit)
+            self.remote_action = tool_menu.addAction("Manage remotes")
+            self.remote_action.triggered.connect(self.remote_requested.emit)
+            self.difftool_action = tool_menu.addAction(FileAction.COMPARE.label)
+            self.difftool_action.setEnabled(False)
+            self.difftool_action.triggered.connect(self.difftool_requested.emit)
+            tool_menu.addSeparator()
+            self.emoji_keyboard_action = tool_menu.addAction(EMOJI_KEYBOARD_TITLE)
+            self.emoji_keyboard_action.triggered.connect(self.emoji_keyboard_requested.emit)
+            tool_menu.aboutToShow.connect(self.update_difftool_action)
+            self.diff_panel.file_tree.currentItemChanged.connect(self.update_difftool_action)
+        self.show_commit(commit)
+        self.splitter_by_key = {"diff_splitter_state": self.diff_panel.splitter, "tree_splitter_state": self.file_tree_panel.splitter}
+        if self.mode == "file_history":
+            self.splitter_by_key["file_history_splitter_state"] = self.detail_splitter
+        self.default_sizes_by_key: dict[str, list[int]] = {}
+        for key, reading_splitter in self.splitter_by_key.items():
+            if reading_splitter is self.detail_splitter:
+                self.default_sizes_by_key[key] = [HISTORY_STRETCH * HISTORY_MIN_HEIGHT, DETAIL_STRETCH * HISTORY_MIN_HEIGHT]
+            else:
+                self.default_sizes_by_key[key] = [DIFF_FILE_STRETCH * REPOSITORY_WIDTH, DIFF_TEXT_STRETCH * REPOSITORY_WIDTH]
+            reading_splitter.splitterMoved.connect(lambda position, index, key=key: self._request_splitter_preference(key))
+
+    def _apply_menu_button_look(self) -> None:
+        """Give Fetch, Open terminal, the repository button and the filter mode button the hover of the current theme, after a light/dark switch."""
+        style_sheet = terminal_button_style_sheet(QApplication.palette())
+        for button in (self.fetch_button, self.terminal_button, self.repository_button, self.filter_mode_button):
+            button.setStyleSheet(style_sheet)
+
+    def show_replay_state(self, state: ReplaySnapshot, *, busy: bool = False, abort_available: bool = False) -> None:
+        """Keep native replay pauses and uncertain external changes visible as literal text.
+
+        A conflict a successful read proved to carry no cherry-pick or revert trace is left to the conflict banner alone.
+        """
+        self.replay_state = state
+        # A conflict proven to carry no cherry-pick or revert trace (a stash pop or stash apply) is an ordinary conflict: the
+        # orange conflict banner already offers Resolve… and the toolbar Refresh, so this banner would only repeat them with
+        # Continue and Abort greyed. An unreadable state loses that proof and keeps the banner.
+        ordinary_conflict = state.kind != ReplayKind.ABSENT and not replay_may_be_present(state)
+        visible = ((state.kind != ReplayKind.ABSENT or bool(state.diagnostic)) and not ordinary_conflict
+                   and WindowCapability.MANAGE in self.capabilities and not self.context.is_bare)
+        label = state.kind.label
+        if state.unmerged_paths:
+            label += f" paused: {len(state.unmerged_paths)} conflict(s)."
+        elif state.kind != ReplayKind.ABSENT:
+            label += " paused."
+        if state.instruction_oids:
+            label += f" {len(state.instruction_oids)} instruction(s)."
+        if state.diagnostic:
+            label += " " + state.diagnostic
+        reason_by_name: dict[str, str] = {}
+        for action, button in ((ReplayAction.RESOLVE, self.replay_resolve_button), (ReplayAction.CONTINUE, self.replay_continue_button),
+                               (ReplayAction.ABORT, self.replay_abort_button)):
+            diagnostic = replay_action_diagnostic(state, action, busy=busy, abort_available=abort_available)
+            button.setEnabled(not diagnostic)
+            button.setToolTip(diagnostic)
+            reason_by_name[button.text()] = diagnostic
+        # A greyed button never leaves the user without a visible reason: its tooltip alone is rarely seen.
+        reason_text = unavailable_reason_text(reason_by_name, label)
+        self.replay_label.setText(label + ("\n" + reason_text if reason_text else ""))
+        self.replay_banner.setVisible(visible)
+
+    def show_rebase_state(self, state: RebaseSnapshot) -> None:
+        """Keep present or uncertain rebases discoverable without hiding conflict access."""
+        visible = state.state != "absent" and WindowCapability.MANAGE in self.capabilities and not self.context.is_bare
+        label = "Rebase in progress"
+        if not state.fresh or state.state == "unknown":
+            label = "Rebase state is unknown — Refresh to inspect"
+        self.rebase_label.setText(label)
+        self.rebase_banner.setVisible(visible)
+
+    def show_conflict_state(self, state: ConflictState, merge_state: MergeBannerState | None = None, *, busy: bool = False) -> None:
+        """Keep known conflicts visible when a refresh cannot establish current state, in one banner that turns blue during a merge.
+
+        A merge waiting for its commit, with no rebase or cherry-pick/revert paused beside it, shows the blue banner even
+        without conflicts, with Continue and Abort; the conflicts and their Resolve… stay in that same banner, and a greyed
+        button says why below the text. Any other conflict keeps the orange banner.
+        """
+        self.conflict_state = state
+        manage = WindowCapability.MANAGE in self.capabilities
+        enabled = bool(state.entries) and state.fresh and manage
+        self.resolve_button.setEnabled(enabled)
+        if self.resolve_action is not None:
+            self.resolve_action.setEnabled(enabled)
+        self.merge_banner_state = merge_state
+        merge_shown = merge_state is not None and merge_state.in_progress and manage and not self.context.is_bare
+        conflict_text = ""
+        if state.entries:
+            labels = []
+            for entry in state.entries[:CONFLICT_BANNER_PATH_LIMIT]:
+                labels.append(conflict_path_label(entry.path))
+            conflict_text = conflict_count_text(len(state.entries)) + ": " + ", ".join(labels)
+            if len(state.entries) > CONFLICT_BANNER_PATH_LIMIT:
+                conflict_text += ", …"
+        if not state.fresh:
+            conflict_text = (conflict_text + "\n" if state.entries else "") + "Conflict state is unknown. " + state.diagnostic
+        if merge_shown != self.merge_banner_shown:
+            # The style sheet is only replaced when the banner changes form: every worktree read lands here.
+            self.conflict_banner.setStyleSheet(MERGE_BANNER_STYLE if merge_shown else CONFLICT_BANNER_STYLE)
+            self.merge_banner_shown = merge_shown
+        self.merge_continue_button.setVisible(merge_shown)
+        self.merge_abort_button.setVisible(merge_shown)
+        if not merge_shown:
+            self.resolve_button.setVisible(True)
+            self.conflict_label.setText(conflict_text)
+            self.conflict_banner.setVisible((bool(state.entries) or not state.fresh) and manage)
+            return
+        self.resolve_button.setVisible(bool(state.entries) or not state.fresh)
+        reason_by_name: dict[str, str] = {}
+        for action, button in ((CONTINUE_ACTION, self.merge_continue_button), (ABORT_ACTION, self.merge_abort_button)):
+            reason = merge_action_reason(merge_state, action, conflict_count=len(state.entries), busy=busy)
+            button.setEnabled(not reason)
+            button.setToolTip(reason)
+            reason_by_name[button.text()] = reason
+        lines = [MERGE_IN_PROGRESS_TEXT]
+        if merge_state.cause:
+            lines.append(merge_state.cause)
+        if conflict_text:
+            lines.append(conflict_text)
+        shown_text = "\n".join(lines)
+        # A greyed button never leaves the user without a visible reason: its tooltip alone is rarely seen.
+        reason_text = unavailable_reason_text(reason_by_name, shown_text)
+        self.conflict_label.setText(shown_text + ("\n" + reason_text if reason_text else ""))
+        self.conflict_banner.setVisible(True)
+
+    def _request_splitter_preference(self, key: str) -> None:
+        """Save only the splitter the user moved, leaving unrelated window state alone."""
+        state = bytes(self.splitter_by_key[key].saveState().toBase64()).decode("ascii")
+        self.reading_preference_requested.emit({key: state})
+
+    def apply_reading_preference(self, value_by_key: dict[str, object]) -> None:
+        """Restore accepted presentation choices without emitting new save intentions."""
+        if "diff_show_entire_file" in value_by_key:
+            checkbox = self.diff_panel.full_context_checkbox
+            with QSignalBlocker(checkbox):
+                checkbox.setChecked(value_by_key["diff_show_entire_file"])
+        for key, splitter in self.splitter_by_key.items():
+            if key not in value_by_key:
+                continue
+            encoded = value_by_key[key]
+            orientation = splitter.orientation()
+            valid = True
+            with QSignalBlocker(splitter):
+                try:
+                    if encoded:
+                        valid = splitter.restoreState(QByteArray(base64.b64decode(encoded, validate=True)))
+                    else:
+                        splitter.setSizes(self.default_sizes_by_key[key])
+                    valid = valid and splitter.orientation() == orientation and all(size > 0 for size in splitter.sizes())
+                except (ValueError, TypeError, binascii.Error):
+                    valid = False
+                if not valid:
+                    splitter.setSizes(self.default_sizes_by_key[key])
+                splitter.setOrientation(orientation)
+                splitter.setChildrenCollapsible(False)
+            if not valid:
+                self.statusBar().showMessage(f"Unreadable layout ignored: {key}. Default proportions restored.")
+
+    def update_difftool_action(self) -> None:
+        """Enable comparison only for a current file in the main window's Diff panel."""
+        if self.difftool_action is not None:
+            entry = self.diff_panel.selected_entry
+            self.difftool_action.setEnabled(not self.is_closed and entry is not None and entry in self.diff_panel.entries
+                                            and self.commit is not None and entry.commit_oid == self.commit.oid)
+
+    def find_active_content(self) -> None:
+        """Search the visible reader while preserving the separate history filter."""
+        if self.detail_tabs.currentWidget() is self.diff_panel:
+            self.diff_panel.open_search()
+            return
+        if self.detail_tabs.currentWidget() is self.file_tree_panel:
+            self.file_tree_panel.open_search()
+            return
+        self.commit_panel.message_panel.open_search()
+
+    def show_status_failure(self, text: str) -> None:
+        """Show in the status bar, bold red until the next message, a failure the user must not miss there."""
+        self.statusBar().show_failure(text)
+
+    def show_file_menu(self, position: QPoint, panel_kind: FilePanel = FilePanel.DIFF) -> None:
+        """Capture a historical file or raw directory target before offering its valid actions."""
+        if WindowCapability.FILE_MENU not in self.capabilities:
+            return
+        panel = self.diff_panel if panel_kind == FilePanel.DIFF else self.file_tree_panel
+        tree = panel.file_tree
+        item = tree.itemAt(position)
+        if item is None:
+            return
+        entry = item.data(0, Qt.ItemDataRole.UserRole)
+        folder_path = item.data(0, FOLDER_PATH_ROLE)
+        if entry is None and not folder_path:
+            return
+        tree.setCurrentItem(item)
+        if self.file_menu is not None:
+            self.file_menu.close()
+            self.file_menu.deleteLater()
+        if self.commit is None:
+            return
+        kind = FileActionTargetKind.FOLDER if entry is None else FileActionTargetKind.FILE
+        selection = FileActionSelection(entry, self.commit.oid, panel_kind, panel.action_generation, kind, folder_path)
+        context = self.context
+        menu = FileActionMenu(selection, lambda chosen: self.context is context and self.file_menu is menu and self.file_action_is_current(chosen), self,
+                              self.file_restore_targets(selection), self.text_editor_reason,
+                              lambda chosen: self.remove_history_reason(chosen) if self.remove_history_reason is not None else "")
+        self.file_menu = menu
+        self.file_menu.history_requested.connect(lambda chosen: self.file_history_requested.emit(chosen.entry))
+        self.file_menu.compare_requested.connect(lambda chosen: self.difftool_requested.emit())
+        self.file_menu.filename_requested.connect(self.copy_filename)
+        self.file_menu.absolute_filename_requested.connect(lambda selection: self.copy_filename(selection, absolute=True))
+        self.file_menu.folder_requested.connect(self.file_folder_requested.emit)
+        self.file_menu.text_editor_requested.connect(self.file_text_editor_requested.emit)
+        self.file_menu.save_requested.connect(self.file_save_requested.emit)
+        self.file_menu.restore_requested.connect(self.file_restore_requested.emit)
+        self.file_menu.remove_history_requested.connect(self.remove_history_requested.emit)
+        self.file_menu.popup(tree.viewport().mapToGlobal(position))
+
+    def file_restore_targets(self, selection: FileActionSelection) -> list[FileRestoreTarget] | None:
+        """Always offer the viewed commit followed by its direct parents in commit-object order."""
+        if WindowCapability.RESTORE not in self.capabilities or self.commit is None or selection.kind == FileActionTargetKind.FOLDER:
+            return None
+        entry = selection.entry
+        unavailable = "This bare repository has no working tree." if self.context.is_bare else ""
+        subject, _separator, _body = self.commit.message.partition("\n")
+        current_unavailable = unavailable
+        if getattr(entry, "new_mode", getattr(entry, "mode", "")) == "160000":
+            current_unavailable = current_unavailable or "A submodule points to a commit, not a file blob."
+        elif getattr(entry, "new_path", True) is None:
+            current_unavailable = current_unavailable or "This file is absent from the selected commit."
+        targets = [FileRestoreTarget(self.commit.oid, "This commit " + self.commit.short_oid + " " + subject[:HISTORICAL_SUBJECT_LIMIT], self.commit.message, current_unavailable)]
+        parent_by_oid = {}
+        if self.commit_relation is not None and self.commit_relation.oid == self.commit.oid:
+            for parent in self.commit_relation.parents:
+                parent_by_oid[parent.oid] = parent
+        for parent_index, parent_oid in enumerate(self.commit.parent_oids):
+            ordinal = parent_index
+            letter = ""
+            alphabet_size = 26
+            first_letter_code = ord("A")
+            while True:
+                ordinal, remainder = divmod(ordinal, alphabet_size)
+                letter = chr(first_letter_code + remainder) + letter
+                if ordinal == 0:
+                    break
+                ordinal -= 1
+            label = "Parent" if len(self.commit.parent_oids) == 1 else "Parent " + letter
+            parent = parent_by_oid.get(parent_oid)
+            parent_unavailable = unavailable
+            message = parent.subject if parent is not None else "Loading commit…"
+            short_oid = parent.short_oid or parent.oid if parent is not None else parent_oid
+            if parent is None or not parent.available:
+                parent_unavailable = parent_unavailable or message
+            if getattr(entry, "parent_oid", None) == parent_oid:
+                if getattr(entry, "old_mode", "") == "160000":
+                    parent_unavailable = parent_unavailable or "A submodule points to a commit, not a file blob."
+                elif getattr(entry, "old_path", None) is None:
+                    parent_unavailable = parent_unavailable or "This file is absent from the parent commit."
+            targets.append(FileRestoreTarget(parent_oid, label + " " + short_oid + " " + message[:HISTORICAL_SUBJECT_LIMIT], message, parent_unavailable))
+        return targets
+
+    def show_commit_relation(self, relation: CommitRelation) -> None:
+        """Publish relatives to the commit panel and any still-current restoration menu."""
+        if self.commit is None or relation.oid != self.commit.oid:
+            return
+        self.commit_relation = relation
+        self.commit_panel.show_relation(relation)
+        if self.file_menu is not None and self.file_action_is_current(self.file_menu.selection):
+            self.file_menu.set_restore_targets(self.file_restore_targets(self.file_menu.selection) or [])
+
+    def file_action_is_current(self, selection: FileActionSelection) -> bool:
+        """Reject menus from a closed window, old commit, or superseded file selection."""
+        panel = self.diff_panel if selection.panel_kind == FilePanel.DIFF else self.file_tree_panel
+        if (self.is_closed or not self.isVisible() or WindowCapability.FILE_MENU not in self.capabilities or self.commit is None
+                or self.commit.oid != selection.commit_oid or panel.action_generation != selection.generation):
+            return False
+        item = panel.file_tree.currentItem()
+        if selection.kind == FileActionTargetKind.FOLDER:
+            return item is not None and item.data(0, Qt.ItemDataRole.UserRole) is None and item.data(0, FOLDER_PATH_ROLE) == selection.path()
+        return panel.selected_entry == selection.entry
+
+    def confirm_historical_restore(self, request: HistoricalRestoreRequest) -> bool:
+        """Name the exact source and local replacement, with cancellation as the default."""
+        dialog = QMessageBox(self)
+        prepare_message_box(dialog, RESTORE_SELECTED_VERSION_TITLE)
+        dialog.setTextFormat(Qt.TextFormat.PlainText)
+        dialog.setText("Replace the local file with the selected historical version?")
+        path_label = os.fsdecode(request.path)
+        if len(path_label) > HISTORICAL_PATH_LABEL_LIMIT:
+            path_label = path_label[:HISTORICAL_PATH_LABEL_LIMIT] + "… (full path in details)"
+        subject, _separator, _body = request.message.partition("\n")
+        dialog.setInformativeText("File: " + path_label + "\nCommit: " + request.commit_oid + "\n" + subject[:HISTORICAL_SUBJECT_LIMIT]
+                                  + "\n\nThe index and HEAD stay unchanged. The result remains Unstaged if it differs from the index. Existing local content, including an untracked file, will be replaced.")
+        dialog.setDetailedText("File: " + os.fsdecode(request.path) + "\nCommit: " + request.commit_oid + "\n\n" + request.message)
+        restore_button = dialog.addButton("Restore selected version", QMessageBox.ButtonRole.AcceptRole)
+        cancel_button = dialog.addButton("Cancel restoration", QMessageBox.ButtonRole.RejectRole)
+        dialog.setDefaultButton(cancel_button)
+        dialog.setEscapeButton(cancel_button)
+        dialog.exec()
+        accepted = dialog.clickedButton() == restore_button
+        dialog.deleteLater()
+        return accepted
+
+    def copy_filename(self, selection: FileActionSelection, *, absolute: bool = False) -> None:
+        """Copy the basename or absolute worktree filename, preserving historical spelling."""
+        if not self.file_action_is_current(selection):
+            return
+        try:
+            filename = worktree_filename(self.context, selection.path()) if absolute else selection.basename()
+            clipboard = self.clipboard if self.clipboard is not None else QApplication.clipboard()
+            clipboard.setText(filename)
+            if clipboard.text() != filename:
+                raise OSError("The clipboard did not retain the requested filename.")
+        except (OSError, RuntimeError, ValueError) as error:
+            diagnostic = Diagnostic("Copy filename", self.context.repository_dir, "", [], str(error)).prepare()
+            self.copy_dialog = ErrorDialog(diagnostic, self)
+            self.copy_dialog.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+            open_window_modal(self.copy_dialog)
+            return
+        self.statusBar().showMessage("Filename copied", COPY_CONFIRMATION_MS)
+
+    def go_to_commit(self) -> None:
+        """Resolve a literal hash in the captured history and reveal its row in the middle of the graph.
+
+        The commit is remembered as the one to center before any reveal, whether it is already shown, still to be read
+        or hidden by a filter that is cleared first. Near the top or the bottom of the history Qt stops the scroll at the
+        end of the graph, which leaves the commit as close to the middle as it can be.
+        """
+        if self.is_closed:
+            return
+        if self.search_pending or self.snapshot is None or not self.snapshot.complete:
+            self.statusBar().showMessage("History is still loading. Try again when reading finishes.")
+            return
+        prefix = typed_value(self.commit_hash_edit.text()).lower()
+        if len(prefix) < MINIMUM_COMMIT_PREFIX_LENGTH or any(character not in "0123456789abcdef" for character in prefix):
+            self.statusBar().showMessage(f"Enter a commit hash or at least {MINIMUM_COMMIT_PREFIX_LENGTH} hexadecimal characters.")
+            return
+        candidate_oid_set = set(self.snapshot.ordered_oids)
+        for commit in self.snapshot.explicit_commits:
+            candidate_oid_set.add(commit.oid)
+        if self.mode == "file_history":
+            candidate_oid_set.intersection_update(self.file_history_result.touching_oid_set if self.file_history_result is not None else set())
+        matching_oids = []
+        for oid in candidate_oid_set:
+            if oid.startswith(prefix):
+                matching_oids.append(oid)
+        if not matching_oids:
+            self.statusBar().showMessage("Commit not found in this file's history." if self.mode == "file_history" else "Commit not found in the captured history.")
+            return
+        if len(matching_oids) != 1:
+            self.statusBar().showMessage("This hash prefix matches several commits. Enter more characters.")
+            return
+        oid = matching_oids.pop()
+        self.centered_oid = oid
+        if self.commit is not None and self.commit.oid == oid and oid in self.history_model.row_by_oid:
+            self.reveal_commit(oid)
+            return
+        self.pending_oid = oid
+        self.anchor_oid = None
+        if self.filter_text and oid not in self.history_model.row_by_oid:
+            self.pending_navigation_oid = oid
+            self.clear_filter()
+            return
+        self.navigation_requested.emit(oid)
+
+    def focus_filter(self) -> None:
+        """Reveal and select the search field without changing its query."""
+        self.filter_edit.setFocus(Qt.FocusReason.ShortcutFocusReason)
+        self.filter_edit.selectAll()
+
+    def eventFilter(self, watched: QWidget, event: QEvent) -> bool:
+        """Activate repositories without folding their children, navigate to a reference on Enter, and handle focused search keys.
+
+        A repository row is checked first, so Enter on it opens the repository and never activates the row. On any other
+        row, Enter goes through the shared helper, since Qt for macOS does not activate a tree row on Enter.
+        """
+        for panel_name, panel_kind in (("diff_panel", FilePanel.DIFF), ("file_tree_panel", FilePanel.TREE)):
+            panel = getattr(self, panel_name, None)
+            if panel is None:
+                continue
+            tree = panel.file_tree
+            if watched is not tree and watched is not tree.viewport():
+                continue
+            keyboard_menu = event.type() == QEvent.Type.ContextMenu and event.reason() == QContextMenuEvent.Reason.Keyboard
+            if event.type() == QEvent.Type.KeyPress:
+                keyboard_menu = event.key() == Qt.Key.Key_Menu or (event.key() == Qt.Key.Key_F10 and event.modifiers() == Qt.KeyboardModifier.ShiftModifier)
+            if keyboard_menu:
+                item = tree.currentItem()
+                if item is not None:
+                    tree.scrollToItem(item)
+                    self.show_file_menu(tree.visualItemRect(item).center(), panel_kind)
+                return True
+        if watched is self.navigation_tree.viewport() and event.type() == QEvent.Type.MouseButtonDblClick and event.button() == Qt.MouseButton.LeftButton:
+            position = event.position().toPoint()
+            item = self.navigation_tree.itemAt(position)
+            if item is not None and item.data(NAVIGATION_COLUMN, REPOSITORY_ROLE) and self.navigation_tree.visualItemRect(item).contains(position):
+                self._activate_repository(item, NAVIGATION_COLUMN)
+                return True
+        if watched is self.navigation_tree and event.type() == QEvent.Type.KeyPress and event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter):
+            item = self.navigation_tree.currentItem()
+            if item is not None and item.data(NAVIGATION_COLUMN, REPOSITORY_ROLE):
+                self._activate_repository(item, NAVIGATION_COLUMN)
+                return True
+        if watched is self.navigation_tree and activate_current_row(self.navigation_tree, event):
+            return True
+        if watched is self.filter_edit and event.type() == QEvent.Type.KeyPress and event.key() == Qt.Key.Key_Escape:
+            self.clear_filter()
+            return True
+        return super().eventFilter(watched, event)
+
+    def _set_tab_order(self) -> None:
+        """Put visible toolbar actions before search and the historical reading panels."""
+        controls = []
+        for action in self.action_toolbar.actions():
+            control = self.action_toolbar.widgetForAction(action)
+            if control is not None:
+                control.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+                control.setAccessibleName(action.text() or control.accessibleName())
+                controls.append(control)
+        controls.extend((self.repository_button, self.filter_mode_button, self.filter_edit, self.clear_filter_button, self.commit_hash_edit, self.go_button, self.navigation_tree, self.commit_list,
+                         self.commit_panel.full_hash_button, self.commit_panel.short_hash_button, self.detail_edit,
+                         self.detail_tabs.tabBar(), self.diff_panel.file_tree, self.diff_panel.full_context_checkbox, self.diff_panel.reader_toolbar.find_button, self.diff_panel.diff_view,
+                         self.file_tree_panel.file_tree, self.file_tree_panel.reader_toolbar.find_button, self.file_tree_panel.text_edit))
+        for previous, following in pairwise(controls):
+            QWidget.setTabOrder(previous, following)
+
+    def refresh_metrics(self, available: QRect | None = None) -> None:
+        """Resize logical controls without touching OIDs, filters or user splitter ratios."""
+        for action, symbol in ((self.open_action, "repository"), (self.fetch_action, "fetch"), (self.push_action, "push"), (self.explorer_action, "folder"),
+                               (self.terminal_action, "terminal"), (self.setting_action, "settings"), (self.stash_action, "stash"),
+                               (self.stash_pop_action, "stash_pop")):
+            action.setIcon(action_icon(symbol, self.devicePixelRatioF()))
+        self.resolve_button.setIcon(action_icon("resolve", self.devicePixelRatioF()))
+        if self.resolve_action is not None:
+            self.resolve_action.setIcon(self.resolve_button.icon())
+        self.fetch_button.setIcon(self.fetch_action.icon())
+        self.terminal_button.setIcon(self.terminal_action.icon())
+        # Without an icon the painted arrow overlaps the last letter of the path.
+        self.repository_button.setIcon(action_icon("repository", self.devicePixelRatioF()))
+        self.refresh_action.setIcon(action_icon("refresh", self.devicePixelRatioF()))
+        self.commit_action.setIcon(action_icon("commit", self.devicePixelRatioF(), self.commit_action.property("change_state") or WorktreeColorState.UNKNOWN))
+        row_height = history_row_height(self.commit_list.fontMetrics().height())
+        keep_selection_visible(self.commit_list)
+        self.commit_list.verticalHeader().setDefaultSectionSize(row_height)
+        self.history_avatar.schedule_refresh()
+        for control in (self.repository_button, self.filter_mode_button, self.filter_edit, self.clear_filter_button, self.commit_hash_edit, self.go_button, self.terminal_button,
+                        self.resolve_button, self.merge_continue_button, self.merge_abort_button, self.rebase_button):
+            control.setMinimumHeight(control_height(control.fontMetrics().height()))
+        self.commit_panel.refresh_metrics()
+        self.diff_panel.refresh_metrics()
+        self.diff_panel.diff_view.refresh_metrics()
+        area = available if available is not None else self.screen().availableGeometry()
+        compact = area.width() < REPOSITORY_MIN_WIDTH + 2 * SPACING_MD or area.height() < REPOSITORY_MIN_HEIGHT + 2 * SPACING_MD
+        self.navigation_tree.setMinimumWidth(0 if compact else NAVIGATION_MIN_WIDTH)
+        self.history_container.setMinimumHeight(0 if compact else HISTORY_MIN_HEIGHT)
+        self.detail_tabs.setMinimumHeight(0 if compact else DETAIL_MIN_HEIGHT)
+        fit_window(self, REPOSITORY_MIN_WIDTH, REPOSITORY_MIN_HEIGHT, area)
+
+    def copy_hash(self, value: str, kind: CopiedHash) -> None:
+        """Copy the explicitly displayed value and report refusal without hiding the hash."""
+        if not value:
+            return
+        try:
+            clipboard = self.clipboard if self.clipboard is not None else QApplication.clipboard()
+            clipboard.setText(value)
+            if clipboard.text() != value:
+                raise OSError("The clipboard did not retain the requested hash.")
+        except (OSError, RuntimeError) as error:
+            diagnostic = Diagnostic("Copy hash", self.context.repository_dir, "", [], str(error)).prepare()
+            self.statusBar().showMessage("Could not copy the hash. Its value is still visible.")
+            self.copy_dialog = ErrorDialog(diagnostic, self)
+            self.copy_dialog.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+            open_window_modal(self.copy_dialog)
+            return
+        self.statusBar().showMessage(kind.copied_message, COPY_CONFIRMATION_MS)
+
+    def _request_push(self) -> None:
+        """Open the Push draft only from a live management window."""
+        if not self.is_closed and WindowCapability.MANAGE in self.capabilities:
+            self.push_requested.emit()
+
+    def _request_stash(self) -> None:
+        """Open stash creation only from a live writable repository window."""
+        if not self.is_closed and not self.context.is_bare and WindowCapability.MANAGE in self.capabilities:
+            self.stash_requested.emit()
+
+    def _request_stash_pop(self) -> None:
+        """Apply the latest stash only from a live writable repository window."""
+        if not self.is_closed and not self.context.is_bare and WindowCapability.MANAGE in self.capabilities:
+            self.stash_pop_requested.emit()
+
+    def _request_fetch(self) -> None:
+        """Emit the saved primary intention only when another Fetch is not already running."""
+        if not self.is_closed and WindowCapability.MANAGE in self.capabilities and not self.fetch_busy:
+            self.fetch_requested.emit()
+
+    def _request_fetch_choice(self, mode: FetchMode) -> None:
+        """Keep the menu's exact remote capture instead of retargeting from later widget labels."""
+        if WindowCapability.MANAGE not in self.capabilities or self.fetch_busy:
+            return
+        if mode == FetchMode.FETCH and not self.fetch_remote_name:
+            return
+        self.apply_fetch_preference({FETCH_DEFAULT_PREFERENCE_KEY: self.fetch_mode.value})
+        self.fetch_selection_requested.emit((mode, self.fetch_remote_name, self.fetch_snapshot))
+
+    def apply_fetch_preference(self, value_by_key: dict[str, object]) -> None:
+        """Reflect only the shared default that successfully reached preference storage, given as the saved word."""
+        if FETCH_DEFAULT_PREFERENCE_KEY not in value_by_key:
+            return
+        self.fetch_mode = fetch_mode_preference(value_by_key[FETCH_DEFAULT_PREFERENCE_KEY])
+        for mode, action in self.fetch_default_action_by_mode.items():
+            action.setChecked(mode == self.fetch_mode)
+            self.fetch_choice_action_by_mode[mode].setChecked(mode == self.fetch_mode)
+        self.fetch_button.setToolTip(self.fetch_mode.label)
+        self.fetch_button.setAccessibleDescription("Default action: " + self.fetch_mode.label)
+
+    def set_fetch_busy(self, busy: bool) -> None:
+        """Keep the independent arrow available while preventing a second primary submission."""
+        self.fetch_busy = busy
+        self.fetch_button.main_enabled = not busy and WindowCapability.MANAGE in self.capabilities
+        for action in self.fetch_choice_action_by_mode.values():
+            action.setEnabled(not busy)
+        for action in self.fetch_remote_menu.actions():
+            if action.data() is not None:
+                action.setEnabled(not busy)
+        if busy:
+            self.statusBar().showMessage("Fetch in progress…")
+
+    def show_fetch_choice(self, snapshot: object, remote_name: str, error: str = "") -> None:
+        """Present complete remote identities, including an explicit recovery for an empty list."""
+        self.fetch_snapshot, self.fetch_remote_name = snapshot, remote_name
+        self.fetch_remote_menu.clear()
+        fetch_action = self.fetch_choice_action_by_mode[FetchMode.FETCH]
+        fetch_action.setMenu(None)
+        names: list[str] = []
+        if snapshot is not None:
+            for name in sorted(snapshot.entry_by_name):
+                if snapshot.entry_by_name[name].active:
+                    names.append(name)
+        if remote_name:
+            self.statusBar().showMessage("Fetch from remote: " + remote_name)
+            fetch_action.setToolTip("Fetch from remote: " + remote_name)
+            fetch_action.setEnabled(not self.fetch_busy)
+            return
+        message = error or ("Choose a remote for Fetch." if names else "No active remotes. Use Manage remotes to add or activate a destination.")
+        self.statusBar().showMessage(message)
+        hint_action = self.fetch_remote_menu.addAction(message)
+        hint_action.setEnabled(False)
+        for name in names:
+            action = self.fetch_remote_menu.addAction(name.replace("&", "&&"))
+            action.setData(name)
+            action.setToolTip(name)
+            action.setEnabled(not self.fetch_busy)
+            action.triggered.connect(lambda checked=False, name=name, capture=snapshot: self.fetch_selection_requested.emit((FetchMode.FETCH, name, capture)))
+        self.fetch_remote_menu.addAction("Manage remotes", self.remote_requested.emit)
+        fetch_action.setMenu(self.fetch_remote_menu)
+        fetch_action.setEnabled(not self.fetch_busy)
+
+    def _branch_activated(self, index: int) -> None:
+        """Open only a real branch choice; browsing alone never changes HEAD."""
+        full_ref = self.branch_selector.itemData(index)
+        if full_ref and WindowCapability.MANAGE in self.capabilities:
+            self.checkout_requested.emit(full_ref)
+        if self.branch_selector.snapshot is not None:
+            self.branch_selector.populate(self.branch_selector.snapshot)
+
+    def _new_context_menu(self) -> QMenu:
+        """Create an empty right-click menu owned by the window, the way every right-click menu of the window is created.
+
+        The graph menu and the stash menu are built here so they cannot drift apart: same owner, so the same style,
+        font and colors, whatever panel they open from, like the file menus, which the window owns too.
+        """
+        return QMenu(self)
+
+    def show_history_menu(self, index: QModelIndex, global_position: QPoint) -> None:
+        """Select the clicked commit before attaching exact hashes to the menu actions."""
+        if self.history_menu is not None:
+            self.history_menu.close()
+            self.history_menu.deleteLater()
+        commit = None
+        if index.isValid():
+            self.commit_list.setCurrentRow(index.row())
+            commit = self.history_model.commits[index.row()]
+        menu = self._new_context_menu()
+        self.history_menu = menu
+        for kind in CopiedHash:
+            value = ""
+            if commit is not None:
+                value = commit.oid if kind == CopiedHash.FULL else commit.short_oid
+            action = menu.addAction(action_icon("copy_hash", self.devicePixelRatioF()), kind.copy_label)
+            action.setEnabled(bool(value))
+            action.triggered.connect(lambda checked=False, value=value, kind=kind: self.copy_hash(value, kind))
+        if commit is not None and WindowCapability.MANAGE in self.capabilities and not self.context.is_bare:
+            oid = commit.oid
+            snapshot = self.branch_selector.snapshot
+            menu.addSeparator()
+            cherry_pick = menu.addAction(action_icon("cherry_pick", self.devicePixelRatioF()), "Cherry-pick…")
+            cherry_pick.setData(oid)
+            # Replaying the current commit onto itself has nothing to apply; Revert of the current commit stays a normal use.
+            cherry_pick.setEnabled(snapshot is not None and bool(snapshot.head_oid) and oid != snapshot.head_oid)
+            cherry_pick.triggered.connect(lambda checked=False, oid=oid, snapshot=snapshot: self.replay_requested.emit(oid, ReplayKind.CHERRY_PICK, snapshot))
+            revert = menu.addAction(action_icon("revert", self.devicePixelRatioF()), "Revert…")
+            revert.setData(oid)
+            revert.setEnabled(snapshot is not None and bool(snapshot.head_oid))
+            revert.triggered.connect(lambda checked=False, oid=oid, snapshot=snapshot: self.replay_requested.emit(oid, ReplayKind.REVERT, snapshot))
+            rebase = menu.addAction(action_icon("rebase", self.devicePixelRatioF()), "Rebase current branch here interactively")
+            rebase.setData(oid)
+            rebase.setEnabled(snapshot is not None and bool(snapshot.head_oid))
+            rebase.triggered.connect(lambda checked=False, oid=oid, snapshot=snapshot: self.rebase_start_requested.emit(oid, snapshot))
+            checkout = menu.addAction(action_icon("checkout_commit", self.devicePixelRatioF()), "Checkout this commit…")
+            checkout.setData(oid)
+            checkout.setEnabled(snapshot is not None)
+            checkout.triggered.connect(lambda checked=False, oid=oid, snapshot=snapshot: self.checkout_commit_requested.emit(oid, snapshot))
+            create = menu.addAction(action_icon("branch_create", self.devicePixelRatioF()), "Create new branch here…")
+            create.setData(oid)
+            create.setEnabled(snapshot is not None)
+            create.triggered.connect(lambda checked=False, oid=oid, snapshot=snapshot: self.create_branch_requested.emit(oid, snapshot))
+            create_tag = menu.addAction("Create new tag here…")
+            create_tag.setIcon(action_icon("tag_create", self.devicePixelRatioF()))
+            create_tag.setData(oid)
+            create_tag.setEnabled(snapshot is not None)
+            create_tag.triggered.connect(lambda checked=False, oid=oid, snapshot=snapshot: self.create_tag_requested.emit(oid, snapshot))
+            reset = menu.addAction(action_icon("reset_current", self.devicePixelRatioF()), "Reset current branch to here…")
+            reset.setData(oid)
+            reset.setEnabled(snapshot is not None and bool(snapshot.head_ref) and bool(snapshot.head_oid))
+            reset.triggered.connect(lambda checked=False, oid=oid, snapshot=snapshot: self.reset_requested.emit(oid, snapshot))
+            move = menu.addAction(action_icon("reset_other", self.devicePixelRatioF()), "Reset another branch to here…")
+            move.setData(oid)
+            move.setEnabled(snapshot is not None)
+            move.triggered.connect(lambda checked=False, oid=oid, snapshot=snapshot: self.move_branch_requested.emit(oid, snapshot))
+            references = self.history_model.references_by_oid.get(oid, [])
+            tag_menu = menu.addMenu(action_icon("tag", self.devicePixelRatioF()), "Checkout tag…")
+            tag_delete_menu = menu.addMenu(action_icon("tag_delete", self.devicePixelRatioF()), "Delete tag…")
+            for reference in sorted(references, key=reference_label):
+                if reference.kind != ReferenceKind.TAGS or reference.symbolic_target or not reference.target_oid:
+                    continue
+                tag_action = tag_menu.addAction(action_icon("checkout_commit", self.devicePixelRatioF()), reference_label(reference))
+                tag_action.setData((reference.full_name, reference.target_oid))
+                tag_action.setToolTip("Checkout this tag at " + reference.target_oid)
+                tag_action.setEnabled(snapshot is not None)
+                tag_action.triggered.connect(lambda checked=False, target_oid=reference.target_oid, snapshot=snapshot: self.checkout_commit_requested.emit(target_oid, snapshot))
+                object_oid = snapshot.object_oid_by_name.get(reference.full_name, "") if snapshot is not None else ""
+                if not object_oid:
+                    continue
+                tag_delete = tag_delete_menu.addAction(action_icon("tag_delete", self.devicePixelRatioF()), reference_label(reference))
+                tag_delete.setData((reference.full_name, object_oid))
+                tag_delete.setEnabled(bool(object_oid))
+                tag_delete.triggered.connect(lambda checked=False, full_ref=reference.full_name, target_oid=object_oid, snapshot=snapshot: self.delete_tag_requested.emit(full_ref, target_oid, snapshot))
+            for submenu in (tag_menu, tag_delete_menu):
+                submenu.menuAction().setEnabled(snapshot is not None and bool(submenu.actions()))
+            branch_menu = menu.addMenu(action_icon("branch_checkout", self.devicePixelRatioF()), "Checkout branch…")
+            rename_menu = menu.addMenu(action_icon("branch_rename", self.devicePixelRatioF()), "Rename branch…")
+            delete_menu = menu.addMenu(action_icon("branch_delete", self.devicePixelRatioF()), "Delete branch…")
+            previous_branch_kind: ReferenceKind | None = None
+            for reference in sorted(references, key=lambda reference: (reference.kind != ReferenceKind.HEADS, reference_label(reference))):
+                if reference.kind not in (ReferenceKind.HEADS, ReferenceKind.REMOTES) or reference.symbolic_target or not reference.target_oid:
+                    continue
+                full_ref = reference.full_name
+                target_oid = reference.target_oid
+                if reference.kind == ReferenceKind.HEADS:
+                    rename = rename_menu.addAction(action_icon("branch_rename", self.devicePixelRatioF()), reference_label(reference))
+                    rename.setData((full_ref, target_oid))
+                    rename.setEnabled(snapshot is not None)
+                    rename.triggered.connect(lambda checked=False, full_ref=full_ref, target_oid=target_oid, snapshot=snapshot: self.rename_branch_requested.emit(full_ref, target_oid, snapshot))
+                if snapshot is None or full_ref != snapshot.head_ref:
+                    if previous_branch_kind == ReferenceKind.HEADS and reference.kind == ReferenceKind.REMOTES:
+                        branch_menu.addSeparator()
+                        delete_menu.addSeparator()
+                    previous_branch_kind = reference.kind
+                    branch_action = branch_menu.addAction(action_icon("branch_checkout", self.devicePixelRatioF()), reference_label(reference))
+                    branch_action.setData((full_ref, target_oid))
+                    branch_action.setEnabled(snapshot is not None)
+                    branch_action.triggered.connect(lambda checked=False, full_ref=full_ref, target_oid=target_oid, snapshot=snapshot: self.checkout_branch_requested.emit(full_ref, target_oid, snapshot))
+                    delete = delete_menu.addAction(action_icon("branch_delete", self.devicePixelRatioF()), reference_label(reference))
+                    delete.setData((full_ref, target_oid))
+                    delete.setEnabled(snapshot is not None)
+                    delete.triggered.connect(lambda checked=False, full_ref=full_ref, target_oid=target_oid, snapshot=snapshot: self.delete_branch_requested.emit(full_ref, target_oid, snapshot))
+            for submenu in (branch_menu, rename_menu, delete_menu):
+                submenu.menuAction().setEnabled(snapshot is not None and bool(submenu.actions()))
+        menu.popup(global_position)
+
+    def _filter_edited(self, text: str) -> None:
+        """Invalidate stale responses immediately while delaying the expensive scan."""
+        if text:
+            self.pending_navigation_oid = None
+        self.filter_text = text
+        self.filter_changed.emit(text)
+        self.search_timer.start()
+
+    def _request_search(self) -> None:
+        """Submit the latest text once for either Enter or the debounce timer."""
+        self.search_timer.stop()
+        self.search_requested.emit()
+
+    def show_filter_mode(self, mode: HistoryFilterMode) -> None:
+        """Show what the filter searches, on the mode button, its menu and the field, without starting a search.
+
+        Used when the window is built and when a repository or a walk back puts a mode back.
+        """
+        self.filter_mode = mode
+        self.filter_mode_button.setText(mode.label)
+        self.filter_mode_action_by_mode[mode].setChecked(True)
+        self.filter_edit.setPlaceholderText(mode.placeholder)
+        self.filter_edit.setAccessibleName(mode.field_name)
+
+    def choose_filter_mode(self, mode: HistoryFilterMode) -> None:
+        """Switch what the filter searches, and search the typed text again at once in the new mode.
+
+        With an empty field only the texts change: an empty filter shows every commit in both modes.
+        """
+        if mode == self.filter_mode:
+            return
+        self.show_filter_mode(mode)
+        if not self.filter_text:
+            return
+        self.filter_changed.emit(self.filter_text)
+        self._request_search()
+
+    def clear_filter(self) -> None:
+        """Restore all captured commits without waiting for the typing timer."""
+        self.filter_edit.clear()
+        self._request_search()
+
+    def begin_search(self) -> None:
+        """Keep old rows painted but prevent acting on a different query's results."""
+        self.search_pending = True
+        self.commit_list.setEnabled(False)
+        self.history_state_label.setText(RepositoryWindowText.FILTER_PREVIOUS.value)
+        self.history_state_label.show()
+        self.show_search_progress(0, 0)
+
+    def capture_anchor(self) -> ViewAnchor:
+        """Record the top row's partial pixel position and independent selection."""
+        selected_index = self.commit_list.currentIndex()
+        top_row = max(FIRST_ROW, self.commit_list.rowAt(0))
+        top_index = self.history_model.index(top_row, MESSAGE_COLUMN)
+        return ViewAnchor(selected_index.data(OID_ROLE), max(FIRST_ROW, selected_index.row()), top_index.data(OID_ROLE), top_row,
+                          self.commit_list.visualRect(top_index).top() if top_index.isValid() else 0,
+                          self.commit_list.horizontalScrollBar().value(), self.filter_edit.text(), self.filter_mode)
+
+    def clear_commit_selection(self) -> None:
+        """Keep remaining rows visible without substituting details for an absent selection."""
+        self.commit_list.clearSelection()
+        self.commit_list.setCurrentIndex(QModelIndex())
+        self.commit = None
+        self.pending_oid = None
+        self.commit_panel.clear_selection()
+        self.diff_panel.clear_selection()
+        self.file_tree_panel.clear_selection()
+
+    def restore_anchor(self, anchor: ViewAnchor) -> None:
+        """Restore OIDs first, then nearby surviving rows and bounded pixel offsets."""
+        count = self.history_model.rowCount()
+        if not count:
+            self.commit_list.clearSelection()
+            self.commit = None
+            self.commit_panel.clear_selection()
+            return
+        last_row = count - 1
+        selected_row = self.history_model.row_by_oid.get(anchor.selected_oid, min(anchor.selected_visible_index, last_row))
+        top_row = self.history_model.row_by_oid.get(anchor.top_oid, min(anchor.top_visible_index, last_row))
+        self.commit_list.setCurrentRow(selected_row)
+        self.commit_list.doItemsLayout()
+        self.commit_list.scrollTo(self.history_model.index(top_row, MESSAGE_COLUMN), QAbstractItemView.ScrollHint.PositionAtTop)
+        vertical_scrollbar = self.commit_list.verticalScrollBar()
+        vertical_scrollbar.setValue(vertical_scrollbar.value() - anchor.top_pixel_offset)
+        self.commit_list.horizontalScrollBar().setValue(anchor.horizontal_offset)
+        if anchor.selected_oid and anchor.selected_oid not in self.history_model.row_by_oid:
+            self.statusBar().showMessage(self.statusBar().currentMessage() + " — The selected commit is no longer visible.")
+
+    def show_search_progress(self, match_count: int, scanned_count: int) -> None:
+        """Announce provisional matches without claiming an empty final result."""
+        suffix = "es" if match_count != 1 else ""
+        scanned_suffix = "s" if scanned_count != 1 else ""
+        self.statusBar().showMessage(f"Searching… {match_count} match{suffix} found — {scanned_count} commit{scanned_suffix} scanned")
+
+    def show_matches(self, snapshot: HistorySnapshot, commits: list[Commit], text: str, selected_oid: str | None,
+                     visible_parent_oids_by_oid: dict[str, list[str]] | None = None) -> None:
+        """Replace rows and true parent boundaries in one synchronous publication."""
+        self.search_pending = False
+        self.filter_text = text
+        self.pending_oid = None
+        self.anchor_oid = None
+        # A new history already empties the rows and walks HEAD's ancestry in show_snapshot; doing it twice costs a
+        # walk of the whole history.
+        snapshot_replaced = self.snapshot is not snapshot
+        self.show_snapshot(snapshot)
+        if not snapshot_replaced:
+            self.history_model.reset_snapshot(snapshot)
+        self.history_model.visible_parent_oids_by_oid = visible_parent_oids_by_oid
+        self.commit_list.graph_width = 0
+        if text or visible_parent_oids_by_oid is not None:
+            self.history_model.visible_oid_set = set()
+            for commit in commits:
+                self.history_model.visible_oid_set.add(commit.oid)
+        self.pending_oid = selected_oid if any(commit.oid == selected_oid for commit in commits) else None
+        self.append_history(commits)
+        if self.mode == "file_history":
+            for group_index in range(self.navigation_tree.topLevelItemCount()):
+                group = self.navigation_tree.topLevelItem(group_index)
+                for item_index in range(group.childCount()):
+                    item = group.child(item_index)
+                    item.setDisabled(item.data(NAVIGATION_COLUMN, OID_ROLE) not in self.history_model.row_by_oid)
+        self.commit_list.setEnabled(True)
+        if not commits:
+            self.commit = None
+            self.commit_panel.clear_selection()
+        self.update_history_status()
+        if commits and selected_oid and selected_oid not in self.history_model.row_by_oid:
+            self.statusBar().showMessage(self.statusBar().currentMessage() + " — The selected commit is no longer visible.")
+        if self.pending_navigation_oid is not None:
+            oid = self.pending_navigation_oid
+            self.pending_navigation_oid = None
+            self.pending_oid = oid
+            self.navigation_requested.emit(oid)
+
+    def set_avatar_service(self, service: AvatarService) -> None:
+        """Share photos between selected details and visible history authors."""
+        self.commit_panel.set_avatar_service(service)
+        self.history_avatar.set_service(service)
+
+    def set_tool_busy(self, tool: str, busy: bool) -> None:
+        """Prevent duplicate activation only while the selected external tool is starting."""
+        if self.is_closed or WindowCapability.MANAGE not in self.capabilities:
+            return
+        if tool == "explorer":
+            self.explorer_action.setEnabled(not busy)
+        elif tool == "terminal":
+            self.terminal_busy = busy
+            self._update_terminal_action()
+
+    def bind_terminal_registry(self, registry: TerminalRegistry) -> None:
+        """Share inventory and persisted selection without sharing a repository directory."""
+        if self.is_closed or WindowCapability.MANAGE not in self.capabilities:
+            return
+        if self.terminal_registry is registry:
+            return
+        if self.terminal_registry is not None:
+            self.terminal_registry.changed.disconnect(self._show_terminals)
+        self.terminal_registry = registry
+        registry.changed.connect(self._show_terminals)
+        self._show_terminals()
+
+    def _show_terminals(self) -> None:
+        """Rebuild exclusive choices from the shared inventory with full-path tooltips."""
+        if self.terminal_registry is None:
+            return
+        self.terminal_menu.clear()
+        for action in self.terminal_choice_actions:
+            self.terminal_group.removeAction(action)
+            action.deleteLater()
+        self.terminal_choice_actions.clear()
+        for terminal in self.terminal_registry.terminals:
+            label = terminal.label + (" — Unavailable" if not terminal.available else "")
+            action = QAction(label, self)
+            action.setCheckable(True)
+            action.setChecked(terminal.id == self.terminal_registry.selected_id)
+            action.setEnabled(terminal.available)
+            action.setToolTip(f"{label}\n{terminal.program_filename}")
+            action.setData(terminal.id)
+            action.triggered.connect(lambda _checked, terminal_id=terminal.id: self._select_terminal(terminal_id))
+            self.terminal_group.addAction(action)
+            self.terminal_choice_actions.append(action)
+            self.terminal_menu.addAction(action)
+        if not self.terminal_choice_actions:
+            self.terminal_menu.addAction(RepositoryWindowText.TERMINAL_EMPTY.value).setEnabled(False)
+        self.terminal_menu.addSeparator()
+        self.terminal_menu.addAction(self.redetect_action)
+        self._update_terminal_action()
+        if self.terminal_registry.warning:
+            self.statusBar().showMessage(self.terminal_registry.warning)
+
+    def _update_terminal_action(self) -> None:
+        """Explain missing choices and disable only launch while keeping the arrow usable."""
+        selected = self.terminal_registry.selected() if self.terminal_registry is not None else None
+        enabled = selected is not None and not self.terminal_busy
+        self.terminal_action.setEnabled(enabled)
+        self.terminal_button.main_enabled = enabled
+        description = RepositoryWindowText.TERMINAL_EMPTY.value
+        if selected is not None:
+            description = f"{selected.label}{' — Unavailable' if not selected.available else ''}\n{selected.program_filename}"
+        self.terminal_button.setToolTip(description)
+        self.terminal_button.setAccessibleName(f"{RepositoryWindowText.TERMINAL.value} — {description}")
+        self.terminal_action.setToolTip(description)
+
+    def _select_terminal(self, terminal_id: str) -> None:
+        """Save a menu choice without launching and restore the old check on write failure."""
+        if self.is_closed or WindowCapability.MANAGE not in self.capabilities or self.terminal_registry is None:
+            return
+        try:
+            self.terminal_registry.select(terminal_id)
+        except OSError as error:
+            self._show_terminals()
+            self._show_terminal_error(str(error))
+
+    def _redetect_terminal(self) -> None:
+        """Refresh shared terminal choices only from a live management window."""
+        if not self.is_closed and WindowCapability.MANAGE in self.capabilities and self.terminal_registry is not None:
+            self.terminal_registry.redetect()
+
+    def _request_terminal(self) -> None:
+        """Capture the chosen descriptor at activation, leaving selection changes launch-free."""
+        if self.is_closed or WindowCapability.MANAGE not in self.capabilities or self.terminal_registry is None or not self.terminal_button.main_enabled:
+            return
+        selected = self.terminal_registry.selected()
+        if selected is None:
+            return
+        if not selected.available:
+            self._show_terminal_error(f"Terminal {selected.label} is unavailable: executable not found ({selected.program_filename}). Choose another terminal using the button arrow.")
+            return
+        self.terminal_requested.emit(selected)
+
+    def _show_terminal_error(self, cause: str) -> None:
+        """Present persistence or missing-tool errors with an explicit menu recovery action."""
+        diagnostic = Diagnostic("Choose terminal", self.context.repository_dir, "", [], cause).prepare()
+        dialog = ErrorDialog(diagnostic, self)
+        self.terminal_dialog = dialog
+        choose_button = QPushButton(SharedText.TERMINAL_CHOOSE.value, dialog)
+        dialog.layout().addWidget(choose_button)
+        choose_button.clicked.connect(dialog.accept)
+        choose_button.clicked.connect(lambda: self.terminal_menu.popup(self.terminal_button.mapToGlobal(self.terminal_button.rect().bottomLeft())))
+        dialog.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+        open_window_modal(dialog)
+
+    def show_recent_repositories(self, recent_dirs: list[str]) -> None:
+        """Keep the latest repository history for the switch list, which is rebuilt from it each time it opens."""
+        self.recent_dirs = list(recent_dirs)
+
+    def _show_repository_list(self) -> None:
+        """Open the switch list under the repository button: the current repository first, then the others, numbered.
+
+        Choosing a row asks for that repository in this window.
+        """
+        if self.repository_list_popup is None:
+            self.repository_list_popup = RepositoryListPopup(self)
+            self.repository_list_popup.repository_chosen.connect(self.repository_switch_requested.emit)
+        # No folder is checked here: a missing network drive would block the window. A missing folder is reported when chosen.
+        self.repository_list_popup.show_entries(repository_menu_dirs(self.context.repository_dir, self.recent_dirs), self.repository_button)
+
+    def show_repository(self, context: RepositoryContext, *, fresh: bool) -> None:
+        """Point the window at another repository, before its history is shown.
+
+        fresh is true for a repository chosen in the switch list: the window then starts as if just opened, with empty
+        filter and hash fields, the filter on messages, default groups in the left panel, no stash, submodule family, branch or notice of the
+        previous repository, an uncounted Commit action and the Commit tab. A walk into a submodule or back to its parent keeps
+        the fields and the left panel, since both belong to the same family. Either way the banners of the previous
+        repository, including the wait message shown while Git finished there, are hidden.
+        """
+        self.search_timer.stop()
+        self.context = context
+        self.repository_button.show_path(context.repository_dir)
+        self.show_parent_reference(None)
+        self.snapshot = None
+        self.commit_relation = None
+        self.pending_navigation_oid = None
+        self.centered_oid = None
+        self.setWindowTitle(repository_window_title(context.repository_dir))
+        self.navigation_tree.setHeaderLabel(repository_display_name(context.repository_dir))
+        self._apply_repository_capability()
+        self._hide_repository_banners()
+        if not fresh:
+            return
+        with QSignalBlocker(self.filter_edit):
+            self.filter_edit.clear()
+        self.filter_text = ""
+        self.show_filter_mode(HISTORY_FILTER_INITIAL_MODE)
+        self.commit_hash_edit.clear()
+        # show_snapshot draws the family it holds again: the previous repository's family must not reach the new one.
+        self.submodule_snapshot = None
+        self._clear_navigation_tree()
+        self.history_state_label.hide()
+        self.commit_action.setText(COMMIT_UNKNOWN_COUNT_LABEL)
+        self.commit_action.setIcon(action_icon("commit", self.devicePixelRatioF()))
+        # Without a state, the next count of the new working tree draws its own icon instead of keeping the old color.
+        self.commit_action.setProperty("change_state", None)
+        self.commit_action.setToolTip("")
+        self.status_notice_by_kind_by_worktree.clear()
+        # The remotes of the previous repository must never be offered, or fetched, in the new one: the Fetch menu
+        # reads the remotes again when it opens.
+        self.fetch_snapshot = None
+        self.fetch_remote_name = ""
+        self.fetch_remote_menu.clear()
+        self.fetch_choice_action_by_mode[FetchMode.FETCH].setMenu(None)
+        self.branch_selector.forget_references()
+        self.detail_tabs.setCurrentIndex(COMMIT_TAB_INDEX)
+
+    def _apply_repository_capability(self) -> None:
+        """Show or enable the actions allowed by the window's mode and by whether the displayed repository has a working tree.
+
+        A bare repository has no branch to check out, nothing to commit and nothing to stash; the window may show one
+        after another repository, so the state is computed again for each repository shown.
+        """
+        manage = WindowCapability.MANAGE in self.capabilities
+        working_tree = manage and not self.context.is_bare
+        self.branch_selector_action.setVisible(working_tree)
+        self.commit_action.setEnabled(working_tree)
+        self.stash_action.setEnabled(working_tree)
+        self.stash_pop_action.setEnabled(working_tree)
+
+    def _hide_repository_banners(self) -> None:
+        """Hide the conflict, rebase and Cherry-pick/Revert banners, and the wait message shown in the rebase banner.
+
+        They describe the repository the window showed; the new one publishes its own state once it has been read.
+        """
+        self.conflict_banner.hide()
+        self.rebase_banner.hide()
+        self.replay_banner.hide()
+        self.merge_continue_button.hide()
+        self.merge_abort_button.hide()
+        self.merge_banner_state = None
+        self.conflict_state = None
+        self.resolve_button.setEnabled(False)
+        if self.resolve_action is not None:
+            self.resolve_action.setEnabled(False)
+
+    def _clear_navigation_tree(self) -> None:
+        """Empty the left panel and forget its expanded groups, stashes and submodule tree, as in a window just opened.
+
+        show_snapshot copies the expanded state of the groups it finds by label, so the groups the previous repository
+        had expanded would otherwise stay expanded.
+        """
+        self.navigation_tree.clear()
+        self.stash_group = None
+        self.stash_group_user_expanded = None
+        self.stash_list = None
+        self.stash_list_context = None
+        self.shown_stash_entries = ()
+        self.submodule_item_by_key.clear()
+        self.submodule_expanded_by_key.clear()
+        self.submodule_selected_key = None
+        self.submodule_scroll = SUBMODULE_SCROLL_START
+
+    def show_commit(self, commit: Commit | None) -> None:
+        """Replace the visible data together so selection cannot mix two commits."""
+        self.commit = commit
+        state = "Bare repository — no working tree: " if self.context.is_bare else ""
+        self.statusBar().showMessage(state + self.context.repository_dir)
+        if commit is None:
+            self.commit_panel.clear_selection()
+            self.detail_edit.setPlainText("No commits in this repository\n\nThis repository has no commits yet. Create one in your terminal, then use Refresh.")
+            return
+        self.history_model.append_batch([commit])
+        self.commit_list.setCurrentRow(FIRST_ROW)
+        self.commit_panel.show_commit(commit)
+
+    def begin_history(self) -> None:
+        """Keep the previous view readable while an updated capture is prepared."""
+        self.pending_oid = self.commit.oid if self.commit is not None else None
+        top_index = self.commit_list.indexAt(self.commit_list.viewport().rect().topLeft())
+        self.anchor_oid = top_index.data(OID_ROLE)
+        self.statusBar().showMessage(("Bare repository — " if self.context.is_bare else "") + RepositoryWindowText.HISTORY_LOADING.value)
+
+    def _reference_icon_by_kind(self) -> dict[ReferenceKind, QIcon]:
+        """Return the icon of each reference group of the left panel, asked now of the style and of the packaged pictures.
+
+        Each icon is asked once, whatever the number of references. The branch icon is the icon theme's folder as Qt
+        draws it at the time of the call: Qt keeps that drawing, so an icon asked before the desktop changed theme keeps
+        the colors of the old theme. Breeze draws its folder in one color, dark in the light theme and light in the dark
+        one, so such an icon disappears on the new background.
+        """
+        branch_icon = self.style().standardIcon(QStyle.StandardPixmap.SP_DirLinkIcon)
+        tag_icon = action_icon("tag", self.devicePixelRatioF())
+        icon_by_kind: dict[ReferenceKind, QIcon] = {}
+        for kind in BRANCH_TREE_GROUP_KINDS:
+            icon_by_kind[kind] = tag_icon if kind == ReferenceKind.TAGS else branch_icon
+        return icon_by_kind
+
+    def _lay_reference_icons(self) -> None:
+        """Give the reference rows already in the left panel the icons of the theme in use, without building the tree again or reading Git."""
+        group_by_kind: dict[ReferenceKind, QTreeWidgetItem] = {}
+        for index in range(self.navigation_tree.topLevelItemCount()):
+            group = self.navigation_tree.topLevelItem(index)
+            for kind in BRANCH_TREE_GROUP_KINDS:
+                if group.text(NAVIGATION_COLUMN) == kind.label:
+                    group_by_kind[kind] = group
+        if not group_by_kind:
+            return
+        icon_by_kind = self._reference_icon_by_kind()
+        for kind, group in group_by_kind.items():
+            icon = icon_by_kind[kind]
+            for row in range(group.childCount()):
+                group.child(row).setIcon(NAVIGATION_COLUMN, icon)
+
+    def changeEvent(self, event: QEvent) -> None:
+        """Lay the left panel's reference icons again when the window's style changes, which Qt also announces after each desktop theme change.
+
+        Qt turns the theme notice it gives the window (light to dark, another icon theme) into a style notice, and only
+        once its icon loader follows the new theme, so the icons asked then are the new theme's.
+        """
+        super().changeEvent(event)
+        if event.type() == QEvent.Type.StyleChange:
+            self._lay_reference_icons()
+
+    def show_snapshot(self, snapshot: HistorySnapshot) -> None:
+        """Publish navigation with the accepted history generation, never mixed refs."""
+        snapshot_replaced = self.snapshot is not snapshot
+        if snapshot_replaced:
+            self.snapshot = snapshot
+            self.graph_index_complete = False
+            self.history_model.reset_snapshot(snapshot)
+            self.commit_list.graph_width = 0
+            self.commit_list.resize_subject()
+            expanded_by_label: dict[str, bool] = {}
+            for index in range(self.navigation_tree.topLevelItemCount()):
+                group = self.navigation_tree.topLevelItem(index)
+                expanded_by_label[group.text(NAVIGATION_COLUMN)] = group.isExpanded()
+            self._capture_submodule_tree()
+            # Clearing the tree destroys the Qt item behind the stash group; it is forgotten first so that nothing Qt
+            # reports about it while the tree empties can be taken for a choice of the user.
+            self.stash_group = None
+            self.navigation_tree.clear()
+            self.submodule_item_by_key.clear()
+            icon_by_kind = self._reference_icon_by_kind()
+            for kind in BRANCH_TREE_GROUP_KINDS:
+                label = kind.label
+                group = QTreeWidgetItem([label])
+                self.navigation_tree.addTopLevelItem(group)
+                icon = icon_by_kind[kind]
+                for reference in snapshot.references:
+                    if reference.kind != kind:
+                        continue
+                    name = reference_label(reference)
+                    if reference.is_head and kind != ReferenceKind.HEAD:
+                        name += " — HEAD"
+                    item = QTreeWidgetItem([name])
+                    font = item.font(NAVIGATION_COLUMN)
+                    font.setBold(reference.is_head and kind == ReferenceKind.HEADS)
+                    item.setFont(NAVIGATION_COLUMN, font)
+                    item.setToolTip(NAVIGATION_COLUMN, reference.full_name if reference.target_oid else reference.full_name + " — target is not a commit; navigation unavailable")
+                    item.setIcon(NAVIGATION_COLUMN, icon)
+                    item.setData(NAVIGATION_COLUMN, OID_ROLE, reference.target_oid)
+                    group.addChild(item)
+                group.setExpanded(expanded_by_label.get(label, kind not in (ReferenceKind.REMOTES, ReferenceKind.TAGS)))
+            if self.submodule_snapshot is not None:
+                self.show_submodules(self.submodule_snapshot)
+            if WindowCapability.MANAGE in self.capabilities:
+                self._add_stash_group()
+            if self.pending_oid is None:
+                self.pending_oid = snapshot.head_oid
+        self.update_history_status()
+        if snapshot.complete and not self.graph_index_complete:
+            self.graph_index_complete = True
+            # Replacing the rows just walked the ancestry of this complete history.
+            if not snapshot_replaced:
+                self.history_model.refresh_ancestry()
+            self.history_model.graph_layout.finish_index(set(snapshot.parent_oids_by_oid))
+            self.commit_list.viewport().update()
+
+    def show_submodules(self, snapshot: SubmoduleSnapshot) -> None:
+        """Render real directory hierarchy with only the active repository in bold."""
+        self._capture_submodule_tree()
+        self.submodule_snapshot = snapshot
+        group = None
+        for index in range(self.navigation_tree.topLevelItemCount()):
+            candidate = self.navigation_tree.topLevelItem(index)
+            if candidate.text(NAVIGATION_COLUMN) == "Submodules":
+                group = candidate
+                break
+        if group is None:
+            group = QTreeWidgetItem(["Submodules"])
+            # Stashes stays the last node, as in Git Extensions. Submodules goes in front of it rather than moving the
+            # stash item, which would lose its expanded state.
+            if self.stash_group is not None:
+                self.navigation_tree.insertTopLevelItem(self.navigation_tree.indexOfTopLevelItem(self.stash_group), group)
+            else:
+                self.navigation_tree.addTopLevelItem(group)
+        self.submodule_item_by_key["group"] = group
+        for item in self.submodule_item_by_key.values():
+            item.setHidden(True)
+        item_by_directory: dict[str, QTreeWidgetItem] = {}
+        for entry in snapshot.entries:
+            parent = item_by_directory.get(canonical_path(entry.parent_dir), group) if entry.parent_dir else group
+            parts = entry.path.split("/") if entry.availability != "invalid" else [entry.path]
+            directory = entry.parent_dir or snapshot.root_dir
+            for part in parts[:-1]:
+                directory = os.path.join(directory, part)
+                directory_key = canonical_path(directory)
+                if directory_key not in item_by_directory:
+                    folder = self.submodule_item_by_key.get(directory_key)
+                    if folder is None:
+                        folder = QTreeWidgetItem(parent, [part])
+                        self.submodule_item_by_key[directory_key] = folder
+                        folder.setExpanded(True)
+                    folder.setHidden(False)
+                    folder.setIcon(NAVIGATION_COLUMN, action_icon("folder", self.devicePixelRatioF()))
+                    item_by_directory[directory_key] = folder
+                parent = item_by_directory[directory_key]
+            state = (entry.branch or "no branch") if entry.availability == "initialized" else entry.availability
+            if entry.submodule.dirty:
+                state += " — Uncommitted changes"
+            elif entry.availability == "initialized" and entry.submodule.dirty is None:
+                state += " — Internal changes unknown"
+            entry_key = canonical_path(entry.repository_dir) if entry.repository_dir else "invalid:" + entry.section
+            item = self.submodule_item_by_key.get(entry_key)
+            if item is None:
+                item = QTreeWidgetItem(parent)
+                self.submodule_item_by_key[entry_key] = item
+                item.setExpanded(True)
+            item.setHidden(False)
+            item.setText(NAVIGATION_COLUMN, f"{os.path.basename(entry.repository_dir) if entry.repository_dir else entry.path} ({state})")
+            item.setToolTip(NAVIGATION_COLUMN, entry.repository_dir + ("\n" + entry.cause if entry.cause else "\nDouble-click or press Enter to open this repository."))
+            if entry.submodule.dirty:
+                item.setToolTip(NAVIGATION_COLUMN, item.toolTip(NAVIGATION_COLUMN) + "\n" + SUBMODULE_DIRTY_DESCRIPTION)
+            item.setIcon(NAVIGATION_COLUMN, action_icon("repository", self.devicePixelRatioF()))
+            item.setData(NAVIGATION_COLUMN, REPOSITORY_ROLE, entry.repository_dir or None)
+            font = item.font(NAVIGATION_COLUMN)
+            font.setBold(bool(entry.repository_dir) and canonical_path(entry.repository_dir) == canonical_path(self.context.repository_dir))
+            item.setFont(NAVIGATION_COLUMN, font)
+            if entry.repository_dir:
+                item_by_directory[canonical_path(entry.repository_dir)] = item
+        if snapshot.cause:
+            error = self.submodule_item_by_key.get("error")
+            if error is None:
+                error = QTreeWidgetItem(group, ["Submodule state is unknown. Review the details and refresh the repository."])
+                self.submodule_item_by_key["error"] = error
+            error.setHidden(False)
+            error.setToolTip(NAVIGATION_COLUMN, snapshot.cause)
+        elif len(snapshot.entries) == 1:
+            empty = self.submodule_item_by_key.get("empty")
+            if empty is None:
+                empty = QTreeWidgetItem(group, ["No submodules"])
+                self.submodule_item_by_key["empty"] = empty
+            empty.setHidden(False)
+            empty.setDisabled(True)
+            empty.setToolTip(NAVIGATION_COLUMN, "This repository has no declared submodules.")
+        group.setExpanded(True)
+        group.setHidden(False)
+        for key, item in self.submodule_item_by_key.items():
+            if key in self.submodule_expanded_by_key:
+                item.setExpanded(self.submodule_expanded_by_key[key])
+            if key == self.submodule_selected_key and not item.isHidden():
+                self.navigation_tree.setCurrentItem(item)
+        horizontal_offset, vertical_offset = self.submodule_scroll
+        self.navigation_tree.doItemsLayout()
+        self.navigation_tree.horizontalScrollBar().setValue(horizontal_offset)
+        self.navigation_tree.verticalScrollBar().setValue(vertical_offset)
+
+    def show_stashes(self, stash_list: StashList) -> None:
+        """Show the stashes read with the latest references, updating the Stashes group in place when it exists.
+
+        The group is expanded as soon as it holds a stash, unless the user expanded or collapsed it by hand in this window:
+        their choice then stays, even when stashes are added or removed. The list is taken as the one of the repository the window shows now, which is the only one its references are
+        published for.
+        """
+        self.stash_list = stash_list
+        self.stash_list_context = self.context
+        if self.stash_group is not None:
+            self._fill_stash_group()
+
+    def _add_stash_group(self) -> None:
+        """Create the Stashes group as the last node of the left panel, expanded when it holds a stash or as the user last left it.
+
+        The stashes often arrive after the group is created; filling it again then applies the same rule.
+        """
+        group = QTreeWidgetItem([STASH_GROUP_LABEL])
+        group.setIcon(NAVIGATION_COLUMN, action_icon("stash", self.devicePixelRatioF()))
+        self.navigation_tree.addTopLevelItem(group)
+        self.stash_group = group
+        self._fill_stash_group()
+
+    def _remember_stash_expansion(self, item: QTreeWidgetItem, expanded: bool) -> None:
+        """Keep the expanded state the user gives the Stashes group, so that later reads of the stashes do not undo it.
+
+        Changes the window applies itself, and those of any other group, are ignored.
+        """
+        if self.applying_stash_expansion or item is not self.stash_group:
+            return
+        self.stash_group_user_expanded = expanded
+
+    def _apply_stash_expansion(self) -> None:
+        """Expand the Stashes group as the user last chose in this window, or else exactly when it holds at least one stash."""
+        expanded = self.stash_group_user_expanded
+        if expanded is None:
+            expanded = self.stash_group.childCount() > 0
+        self.applying_stash_expansion = True
+        try:
+            self.stash_group.setExpanded(expanded)
+        finally:
+            self.applying_stash_expansion = False
+
+    def _fill_stash_group(self) -> None:
+        """Write one `stash@{N}: <message>` line per stash, newest first, and the count on the group when there is any.
+
+        The lines carry no commit or repository, so clicking one navigates nowhere. A list that could not be read leaves
+        the group empty, with the reason in its tooltip. The group is then expanded or collapsed, now that its count is known.
+        """
+        group = self.stash_group
+        group.takeChildren()
+        entries: tuple[StashEntry, ...] = ()
+        cause = ""
+        # After moving to a submodule or back to the parent, the tree is rebuilt for the new repository before its
+        # references, and so its stashes, are read: the list still held belongs to the previous repository and is not
+        # shown. The right list arrives with the reference read that follows.
+        if self.stash_list is not None and self.stash_list_context == self.context:
+            cause = self.stash_list.cause
+            if not cause:
+                entries = self.stash_list.entries
+        group.setToolTip(NAVIGATION_COLUMN, plain_text_tooltip([STASH_UNAVAILABLE_PREFIX + cause]) if cause else "")
+        group.setText(NAVIGATION_COLUMN, f"{STASH_GROUP_LABEL} ({len(entries)})" if entries else STASH_GROUP_LABEL)
+        icon = action_icon("stash", self.devicePixelRatioF())
+        for entry in entries:
+            item = QTreeWidgetItem([f"{stash_selector(entry.index)}: {entry.message}"])
+            item.setIcon(NAVIGATION_COLUMN, icon)
+            item.setToolTip(NAVIGATION_COLUMN, self._stash_tooltip(entry))
+            group.addChild(item)
+        self.shown_stash_entries = entries
+        self._apply_stash_expansion()
+
+    def shown_stash_entry(self, item: QTreeWidgetItem | None) -> StashEntry | None:
+        """Answer the stash a left-panel line shows, or None for any other line, the Stashes group itself included."""
+        if item is None or self.stash_group is None or item.parent() is not self.stash_group:
+            return None
+        position = self.stash_group.indexOfChild(item)
+        if position < 0 or position >= len(self.shown_stash_entries):
+            return None
+        return self.shown_stash_entries[position]
+
+    def show_navigation_menu(self, position: QPoint) -> None:
+        """Open the right-click menu of a stash line in the left panel; other lines have no menu.
+
+        Only a window that may write to the repository offers Drop stash. The menu carries the stash as it was read,
+        so the drop can check it is still the same stash before removing it.
+        """
+        if self.navigation_menu is not None:
+            self.navigation_menu.close()
+            self.navigation_menu.deleteLater()
+            self.navigation_menu = None
+        entry = self.shown_stash_entry(self.navigation_tree.itemAt(position))
+        if entry is None or WindowCapability.MANAGE not in self.capabilities or self.context.is_bare:
+            return
+        menu = self._new_context_menu()
+        self.navigation_menu = menu
+        # The icon gives the entry the icon column every other menu of the window has; without it the style lays the
+        # text alone in a box its minimum width makes much wider than the text.
+        drop = menu.addAction(action_icon("stash", self.devicePixelRatioF()), DROP_OPERATION_LABEL)
+        drop.triggered.connect(lambda checked=False, entry=entry: self.stash_drop_requested.emit(entry))
+        menu.popup(self.navigation_tree.viewport().mapToGlobal(position))
+
+    def refresh_stash_date(self) -> None:
+        """Rewrite the stash tooltips so their relative creation date keeps up with the clock, like the history dates."""
+        if self.stash_group is None:
+            return
+        for position, entry in enumerate(self.shown_stash_entries):
+            self.stash_group.child(position).setToolTip(NAVIGATION_COLUMN, self._stash_tooltip(entry))
+
+    def _stash_tooltip(self, entry: StashEntry) -> str:
+        """Describe one stash for its tooltip: full message, creation date, starting commit when known, and stash commit.
+
+        A stash message is free text and may look like markup, which a Qt tooltip would render; every line is escaped
+        so the tooltip shows exactly what Git stored.
+        """
+        lines = [entry.message, STASH_CREATED_PREFIX + format_commit_date(entry.timestamp, datetime.now(UTC))]
+        base_commit = stash_base_commit(entry.message)
+        if base_commit:
+            lines.append(STASH_BASE_COMMIT_PREFIX + base_commit)
+        lines.append(STASH_COMMIT_PREFIX + entry.oid)
+        return plain_text_tooltip(lines)
+
+    def _capture_submodule_tree(self) -> None:
+        """Remember expansion and native scroll positions before rebuilding references."""
+        if not self.submodule_item_by_key:
+            return
+        selected = self.navigation_tree.currentItem()
+        self.submodule_selected_key = None
+        for key, item in self.submodule_item_by_key.items():
+            self.submodule_expanded_by_key[key] = item.isExpanded()
+            if item is selected:
+                self.submodule_selected_key = key
+        self.submodule_scroll = (self.navigation_tree.horizontalScrollBar().value(), self.navigation_tree.verticalScrollBar().value())
+
+    def show_submodule_initializing(self, repository_dir: str) -> None:
+        """Mark the target while leaving the active repository and graph untouched."""
+        for item in self.submodule_item_by_key.values():
+            directory = item.data(NAVIGATION_COLUMN, REPOSITORY_ROLE)
+            if directory and canonical_path(directory) == canonical_path(repository_dir):
+                item.setText(NAVIGATION_COLUMN, os.path.basename(directory) + " (Initializing…)")
+                item.setToolTip(NAVIGATION_COLUMN, "Initializing submodule: " + directory)
+                return
+
+    def _activate_repository(self, item: QTreeWidgetItem, column: int) -> None:
+        """Request another declared repository so unavailable children can explain their refusal."""
+        directory = item.data(NAVIGATION_COLUMN, REPOSITORY_ROLE)
+        if self.mode != "repository" or item.isHidden() or item.isDisabled() or not directory or canonical_path(directory) == canonical_path(self.context.repository_dir):
+            return
+        self.repository_activated.emit(directory)
+
+    def append_history(self, commits: list[Commit]) -> None:
+        """Append a page while preserving selection and the visible scroll anchor."""
+        self.history_model.append_batch(commits)
+        for commit in commits:
+            row = self.history_model.graph_layout.row_by_oid[commit.oid]
+            self.commit_list.graph_width = max(self.commit_list.graph_width, row.lane_count * GRAPH_LANE_WIDTH)
+        self.commit_list.resize_subject()
+        if self.pending_oid in self.history_model.row_by_oid:
+            self.reveal_commit(self.pending_oid)
+            self.pending_oid = None
+        elif self.commit_list.currentIndex().isValid() is False and self.history_model.commits:
+            self.commit_list.setCurrentRow(FIRST_ROW)
+        if self.anchor_oid in self.history_model.row_by_oid:
+            self.commit_list.scrollTo(self.history_model.index(self.history_model.row_by_oid[self.anchor_oid], MESSAGE_COLUMN), QAbstractItemView.ScrollHint.PositionAtTop)
+            self.anchor_oid = None
+        self.update_history_status()
+
+    def show_status_notice(self, worktree_key: WorktreeKey, kind: str, notice: str) -> None:
+        """Keep a notice of one kind at the end of the history status line of one working tree, and show it now when that tree is displayed.
+
+        A plain status message would be replaced by the next history line ("Loading more commits…", then the count of
+        loaded commits) as soon as it is written. Following the history line, the notice stays readable once loading
+        ends; a message written outside the history line hides it only until the next history line. An empty notice
+        removes the notice of that kind alone.
+        """
+        notice_by_kind = self.status_notice_by_kind_by_worktree.setdefault(worktree_key, {})
+        if notice:
+            notice_by_kind[kind] = notice
+        else:
+            notice_by_kind.pop(kind, None)
+        if not notice_by_kind:
+            del self.status_notice_by_kind_by_worktree[worktree_key]
+        self.update_history_status()
+
+    def _show_history_status(self, text: str) -> None:
+        """Write one history status line, followed by the notices kept for the displayed working tree, in their fixed order."""
+        notice_by_kind = self.status_notice_by_kind_by_worktree.get(WorktreeKey.from_context(self.context), {})
+        for kind in STATUS_NOTICE_KINDS:
+            if kind in notice_by_kind:
+                text += STATUS_PART_SEPARATOR + notice_by_kind[kind]
+        self.statusBar().showMessage(text)
+
+    def update_history_status(self) -> None:
+        """Distinguish loaded rows, a finished empty repository and incomplete history, and keep the window's notice at the end of the line."""
+        self.update_parent_reference()
+        snapshot = self.snapshot
+        if snapshot is None:
+            return
+        if self.search_pending:
+            return
+        loaded = self.history_model.rowCount()
+        suffix = "s" if loaded != 1 else ""
+        if self.mode == "file_history" and self.file_history_result is not None:
+            result = self.file_history_result
+            text = f"{loaded} file history commit{suffix}"
+            if self.filter_text:
+                text += f" matching '{self.filter_text}'"
+            if not result.complete:
+                text += f" — Incomplete history — {result.error or 'Continue reading to resume'}"
+            self.file_history_resume_action.setEnabled(not result.complete and not snapshot.error and not snapshot.shallow)
+            self._show_history_status(text)
+            self.history_state_label.setText("No matching file history commits. Change the filter or continue reading.")
+            self.history_state_label.setVisible(loaded == 0)
+            return
+        if self.filter_text:
+            suffix = "s" if loaded != 1 else ""
+            self._show_history_status(f"{loaded} matching commit{suffix} — The filter hides commits that do not match")
+            self.history_state_label.setText(f"No matching commits\n{self.filter_mode.no_match_text} '{self.filter_text}'. Change the search or clear the filter.")
+            self.history_state_label.setVisible(loaded == 0)
+            return
+        self.history_state_label.setText("No commits in this repository\nThis repository has no commits yet. Create one in your terminal, then use Refresh.")
+        self.history_state_label.setVisible(snapshot.complete and not snapshot.ordered_oids and not snapshot.error)
+        if snapshot.error:
+            text = f"Incomplete history — {loaded} commit{suffix} loaded — {snapshot.error}"
+        elif not snapshot.complete or loaded < len(snapshot.ordered_oids):
+            text = RepositoryWindowText.HISTORY_LOADING.value if loaded == 0 else f"Loading more commits… {loaded} commit{suffix} loaded"
+        elif loaded == 0:
+            text = RepositoryWindowText.REPOSITORY_EMPTY.value
+            self.commit = None
+            self.commit_panel.clear_selection()
+        else:
+            text = f"{loaded} commit{suffix} loaded"
+        if snapshot.shallow:
+            text += " — Shallow repository: parents beyond the boundary are unavailable"
+        self._show_history_status(("Bare repository — " if self.context.is_bare else "") + text)
+
+    def show_parent_reference(self, oid: str | None, availability: str = "", cause: str = "") -> None:
+        """Expose the committed parent source separately from history loading and selection."""
+        self.parent_reference_availability = availability
+        self.history_model.set_committed_parent(oid if availability == "Available" else None)
+        self.parent_reference_label.setToolTip(cause)
+        self.update_parent_reference()
+
+    def update_parent_reference(self) -> None:
+        """Keep absent, unknown and filtered references explicit without a substitute arrow."""
+        oid = self.history_model.committed_parent_oid
+        text = ""
+        if self.parent_reference_availability == "Unavailable":
+            text = "The committed parent reference could not be read. Refresh the repository to retry."
+        elif self.parent_reference_availability in ("Parent has no commit", "No committed gitlink"):
+            text = "The parent repository has no committed submodule reference."
+        elif oid is not None:
+            text = f"Committed in parent: {oid}" if oid in self.history_model.row_by_oid else f"Parent commit reference: {oid}. This commit is not in the current view."
+        self.parent_reference_label.setText(text)
+        self.parent_reference_label.setAccessibleDescription(text)
+        self.parent_reference_label.setVisible(bool(text))
+
+    def scroll_history_to_top(self) -> None:
+        """Show the top of the graph, where an operation that adds commits or moves a branch puts its result; the selection stays."""
+        self.anchor_oid = None
+        self.commit_list.scrollToTop()
+
+    def reveal_commit(self, oid: str) -> None:
+        """Select a known OID or remember it until its metadata page arrives.
+
+        The commit Go to commit hash asked for is scrolled to the middle of the graph, then forgotten; any other commit is
+        only scrolled into view, so a row already on screen leaves the graph where it is.
+        """
+        row = self.history_model.row_by_oid.get(oid)
+        if row is None:
+            self.pending_oid = oid
+            return
+        self.pending_oid = None
+        self.commit_list.setCurrentRow(row)
+        scroll_hint = QAbstractItemView.ScrollHint.EnsureVisible
+        if oid == self.centered_oid:
+            scroll_hint = QAbstractItemView.ScrollHint.PositionAtCenter
+            self.centered_oid = None
+        self.commit_list.scrollTo(self.history_model.index(row, MESSAGE_COLUMN), scroll_hint)
+
+    def _navigate_reference(self, item: QTreeWidgetItem, column: int) -> None:
+        """Emit only navigable commit targets, leaving groups and blob tags inert."""
+        if self.is_closed:
+            return
+        oid = item.data(NAVIGATION_COLUMN, OID_ROLE)
+        if self.mode == "file_history" and (self.search_pending or oid not in self.history_model.row_by_oid):
+            return
+        if oid:
+            self.navigation_requested.emit(oid)
+
+    def showEvent(self, event: QShowEvent) -> None:
+        """Centre the window on the GitPane window it was opened from at its first show; later shows keep the user's place.
+
+        The window it was opened from is let go afterwards: the Open repository window is destroyed once the repository
+        opens, and a reference kept here would leave a Python object pointing at a deleted window.
+        """
+        super().showEvent(event)
+        if self.centred:
+            return
+        self.centred = True
+        centre_on_placement_anchor(self, self.placement_anchor)
+        self.placement_anchor = None
+
+    def closeEvent(self, event: QCloseEvent) -> None:
+        """Tell the shutdown controller to invalidate work for this window only."""
+        if self.is_closed:
+            event.accept()
+            return
+        self.is_closed = True
+        self.search_timer.stop()
+        self.date_timer.stop()
+        if self.terminal_registry is not None:
+            self.terminal_registry.changed.disconnect(self._show_terminals)
+            self.terminal_registry = None
+        self.closed.emit()
+        super().closeEvent(event)
+
+    def _select_commit(self, index: QModelIndex, previous: QModelIndex | None = None) -> None:
+        """Render and publish selection without performing repository work."""
+        if not index.isValid():
+            self.commit_panel.clear_selection()
+            return
+        self.commit = self.history_model.commits[index.row()]
+        self.commit_panel.show_loading(self.commit.oid, self.commit.short_oid)
+        self.commit_selected.emit(self.commit.oid)