gitpane 1.0.0__py3-none-any.whl

gitpane/ui/transport/remote_dialog.py

@@ -0,0 +1,943 @@
+"""Edit remote drafts apart from the repository, publishing them only on an explicit Save."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, replace
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QRect, QSignalBlocker, Qt, Signal
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QDialog,
+    QFileDialog,
+    QFormLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QLayout,
+    QLineEdit,
+    QMessageBox,
+    QPushButton,
+    QScrollArea,
+    QStyle,
+    QTabWidget,
+    QTreeWidget,
+    QTreeWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+from shiboken6 import isValid
+
+from gitpane.config import LOCAL_PREFIX, SPACING_MD, SPACING_SM, keep_selection_visible
+from gitpane.operation.diagnostic import SensitiveTextFilter
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.process.process_runner import ProcessStatus
+from gitpane.text.typed_path import session_typed_path, typed_path_value, typed_start_dir
+from gitpane.text.typed_text import typed_value
+from gitpane.transport.remote import TRACKING_LABEL_BY_FIELD, RemoteChange, url_edit_reason, validate_name
+from gitpane.transport.remote_config import INACTIVE_REMOTE_SECTION, MERGE_TRACKING_FIELD, REMOTE_TRACKING_FIELD, RemoteValue, field_values, tracking_values
+from gitpane.ui.look.action_icon import action_icon
+from gitpane.ui.widget.dialog_layout import apply_left_aligned_form, fit_form
+from gitpane.ui.widget.long_text import WrappingLabel
+from gitpane.ui.widget.wheel_safe_drop_down import UrlSelector
+from gitpane.ui.window_control.dialog_modality import open_window_modal, prepare_message_box
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtGui import QIcon
+
+    from gitpane.transport.remote import RemoteOutcome
+    from gitpane.transport.remote_config import RemoteSnapshot
+
+REMOTE_DIALOG_WIDTH = 960
+REMOTE_DIALOG_HEIGHT = 520
+REMOVE_REMOTE_TITLE = "Remove remote"
+REMOTE_NAME_COLUMN = 0
+TRACKING_NAME_COLUMN = 0
+TRACKING_REMOTE_COLUMN = 1
+TRACKING_MERGE_COLUMN = 2
+REMOTE_LIST_STRETCH = 1
+REMOTE_DETAILS_STRETCH = 4
+
+
+@dataclass
+class RemoteDraft:
+    """Retain each edited URL independently while changing target or selected occurrence."""
+
+    name: str = ""
+    fetch_by_value: dict[RemoteValue | None, str] = field(default_factory=dict)
+    push_by_value: dict[RemoteValue | None, str] = field(default_factory=dict)
+    fetch_selected: RemoteValue | None = None
+    push_selected: RemoteValue | None = None
+    separate: bool = False
+    local_override: bool = False
+
+
+@dataclass
+class TrackingDraft:
+    """Keep a branch editor bound to its own capture while navigating other rows."""
+
+    snapshot: RemoteSnapshot
+    remote: str = ""
+    merge: str = ""
+    remote_selected: RemoteValue | None = None
+    merge_selected: RemoteValue | None = None
+    remote_by_value: dict[RemoteValue | None, str] = field(default_factory=dict)
+    merge_by_value: dict[RemoteValue | None, str] = field(default_factory=dict)
+    stale: bool = False
+
+
+class RemoteDialog(QDialog):
+    """Present captured repositories and retain unsaved details per selected remote."""
+
+    save_requested = Signal(object)
+    active_requested = Signal(object)
+    remove_requested = Signal(object)
+    tracking_requested = Signal(object)
+    tracking_reload_requested = Signal()
+
+    def __init__(self, session_id: str, parent: QWidget | None = None, *, typed_path: Callable[[str], str] = session_typed_path) -> None:
+        """Build a scrollable editor with permanent Save and Close controls.
+
+        ``typed_path`` reads ``~`` in the Url and Push Url fields where that is the usage; the tests hand their own
+        system and home folder.
+        """
+        super().__init__(parent)
+        self.typed_path = typed_path
+        self.session_id = session_id
+        self.snapshot: RemoteSnapshot | None = None
+        self.selected_name: str | None = None
+        self.draft_by_name: dict[str | None, RemoteDraft] = {}
+        self.tracking_draft_by_ref: dict[str, TrackingDraft] = {}
+        self.selected_full_ref: str | None = None
+        self.loading = False
+        self.tracking_loading = False
+        self.uncertain = False
+        self.text_filter = SensitiveTextFilter()
+        self.closed = False
+        self.busy = False
+        self.read_failed = False
+        self.request_kind = ""
+        self.request: tuple | None = None
+        self.removal_dialog: QMessageBox | None = None
+        self.return_focus = parent.focusWidget() if parent else None
+        self.setWindowTitle("Remote repositories")
+        self.resize(REMOTE_DIALOG_WIDTH, REMOTE_DIALOG_HEIGHT)
+        layout = QVBoxLayout(self)
+        layout.setSizeConstraint(QLayout.SizeConstraint.SetNoConstraint)
+        self.scroll_area = QScrollArea()
+        self.scroll_area.setWidgetResizable(True)
+        remote_page = QWidget()
+        body = QHBoxLayout(remote_page)
+        body.setSpacing(SPACING_SM)
+        self.remote_tree = QTreeWidget()
+        self.remote_tree.setHeaderHidden(True)
+        self.remote_tree.setAccessibleName("Remote repositories")
+        body.addWidget(self.remote_tree, REMOTE_LIST_STRETCH)
+        tools = QVBoxLayout()
+        density = self.devicePixelRatioF()
+        self.add_button = self._tool_button("Add remote", action_icon("add_remote", density))
+        self.remove_button = self._tool_button("Remove remote", action_icon("remove_remote", density))
+        self.activate_button = self._tool_button("Activate remote", self.style().standardIcon(QStyle.StandardPixmap.SP_ArrowUp))
+        self.deactivate_button = self._tool_button("Deactivate remote", self.style().standardIcon(QStyle.StandardPixmap.SP_ArrowDown))
+        for button in (self.add_button, self.remove_button, self.activate_button, self.deactivate_button):
+            tools.addWidget(button)
+        tools.addStretch()
+        body.addLayout(tools)
+        self.details = QGroupBox("Edit Remote Details")
+        details_layout = QVBoxLayout(self.details)
+        content = QWidget()
+        form = QFormLayout(content)
+        form.setContentsMargins(0, 0, 0, 0)
+        apply_left_aligned_form(form)
+        self.url_edit = QLineEdit()
+        self.url_edit.setAccessibleName("Url")
+        self.url_label = self._label("Url")
+        self.url_label.setBuddy(self.url_edit)
+        url_row = QHBoxLayout()
+        url_row.addWidget(self.url_edit)
+        self.browse_button = QPushButton("Browse")
+        self.browse_button.setAccessibleName("Browse fetch URL")
+        url_row.addWidget(self.browse_button)
+        form.addRow(self.url_label, url_row)
+        self.name_edit = QLineEdit()
+        self.name_edit.setAccessibleName("Name")
+        name_label = self._label("Name")
+        name_label.setBuddy(self.name_edit)
+        form.addRow(name_label, self.name_edit)
+        self.separate_push_checkbox = QCheckBox("Separate Push Url")
+        form.addRow(self.separate_push_checkbox)
+        self.push_url_edit = QLineEdit()
+        self.push_url_edit.setAccessibleName("Push Url")
+        self.push_label = self._label("Push Url")
+        self.push_label.setBuddy(self.push_url_edit)
+        self.push_row = QWidget()
+        push_layout = QHBoxLayout(self.push_row)
+        push_layout.setContentsMargins(0, 0, 0, 0)
+        push_layout.addWidget(self.push_url_edit)
+        self.push_browse_button = QPushButton("Browse")
+        self.push_browse_button.setAccessibleName("Browse push URL")
+        self.push_browse_button.setAutoDefault(False)
+        push_layout.addWidget(self.push_browse_button)
+        form.addRow(self.push_label, self.push_row)
+        self.fetch_selector = UrlSelector()
+        self.fetch_selector.setAccessibleName("Configured fetch URL to edit")
+        self.push_selector = UrlSelector()
+        self.push_selector.setAccessibleName("Configured push URL to edit")
+        self.fetch_selector_label = self._label("Configured Fetch URLs")
+        self.fetch_selector_label.setBuddy(self.fetch_selector)
+        self.push_selector_label = self._label("Configured Push URLs")
+        self.push_selector_label.setBuddy(self.push_selector)
+        form.addRow(self.fetch_selector_label, self.fetch_selector)
+        form.addRow(self.push_selector_label, self.push_selector)
+        self.local_override_checkbox = QCheckBox("Create local Push URL override")
+        form.addRow(self.local_override_checkbox)
+        self.edit_reason_label = self._label("")
+        form.addRow(self.edit_reason_label)
+        self.effective_label = self._label("")
+        self.effective_label.setAccessibleName("Effective Fetch and Push destinations")
+        form.addRow(self.effective_label)
+        self.origin_label = self._label("")
+        form.addRow(self.origin_label)
+        self.unavailable_label = self._label("Inactive remotes use Git Extensions-compatible -remote sections. GitPane excludes them from automatic operations.")
+        form.addRow(self.unavailable_label)
+        self.scroll_area.setWidget(content)
+        details_layout.addWidget(self.scroll_area, 1)
+        details_actions = QHBoxLayout()
+        details_actions.addStretch()
+        self.save_button = QPushButton("Save changes")
+        details_actions.addWidget(self.save_button)
+        details_layout.addLayout(details_actions)
+        body.addWidget(self.details, REMOTE_DETAILS_STRETCH)
+        self.tabs = QTabWidget()
+        self.tabs.addTab(remote_page, "Remote repositories")
+        self._build_tracking()
+        self.tabs.addTab(self.tracking_page, "Default pull behavior (fetch & merge)")
+        layout.addWidget(self.tabs)
+        self.status_label = self._label("Loading remotes…")
+        layout.addWidget(self.status_label)
+        actions = QHBoxLayout()
+        actions.addStretch()
+        self.tracking_save_button = QPushButton("Save changes")
+        self.close_button = QPushButton("Close")
+        for button in (self.save_button, self.tracking_save_button, self.close_button, self.browse_button):
+            button.setAutoDefault(False)
+        actions.addWidget(self.tracking_save_button)
+        actions.addWidget(self.close_button)
+        layout.addLayout(actions)
+        self.remote_tree.currentItemChanged.connect(self._selection_changed)
+        self.add_button.clicked.connect(lambda: self.select_remote(None))
+        self.browse_button.clicked.connect(self._browse)
+        self.name_edit.textChanged.connect(self._update_action)
+        self.url_edit.textChanged.connect(self._update_action)
+        self.push_url_edit.textChanged.connect(self._update_action)
+        self.separate_push_checkbox.toggled.connect(self._toggle_push)
+        self.local_override_checkbox.toggled.connect(self._update_action)
+        self.fetch_selector.currentIndexChanged.connect(lambda: self._url_selected(False))
+        self.push_selector.currentIndexChanged.connect(lambda: self._url_selected(True))
+        self.push_browse_button.clicked.connect(lambda: self._browse(True))
+        self.save_button.clicked.connect(self._save)
+        self.tracking_save_button.clicked.connect(self._save)
+        self.activate_button.clicked.connect(lambda: self._set_active(True))
+        self.deactivate_button.clicked.connect(lambda: self._set_active(False))
+        self.remove_button.clicked.connect(self._remove)
+        self.close_button.clicked.connect(self.reject)
+        self.tabs.currentChanged.connect(self._update_action)
+        self._update_action()
+        self.refresh_metrics()
+
+    def _build_tracking(self) -> None:
+        """Place the branch table and exact config editors inside a scrollable tab."""
+        self.tracking_page = QScrollArea()
+        self.tracking_page.setWidgetResizable(True)
+        content = QWidget()
+        body = QVBoxLayout(content)
+        self.tracking_tree = QTreeWidget()
+        self.tracking_tree.setRootIsDecorated(False)
+        self.tracking_tree.setHeaderLabels(["Local branch name", TRACKING_LABEL_BY_FIELD[REMOTE_TRACKING_FIELD], TRACKING_LABEL_BY_FIELD[MERGE_TRACKING_FIELD]])
+        self.tracking_tree.setAccessibleName("Local branch tracking")
+        self.tracking_tree.header().setSectionResizeMode(QHeaderView.ResizeMode.Interactive)
+        self.tracking_tree.header().setStretchLastSection(True)
+        body.addWidget(self.tracking_tree)
+        self.tracking_details = QGroupBox("Edit branch tracking")
+        form = QFormLayout(self.tracking_details)
+        apply_left_aligned_form(form)
+        self.local_branch_edit = QLineEdit()
+        self.local_branch_edit.setReadOnly(True)
+        self.tracking_remote_selector = UrlSelector()
+        self.merge_edit = QLineEdit()
+        self.tracking_remote_value_selector = UrlSelector()
+        self.merge_selector = UrlSelector()
+        for text, widget in (("Local branch name", self.local_branch_edit), ("Configured Remote values", self.tracking_remote_value_selector),
+                             (TRACKING_LABEL_BY_FIELD[REMOTE_TRACKING_FIELD], self.tracking_remote_selector), ("Configured Merge values", self.merge_selector),
+                             (TRACKING_LABEL_BY_FIELD[MERGE_TRACKING_FIELD], self.merge_edit)):
+            label = self._label(text)
+            label.setBuddy(widget)
+            widget.setAccessibleName(text)
+            form.addRow(label, widget)
+        self.tracking_origin_label = self._label("")
+        self.tracking_origin_label.setAccessibleName("Tracking Source and Effective value")
+        form.addRow(self.tracking_origin_label)
+        body.addWidget(self.tracking_details)
+        self.tracking_state_label = self._label("Loading branch tracking…")
+        body.addWidget(self.tracking_state_label)
+        self.tracking_reload_button = QPushButton("Reread tracking")
+        self.tracking_reload_button.setAutoDefault(False)
+        self.tracking_reload_button.setAccessibleName("Reread tracking")
+        body.addWidget(self.tracking_reload_button)
+        self.tracking_page.setWidget(content)
+        self.tracking_tree.currentItemChanged.connect(self._branch_selection_changed)
+        self.tracking_remote_selector.currentIndexChanged.connect(self._update_action)
+        self.merge_edit.textChanged.connect(self._update_action)
+        self.tracking_remote_value_selector.currentIndexChanged.connect(lambda: self._tracking_value_selected(REMOTE_TRACKING_FIELD))
+        self.merge_selector.currentIndexChanged.connect(lambda: self._tracking_value_selected(MERGE_TRACKING_FIELD))
+        self.tracking_reload_button.clicked.connect(self._reload_tracking)
+
+    def _reload_tracking(self) -> None:
+        """Request an explicit fresh read while retaining the selected branch's draft."""
+        if self.busy or self.closed:
+            return
+        self._store_tracking_draft()
+        self.busy = True
+        self.status_label.setText("Reading branch tracking…")
+        self._update_action()
+        self.tracking_reload_requested.emit()
+
+    def tracking_reloaded(self, snapshot: RemoteSnapshot) -> None:
+        """Accept a requested reread without selecting another branch or discarding text."""
+        self.busy = False
+        self.read_failed = False
+        self.uncertain = False
+        draft = self.tracking_draft_by_ref.get(self.selected_full_ref)
+        if draft is not None:
+            self._rebase_tracking_draft(draft, snapshot, set())
+        self.populate(snapshot, self.selected_name, select_first=False, preserve_tracking=False)
+
+    def _rebase_tracking_draft(self, draft: TrackingDraft, snapshot: RemoteSnapshot, successful_field_set: set[str]) -> None:
+        """Accept observed successes and rebind failed buffers only to unambiguous values."""
+        full_ref = self.selected_full_ref
+        for field_name in TRACKING_LABEL_BY_FIELD:
+            selected = getattr(draft, field_name + "_selected")
+            text = getattr(draft, field_name)
+            edited = text != (selected.value if selected else "")
+            values = tracking_values(snapshot, full_ref, field_name)
+            value_by_selected = getattr(draft, field_name + "_by_value")
+            if field_name in successful_field_set:
+                value_by_selected.pop(selected, None)
+                matching_values = tuple(value for value in values if value.value == text)
+                selected = next(iter(matching_values)) if len(matching_values) == 1 else None
+            elif selected not in values:
+                selected = next(iter(values)) if len(values) == 1 else None
+                if not edited:
+                    text = selected.value if selected else ""
+            setattr(draft, field_name + "_selected", selected)
+            setattr(draft, field_name, text)
+            value_by_selected[selected] = text
+        draft.snapshot = snapshot
+        draft.stale = False
+
+    def _branch_selection_changed(self, current: QTreeWidgetItem | None, previous: QTreeWidgetItem | None) -> None:
+        """Select the full local ref even when its displayed name is shortened."""
+        if current is not None:
+            self.select_branch(current.data(TRACKING_NAME_COLUMN, Qt.ItemDataRole.UserRole))
+
+    def _populate_tracking(self) -> None:
+        """Show every branch independently in full-name order without grouping upstreams."""
+        with QSignalBlocker(self.tracking_tree):
+            self.tracking_tree.clear()
+            for full_ref in sorted(self.snapshot.tracking_by_ref):
+                texts = [full_ref.removeprefix(LOCAL_PREFIX)]
+                for field_name in TRACKING_LABEL_BY_FIELD:
+                    values = tracking_values(self.snapshot, full_ref, field_name)
+                    texts.append("; ".join(value.value for value in values) if values else "Not configured")
+                item = QTreeWidgetItem(self.tracking_tree, texts)
+                item.setData(TRACKING_NAME_COLUMN, Qt.ItemDataRole.UserRole, full_ref)
+                for column, text in enumerate(texts):
+                    item.setToolTip(column, text)
+        selected = self.selected_full_ref
+        if selected is None:
+            selected = next(iter(sorted(self.snapshot.tracking_by_ref)), None)
+        self.select_branch(selected, preserve=False)
+
+    def select_branch(self, full_ref: str | None, *, preserve: bool = True) -> None:
+        """Load one branch's draft without saving or adopting another branch's identity."""
+        if self.busy or self.snapshot is None:
+            return
+        if preserve:
+            self._store_tracking_draft()
+        self.loading = True
+        self.selected_full_ref = full_ref
+        branch = self.snapshot.tracking_by_ref.get(full_ref)
+        with QSignalBlocker(self.tracking_tree):
+            self.tracking_tree.clearSelection()
+            for index in range(self.tracking_tree.topLevelItemCount()):
+                item = self.tracking_tree.topLevelItem(index)
+                if item.data(TRACKING_NAME_COLUMN, Qt.ItemDataRole.UserRole) == full_ref:
+                    self.tracking_tree.setCurrentItem(item)
+        self.local_branch_edit.setText(full_ref.removeprefix(LOCAL_PREFIX) if full_ref else "")
+        if branch is not None and full_ref not in self.tracking_draft_by_ref:
+            remote_values = tracking_values(self.snapshot, full_ref, REMOTE_TRACKING_FIELD)
+            merge_values = tracking_values(self.snapshot, full_ref, MERGE_TRACKING_FIELD)
+            remote = next(iter(remote_values)) if len(remote_values) == 1 else None
+            merge = next(iter(merge_values)) if len(merge_values) == 1 else None
+            self.tracking_draft_by_ref[full_ref] = TrackingDraft(self.snapshot, remote.value if remote else "", merge.value if merge else "", remote, merge)
+        draft = self.tracking_draft_by_ref.get(full_ref)
+        self.tracking_remote_selector.clear()
+        self.tracking_remote_selector.addItem("This repository (.)", ".")
+        for name in sorted(self.snapshot.entry_by_name):
+            entry = self.snapshot.entry_by_name[name]
+            self.tracking_remote_selector.addItem(name + (" — Inactive" if not entry.active else ""), name)
+        if draft and draft.remote and self.tracking_remote_selector.findData(draft.remote) < 0:
+            self.tracking_remote_selector.addItem(draft.remote + " — Not configured", draft.remote)
+        self.tracking_remote_selector.setCurrentIndex(self.tracking_remote_selector.findData(draft.remote) if draft and draft.remote else -1)
+        self.merge_edit.setText(draft.merge if draft else "")
+        for field_name, selector in ((REMOTE_TRACKING_FIELD, self.tracking_remote_value_selector), (MERGE_TRACKING_FIELD, self.merge_selector)):
+            selector.clear()
+            if draft:
+                for value in tracking_values(draft.snapshot, full_ref, field_name):
+                    selector.addItem(value.value + " — " + value.scope.value + ": " + value.origin, value)
+                selected = getattr(draft, field_name + "_selected")
+                selector.setCurrentIndex(selector.findData(selected) if selected else -1)
+        self.tracking_origin_label.setText("" if branch is None else "\n".join(value.key + " = " + value.value + "\nSource: " + value.scope.value + " — " + value.origin for value in branch.values))
+        if branch is None:
+            self.tracking_state_label.setText("No local branches to configure." if not self.snapshot.tracking_by_ref else "Selected branch is no longer available. Reread tracking.")
+        elif not tracking_values(self.snapshot, full_ref, REMOTE_TRACKING_FIELD) or not tracking_values(self.snapshot, full_ref, MERGE_TRACKING_FIELD):
+            self.tracking_state_label.setText("Tracking association is not configured.")
+        elif any(len(tracking_values(self.snapshot, full_ref, field_name)) > 1 for field_name in TRACKING_LABEL_BY_FIELD):
+            self.tracking_state_label.setText("Multiple tracking values. Select the exact configured value to edit; other values remain unchanged.")
+        elif draft.remote != "." and draft.remote not in self.snapshot.entry_by_name:
+            self.tracking_state_label.setText("Configured remote repository is not available. Choose a configured remote explicitly.")
+        else:
+            self.tracking_state_label.setText("Effective value: " + branch.upstream if branch.observed else "Configured tracking target is not observed locally.")
+        self.loading = False
+        self._update_action()
+
+    def _store_tracking_draft(self) -> None:
+        """Retain the active branch's text buffers only in this dialog."""
+        if self.loading or self.tracking_loading or self.selected_full_ref not in self.tracking_draft_by_ref:
+            return
+        draft = self.tracking_draft_by_ref[self.selected_full_ref]
+        draft.remote = self.tracking_remote_selector.currentData() or ""
+        draft.merge = self.merge_edit.text()
+        draft.remote_by_value[draft.remote_selected] = draft.remote
+        draft.merge_by_value[draft.merge_selected] = draft.merge
+
+    def _tracking_value_selected(self, field_name: str) -> None:
+        """Require an explicit choice before reducing a multi-value field to one editor."""
+        if self.loading or self.selected_full_ref not in self.tracking_draft_by_ref:
+            return
+        self._store_tracking_draft()
+        draft = self.tracking_draft_by_ref[self.selected_full_ref]
+        selector = self.merge_selector if field_name == MERGE_TRACKING_FIELD else self.tracking_remote_value_selector
+        selected = selector.currentData()
+        setattr(draft, field_name + "_selected", selected)
+        text = getattr(draft, field_name + "_by_value").get(selected, selected.value if selected else "")
+        if field_name == MERGE_TRACKING_FIELD:
+            self.merge_edit.setText(text)
+        else:
+            self.tracking_remote_selector.setCurrentIndex(self.tracking_remote_selector.findData(text) if text else -1)
+        self._update_action()
+
+    def _tracking_changes(self) -> tuple[RemoteChange, ...]:
+        """Collect explicit changed fields without replacing neighboring occurrences.
+
+        The tracked branch is typed, so it is sent without the blanks around it while its draft keeps them; the remote
+        comes from a list and is sent as chosen.
+        """
+        self._store_tracking_draft()
+        draft = self.tracking_draft_by_ref.get(self.selected_full_ref)
+        if draft is None:
+            return ()
+        changes: list[RemoteChange] = []
+        for field_name in TRACKING_LABEL_BY_FIELD:
+            selected = getattr(draft, field_name + "_selected")
+            text = getattr(draft, field_name)
+            if field_name == MERGE_TRACKING_FIELD:
+                text = typed_value(text)
+            if text != (selected.value if selected else ""):
+                changes.append(RemoteChange(field_name, text, selected))
+        return tuple(changes)
+
+    def _tool_button(self, name: str, icon: QIcon) -> QPushButton:
+        """Build an icon-only list button whose name is still given to screen readers and shown as its tooltip.
+
+        Add and remove use GitPane's drawn plus and minus at the window's density; the others keep the style's arrows.
+        """
+        button = QPushButton()
+        button.setIcon(icon)
+        button.setAccessibleName(name)
+        button.setToolTip(name)
+        button.setAutoDefault(False)
+        return button
+
+    def _label(self, text: str) -> QLabel:
+        label = WrappingLabel(text)
+        label.setTextFormat(Qt.TextFormat.PlainText)
+        label.setWordWrap(True)
+        label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
+        return label
+
+    def populate(self, snapshot: RemoteSnapshot, selected_name: str | None = None, *, select_first: bool = True, preserve_tracking: bool = True) -> None:
+        """Replace the observed list without publishing or discarding unrelated drafts."""
+        if preserve_tracking:
+            self._store_tracking_draft()
+        self.tracking_loading = True
+        self.read_failed = False
+        self.snapshot = snapshot
+        with QSignalBlocker(self.remote_tree):
+            self.remote_tree.clear()
+            active = QTreeWidgetItem(self.remote_tree, ["Active"])
+            inactive = QTreeWidgetItem(self.remote_tree, ["Inactive"])
+            for group in (active, inactive):
+                group.setFlags(group.flags() & ~Qt.ItemFlag.ItemIsSelectable)
+                group.setExpanded(True)
+            for name in sorted(snapshot.entry_by_name, key=lambda name: (name.casefold(), name)):
+                entry = snapshot.entry_by_name[name]
+                item = QTreeWidgetItem(active if entry.active else inactive, [entry.name])
+                item.setData(REMOTE_NAME_COLUMN, Qt.ItemDataRole.UserRole, entry.name)
+        selected = selected_name if selected_name in snapshot.entry_by_name else next(iter(snapshot.entry_by_name), None) if select_first else None
+        self.select_remote(selected, preserve=False)
+        self.status_label.setText("" if snapshot.entry_by_name else "No remotes configured. Choose Add remote.")
+        self._populate_tracking()
+        self.tracking_loading = False
+        self._update_action()
+
+    def _selection_changed(self, current: QTreeWidgetItem | None, previous: QTreeWidgetItem | None) -> None:
+        """Select an exact data identity rather than a potentially shortened label."""
+        if current is not None and current.data(REMOTE_NAME_COLUMN, Qt.ItemDataRole.UserRole) is not None:
+            self.select_remote(current.data(REMOTE_NAME_COLUMN, Qt.ItemDataRole.UserRole))
+
+    def select_remote(self, name: str | None, *, preserve: bool = True) -> None:
+        """Retain the old target's draft while displaying another captured target."""
+        if self.busy or self.snapshot is None:
+            return
+        if preserve:
+            self._store_draft()
+        self.loading = True
+        self.selected_name = name
+        with QSignalBlocker(self.remote_tree):
+            self.remote_tree.clearSelection()
+            for group_index in range(self.remote_tree.topLevelItemCount()):
+                group = self.remote_tree.topLevelItem(group_index)
+                for child_index in range(group.childCount()):
+                    item = group.child(child_index)
+                    if item.data(REMOTE_NAME_COLUMN, Qt.ItemDataRole.UserRole) == name:
+                        self.remote_tree.setCurrentItem(item)
+        entry = self.snapshot.entry_by_name.get(name)
+        fetch_values = field_values(self.snapshot, name, "url") if entry is not None else ()
+        push_values = field_values(self.snapshot, name, "pushurl") if entry is not None else ()
+        if name not in self.draft_by_name:
+            self.draft_by_name[name] = RemoteDraft(name or "", fetch_selected=next(iter(fetch_values)) if len(fetch_values) == 1 else None,
+                                                   push_selected=next(iter(push_values)) if len(push_values) == 1 else None, separate=bool(push_values))
+        draft = self.draft_by_name[name]
+        self.name_edit.setText(draft.name)
+        for selector, values, selected in ((self.fetch_selector, fetch_values, draft.fetch_selected), (self.push_selector, push_values, draft.push_selected)):
+            with QSignalBlocker(selector):
+                selector.clear()
+                for value in values:
+                    selector.addItem(self.text_filter.redact(value.value) + " — " + value.scope.value + ": " + value.origin, value)
+                selector.setCurrentIndex(selector.findData(selected) if selected is not None else -1)
+        self.url_edit.setText(draft.fetch_by_value.get(draft.fetch_selected, draft.fetch_selected.value if draft.fetch_selected else ""))
+        self.push_url_edit.setText(draft.push_by_value.get(draft.push_selected, draft.push_selected.value if draft.push_selected else ""))
+        self.separate_push_checkbox.setChecked(draft.separate)
+        self.local_override_checkbox.setChecked(draft.local_override)
+        self.details.setTitle("Add remote" if name is None else "Edit Remote Details")
+        self.origin_label.setText("" if entry is None else "\n".join(value.key + " — " + value.scope.value + ": " + value.origin for value in entry.values))
+        self.effective_label.setText("" if entry is None else self.text_filter.redact("Effective Fetch URLs:\n" + "\n".join(entry.fetch_urls) + "\nEffective Push URLs:\n" + "\n".join(entry.push_urls)))
+        self.loading = False
+        self._toggle_push()
+
+    def _store_draft(self) -> None:
+        """Save the current editor buffers in memory without touching Git."""
+        if self.loading or self.selected_name not in self.draft_by_name:
+            return
+        draft = self.draft_by_name[self.selected_name]
+        draft.name = self.name_edit.text()
+        draft.fetch_by_value[draft.fetch_selected] = self.url_edit.text()
+        draft.push_by_value[draft.push_selected] = self.push_url_edit.text()
+        draft.separate = self.separate_push_checkbox.isChecked()
+        draft.local_override = self.local_override_checkbox.isChecked()
+
+    def _url_selected(self, push: bool) -> None:
+        """Retain the previous occurrence's draft before editing an explicitly selected URL."""
+        if self.loading or self.selected_name not in self.draft_by_name:
+            return
+        self._store_draft()
+        draft = self.draft_by_name[self.selected_name]
+        selected = (self.push_selector if push else self.fetch_selector).currentData()
+        if push:
+            draft.push_selected = selected
+            self.push_url_edit.setText(draft.push_by_value.get(selected, selected.value if selected else ""))
+        else:
+            draft.fetch_selected = selected
+            self.url_edit.setText(draft.fetch_by_value.get(selected, selected.value if selected else ""))
+        self._update_action()
+
+    def _toggle_push(self) -> None:
+        """Show separate editors while preserving disabled push drafts and configured URLs."""
+        separate = self.separate_push_checkbox.isChecked()
+        self.url_label.setText("Fetch Url" if separate else "Url")
+        self.url_edit.setAccessibleName("Fetch Url" if separate else "Url")
+        self.push_label.setVisible(separate)
+        self.push_row.setVisible(separate)
+        self.push_selector.setVisible(separate and self.push_selector.count() > 1)
+        self.push_selector_label.setVisible(separate and self.push_selector.count() > 1)
+        self.fetch_selector.setVisible(self.fetch_selector.count() > 1)
+        self.fetch_selector_label.setVisible(self.fetch_selector.count() > 1)
+        self._update_action()
+
+    def typed_fetch_url(self) -> str:
+        """Return the Url that Save sends to Git: the field's text without the blanks around it, ``~`` read where that is the usage.
+
+        Only a local folder address can change, since no HTTPS, SSH or ``file://`` address starts with ``~/``; the field
+        and the draft keep the text as typed.
+        """
+        return typed_path_value(self.url_edit.text(), self.typed_path)
+
+    def typed_push_url(self) -> str:
+        """Return the Push Url that Save sends to Git: the field's text without the blanks around it, ``~`` read where that is the usage.
+
+        Only a local folder address can change, since no HTTPS, SSH or ``file://`` address starts with ``~/``; the field
+        and the draft keep the text as typed.
+        """
+        return typed_path_value(self.push_url_edit.text(), self.typed_path)
+
+    def _changes(self) -> tuple[RemoteChange, ...]:
+        """Collect only edited fields and keep hidden push drafts out of this Save.
+
+        Names and addresses are compared and sent without the blanks around them, so a value that differs from Git only
+        by those blanks is no change; the drafts keep the text as typed. An address is sent with ``~`` read where that is
+        the usage, so Git gets the full path. It is a change only when both its trimmed text and that reading differ from
+        the configured value: an address Git already has, even one another tool wrote with ``~``, is rewritten only once
+        the user changes it, and ``~/…`` typed for the path already configured is no change.
+        """
+        if self.snapshot is None or self.selected_name not in self.draft_by_name:
+            return ()
+        self._store_draft()
+        draft = self.draft_by_name[self.selected_name]
+        name = typed_value(draft.name)
+        fetch_url = self.typed_fetch_url()
+        push_url = self.typed_push_url()
+        changes: list[RemoteChange] = []
+        if self.selected_name is None:
+            changes.append(RemoteChange("add", fetch_url))
+        elif name != self.selected_name:
+            changes.append(RemoteChange("name", name))
+        if self.selected_name is not None and draft.fetch_selected is not None and self._address_changed(self.url_edit, fetch_url, draft.fetch_selected.value):
+            changes.append(RemoteChange("url", fetch_url, draft.fetch_selected))
+        if draft.separate and self._address_changed(self.push_url_edit, push_url, draft.push_selected.value if draft.push_selected else ""):
+            changes.append(RemoteChange("pushurl", push_url, draft.push_selected, draft.local_override))
+        return tuple(changes)
+
+    @staticmethod
+    def _address_changed(edit: QLineEdit, read_address: str, configured_address: str) -> bool:
+        """Answer whether the address typed in ``edit`` is a change from ``configured_address``.
+
+        Neither the trimmed text nor its reading with ``~`` may be the configured value: the first keeps an address
+        written with ``~`` by another tool, the second keeps the full path typed back with ``~``.
+        """
+        return typed_value(edit.text()) != configured_address and read_address != configured_address
+
+    def _update_action(self) -> None:
+        """Explain ambiguous or inherited fields and enable only explicit valid edits."""
+        if self.loading:
+            return
+        ready = self.snapshot is not None and not self.busy and not self.closed and not self.uncertain and not self.read_failed
+        changes = self._changes()
+        valid = bool(changes)
+        try:
+            validate_name(typed_value(self.name_edit.text()))
+        except ValueError:
+            valid = False
+        for change in changes:
+            if not change.value or any(character in change.value for character in ("\0", "\n", "\r")):
+                valid = False
+        reasons: list[str] = []
+        inherited = False
+        if self.snapshot is not None and self.selected_name in self.snapshot.entry_by_name:
+            entry = self.snapshot.entry_by_name[self.selected_name]
+            inherited = any(value not in self.snapshot.direct_values for value in entry.values)
+            draft = self.draft_by_name[self.selected_name]
+            for field, selected, edit in (("url", draft.fetch_selected, self.url_edit), ("pushurl", draft.push_selected, self.push_url_edit)):
+                try:
+                    reason = url_edit_reason(self.snapshot, self.selected_name, field, selected)
+                except ValueError as error:
+                    reason = str(error)
+                edit.setReadOnly(bool(reason))
+                if reason:
+                    reasons.append(reason)
+                if reason and any(change.field == field for change in changes):
+                    valid = False
+            if inherited:
+                self.name_edit.setReadOnly(True)
+                reasons.append("Inherited configuration remains in its original file. Name cannot be changed here.")
+                if draft.push_selected is None and draft.separate and not draft.local_override:
+                    reasons.append("Select Create local Push URL override to send pushes to a separate local destination.")
+                    if any(change.field == "pushurl" for change in changes):
+                        valid = False
+        else:
+            self.name_edit.setReadOnly(False)
+            self.url_edit.setReadOnly(False)
+            self.push_url_edit.setReadOnly(False)
+        if not inherited:
+            self.name_edit.setReadOnly(False)
+        entry = self.snapshot.entry_by_name.get(self.selected_name) if self.snapshot is not None else None
+        if entry is not None and not entry.active:
+            self.name_edit.setReadOnly(True)
+            reasons.append("Activate this remote before renaming it so Git can update its references and tracking.")
+            if any(change.field == "name" for change in changes):
+                valid = False
+        if entry is not None and entry.collision:
+            reasons.append("Active and inactive definitions collide. Review their configuration sources before making changes.")
+            valid = False
+        self.local_override_checkbox.setVisible(inherited and self.separate_push_checkbox.isChecked() and self.push_selector.count() == 0)
+        if not self.separate_push_checkbox.isChecked() and self.push_selector.count():
+            reasons.append("Configured Push URLs remain unchanged. Enable Separate Push Url to edit them.")
+        self.edit_reason_label.setText("\n".join(dict.fromkeys(reasons)))
+        self.save_button.setEnabled(ready and valid)
+        self.add_button.setEnabled(ready)
+        self.details.setEnabled(ready)
+        self.remote_tree.setEnabled(ready)
+        manageable = ready and entry is not None and not entry.collision
+        self.remove_button.setEnabled(manageable)
+        self.activate_button.setEnabled(manageable and not entry.active)
+        self.deactivate_button.setEnabled(manageable and entry.active)
+        self.tracking_tree.setEnabled(ready)
+        self.tracking_reload_button.setEnabled(not self.busy and not self.closed)
+        self.tracking_details.setEnabled(ready and self.selected_full_ref in (self.snapshot.tracking_by_ref if self.snapshot else {}))
+        if self.tabs.currentWidget() is self.tracking_page:
+            tracking_changes = self._tracking_changes()
+            valid = self.tracking_details.isEnabled() and bool(tracking_changes)
+            draft = self.tracking_draft_by_ref.get(self.selected_full_ref)
+            if draft is not None and (draft.stale or draft.snapshot.values != self.snapshot.values
+                                      or draft.snapshot.tracking_by_ref.get(self.selected_full_ref) != self.snapshot.tracking_by_ref.get(self.selected_full_ref)):
+                self.tracking_state_label.setText("Branch or configuration changed. Reread tracking before saving this branch.")
+                valid = False
+            for change in tracking_changes:
+                if not change.value or any(character in change.value for character in ("\0", "\n", "\r")) or change.field == MERGE_TRACKING_FIELD and not change.value.startswith(LOCAL_PREFIX):
+                    valid = False
+                if tracking_values(self.snapshot, self.selected_full_ref, change.field) and change.selected is None:
+                    valid = False
+                if change.selected is not None and change.selected not in self.snapshot.direct_values:
+                    self.tracking_state_label.setText("This tracking value is inherited. Edit its original configuration source.")
+                    valid = False
+            self.save_button.setEnabled(ready and valid)
+        self.tracking_save_button.setVisible(self.tabs.currentWidget() is self.tracking_page)
+        self.tracking_save_button.setEnabled(self.save_button.isEnabled())
+
+    def _set_active(self, active: bool) -> None:
+        """Capture one section move while keeping unsaved field edits separate."""
+        button = self.activate_button if active else self.deactivate_button
+        if not button.isEnabled():
+            return
+        self._store_draft()
+        self.request_kind = "remote"
+        self.request = (self.snapshot, self.selected_name, active)
+        self.busy = True
+        self._update_action()
+        self.status_label.setText("Activating remote…" if active else "Deactivating remote…")
+        self.active_requested.emit(self.request)
+
+    def _remove(self) -> None:
+        """Confirm the captured remote with cancellation as the default and Escape action."""
+        if not self.remove_button.isEnabled():
+            return
+        self._store_draft()
+        self.request_kind = "remote"
+        snapshot, name = self.snapshot, self.selected_name
+        self.busy = True
+        self._update_action()
+        confirmation = QMessageBox(self)
+        self.removal_dialog = confirmation
+        prepare_message_box(confirmation, REMOVE_REMOTE_TITLE)
+        confirmation.setTextFormat(Qt.TextFormat.PlainText)
+        confirmation.setText("Remove remote '" + name + "' from this repository? This does not delete the remote repository.")
+        remove = confirmation.addButton("Remove remote", QMessageBox.ButtonRole.DestructiveRole)
+        cancel = confirmation.addButton("Cancel removal", QMessageBox.ButtonRole.RejectRole)
+        confirmation.setDefaultButton(cancel)
+        confirmation.setEscapeButton(cancel)
+
+        def finished() -> None:
+            """Emit only the confirmation's captured target while its parent is still live."""
+            self.removal_dialog = None
+            accepted = confirmation.clickedButton() is remove
+            confirmation.setParent(None)
+            confirmation.deleteLater()
+            if self.closed:
+                return
+            if not accepted:
+                self.busy = False
+                self.status_label.setText("Remote removal cancelled.")
+                self._update_action()
+                self.remove_button.setFocus()
+                return
+            self.request = (snapshot, name, None)
+            self.status_label.setText("Removing remote…")
+            self.remove_requested.emit(self.request)
+
+        confirmation.finished.connect(finished)
+        open_window_modal(confirmation)
+
+    def _save(self) -> None:
+        """Freeze the selected draft before emitting a business intent."""
+        if not self.save_button.isEnabled():
+            return
+        if self.tabs.currentWidget() is self.tracking_page:
+            self.request_kind = "tracking"
+            draft = self.tracking_draft_by_ref[self.selected_full_ref]
+            self.request = (draft.snapshot, self.selected_full_ref, self._tracking_changes())
+            self.busy = True
+            self._update_action()
+            self.status_label.setText("Saving branch tracking…")
+            self.tracking_requested.emit(self.request)
+            return
+        self.request_kind = "remote"
+        self.request = (self.snapshot, typed_value(self.name_edit.text()) if self.selected_name is None else self.selected_name, self._changes())
+        self.busy = True
+        self._update_action()
+        self.status_label.setText("Saving remote…")
+        self.save_requested.emit(self.request)
+
+    def show_outcome(self, outcome: RemoteOutcome) -> None:
+        """Retain failed field drafts and forbid replay after an uncertain native result."""
+        if self.request_kind == "tracking":
+            self._show_tracking_outcome(outcome)
+            return
+        self._store_draft()
+        old_name = self.selected_name
+        old_url, old_push = self.url_edit.text(), self.push_url_edit.text()
+        old_draft = self.draft_by_name.get(old_name)
+        self.busy = False
+        if outcome.steps and all(step.operation in ("Activate remote", "Deactivate remote", "Remove remote") for step in outcome.steps):
+            if getattr(outcome, "snapshot", None) is not None:
+                # Section moves keep the same fields; remap occurrence identities without losing drafts.
+                removing = any(step.operation == "Remove remote" for step in outcome.steps)
+                if old_draft is not None and old_name in outcome.snapshot.entry_by_name:
+                    prefix = "remote." if outcome.snapshot.entry_by_name.get(old_name, self.snapshot.entry_by_name[old_name]).active else INACTIVE_REMOTE_SECTION
+                    for field_name, config_field in (("fetch", "url"), ("push", "pushurl")):
+                        value_by_selected = getattr(old_draft, field_name + "_by_value")
+                        remapped_by_value: dict[RemoteValue | None, str] = {}
+                        for value, text in value_by_selected.items():
+                            remapped_by_value[replace(value, key=prefix + value.key.removeprefix("-").removeprefix("remote.")) if value else None] = text
+                        setattr(old_draft, field_name + "_by_value", remapped_by_value)
+                        selected = getattr(old_draft, field_name + "_selected")
+                        if selected is not None:
+                            selected = replace(selected, key=prefix + selected.key.removeprefix("-").removeprefix("remote."))
+                            values = field_values(outcome.snapshot, old_name, config_field)
+                            if selected not in values:
+                                text = remapped_by_value.get(selected, selected.value)
+                                selected = next(iter(values)) if len(values) == 1 else None
+                                remapped_by_value[selected] = text
+                            setattr(old_draft, field_name + "_selected", selected)
+                if removing and old_name not in outcome.snapshot.entry_by_name and outcome.status == OperationStatus.SUCCESS:
+                    self.draft_by_name.pop(old_name, None)
+                self.populate(outcome.snapshot, old_name, select_first=False)
+            self.uncertain = outcome.status == OperationStatus.UNKNOWN
+            self.status_label.setText("\n".join(step.operation + ": " + step.status.value for step in outcome.steps))
+            if outcome.diagnostic is not None:
+                self.status_label.setText(self.status_label.text() + "\n" + (outcome.diagnostic.detail or outcome.diagnostic.cause))
+            self._update_action()
+            return
+        if getattr(outcome, "snapshot", None) is not None:
+            self.draft_by_name.pop(old_name, None)
+            self.draft_by_name.pop(outcome.selected_name, None)
+            self.populate(outcome.snapshot, outcome.selected_name)
+            failed_field_set = {step.before.field for step in outcome.steps if isinstance(step.before, RemoteChange) and step.status != OperationStatus.SUCCESS}
+            if "url" in failed_field_set:
+                self.url_edit.setText(old_url)
+            if "pushurl" in failed_field_set:
+                self.separate_push_checkbox.setChecked(True)
+                self.push_url_edit.setText(old_push)
+            if "name" in failed_field_set and old_draft is not None:
+                self.name_edit.setText(old_draft.name)
+            if old_draft is not None and not old_draft.separate:
+                self.separate_push_checkbox.setChecked(False)
+                self.push_url_edit.setText(old_push)
+        self.uncertain = outcome.status == OperationStatus.UNKNOWN or any(step.status == OperationStatus.UNKNOWN or step.process_status == ProcessStatus.SUCCESS and step.after is None for step in outcome.steps)
+        messages: list[str] = []
+        for step in outcome.steps:
+            messages.append(step.operation + ": " + step.status.value)
+        if outcome.diagnostic is not None:
+            messages.append(outcome.diagnostic.detail or outcome.diagnostic.cause)
+        self.status_label.setText("\n".join(messages))
+        self._update_action()
+
+    def _show_tracking_outcome(self, outcome: RemoteOutcome) -> None:
+        """Publish observed tracking while keeping failed field buffers available."""
+        self._store_tracking_draft()
+        full_ref = self.selected_full_ref
+        draft = self.tracking_draft_by_ref.get(full_ref)
+        self.busy = False
+        snapshot = getattr(outcome, "snapshot", None)
+        if snapshot is not None:
+            if draft is not None and outcome.status in (OperationStatus.SUCCESS, OperationStatus.PARTIAL):
+                successful_field_set = {step.before.field for step in outcome.steps if isinstance(step.before, RemoteChange) and step.status == OperationStatus.SUCCESS}
+                self._rebase_tracking_draft(draft, snapshot, successful_field_set)
+            elif draft is not None and outcome.status == OperationStatus.REFUSED:
+                draft.stale = True
+            self.populate(snapshot, self.selected_name, select_first=False, preserve_tracking=False)
+        self.uncertain = outcome.status == OperationStatus.UNKNOWN or any(step.status == OperationStatus.UNKNOWN for step in outcome.steps)
+        texts: list[str] = []
+        for step in outcome.steps:
+            texts.append(step.operation + ": " + step.status.value)
+        if outcome.diagnostic is not None:
+            texts.append(outcome.diagnostic.detail or outcome.diagnostic.cause)
+        self.status_label.setText("\n".join(texts))
+        self._update_action()
+
+    def show_error(self, cause: str) -> None:
+        """Keep the form unavailable after an incomplete initial read."""
+        self.busy = False
+        self.read_failed = True
+        self.status_label.setText(cause)
+        self.tracking_state_label.setText("Branch tracking could not be read. Reread tracking after reviewing the diagnostic.")
+        self._update_action()
+
+    def _browse(self, push: bool = False) -> None:
+        """Choose a local destination asynchronously, from the folder the typed address stands for, without writing its remote.
+
+        ``~`` is read where that is the usage; an address that is not an absolute folder leaves the selector at its own
+        start folder.
+        """
+        edit = self.push_url_edit if push else self.url_edit
+        self._open_folder_chooser(typed_start_dir(edit.text(), self.typed_path), edit)
+
+    def _open_folder_chooser(self, start_dir: str, edit: QLineEdit) -> None:
+        """Open the directory selector at ``start_dir`` and write the chosen folder into ``edit``; cancelling changes nothing."""
+        dialog = QFileDialog(self, "Choose remote repository", start_dir)
+        dialog.setFileMode(QFileDialog.FileMode.Directory)
+        dialog.fileSelected.connect(lambda filename: edit.setText(filename) if not self.closed else None)
+        dialog.open()
+
+    def refresh_metrics(self, available: QRect | None = None) -> None:
+        """Fit the logical dialog bounds to the available screen without scaling twice."""
+        fit_form(self, available)
+        for tree in (self.remote_tree, self.tracking_tree):
+            keep_selection_visible(tree)
+            if not tree.styleSheet():
+                # Windows can paint an unfocused selection gray despite its palette; use the system accent explicitly.
+                tree.setStyleSheet("QTreeView::item:selected { background-color: palette(highlight); color: palette(highlighted-text); }")
+        header = self.tracking_tree.header()
+        for column in (TRACKING_NAME_COLUMN, TRACKING_REMOTE_COLUMN):
+            caption_width = header.fontMetrics().horizontalAdvance(self.tracking_tree.headerItem().text(column)) + SPACING_MD * 2
+            header.resizeSection(column, max(header.sectionSize(column), caption_width))
+
+    def changeEvent(self, event: QEvent) -> None:
+        """Keep both selected rows legible after a system palette update."""
+        super().changeEvent(event)
+        if event.type() == QEvent.Type.PaletteChange and hasattr(self, "tracking_tree"):
+            for tree in (self.remote_tree, self.tracking_tree):
+                keep_selection_visible(tree)
+
+    def done(self, result: int) -> None:
+        """Invalidate pending intentions and restore focus after abandoning local drafts."""
+        self.closed = True
+        self.draft_by_name.clear()
+        self.tracking_draft_by_ref.clear()
+        if self.removal_dialog is not None:
+            self.removal_dialog.reject()
+        super().done(result)
+        if self.return_focus is not None and isValid(self.return_focus):
+            self.return_focus.setFocus()