gitpane 1.0.0__py3-none-any.whl

gitpane/controller/shutdown_controller.py

@@ -0,0 +1,345 @@
+"""Close GitPane only once no write or process it started still runs."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QObject, Qt
+from PySide6.QtWidgets import QApplication, QDialog
+from shiboken6 import isValid
+
+from gitpane.controller.session_registry import NavigationKind
+from gitpane.operation.operation_status import OperationStatus
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtWidgets import QWidget
+
+    from gitpane.account.authentication import AuthenticationService
+    from gitpane.account.ssh import SshService
+    from gitpane.controller.account_controller import AccountController
+    from gitpane.controller.close_readiness import CloseReadiness
+    from gitpane.controller.conflict_controller import ConflictController
+    from gitpane.controller.emoji_window_controller import EmojiWindowController
+    from gitpane.controller.history_read_controller import HistoryReadController
+    from gitpane.controller.navigation_controller import NavigationController
+    from gitpane.controller.rebase_controller import RebaseController
+    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 SessionRegistry
+    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.window_activation import WindowActivationFilter
+    from gitpane.history.repository import GitRepository
+    from gitpane.operation.repository_operation import RepositoryOperationService
+    from gitpane.sequencer.mergetool import MergetoolService
+    from gitpane.sequencer.rebase import RebaseService
+    from gitpane.sequencer.replay import ReplayService
+    from gitpane.submodule.submodule_discovery import SubmoduleService
+    from gitpane.tool.difftool import DifftoolService
+    from gitpane.tool.editor import EditorService
+    from gitpane.tool.system_tool import SystemToolService
+    from gitpane.transport.branch_exchange import TransportService
+    from gitpane.transport.clone import CloneService
+    from gitpane.worktree.mutation import MutationService
+    from gitpane.worktree.worktree_service import WorktreeService
+
+
+def holds_running_work(widget: QWidget) -> bool:
+    """Tell whether a window is making Git work right now, so quitting waits for it instead of closing it.
+
+    Operation consoles say so with ``running`` and forms with ``busy``; closing one of them would stop a write halfway
+    (a running console treats a close as Abort) instead of letting it finish. Any other window has neither attribute.
+    """
+    return bool(getattr(widget, "running", False) or getattr(widget, "busy", False))
+
+
+class ShutdownController(QObject):
+    """The end of GitPane and of each repository window: it keeps hold of Quit and of the close of a repository window while Git works, closes the windows of every domain in their order, and leaves the event loop once everything has drained."""
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, staging_session_registry_controller: StagingSessionRegistry, window_activation_controller: WindowActivationFilter, reference_read_controller: ReferenceReadController,
+                 refresh_controller: RefreshController, history_read_controller: HistoryReadController, account_controller: AccountController, emoji_window_controller: EmojiWindowController,
+                 transport_controller: TransportController, reference_form_controller: ReferenceFormController, replay_controller: ReplayController, rebase_controller: RebaseController, stash_controller: StashController,
+                 conflict_controller: ConflictController, close_readiness_controller: CloseReadiness, navigation_controller: NavigationController, application: QApplication, leave_event_loop: Callable[[], None],
+                 repository: GitRepository, difftool: DifftoolService, worktree_service: WorktreeService, editor: EditorService, repository_operation: RepositoryOperationService, rebase: RebaseService, replay: ReplayService,
+                 mutation: MutationService, authentication: AuthenticationService, ssh: SshService, transport: TransportService, clone: CloneService, mergetool: MergetoolService, system_tool: SystemToolService,
+                 submodule: SubmoduleService, parent: QObject | None = None) -> None:
+        """Receive the services and the lower controllers whose work and windows a close waits for; the wiring builds it last and installs it on the application before the placement filter."""
+        super().__init__(parent)
+        self.session_registry_controller = session_registry_controller
+        self.staging_session_registry_controller = staging_session_registry_controller
+        self.window_activation_controller = window_activation_controller
+        self.reference_read_controller = reference_read_controller
+        self.refresh_controller = refresh_controller
+        self.history_read_controller = history_read_controller
+        self.account_controller = account_controller
+        self.emoji_window_controller = emoji_window_controller
+        self.transport_controller = transport_controller
+        self.reference_form_controller = reference_form_controller
+        self.replay_controller = replay_controller
+        self.rebase_controller = rebase_controller
+        self.stash_controller = stash_controller
+        self.conflict_controller = conflict_controller
+        self.close_readiness_controller = close_readiness_controller
+        self.navigation_controller = navigation_controller
+        self.application = application
+        self.leave_event_loop = leave_event_loop
+        self.repository = repository
+        self.difftool = difftool
+        self.worktree_service = worktree_service
+        self.editor = editor
+        self.repository_operation = repository_operation
+        self.rebase = rebase
+        self.replay = replay
+        self.mutation = mutation
+        self.authentication = authentication
+        self.ssh = ssh
+        self.transport = transport
+        self.clone = clone
+        self.mergetool = mergetool
+        self.system_tool = system_tool
+        self.submodule = submodule
+        self.application_quit_requested = False
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """Keep hold of the Quit of the application and of the Close of a repository window while Git work still runs.
+
+        Quit becomes a shutdown request that waits for every write and process; the Close of a repository window waits the
+        same way when its repository is still busy.
+        """
+        if watched is self.application and event.type() == QEvent.Type.Quit and not self.session_registry_controller.shutdown_requested:
+            self.request_shutdown()
+            event.ignore()
+            return True
+        if event.type() == QEvent.Type.Close:
+            for session_id, window in tuple(self.session_registry_controller.window_by_session.items()):
+                if watched is window and self.close_readiness_controller.defer_repository_close(session_id):
+                    event.ignore()
+                    return True
+        return super().eventFilter(watched, event)
+
+    def request_shutdown(self) -> None:
+        """Keep application ownership until all writes, descendants and file work finish."""
+        if self.session_registry_controller.shutdown_requested:
+            return
+        self._reject_idle_modal_windows()
+        self.session_registry_controller.quit_pending = True
+        if not self.close_readiness_controller.close_ready():
+            self.close_readiness_controller.show_close_wait()
+            self.close_readiness_controller.close_timer.start()
+            return
+        self.session_registry_controller.quit_pending = False
+        self.session_registry_controller.shutdown_requested = True
+        self.close_readiness_controller.close_timer.stop()
+        self.rebase.close()
+        self.replay.close()
+        self.editor.close()
+        # A window that refuses to close keeps Qt from quitting, so Settings closes here without asking about unsaved changes.
+        if self.session_registry_controller.setting_dialog is not None and isValid(self.session_registry_controller.setting_dialog):
+            self.session_registry_controller.setting_dialog.discard_and_close()
+        # A window modal for the whole application left open would keep the other windows from closing.
+        if self.account_controller.credential_manager_dialog is not None and isValid(self.account_controller.credential_manager_dialog):
+            self.account_controller.credential_manager_dialog.close()
+        # The keyboard belongs to no repository window, so closing those would leave it open; closing it saves its geometry.
+        if self.emoji_window_controller.emoji_window is not None and isValid(self.emoji_window_controller.emoji_window) and self.emoji_window_controller.emoji_window.isVisible():
+            self.emoji_window_controller.emoji_window.close()
+        for window in tuple(self.session_registry_controller.window_by_session.values()):
+            window.close()
+        self.transport.close()
+        self.clone.close()
+        for run in tuple(self.submodule.run_by_id.values()):
+            self.submodule.cancel(run.operation_id)
+        self.ssh.close()
+        self.repository_operation.close()
+        self.authentication.close()
+        self.difftool.close()
+        self.mergetool.close()
+        self.system_tool.close()
+        for staging in self.staging_session_registry_controller.staging_by_key.values():
+            staging.timer.stop()
+            staging.refresh_queued = False
+            staging.queued_refresh_priority = None
+        self.maybe_quit()
+
+    def _reject_idle_modal_windows(self) -> None:
+        """Answer Cancel in every open modal window that makes no Git work, so a window left open never keeps GitPane from quitting.
+
+        On macOS every modal window of GitPane blocks the whole application, and a question asked with exec() runs its
+        own event loop until answered. A console or form still making Git work is left open: quitting waits for it, and
+        the next retry of the pending quit closes it once it is idle. Settings and the Git Credential Manager window keep
+        their own closing in request_shutdown.
+        """
+        kept_window_set = {self.session_registry_controller.setting_dialog, self.account_controller.credential_manager_dialog}
+        for widget in tuple(QApplication.topLevelWidgets()):
+            if not isinstance(widget, QDialog) or not isValid(widget) or widget in kept_window_set:
+                continue
+            if not widget.isVisible() or widget.windowModality() == Qt.WindowModality.NonModal or holds_running_work(widget):
+                continue
+            widget.reject()
+
+    def resume_pending_close(self) -> None:
+        """Honor original close requests only after owners have published native results."""
+        if self.session_registry_controller.quit_pending:
+            self.request_shutdown()
+            return
+        for session_id in tuple(self.session_registry_controller.close_session_set):
+            if not self.close_readiness_controller.close_ready(session_id):
+                self.close_readiness_controller.show_close_wait(session_id)
+                continue
+            self.session_registry_controller.close_session_set.discard(session_id)
+            window = self.session_registry_controller.window_by_session.get(session_id)
+            if window is not None and isValid(window):
+                window.close()
+        for session_id, (session, repository_dir, kind) in tuple(self.session_registry_controller.navigation_request_by_session.items()):
+            if self.session_registry_controller.session_by_id.get(session_id) is not session:
+                self.session_registry_controller.navigation_request_by_session.pop(session_id, None)
+                continue
+            if not self.close_readiness_controller.navigation_ready(session_id):
+                continue
+            self.session_registry_controller.navigation_request_by_session.pop(session_id, None)
+            # A repository chosen in the switch menu is outside the family, which the submodule path refuses.
+            if kind is NavigationKind.SWITCH:
+                self.navigation_controller.switch_repository(session_id, repository_dir)
+            else:
+                self.navigation_controller.navigate_repository(session_id, repository_dir)
+            # The resumed change checks everything again and may stop before reading anything (folder gone, window
+            # opened meanwhile): its wait message goes with it. A change that waits again or started reading keeps it.
+            if session_id not in self.session_registry_controller.navigation_request_by_session and session_id not in self.navigation_controller.navigation_target_by_session:
+                self.close_readiness_controller.clear_navigation_wait(session_id)
+        for target_id, snapshot in tuple(self.navigation_controller.navigation_resume_by_target.items()):
+            owner_id = self.session_registry_controller.navigation_owner_by_id.get(target_id)
+            if owner_id is not None and not self.close_readiness_controller.navigation_ready(owner_id):
+                continue
+            self.navigation_controller.navigation_resume_by_target.pop(target_id, None)
+            self.navigation_controller.publish_repository(target_id, snapshot)
+        if not self.session_registry_controller.close_session_set and not self.session_registry_controller.navigation_request_by_session and not self.navigation_controller.navigation_resume_by_target:
+            self.close_readiness_controller.close_timer.stop()
+
+    def maybe_quit(self, *arguments: object) -> None:
+        """Exit only after results have been retained and every native child has drained."""
+        if (self.application_quit_requested or not self.session_registry_controller.shutdown_requested
+                or self.repository_operation.active_by_id or self.mutation.active_key_set or self.mutation.configuration_busy or self.authentication.active_by_id
+                or self.editor.active_by_id or self.mergetool.active_by_id or self.mergetool.series_by_id or self.worktree_service.file_task_by_id or self.worktree_service.continuation_by_id):
+            return
+        if not self.repository.runner.closed:
+            self.repository.close()
+        if (not self.application_quit_requested and not self.system_tool.export_by_id and not self.difftool.active_by_id and not self.mergetool.active_by_id and not self.repository.runner.active_by_id
+                and not self.repository.runner.pending_requests and not self.worktree_service.file_task_by_id and not self.worktree_service.continuation_by_id):
+            self.application_quit_requested = True
+            self.leave_event_loop()
+
+    def close_repository(self, session_id: str, *, keep_navigation: bool = False) -> None:
+        """Close one session and preserve all other windows and pending requests."""
+        if not keep_navigation and self.close_readiness_controller.defer_repository_close(session_id):
+            return
+        self.session_registry_controller.navigation_request_by_session.pop(session_id, None)
+        if not keep_navigation:
+            for run in tuple(self.submodule.run_by_id.values()):
+                if run.session_id == session_id:
+                    self.submodule.cancel(run.operation_id)
+            for target_id, owner_id in tuple(self.session_registry_controller.navigation_owner_by_id.items()):
+                if owner_id != session_id:
+                    continue
+                self.session_registry_controller.navigation_owner_by_id.pop(target_id, None)
+                self.navigation_controller.navigation_kind_by_id.pop(target_id, None)
+                self.navigation_controller.navigation_family_by_id.pop(target_id, None)
+                self.navigation_controller.navigation_resume_by_target.pop(target_id, None)
+                run = self.navigation_controller.submodule_run_by_navigation.pop(target_id, None)
+                if run is not None:
+                    run.open_status = OperationStatus.CANCELLED.value
+                self.navigation_controller.navigation_context_by_id.pop(target_id, None)
+                self.navigation_controller.navigation_snapshot_by_id.pop(target_id, None)
+                self.navigation_controller.navigation_commits_by_id.pop(target_id, None)
+                self.navigation_controller.navigation_streamed_history_by_id.pop(target_id, None)
+                self.repository.cancel(target_id)
+                self.repository.context_by_session.pop(target_id, None)
+            self.navigation_controller.navigation_target_by_session.pop(session_id, None)
+            self.refresh_controller.submodule_snapshot_by_session.pop(session_id, None)
+            self.navigation_controller.anchor_by_window.pop(session_id, None)
+        self.mergetool.invalidate_session(session_id)
+        self.refresh_controller.leave_full_refresh_read(session_id)
+        self.replay_controller.replay_refresh_by_session.pop(session_id, None)
+        self.session_registry_controller.replay_pending_resolve_set.discard(session_id)
+        for key, request in tuple(self.replay_controller.replay_auto_continue_by_key.items()):
+            if request.session_id == session_id:
+                self.replay_controller.replay_auto_continue_by_key.pop(key, None)
+        for key, resume_session_id in tuple(self.replay_controller.replay_resume_session_by_key.items()):
+            if resume_session_id == session_id:
+                self.replay_controller.replay_resume_session_by_key.pop(key, None)
+        for dialog_by_session in (self.replay_controller.replay_dialog_by_session, self.replay_controller.replay_prompt_by_session,
+                                  self.rebase_controller.rebase_dialog_by_session, self.rebase_controller.rebase_confirmation_by_session, self.stash_controller.stash_dialog_by_session,
+                                  self.conflict_controller.conflict_dialog_by_session, self.conflict_controller.conflict_confirmation_by_session, self.conflict_controller.conflict_prompt_by_session,
+                                  self.navigation_controller.invalid_repository_prompt_by_session):
+            dialog = dialog_by_session.pop(session_id, None)
+            if dialog is not None and isValid(dialog):
+                dialog.close()
+        recovery_dialog = self.conflict_controller.merge_recovery_dialog_by_session.pop(session_id, None)
+        if recovery_dialog is not None and isValid(recovery_dialog):
+            recovery_dialog.close()
+        for operation_id, run in tuple(self.transport.run_by_id.items()):
+            if run.request.operation.session_id == session_id:
+                self.transport.cancel(operation_id)
+                if operation_id in self.transport.outcome_by_id:
+                    run.trace.close()
+        checkout_dialog = self.reference_form_controller.checkout_dialog_by_session.pop(session_id, None)
+        checkout_revision_dialog = self.reference_form_controller.checkout_revision_dialog_by_session.pop(session_id, None)
+        branch_dialog = self.reference_form_controller.branch_dialog_by_session.pop(session_id, None)
+        delete_dialog = self.reference_form_controller.delete_dialog_by_session.pop(session_id, None)
+        if delete_dialog is not None and isValid(delete_dialog):
+            delete_dialog.reject()
+        local_branch_delete_dialog = self.reference_form_controller.local_branch_delete_dialog_by_session.pop(session_id, None)
+        if local_branch_delete_dialog is not None and isValid(local_branch_delete_dialog):
+            local_branch_delete_dialog.reject()
+        remote_dialog = self.transport_controller.remote_dialog_by_session.pop(session_id, None)
+        push_dialog = self.transport_controller.push_dialog_by_session.pop(session_id, None)
+        if push_dialog is not None and isValid(push_dialog):
+            push_dialog.reject()
+        push_rejection_prompt = self.transport_controller.push_rejection_prompt_by_session.pop(session_id, None)
+        if push_rejection_prompt is not None and isValid(push_rejection_prompt):
+            push_rejection_prompt.reject()
+        # A question parented on the Push window outlives its rejection, since Qt hides no child window then.
+        push_tracking_question = self.transport_controller.push_tracking_question_by_session.pop(session_id, None)
+        if push_tracking_question is not None and isValid(push_tracking_question):
+            push_tracking_question.reject()
+        if remote_dialog is not None and isValid(remote_dialog):
+            remote_dialog.reject()
+        tag_dialog = self.reference_form_controller.tag_dialog_by_session.pop(session_id, None)
+        if tag_dialog is not None and isValid(tag_dialog):
+            tag_dialog.reject()
+        reset_dialog = self.reference_form_controller.reset_dialog_by_session.pop(session_id, None)
+        # A form may still wait for its opening check and never have been shown, and close() then emits no finished.
+        for form in (reset_dialog, branch_dialog, checkout_dialog, checkout_revision_dialog):
+            if form is not None and isValid(form):
+                form.done(QDialog.DialogCode.Rejected)
+        self.reference_read_controller.reference_snapshot_by_session.pop(session_id, None)
+        self.reference_read_controller.reference_read_generation_by_session.pop(session_id, None)
+        self.reference_read_controller.logged_stash_cause_by_session.pop(session_id, None)
+        self.reference_read_controller.reference_continuation_by_session.pop(session_id, None)
+        self.refresh_controller.checkout_refresh_session_set.discard(session_id)
+        # The window id outlives its session when the window moves to another repository: what the previous repository
+        # still had to do (scroll to the top, offer to resolve its conflicts, read its remotes for Fetch) must never
+        # happen in the repository the same window shows next.
+        self.history_read_controller.history_top_session_set.discard(session_id)
+        self.session_registry_controller.conflict_pending_session_set.discard(session_id)
+        self.transport_controller.fetch_read_by_session.pop(session_id, None)
+        self.rebase_controller.rebase_final_oid_by_session.pop(session_id, None)
+        self.rebase_controller.rebase_end_notice_session_set.discard(session_id)
+        for identity, owner_id in tuple(self.session_registry_controller.export_owner_by_identity.items()):
+            if owner_id == session_id:
+                self.session_registry_controller.export_owner_by_identity.pop(identity, None)
+                self.system_tool.cancel_export(identity)
+                export_id = identity.request_identity.session_id
+                self.repository.cancel(export_id)
+                self.repository.context_by_session.pop(export_id, None)
+        self.session_registry_controller.window_by_session.pop(session_id, None)
+        self.session_registry_controller.identity_by_session.pop(session_id, None)
+        session = self.session_registry_controller.session_by_id.pop(session_id, None)
+        if session is not None:
+            session.refresh_queued = None
+            session.close()
+        # A worktree that has just lost its last window must stop refreshing itself, and no activation event says so.
+        self.window_activation_controller.schedule_activation_update()

gitpane/controller/staging_controller.py

@@ -0,0 +1,199 @@
+"""Coordinate the Prepare changes window of each worktree with the rest of GitPane."""
+
+from __future__ import annotations
+
+import uuid
+from typing import TYPE_CHECKING
+
+from shiboken6 import isValid
+
+from gitpane.history.file_history import WindowCapability
+from gitpane.history.repository_value import RequestIdentity
+from gitpane.operation.diagnostic import Diagnostic
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.system.path_identity import canonical_path
+from gitpane.tool.system_tool import text_editor_unavailable_reason
+from gitpane.transport.remote_config import GitConfigScope
+from gitpane.ui.repository.repository_window import COMMIT_NOTICE_KIND
+from gitpane.worktree.worktree_snapshot import WorktreeKey
+
+if TYPE_CHECKING:
+    from gitpane.commit.commit_write import CommitOutcome
+    from gitpane.controller.emoji_window_controller import EmojiWindowController
+    from gitpane.controller.file_action_controller import FileActionController
+    from gitpane.controller.history_read_controller import HistoryReadController
+    from gitpane.controller.opening_controller import OpeningController
+    from gitpane.controller.operation_policy import OperationPolicy
+    from gitpane.controller.refresh_controller import RefreshController
+    from gitpane.controller.session_registry import SessionRegistry
+    from gitpane.controller.staging_session_registry import StagingSessionRegistry
+    from gitpane.controller.window_activation import WindowActivationFilter
+    from gitpane.controller.worktree_state_controller import WorktreeStateController
+    from gitpane.history.file_history import FileHistoryAnchor
+    from gitpane.history.repository import GitRepository
+    from gitpane.history.repository_value import RepositoryContext
+    from gitpane.operation.diagnostic import DiagnosticLog
+    from gitpane.preference.preference_store import PreferenceStore
+    from gitpane.ui.repository.repository_window import RepositoryWindow
+    from gitpane.ui.staging.staging_window import StagingWindow
+    from gitpane.worktree.mutation import MutationOutcome
+    from gitpane.worktree.staging import StagingSession
+
+
+class StagingController:
+    """Prepare changes of every worktree: its opening from a repository window, its window bound to the shared preferences, and the reads that its commits, its ignore changes and its index writes ask from the other worktrees and windows."""
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, operation_policy_controller: OperationPolicy, staging_session_registry_controller: StagingSessionRegistry, window_activation_controller: WindowActivationFilter,
+                 refresh_controller: RefreshController, worktree_state_controller: WorktreeStateController, history_read_controller: HistoryReadController, opening_controller: OpeningController, emoji_window_controller: EmojiWindowController,
+                 file_action_controller: FileActionController, preference: PreferenceStore, repository: GitRepository, diagnostic_log: DiagnosticLog | None) -> None:
+        """Receive the services and the lower controllers Prepare changes works with; the wiring builds it after the file action controller, and the repository windows and the preparation sessions reach it through the wiring."""
+        self.session_registry_controller = session_registry_controller
+        self.operation_policy_controller = operation_policy_controller
+        self.staging_session_registry_controller = staging_session_registry_controller
+        self.window_activation_controller = window_activation_controller
+        self.refresh_controller = refresh_controller
+        self.worktree_state_controller = worktree_state_controller
+        self.history_read_controller = history_read_controller
+        self.opening_controller = opening_controller
+        self.emoji_window_controller = emoji_window_controller
+        self.file_action_controller = file_action_controller
+        self.preference = preference
+        self.repository = repository
+        self.diagnostic_log = diagnostic_log
+
+    def open_staging(self, session_id: str) -> StagingWindow | None:
+        """Open shared preparation only from a live management window with a working tree."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return None
+        session = self.session_registry_controller.session_by_id[session_id]
+        if session.repository_context.is_bare or session.repository_context.worktree_dir is None:
+            return None
+        staging = self.staging_session_registry_controller.staging_session(session.repository_context)
+        staging.commit_push_session_id = session_id
+        return staging.open()
+
+    def log_mutation_result(self, outcome: MutationOutcome) -> None:
+        """Include prepared write failures in the optional application diagnostic file."""
+        if outcome.diagnostic is not None and self.diagnostic_log is not None:
+            self.diagnostic_log.write(outcome.diagnostic)
+        staging = self.staging_session_registry_controller.staging_by_key.get(outcome.key)
+        if staging is not None:
+            self.refresh_submodule_family(staging.context)
+
+    def refresh_submodule_family(self, context: RepositoryContext) -> None:
+        """Refresh declared relatives across separate Git directories after a local write."""
+        directory = canonical_path(context.repository_dir)
+        related_dir_set: set[str] = set()
+        for session_id, family in tuple(self.refresh_controller.submodule_snapshot_by_session.items()):
+            family_dir_set = {canonical_path(entry.repository_dir) for entry in family.entries if entry.repository_dir}
+            if directory not in family_dir_set:
+                continue
+            session = self.session_registry_controller.session_by_id.get(session_id)
+            if session is None or session.is_closed or canonical_path(session.repository_context.repository_dir) not in family_dir_set:
+                continue
+            related_dir_set.update(family_dir_set)
+            self.refresh_controller.read_submodules(session_id)
+        for staging in tuple(self.staging_session_registry_controller.staging_by_key.values()):
+            if canonical_path(staging.context.repository_dir) in related_dir_set and WorktreeKey.from_context(staging.context) != WorktreeKey.from_context(context):
+                staging.refresh()
+
+    def git_setting_changed(self, result: object) -> None:
+        """Refresh every affected worktree after conversion changes shared across windows."""
+        context, results = result
+        changed_scope_set: set[GitConfigScope] = set()
+        for outcome in results:
+            if outcome.saved and outcome.change.key == "core.autocrlf":
+                changed_scope_set.add(outcome.change.scope)
+        if not changed_scope_set:
+            return
+        for staging in self.staging_session_registry_controller.staging_by_key.values():
+            if GitConfigScope.GLOBAL in changed_scope_set or (context is not None and canonical_path(staging.context.common_git_dir) == canonical_path(context.common_git_dir)):
+                staging.invalidate_conversion()
+
+    def staging_window_opened(self, window: StagingWindow) -> None:
+        """Bind a new preparation view to shared persisted proportions and its current screen, and open it over the repository window that asked for it."""
+        window.installEventFilter(self.window_activation_controller)
+        window.closed.connect(self.window_activation_controller.schedule_activation_update)
+        for staging in self.staging_session_registry_controller.staging_by_key.values():
+            if staging.window is not window:
+                continue
+            if staging.commit_push_session_id is not None:
+                window.placement_anchor = self.session_registry_controller.window_by_session.get(staging.commit_push_session_id)
+            context = staging.context
+            window.text_editor_reason = lambda entry, context=context: text_editor_unavailable_reason(context, entry.path, self.file_action_controller.text_editor_command(context))
+            if context.repository_dir not in self.file_action_controller.git_editor_setting_by_repository_dir:
+                self.file_action_controller.read_git_editor_setting(context)
+        window.apply_preference(self.preference.value_by_key)
+        window.preference_requested.connect(lambda values: self._save_staging_preference(window, values))
+        self.emoji_window_controller.report_emoji_font()
+
+    def _save_staging_preference(self, window: StagingWindow, value_by_key: dict[str, object]) -> None:
+        """Restore accepted pane weights if storage refuses a change, preserving the message."""
+        if not isValid(window):
+            return
+        try:
+            self.preference.update(value_by_key)
+        except (OSError, ValueError, TypeError) as error:
+            window.apply_preference(self.preference.value_by_key)
+            diagnostic = Diagnostic("Save staging preferences", window.context.repository_dir, "", [], str(error)).prepare()
+            window.status_label.setText(diagnostic.cause)
+            if self.diagnostic_log is not None:
+                self.diagnostic_log.write(diagnostic)
+
+    def open_staging_history(self, staging: StagingSession, anchor: FileHistoryAnchor) -> RepositoryWindow | None:
+        """Open the existing limited history view for a locally resolved committed blob."""
+        if self.staging_session_registry_controller.staging_by_key.get(staging.key) is not staging or staging.window is None or staging.window.close_requested or staging.busy:
+            return None
+        if staging.snapshot is None or not staging.snapshot.fresh or staging.snapshot.head_oid != anchor.commit_oid:
+            return None
+        identity = RequestIdentity(uuid.uuid4().hex, 1)
+        self.session_registry_controller.identity_by_session[identity.session_id] = identity
+        self.repository.context_by_session[identity.session_id] = staging.context
+        self.opening_controller.opened(identity, staging.context, None, anchor, staging.window)
+        return self.session_registry_controller.window_by_session[identity.session_id]
+
+    def ignore_changed(self, context: RepositoryContext, *, refreshed_key: WorktreeKey | None = None) -> None:
+        """Reread every worktree sharing the repository's exclude file, except the one named as already reading.
+
+        That key names the session whose staging asked for the read itself; it is not derived from the context, which
+        can belong to a linked worktree that has not read yet. Without a key, every sharing worktree reads.
+        """
+        common_dir = canonical_path(context.common_git_dir)
+        for staging in self.staging_session_registry_controller.staging_by_key.values():
+            if staging.key == refreshed_key:
+                continue
+            if canonical_path(staging.context.common_git_dir) == common_dir:
+                staging.refresh()
+
+    def commit_finished(self, staging: StagingSession, outcome: CommitOutcome) -> None:
+        """Refresh shared history after native writes without sharing linked-worktree drafts.
+
+        The committing worktree shows the complete read the commit made after writing; its preparation session reads
+        again on its own when that read cannot serve. Every other worktree of the repository reads once for all its windows.
+
+        A successful Commit or Amend puts its commit at the top of the graph, so every repository window of the committing
+        worktree goes back to its top once that read is shown. Other worktrees, whose branch did not move, and a refused
+        or failed commit leave the graph where it was.
+
+        A successful commit around which a hook or another program changed files writes those details to the --log
+        file. The neutral notice of the commit, or its absence, replaces the previous commit's notice in every
+        repository window of the worktree, next to any other notice they show.
+        """
+        self.log_mutation_result(outcome)
+        if outcome.log_diagnostic is not None and self.diagnostic_log is not None:
+            self.diagnostic_log.write(outcome.log_diagnostic)
+        for _session_id, window in self.worktree_state_controller.managed_windows_of_worktree(staging.key):
+            window.show_status_notice(staging.key, COMMIT_NOTICE_KIND, outcome.notice)
+        common_dir = canonical_path(staging.context.common_git_dir)
+        if outcome.status == OperationStatus.SUCCESS:
+            for session_id, session in self.session_registry_controller.session_by_id.items():
+                if not session.is_closed and session.mode == "repository" and WorktreeKey.from_context(session.repository_context) == staging.key:
+                    self.history_read_controller.history_top_session_set.add(session_id)
+        shared_by_key = {staging.key: self.refresh_controller.begin_full_refresh_read(staging.key, published_staging=staging)}
+        for session_id, session in tuple(self.session_registry_controller.session_by_id.items()):
+            if not session.is_closed and canonical_path(session.repository_context.common_git_dir) == common_dir:
+                self.refresh_controller.refresh(session_id, full_refresh_read=self.refresh_controller.full_refresh_read_for(session, shared_by_key))
+        refreshed_key_set = self.refresh_controller.observe_full_refresh_pauses(shared_by_key)
+        for other in self.staging_session_registry_controller.staging_by_key.values():
+            if other is not staging and other.key not in refreshed_key_set and canonical_path(other.context.common_git_dir) == common_dir:
+                other.refresh()

