gitpane 1.0.0__py3-none-any.whl

gitpane/controller/conflict_controller.py

@@ -0,0 +1,885 @@
+"""Resolve the conflicts of a merge, a rebase or a replay from a repository window."""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, Qt
+from PySide6.QtWidgets import QMessageBox
+from shiboken6 import isValid
+
+from gitpane.controller.refresh_controller import RefreshScope
+from gitpane.controller.stash_controller import StashDropAfterResolution
+from gitpane.history.file_history import WindowCapability
+from gitpane.history.repository_value import FileStatus
+from gitpane.operation.diagnostic import Diagnostic
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.operation.repository_operation import OperationAction, OperationIntent
+from gitpane.preference.preference_store import CONFLICT_PROMPT_PREFERENCE_KEY
+from gitpane.reference.reference_edit import MergeAbortIntent
+from gitpane.reference.stash import StashObservation
+from gitpane.sequencer.conflict import NO_CONFLICT_SELECTED_TEXT, ConflictResolutionIntent, capture_conflict_result, conflict_path_label, has_deleted_side, snapshot_has_conflicts
+from gitpane.sequencer.merge_state import ABORT_ACTION, MERGE_ABORT_REFRESH_REASON, MergeBannerState, merge_action_reason
+from gitpane.sequencer.mergetool import MergetoolRequest, MergetoolStatus
+from gitpane.sequencer.replay_state import BUSY_ACTION_REASON
+from gitpane.tool.mergetool_recipe import MERGETOOL_COMMAND_PREFERENCE_KEY, MERGETOOL_FILENAME_PREFERENCE_KEY, MergetoolRecipe
+from gitpane.ui.sequencer.conflict_dialog import ConflictConfirmation, ConflictDialog, ConflictPrompt, DeletedFileDialog, MergeConfirmation
+from gitpane.ui.sequencer.merge_recovery_dialog import MergeRecoveryDialog
+from gitpane.ui.window_control.dialog_modality import open_window_modal, prepare_message_box
+from gitpane.worktree.command_sequence import FileTask, GitCommandError
+from gitpane.worktree.worktree_snapshot import CONFLICT_ROLE_BY_STAGE, WorktreeKey
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+    from gitpane.controller.operation_policy import OperationPolicy
+    from gitpane.controller.rebase_controller import RebaseController
+    from gitpane.controller.reference_form_controller import ReferenceFormController
+    from gitpane.controller.refresh_controller import RefreshController
+    from gitpane.controller.replay_controller import ReplayController
+    from gitpane.controller.session_registry import SessionRegistry
+    from gitpane.controller.setting_controller import SettingController
+    from gitpane.controller.staging_session_registry import StagingSessionRegistry
+    from gitpane.controller.stash_controller import StashController
+    from gitpane.controller.window_activation import WindowActivationFilter
+    from gitpane.controller.worktree_state_controller import WorktreeStateController
+    from gitpane.history.repository import GitRepository
+    from gitpane.operation.diagnostic import DiagnosticLog
+    from gitpane.operation.repository_operation import OperationOutcome, RepositoryOperationService
+    from gitpane.preference.preference_store import PreferenceStore
+    from gitpane.reference.reference_edit import ReferenceService
+    from gitpane.reference.stash import StashService
+    from gitpane.sequencer.conflict import ConflictSelection, ConflictService, ConflictState
+    from gitpane.sequencer.mergetool import MergetoolResult, MergetoolSeries, MergetoolService
+    from gitpane.sequencer.rebase import RebaseService
+    from gitpane.sequencer.rebase_state import RebaseSnapshot
+    from gitpane.worktree.mutation import MutationOutcome, MutationService
+    from gitpane.worktree.staging import StagingSession
+    from gitpane.worktree.worktree_service import WorktreeService
+    from gitpane.worktree.worktree_snapshot import WorktreeSnapshot
+
+# The name of the merge banner's Abort in its console and in its question.
+MERGE_ABORT_LABEL = "Abort merge"
+# Asked only when the working tree no longer matches the tree the merge left, or when that could not be read.
+MERGE_ABORT_QUESTION = ("Abort the merge in progress?\n\nChanges made since the merge stopped, such as resolved conflicts, will be lost. "
+                        "Submodule content is not changed.")
+MERGE_ABORT_CANCEL_LABEL = "Cancel"
+
+
+@dataclass(frozen=True)
+class MergetoolPublication:
+    """What a merge tool series must still match for its terminal reads to become the displayed worktree state.
+
+    The worktree, the Git executable and the configuration generation are the ones the series started with, and the
+    displayed read is still the last one this series published: any other read published meanwhile wins.
+    """
+
+    key: WorktreeKey
+    git_filename: str
+    staging_generation: int
+    configuration_generation: int
+
+
+class ConflictController(QObject):
+    """The conflicts of every repository window: the conflict list with Mark solved and Delete file, the merge tool series, the retained merge results, the stash a Stash pop kept, and the Abort and Continue of a merge."""
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, operation_policy_controller: OperationPolicy, staging_session_registry_controller: StagingSessionRegistry, window_activation_controller: WindowActivationFilter,
+                 refresh_controller: RefreshController, worktree_state_controller: WorktreeStateController, setting_controller: SettingController, reference_form_controller: ReferenceFormController,
+                 replay_controller: ReplayController, rebase_controller: RebaseController, stash_controller: StashController, preference: PreferenceStore, repository: GitRepository, worktree_service: WorktreeService,
+                 repository_operation: RepositoryOperationService, rebase: RebaseService, reference: ReferenceService, stash: StashService, mutation: MutationService, conflict: ConflictService, mergetool: MergetoolService,
+                 diagnostic_log: DiagnosticLog | None, parent: QObject | None = None) -> None:
+        """Receive the services and the lower controllers conflicts are resolved with; the wiring builds it after the stash controller, and the repository windows reach it through the wiring."""
+        super().__init__(parent)
+        self.session_registry_controller = session_registry_controller
+        self.operation_policy_controller = operation_policy_controller
+        self.staging_session_registry_controller = staging_session_registry_controller
+        self.window_activation_controller = window_activation_controller
+        self.refresh_controller = refresh_controller
+        self.worktree_state_controller = worktree_state_controller
+        self.setting_controller = setting_controller
+        self.reference_form_controller = reference_form_controller
+        self.replay_controller = replay_controller
+        self.rebase_controller = rebase_controller
+        self.stash_controller = stash_controller
+        self.preference = preference
+        self.repository = repository
+        self.worktree_service = worktree_service
+        self.repository_operation = repository_operation
+        self.rebase = rebase
+        self.reference = reference
+        self.stash = stash
+        self.mutation = mutation
+        self.conflict = conflict
+        self.mergetool = mergetool
+        self.diagnostic_log = diagnostic_log
+        self.merge_abort_intent_by_id: dict[str, MergeAbortIntent] = {}
+        # The operation ID of the latest Abort click of each window: an answer about the work at risk for an older click is dropped.
+        self.merge_abort_pending_by_session: dict[str, str] = {}
+        self.merge_abort_confirmation_by_session: dict[str, QMessageBox] = {}
+        self.merge_recovery_dialog_by_session: dict[str, MergeRecoveryDialog] = {}
+        self.merge_confirmation_by_id: dict[str, MergeConfirmation | DeletedFileDialog] = {}
+        self.mergetool_publication_by_series: dict[str, MergetoolPublication] = {}
+        self.conflict_dialog_by_session: dict[str, ConflictDialog] = {}
+        self.conflict_confirmation_by_session: dict[str, ConflictConfirmation] = {}
+        self.conflict_resolution_by_id: dict[str, ConflictResolutionIntent] = {}
+        self.conflict_followup_by_id: dict[str, tuple[ConflictResolutionIntent, ...]] = {}
+        self.conflict_prompt_by_session: dict[str, ConflictPrompt] = {}
+        self.conflict_retention_by_key: dict[WorktreeKey, StashObservation] = {}
+        self.conflict_retention_read_set: set[WorktreeKey] = set()
+
+    def open_conflict_dialog(self, session_id: str, selected_state: ConflictState | None = None) -> ConflictDialog | None:
+        """Open only current conflicts belonging to a management-capable repository window."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return None
+        window = self.session_registry_controller.window_by_session[session_id]
+        key = WorktreeKey.from_context(window.context)
+        state = self.conflict.state_by_key.get(key)
+        if window.context.is_bare or state is None or not state.fresh or not state.entries or (selected_state is not None and selected_state != state):
+            window.statusBar().showMessage("Refresh the repository before opening its current conflicts")
+            return None
+        dialog = self.conflict_dialog_by_session.get(session_id)
+        if dialog is None or not isValid(dialog):
+            dialog = ConflictDialog(state, window)
+            dialog.installEventFilter(self.window_activation_controller)
+            dialog.refresh_requested.connect(lambda: self._refresh_conflict_dialog(session_id))
+            dialog.mark_solved_requested.connect(lambda selection: self.mark_conflict_solved(session_id, selection))
+            dialog.delete_requested.connect(lambda selection: self.mark_conflict_solved(session_id, selection, delete_file=True))
+            dialog.open_tool_requested.connect(lambda selection: self.open_mergetool(session_id, selection))
+            dialog.settings_requested.connect(lambda: self.setting_controller.show_setting(session_id, section="mergetool"))
+            dialog.stop_series_requested.connect(lambda: self._stop_mergetool_series(session_id))
+            dialog.finished.connect(lambda: self._stop_mergetool_series(session_id))
+            self.conflict_dialog_by_session[session_id] = dialog
+        dialog.show_state(state)
+        dialog.show_rebase_state(self.rebase.state_by_key.get(key))
+        self.replay_controller.replay_actions_changed()
+        dialog.show()
+        dialog.raise_()
+        if not self._conflict_state_is_recent(key, state):
+            self._refresh_conflict_dialog(session_id)
+        return dialog
+
+    def _conflict_state_is_recent(self, key: WorktreeKey, state: ConflictState) -> bool:
+        """Tell whether a conflict list can be shown as it was last read, with no read of its own.
+
+        It can when it comes from the complete worktree read currently shown, made with the current Git, and no read is
+        running or requested. Showing it writes nothing: every action on it checks the repository again before writing,
+        and Rescan stays the explicit way to see a resolution made outside the application.
+        """
+        staging = self.staging_session_registry_controller.staging_by_key.get(key)
+        if staging is None or staging.refresh_active or staging.refresh_queued or staging.explicit_refresh:
+            return False
+        snapshot = staging.snapshot
+        return (snapshot is not None and snapshot.fresh and snapshot.key == key and snapshot.generation == state.generation
+                and snapshot.git_filename == staging.git_filename == self.repository.git_filename)
+
+    def _refresh_conflict_dialog(self, session_id: str) -> None:
+        """Refresh the shared worktree without granting limited windows mutation access."""
+        if self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            dialog = self.conflict_dialog_by_session.get(session_id)
+            if dialog is not None and isValid(dialog):
+                dialog.begin_rescan()
+            self.staging_session_registry_controller.staging_session(self.session_registry_controller.session_by_id[session_id].repository_context).refresh(explicit=True)
+
+    def _conflict_action_snapshot(self, session_id: str, selection: ConflictSelection) -> WorktreeSnapshot | None:
+        """Reject expired selections with visible feedback instead of silently losing the click."""
+        dialog = self.conflict_dialog_by_session.get(session_id)
+        if dialog is None or not isValid(dialog) or not dialog.isVisible():
+            return None
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            dialog.error_label.setText("This window can no longer resolve conflicts. Reopen the repository.")
+            return None
+        if dialog.busy:
+            dialog.error_label.setText("A conflict resolution is already running. Wait for it to finish.")
+            return None
+        if not selection.paths:
+            dialog.error_label.setText(NO_CONFLICT_SELECTED_TEXT)
+            return None
+        staging = self.staging_session_registry_controller.staging_by_key.get(selection.key)
+        snapshot = staging.snapshot if staging is not None else None
+        if (dialog.selection() != selection or not dialog.state.fresh or snapshot is None or not snapshot.fresh
+                or snapshot.generation != selection.generation):
+            dialog.error_label.setText("The conflict list changed or is refreshing. Wait for the scan to finish, then select the file and try again.")
+            self._refresh_conflict_dialog(session_id)
+            return None
+        return snapshot
+
+    def open_merge_recovery(self, session_id: str) -> MergeRecoveryDialog | None:
+        """Open retained results even when current conflicts are absent or unreadable."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return None
+        dialog = self.merge_recovery_dialog_by_session.get(session_id)
+        if dialog is None or not isValid(dialog):
+            dialog = MergeRecoveryDialog(self.session_registry_controller.window_by_session[session_id])
+            dialog.installEventFilter(self.window_activation_controller)
+            dialog.refresh_requested.connect(lambda: self._refresh_merge_recovery(session_id))
+            self.merge_recovery_dialog_by_session[session_id] = dialog
+        dialog.show()
+        dialog.raise_()
+        self._refresh_merge_recovery(session_id)
+        return dialog
+
+    def _refresh_merge_recovery(self, session_id: str) -> None:
+        """Discover retained output independently of the vanished session that produced it."""
+        dialog = self.merge_recovery_dialog_by_session.get(session_id)
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if dialog is None or not isValid(dialog) or session is None:
+            return
+        context = session.repository_context
+        key = WorktreeKey.from_context(context)
+        store = self.mergetool.temporary_store.recovery_store
+        dialog.read_generation += 1
+        generation = dialog.read_generation
+        dialog.refresh_button.setEnabled(False)
+        dialog.recovery_text.setPlainText("Reading retained merge results...")
+
+        def sequence() -> Generator:
+            """Keep recovery directory and content reads off the Qt thread."""
+            return (yield FileTask(lambda: store.discover(context)))
+
+        def complete(results: object, error: Exception | None) -> None:
+            """Show only locations discovered for this still-open worktree."""
+            current = self.session_registry_controller.session_by_id.get(session_id)
+            if not isValid(dialog) or self.merge_recovery_dialog_by_session.get(session_id) is not dialog or current is None or WorktreeKey.from_context(current.repository_context) != key:
+                return
+            if generation != dialog.read_generation:
+                return
+            if error is not None:
+                dialog.show_results((), "Could not read retained merge results. Inspect the recovery directory: " + store.root_dir(context))
+                return
+            dialog.show_results(results, recovery_dir=store.root_dir(context))
+
+        self.worktree_service.run(context, self.repository.git_filename, sequence(), complete)
+
+    def open_mergetool(self, session_id: str, selection: ConflictSelection) -> None:
+        """Capture all selected conflicts once under the original session authority."""
+        snapshot = self._conflict_action_snapshot(session_id, selection)
+        if snapshot is None:
+            return
+        dialog = self.conflict_dialog_by_session[session_id]
+        path = next(iter(selection.paths))
+        entry = next((entry for entry in dialog.state.entries if entry.path == path), None)
+        if entry is None:
+            return
+        self.preference.initialize_mergetool()
+        owner = OperationIntent.capture(uuid.uuid4().hex, snapshot.context, snapshot.git_filename, session_id=session_id,
+                                        generation=self.session_registry_controller.generation_by_session[session_id], operation="Resolve conflict with external tool", action=OperationAction.CONFLICT_TOOL)
+        recipe = MergetoolRecipe(str(self.preference.value_by_key[MERGETOOL_FILENAME_PREFERENCE_KEY]), str(self.preference.value_by_key[MERGETOOL_COMMAND_PREFERENCE_KEY]))
+        request = MergetoolRequest(snapshot, path, entry.sides, owner, recipe)
+        dialog.merge_series_id = owner.operation_id
+        staging = self.staging_session_registry_controller.staging_by_key.get(selection.key)
+        if staging is not None:
+            self.mergetool_publication_by_series[owner.operation_id] = MergetoolPublication(snapshot.key, snapshot.git_filename, staging.generation,
+                                                                                            staging.configuration_generation)
+        dialog.set_busy(True)
+        dialog.error_label.setText("Preparing conflict resolution: " + conflict_path_label(path))
+        dialog.settings_button.hide()
+        def is_current() -> bool:
+            """Bind every file in this series to the captured session, Git and executable recipe."""
+            return (self.operation_policy_controller.operation_allowed(owner) and self.repository.git_filename == snapshot.git_filename
+                    and self.preference.value_by_key[MERGETOOL_FILENAME_PREFERENCE_KEY] == recipe.program_filename
+                    and self.preference.value_by_key[MERGETOOL_COMMAND_PREFERENCE_KEY] == recipe.command)
+
+        self.mergetool.merge_series(request, selection.paths, is_current)
+
+    def _stop_mergetool_series(self, session_id: str) -> None:
+        """Stop future editors while the current one remains owned by its service."""
+        for series_id, series in tuple(self.mergetool.series_by_id.items()):
+            if series.request.operation.session_id == session_id:
+                self.mergetool.stop_series(series_id)
+
+    def mergetool_series_changed(self, series: MergetoolSeries) -> None:
+        """Keep mutation controls disabled throughout capture, process and publication waits."""
+        self.rebase_controller.rebase_actions_changed()
+        self.replay_controller.replay_actions_changed()
+        self.worktree_state_controller.merge_banner_actions_changed()
+        if not self.operation_policy_controller.operation_allowed(series.request.operation):
+            return
+        dialog = self.conflict_dialog_by_session.get(series.request.operation.session_id)
+        if dialog is None or not isValid(dialog) or dialog.merge_series_id != series.request.operation.operation_id:
+            return
+        dialog.set_busy(True)
+        dialog.stop_series_button.setVisible(len(series.paths) > 1)
+        dialog.stop_series_button.setEnabled(not series.stop_requested)
+        if series.stop_requested:
+            dialog.error_label.setText("Series stopped. Waiting for the current KDiff3 process.")
+        elif series.current_id:
+            current_position = series.position - 1
+            dialog.error_label.setText("Resolving: " + conflict_path_label(series.paths[current_position]))
+        else:
+            dialog.error_label.setText("Reading current merge conflicts...")
+
+    def mergetool_series_finished(self, series: MergetoolSeries) -> None:
+        """Expose failed rereads and preserve the list until fresh Git proves it empty."""
+        self.mergetool_publication_by_series.pop(series.request.operation.operation_id, None)
+        self.stash_controller.continue_stash_drops_after_resolution()
+        self.rebase_controller.rebase_actions_changed()
+        self.replay_controller.replay_actions_changed()
+        self.worktree_state_controller.merge_banner_actions_changed()
+        dialog = self.conflict_dialog_by_session.get(series.request.operation.session_id)
+        if dialog is None or not isValid(dialog) or dialog.merge_series_id != series.request.operation.operation_id:
+            return
+        dialog.merge_series_id = ""
+        dialog.set_busy(False)
+        dialog.stop_series_button.hide()
+        if not self.operation_policy_controller.operation_allowed(series.request.operation):
+            if dialog.state.key == series.request.snapshot.key:
+                dialog.error_label.setText(series.diagnostic or "Series stopped. The original repository session is no longer current.")
+            return
+        if series.diagnostic:
+            # A series stops at the first result that offers Settings, and that result's diagnostic is the series' own.
+            settings_available = bool(series.results) and series.results[-1].settings_available
+            dialog.show_mergetool_result(series.diagnostic, settings_available=settings_available)
+        if series.snapshot is not None and not series.diagnostic:
+            # The last terminal read has already been published, adopted or observed; only a read the series made
+            # after it, to skip a file resolved elsewhere, still has to become the list.
+            state = self.conflict.state_by_key.get(series.snapshot.key)
+            last_result_snapshot = series.results[-1].snapshot if series.results else None
+            if state is None or series.snapshot is not last_result_snapshot:
+                state = self.conflict.observe(series.snapshot.key, series.snapshot)
+            dialog.show_state(state)
+            if state.fresh and not state.entries:
+                self.replay_controller.request_replay_auto_continue(series.request.operation.session_id, series.snapshot.key)
+                dialog.close()
+
+    def confirm_mergetool(self, request: MergetoolRequest, reason: str) -> None:
+        """Present an explicit answer only in the surviving original repository session."""
+        request_id = request.operation.operation_id
+        window = self.session_registry_controller.window_by_session.get(request.operation.session_id)
+        if window is None or not isValid(window) or not self.operation_policy_controller.operation_allowed(request.operation):
+            self.mergetool.confirm(request_id, False)
+            return
+        if reason == "deleted-side":
+            confirmation = DeletedFileDialog(request.path, window, keep_available=request.snapshot.fingerprint_by_path.get(request.path) != "absent")
+            confirmation.finished.connect(lambda result: self.mergetool.confirm_deletion(request_id, confirmation.delete_result if result else None))
+            dialog = self.conflict_dialog_by_session.get(request.operation.session_id)
+            if dialog is not None and isValid(dialog):
+                dialog.error_label.setText("Choose whether to keep or delete: " + conflict_path_label(request.path))
+        else:
+            confirmation = MergeConfirmation(request.path, reason, window)
+            confirmation.finished.connect(lambda result: self.mergetool.confirm(request_id, bool(result)))
+        confirmation.installEventFilter(self.window_activation_controller)
+        self.merge_confirmation_by_id[request_id] = confirmation
+        confirmation.finished.connect(lambda: self.merge_confirmation_by_id.pop(request_id, None))
+        open_window_modal(confirmation)
+
+    def close_merge_confirmation(self, request_id: str) -> None:
+        """Dismiss obsolete questions when shutdown or invalidation completes their owner."""
+        confirmation = self.merge_confirmation_by_id.pop(request_id, None)
+        if confirmation is not None and isValid(confirmation):
+            confirmation.reject()
+
+    def mergetool_finished(self, result: MergetoolResult) -> None:
+        """Show the terminal conflict read immediately, as the staging state when nothing newer wins, else read again."""
+        request = result.request
+        if result.recovery_filename:
+            for session_id, session in tuple(self.session_registry_controller.session_by_id.items()):
+                if WorktreeKey.from_context(session.repository_context) == request.snapshot.key:
+                    self._refresh_merge_recovery(session_id)
+        if self.diagnostic_log is not None:
+            message = f"Result: {result.status.value}. " + result.diagnostic
+            if result.recovery_filename:
+                message += " Saved result kept at: " + result.recovery_filename
+            self.diagnostic_log.write(Diagnostic("External merge", request.snapshot.context.repository_dir, request.recipe.program_filename, [], message, return_code=result.return_code).prepare())
+        series_id = self.mergetool.series_id_by_request.get(request.operation.operation_id, request.operation.operation_id)
+        allowed = self.operation_policy_controller.operation_allowed(request.operation)
+        staging = self.staging_session_registry_controller.staging_by_key.get(request.snapshot.key)
+        if allowed and result.status == MergetoolStatus.SAVED:
+            # Asked before the tool's terminal read is published: that publication is the read that decides.
+            self._request_stash_drop_after_resolution(request.operation)
+        adopted = allowed and staging is not None and not self.session_registry_controller.shutdown_requested and self._adopt_mergetool_snapshot(series_id, result, staging)
+        dialog = self.conflict_dialog_by_session.get(request.operation.session_id)
+        if dialog is not None and isValid(dialog) and dialog.merge_series_id == series_id:
+            message = result.diagnostic
+            if result.recovery_filename:
+                message += " Saved result retained at: " + result.recovery_filename
+            if not allowed:
+                dialog.set_busy(False)
+                dialog.stop_series_button.hide()
+                if dialog.state.key == request.snapshot.key:
+                    dialog.error_label.setText(message)
+                return
+            busy = any(series.request.operation.session_id == request.operation.session_id for series in self.mergetool.series_by_id.values())
+            dialog.set_busy(busy)
+            dialog.show_mergetool_result(message, settings_available=result.settings_available)
+            if result.snapshot is not None and not adopted:
+                state = self.conflict.observe(request.snapshot.key, result.snapshot)
+                dialog.show_state(state)
+        if not allowed:
+            return
+        if staging is not None and not self.session_registry_controller.shutdown_requested:
+            if not adopted:
+                staging.refresh(explicit=True)
+            self.rebase_controller.observe_rebase(request.operation.session_id)
+
+    def _adopt_mergetool_snapshot(self, series_id: str, result: MergetoolResult, staging: StagingSession) -> bool:
+        """Publish the merge tool's terminal read as the staging state when nothing newer has to win; answer whether it did.
+
+        That read is a complete read of the worktree taken after the tool's last write. It becomes the displayed state
+        only while the series still owns its publication, for the same worktree, Git and configuration, and while no
+        other read has been published, is running or was asked for. It is shown under a new read number of the staging
+        session, so selections and prepared actions of the previous state no longer apply.
+        """
+        publication = self.mergetool_publication_by_series.get(series_id)
+        snapshot = result.snapshot
+        if publication is None or snapshot is None or not snapshot.fresh:
+            return False
+        if (snapshot.key != publication.key or staging.key != publication.key or snapshot.git_filename != publication.git_filename
+                or staging.git_filename != publication.git_filename or self.repository.git_filename != publication.git_filename
+                or staging.configuration_generation != publication.configuration_generation):
+            return False
+        if staging.generation != publication.staging_generation or staging.refresh_active or staging.refresh_queued or staging.explicit_refresh or staging.busy:
+            return False
+        staging.generation += 1
+        shown, _reusable = staging._publish_operation_snapshot(replace(snapshot, generation=staging.generation))
+        staging._show()
+        if shown:
+            staging._reconcile_selection()
+        self.mergetool_publication_by_series[series_id] = replace(publication, staging_generation=staging.generation)
+        staging.changed.emit()
+        return True
+
+    def mark_conflict_solved(self, session_id: str, selection: ConflictSelection, *, delete_file: bool = False) -> None:
+        """Recapture the selected working results and stage their exact bytes as they were at the click.
+
+        A file without conflict markers is staged without a question, since the click is the user's choice; a file that
+        still holds markers gets a warning naming their lines, and a deletion keeps its confirmation.
+        """
+        snapshot = self._conflict_action_snapshot(session_id, selection)
+        if snapshot is None:
+            return
+        dialog = self.conflict_dialog_by_session[session_id]
+        owner = OperationIntent.capture(uuid.uuid4().hex, snapshot.context, snapshot.git_filename, session_id=session_id,
+                                        generation=self.session_registry_controller.generation_by_session[session_id], operation="Resolve conflict", action=OperationAction.CONFLICT_STAGE)
+        dialog.set_busy(True)
+        dialog.error_label.clear()
+
+        def capture() -> Generator:
+            """Accept the bytes present at the click, then have Git verify everything else against the list shown.
+
+            An edit made before the click is the result the user chose, so its bytes are accepted locally. The index,
+            HEAD and conversion settings are never taken from now: Git compares them with the read the list was built
+            from, and the accepted images are proven unchanged again before the intents are built from them.
+            """
+            accepted, image_by_path = yield FileTask(lambda: capture_conflict_result(snapshot, selection.paths))
+            yield from self.worktree_service.verify(accepted, selection.paths)
+            intents = []
+            for path in selection.paths:
+                entry = next(entry for entry in accepted.entries if entry.path == path and entry.status == FileStatus.UNMERGED)
+                role_set = set()
+                for side in entry.conflict_sides:
+                    role_set.add(CONFLICT_ROLE_BY_STAGE[side.stage])
+                if delete_file and not has_deleted_side(entry.conflict_sides):
+                    raise ValueError("Delete file requires a conflict with a deleted side")
+                image = image_by_path[path]
+                delete = delete_file or not image.exists and not {"LOCAL", "REMOTE"}.issubset(role_set)
+                intent_owner = replace(owner, operation_id=uuid.uuid4().hex)
+                # The markers are looked for in the bytes accepted here, so the warning describes exactly what would be staged.
+                intents.append((yield FileTask(lambda path=path, image=image, intent_owner=intent_owner, delete=delete:
+                                               ConflictResolutionIntent.accept(accepted, path, image, intent_owner, delete=delete).with_marker_lines())))
+            return tuple(intents)
+
+        def complete(value: object, error: Exception | None) -> None:
+            """Only a surviving originating dialog can confirm the captured result."""
+            if not isValid(dialog):
+                return
+            if error is not None or not self.operation_policy_controller.operation_allowed(owner) or not dialog.isVisible():
+                dialog.set_busy(False)
+                if error is not None:
+                    diagnostic = error.diagnostic if isinstance(error, GitCommandError) else Diagnostic("Resolve conflict", snapshot.context.repository_dir, snapshot.git_filename, [], str(error)).prepare()
+                    dialog.error_label.setText("Could not prepare conflict resolution: " + diagnostic.cause)
+                    self._refresh_conflict_dialog(session_id)
+                return
+            self._confirm_manual_result(session_id, value)
+
+        self.worktree_service.run(snapshot.context, snapshot.git_filename, capture(), complete)
+
+    def _confirm_manual_result(self, session_id: str, intents: tuple[ConflictResolutionIntent, ...]) -> None:
+        """Stage each original selected result in turn, asking first only for a file that still holds conflict markers or for a deletion.
+
+        Clicking Mark conflict as solved or Keep modified file already is the user's explicit choice, so a file without
+        markers is staged straight away. Markers left in the file get a warning, and a deletion either removes a working
+        file or stages something other than what Keep modified file says, so both keep their question. Each result is
+        the one captured at the click: nothing is ever retargeted from the live selection.
+        """
+        dialog = self.conflict_dialog_by_session.get(session_id)
+        if dialog is None or not isValid(dialog):
+            return
+        intent, *remaining_intents = intents
+        owner = intent.operation
+        if not dialog.isVisible() or not self.operation_policy_controller.operation_allowed(owner):
+            dialog.set_busy(False)
+            return
+        if not intent.marker_lines and not intent.delete:
+            self._submit_manual_result(intent, tuple(remaining_intents))
+            return
+        confirmation = ConflictConfirmation(intent.path, dialog, delete=intent.delete, remove_existing=intent.delete and intent.image.exists, marker_lines=intent.marker_lines)
+        confirmation.installEventFilter(self.window_activation_controller)
+        self.conflict_confirmation_by_session[session_id] = confirmation
+
+        def answer(result: int) -> None:
+            """Submit only explicit agreement; stale results are rechecked by the mutation."""
+            self.conflict_confirmation_by_session.pop(session_id, None)
+            if not result or not dialog.isVisible() or not self.operation_policy_controller.operation_allowed(owner):
+                dialog.set_busy(False)
+                return
+            self._submit_manual_result(intent, tuple(remaining_intents))
+
+        confirmation.finished.connect(answer)
+        open_window_modal(confirmation)
+
+    def _submit_manual_result(self, intent: ConflictResolutionIntent, remaining_intents: tuple[ConflictResolutionIntent, ...]) -> None:
+        """Hand one accepted result to the mutation and remember the selected files still waiting behind it.
+
+        The mutation checks again that the accepted bytes, the index and HEAD are unchanged before staging anything, so
+        a result submitted without a question is refused exactly like a confirmed one when another program changed it.
+        """
+        operation_id = intent.operation.operation_id
+        self.conflict_resolution_by_id[operation_id] = intent
+        self.conflict_followup_by_id[operation_id] = remaining_intents
+        self.mutation.resolve_conflict(intent)
+
+    def conflict_resolution_finished(self, outcome: MutationOutcome) -> None:
+        """Keep refusal diagnostics visible until a deliberate rescan or new selection."""
+        intent = self.conflict_resolution_by_id.pop(outcome.operation_id, None)
+        remaining_intents = self.conflict_followup_by_id.pop(outcome.operation_id, ())
+        if intent is None:
+            return
+        dialog = self.conflict_dialog_by_session.get(intent.operation.session_id)
+        if dialog is not None and isValid(dialog):
+            dialog.set_busy(bool(remaining_intents) and outcome.status == OperationStatus.SUCCESS.value)
+            if outcome.diagnostic is not None:
+                dialog.error_label.setText(outcome.diagnostic.cause)
+            if remaining_intents and outcome.status == OperationStatus.SUCCESS.value:
+                self._read_manual_followup(intent, remaining_intents)
+        if not remaining_intents and outcome.status == OperationStatus.SUCCESS.value:
+            self._request_stash_drop_after_resolution(intent.operation)
+            refusal = self._replay_auto_continue_refusal(intent.operation)
+            if not refusal:
+                self.replay_controller.request_replay_auto_continue(intent.operation.session_id, intent.operation.key)
+            elif self.diagnostic_log is not None:
+                self.diagnostic_log.write(Diagnostic("Automatic replay continue", intent.operation.context.repository_dir, self.repository.git_filename, [],
+                                                     "Conflict resolution finished in GitPane: automatic Continue not requested (" + refusal + ").").prepare())
+
+    def _replay_auto_continue_refusal(self, operation: OperationIntent) -> str:
+        """Tell why a finished resolution may not ask for the automatic Continue, or return an empty text when it may.
+
+        Only the requesting window has to be alive, allowed to write and still on the same worktree. A graph refresh
+        in between (F5, another operation) changes the history generation but not the paused operation, and the
+        request rereads the native state, its owner and its mode itself before continuing anything.
+        """
+        if operation.session_id is None:
+            return "no repository window requested this resolution"
+        session = self.session_registry_controller.session_by_id.get(operation.session_id)
+        if session is None or not self.operation_policy_controller.allows(operation.session_id, WindowCapability.MANAGE):
+            return "the repository window was closed or can no longer write"
+        if session.repository_context != operation.context:
+            return "the repository window now shows another worktree"
+        return ""
+
+    def _read_manual_followup(self, completed: ConflictResolutionIntent, remaining_intents: tuple[ConflictResolutionIntent, ...]) -> None:
+        """Rebase only confirmed index changes while retaining every pending result's identity."""
+        snapshot = completed.snapshot
+        session_id = completed.operation.session_id
+
+        def capture() -> Generator:
+            """Require unchanged neighbours and pending bytes before the next separate confirmation."""
+            from gitpane.worktree.worktree_file import validate_image
+
+            current = yield from self.worktree_service.capture(snapshot.context, snapshot.git_filename, snapshot.generation)
+            yield from self.worktree_service.verify_conversion(snapshot)
+            if current.head_oid != snapshot.head_oid:
+                raise ValueError("Repository changed during conflict resolution; rescan merge conflicts")
+            unchanged_records = []
+            for output in (snapshot.index_entries, current.index_entries):
+                records = []
+                for record in output.split(b"\0"):
+                    _metadata, _separator, path = record.partition(b"\t")
+                    if record and path != completed.path:
+                        records.append(record)
+                unchanged_records.append(sorted(records))
+            before_records, after_records = unchanged_records
+            if before_records != after_records:
+                raise ValueError("Other index entries changed; rescan merge conflicts")
+            intents = []
+            for pending in remaining_intents:
+                yield FileTask(lambda pending=pending: validate_image(current.context, pending.path, pending.image))
+                intents.append(replace(pending, snapshot=current))
+            return tuple(intents)
+
+        def complete(value: object, error: Exception | None) -> None:
+            """A lost reread stops the selection without undoing already staged results."""
+            dialog = self.conflict_dialog_by_session.get(session_id)
+            if dialog is None or not isValid(dialog):
+                return
+            if error is not None:
+                dialog.set_busy(False)
+                diagnostic = error.diagnostic if isinstance(error, GitCommandError) else Diagnostic("Resolve conflict", snapshot.context.repository_dir, snapshot.git_filename, [], str(error)).prepare()
+                dialog.error_label.setText(diagnostic.cause)
+                return
+            self._confirm_manual_result(session_id, value)
+
+        self.worktree_service.run(snapshot.context, snapshot.git_filename, capture(), complete)
+
+    def offer_conflict_resolution(self, session_id: str) -> None:
+        """Offer a current conflict list or open it directly when the proposal is suppressed."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        state = self.conflict.state_by_key.get(WorktreeKey.from_context(session.repository_context))
+        if state is None or not state.fresh or not state.entries:
+            return
+        if self.preference.read(CONFLICT_PROMPT_PREFERENCE_KEY):
+            self.open_conflict_dialog(session_id, state)
+            return
+        existing = self.conflict_prompt_by_session.get(session_id)
+        if existing is not None and isValid(existing) and existing.isVisible():
+            return
+        generation = session.generation
+        prompt = ConflictPrompt(self.preference, self.session_registry_controller.window_by_session[session_id])
+        prompt.installEventFilter(self.window_activation_controller)
+        self.conflict_prompt_by_session[session_id] = prompt
+
+        def resolve() -> None:
+            """Discard an answer whose originating session has since been refreshed or closed."""
+            if not session.is_closed and session.generation == generation:
+                self.open_conflict_dialog(session_id, state)
+
+        prompt.resolve_requested.connect(resolve)
+        prompt.show()
+
+    def track_conflict_retention(self, key: WorktreeKey, observation: StashObservation) -> None:
+        """Keep watching the stash a pop left behind only while that can still tell the user something.
+
+        A stash known to be gone (retained False) or a pop that left no conflict ends the watch. An unknown terminal
+        read (no conflict list) keeps it until a fresh read says otherwise. The pop's own result is never changed.
+        A drop still waiting for an earlier pop's resolution is forgotten: only the stash this pop kept may be dropped.
+        """
+        self.stash_controller.stash_drop_after_resolution_by_key.pop(key, None)
+        if observation.retained is False or observation.unmerged_paths == ():
+            self._stop_conflict_retention(key)
+            return
+        self.conflict_retention_by_key[key] = observation
+
+    def _stop_conflict_retention(self, key: WorktreeKey) -> None:
+        """End the watch of a worktree's retained stash and clear it from the conflict lists still open on that worktree."""
+        if self.conflict_retention_by_key.pop(key, None) is None:
+            return
+        for dialog in self.conflict_dialog_by_session.values():
+            if isValid(dialog) and dialog.state.key == key:
+                dialog.show_retention(None)
+
+    def read_conflict_retention(self, key: WorktreeKey) -> None:
+        """Recheck a previously observed stash independently of historic operation output, and only while conflicts remain."""
+        previous = self.conflict_retention_by_key.get(key)
+        staging = self.staging_session_registry_controller.staging_by_key.get(key)
+        if previous is None or staging is None:
+            return
+        snapshot = staging.snapshot
+        if snapshot is None or not snapshot.fresh:
+            return
+        # Checked before the read in progress, so a resolution ends the watch even while an older read is still out.
+        if previous.retained is False or not snapshot_has_conflicts(snapshot):
+            self._stop_conflict_retention(key)
+            return
+        if key in self.conflict_retention_read_set:
+            return
+        self.conflict_retention_read_set.add(key)
+
+        def complete(observation: StashObservation | None, error: Exception | None) -> None:
+            """Publish only for the watch, session and worktree read this answer was asked for."""
+            self.conflict_retention_read_set.discard(key)
+            if (self.staging_session_registry_controller.staging_by_key.get(key) is not staging or staging.snapshot is not snapshot or staging.context != snapshot.context
+                    or self.conflict_retention_by_key.get(key) is not previous):
+                return
+            if not snapshot_has_conflicts(snapshot):
+                self._stop_conflict_retention(key)
+                return
+            current = replace(previous, retained=None)
+            if error is None and observation is not None:
+                current = observation.retention_of(StashObservation(previous.retained_oid, ()))
+            if current.retained is False:
+                self._stop_conflict_retention(key)
+                return
+            self.conflict_retention_by_key[key] = current
+            for dialog in self.conflict_dialog_by_session.values():
+                if isValid(dialog) and dialog.state.key == key and dialog.state.fresh:
+                    dialog.show_retention(current)
+
+        self.worktree_service.run(staging.context, staging.git_filename, self.stash.observe(staging.context), complete)
+
+    def _request_stash_drop_after_resolution(self, operation: OperationIntent) -> None:
+        """Ask to drop the stash a Stash pop kept, after a conflict of that pop was resolved in GitPane.
+
+        Only the two places where GitPane itself resolves a conflict call this: Mark solved (or Delete file) in the
+        conflict list, and a result saved in the merge tool GitPane started. A resolution made in a terminal, a reset
+        or an abandoned merge never asks, so the stash then stays. Nothing is asked when no kept stash is watched.
+        """
+        key, session_id = operation.key, operation.session_id
+        retention = self.conflict_retention_by_key.get(key)
+        staging = self.staging_session_registry_controller.staging_by_key.get(key)
+        if session_id is None or retention is None or retention.retained is False or retention.retained_oid is None or staging is None:
+            return
+        self.stash_controller.stash_drop_after_resolution_by_key[key] = StashDropAfterResolution(session_id, retention.retained_oid, staging.generation)
+        self.stash_controller.continue_stash_drop_after_resolution(key)
+
+    def abort_merge(self, session_id: str) -> None:
+        """Abort the merge the banner shows with Git's own merge --abort, asking first only when work would be lost.
+
+        The merge and HEAD are taken from the state the window shows, so the Abort applies to that merge only. One Git
+        read tells whether anything changed since the merge stopped; with nothing to lose the Abort starts at once,
+        otherwise a question opens with Cancel as the default and Escape answer. A new click replaces an open question.
+        The question opens once that read answers, so it is found in ``merge_abort_confirmation_by_session``. A click
+        that cannot act always says why in the status bar: busy, a merge that could not be read, or no merge, snapshot
+        or HEAD read yet, which a refresh brings.
+        """
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return
+        window = self.session_registry_controller.window_by_session.get(session_id)
+        session = self.session_registry_controller.session_by_id[session_id]
+        context = session.repository_context
+        if window is None or context.is_bare:
+            return
+        staging = self.staging_session_registry_controller.staging_by_key.get(WorktreeKey.from_context(context))
+        merge_state = staging.merge_banner_state if staging is not None else MergeBannerState()
+        snapshot = staging.snapshot if staging is not None else None
+        busy = self.mergetool.owns_repository(context.common_git_dir) or self.repository_operation.owns_worktree(WorktreeKey.from_context(context))
+        reason = merge_action_reason(merge_state, ABORT_ACTION, conflict_count=0, busy=busy)
+        if not reason and (not merge_state.in_progress or merge_state.merge is None or snapshot is None or snapshot.head_oid is None):
+            reason = MERGE_ABORT_REFRESH_REASON
+        if reason:
+            window.statusBar().showMessage(reason)
+            return
+        previous = self.merge_abort_confirmation_by_session.pop(session_id, None)
+        if previous is not None and isValid(previous):
+            previous.close()
+            previous.deleteLater()
+        merge_head_oids = merge_state.merge.parent_oids
+        operation = OperationIntent.capture(uuid.uuid4().hex, context, self.repository.git_filename, session_id=session_id, generation=self.session_registry_controller.generation_by_session[session_id],
+                                            targets=(*merge_head_oids, snapshot.head_oid), operation=MERGE_ABORT_LABEL, action=OperationAction.MERGE_ABORT)
+        intent = MergeAbortIntent(operation, merge_head_oids, snapshot.head_oid)
+        self.merge_abort_pending_by_session[session_id] = operation.operation_id
+
+        def answered(at_risk: object, error: Exception | None) -> None:
+            """Abort at once when nothing would be lost; otherwise ask first."""
+            if self.merge_abort_pending_by_session.get(session_id) != operation.operation_id:
+                return
+            del self.merge_abort_pending_by_session[session_id]
+            if self.session_registry_controller.session_by_id.get(session_id) is not session or session.is_closed or not self.operation_policy_controller.operation_allowed(operation):
+                return
+            if error is None and not at_risk:
+                self._submit_merge_abort(intent)
+                return
+            self._ask_merge_abort(intent)
+
+        self.reference.merge_work_at_risk(context, operation.git_filename, answered)
+
+    def _ask_merge_abort(self, intent: MergeAbortIntent) -> None:
+        """Ask before an Abort that would lose work, and abort only on an explicit Abort merge."""
+        session_id = intent.operation.session_id
+        window = self.session_registry_controller.window_by_session.get(session_id)
+        if window is None:
+            return
+        confirmation = QMessageBox(QMessageBox.Icon.Question, MERGE_ABORT_LABEL, MERGE_ABORT_QUESTION, QMessageBox.StandardButton.NoButton, window)
+        prepare_message_box(confirmation, MERGE_ABORT_LABEL)
+        confirmation.setTextFormat(Qt.TextFormat.PlainText)
+        abort_button = confirmation.addButton(MERGE_ABORT_LABEL, QMessageBox.ButtonRole.DestructiveRole)
+        cancel_button = confirmation.addButton(MERGE_ABORT_CANCEL_LABEL, QMessageBox.ButtonRole.RejectRole)
+        confirmation.setDefaultButton(cancel_button)
+        confirmation.setEscapeButton(cancel_button)
+        self.merge_abort_confirmation_by_session[session_id] = confirmation
+
+        def answer() -> None:
+            """Abort only on an explicit Abort merge; any other ending leaves the merge in place."""
+            if self.merge_abort_confirmation_by_session.get(session_id) is confirmation:
+                del self.merge_abort_confirmation_by_session[session_id]
+            accepted = confirmation.clickedButton() is abort_button
+            confirmation.deleteLater()
+            if accepted:
+                self._submit_merge_abort(intent)
+
+        confirmation.finished.connect(answer)
+        open_window_modal(confirmation)
+
+    def _submit_merge_abort(self, intent: MergeAbortIntent) -> None:
+        """Open the console, then hand the Abort to the reference service while its window, repository and Git are unchanged.
+
+        A merge tool series may have begun during the read of the work at risk or while the question was open: it does
+        not hold the repository between two files, so it is looked at here and again just before Git starts, as the
+        rebase's Abort and Continue do, and the Abort then waits with the reason in the status bar.
+        """
+        operation = intent.operation
+        session_id = operation.session_id
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None or session.is_closed or not self.operation_policy_controller.operation_allowed(operation) or self.repository.git_filename != operation.git_filename:
+            return
+        if self.mergetool.owns_repository(operation.common_git_dir):
+            window = self.session_registry_controller.window_by_session.get(session_id)
+            if window is not None:
+                window.statusBar().showMessage(BUSY_ACTION_REASON)
+            return
+
+        def is_current() -> bool:
+            """Keep the window's authority, repository and Git current, and no merge tool at work, until Git starts."""
+            return (self.session_registry_controller.session_by_id.get(session_id) is session and not session.is_closed and self.operation_policy_controller.operation_allowed(operation)
+                    and self.repository.git_filename == operation.git_filename and not self.mergetool.owns_repository(operation.common_git_dir))
+
+        self.merge_abort_intent_by_id[operation.operation_id] = intent
+        self.reference_form_controller.open_reference_output(intent, None, modal=True)
+        self.reference.abort_merge(intent, is_current=is_current)
+
+    def merge_abort_finished(self, outcome: OperationOutcome) -> None:
+        """Publish the Abort's result in its console, log a failure, close the worktree's Prepare changes after a successful Abort and refresh the windows of the repository."""
+        intent = self.merge_abort_intent_by_id.pop(outcome.operation_id, None)
+        if intent is None:
+            return
+        self.reference.outcome_by_id[outcome.operation_id] = outcome
+        # A refusal explains itself in GitPane's words (the merge changed or ended), which the user needs to read.
+        refusal_text = outcome.diagnostic.cause if outcome.status == OperationStatus.REFUSED and outcome.diagnostic is not None else ""
+        self.reference_form_controller.finish_reference_output(outcome, failure_text=refusal_text)
+        if outcome.diagnostic is not None and self.diagnostic_log is not None:
+            self.diagnostic_log.write(outcome.diagnostic)
+        if outcome.status == OperationStatus.SUCCESS:
+            # Nothing is left to commit once the merge is abandoned; the console keeps the result, and a message the
+            # user typed stays in the session and comes back when Prepare changes is reopened, as the rebase window
+            # closes after its Abort.
+            staging = self.staging_session_registry_controller.staging_by_key.get(intent.operation.key)
+            if staging is not None and staging.window is not None:
+                staging.window.close()
+        self.refresh_controller.refresh_after_reference_operation(intent.operation, outcome, RefreshScope.FULL)
+
+    def show_rebase_state_in_conflict_dialog(self, session_id: str, state: RebaseSnapshot) -> None:
+        """Show in the conflict window of one repository window the rebase state that window has just shown."""
+        conflict_dialog = self.conflict_dialog_by_session.get(session_id)
+        if conflict_dialog is not None and isValid(conflict_dialog):
+            conflict_dialog.show_rebase_state(state)
+
+    def show_conflict_write_availability(self, session_id: str, locked: bool) -> None:
+        """Lock or unlock the writes of the conflict window of one repository window, as the replay availability just computed it."""
+        dialog = self.conflict_dialog_by_session.get(session_id)
+        if dialog is not None and isValid(dialog):
+            # Only a possible replay locks the conflict list up front. An ordinary conflict keeps its buttons, so a second window
+            # that tries to write while a merge series runs gets the explicit refusal instead of silently disabled controls.
+            dialog.show_write_availability("Wait for the current operation or refresh the native state." if locked else "")
+
+    def show_window_conflict_state(self, session_id: str, key: WorktreeKey, conflict_state: ConflictState) -> None:
+        """Bring the conflict window and the conflict prompts of one repository window to the conflict state it has just shown.
+
+        A conflict window shows the new state, ends its rescan once no read is running or waiting, and closes once no
+        conflict is left; a conflict resolution or a replay that waited for this read is offered once it is fresh.
+        """
+        staging = self.staging_session_registry_controller.staging_by_key[key]
+        dialog = self.conflict_dialog_by_session.get(session_id)
+        if dialog is not None and isValid(dialog):
+            dialog.show_state(conflict_state)
+            if not staging.refresh_active and not staging.refresh_queued and not staging.explicit_refresh:
+                dialog.finish_rescan()
+            if conflict_state.fresh and not conflict_state.entries and not dialog.busy and not staging.refresh_active and not staging.refresh_queued:
+                dialog.close()
+        if session_id in self.session_registry_controller.conflict_pending_session_set and conflict_state.fresh and not staging.refresh_active and not staging.refresh_queued:
+            self.session_registry_controller.conflict_pending_session_set.discard(session_id)
+            self.offer_conflict_resolution(session_id)
+        if session_id in self.session_registry_controller.replay_pending_resolve_set and conflict_state.fresh and not staging.refresh_active and not staging.refresh_queued:
+            self.session_registry_controller.replay_pending_resolve_set.discard(session_id)
+            self.open_conflict_dialog(session_id, conflict_state)