gitpane 1.0.0__py3-none-any.whl

gitpane/controller/history_read_controller.py

@@ -0,0 +1,671 @@
+"""Read from Git what a repository window shows of its history."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, QSignalBlocker, QTimer, Signal
+from shiboken6 import isValid
+
+from gitpane.config import SharedText
+from gitpane.controller.session_registry import keep_streamed_commits
+from gitpane.history.file_history import FileHistoryEngine, WindowCapability, visible_parent_map
+from gitpane.history.history_filter import HistoryFilterMode
+from gitpane.history.history_parse import summarize_commit
+from gitpane.history.repository_value import FilePanel, FileReadIdentity, RequestIdentity
+from gitpane.operation.diagnostic import Diagnostic
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.text.text_query import TextQuery
+from gitpane.transport.refusal_notice import failure_summary
+from gitpane.ui.console.error_dialog import ErrorDialog
+from gitpane.ui.welcome.welcome_window import WelcomeWindow
+from gitpane.ui.window_control.dialog_modality import open_window_modal
+
+if TYPE_CHECKING:
+    from gitpane.controller.operation_policy import OperationPolicy
+    from gitpane.controller.reference_read_controller import ReferenceReadController
+    from gitpane.controller.refresh_controller import RefreshController
+    from gitpane.controller.session_registry import RepositorySession, SessionRegistry
+    from gitpane.history.file_history import FileHistoryResult
+    from gitpane.history.repository import GitRepository
+    from gitpane.history.repository_value import BlobContent, Commit, CommitRelation, ComparisonGroup, HistorySnapshot, RepositoryFailure, RevisionEntry, TreeEntry
+    from gitpane.operation.diagnostic import DiagnosticLog
+    from gitpane.preference.preference_store import PreferenceStore
+    from gitpane.tool.system_tool import SystemToolService
+    from gitpane.transport.clone import CloneService
+
+
+class HistoryReadController(QObject):
+    """The history reads of every repository window: the graph and its search, the selected commit with its relatives, its files, its tree and the diff of one file."""
+
+    # session id, generation of the history just shown in the window
+    history_published = Signal(str, int)
+    # session id, reference capture the refresh read (or None), once the published history wrote its status line
+    history_status_written = Signal(str, object)
+    # session id, prepared diagnostic of the read that ended a refresh
+    refresh_failed = Signal(str, object)
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, operation_policy_controller: OperationPolicy, reference_read_controller: ReferenceReadController, refresh_controller: RefreshController, preference: PreferenceStore,
+                 repository: GitRepository, clone: CloneService, diagnostic_log: DiagnosticLog | None, system_tool: SystemToolService, parent: QObject | None = None) -> None:
+        """Receive the services and the lower controllers the reads go through; the wiring builds it after the worktree state controller, and the repository service, the windows and the operations ask it to read."""
+        super().__init__(parent)
+        self.session_registry_controller = session_registry_controller
+        self.repository = repository
+        self.operation_policy_controller = operation_policy_controller
+        self.preference = preference
+        self.diagnostic_log = diagnostic_log
+        self.system_tool = system_tool
+        self.reference_read_controller = reference_read_controller
+        self.refresh_controller = refresh_controller
+        self.clone = clone
+        # Windows whose graph goes back to its top once the history read after their operation is shown: an operation
+        # that adds commits or moves a branch to a new commit puts its result at the top of the graph. An operation that
+        # names a commit the user clicked, a tag or a reset of a branch, leaves the graph where it was.
+        self.history_top_session_set: set[str] = set()
+        self.reported_request_set: set[RequestIdentity] = set()
+
+    def read_selection(self, session_id: str, oid: str) -> None:
+        """Read full text separately from lightweight table rows and traversal pages."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None:
+            return
+        if session.mode == "file_history" and (session.search_pending or oid not in session.visible_oid_set):
+            return
+        identity = RequestIdentity(session_id, session.generation, session.selection_generation, oid)
+        window = self.session_registry_controller.window_by_session[session_id]
+        window.commit_panel.show_loading(oid, window.commit.short_oid if window.commit is not None and window.commit.oid == oid else "")
+        if session.refresh_active and session.view_anchor is not None:
+            session.view_anchor = replace(session.view_anchor, selected_oid=oid, selected_visible_index=window.commit_list.currentIndex().row())
+        if session.navigation_oid == oid:
+            self.repository.read_commit(oid, identity, verify_exists=True)
+        else:
+            self.repository.read_commit(oid, identity)
+
+    def file_is_current(self, identity: FileReadIdentity) -> bool:
+        """Reject replies whose window, commit, selection, or panel has changed."""
+        request = identity.request_identity
+        session = self.session_registry_controller.session_by_id.get(request.session_id)
+        return (session is not None and not session.is_closed and session.generation == request.generation
+                and session.selection_generation == request.selection_generation and session.selected_oid == request.oid
+                and session.file_identity_by_kind.get(identity.panel_kind) == identity)
+
+    def read_diff(self, session_id: str, entry: RevisionEntry) -> None:
+        """Start a new comparison only for an entry in the current commit's file list."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None or entry.commit_oid != session.selected_oid or not any(entry in group.entries for group in session.diff_groups):
+            return
+        preserve_selection = session.selected_entry == entry
+        session.panel_generation += 1
+        session.selected_entry = entry
+        request = RequestIdentity(session_id, session.generation, session.selection_generation, session.selected_oid)
+        panel = self.session_registry_controller.window_by_session[session_id].diff_panel
+        identity = FileReadIdentity(request, FilePanel.DIFF, session.panel_generation, entry.parent_oid, entry.old_path, entry.new_path, panel.full_context_checkbox.isChecked())
+        session.file_identity_by_kind[FilePanel.DIFF] = identity
+        panel.selected_entry = entry
+        panel.full_context_checkbox.setEnabled(True)
+        panel.diff_view.clear(preserve_selection=preserve_selection)
+        panel.reader_toolbar.start_loading("Loading diff…")
+        self.repository.read_diff(entry, identity)
+
+    def change_diff_context(self, session_id: str, checked: bool) -> None:
+        """Reload only the selected comparison while keeping graph and commit detail intact."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is not None and session.selected_entry is not None:
+            self.read_diff(session_id, session.selected_entry)
+
+    def diff_read(self, identity: FileReadIdentity, entry: RevisionEntry, patch: bytes) -> None:
+        """Publish patch bytes only for the selected entry and panel generation."""
+        if not self.file_is_current(identity):
+            return
+        session_id = identity.request_identity.session_id
+        if self.session_registry_controller.session_by_id[session_id].selected_entry != entry:
+            return
+        panel = self.session_registry_controller.window_by_session[session_id].diff_panel
+        try:
+            panel.show_patch(entry, patch)
+        except ValueError as error:
+            panel.show_error(str(error))
+
+    def retry_diff(self, session_id: str) -> None:
+        """Retry failed file or file-list reads without replacing commit details."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None:
+            return
+        if session.selected_entry is not None:
+            self.read_diff(session_id, session.selected_entry)
+            return
+        session.invalidate_file_selection()
+        if session.selected_oid is not None:
+            self.read_selection(session_id, session.selected_oid)
+
+    def save_reading_preference(self, session_id: str, changed_value_by_key: dict[str, object]) -> None:
+        """Publish only synchronized choices and restore the accepted view on refusal."""
+        window = self.session_registry_controller.window_by_session.get(session_id)
+        if window is None or window.is_closed:
+            return
+        try:
+            self.preference.update(changed_value_by_key)
+        except (OSError, ValueError, TypeError) as error:
+            window.apply_reading_preference(self.preference.value_by_key)
+            diagnostic = Diagnostic("Save reading preferences", window.context.repository_dir, "", [], str(error)).prepare()
+            window.statusBar().showMessage(diagnostic.cause)
+            if self.diagnostic_log is not None:
+                self.diagnostic_log.write(diagnostic)
+
+    def resume_file_history(self, session_id: str) -> None:
+        """Resume only the current limited window's immutable file-history calculation."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None or session.is_closed or session.file_history_engine is None:
+            return
+        self.session_registry_controller.window_by_session[session_id].file_history_resume_action.setEnabled(False)
+        session.file_history_engine.resume()
+
+    def change_filter(self, session_id: str, text: str) -> None:
+        """Invalidate on every keystroke, before the delayed replacement scan starts."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None:
+            return
+        session.search(text)
+        self.session_registry_controller.window_by_session[session_id].begin_search()
+
+    def read_navigation(self, session_id: str, oid: str) -> None:
+        """Clear the previous row's active detail while verifying a requested relative."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.CONSULT):
+            return
+        window = self.session_registry_controller.window_by_session[session_id]
+        session = self.session_registry_controller.session_by_id[session_id]
+        if session.mode == "file_history" and (session.search_pending or oid not in session.visible_oid_set):
+            return
+        if not window.search_pending and oid in window.history_model.row_by_oid and window.commit is not None and window.commit.oid != oid:
+            window.reveal_commit(oid)
+            return
+        window.commit_list.clearSelection()
+        self.read_selection(session_id, oid)
+
+    def _finish_navigation(self, session_id: str, commit: Commit) -> None:
+        """Reveal the real row and announce only a filter that hid this target."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.CONSULT):
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        window = self.session_registry_controller.window_by_session[session_id]
+        if session.mode == "file_history" and (session.search_pending or commit.oid not in session.visible_oid_set):
+            return
+        session.navigation_oid = None
+        session.navigation_commit = None
+        if (session.snapshot is not None and commit.oid not in session.snapshot.parent_oids_by_oid
+                and not any(explicit.oid == commit.oid for explicit in session.snapshot.explicit_commits)):
+            session.snapshot.explicit_commits.append(summarize_commit(commit))
+        window.reveal_commit(commit.oid)
+        window.commit = commit
+        window.commit_panel.show_commit(commit)
+        if session.navigation_filter_cleared:
+            window.statusBar().showMessage(f"Filter cleared to show commit {commit.short_oid}.")
+            session.navigation_filter_cleared = False
+
+    def _read_relation(self, session_id: str) -> None:
+        """Associate each relative read with the active detail and index completeness."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.CONSULT):
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        commit = self.session_registry_controller.window_by_session[session_id].commit_panel.commit
+        if commit is None or commit.oid != session.selected_oid:
+            return
+        session.relation_generation += 1
+        identity = RequestIdentity(session_id, session.generation, session.selection_generation, commit.oid, relation_generation=session.relation_generation)
+        session.relation_identity = identity
+        self.session_registry_controller.window_by_session[session_id].commit_panel.child_label.setText(SharedText.CHILD_LOADING.value)
+        self.repository.read_relation(commit, session.snapshot, identity)
+
+    def relation_read(self, identity: RequestIdentity, relation: CommitRelation) -> None:
+        """Reject late relatives from another selection, capture or index read."""
+        session = self.session_registry_controller.session_by_id.get(identity.session_id)
+        if (session is None or session.relation_identity != identity or session.generation != identity.generation
+                or session.selection_generation != identity.selection_generation or session.selected_oid != relation.oid):
+            return
+        if session.mode == "file_history":
+            parents = []
+            child_links = []
+            for link in relation.parents:
+                parents.append(replace(link, available=link.available and link.oid in session.visible_oid_set))
+            for link in relation.child_links:
+                child_links.append(replace(link, available=link.available and link.oid in session.visible_oid_set))
+            relation = replace(relation, parents=parents, child_links=child_links)
+        self.session_registry_controller.window_by_session[identity.session_id].show_commit_relation(relation)
+
+    def retry_selection(self, session_id: str, oid: str) -> None:
+        """Give an explicit retry a fresh identity so another diagnostic can be shown."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None or session.selected_oid != oid:
+            return
+        session.selection_generation += 1
+        self.read_selection(session_id, oid)
+
+    def read_visible_tree(self, session_id: str) -> None:
+        """Read the historical tree of the selected commit once the File tree tab is on screen.
+
+        The tree of a commit nobody looks at is never read. The read belongs to the current selection and panel
+        generation, so the answer for a commit the user has left is dropped, and showing the tab again for the same
+        selection, an empty tree or a failed read included, asks for nothing more; Retry is the way to read again.
+        An answer that arrived while the tab was hidden is built now from the entries already received, without a new
+        Git read, provided it still belongs to the current selection.
+        """
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        window = self.session_registry_controller.window_by_session.get(session_id)
+        if session is None or session.is_closed or window is None or not isValid(window):
+            return
+        if window.detail_tabs.currentWidget() is not window.file_tree_panel:
+            return
+        # Only the commit read for the current selection and generation can own the read: a commit still shown from
+        # before a refresh or a new selection waits for its own detail read, which asks again.
+        request = session.commit_identity
+        commit = window.commit
+        if (request is None or commit is None or commit.detail_error or request.oid != commit.oid or request.oid != session.selected_oid
+                or request.generation != session.generation or request.selection_generation != session.selection_generation):
+            return
+        pending = session.pending_tree_identity
+        session.pending_tree_identity = None
+        if pending is not None and self.file_is_current(pending):
+            window.file_tree_panel.show_tree(session.tree_entries)
+            return
+        if session.file_identity_by_kind.get(FilePanel.TREE) is not None:
+            return
+        tree_identity = FileReadIdentity(request, FilePanel.TREE, session.panel_generation)
+        session.file_identity_by_kind[FilePanel.TREE] = tree_identity
+        self.repository.read_tree(commit.oid, tree_identity)
+
+    def tree_read(self, identity: FileReadIdentity, entries: list[TreeEntry]) -> None:
+        """Present paths only for the active commit and repository window, and only while the File tree tab is shown.
+
+        The entries are kept in every case because choosing a file of the tree relies on them. Building thousands of
+        tree rows for a tab the user already left would only block the window, so a hidden tab keeps the answer as
+        pending and the tree is built when the tab comes back.
+        """
+        if not self.file_is_current(identity):
+            return
+        session_id = identity.request_identity.session_id
+        session = self.session_registry_controller.session_by_id[session_id]
+        session.tree_entries = entries
+        window = self.session_registry_controller.window_by_session[session_id]
+        if window.detail_tabs.currentWidget() is not window.file_tree_panel:
+            session.pending_tree_identity = identity
+            return
+        window.file_tree_panel.show_tree(entries)
+
+    def read_blob(self, session_id: str, entry: TreeEntry) -> None:
+        """Resolve the selected tree object independently of the diff selection."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None or entry not in session.tree_entries:
+            return
+        session.panel_generation += 1
+        session.selected_tree_entry = entry
+        request = RequestIdentity(session_id, session.generation, session.selection_generation, session.selected_oid)
+        identity = FileReadIdentity(request, FilePanel.BLOB, session.panel_generation, new_path=entry.path)
+        session.file_identity_by_kind[FilePanel.BLOB] = identity
+        panel = self.session_registry_controller.window_by_session[session_id].file_tree_panel
+        panel.selected_entry = entry
+        panel.begin_loading()
+        self.repository.cancel_file(session_id, FilePanel.BLOB)
+        if entry.mode == "160000":
+            panel.show_submodule(entry.oid)
+            return
+        self.repository.read_blob(entry.oid, identity)
+
+    def blob_read(self, identity: FileReadIdentity, content: BlobContent) -> None:
+        """Ignore late file bytes even when they belong to another file in the same tree."""
+        if not self.file_is_current(identity):
+            return
+        session_id = identity.request_identity.session_id
+        entry = self.session_registry_controller.session_by_id[session_id].selected_tree_entry
+        if entry is None or entry.oid != content.oid:
+            return
+        self.session_registry_controller.window_by_session[session_id].file_tree_panel.show_blob(content)
+
+    def changes_read(self, identity: FileReadIdentity, groups: list[ComparisonGroup]) -> None:
+        """Publish file groups only for the active comparison request."""
+        if not self.file_is_current(identity):
+            return
+        session = self.session_registry_controller.session_by_id[identity.request_identity.session_id]
+        session.diff_groups = groups
+        window = self.session_registry_controller.window_by_session[session.session_id]
+        panel = window.diff_panel
+        selected_entry = panel.selected_entry
+        panel.show_changes(groups)
+        if selected_entry not in panel.item_by_entry and session.file_history_result is not None and window.commit is not None:
+            selected_entry = session.file_history_result.select_entry(window.commit, groups)
+        if selected_entry not in panel.item_by_entry:
+            selected_entry = panel.first_entry()
+        if selected_entry in panel.item_by_entry:
+            panel.file_tree.setCurrentItem(panel.item_by_entry[selected_entry])
+
+    def retry_file_tree(self, session_id: str, kind: FilePanel | None) -> None:
+        """Retry only the failed tree or blob with fresh ownership in either window mode; any other panel, or none, is not retried here."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None or session.is_closed or session.selected_oid is None:
+            return
+        if kind == FilePanel.BLOB and session.selected_tree_entry is not None:
+            self.read_blob(session_id, session.selected_tree_entry)
+            return
+        if kind != FilePanel.TREE:
+            return
+        session.panel_generation += 1
+        session.pending_tree_identity = None
+        request = RequestIdentity(session_id, session.generation, session.selection_generation, session.selected_oid)
+        identity = FileReadIdentity(request, FilePanel.TREE, session.panel_generation)
+        session.file_identity_by_kind[FilePanel.TREE] = identity
+        self.session_registry_controller.window_by_session[session_id].file_tree_panel.show_error("Loading files…")
+        self.repository.read_tree(session.selected_oid, identity)
+
+    def file_failed(self, identity: FileReadIdentity, failure: RepositoryFailure) -> None:
+        """Present a file-specific diagnostic without marking commit metadata unavailable."""
+        if identity in self.session_registry_controller.export_owner_by_identity:
+            self.system_tool.fail_export(identity, failure.cause)
+            return
+        if not self.file_is_current(identity):
+            return
+        diagnostic = Diagnostic(failure.operation, failure.repository_dir, failure.program_filename, failure.arguments, failure.cause, failure.stderr, failure.return_code).prepare()
+        window = self.session_registry_controller.window_by_session[identity.request_identity.session_id]
+        if identity.panel_kind == FilePanel.DIFF:
+            window.diff_panel.show_error(diagnostic.detail)
+        else:
+            window.file_tree_panel.show_error(diagnostic.detail, retry_kind=identity.panel_kind)
+        if self.diagnostic_log is not None:
+            self.diagnostic_log.write(diagnostic)
+
+    def snapshot_read(self, identity: RequestIdentity, snapshot: HistorySnapshot) -> None:
+        """Route one capture through its owning session to the native model."""
+        if identity.session_id in self.session_registry_controller.navigation_owner_by_id:
+            return
+        if self.session_registry_controller.identity_by_session.get(identity.session_id) != identity:
+            return
+        session = self.session_registry_controller.session_by_id[identity.session_id]
+        if session.file_history_engine is not None and session.snapshot is not snapshot:
+            return
+        session.snapshot = snapshot
+        if session.file_history_anchor is not None:
+            if snapshot.complete and session.file_history_engine is None:
+                self._calculate_file_history(session)
+            return
+        if session.search_pending or session.filter_text or session.refresh_active:
+            if snapshot.complete and session.search_identity is None:
+                self.start_search(identity.session_id)
+            return
+        self.session_registry_controller.window_by_session[identity.session_id].show_snapshot(snapshot)
+        if snapshot.complete:
+            self._read_relation(identity.session_id)
+
+    def _calculate_file_history(self, session: RepositorySession) -> None:
+        """Publish a captured file membership only to the still-open owning session."""
+        session.file_history_generation += 1
+        generation = session.file_history_generation
+        engine = FileHistoryEngine(self.repository)
+        session.file_history_engine = engine
+
+        def receive(result: FileHistoryResult) -> None:
+            """Start message filtering only after the file membership is known."""
+            if session.is_closed or session.file_history_generation != generation:
+                return
+            session.file_history_result = result
+            self.session_registry_controller.window_by_session[session.session_id].file_history_result = result
+            session.search(session.filter_text)
+            self.session_registry_controller.window_by_session[session.session_id].begin_search()
+            self.start_search(session.session_id)
+
+        def progress(count: int, total: int) -> None:
+            """Show progress without publishing an unfinished file membership."""
+            if not session.is_closed and session.file_history_generation == generation:
+                self.session_registry_controller.window_by_session[session.session_id].statusBar().showMessage(f"Reading file history… {count}/{total} commits")
+
+        engine.finished.connect(receive)
+        engine.progressed.connect(progress)
+        engine.calculate(session.snapshot, session.file_history_anchor, self.session_registry_controller.identity_by_session[session.session_id])
+
+    def commit_batch_read(self, identity: RequestIdentity, commits: list[Commit]) -> None:
+        """Keep the rows the history read just parsed, and append them, in Git's order, to the live generation of the whole history.
+
+        The rows are pushed as the history is read, and kept with their history so that an empty query can show them
+        again without reading Git. A file history, a search, a filter or a refresh shows its own rows instead, so it
+        does not append these; neither does a walk into another repository, whose window is not replaced yet.
+        """
+        if identity.session_id in self.session_registry_controller.navigation_owner_by_id:
+            return
+        snapshot = self.repository.snapshot_by_session.get(identity.session_id)
+        if self.session_registry_controller.identity_by_session.get(identity.session_id) != identity:
+            return
+        session = self.session_registry_controller.session_by_id[identity.session_id]
+        if snapshot is not None:
+            session.streamed_history = keep_streamed_commits(session.streamed_history, snapshot, commits)
+        if session.mode == "file_history" or session.snapshot is None:
+            return
+        if session.search_pending or session.filter_text or session.refresh_active:
+            return
+        self.session_registry_controller.window_by_session[identity.session_id].append_history(commits)
+
+    def start_search(self, session_id: str) -> None:
+        """Start one scan only once the captured ancestry is complete.
+
+        An empty query answers on a later turn with the rows already read; that answer is dropped if the window's history
+        list is destroyed first.
+        """
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None or session.snapshot is None or not session.snapshot.complete or session.search_identity is not None:
+            return
+        if self.session_registry_controller.window_by_session[session_id].search_timer.isActive():
+            return
+        if session.mode == "file_history" and session.file_history_result is None:
+            return
+        if not session.search_pending:
+            session.search(session.filter_text)
+        identity = RequestIdentity(session_id, session.generation, search_generation=session.search_generation)
+        session.search_identity = identity
+        # An empty query shows every commit: the rows the history read already delivered are the answer. They go
+        # through the same path as a search's answer, on a later turn of the event loop as a search's would.
+        streamed_history = session.streamed_history
+        commits = streamed_history.complete_commits(session.snapshot) if streamed_history is not None and not session.filter_text else None
+        if commits is not None:
+            # Tied to the history list: a window closed before the next turn takes the answer with it, instead of
+            # publishing into a list that no longer exists.
+            QTimer.singleShot(0, self.session_registry_controller.window_by_session[session_id].commit_list, lambda: self.matching_read(identity, commits, len(commits), True))
+            return
+        window = self.session_registry_controller.window_by_session[session_id]
+        self.repository.read_filter_matches(session.snapshot, session.filter_text, window.filter_mode, identity)
+
+    def matching_read(self, identity: RequestIdentity, commits: list[Commit], scanned_count: int, complete: bool) -> None:
+        """Publish a coherent graph only after the current query has checked every OID."""
+        if identity.session_id in self.session_registry_controller.navigation_owner_by_id:
+            return
+        session = self.session_registry_controller.session_by_id.get(identity.session_id)
+        if session is None or session.search_identity != identity or not session.search_pending:
+            return
+        for commit in commits:
+            if session.file_history_result is None or commit.oid in session.file_history_result.touching_oid_set:
+                session.matching_commits.append(commit)
+        window = self.session_registry_controller.window_by_session[identity.session_id]
+        if not complete:
+            if session.refresh_active:
+                window.statusBar().showMessage(f"Refreshing… {scanned_count} commits scanned")
+            else:
+                window.show_search_progress(len(session.matching_commits), scanned_count)
+            return
+        session.search_pending = False
+        refresh_anchor = session.view_anchor
+        navigation_commit = session.navigation_commit
+        if (session.mode != "file_history" and navigation_commit is not None and navigation_commit.oid == session.selected_oid
+                and not any(commit.oid == navigation_commit.oid for commit in session.matching_commits)):
+            session.matching_commits.append(summarize_commit(navigation_commit))
+        session.visible_oid_set = set()
+        for commit in session.matching_commits:
+            session.visible_oid_set.add(commit.oid)
+        parent_map = visible_parent_map(session.snapshot, session.visible_oid_set) if session.mode == "file_history" else None
+        missing_checkout_selection = (identity.session_id in self.refresh_controller.checkout_refresh_session_set and session.selected_oid is not None
+                                      and session.selected_oid not in session.visible_oid_set)
+        if missing_checkout_selection:
+            with QSignalBlocker(window):
+                window.show_matches(session.snapshot, session.matching_commits, session.filter_text, session.selected_oid, parent_map)
+                if session.refresh_active and refresh_anchor is not None:
+                    window.restore_anchor(refresh_anchor)
+                window.clear_commit_selection()
+            session.selected_oid = None
+            session.selection_generation += 1
+            session.invalidate_file_selection()
+            session.navigation_commit = None
+            navigation_commit = None
+        else:
+            window.show_matches(session.snapshot, session.matching_commits, session.filter_text, session.selected_oid, parent_map)
+            if session.refresh_active and refresh_anchor is not None:
+                window.restore_anchor(refresh_anchor)
+        self.refresh_controller.checkout_refresh_session_set.discard(identity.session_id)
+        # Only the last read of a refresh moves the view: a read queued behind this one keeps the position it starts from.
+        if session.refresh_active and session.refresh_queued is None and identity.session_id in self.history_top_session_set:
+            self.history_top_session_set.discard(identity.session_id)
+            window.scroll_history_to_top()
+        self.history_published.emit(identity.session_id, identity.generation)
+        session.matching_commits = []
+        if navigation_commit is not None and navigation_commit.oid == session.selected_oid:
+            self._finish_navigation(identity.session_id, navigation_commit)
+        if not window.history_model.commits:
+            session.selected_oid = None
+            session.selection_generation += 1
+            session.invalidate_file_selection()
+            window.diff_panel.clear_selection()
+            window.file_tree_panel.clear_selection()
+        if session.refresh_active and session.refresh_queued is None:
+            # The history just published wrote its own status line: a line owed about an ended rebase is added to it,
+            # naming the HEAD this very refresh read.
+            self.history_status_written.emit(identity.session_id, self.reference_read_controller.reference_snapshot_by_session.get(identity.session_id))
+        if session.refresh_active:
+            session.refresh_active = False
+            session.view_anchor = None
+            self.refresh_controller.recovery_request_set.discard(self.session_registry_controller.identity_by_session[identity.session_id])
+            self.refresh_controller.leave_full_refresh_read(identity.session_id)
+            if session.refresh_queued is not None:
+                request = session.refresh_queued
+                session.refresh_queued = None
+                self.refresh_controller.submit_refresh_request(identity.session_id, request)
+
+    def commit_read(self, identity: RequestIdentity, commit: Commit) -> None:
+        """Discard superseded detail responses without disturbing ongoing history reads."""
+        session = self.session_registry_controller.session_by_id.get(identity.session_id)
+        if session is None or session.generation != identity.generation or session.selection_generation != identity.selection_generation or session.selected_oid != commit.oid or identity.oid != commit.oid:
+            return
+        window = self.session_registry_controller.window_by_session[identity.session_id]
+        window.commit = commit
+        session.commit_identity = identity
+        window.commit_panel.show_commit(commit)
+        if not commit.detail_error:
+            file_identity = FileReadIdentity(identity, panel_generation=session.panel_generation)
+            if session.file_identity_by_kind.get(FilePanel.DIFF) is None:
+                session.file_identity_by_kind[FilePanel.DIFF] = file_identity
+                self.repository.read_changes(commit, file_identity)
+        self.read_visible_tree(identity.session_id)
+        if session.navigation_oid == commit.oid and not commit.detail_error:
+            if commit.oid in window.history_model.row_by_oid and not window.search_pending:
+                self._finish_navigation(identity.session_id, commit)
+            elif session.mode == "file_history":
+                session.navigation_commit = commit
+            else:
+                session.navigation_commit = commit
+                # The files a commit changes come from another read than this one, so in the file name mode the filter is
+                # cleared to show the commit: a commit the finished search left out is one the filter hides.
+                hidden_by_filter = window.filter_mode == HistoryFilterMode.FILES or not TextQuery(session.filter_text).matches(commit.message)
+                if session.filter_text and hidden_by_filter:
+                    session.navigation_filter_cleared = True
+                    window.clear_filter()
+                else:
+                    session.search(session.filter_text)
+                    window.begin_search()
+                    self.start_search(identity.session_id)
+        self._read_relation(identity.session_id)
+
+    def failed(self, identity: RequestIdentity, failure: RepositoryFailure) -> None:
+        """Present one prepared diagnostic while allowing a failed opening to retry."""
+        if identity.session_id in self.session_registry_controller.navigation_owner_by_id:
+            return
+        session = self.session_registry_controller.session_by_id.get(identity.session_id)
+        selected_request = session is not None and identity.oid is not None and session.generation == identity.generation and session.selection_generation == identity.selection_generation and session.selected_oid == identity.oid
+        relation_request = selected_request and bool(identity.relation_generation)
+        if relation_request and session.relation_identity != identity:
+            return
+        search_request = session is not None and session.search_identity == identity and session.search_pending
+        if self.session_registry_controller.identity_by_session.get(identity.session_id) != identity and not selected_request and not search_request:
+            return
+        if identity in self.reported_request_set:
+            return
+        self.reported_request_set.add(identity)
+        diagnostic = Diagnostic(failure.operation, failure.repository_dir, failure.program_filename, failure.arguments, failure.cause, failure.stderr, failure.return_code).prepare()
+        clone_dialog = self.session_registry_controller.clone_dialog_by_session.get(identity.session_id)
+        if clone_dialog is not None and clone_dialog.operation_id is not None and identity.session_id not in self.session_registry_controller.window_by_session:
+            run = self.clone.run_by_id[clone_dialog.operation_id]
+            if run.clone_status == OperationStatus.SUCCESS.value or run.incomplete_repository:
+                self.session_registry_controller.identity_by_session.pop(identity.session_id, None)
+                self.session_registry_controller.welcome_by_session[identity.session_id].set_loading(False)
+                self.clone.open_result(run.operation_id, False, diagnostic)
+                clone_dialog.show_failure(failure_summary(diagnostic), partial=True)
+                run.trace.append_diagnostic(run.operation_id, "error", diagnostic, OperationStatus.FAILED)
+                return
+        if relation_request:
+            self.session_registry_controller.window_by_session[identity.session_id].commit_panel.child_label.setText("Children unknown — incomplete read: " + diagnostic.cause)
+        elif selected_request:
+            self.session_registry_controller.window_by_session[identity.session_id].commit_panel.show_error(identity.oid, diagnostic.cause)
+        parent = self.session_registry_controller.welcome_by_session.get(identity.session_id) or self.session_registry_controller.window_by_session.get(identity.session_id)
+        if parent is None:
+            return
+        if isinstance(parent, WelcomeWindow):
+            parent.set_loading(False)
+            parent.mark_unavailable(self.session_registry_controller.opening_dir_by_session.get(identity.session_id, failure.repository_dir))
+            self.session_registry_controller.identity_by_session.pop(identity.session_id, None)
+        else:
+            session = self.session_registry_controller.session_by_id[identity.session_id]
+            if session.refresh_active and not selected_request:
+                self.refresh_failed.emit(identity.session_id, diagnostic)
+                session.refresh_active = False
+                session.refresh_queued = None
+                self.refresh_controller.leave_full_refresh_read(identity.session_id)
+                session.search_pending = False
+                session.search_identity = None
+                parent.search_pending = False
+                parent.commit_list.setEnabled(True)
+                parent.history_state_label.hide()
+                parent.statusBar().showMessage("State not refreshed — references not refreshed")
+            elif search_request:
+                session.search_pending = False
+                session.search_identity = None
+                parent.statusBar().showMessage("State not refreshed — search incomplete")
+            elif not selected_request and session.snapshot is not None and session.snapshot.generation == identity.generation:
+                session.snapshot.error = diagnostic.cause
+                parent.update_history_status()
+            else:
+                parent.statusBar().showMessage("State not refreshed — references not refreshed")
+        if self.diagnostic_log is not None:
+            self.diagnostic_log.write(diagnostic)
+            if self.diagnostic_log.warning:
+                if isinstance(parent, WelcomeWindow):
+                    parent.show_status(self.diagnostic_log.warning)
+                else:
+                    parent.statusBar().showMessage(self.diagnostic_log.warning)
+        if identity in self.refresh_controller.recovery_request_set:
+            self.refresh_controller.recovery_request_set.discard(identity)
+            return
+        dialog = ErrorDialog(diagnostic, parent, self.diagnostic_log.log_filename if self.diagnostic_log is not None else None)
+        if isinstance(parent, WelcomeWindow):
+            dialog.setWindowTitle("Could not open repository")
+            opening_diagnostic = Diagnostic(failure.operation, failure.repository_dir, failure.program_filename, [],
+                                            f"Cannot open {failure.repository_dir}: {failure.cause}. Check the path and access permissions, then try again.", failure.stderr).prepare()
+            dialog.cause_label.setText(opening_diagnostic.cause)
+        self.session_registry_controller.dialogs.append(dialog)
+
+        def finish() -> None:
+            """Attempt one recovery after dismissal, provided the original view still exists."""
+            if dialog in self.session_registry_controller.dialogs:
+                self.session_registry_controller.dialogs.remove(dialog)
+            navigation_failed = (selected_request and not relation_request and session is not None and session.navigation_oid == identity.oid
+                                 and session.selection_generation == identity.selection_generation)
+            if navigation_failed:
+                session.navigation_oid = None
+                session.navigation_commit = None
+            if (self.session_registry_controller.identity_by_session.get(identity.session_id) == identity or navigation_failed) and identity.session_id in self.session_registry_controller.window_by_session:
+                self.refresh_controller.refresh(identity.session_id, recovery=True)
+            dialog.deleteLater()
+
+        dialog.finished.connect(finish)
+        open_window_modal(dialog)