gitpane/controller/staging_session_registry.py

@@ -0,0 +1,47 @@
+"""Reuse one preparation session per worktree across the windows that show it."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject
+
+from gitpane.worktree.staging import StagingSession
+from gitpane.worktree.worktree_snapshot import WorktreeKey
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtWidgets import QWidget
+
+    from gitpane.history.repository import GitRepository
+    from gitpane.history.repository_value import RepositoryContext
+    from gitpane.sequencer.rebase import RebaseService
+    from gitpane.worktree.mutation import MutationService
+    from gitpane.worktree.worktree_service import WorktreeService
+
+
+class StagingSessionRegistry(QObject):
+    """The preparation session of each worktree, created once, owned here and shared by every window of that worktree."""
+
+    def __init__(self, *, repository: GitRepository, worktree_service: WorktreeService, rebase: RebaseService, mutation: MutationService,
+                 wire_staging_session: Callable[[WorktreeKey, StagingSession], None], window_factory: Callable[[RepositoryContext], QWidget], parent: QObject | None = None) -> None:
+        """Receive the services a session works with, the function of the wiring that connects a new session to the controllers above this registry, and the
+        factory every session builds its Prepare changes window with."""
+        super().__init__(parent)
+        self.repository = repository
+        self.worktree_service = worktree_service
+        self.rebase = rebase
+        self.mutation = mutation
+        self.wire_staging_session = wire_staging_session
+        self.window_factory = window_factory
+        self.staging_by_key: dict[WorktreeKey, StagingSession] = {}
+
+    def staging_session(self, context: RepositoryContext) -> StagingSession:
+        """Reuse one index owner and in-memory draft across repository windows."""
+        key = WorktreeKey.from_context(context)
+        if key not in self.staging_by_key:
+            staging = StagingSession(context, self.repository.git_filename, self.worktree_service, self.mutation, self, rebase_service=self.rebase, window_factory=self.window_factory)
+            self.staging_by_key[key] = staging
+            self.wire_staging_session(key, staging)
+        return self.staging_by_key[key]