gitpane 1.0.0__py3-none-any.whl

gitpane/application.py

@@ -0,0 +1,684 @@
+"""Wire the services of GitPane to its controllers, then run its event loop."""
+
+from __future__ import annotations
+
+import functools
+import os
+import signal
+import sys
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, QSettings, QStandardPaths, QTimer
+from PySide6.QtGui import QGuiApplication
+from PySide6.QtWidgets import QApplication
+
+from gitpane.account.authentication import AuthenticationService
+from gitpane.account.credential_manager import (
+    CredentialManagerLocator,
+    ignore_line,
+)
+from gitpane.account.credential_manager_install import session_gcm_archive_architecture
+from gitpane.account.keyring_reader import read_session_keyring_state
+from gitpane.account.ssh import SshClientFinder, SshService
+from gitpane.commit.commit_push import CommitPushService
+from gitpane.config import (
+    APPLICATION_NAME,
+    APPLICATION_VERSION,
+    APPLICATION_VERSION_LINE,
+    SharedText,
+)
+from gitpane.controller.account_controller import AccountController
+from gitpane.controller.clone_controller import CloneController
+from gitpane.controller.close_readiness import CloseReadiness
+from gitpane.controller.commit_timing_controller import CommitTimingController
+from gitpane.controller.conflict_controller import ConflictController
+from gitpane.controller.console_registry import ConsoleRegistry
+from gitpane.controller.emoji_window_controller import EmojiWindowController
+from gitpane.controller.file_action_controller import (
+    STAGING_FOLDER_TOOL,
+    STAGING_TEXT_EDITOR_TOOL,
+    FileActionController,
+)
+from gitpane.controller.history_read_controller import HistoryReadController
+from gitpane.controller.history_rewrite_controller import HistoryRewriteController
+from gitpane.controller.navigation_controller import (
+    NavigationController,
+)
+from gitpane.controller.opening_controller import OpeningController
+from gitpane.controller.operation_policy import OperationPolicy
+from gitpane.controller.rebase_controller import RebaseController
+from gitpane.controller.rebase_editor_controller import RebaseEditorController
+from gitpane.controller.reference_form_controller import (
+    ReferenceFormController,
+)
+from gitpane.controller.reference_read_controller import ReferenceReadController
+from gitpane.controller.refresh_controller import RefreshController
+from gitpane.controller.replay_controller import ReplayController
+from gitpane.controller.session_registry import RepositorySession, SessionRegistry
+from gitpane.controller.setting_controller import SettingController
+from gitpane.controller.shutdown_controller import ShutdownController
+from gitpane.controller.staging_controller import StagingController
+from gitpane.controller.staging_session_registry import StagingSessionRegistry
+from gitpane.controller.stash_controller import (
+    StashController,
+)
+from gitpane.controller.transport_controller import TransportController
+from gitpane.controller.welcome_controller import WelcomeController
+from gitpane.controller.window_activation import WindowActivationFilter
+from gitpane.controller.worktree_state_controller import WorktreeStateController
+from gitpane.git_config.git_setting import GitSettingService
+from gitpane.history.avatar import AvatarService
+from gitpane.history.file_history import FileHistoryAnchor, WindowCapability
+from gitpane.history.repository import GitRepository
+from gitpane.history.repository_value import (
+    RepositoryContext,
+    RequestIdentity,
+)
+from gitpane.history_rewrite.recovery import HISTORY_REWRITE_STORAGE_BASENAME
+from gitpane.operation.diagnostic import DiagnosticLog
+from gitpane.operation.repository_operation import (
+    RepositoryOperationService,
+)
+from gitpane.preference.preference_location import PREFERENCE_FILE_LOG_TEXT, user_preference_filename
+from gitpane.preference.preference_store import (
+    PreferenceStore,
+)
+from gitpane.process.process_log import ProcessLogWriter
+from gitpane.reference.reference_edit import (
+    BranchMode,
+    ReferenceService,
+)
+from gitpane.reference.stash import StashService
+from gitpane.sequencer.conflict import (
+    ConflictService,
+)
+from gitpane.sequencer.mergetool import MergetoolService, TemporaryMergeStore
+from gitpane.sequencer.rebase import RebaseService
+from gitpane.sequencer.replay import ReplayService
+from gitpane.submodule.submodule_discovery import SubmoduleService
+from gitpane.system.application_identity import declare_application_identity
+from gitpane.system.command_line import command_line_parser
+from gitpane.system.desktop_shortcut import create_installed_desktop_shortcut
+from gitpane.system.linux_distribution import session_distribution_family, session_distribution_release
+from gitpane.system.qt_folder import writable_folder
+from gitpane.system.ready_channel_watch import ReadyChannelWatch
+from gitpane.system.terminal_detach import (
+    detached_child_command,
+    detaches_from_terminal,
+    interrupt_stops_gitpane,
+    relaunch_detached,
+    running_interpreter_options,
+    take_ready_channel,
+)
+from gitpane.tool.difftool import DifftoolService
+from gitpane.tool.editor import EditorService
+from gitpane.tool.git_executable import GitExecutableValidator, terminal_git_filename
+from gitpane.tool.system_editor_default import SystemEditorDefault
+from gitpane.tool.system_text_editor import session_system_text_editor_id
+from gitpane.tool.system_tool import SystemToolService
+from gitpane.tool.terminal_recipe import TerminalRegistry, detect_terminal
+from gitpane.transport.branch_exchange import TransportService
+from gitpane.transport.clone import CloneService
+from gitpane.transport.remote import RemoteService
+from gitpane.ui.look.application_icon import install_application_icon
+from gitpane.ui.look.application_style import configure_system_style
+from gitpane.ui.look.desktop_appearance_follower import install_desktop_appearance_follower
+from gitpane.ui.look.theme_palette import install_light_field_palette
+from gitpane.ui.repository.repository_window import RepositoryWindow
+from gitpane.ui.staging.staging_window import StagingWindow
+from gitpane.ui.widget.drop_down_wheel_filter import DropDownWheelFilter
+from gitpane.ui.widget.refresh_advice import refresh_advice_text
+from gitpane.ui.window_control.desktop_activation import desktop_activation
+from gitpane.ui.window_control.modal_focus_relay import ModalFocusRelay, modal_window_activator
+from gitpane.ui.window_control.window_placement import NewWindowPlacement
+from gitpane.worktree.historical_restore import HistoricalRestoreService
+from gitpane.worktree.mutation import MutationService
+from gitpane.worktree.staging import StagingSession
+from gitpane.worktree.worktree_service import WorktreeService
+from gitpane.worktree.worktree_snapshot import WorktreeKey
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from gitpane.sequencer.merge_recovery import MergeRecoveryStore
+
+
+class ApplicationWiring(QObject):
+    """Build the services of GitPane, then connect them to its windows."""
+
+    def __init__(self, application: QApplication, preference: PreferenceStore, repository: GitRepository, diagnostic_log: DiagnosticLog | None = None,
+                 avatar_service: AvatarService | None = None, system_tool: SystemToolService | None = None, terminal_registry: TerminalRegistry | None = None,
+                 difftool: DifftoolService | None = None, merge_recovery: MergeRecoveryStore | None = None, rebase: RebaseService | None = None,
+                 leave_event_loop: Callable[[], None] | None = None, system_editor_default: SystemEditorDefault | None = None) -> None:
+        """Inject external services and keep window lifetimes explicit.
+
+        system_editor_default keeps the text editor the system names for plain text; by default it reads the session's
+        files of this system, only when asked, so building the wiring reads nothing, and writes an unexpected error of its read to the --log journal.
+
+        leave_event_loop ends the application once everything has drained. Only the caller that runs the event loop knows
+        that a loop runs to be left, so it gives QApplication.exit there; the default, QApplication.quit, does nothing
+        while no loop runs, which keeps a wiring driven without one, as in the tests, from stopping later loops.
+        """
+        super().__init__(application)
+        self.session_registry_controller = SessionRegistry()
+        self.application = application
+        self.leave_event_loop = leave_event_loop if leave_event_loop is not None else application.quit
+        self.preference = preference
+        self.repository = repository
+        # The distribution is read once here and handed to everything that says how to install a tool on it.
+        distribution_family = session_distribution_family()
+        distribution_release = session_distribution_release()
+        self.difftool = difftool if difftool is not None else DifftoolService(repository, parent=self, activation=desktop_activation, distribution_family=distribution_family,
+                                                                              distribution_release=distribution_release)
+        self.worktree_service = WorktreeService(repository.runner, self)
+        self.editor = EditorService(self)
+        # The operation policy reads this service, so it is built after it: the lambdas read the policy when a write is submitted.
+        self.repository_operation = RepositoryOperationService(self.worktree_service, self, allows=lambda intent: self.operation_policy_controller.operation_allowed(intent),
+                                                               explains=lambda intent: self.operation_policy_controller.operation_refusal(intent))
+        self.rebase = rebase if rebase is not None else RebaseService(self.worktree_service, self, repository_operation=self.repository_operation, editor=self.editor)
+        self.operation_policy_controller = OperationPolicy(session_registry_controller=self.session_registry_controller, repository=self.repository, repository_operation=self.repository_operation, rebase=self.rebase)
+        self.replay = ReplayService(self.worktree_service, self, repository_operation=self.repository_operation)
+        # Connected before the merge tool service is built: it connects itself to this signal while it is built, and Qt
+        # calls the slots of a signal in connection order, so these three keep running before its own. The rebase, replay
+        # and worktree state controllers are built after that service, so their slots are read by lambdas when the signal comes.
+        self.repository_operation.changed.connect(lambda: self.rebase_controller.rebase_actions_changed())
+        self.repository_operation.changed.connect(lambda: self.replay_controller.replay_actions_changed())
+        self.repository_operation.changed.connect(lambda: self.worktree_state_controller.merge_banner_actions_changed())
+        self.reference = ReferenceService(self.worktree_service, self.repository_operation, refresh_advice=refresh_advice_text)
+        self.stash = StashService(self.worktree_service, self.repository_operation)
+        self.remote = RemoteService(self.worktree_service, self.repository_operation)
+        self.mutation = MutationService(repository.runner, self.worktree_service, self, repository_operation=self.repository_operation)
+        self.historical_restore = HistoricalRestoreService(self.mutation, self)
+        self.git_setting_service = GitSettingService(repository.runner, self.mutation, self)
+        # The search of the credential manager writes its --log lines from the background task of each operation.
+        log_line = diagnostic_log.write_line if diagnostic_log is not None else ignore_line
+        credential_manager = CredentialManagerLocator(sys.platform, os.environ, log_line=log_line, distribution_family=distribution_family,
+                                                      architecture=session_gcm_archive_architecture())
+        self.authentication = AuthenticationService(preference, self, credential_manager=credential_manager,
+                                                    current_git_filename=lambda: terminal_git_filename(self.repository.git_filename))
+        self.ssh_client_finder = SshClientFinder(lambda: terminal_git_filename(self.repository.git_filename), sys.platform, os.environ, log_line=log_line)
+        self.ssh = SshService(preference, repository.runner, self, repository_operation=self.repository_operation, detect_client=self.ssh_client_finder.find)
+        self.transport = TransportService(self.remote, self.authentication, self.ssh, self.repository_operation, repository.runner,
+                                          self, is_current=self.operation_policy_controller.operation_allowed, log=diagnostic_log)
+        # Connected before the commit-and-push service is built: it connects itself to this signal while it is built, and
+        # Qt calls the slots of a signal in connection order, so these two keep running before its own. The end of a remote
+        # deletion comes first, as it did when the end of a transfer called it first; it ignores any other transfer, whose
+        # operation is never one a deletion form submitted. The reference form and transport controllers are built after
+        # that service, so their slots are read by lambdas when the signal comes.
+        self.transport.finished.connect(lambda outcome: self.reference_form_controller.delete_finished(outcome))
+        self.transport.finished.connect(lambda outcome: self.transport_controller.transport_finished(outcome))
+        self.commit_push = CommitPushService(self.transport, current_operation=self.operation_policy_controller.commit_push_operation, parent=self)
+        self.clone = CloneService(repository.runner, self.repository_operation, self.authentication, self.ssh, self, is_current=self.operation_policy_controller.clone_is_current, log=diagnostic_log)
+        self.staging_session_registry_controller = StagingSessionRegistry(repository=self.repository, worktree_service=self.worktree_service, rebase=self.rebase, mutation=self.mutation,
+                                                                          wire_staging_session=self.wire_staging_session, window_factory=StagingWindow, parent=self)
+        self.window_activation_controller = WindowActivationFilter(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller,
+                                                                   staging_session_registry_controller=self.staging_session_registry_controller, application=self.application,
+                                                                   preference=self.preference, parent=self)
+        self.console_registry_controller = ConsoleRegistry()
+        self.conflict = ConflictService()
+        self.mergetool = MergetoolService(self.conflict, self.mutation, self, temporary_store=TemporaryMergeStore(merge_recovery), activation=desktop_activation,
+                                         distribution_family=distribution_family, distribution_release=distribution_release)
+        self.diagnostic_log = diagnostic_log
+        self.reference_read_controller = ReferenceReadController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller, repository=self.repository, reference=self.reference,
+                                                                 diagnostic_log=self.diagnostic_log)
+        self.process_log_writer: ProcessLogWriter | None = None
+        # The condition is on the open file, not on the option: without a log to write into, no subscriber must be
+        # added to the path every single process goes through. The attribute keeps the writer alive with this owner.
+        if diagnostic_log is not None and diagnostic_log.stream is not None:
+            self.process_log_writer = ProcessLogWriter(diagnostic_log, [repository.runner, self.authentication.runner])
+        self.avatar_service = avatar_service if avatar_service is not None else AvatarService(parent=self)
+        self.system_tool = system_tool if system_tool is not None else SystemToolService(parent=self, activation=desktop_activation)
+        # Git Bash is searched from the Git and the utilities folder GitPane uses, both read at each search.
+        self.terminal_registry = terminal_registry if terminal_registry is not None else TerminalRegistry(
+            preference, lambda: detect_terminal(git_filename=terminal_git_filename(self.repository.git_filename), git_utility_dir=str(self.preference.value_by_key["git_utility_dir"])),
+            parent=self)
+        self.validator = GitExecutableValidator(repository.runner)
+        self.submodule = SubmoduleService(self.worktree_service, self.repository_operation, self.authentication, self.ssh, diagnostic_log)
+        self.refresh_controller = RefreshController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller,
+                                                    staging_session_registry_controller=self.staging_session_registry_controller, reference_read_controller=self.reference_read_controller, repository=self.repository, submodule=self.submodule,
+                                                    parent=self)
+        self.history_rewrite_controller = HistoryRewriteController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller,
+                                                                  reference_read_controller=self.reference_read_controller, console_registry_controller=self.console_registry_controller,
+                                                                  refresh_controller=self.refresh_controller, repository=self.repository, worktree_service=self.worktree_service,
+                                                                  repository_operation=self.repository_operation,
+                                                                  storage_root_dir=os.path.join(writable_folder(QStandardPaths.StandardLocation.AppLocalDataLocation, sys.platform), HISTORY_REWRITE_STORAGE_BASENAME),
+                                                                  preference=self.preference, diagnostic_log=self.diagnostic_log, parent=self)
+        self.worktree_state_controller = WorktreeStateController(session_registry_controller=self.session_registry_controller, staging_session_registry_controller=self.staging_session_registry_controller,
+                                                                 reference_read_controller=self.reference_read_controller, refresh_controller=self.refresh_controller, repository_operation=self.repository_operation, conflict=self.conflict,
+                                                                 mergetool=self.mergetool, parent=self)
+        self.history_read_controller = HistoryReadController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller, reference_read_controller=self.reference_read_controller,
+                                                             refresh_controller=self.refresh_controller, preference=self.preference, repository=self.repository, clone=self.clone, diagnostic_log=self.diagnostic_log, system_tool=self.system_tool,
+                                                             parent=self)
+        self.commit_timing_controller = CommitTimingController(session_registry_controller=self.session_registry_controller, staging_session_registry_controller=self.staging_session_registry_controller,
+                                                               worktree_state_controller=self.worktree_state_controller, history_read_controller=self.history_read_controller, refresh_controller=self.refresh_controller,
+                                                               reference_read_controller=self.reference_read_controller, repository=self.repository, authentication=self.authentication,
+                                                               worktree_service=self.worktree_service, repository_operation=self.repository_operation, diagnostic_log=self.diagnostic_log, parent=self)
+        self.system_editor_default = system_editor_default if system_editor_default is not None else SystemEditorDefault(session_system_text_editor_id, parent=self, log_line=log_line)
+        self.setting_controller = SettingController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller,
+                                                    staging_session_registry_controller=self.staging_session_registry_controller, window_activation_controller=self.window_activation_controller, history_read_controller=self.history_read_controller,
+                                                    preference=self.preference, repository=self.repository, git_setting_service=self.git_setting_service, ssh=self.ssh, mergetool=self.mergetool, diagnostic_log=self.diagnostic_log,
+                                                    terminal_registry=self.terminal_registry, validator=self.validator, system_editor_default=self.system_editor_default,
+                                                    distribution_family=distribution_family, distribution_release=distribution_release,
+                                                    desktop_shortcut=functools.partial(create_installed_desktop_shortcut, application_module_name=application_module_name()), parent=self)
+        self.account_controller = AccountController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller, setting_controller=self.setting_controller, repository=self.repository,
+                                                    worktree_service=self.worktree_service, remote=self.remote, authentication=self.authentication, diagnostic_log=self.diagnostic_log,
+                                                    read_keyring=read_session_keyring_state)
+        self.clone_controller = CloneController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller, account_controller=self.account_controller, application=self.application,
+                                                preference=self.preference, repository=self.repository, authentication=self.authentication, clone=self.clone, diagnostic_log=self.diagnostic_log, parent=self)
+        self.opening_controller = OpeningController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller,
+                                                    staging_session_registry_controller=self.staging_session_registry_controller, window_activation_controller=self.window_activation_controller,
+                                                    reference_read_controller=self.reference_read_controller, refresh_controller=self.refresh_controller, history_read_controller=self.history_read_controller,
+                                                    setting_controller=self.setting_controller, clone_controller=self.clone_controller, preference=self.preference, repository=self.repository, authentication=self.authentication, clone=self.clone,
+                                                    diagnostic_log=self.diagnostic_log, wire_repository_window=self.wire_repository_window, parent=self)
+        self.welcome_controller = WelcomeController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller, window_activation_controller=self.window_activation_controller,
+                                                    setting_controller=self.setting_controller, clone_controller=self.clone_controller, opening_controller=self.opening_controller, preference=self.preference, repository=self.repository,
+                                                    diagnostic_log=self.diagnostic_log)
+        self.emoji_window_controller = EmojiWindowController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller, application=self.application, preference=self.preference,
+                                                             diagnostic_log=self.diagnostic_log)
+        self.file_action_controller = FileActionController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller,
+                                                           staging_session_registry_controller=self.staging_session_registry_controller, refresh_controller=self.refresh_controller, history_read_controller=self.history_read_controller,
+                                                           opening_controller=self.opening_controller, preference=self.preference, repository=self.repository, difftool=self.difftool, worktree_service=self.worktree_service,
+                                                           historical_restore=self.historical_restore, diagnostic_log=self.diagnostic_log, system_tool=self.system_tool,
+                                                           system_editor_default=self.system_editor_default)
+        self.staging_controller = StagingController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller,
+                                                    staging_session_registry_controller=self.staging_session_registry_controller, window_activation_controller=self.window_activation_controller, refresh_controller=self.refresh_controller,
+                                                    worktree_state_controller=self.worktree_state_controller, history_read_controller=self.history_read_controller, opening_controller=self.opening_controller,
+                                                    emoji_window_controller=self.emoji_window_controller, file_action_controller=self.file_action_controller, preference=self.preference, repository=self.repository, diagnostic_log=self.diagnostic_log)
+        self.transport_controller = TransportController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller,
+                                                        staging_session_registry_controller=self.staging_session_registry_controller, console_registry_controller=self.console_registry_controller,
+                                                        reference_read_controller=self.reference_read_controller, refresh_controller=self.refresh_controller, account_controller=self.account_controller, clone_controller=self.clone_controller,
+                                                        preference=self.preference, repository=self.repository, worktree_service=self.worktree_service, repository_operation=self.repository_operation, remote=self.remote,
+                                                        authentication=self.authentication, transport=self.transport, commit_push=self.commit_push, diagnostic_log=self.diagnostic_log, parent=self)
+        self.reference_form_controller = ReferenceFormController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller,
+                                                                 console_registry_controller=self.console_registry_controller, reference_read_controller=self.reference_read_controller, refresh_controller=self.refresh_controller,
+                                                                 history_read_controller=self.history_read_controller, staging_controller=self.staging_controller, transport_controller=self.transport_controller, preference=self.preference,
+                                                                 repository=self.repository, worktree_service=self.worktree_service, reference=self.reference, remote=self.remote, transport=self.transport, diagnostic_log=self.diagnostic_log)
+        self.replay_controller = ReplayController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller,
+                                                  staging_session_registry_controller=self.staging_session_registry_controller, console_registry_controller=self.console_registry_controller, reference_read_controller=self.reference_read_controller,
+                                                  refresh_controller=self.refresh_controller, worktree_state_controller=self.worktree_state_controller, history_read_controller=self.history_read_controller,
+                                                  reference_form_controller=self.reference_form_controller, repository=self.repository, repository_operation=self.repository_operation, replay=self.replay, mergetool=self.mergetool,
+                                                  diagnostic_log=self.diagnostic_log, parent=self)
+        self.rebase_editor_controller = RebaseEditorController(editor=self.editor, worktree_service=self.worktree_service, parent=self)
+        self.rebase_controller = RebaseController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller,
+                                                  staging_session_registry_controller=self.staging_session_registry_controller, window_activation_controller=self.window_activation_controller,
+                                                  console_registry_controller=self.console_registry_controller, reference_read_controller=self.reference_read_controller, refresh_controller=self.refresh_controller,
+                                                  worktree_state_controller=self.worktree_state_controller, history_read_controller=self.history_read_controller, staging_controller=self.staging_controller,
+                                                  replay_controller=self.replay_controller, rebase_editor_controller=self.rebase_editor_controller, preference=self.preference, repository=self.repository,
+                                                  worktree_service=self.worktree_service, repository_operation=self.repository_operation, rebase=self.rebase, mergetool=self.mergetool, diagnostic_log=self.diagnostic_log, parent=self)
+        self.stash_controller = StashController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller, staging_session_registry_controller=self.staging_session_registry_controller,
+                                                window_activation_controller=self.window_activation_controller, refresh_controller=self.refresh_controller,
+                                                replay_controller=self.replay_controller, preference=self.preference, repository=self.repository, worktree_service=self.worktree_service, stash=self.stash, diagnostic_log=self.diagnostic_log,
+                                                parent=self)
+        self.conflict_controller = ConflictController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller,
+                                                      staging_session_registry_controller=self.staging_session_registry_controller, window_activation_controller=self.window_activation_controller, refresh_controller=self.refresh_controller,
+                                                      worktree_state_controller=self.worktree_state_controller, setting_controller=self.setting_controller,
+                                                      reference_form_controller=self.reference_form_controller, replay_controller=self.replay_controller, rebase_controller=self.rebase_controller, stash_controller=self.stash_controller,
+                                                      preference=self.preference, repository=self.repository, worktree_service=self.worktree_service, repository_operation=self.repository_operation, rebase=self.rebase, reference=self.reference,
+                                                      stash=self.stash, mutation=self.mutation, conflict=self.conflict, mergetool=self.mergetool, diagnostic_log=self.diagnostic_log, parent=self)
+        self.close_readiness_controller = CloseReadiness(session_registry_controller=self.session_registry_controller, console_registry_controller=self.console_registry_controller, reference_form_controller=self.reference_form_controller,
+                                                         replay_controller=self.replay_controller, rebase_controller=self.rebase_controller, rebase_editor_controller=self.rebase_editor_controller, editor=self.editor,
+                                                         repository_operation=self.repository_operation, rebase=self.rebase, replay=self.replay,
+                                                         mutation=self.mutation, mergetool=self.mergetool, parent=self)
+        self.navigation_controller = NavigationController(session_registry_controller=self.session_registry_controller, operation_policy_controller=self.operation_policy_controller,
+                                                          staging_session_registry_controller=self.staging_session_registry_controller, reference_read_controller=self.reference_read_controller, refresh_controller=self.refresh_controller,
+                                                          history_read_controller=self.history_read_controller, account_controller=self.account_controller, opening_controller=self.opening_controller, transport_controller=self.transport_controller,
+                                                          replay_controller=self.replay_controller, rebase_controller=self.rebase_controller, close_readiness_controller=self.close_readiness_controller, preference=self.preference,
+                                                          repository=self.repository, reference=self.reference, authentication=self.authentication, diagnostic_log=self.diagnostic_log, submodule=self.submodule, parent=self)
+        self.shutdown_controller = ShutdownController(session_registry_controller=self.session_registry_controller, staging_session_registry_controller=self.staging_session_registry_controller,
+                                                      window_activation_controller=self.window_activation_controller, reference_read_controller=self.reference_read_controller, refresh_controller=self.refresh_controller,
+                                                      history_read_controller=self.history_read_controller, account_controller=self.account_controller,
+                                                      emoji_window_controller=self.emoji_window_controller, transport_controller=self.transport_controller, reference_form_controller=self.reference_form_controller,
+                                                      replay_controller=self.replay_controller, rebase_controller=self.rebase_controller, stash_controller=self.stash_controller, conflict_controller=self.conflict_controller,
+                                                      close_readiness_controller=self.close_readiness_controller, navigation_controller=self.navigation_controller, application=self.application,
+                                                      leave_event_loop=self.leave_event_loop, repository=self.repository,
+                                                      difftool=self.difftool, worktree_service=self.worktree_service, editor=self.editor, repository_operation=self.repository_operation, rebase=self.rebase, replay=self.replay, mutation=self.mutation,
+                                                      authentication=self.authentication, ssh=self.ssh, transport=self.transport, clone=self.clone, mergetool=self.mergetool, system_tool=self.system_tool, submodule=self.submodule, parent=self)
+        # Everything above is built before anything is connected, and the connections below keep the order they had: Qt calls
+        # the slots of a signal in connection order, and every object a connection reaches must already exist. The few
+        # connections made above stay ahead of a slot that a service adds to the same signal while it is built.
+        self.rebase.changed.connect(self.worktree_state_controller.relay_rebase_state)
+        self.rebase.changed.connect(self.rebase_controller.follow_rebase_ended_outside)
+        self.repository_operation.finished.connect(self.replay_controller.replay_finished)
+        self.replay.changed.connect(self.worktree_state_controller.relay_replay_state)
+        self.repository_operation.finished.connect(self.stash_controller.stash_finished)
+        self.repository_operation.finished.connect(self.stash_controller.stash_pop_finished)
+        self.repository_operation.finished.connect(self.stash_controller.stash_drop_finished)
+        self.repository_operation.finished.connect(self.reference_form_controller.reset_finished)
+        self.repository_operation.finished.connect(self.reference_form_controller.checkout_finished)
+        self.repository_operation.finished.connect(self.reference_form_controller.branch_finished)
+        self.repository_operation.finished.connect(self.reference_form_controller.delete_finished)
+        self.repository_operation.finished.connect(self.reference_form_controller.branch_deletion_finished)
+        self.repository_operation.finished.connect(self.reference_form_controller.tag_finished)
+        self.repository_operation.finished.connect(self.conflict_controller.merge_abort_finished)
+        self.mutation.finished.connect(self.file_action_controller.historical_restore_finished)
+        self.repository_operation.finished.connect(self.history_rewrite_controller.operation_finished)
+        self.history_rewrite_controller.recovery_requested.connect(self.history_rewrite_controller.present_recovery)
+        self.opening_controller.pause_observation_requested.connect(self.history_rewrite_controller.check_pending_recovery)
+        self.refresh_controller.pause_observation_requested.connect(lambda session_id, *_: self.history_rewrite_controller.check_pending_recovery(session_id))
+        self.refresh_controller.refresh_started.connect(self.history_rewrite_controller.observe_refresh)
+        self.worktree_service.idle.connect(self.history_rewrite_controller.readers_changed)
+        self.repository.runner.idle.connect(self.history_rewrite_controller.readers_changed)
+        self.git_setting_service.changed.connect(self.staging_controller.git_setting_changed)
+        self.commit_push.push_started.connect(self.transport_controller.commit_push_started)
+        self.commit_push.tracking_decision_requested.connect(self.transport_controller.commit_push_decide_tracking)
+        self.commit_push.choose_requested.connect(self.transport_controller.commit_push_choose)
+        self.application.aboutToQuit.connect(self.transport.close)
+        self.clone.finished.connect(self.clone_controller.clone_finished)
+        self.ssh.question_requested.connect(self.account_controller.show_ssh_question)
+        self.ssh.question_closed.connect(self.account_controller.close_ssh_question)
+        self.application.aboutToQuit.connect(self.ssh.close)
+        self.authentication.idle.connect(self.shutdown_controller.maybe_quit)
+        self.application.aboutToQuit.connect(self.authentication.close)
+        self.mutation.finished.connect(self.staging_controller.log_mutation_result)
+        self.mergetool.finished.connect(self.conflict_controller.mergetool_finished)
+        self.mergetool.series_changed.connect(self.conflict_controller.mergetool_series_changed)
+        self.mergetool.series_finished.connect(self.conflict_controller.mergetool_series_finished)
+        self.mergetool.confirmation_requested.connect(self.conflict_controller.confirm_mergetool)
+        self.mergetool.confirmation_closed.connect(self.conflict_controller.close_merge_confirmation)
+        self.mergetool.idle.connect(self.shutdown_controller.maybe_quit)
+        self.application.aboutToQuit.connect(self.mergetool.close)
+        self.mutation.finished.connect(self.conflict_controller.conflict_resolution_finished)
+        # A drop waiting for the merge tool or another write to release the repository starts as soon as it is free.
+        self.repository_operation.changed.connect(self.stash_controller.continue_stash_drops_after_resolution)
+        self.difftool.failed.connect(self.file_action_controller.difftool_failed)
+        self.difftool.started.connect(self.file_action_controller.difftool_started)
+        self.difftool.tool_exited.connect(self.file_action_controller.difftool_closed)
+        self.application.aboutToQuit.connect(self.difftool.close)
+        self.application.aboutToQuit.connect(self.avatar_service.close)
+        self.repository_operation.finished.connect(self.rebase_controller.rebase_finished)
+        self.editor.waiting.connect(self.rebase_controller.rebase_editor_waiting)
+        # Only a wait reads the native list again, so a reword shows the edited instructions; closing the editor
+        # changes the progress text alone, and the command's own result follows.
+        self.editor.finished.connect(lambda result: self.rebase_controller.rebase_progress(result.request.operation_id, SharedText.REBASE_APPLYING_COMMITS.value))
+        # A request whose bridge was lost ends without an answer, and Git goes on to its own result the same way.
+        self.editor.edit_cancelled.connect(lambda request: self.rebase_controller.rebase_progress(request.operation_id, SharedText.REBASE_APPLYING_COMMITS.value))
+        self.editor.idle.connect(self.shutdown_controller.maybe_quit)
+        self.system_tool.started.connect(self.file_action_controller.tool_started)
+        self.system_tool.finished.connect(self.file_action_controller.tool_finished)
+        self.system_tool.export_finished.connect(self.file_action_controller.export_finished)
+        self.application.aboutToQuit.connect(self.system_tool.close)
+        self.validator.validated.connect(self.setting_controller.git_validated)
+        self.validator.tools_folder_checked.connect(self.setting_controller.git_tools_folder_checked)
+        # Settings applies a change first, then an open accounts page and the clone forms show the accounts it touched, as before.
+        self.preference.changed.connect(self.setting_controller.preference_changed)
+        self.preference.changed.connect(self.account_controller.preference_changed_for_accounts)
+        self.preference.changed.connect(self.clone_controller.preference_changed_for_clone_forms)
+        # A read a navigation owns goes to its own slot, connected first; the opening's and the history read's slots that follow ignore it.
+        self.repository.opened.connect(self.navigation_controller.navigation_opened)
+        self.repository.opened.connect(self.opening_controller.opened)
+        self.repository.failed.connect(self.navigation_controller.navigation_read_failed)
+        self.repository.failed.connect(self.history_read_controller.failed)
+        self.repository.snapshot_read.connect(self.navigation_controller.navigation_snapshot_read)
+        self.repository.snapshot_read.connect(self.history_read_controller.snapshot_read)
+        self.repository.commit_batch_read.connect(self.navigation_controller.navigation_commit_batch_read)
+        self.repository.commit_batch_read.connect(self.history_read_controller.commit_batch_read)
+        self.repository.commit_read.connect(self.history_read_controller.commit_read)
+        self.repository.matching_read.connect(self.navigation_controller.navigation_matching_read)
+        self.repository.matching_read.connect(self.history_read_controller.matching_read)
+        self.repository.relation_read.connect(self.history_read_controller.relation_read)
+        self.repository.changes_read.connect(self.history_read_controller.changes_read)
+        self.repository.diff_read.connect(self.history_read_controller.diff_read)
+        self.repository.tree_read.connect(self.history_read_controller.tree_read)
+        self.repository.blob_read.connect(self.history_read_controller.blob_read)
+        self.repository.file_failed.connect(self.history_read_controller.file_failed)
+        self.application.aboutToQuit.connect(self.repository.close)
+        self.close_readiness_controller.close_timer.timeout.connect(self.shutdown_controller.resume_pending_close)
+        self.repository.runner.idle.connect(self.shutdown_controller.maybe_quit)
+        self.repository_operation.idle.connect(self.shutdown_controller.maybe_quit)
+        self.system_tool.export_idle.connect(self.shutdown_controller.maybe_quit)
+        self.difftool.idle.connect(self.shutdown_controller.maybe_quit)
+        self.mutation.finished.connect(self.shutdown_controller.maybe_quit)
+        self.worktree_service.idle.connect(self.shutdown_controller.maybe_quit)
+        if diagnostic_log is not None:
+            self.application.aboutToQuit.connect(diagnostic_log.close)
+        # A controller tells a higher one through a signal connected here. The lambda reads the slot when the signal comes,
+        # so a slot replaced on its owner after construction is the one called, and passes the options it only takes by name.
+        self.refresh_controller.pause_observation_requested.connect(
+            lambda session_id, replay_publication, rebase_publication: self.rebase_controller.observe_rebase(session_id, open_paused=True, replay_publication=replay_publication,
+                                                                                           rebase_publication=rebase_publication))
+        self.worktree_state_controller.automatic_observation_requested.connect(lambda session_id: self.rebase_controller.observe_rebase(session_id, open_paused=True, automatic=True))
+        self.worktree_state_controller.window_conflict_state_shown.connect(lambda session_id, key, conflict_state: self.conflict_controller.show_window_conflict_state(session_id, key, conflict_state))
+        # The stash kept for its conflicts is settled before the conflicts a Stash pop left are read again, as before.
+        self.worktree_state_controller.worktree_conflict_state_read.connect(lambda key: self.stash_controller.continue_stash_drop_after_resolution(key))
+        self.worktree_state_controller.worktree_conflict_state_read.connect(lambda key: self.conflict_controller.read_conflict_retention(key))
+        # A published history ends the replay refresh waiting for it before a finished rebase shows its final commit, as before.
+        self.history_read_controller.history_published.connect(lambda session_id, generation: self.replay_controller.finish_replay_refresh(session_id, published_generation=generation))
+        self.history_read_controller.history_published.connect(lambda session_id, generation: self.history_rewrite_controller.readers_changed())
+        self.history_read_controller.history_published.connect(lambda session_id, generation: self.rebase_controller.reveal_rebase_result(session_id))
+        self.history_read_controller.history_status_written.connect(lambda session_id, snapshot: self.rebase_controller.show_rebase_end_notice(session_id, snapshot, after_history=True))
+        self.history_read_controller.refresh_failed.connect(lambda session_id, diagnostic: self.replay_controller.finish_replay_refresh(session_id, diagnostic))
+        self.history_read_controller.refresh_failed.connect(lambda session_id, diagnostic: self.rebase_controller.forget_rebase_end_notice(session_id))
+        self.setting_controller.setting_opened.connect(
+            lambda dialog, account_page, session_id, context: self.account_controller.bind_setting_account_page(dialog, account_page, session_id, context))
+        self.setting_controller.git_missing.connect(lambda: self.welcome_controller.show_missing_git())
+        self.setting_controller.waiting_opening_released.connect(lambda waiting: self.opening_controller.resume_waiting_opening(waiting))
+        self.clone_controller.open_requested.connect(lambda session_id, repository_dir: self.opening_controller.open(session_id, repository_dir))
+        self.clone_controller.open_cancel_requested.connect(lambda session_id: self.opening_controller.cancel_open(session_id))
+        self.opening_controller.pause_observation_requested.connect(lambda session_id: self.rebase_controller.observe_rebase(session_id, open_paused=True))
+        self.replay_controller.conflict_write_availability_changed.connect(lambda session_id, locked: self.conflict_controller.show_conflict_write_availability(session_id, locked))
+        self.rebase_controller.close_wait_requested.connect(lambda session_id: self.close_readiness_controller.show_close_wait(session_id))
+        self.rebase_controller.rebase_state_shown.connect(lambda session_id, state: self.conflict_controller.show_rebase_state_in_conflict_dialog(session_id, state))
+        self.rebase_controller.conflict_list_requested.connect(lambda session_id: self.conflict_controller.open_conflict_dialog(session_id))
+        self.stash_controller.conflict_retention_requested.connect(lambda key, observation: self.conflict_controller.track_conflict_retention(key, observation))
+        # The session a published change of repository leaves behind closes at once, its window and the navigation it publishes kept.
+        self.navigation_controller.repository_close_requested.connect(lambda owner_id: self.shutdown_controller.close_repository(owner_id, keep_navigation=True))
+        # Qt calls the filters of the application from the last installed to the first: the placement filter still sees a
+        # window's first show before the activation filter, and the event types of the other filters do not overlap; the
+        # modal relay alone follows WindowBlocked and WindowUnblocked.
+        application.installEventFilter(self.shutdown_controller)
+        self.drop_down_wheel_filter = DropDownWheelFilter(application, self)
+        application.installEventFilter(self.window_activation_controller)
+        application.applicationStateChanged.connect(self.window_activation_controller.schedule_activation_update)
+        self.window_placement = NewWindowPlacement(application, self)
+        self.modal_focus_relay: ModalFocusRelay | None = None
+        activate_modal_window = modal_window_activator(QGuiApplication.platformName())
+        if activate_modal_window is not None:
+            self.modal_focus_relay = ModalFocusRelay(application, activate_modal_window, self)
+
+    def wire_staging_session(self, key: WorktreeKey, staging: StagingSession) -> None:
+        """Connect a new preparation session to the controllers that follow what it does.
+
+        The registry that creates the session sits below these controllers and knows none of them, so its connections are
+        made here, together, in the order Qt calls them. The commit timing hears a commit's result after the controllers
+        that start its refresh, so the refresh it waits for is already asked.
+        """
+        staging.changed.connect(lambda: self.worktree_state_controller.show_worktree_state(key))
+        staging.changed.connect(lambda: self.history_rewrite_controller.observe_worktree(staging))
+        staging.head_moved.connect(lambda: self.worktree_state_controller.follow_moved_head(key))
+        staging.pause_observation_requested.connect(lambda: self.worktree_state_controller.observe_worktree_pause(key))
+        staging.window_opened.connect(self.staging_controller.staging_window_opened)
+        staging.commit_finished.connect(lambda outcome: self.staging_controller.commit_finished(staging, outcome))
+        staging.commit_finished.connect(self.commit_push.commit_finished)
+        staging.commit_submitted.connect(lambda request: self.commit_timing_controller.commit_clicked(staging, request))
+        staging.commit_finished.connect(self.commit_timing_controller.commit_finished)
+        staging.commit_push_requested.connect(self.transport_controller.commit_push_requested)
+        # The session behind this service has just read its worktree on the same result, so only the others read.
+        staging.ignore_service.changed.connect(lambda context: self.staging_controller.ignore_changed(context, refreshed_key=staging.key))
+        staging.ignore_service.finished.connect(self.staging_controller.log_mutation_result)
+        staging.history_requested.connect(lambda anchor: self.staging_controller.open_staging_history(staging, anchor))
+        staging.folder_requested.connect(lambda path: self.system_tool.show_file_location((key.git_dir, STAGING_FOLDER_TOOL), staging.context, path, allow_missing=True))
+        staging.text_editor_requested.connect(lambda path: self.file_action_controller.launch_text_editor((key.git_dir, STAGING_TEXT_EDITOR_TOOL), staging.context, path))
+        # A brand new session has never been told which window is active, and no activation event is on its way.
+        self.window_activation_controller.schedule_activation_update()
+
+    def wire_repository_window(self, identity: RequestIdentity, session: RepositorySession, window: RepositoryWindow, context: RepositoryContext, file_history_anchor: FileHistoryAnchor | None) -> None:
+        """Connect a new repository window and its session to the controllers that answer what the user does in it.
+
+        The opening that builds the window sits below most of these controllers and knows none of them, so its
+        connections are made here, together, in the order Qt calls them, before the window is shown.
+        """
+        window.file_history_requested.connect(lambda entry: self.file_action_controller.open_file_history(identity.session_id, entry))
+        window.remove_history_requested.connect(lambda selection: self.history_rewrite_controller.request(identity.session_id, selection))
+        window.remove_history_reason = lambda selection: self.history_rewrite_controller.remove_history_reason(identity.session_id, selection)
+        window.file_folder_requested.connect(lambda selection: self.file_action_controller.show_file_folder(identity.session_id, selection))
+        window.file_text_editor_requested.connect(lambda selection: self.file_action_controller.show_file_in_text_editor(identity.session_id, selection))
+        window.text_editor_reason = lambda selection: self.file_action_controller.text_editor_reason(identity.session_id, selection)
+        if file_history_anchor is None:
+            self.file_action_controller.read_git_editor_setting(context)
+        window.file_save_requested.connect(lambda selection: self.file_action_controller.save_file_as(identity.session_id, selection))
+        window.file_restore_requested.connect(lambda selection, target: self.file_action_controller.restore_historical_file(identity.session_id, selection, target))
+        window.difftool_requested.connect(lambda: self.file_action_controller.compare_external(identity.session_id))
+        window.file_history_resume_requested.connect(lambda: self.history_read_controller.resume_file_history(identity.session_id))
+        session.selection_changed.connect(lambda oid: window.diff_panel.clear_selection("Loading diff…"))
+        session.selection_changed.connect(lambda oid: window.file_tree_panel.clear_selection("Loading tree…"))
+        session.closed.connect(window.file_tree_panel.clear_selection)
+        window.file_tree_panel.selection_requested.connect(lambda entry: self.history_read_controller.read_blob(identity.session_id, entry))
+        window.file_tree_panel.retry_requested.connect(lambda kind: self.history_read_controller.retry_file_tree(identity.session_id, kind))
+        window.detail_tabs.currentChanged.connect(lambda _index: self.history_read_controller.read_visible_tree(identity.session_id))
+        window.diff_panel.entry_selected.connect(lambda entry: self.history_read_controller.read_diff(identity.session_id, entry))
+        window.diff_panel.retry_requested.connect(lambda: self.history_read_controller.retry_diff(identity.session_id))
+        window.diff_panel.full_context_requested.connect(lambda checked: self.history_read_controller.save_reading_preference(identity.session_id, {"diff_show_entire_file": checked}))
+        window.reading_preference_requested.connect(lambda values: self.history_read_controller.save_reading_preference(identity.session_id, values))
+        window.set_avatar_service(self.avatar_service)
+        window.explorer_requested.connect(lambda: self.file_action_controller.open_explorer(identity.session_id))
+        if WindowCapability.MANAGE in session.capabilities:
+            window.bind_terminal_registry(self.terminal_registry)
+        window.terminal_requested.connect(lambda descriptor: self.file_action_controller.launch_terminal(identity.session_id, descriptor))
+        window.commit_selected.connect(lambda oid: self.session_registry_controller.session_by_id[identity.session_id].select_commit(oid))
+        window.commit_selected.connect(lambda oid: self.history_read_controller.read_selection(identity.session_id, oid))
+        window.detail_retry_requested.connect(lambda oid: self.history_read_controller.retry_selection(identity.session_id, oid))
+        window.navigation_requested.connect(lambda oid: self.session_registry_controller.session_by_id[identity.session_id].navigate_to_commit(oid))
+        window.repository_activated.connect(lambda directory: self.navigation_controller.navigate_repository(identity.session_id, directory))
+        window.repository_switch_requested.connect(lambda directory: self.navigation_controller.switch_repository(identity.session_id, directory))
+        session.navigation_requested.connect(lambda oid: self.history_read_controller.read_navigation(identity.session_id, oid))
+        window.setting_requested.connect(lambda: self.setting_controller.show_setting(identity.session_id))
+        window.installEventFilter(self.window_activation_controller)
+        window.commit_requested.connect(lambda: self.staging_controller.open_staging(identity.session_id))
+        window.checkout_requested.connect(lambda full_ref: self.reference_form_controller.open_checkout(identity.session_id, full_ref))
+        window.create_branch_requested.connect(lambda oid, snapshot: self.reference_form_controller.open_branch(identity.session_id, BranchMode.CREATE, oid, expected_snapshot=snapshot))
+        window.create_tag_requested.connect(lambda oid, snapshot: self.reference_form_controller.open_tag(identity.session_id, oid, expected_snapshot=snapshot))
+        window.remote_requested.connect(lambda: self.transport_controller.open_remote(identity.session_id))
+        window.emoji_keyboard_requested.connect(lambda: self.emoji_window_controller.open_emoji_window(identity.session_id))
+        window.fetch_requested.connect(lambda: self.transport_controller.fetch(identity.session_id))
+        window.push_requested.connect(lambda: self.transport_controller.open_push(identity.session_id))
+        window.stash_requested.connect(lambda: self.stash_controller.open_stash(identity.session_id))
+        window.resolve_requested.connect(lambda state: self.conflict_controller.open_conflict_dialog(identity.session_id, state))
+        # Continue merge works the way Git Extensions does: it opens Prepare changes, where Git's merge message is offered,
+        # and the user makes the merge commit with Commit; Git's own merge --continue is never run.
+        window.merge_continue_requested.connect(lambda: self.staging_controller.open_staging(identity.session_id))
+        window.merge_abort_requested.connect(lambda: self.conflict_controller.abort_merge(identity.session_id))
+        window.rebase_requested.connect(lambda: self.rebase_controller.open_rebase_dialog(identity.session_id))
+        window.replay_refresh_requested.connect(lambda: self.replay_controller.observe_replay(identity.session_id))
+        window.replay_resolve_requested.connect(lambda state: self.replay_controller.resolve_replay(identity.session_id, state))
+        window.replay_continue_requested.connect(lambda state: self.replay_controller.continue_replay(identity.session_id, state))
+        window.replay_abort_requested.connect(lambda state: self.replay_controller.abort_replay(identity.session_id, state))
+        window.replay_requested.connect(lambda oid, kind, snapshot: self.replay_controller.open_replay(identity.session_id, oid, kind, snapshot))
+        window.rebase_start_requested.connect(lambda oid, snapshot: self.rebase_controller.start_rebase(identity.session_id, oid, snapshot))
+        window.merge_recovery_requested.connect(lambda: self.conflict_controller.open_merge_recovery(identity.session_id))
+        window.stash_pop_requested.connect(lambda: self.stash_controller.stash_pop(identity.session_id))
+        window.stash_drop_requested.connect(lambda entry: self.stash_controller.drop_stash(identity.session_id, entry))
+        window.fetch_selection_requested.connect(lambda choice: self.transport_controller.fetch(identity.session_id, choice))
+        window.fetch_menu_requested.connect(lambda: self.transport_controller.read_fetch_choice(identity.session_id))
+        window.fetch_default_requested.connect(lambda mode: self.transport_controller.save_fetch_default(identity.session_id, mode))
+        window.reset_requested.connect(lambda oid, snapshot: self.reference_form_controller.open_reset(identity.session_id, oid, expected_snapshot=snapshot))
+        window.move_branch_requested.connect(lambda oid, snapshot: self.reference_form_controller.open_branch(identity.session_id, BranchMode.MOVE, oid, expected_snapshot=snapshot))
+        window.rename_branch_requested.connect(lambda full_ref, oid, snapshot: self.reference_form_controller.open_branch(identity.session_id, BranchMode.RENAME, oid, expected_snapshot=snapshot, full_ref=full_ref))
+        window.delete_branch_requested.connect(lambda full_ref, oid, snapshot: self.reference_form_controller.open_delete_branch(identity.session_id, full_ref, oid, expected_snapshot=snapshot))
+        window.delete_tag_requested.connect(lambda full_ref, oid, snapshot: self.reference_form_controller.open_delete_tag(identity.session_id, full_ref, oid, expected_snapshot=snapshot))
+        window.checkout_commit_requested.connect(lambda oid, snapshot: self.reference_form_controller.open_checkout_revision(identity.session_id, oid, expected_snapshot=snapshot))
+        window.checkout_branch_requested.connect(lambda full_ref, oid, snapshot: self.reference_form_controller.open_checkout(identity.session_id, full_ref, target_oid=oid, expected_snapshot=snapshot))
+        window.open_requested.connect(lambda: self.welcome_controller.reopen_welcome(identity.session_id))
+        window.closed.connect(lambda: self.shutdown_controller.close_repository(identity.session_id))
+        window.refresh_requested.connect(lambda: self.refresh_controller.refresh(identity.session_id))
+        window.filter_changed.connect(lambda text: self.history_read_controller.change_filter(identity.session_id, text))
+        window.search_requested.connect(lambda: self.history_read_controller.start_search(identity.session_id))
+
+
+def application_module_name() -> str:
+    """Answer the name under which the import system loaded this module, which a desktop shortcut passes to ``python -m``.
+
+    It is read from the module's spec, so it stays right when this module runs itself through -m, where __name__ is
+    __main__, and a move of the module cannot leave a stale name in the shortcut. A module loaded without a spec has no
+    name to give, and the text is empty.
+    """
+    if __spec__ is None:
+        return ""
+    return __spec__.name
+
+
+def run(argv: list[str], *, preference_filename: str = "") -> int:
+    """Parse command-line options and start the installed Qt application.
+
+    Preferences live in one INI file: ``preference_filename`` when given (test launchers pass a temporary one), otherwise
+    the per-user gitpane.ini. The registry is no longer read or written.
+
+    A GitPane started detached by the gitpane command finds the ready channel in its environment: it is taken before any
+    program is started, so none inherits it, and the ready signal is sent once the first window is shown and Git is set
+    up, which gives the terminal back. When the command is gone before that (its wait ran out, Ctrl+C, the terminal was
+    closed), the standard streams leave its pipes as soon as the event loop runs. This function never detaches by
+    itself: only main() decides that.
+    """
+    ready_channel = take_ready_channel(os.environ)
+    option = command_line_parser().parse_args(argv)
+    declare_application_identity()
+    # The desktop finds a running application by this identifier, which Qt hands to each window when it creates it, so
+    # it is set before the application and its first window. Under Wayland it is the application id GNOME reads to name
+    # the window and to find the GitPane.desktop entry that carries the icon; under X11 the window class keeps matching
+    # the entry's StartupWMClass. Without it, a window started from Python is named after the interpreter.
+    QGuiApplication.setDesktopFileName(APPLICATION_NAME)
+    application = QApplication([APPLICATION_NAME])
+    # Here: the first point where an event loop can watch the channel, so a command gone before the first window is
+    # handled as soon as the loop runs, not only once GitPane is ready.
+    ready_watch = ReadyChannelWatch(ready_channel, application) if ready_channel is not None else None
+    configure_system_style(application)
+    # Here: the application just loaded GTK and subscribed Qt's portal listeners, and a dark desktop palette must exist before the Git Extensions colours are decided on it.
+    install_desktop_appearance_follower(application)
+    install_light_field_palette(application)
+    install_application_icon(application)
+    application.setOrganizationName(APPLICATION_NAME)
+    application.setApplicationName(APPLICATION_NAME)
+    application.setApplicationVersion(APPLICATION_VERSION)
+    preference_filename = preference_filename or user_preference_filename(sys.platform, os.environ, os.path.expanduser("~"))
+    preference = PreferenceStore(QSettings(preference_filename, QSettings.Format.IniFormat))
+    git_filename = str(preference.read("git_filename"))
+    repository = GitRepository(git_filename)
+    diagnostic_log = DiagnosticLog(option.log, writable_folder(QStandardPaths.StandardLocation.AppLocalDataLocation, sys.platform))
+    diagnostic_log.write_line(APPLICATION_VERSION_LINE)
+    diagnostic_log.write_line(PREFERENCE_FILE_LOG_TEXT.format(filename=preference_filename))
+    if preference.warning:
+        diagnostic_log.write_line(preference.warning)
+    for line in preference.foreign_dir_lines:
+        diagnostic_log.write_line(line)
+    # Workaround: on macOS, QApplication.quit() asks AppKit to terminate the application. Asked while GitPane answers
+    # AppKit's own terminate request (Cmd+Q when nothing runs), AppKit calls the C exit() in the middle of a Python call:
+    # exec() never returns and Shiboken's static destructors crash the interpreter. exit() only leaves the event loop,
+    # on every system, so exec() returns here and the process ends normally. It is given here because only this function
+    # runs the loop: called while no loop runs, exit() would make every later event loop return at once.
+    coordinator = ApplicationWiring(application, preference, repository, diagnostic_log, leave_event_loop=application.exit)
+    # The startup read blocks nothing: Show in text editor and Settings use the desktop's editor as soon as it arrives.
+    coordinator.system_editor_default.request_read()
+    coordinator.welcome_controller.show_welcome()
+    coordinator.setting_controller.initialize_git()
+    if ready_watch is not None:
+        # Sent from the event loop, so the first window has had its show handled before the terminal is given back.
+        QTimer.singleShot(0, functools.partial(ready_watch.send_ready, diagnostic_log.log_filename or ""))
+    application.setQuitOnLastWindowClosed(False)
+    application.lastWindowClosed.connect(coordinator.shutdown_controller.request_shutdown)
+    try:
+        return application.exec()
+    finally:
+        diagnostic_log.close()
+
+
+def main(stream_is_terminal: Callable[[int], bool] = os.isatty) -> int:
+    """Start GitPane with the command-line arguments of the process, detached from the terminal it was typed in.
+
+    The installed gitpane command, main.py and python -m gitpane.application call it without argument;
+    ``stream_is_terminal`` lets tests decide whether the standard streams are a terminal. The options are read first, so
+    --version, --help and an unknown option answer in the terminal. Typed in a terminal on Linux or macOS without
+    --attach, GitPane is started again in a session of its own, under the interpreter options of this command, and this
+    command returns once its first window is shown; otherwise GitPane runs in this process, and with --attach Ctrl+C
+    stops it at once.
+    """
+    argv = sys.argv[1:]
+    option = command_line_parser().parse_args(argv)
+    module_name = application_module_name()
+    if module_name and detaches_from_terminal(sys.platform, stream_is_terminal, option.attach, os.environ):
+        return relaunch_detached(detached_child_command(argv, sys.executable, module_name, running_interpreter_options()), os.environ).exit_code
+    if interrupt_stops_gitpane(sys.platform, option.attach):
+        signal.signal(signal.SIGINT, signal.SIG_DFL)
+    return run(argv)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())