gitpane 1.0.0__py3-none-any.whl

gitpane/ui/sequencer/conflict_dialog.py

@@ -0,0 +1,532 @@
+"""Present the unresolved paths of a repository, with the questions their resolution asks the user."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QItemSelectionModel, Qt, Signal
+from PySide6.QtWidgets import QAbstractItemView, QCheckBox, QDialog, QGridLayout, QHBoxLayout, QLabel, QPlainTextEdit, QPushButton, QScrollArea, QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget
+
+from gitpane.config import FIRST_ROW, OPERATION_HEIGHT, OPERATION_WIDTH, control_height
+from gitpane.operation.diagnostic import SensitiveTextFilter
+from gitpane.preference.preference_store import CONFLICT_PROMPT_PREFERENCE_KEY
+from gitpane.sequencer.conflict import ConflictEntry, ConflictSelection, ConflictState, conflict_count_text, conflict_path_label, has_deleted_side
+from gitpane.ui.widget.dialog_layout import fit_form
+from gitpane.ui.widget.long_text import WrappingLabel
+from gitpane.ui.widget.result_label import ResultLabel
+from gitpane.worktree.worktree_snapshot import CONFLICT_ROLE_BY_STAGE
+
+if TYPE_CHECKING:
+    from PySide6.QtCore import QObject, QRect
+
+    from gitpane.preference.preference_store import PreferenceStore
+    from gitpane.reference.stash import StashObservation
+    from gitpane.sequencer.conflict import ConflictMarkerLine
+    from gitpane.sequencer.rebase_state import RebaseSnapshot
+
+CONFLICT_PATH_COLUMN = 0
+CONFLICT_KIND_COLUMN = 1
+CONFLICT_STATE_COLUMN = 2
+DETAIL_HEIGHT_DIVISOR = 3
+MESSAGE_VISIBLE_LINES = 4
+PRIMARY_ACTION_ROW, SECONDARY_ACTION_ROW = 0, 1
+STOP_ACTION_ROW = 2
+FIRST_ACTION_COLUMN, SECOND_ACTION_COLUMN, LAST_ACTION_COLUMN = 0, 1, 2
+# A file with many conflicts would otherwise give a warning longer than its window; the first lines are enough to find them.
+SHOWN_MARKER_LINE_LIMIT = 12
+
+
+def conflict_marker_warning(label: str, marker_lines: tuple[ConflictMarkerLine, ...]) -> str:
+    """Tell which lines of a file still hold conflict markers and what staging it anyway would do."""
+    line_texts = []
+    for marker_line in marker_lines[:SHOWN_MARKER_LINE_LIMIT]:
+        line_texts.append(str(marker_line.line_number))
+    hidden_count = len(marker_lines) - len(line_texts)
+    if hidden_count > 0:
+        line_texts.append(f"and {hidden_count} more")
+    line_word = "line" if len(marker_lines) == 1 else "lines"
+    return (f"'{label}' still contains conflict markers ({line_word} {', '.join(line_texts)}). Mark it as solved anyway? "
+            "The markers will be committed as they are.")
+
+
+def conflict_rows_signature(state: ConflictState) -> tuple[object, ...]:
+    """Tell what the rows of the conflict list show of a state; two states with the same signature give the same rows."""
+    return (state.entries, state.fresh)
+
+
+def rebase_role_signature(state: RebaseSnapshot | None) -> tuple[object, ...] | None:
+    """Tell what the conflict rows and details show of a rebase state; two states with the same signature describe the conflicts the same way."""
+    if state is None:
+        return None
+    return (state.key, state.identity, state.current_step)
+
+
+class ConflictDialog(QDialog):
+    """Keep a selectable list open independently of repository browsing."""
+
+    refresh_requested = Signal()
+    mark_solved_requested = Signal(object)
+    delete_requested = Signal(object)
+    open_tool_requested = Signal(object)
+    settings_requested = Signal()
+    stop_series_requested = Signal()
+
+    def __init__(self, state: ConflictState, parent: QWidget | None = None) -> None:
+        """Build a modeless view with exact path identities and permanent refresh access."""
+        super().__init__(parent)
+        self.state = state
+        self.rebase_state: RebaseSnapshot | None = None
+        self.shown_row_signature: tuple[object, ...] | None = None
+        self.shown_rebase_role_signature: tuple[object, ...] | None = None
+        self.busy = False
+        self.write_diagnostic = ""
+        self.scanning = False
+        self.scan_complete = False
+        self.merge_series_id = ""
+        # The whole list is selected once, when its first conflicts appear, so the series starts in one click; after that
+        # the selection is the user's and publications keep it.
+        self.initial_selection_done = False
+        repository_label = parent.windowTitle() if parent is not None else state.key.git_dir
+        self.setWindowTitle("Resolve merge conflicts — " + repository_label)
+        self.resize(OPERATION_WIDTH, OPERATION_HEIGHT)
+        layout = QVBoxLayout(self)
+        self.message_scroll = QScrollArea()
+        self.message_scroll.setWidgetResizable(True)
+        self.message_scroll.setFrameShape(QScrollArea.Shape.NoFrame)
+        self.message_scroll.setAccessibleName("Conflict status and diagnostics")
+        message_container = QWidget()
+        message_layout = QVBoxLayout(message_container)
+        message_layout.setContentsMargins(0, 0, 0, 0)
+        self.status_label = WrappingLabel()
+        self.status_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.status_label.setWordWrap(True)
+        message_layout.addWidget(self.status_label)
+        self.retention_label = WrappingLabel()
+        self.retention_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.retention_label.setWordWrap(True)
+        message_layout.addWidget(self.retention_label)
+        # Plain, wrapped text selectable by mouse and keyboard, which can show a refusal in the warning tone.
+        self.error_label = ResultLabel()
+        self.error_label.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+        self.error_label.setAccessibleName("Conflict diagnostic and recovery path")
+        self.error_label.installEventFilter(self)
+        message_layout.addWidget(self.error_label)
+        self.message_scroll.setWidget(message_container)
+        layout.addWidget(self.message_scroll)
+        self.conflict_list = QTreeWidget()
+        self.conflict_list.setHeaderLabels(["Filename", "Conflict type", "State"])
+        self.conflict_list.setRootIsDecorated(False)
+        self.conflict_list.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
+        self.conflict_list.setAccessibleName("Unresolved merge conflicts")
+        self.conflict_list.itemSelectionChanged.connect(self._show_selection)
+        layout.addWidget(self.conflict_list, 1)
+        self.explanation_label = QPlainTextEdit()
+        self.explanation_label.setReadOnly(True)
+        self.explanation_label.setTabChangesFocus(True)
+        self.explanation_label.setAccessibleName("Selected conflict details")
+        self.explanation_label.setMaximumHeight(OPERATION_HEIGHT // DETAIL_HEIGHT_DIVISOR)
+        layout.addWidget(self.explanation_label)
+        button_layout = QGridLayout()
+        self.refresh_button = QPushButton("Rescan merge conflicts")
+        self.refresh_button.clicked.connect(self.refresh_requested.emit)
+        self.mark_solved_button = QPushButton("Mark conflict as solved")
+        self.mark_solved_button.clicked.connect(lambda: self.mark_solved_requested.emit(self.selection()))
+        self.delete_button = QPushButton("Delete file")
+        self.delete_button.clicked.connect(lambda: self.delete_requested.emit(self.selection()))
+        self.open_tool_button = QPushButton("Solve conflicts in KDiff3")
+        self.open_tool_button.setAccessibleName(self.open_tool_button.text())
+        self.open_tool_button.setToolTip("Process selected files in order: open KDiff3 for content conflicts, or ask to keep/delete a file when one side is deleted")
+        self.open_tool_button.clicked.connect(self.open_selected_tool)
+        self.conflict_list.itemDoubleClicked.connect(lambda _item, _column: self.open_selected_tool())
+        self.settings_button = QPushButton("Open Settings")
+        self.settings_button.clicked.connect(self.settings_requested.emit)
+        self.settings_button.hide()
+        self.stop_series_button = QPushButton("Stop series")
+        self.stop_series_button.clicked.connect(self.stop_series_requested.emit)
+        self.stop_series_button.hide()
+        self.close_button = QPushButton("Close")
+        self.close_button.clicked.connect(self.close)
+        button_layout.addWidget(self.refresh_button, PRIMARY_ACTION_ROW, FIRST_ACTION_COLUMN)
+        button_layout.addWidget(self.mark_solved_button, PRIMARY_ACTION_ROW, SECOND_ACTION_COLUMN)
+        button_layout.addWidget(self.open_tool_button, PRIMARY_ACTION_ROW, LAST_ACTION_COLUMN)
+        button_layout.addWidget(self.delete_button, SECONDARY_ACTION_ROW, SECOND_ACTION_COLUMN)
+        button_layout.addWidget(self.settings_button, SECONDARY_ACTION_ROW, FIRST_ACTION_COLUMN)
+        button_layout.addWidget(self.stop_series_button, STOP_ACTION_ROW, SECOND_ACTION_COLUMN)
+        button_layout.addWidget(self.close_button, SECONDARY_ACTION_ROW, LAST_ACTION_COLUMN)
+        layout.addLayout(button_layout)
+        self.show_state(state)
+        self.refresh_metrics()
+
+    def refresh_metrics(self, available_geometry: QRect | None = None) -> None:
+        """Keep native text and controls usable after screen or font changes."""
+        for column in (CONFLICT_PATH_COLUMN, CONFLICT_KIND_COLUMN, CONFLICT_STATE_COLUMN):
+            self.conflict_list.resizeColumnToContents(column)
+        self.message_scroll.setMaximumHeight(control_height(self.fontMetrics().height()) * MESSAGE_VISIBLE_LINES)
+        fit_form(self, available_geometry)
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """Reveal the selectable recovery diagnostic when keyboard navigation reaches it."""
+        if watched is self.error_label and event.type() == QEvent.Type.FocusIn:
+            self.message_scroll.ensureWidgetVisible(self.error_label)
+        return super().eventFilter(watched, event)
+
+    def selection(self) -> ConflictSelection:
+        """Capture selected raw paths in explicit order with their observation identity."""
+        paths = []
+        for item in self.conflict_list.selectedItems():
+            paths.append(item.data(CONFLICT_PATH_COLUMN, Qt.ItemDataRole.UserRole))
+        return ConflictSelection(self.state.key, self.state.generation, tuple(sorted(paths)))
+
+    def show_state(self, state: ConflictState) -> None:
+        """Retain the latest state, reconcile selection by raw path and preserve unknown rows after read failures.
+
+        The rows are rebuilt only when the conflicts or their freshness changed.
+        """
+        selected_path_set = set(self.selection().paths)
+        self.state = state
+        # The retained read number decides whether a click is still current, so it follows every publication. The rows
+        # only change with the conflicts or their freshness; rebuilding them anyway would lose the scroll position and
+        # set the selection again for nothing.
+        signature = conflict_rows_signature(state)
+        if signature != self.shown_row_signature:
+            self.shown_row_signature = signature
+            self.conflict_list.clear()
+            for entry in state.entries:
+                kind, explanation = self._describe_entry(entry)
+                item = QTreeWidgetItem([conflict_path_label(entry.path), kind, "Unresolved" if state.fresh else "Unknown; last known conflict"])
+                item.setData(CONFLICT_PATH_COLUMN, Qt.ItemDataRole.UserRole, entry.path)
+                item.setToolTip(CONFLICT_KIND_COLUMN, explanation)
+                self.conflict_list.addTopLevelItem(item)
+                item.setSelected(entry.path in selected_path_set)
+            for column in (CONFLICT_PATH_COLUMN, CONFLICT_KIND_COLUMN, CONFLICT_STATE_COLUMN):
+                self.conflict_list.resizeColumnToContents(column)
+            self._select_first_conflicts()
+        count = len(state.entries)
+        message = "No unresolved merge conflicts. Return to the repository to review the staged changes."
+        if count:
+            message = conflict_count_text(count)
+            if self.scan_complete:
+                message = "Scan complete. " + message + ". Select a file and choose its resolution."
+        if self.scanning:
+            message = "Rescanning merge conflicts..."
+        self.status_label.setText(message if state.fresh or self.scanning else "Conflict state is unknown. " + state.diagnostic)
+        if not state.fresh:
+            self.show_retention(None)
+        self._show_selection()
+
+    def _select_first_conflicts(self) -> None:
+        """Select every row the first time the list shows conflicts, and start over once it is emptied.
+
+        An emptied list holds no choice of the user's, and the conflicts that appear next, such as those of the next
+        replayed commit, are a new series.
+        """
+        if not self.state.entries:
+            self.initial_selection_done = False
+            return
+        if self.initial_selection_done:
+            return
+        self.initial_selection_done = True
+        self.conflict_list.setCurrentItem(self.conflict_list.topLevelItem(FIRST_ROW), CONFLICT_PATH_COLUMN, QItemSelectionModel.SelectionFlag.NoUpdate)
+        self.conflict_list.selectAll()
+        self.conflict_list.setFocus()
+
+    def show_write_availability(self, diagnostic: str) -> None:
+        """Apply the shared write refusal without replacing the current selection or scan; the same refusal again changes nothing."""
+        if diagnostic == self.write_diagnostic:
+            return
+        self.write_diagnostic = diagnostic
+        self._show_selection()
+
+    def _show_selection(self) -> None:
+        """Explain selected special modes and show every available role without invented sides."""
+        selected_path_set = set(self.selection().paths)
+        selected_entries = []
+        for entry in self.state.entries:
+            if entry.path in selected_path_set:
+                selected_entries.append(entry)
+        all_deletions = bool(selected_entries) and all(has_deleted_side(entry.sides) for entry in selected_entries)
+        actionable = bool(selected_path_set) and self.state.fresh and not self.busy and not self.scanning and not self.write_diagnostic
+        self.mark_solved_button.setEnabled(actionable)
+        self.mark_solved_button.setText("Keep modified file" if all_deletions else "Mark conflict as solved")
+        self.open_tool_button.setEnabled(actionable)
+        self.mark_solved_button.setToolTip(self.write_diagnostic)
+        self.open_tool_button.setToolTip(self.write_diagnostic or "Open the selected conflict in the configured merge tool")
+        self.delete_button.setEnabled(actionable and all_deletions)
+        self.delete_button.setToolTip("Delete the selected file and stage its deletion" if all_deletions else "Select only conflicts with a deleted side")
+        descriptions = []
+        for entry in self.state.entries:
+            if entry.path not in selected_path_set:
+                continue
+            _kind, explanation = self._describe_entry(entry)
+            parts = [conflict_path_label(entry.path) + ": " + explanation]
+            if has_deleted_side(entry.sides):
+                parts.extend(("Keep modified file: stage the current working file.", "Delete file: remove the working file and stage its deletion.",
+                              "Solve conflicts in KDiff3 asks whether to keep or delete this file, then proceeds to the next selected file. Rescan only updates this list."))
+            rebase = self.rebase_state
+            if rebase is not None and rebase.key == self.state.key and rebase.identity is not None:
+                parts.extend(("During rebase:", "BASE: base of the replayed change", "LOCAL: result already built on the target",
+                              "REMOTE: commit being replayed", "MERGED: saved result to stage"))
+                if rebase.current_step is not None:
+                    parts.append(rebase.current_step.oid + " " + rebase.current_step.message)
+            side_by_role = {}
+            for side in entry.sides:
+                side_by_role[CONFLICT_ROLE_BY_STAGE[side.stage]] = side
+            for role in CONFLICT_ROLE_BY_STAGE.values():
+                side = side_by_role.get(role)
+                parts.append(role + ": " + (f"mode {side.mode}, object {side.oid}" if side is not None else "absent"))
+            descriptions.append("\n".join(parts))
+        self.explanation_label.setPlainText("\n\n".join(descriptions) if descriptions else "Select a conflict to inspect its versions and choose a resolved result.")
+
+    def show_rebase_state(self, state: RebaseSnapshot | None) -> None:
+        """Explain replay roles without changing the shared index-stage or tool argument order.
+
+        The latest state is always retained; the rows and details are written again only when what they show of it changed.
+        """
+        self.rebase_state = state
+        signature = rebase_role_signature(state)
+        if signature == self.shown_rebase_role_signature:
+            return
+        self.shown_rebase_role_signature = signature
+        entry_by_path = {}
+        for entry in self.state.entries:
+            entry_by_path[entry.path] = entry
+        for row in range(self.conflict_list.topLevelItemCount()):
+            item = self.conflict_list.topLevelItem(row)
+            entry = entry_by_path.get(item.data(CONFLICT_PATH_COLUMN, Qt.ItemDataRole.UserRole))
+            if entry is not None:
+                kind, explanation = self._describe_entry(entry)
+                item.setText(CONFLICT_KIND_COLUMN, kind)
+                item.setToolTip(CONFLICT_KIND_COLUMN, explanation)
+        self.conflict_list.resizeColumnToContents(CONFLICT_KIND_COLUMN)
+        self._show_selection()
+
+    def _describe_entry(self, entry: ConflictEntry) -> tuple[str, str]:
+        """Name the actual deletion during replay without implying a remote server or another person."""
+        rebase = self.rebase_state
+        if rebase is None or rebase.key != self.state.key or rebase.identity is None or not has_deleted_side(entry.sides):
+            return entry.kind, entry.explanation
+        role_set = set()
+        for side in entry.sides:
+            role_set.add(CONFLICT_ROLE_BY_STAGE[side.stage])
+        if "LOCAL" in role_set:
+            return "Deleted by replayed commit", "The rebuilt history contains the modified file; the commit being replayed deletes it. Choose whether to keep the file or apply the deletion."
+        if "REMOTE" in role_set:
+            return "Deleted in rebuilt history", "The file is already absent from the rebuilt history; the commit being replayed modifies it. Choose whether to keep the file or keep it deleted."
+        return entry.kind, entry.explanation
+
+    def begin_rescan(self) -> None:
+        """Acknowledge an explicit refresh while its shared read is pending."""
+        self.scanning = True
+        self.scan_complete = False
+        self.refresh_button.setText("Rescanning...")
+        self.refresh_button.setEnabled(False)
+        self.status_label.setText("Rescanning merge conflicts...")
+        self._show_selection()
+
+    def finish_rescan(self) -> None:
+        """Retain visible completion feedback after the shared read succeeds or fails."""
+        if not self.scanning:
+            return
+        self.scanning = False
+        self.scan_complete = self.state.fresh
+        self.refresh_button.setText("Rescan merge conflicts")
+        self.refresh_button.setEnabled(True)
+        self.show_state(self.state)
+
+    def set_busy(self, busy: bool) -> None:
+        """Prevent a second mutation while keeping the list and refresh available."""
+        self.busy = busy
+        if busy:
+            self.scan_complete = False
+        self._show_selection()
+
+    def show_mergetool_result(self, message: str, *, settings_available: bool) -> None:
+        """Show what the merge tool run ended with, and offer Open Settings when changing the tool there is the way out.
+
+        A result that offers Settings is a refusal of the tool itself (not configured, not found, not executable, or
+        not started): it reads bold orange so it is not missed, while any other result keeps the ordinary look.
+        """
+        if settings_available:
+            self.error_label.show_warning(message)
+        else:
+            self.error_label.setText(message)
+        self.settings_button.setVisible(settings_available)
+
+    def open_selected_tool(self) -> None:
+        """Route button and double-click through the same captured raw path intention."""
+        if self.open_tool_button.isEnabled():
+            self.open_tool_requested.emit(self.selection())
+
+    def show_retention(self, observation: StashObservation | None) -> None:
+        """Name a retained stash only when a current read establishes its presence."""
+        if observation is None or observation.retained is None:
+            self.retention_label.setText("Stash retention has not been verified." if observation is not None else "")
+            return
+        text = ""
+        if observation.retained and observation.retained_oid is not None and observation.observed_at is not None:
+            text = f"Stash {observation.retained_oid} is retained (checked {observation.observed_at.isoformat(timespec='seconds')})."
+        self.retention_label.setText(text)
+
+
+class ConflictConfirmation(QDialog):
+    """Ask about one exact working result while preserving a clear non-writing exit.
+
+    Marking a conflict solved only opens it for a file that still holds conflict markers or for a deletion: the click on
+    Mark conflict as solved or Keep modified file already is the user's choice for a cleaned file, whereas a deletion
+    removes a working file or stages something other than what Keep modified file says.
+    """
+
+    def __init__(self, path: bytes, parent: QWidget | None = None, *, delete: bool = False, remove_existing: bool = False,
+                 marker_lines: tuple[ConflictMarkerLine, ...] = ()) -> None:
+        """Name the captured path and distinguish a deletion from an existing empty file.
+
+        When the accepted bytes still hold conflict markers, the question becomes a warning that names their lines, and
+        only an explicit click on the confirm button stages them: Enter and the focus stay on Keep unresolved.
+        """
+        super().__init__(parent)
+        self.setWindowTitle("Stage resolved deletion" if delete else "Mark conflict as solved")
+        layout = QVBoxLayout(self)
+        label = conflict_path_label(path)
+        message = f"Keep '{label}' deleted and stage that deletion as the conflict resolution?" if delete else f"Use the current working file '{label}' as the resolved result and stage it?"
+        if remove_existing:
+            self.setWindowTitle("Delete conflicted file")
+            message = f"Delete the working file '{label}' and stage its deletion as the conflict resolution? Earlier commits keep their file content."
+        self.message_label = ResultLabel()
+        if marker_lines:
+            self.message_label.show_warning(conflict_marker_warning(label, marker_lines))
+        else:
+            self.message_label.setText(message)
+        layout.addWidget(self.message_label)
+        button_layout = QHBoxLayout()
+        self.confirm_button = QPushButton("Stage deletion" if delete else "Mark conflict as solved")
+        if remove_existing:
+            self.confirm_button.setText("Delete file")
+        # A risky answer is never the button Enter or the initial focus would press.
+        cautious = remove_existing or bool(marker_lines)
+        if cautious:
+            self.confirm_button.setAutoDefault(False)
+        self.decline_button = QPushButton("Keep unresolved")
+        self.confirm_button.clicked.connect(self.accept)
+        self.decline_button.clicked.connect(self.reject)
+        self.decline_button.setDefault(True)
+        if cautious:
+            self.decline_button.setFocus()
+        button_layout.addWidget(self.confirm_button)
+        button_layout.addWidget(self.decline_button)
+        layout.addLayout(button_layout)
+        self.resize(OPERATION_WIDTH, layout.totalHeightForWidth(OPERATION_WIDTH))
+        self.refresh_metrics()
+
+    def refresh_metrics(self, available_geometry: QRect | None = None) -> None:
+        """Keep the named result and both answers reachable with native font scaling."""
+        fit_form(self, available_geometry)
+        self.resize(self.width(), max(self.height(), self.layout().totalHeightForWidth(self.width())))
+        fit_form(self, available_geometry)
+
+class MergeConfirmation(ConflictConfirmation):
+    """Ask separately about missing historical input and an ambiguous saved output."""
+
+    def __init__(self, path: bytes, reason: str, parent: QWidget | None = None) -> None:
+        """Keep both decisions explicit and provide the same non-writing decline action."""
+        super().__init__(path, parent)
+        label = conflict_path_label(path)
+        if reason == "missing-base":
+            self.setWindowTitle("Two-input merge")
+            self.message_label.setText(f"No base version exists for '{label}'. Open a two-input merge with LOCAL and REMOTE?")
+            self.confirm_button.setText("Open two-input merge")
+        else:
+            self.setWindowTitle("Use saved merge result")
+            self.message_label.setText(f"KDiff3 produced a result for '{label}', but success could not be confirmed. Use this result and stage it?")
+            self.confirm_button.setText("Use saved result")
+        self.refresh_metrics()
+
+
+class DeletedFileDialog(QDialog):
+    """Choose the resolved file during a mixed conflict series without opening a text merge tool."""
+
+    def __init__(self, path: bytes, parent: QWidget | None = None, *, keep_available: bool = True) -> None:
+        """Name the current file and leave cancellation as the default keyboard choice."""
+        super().__init__(parent)
+        self.delete_result: bool | None = None
+        self.setWindowTitle("Resolve deleted file")
+        layout = QVBoxLayout(self)
+        self.message_label = WrappingLabel(f"'{conflict_path_label(path)}' has a deleted side. Keep the current working file or delete it? The chosen result will be staged, then the next selected file will be processed.")
+        self.message_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.message_label.setWordWrap(True)
+        layout.addWidget(self.message_label)
+        self.keep_button = QPushButton("Keep modified file")
+        self.keep_button.setEnabled(keep_available)
+        self.keep_button.setAutoDefault(False)
+        self.keep_button.setToolTip("Use the current working file" if keep_available else "The working file is already absent")
+        self.delete_button = QPushButton("Delete file")
+        self.delete_button.setAutoDefault(False)
+        self.cancel_button = QPushButton("Cancel")
+        self.cancel_button.setToolTip("Keep this conflict unresolved and stop processing the remaining selected files")
+        self.cancel_button.setDefault(True)
+        self.cancel_button.setFocus()
+        self.keep_button.clicked.connect(lambda: self.choose_result(False))
+        self.delete_button.clicked.connect(lambda: self.choose_result(True))
+        self.cancel_button.clicked.connect(self.reject)
+        button_layout = QHBoxLayout()
+        for button in (self.keep_button, self.delete_button, self.cancel_button):
+            button_layout.addWidget(button)
+        layout.addLayout(button_layout)
+        self.resize(OPERATION_WIDTH, layout.totalHeightForWidth(OPERATION_WIDTH))
+        self.refresh_metrics()
+
+    def choose_result(self, delete: bool) -> None:
+        """Remember only an explicit button choice for the still-captured file."""
+        self.delete_result = delete
+        self.accept()
+
+    def refresh_metrics(self, available_geometry: QRect | None = None) -> None:
+        """Keep the complete filename and every choice visible with native font scaling."""
+        fit_form(self, available_geometry)
+        self.resize(self.width(), max(self.height(), self.layout().totalHeightForWidth(self.width())))
+        fit_form(self, available_geometry)
+
+
+class ConflictPrompt(QDialog):
+    """Offer immediate resolution without removing access when the user declines."""
+
+    resolve_requested = Signal()
+
+    def __init__(self, preference: PreferenceStore, parent: QWidget | None = None) -> None:
+        """Save suppression through the validated store before accepting either answer."""
+        super().__init__(parent)
+        self.preference = preference
+        self.setWindowTitle("Unresolved merge conflicts")
+        layout = QVBoxLayout(self)
+        label = QLabel("There are unresolved merge conflicts. Would you like to resolve them now?")
+        label.setWordWrap(True)
+        layout.addWidget(label)
+        self.dont_show_again = QCheckBox("Don't show again")
+        layout.addWidget(self.dont_show_again)
+        self.error_label = QLabel()
+        self.error_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.error_label.setWordWrap(True)
+        layout.addWidget(self.error_label)
+        button_layout = QHBoxLayout()
+        self.resolve_button = QPushButton("Resolve now")
+        self.decline_button = QPushButton("Not now")
+        self.resolve_button.clicked.connect(lambda: self._answer(True))
+        self.decline_button.clicked.connect(lambda: self._answer(False))
+        button_layout.addWidget(self.resolve_button)
+        button_layout.addWidget(self.decline_button)
+        layout.addLayout(button_layout)
+        self.refresh_metrics()
+
+    def refresh_metrics(self, available_geometry: QRect | None = None) -> None:
+        """Fit the proposal and its error text to the current screen."""
+        fit_form(self, available_geometry)
+
+    def _answer(self, resolve: bool) -> None:
+        """Keep the proposal visible if its suppression choice cannot be saved."""
+        try:
+            self.preference.update({CONFLICT_PROMPT_PREFERENCE_KEY: self.dont_show_again.isChecked()})
+        except (OSError, ValueError, TypeError) as error:
+            self.error_label.setText("Could not save this choice. The prompt remains enabled; after fixing the settings file, choose an answer again. " + SensitiveTextFilter().redact(str(error)))
+            return
+        self.accept()
+        if resolve:
+            self.resolve_requested.emit()

gitpane/ui/sequencer/merge_recovery_dialog.py

@@ -0,0 +1,67 @@
+"""Present retained merge files independently of the current conflict list."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import QApplication, QDialog, QHBoxLayout, QPlainTextEdit, QPushButton, QVBoxLayout, QWidget
+
+from gitpane.config import OPERATION_HEIGHT, OPERATION_WIDTH, control_height
+from gitpane.sequencer.conflict import conflict_path_label
+from gitpane.ui.widget.dialog_layout import fit_form
+
+if TYPE_CHECKING:
+    from PySide6.QtCore import QRect
+
+    from gitpane.sequencer.merge_recovery import MergeRecovery
+
+
+class MergeRecoveryDialog(QDialog):
+    """Offer copyable locations without any action that publishes retained bytes."""
+
+    refresh_requested = Signal()
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        """Build a separate reader that remains usable with no current conflicts."""
+        super().__init__(parent)
+        self.read_generation = 0
+        self.setWindowTitle("Retained merge results" + (" — " + parent.windowTitle() if parent is not None else ""))
+        self.resize(OPERATION_WIDTH, OPERATION_HEIGHT)
+        layout = QVBoxLayout(self)
+        self.recovery_text = QPlainTextEdit()
+        self.recovery_text.setReadOnly(True)
+        self.recovery_text.setTabChangesFocus(True)
+        self.recovery_text.setAccessibleName("Retained merge results and recovery paths")
+        layout.addWidget(self.recovery_text, 1)
+        button_layout = QHBoxLayout()
+        self.refresh_button = QPushButton("Refresh")
+        self.refresh_button.clicked.connect(self.refresh_requested.emit)
+        self.copy_button = QPushButton("Copy details")
+        self.copy_button.clicked.connect(lambda: QApplication.clipboard().setText(self.recovery_text.toPlainText()))
+        self.close_button = QPushButton("Close")
+        self.close_button.clicked.connect(self.close)
+        for button in (self.refresh_button, self.copy_button, self.close_button):
+            button_layout.addWidget(button)
+        layout.addLayout(button_layout)
+        self.refresh_metrics()
+
+    def refresh_metrics(self, available_geometry: QRect | None = None) -> None:
+        """Keep the reader and its native actions reachable on the available screen."""
+        for button in (self.refresh_button, self.copy_button, self.close_button):
+            button.setMinimumHeight(control_height(button.fontMetrics().height()))
+        fit_form(self, available_geometry)
+
+    def show_results(self, results: tuple[MergeRecovery, ...], diagnostic: str = "", recovery_dir: str = "") -> None:
+        """Show exact copyable locations while leaving any new resolution to the user."""
+        descriptions = ["Retained merge results. Copy a path to inspect the saved file; apply any resolution manually."]
+        for result in results:
+            descriptions.append(conflict_path_label(result.path) + " (" + result.saved_at + ")\n" + result.filename)
+        if not results:
+            descriptions.append("No recorded merge results were found.")
+        if diagnostic:
+            descriptions = [diagnostic]
+        if recovery_dir:
+            descriptions.append("Recovery directory:\n" + recovery_dir)
+        self.recovery_text.setPlainText("\n\n".join(descriptions))
+        self.refresh_button.setEnabled(True)