gitpane 1.0.0__py3-none-any.whl

gitpane/controller/rebase_controller.py

@@ -0,0 +1,797 @@
+"""Run an interactive rebase from a repository window, through its pauses."""
+
+from __future__ import annotations
+
+import time
+import uuid
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, QSignalBlocker, Signal
+from shiboken6 import isValid
+
+from gitpane.config import LOCAL_PREFIX, REBASE_REFRESH_INTERVAL_MS, SHORT_OID_LENGTH, ConsoleOperation, ProcessPriority, SharedText
+from gitpane.controller.refresh_controller import RebaseRefreshPublication
+from gitpane.history.file_history import WindowCapability
+from gitpane.history.repository_value import GIT_CONFLICT_RETURN_CODE
+from gitpane.operation.console_line import COMPLETED_STATUS_SET, END_TEXT_TEMPLATE, REBASE_LABEL, REPOSITORY_HEADER_LABEL, ConsoleHeader, operation_end_text
+from gitpane.operation.diagnostic import Diagnostic
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.operation.operation_trace import OperationTrace, publish_after_trace
+from gitpane.operation.repository_operation import REBASE_PAUSE_OBSERVATION, OperationAction, OperationIntent, OperationOutcome, WriteScope
+from gitpane.preference.preference_store import REBASE_PROMPT_PREFERENCE_KEY
+from gitpane.sequencer.conflict import conflict_path_label
+from gitpane.sequencer.rebase import RebaseIntent, RebaseOutcome
+from gitpane.sequencer.rebase_state import REBASE_ENDED_OUTSIDE_MESSAGE, REBASE_STOPPED_STATE_SET, RebaseSnapshot, native_observations_unchanged, read_rebase_commits, state_dirs_from_pause_paths
+from gitpane.ui.console.operation_dialog import OperationDialog
+from gitpane.ui.sequencer.rebase_dialog import RebaseConfirmation, RebaseDialog
+from gitpane.ui.sequencer.rebase_editor_window import EditorValidation
+from gitpane.ui.window_control.dialog_modality import open_window_modal
+from gitpane.worktree.command_sequence import FileTask, GitCommandError
+from gitpane.worktree.worktree_snapshot import WorktreeKey
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator
+
+    from gitpane.controller.console_registry import ConsoleRegistry
+    from gitpane.controller.history_read_controller import HistoryReadController
+    from gitpane.controller.operation_policy import OperationPolicy
+    from gitpane.controller.rebase_editor_controller import RebaseEditorController
+    from gitpane.controller.reference_read_controller import ReferenceReadController
+    from gitpane.controller.refresh_controller import FullRefreshRead, RefreshController, ReplayRefreshPublication
+    from gitpane.controller.replay_controller import ReplayController
+    from gitpane.controller.session_registry import SessionRegistry
+    from gitpane.controller.staging_controller import StagingController
+    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.repository import GitRepository
+    from gitpane.history.repository_value import RepositoryContext
+    from gitpane.operation.diagnostic import DiagnosticLog
+    from gitpane.operation.repository_operation import RepositoryOperationService
+    from gitpane.preference.preference_store import PreferenceStore
+    from gitpane.reference.reference_snapshot import ReferenceSnapshot
+    from gitpane.sequencer.mergetool import MergetoolService
+    from gitpane.sequencer.rebase import RebaseService
+    from gitpane.sequencer.rebase_state import RebaseCommit, RebaseStep
+    from gitpane.tool.editor import EditorRequest
+    from gitpane.worktree.worktree_service import WorktreeService
+
+# Console line of a rebase that stopped on a conflict, followed by the conflicting files separated by ", ".
+REBASE_CONFLICT_PAUSE_PREFIX = "Rebase paused: new conflict in "
+
+
+def outcome_instruction_error(outcome: OperationOutcome) -> str:
+    """Answer the error lines of the instructions Git refused and kept for a correction, or an empty text for any other result.
+
+    Only a rebase command reads them; a refusal before any command, or an Abort, never carries them.
+    """
+    return outcome.instruction_error if isinstance(outcome, RebaseOutcome) else ""
+
+
+def rebase_end_notice(snapshot: ReferenceSnapshot | None) -> str:
+    """Say that a rebase ended outside GitPane and where HEAD is now, as the references just read tell it."""
+    if snapshot is None or snapshot.head_oid is None:
+        return REBASE_ENDED_OUTSIDE_MESSAGE
+    short_oid = snapshot.head_oid[:SHORT_OID_LENGTH]
+    if snapshot.head_ref is not None and snapshot.head_ref.startswith(LOCAL_PREFIX):
+        return f"{REBASE_ENDED_OUTSIDE_MESSAGE} HEAD is on {snapshot.head_ref.removeprefix(LOCAL_PREFIX)} at {short_oid}."
+    return f"{REBASE_ENDED_OUTSIDE_MESSAGE} HEAD is detached at {short_oid}."
+
+
+def rebase_conflict_pause_text(outcome: OperationOutcome, state: RebaseSnapshot | None) -> str | None:
+    """Return the line naming the files of the new conflict a rebase command stopped on, or None when it did not stop on one.
+
+    Editing the instructions during a conflict also ends paused, but Git did not stop on a new conflict then: only a
+    command Git ended with its conflict exit status is named that way.
+    """
+    stopped_on_conflict = any(step.return_code == GIT_CONFLICT_RETURN_CODE for step in outcome.steps)
+    if outcome.status != OperationStatus.PAUSED or not stopped_on_conflict or state is None or state.state != "conflict" or not state.conflict_paths:
+        return None
+    labels = []
+    for path in state.conflict_paths:
+        labels.append(conflict_path_label(path))
+    return REBASE_CONFLICT_PAUSE_PREFIX + ", ".join(labels)
+
+
+def rebase_result_line(outcome: OperationOutcome, state: RebaseSnapshot | None) -> str:
+    """Write the console line ending a rebase command, such as ``Rebase: done``; a stop on a new conflict names its files instead."""
+    pause_text = rebase_conflict_pause_text(outcome, state)
+    if pause_text is not None:
+        return pause_text
+    return operation_end_text(REBASE_LABEL, outcome.status)
+
+
+def rebase_result_log_text(outcome: OperationOutcome, state: RebaseSnapshot | None) -> str:
+    """Write the ``--log`` line ending a rebase command: the bare status, as the log always kept it, or the same conflict line as the console."""
+    pause_text = rebase_conflict_pause_text(outcome, state)
+    if pause_text is not None:
+        return pause_text
+    return END_TEXT_TEMPLATE.format(label=REBASE_LABEL, word=outcome.status.value)
+
+
+class RebaseController(QObject):
+    """The interactive rebase of every repository window: confirmation, launch, console, Rebase window with Continue, Amend and Abort, and the observation of a pause or of a rebase ended outside GitPane."""
+
+    # Asks to show, in place of the rebase progress, that a repository window waits for its work to end before it
+    # closes or GitPane quits: the session id of that window.
+    close_wait_requested = Signal(str)
+    # Tells the rebase state a repository window has just shown, for the conflict window of that window: the session id
+    # and the RebaseSnapshot.
+    rebase_state_shown = Signal(str, object)
+    # Asks to open the conflict list of a repository window from its Rebase window: the session id.
+    conflict_list_requested = Signal(str)
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, operation_policy_controller: OperationPolicy, staging_session_registry_controller: StagingSessionRegistry, window_activation_controller: WindowActivationFilter,
+                 console_registry_controller: ConsoleRegistry, reference_read_controller: ReferenceReadController, refresh_controller: RefreshController, worktree_state_controller: WorktreeStateController,
+                 history_read_controller: HistoryReadController, staging_controller: StagingController, replay_controller: ReplayController, rebase_editor_controller: RebaseEditorController, preference: PreferenceStore,
+                 repository: GitRepository, worktree_service: WorktreeService, repository_operation: RepositoryOperationService, rebase: RebaseService, mergetool: MergetoolService, diagnostic_log: DiagnosticLog | None,
+                 parent: QObject | None = None) -> None:
+        """Receive the services and the lower controllers a rebase works with; the wiring builds it after the replay controller, and the conflict, the close readiness and the repository windows reach it through the wiring.
+
+        Every edit Git asks for during one of its commands is served by the rebase editor controller, told before each
+        command which repository window parents the editor windows and whether their button continues or saves.
+        """
+        super().__init__(parent)
+        self.session_registry_controller = session_registry_controller
+        self.operation_policy_controller = operation_policy_controller
+        self.staging_session_registry_controller = staging_session_registry_controller
+        self.window_activation_controller = window_activation_controller
+        self.console_registry_controller = console_registry_controller
+        self.reference_read_controller = reference_read_controller
+        self.refresh_controller = refresh_controller
+        self.worktree_state_controller = worktree_state_controller
+        self.history_read_controller = history_read_controller
+        self.staging_controller = staging_controller
+        self.replay_controller = replay_controller
+        self.rebase_editor_controller = rebase_editor_controller
+        self.preference = preference
+        self.repository = repository
+        self.worktree_service = worktree_service
+        self.repository_operation = repository_operation
+        self.rebase = rebase
+        self.mergetool = mergetool
+        self.diagnostic_log = diagnostic_log
+        self.rebase_dialog_by_session: dict[str, RebaseDialog] = {}
+        self.rebase_confirmation_by_session: dict[str, RebaseConfirmation] = {}
+        self.rebase_intent_by_id: dict[str, RebaseIntent] = {}
+        self.rebase_final_oid_by_session: dict[str, str] = {}
+        # Windows owing the line that tells a rebase ended outside GitPane: a refresh of theirs is running, and the line
+        # is written once its history is published, so it names the HEAD that refresh read and is not hidden by it.
+        self.rebase_end_notice_session_set: set[str] = set()
+        self.rebase_observed_at_by_key: dict[WorktreeKey, float] = {}
+        # The validating button each command's editor windows were given, so instructions Git refuses reopen with the same one.
+        self.validation_by_operation_id: dict[str, EditorValidation] = {}
+        # The list edits reopened after Git refused a command that was to continue the rebase: once Git accepts the
+        # corrected list, the rebase continues.
+        self.continue_after_correction_operation_id_set: set[str] = set()
+
+    def start_rebase(self, session_id: str, target_oid: str, snapshot: ReferenceSnapshot | None) -> RebaseConfirmation | None:
+        """Prepare a graph target against the loaded HEAD before one confirmation."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE) or snapshot is None:
+            return None
+        session = self.session_registry_controller.session_by_id[session_id]
+        window = self.session_registry_controller.window_by_session[session_id]
+        if session.repository_context.is_bare:
+            return None
+        existing = self.rebase_confirmation_by_session.get(session_id)
+        if existing is not None and isValid(existing) and existing.isVisible():
+            existing.raise_()
+            return existing
+        operation = OperationIntent.capture(uuid.uuid4().hex, session.repository_context, self.repository.git_filename,
+                                            session_id=session_id, generation=self.session_registry_controller.generation_by_session[session_id], operation=REBASE_LABEL, action=OperationAction.REBASE_START,
+                                            scope=WriteScope.capture(session.repository_context, (snapshot.head_ref,) if snapshot.head_ref else ()))
+        intent = RebaseIntent(operation, target_oid, snapshot.head_oid, snapshot.head_ref)
+
+        def current() -> bool:
+            """Keep a pending launch bound to the original repository session."""
+            return (self.operation_policy_controller.operation_allowed(operation) and self.repository.git_filename == operation.git_filename and snapshot.context == operation.context
+                    and snapshot.git_filename == operation.git_filename and snapshot.generation == operation.generation)
+
+        def prepared(value: RebaseIntent | None, error: Exception | None) -> None:
+            """Only a fully resolved source and target may reach confirmation."""
+            if session.is_closed or self.session_registry_controller.session_by_id.get(session_id) is not session:
+                return
+            if error is not None or value is None or not current():
+                self._rebase_refused(intent, error or ValueError("The rebase capture changed. Refresh before rebasing."))
+                return
+            source = (value.source_symbolic_ref or "Detached HEAD") + " (" + value.source_head_oid + ")"
+            previous = self.rebase_confirmation_by_session.get(session_id)
+            if previous is not None and isValid(previous):
+                # A confirmation answered earlier stays parented to the window until replaced; the newest request is the only one that may still launch.
+                previous.close()
+                previous.deleteLater()
+            dialog = RebaseConfirmation(source, value.target_oid, window, preference=self.preference)
+            self.rebase_confirmation_by_session[session_id] = dialog
+            dialog.submit_requested.connect(lambda: self._confirm_rebase(value, current, dialog))
+            if self.preference.read(REBASE_PROMPT_PREFERENCE_KEY):
+                dialog.dont_show_again.setChecked(True)
+                self._confirm_rebase(value, current, dialog)
+            else:
+                open_window_modal(dialog)
+
+        self.rebase.prepare(intent, is_current=current, callback=prepared)
+        return None
+
+    def _confirm_rebase(self, intent: RebaseIntent, current: Callable[[], bool], dialog: RebaseConfirmation) -> None:
+        """Launch the intention prepared before confirmation; the edits Git asks for open in GitPane, so no editor choice is needed.
+
+        The form is not prepared again: the start validates the target, HEAD and the absence of a native rebase inside
+        its reservation, and checks references once more at launch, so a change made since the confirmation opened is
+        refused there.
+        """
+        if dialog.submitting or not isValid(dialog) or dialog.cancelled:
+            return
+        dialog.submitting = True
+        dialog.confirm_button.setEnabled(False)
+        if not current():
+            self._rebase_refused(intent, ValueError("The rebase capture changed. Refresh before rebasing."))
+            dialog.reject()
+            return
+        dialog.accept()
+        self._launch_rebase(intent, current)
+
+    def _create_rebase_output(self, intent: RebaseIntent) -> OperationDialog:
+        """Keep rebase diagnostics visible while leaving the main window's deferred Close action accessible."""
+        operation = intent.operation
+        trace = OperationTrace(operation.operation_id, self.repository.runner, self.diagnostic_log, header=ConsoleHeader(REPOSITORY_HEADER_LABEL, operation.context.repository_dir))
+        output = OperationDialog(trace, REBASE_LABEL, self.session_registry_controller.window_by_session[operation.session_id], preference=self.preference, console_operation=ConsoleOperation.REBASE)
+        output.finished.connect(trace.close)
+        output.finished.connect(lambda: self._dispose_rebase_output(operation.operation_id))
+        self.rebase_intent_by_id[operation.operation_id] = intent
+        self.console_registry_controller.rebase_output_by_id[operation.operation_id] = output
+        output.show()
+        return output
+
+    def _dispose_rebase_output(self, operation_id: str) -> None:
+        """Release a dismissed diagnostic window with its trace instead of retaining one per command for the whole session."""
+        output = self.console_registry_controller.rebase_output_by_id.pop(operation_id, None)
+        if output is not None and isValid(output):
+            output.deleteLater()
+
+    def _rebase_refused(self, intent: RebaseIntent, error: Exception) -> None:
+        """Expose a preflight cause without creating an editor or repairing native state."""
+        operation = intent.operation
+        if not self.operation_policy_controller.allows(operation.session_id, WindowCapability.MANAGE):
+            return
+        diagnostic = error.diagnostic if isinstance(error, GitCommandError) else Diagnostic(REBASE_LABEL, operation.context.repository_dir, operation.git_filename, [], str(error)).prepare()
+        self._create_rebase_output(intent)
+        self.rebase_finished(OperationOutcome(operation.operation_id, OperationStatus.REFUSED, diagnostic=diagnostic))
+
+    def _launch_rebase(self, intent: RebaseIntent, current: Callable[[], bool]) -> None:
+        """Create shared diagnostics and run one captured command whose edits open in GitPane, each with Continue."""
+        operation = intent.operation
+        if not current():
+            self._rebase_refused(intent, ValueError("The rebase capture changed. Refresh before rebasing."))
+            return
+        output = self._create_rebase_output(intent)
+        state = RebaseSnapshot(operation.key, operation.generation, head_oid=intent.source_head_oid, state="starting")
+        dialog = self._create_rebase_dialog(operation.session_id, state)
+        dialog.show()
+        self.rebase_progress(operation.operation_id, SharedText.REBASE_APPLYING_COMMITS.value)
+        output.set_running()
+        self._expect_edits(operation, EditorValidation.CONTINUE)
+        self.rebase.start(intent, is_current=current)
+
+    def _expect_edits(self, operation: OperationIntent, validation: EditorValidation, error_text: str = "") -> None:
+        """Tell the rebase editor controller to serve the edits of this command in windows parented to its repository window.
+
+        An error text, such as the instructions Git refused, is shown above the text of the first window.
+        """
+        self.validation_by_operation_id[operation.operation_id] = validation
+        self.rebase_editor_controller.expect_edits(operation.operation_id, operation.context, operation.git_filename, validation,
+                                                   self.session_registry_controller.window_by_session.get(operation.session_id), error_text)
+
+    def rebase_editor_waiting(self, request: EditorRequest) -> None:
+        """Say which file Git waits for while its GitPane editor window is open."""
+        self._rebase_editor_changed(request.operation_id, request.kind.progress_text)
+
+    def _rebase_editor_changed(self, operation_id: str, message: str) -> None:
+        """Reread Git's edited list during message waits without confusing it with completion."""
+        intent = self.rebase_intent_by_id.get(operation_id)
+        if intent is None:
+            return
+        self.rebase_progress(operation_id, message)
+
+        def complete(state: RebaseSnapshot) -> None:
+            """Apply a current command observation to its still-open worktree views."""
+            for session_id, session in tuple(self.session_registry_controller.session_by_id.items()):
+                if session.is_closed or WorktreeKey.from_context(session.repository_context) != intent.operation.key:
+                    continue
+                dialog = self.rebase_dialog_by_session.get(session_id)
+                if dialog is not None and isValid(dialog):
+                    dialog.show_state(state)
+            self.rebase_progress(operation_id, message)
+
+        self.rebase.observe(intent.operation.context, intent.operation.git_filename,
+                            is_current=lambda: self.rebase_intent_by_id.get(operation_id) is intent, callback=complete)
+
+    def edit_rebase_todo(self, session_id: str) -> None:
+        """Capture one explicit instruction correction and leave Git paused after its editor exits."""
+        # Save writes the list and leaves the rebase paused; the user resumes it with Continue rebase.
+        self._edit_rebase_todo(session_id, EditorValidation.SAVE, "")
+
+    def reopen_rebase_todo(self, session_id: str, validation: EditorValidation, error_text: str) -> None:
+        """Open the editor again on the instructions Git refused and kept, with Git's error above what remains to do.
+
+        The correction reaches Git by git rebase --edit-todo, on the list Git holds: nothing done is replayed. With
+        Continue, the rebase continues once Git accepts the corrected list; with Save, it stays paused.
+        """
+        self._edit_rebase_todo(session_id, validation, error_text)
+
+    def _edit_rebase_todo(self, session_id: str, validation: EditorValidation, error_text: str) -> None:
+        """Submit one git rebase --edit-todo whose editor window validates with the given button and shows the given error first.
+
+        An edit that validates with Continue is remembered, so the rebase continues once Git accepts the edited list.
+        """
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        state = self.rebase.state_by_key.get(WorktreeKey.from_context(session.repository_context))
+        if state is None or not state.fresh or state.identity is None or state.state not in REBASE_STOPPED_STATE_SET:
+            self.observe_rebase(session_id)
+            return
+        operation = OperationIntent.capture(uuid.uuid4().hex, session.repository_context, self.repository.git_filename,
+                                            session_id=session_id, generation=self.session_registry_controller.generation_by_session[session_id], operation="Edit rebase instructions",
+                                            action=OperationAction.REBASE_CONTINUE)
+        intent = RebaseIntent(operation, state.identity.onto_oid, state.head_oid, state.identity.head_name)
+        output = self._create_rebase_output(intent)
+        output.set_running()
+        self.rebase_progress(operation.operation_id, "Editing rebase instructions…")
+        self._expect_edits(operation, validation, error_text)
+        if validation == EditorValidation.CONTINUE:
+            self.continue_after_correction_operation_id_set.add(operation.operation_id)
+        self.rebase.edit_todo(operation, state, is_current=lambda: self.operation_policy_controller.operation_allowed(operation), error_before_edit=error_text)
+
+    def rebase_progress(self, operation_id: str, message: str) -> None:
+        """Update tracking and banners without replacing native observation facts."""
+        intent = self.rebase_intent_by_id.get(operation_id)
+        if intent is None:
+            return
+        for session_id, session in tuple(self.session_registry_controller.session_by_id.items()):
+            if session.is_closed or WorktreeKey.from_context(session.repository_context) != intent.operation.key:
+                continue
+            window = self.session_registry_controller.window_by_session[session_id]
+            if self.session_registry_controller.quit_pending or session_id in self.session_registry_controller.close_session_set:
+                self.close_wait_requested.emit(session_id)
+            else:
+                window.rebase_label.setText(message)
+            window.rebase_banner.show()
+            dialog = self.rebase_dialog_by_session.get(session_id)
+            if dialog is not None and isValid(dialog):
+                dialog.status_label.setText(message)
+                dialog.command_message = ""
+                dialog.set_busy(True)
+
+    def follow_rebase_ended_outside(self, state: RebaseSnapshot) -> None:
+        """Follow a rebase that ended without a command of GitPane, with no banner: close its Rebase window and say so in one status line.
+
+        The line names where HEAD is as the references tell it: a refresh already running, or the one a finishing
+        rebase command starts, reads them and the line is completed once its history is published; otherwise only the
+        references are read, which costs nothing when their files did not change. A HEAD that moved is brought to the
+        graph by the worktree read that sees it.
+        """
+        if not state.ended_outside:
+            return
+        command_finishing = any(intent.operation.key == state.key for intent in self.rebase_intent_by_id.values())
+        for session_id, window in self.worktree_state_controller.managed_windows_of_worktree(state.key):
+            window.show_rebase_state(state)
+            dialog = self.rebase_dialog_by_session.get(session_id)
+            if dialog is not None and isValid(dialog):
+                dialog.show_state(state)
+                dialog.close()
+            self.rebase_end_notice_session_set.add(session_id)
+            window.statusBar().showMessage(REBASE_ENDED_OUTSIDE_MESSAGE)
+            if self.session_registry_controller.session_by_id[session_id].refresh_active or command_finishing:
+                continue
+            self.reference_read_controller.read_references(session_id, previous=self.reference_read_controller.reference_snapshot_by_session.get(session_id),
+                                 on_complete=lambda snapshot, _error, session_id=session_id: self.show_rebase_end_notice(session_id, snapshot))
+
+    def show_rebase_end_notice(self, session_id: str, snapshot: ReferenceSnapshot | None, *, after_history: bool = False) -> None:
+        """Write, once, the line telling a window that a rebase ended outside GitPane, after the status line of a just published history if asked."""
+        window = self.session_registry_controller.window_by_session.get(session_id)
+        if session_id not in self.rebase_end_notice_session_set or window is None or not isValid(window):
+            return
+        self.rebase_end_notice_session_set.discard(session_id)
+        notice = rebase_end_notice(snapshot)
+        window.statusBar().showMessage(window.statusBar().currentMessage() + " — " + notice if after_history else notice)
+
+    def reveal_rebase_result(self, session_id: str) -> None:
+        """Select the commit a finished rebase ended on once the history read after it is shown, then close its Rebase window."""
+        final_oid = self.rebase_final_oid_by_session.pop(session_id, None)
+        if final_oid is None:
+            return
+        self.session_registry_controller.window_by_session[session_id].reveal_commit(final_oid)
+        dialog = self.rebase_dialog_by_session.get(session_id)
+        if dialog is not None and isValid(dialog):
+            dialog.close()
+
+    def forget_rebase_end_notice(self, session_id: str) -> None:
+        """Drop the line owed about a rebase that ended outside GitPane when the refresh that was to complete it failed."""
+        self.rebase_end_notice_session_set.discard(session_id)
+
+    def rebase_actions_changed(self) -> None:
+        """Apply the shared writer availability to every existing tracking window."""
+        for session_id, dialog in tuple(self.rebase_dialog_by_session.items()):
+            session = self.session_registry_controller.session_by_id.get(session_id)
+            if session is None or session.is_closed or not isValid(dialog):
+                continue
+            operation = OperationIntent.capture("rebase-availability", session.repository_context, self.repository.git_filename,
+                                                action=OperationAction.REBASE_ABORT)
+            dialog.set_busy(bool(self.repository_operation.availability_diagnostic(operation)) or self.mergetool.owns_repository(operation.common_git_dir))
+
+    def rebase_finished(self, outcome: OperationOutcome) -> None:
+        """Keep refusals visible and reveal successful HEAD only after graph publication.
+
+        Instructions Git refused reopen the editor once the result is shown; a list corrected after a refused Continue
+        continues the rebase.
+        """
+        self.rebase_editor_controller.forget(outcome.operation_id)
+        validation = self.validation_by_operation_id.pop(outcome.operation_id, None)
+        continue_after_correction = outcome.operation_id in self.continue_after_correction_operation_id_set
+        self.continue_after_correction_operation_id_set.discard(outcome.operation_id)
+        intent = self.rebase_intent_by_id.pop(outcome.operation_id, None)
+        if intent is None:
+            return
+        operation = intent.operation
+        self.rebase.outcome_by_id[outcome.operation_id] = outcome
+        if outcome.status == OperationStatus.UNKNOWN:
+            # Only a command that could not read its own result asks a pending close to reread; observation failures never do.
+            self.session_registry_controller.close_reread_count_by_key[operation.key] = 0
+        else:
+            self.session_registry_controller.close_reread_count_by_key.pop(operation.key, None)
+        state = self.rebase.state_by_key.get(operation.key)
+        publish_after_trace(lambda: self._publish_rebase_console(outcome, operation, state), self)
+        if outcome.status in COMPLETED_STATUS_SET:
+            self.console_registry_controller.settle_paused_consoles(operation.key)
+        shared_by_key: dict[WorktreeKey, FullRefreshRead] = {}
+        for session_id, session in tuple(self.session_registry_controller.session_by_id.items()):
+            if session.is_closed or WorktreeKey.from_context(session.repository_context) != operation.key:
+                continue
+            window = self.session_registry_controller.window_by_session[session_id]
+            dialog = self.rebase_dialog_by_session.get(session_id)
+            if state is not None:
+                window.show_rebase_state(state)
+                if dialog is not None and isValid(dialog):
+                    dialog.set_busy(False)
+                    dialog.show_state(state)
+                    if outcome.diagnostic is not None:
+                        dialog.show_command_result(outcome.status, outcome.diagnostic.cause)
+                    if outcome.status == OperationStatus.ABORTED:
+                        # Nothing is left to track once the rebase is abandoned; its console keeps the result.
+                        dialog.close()
+                if outcome.status == OperationStatus.SUCCESS and state.head_oid:
+                    self.rebase_final_oid_by_session[session_id] = state.head_oid
+                    if session_id == operation.session_id:
+                        self.history_read_controller.history_top_session_set.add(session_id)
+                    session.filter_text = ""
+                    with QSignalBlocker(window.filter_edit):
+                        window.filter_edit.clear()
+            self.refresh_controller.refresh(session_id, full_refresh_read=self.refresh_controller.full_refresh_read_for(session, shared_by_key, explicit=True))
+        shared = shared_by_key.get(operation.key)
+        if shared is not None:
+            shared.rebase_publication = self._rebase_finish_publication(operation.key)
+        refreshed_key_set = self.refresh_controller.observe_full_refresh_pauses(shared_by_key)
+        self.rebase_actions_changed()
+        staging = self.staging_session_registry_controller.staging_by_key.get(operation.key)
+        # A preparation session without any open repository window still shows the result.
+        if staging is not None and operation.key not in refreshed_key_set:
+            staging.refresh(explicit=True)
+        self._follow_instruction_correction(outcome, operation, validation, continue_after_correction)
+
+    def _follow_instruction_correction(self, outcome: OperationOutcome, operation: OperationIntent, validation: EditorValidation | None, continue_after_correction: bool) -> None:
+        """Reopen the editor on instructions Git refused, or continue the rebase once Git accepted a list a refused Continue had to correct.
+
+        Each step starts only from a result of Git that answers a click of the user in an editor window, so the loop
+        turns at the user's pace; Abort in the editor ends it with the whole rebase. Nothing is chained while the
+        repository window is closing or changing repository, or while GitPane is quitting: the rebase stays paused.
+        """
+        session = self.session_registry_controller.session_by_id.get(operation.session_id)
+        if session is None or session.is_closed:
+            return
+        if self.replay_controller.replay_session_leaving(operation.session_id):
+            # The rebase is paused, a stable state where the close, the quit or the repository change can end; the error
+            # stays in the console and the Rebase window lets the user go on later.
+            return
+        instruction_error = outcome_instruction_error(outcome)
+        if instruction_error and validation is not None:
+            self.reopen_rebase_todo(operation.session_id, validation, instruction_error)
+            return
+        if not continue_after_correction or outcome.status != OperationStatus.PAUSED:
+            return
+        state = self.rebase.state_by_key.get(operation.key)
+        if state is not None and state.fresh and state.identity is not None:
+            self.continue_rebase(operation.session_id, state)
+
+    def _publish_rebase_console(self, outcome: OperationOutcome, operation: OperationIntent, state: RebaseSnapshot | None) -> None:
+        """Write the result of a rebase in its console, then settle what depends on how that console ended.
+
+        A console that closed on an expected pause hands the user over to the Rebase window; a console that stays open
+        on a failure while the rebase still waits for the user is kept until the rebase ends.
+        """
+        output = self.console_registry_controller.rebase_output_by_id.get(outcome.operation_id)
+        expected_stop = False
+        if output is not None and isValid(output):
+            if outcome.diagnostic is not None:
+                output.trace.append_diagnostic(outcome.operation_id, "status", outcome.diagnostic, outcome.status)
+            failure_reported = outcome.diagnostic is not None
+            output.trace.append_end_line(outcome.operation_id, "status", rebase_result_log_text(outcome, state), rebase_result_line(outcome, state), outcome.status,
+                                         failure_reported=failure_reported)
+            output.show_result(outcome.status, failure_reported=failure_reported)
+            expected_stop = outcome.status == OperationStatus.PAUSED and output.completed
+        if outcome.status not in COMPLETED_STATUS_SET and state is not None and state.fresh and state.identity is not None and not expected_stop:
+            # A step Git refused while the rebase still waits for the user keeps its console open on the failure; that
+            # console is settled once the rebase ends.
+            self.console_registry_controller.paused_console_ids_by_key.setdefault(operation.key, []).append(outcome.operation_id)
+        if expected_stop and not outcome_instruction_error(outcome) and (output is None or not isValid(output) or not output.isVisible()):
+            # The console closed on the pause: what waits for the user is the Rebase window, so it comes to the front.
+            # Instructions Git refused reopen the editor instead, which must stay in front.
+            self._bring_rebase_dialog_forward(operation.session_id)
+
+    def _bring_rebase_dialog_forward(self, session_id: str) -> None:
+        """Show the Rebase window of a session in front and active, opening it as the Open rebase banner does when needed."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None or session.is_closed:
+            return
+        dialog = self.rebase_dialog_by_session.get(session_id)
+        if dialog is None or not isValid(dialog) or not dialog.isVisible():
+            dialog = self.open_rebase_dialog(session_id)
+        if dialog is None or not isValid(dialog):
+            return
+        dialog.raise_()
+        dialog.activateWindow()
+
+    def observe_rebase(self, session_id: str, *, open_paused: bool = False, automatic: bool = False,
+                       replay_publication: ReplayRefreshPublication | None = None, rebase_publication: RebaseRefreshPublication | None = None) -> None:
+        """Observe one worktree without allowing a late response to reach a replaced session.
+
+        ``replay_publication`` is the state a Cherry-pick or Revert just published when it ended, shown in place of a
+        replay read while it is still current. ``rebase_publication`` is the state a rebase command just published: it
+        is shown in place of a rebase read once its native files are found unchanged, and read through Git otherwise.
+        """
+        self.replay_controller.observe_replay(session_id, automatic=automatic, publication=replay_publication)
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        context = session.repository_context
+        if context.is_bare:
+            return
+        identity = self.session_registry_controller.identity_by_session[session_id]
+        key = WorktreeKey.from_context(context)
+        # Checked before the delay below on purpose: returning here stamps no moment, so the first observation asked
+        # for once the worktree is free is not held back by a timestamp it never wrote.
+        if automatic and self.repository_operation.owns_worktree(key):
+            return
+        now = time.monotonic()
+        if automatic and (now - self.rebase_observed_at_by_key.get(key, 0)) * 1000 < REBASE_REFRESH_INTERVAL_MS:
+            return
+        self.rebase_observed_at_by_key[key] = now
+        existing_dialog = self.rebase_dialog_by_session.get(session_id)
+        if existing_dialog is not None and isValid(existing_dialog):
+            existing_dialog.refresh_button.setEnabled(False)
+        recipients = []
+        for target_id, target_session in self.session_registry_controller.session_by_id.items():
+            if (not target_session.is_closed and WindowCapability.MANAGE in target_session.capabilities
+                    and WorktreeKey.from_context(target_session.repository_context) == key):
+                recipients.append((target_id, target_session, self.session_registry_controller.identity_by_session.get(target_id)))
+
+        def current() -> bool:
+            """Require both the original request and its independent worktree to remain current."""
+            return (self.session_registry_controller.identity_by_session.get(session_id) == identity and self.session_registry_controller.session_by_id.get(session_id) is session
+                    and not session.is_closed and WorktreeKey.from_context(session.repository_context) == key)
+
+        def complete(state: RebaseSnapshot) -> None:
+            """Publish to the captured current views sharing this exact worktree."""
+            self.repository_operation.register_context(key, context)
+            for target_id, target_session, target_identity in recipients:
+                window = self.session_registry_controller.window_by_session.get(target_id)
+                if (self.session_registry_controller.session_by_id.get(target_id) is not target_session or self.session_registry_controller.identity_by_session.get(target_id) != target_identity
+                        or target_session.is_closed or window is None or not isValid(window) or window.is_closed):
+                    continue
+                window.show_rebase_state(state)
+                dialog = self.rebase_dialog_by_session.get(target_id)
+                self.rebase_state_shown.emit(target_id, state)
+                if dialog is not None and isValid(dialog):
+                    dialog.show_state(state)
+                    dialog.refresh_button.setEnabled(True)
+                elif open_paused and state.state != "absent":
+                    self.open_rebase_dialog(target_id)
+
+        if rebase_publication is not None and not automatic:
+            self._show_rebase_publication(key, context, rebase_publication, current, complete)
+            return
+        self.worktree_state_controller.mark_pause_observed(key, REBASE_PAUSE_OBSERVATION)
+        # An automatic look waits behind every request somebody is waiting for; a click reads as a user action.
+        priority = ProcessPriority.BACKGROUND if automatic else ProcessPriority.USER
+        source = self.replay_controller.passive_observation_source(key) if automatic else None
+        if source is None:
+            self.rebase.observe(context, self.repository.git_filename, is_current=current, callback=complete, priority=priority)
+            return
+        self.rebase.observe_passive(context, self.repository.git_filename, source, is_current=current, callback=complete, priority=priority)
+
+    def _rebase_finish_publication(self, key: WorktreeKey) -> RebaseRefreshPublication | None:
+        """Answer the state the rebase command that just ended published for this worktree, while nothing newer replaced it.
+
+        Only a fresh state that still carries the native files its capture proved stable is offered: a refusal, an
+        error or a message of the command's own leaves nothing to show without reading again. A read that started before
+        the publication, such as the one an editor wait asked for, never replaces it, so it does not stand in the way.
+        """
+        state = self.rebase.state_by_key.get(key)
+        if (state is None or not state.fresh or state.native_observations is None or state.generation != self.rebase.published_generation_by_key.get(key)
+                or state.generation != self.rebase.generation_by_key.get(key)):
+            return None
+        return RebaseRefreshPublication(state, self.repository.git_filename)
+
+    def _rebase_publication_current(self, key: WorktreeKey, publication: RebaseRefreshPublication) -> bool:
+        """Tell whether a rebase finish publication may still be shown: the latest state of this worktree, same Git, and no read started since.
+
+        Every read started after the publication takes a newer generation; one started before it cannot replace it.
+        """
+        state = publication.state
+        return (state.key == key and publication.git_filename == self.repository.git_filename and self.rebase.state_by_key.get(key) is state
+                and self.rebase.generation_by_key.get(key) == state.generation)
+
+    def _show_rebase_publication(self, key: WorktreeKey, context: RepositoryContext, publication: RebaseRefreshPublication, current: Callable[[], bool],
+                                 complete: Callable[[RebaseSnapshot], None]) -> None:
+        """Show a rebase command's published state after proving, on a worker, that its native files are still the captured ones.
+
+        The pause is acknowledged only once that proof holds, so the periodic refresh still looks at anything that moves
+        afterwards. A publication that stopped being current, pause paths not known yet, a changed or unreadable native
+        file: each reads the rebase state through Git instead.
+        """
+        git_filename = self.repository.git_filename
+        staging = self.staging_session_registry_controller.staging_by_key.get(key)
+        filename_by_git_path = staging.pause_probe.filename_by_git_path() if staging is not None else None
+
+        def read_through_git() -> None:
+            """Observe the rebase as any refresh does."""
+            self.worktree_state_controller.mark_pause_observed(key, REBASE_PAUSE_OBSERVATION)
+            self.rebase.observe(context, git_filename, is_current=current, callback=complete)
+
+        if filename_by_git_path is None or not self._rebase_publication_current(key, publication):
+            read_through_git()
+            return
+
+        def prove() -> Generator[FileTask, object, bool]:
+            """Compare the native rebase files with the ones the command's capture proved, off the Qt thread."""
+            state_dirs = state_dirs_from_pause_paths(key, filename_by_git_path)
+            unchanged = yield FileTask(lambda: native_observations_unchanged(state_dirs, publication.state.native_observations))
+            return unchanged
+
+        def proven(unchanged: bool | None, error: Exception | None) -> None:
+            """Show the publication only if it is still the latest state and its files did not move; otherwise read."""
+            if not current():
+                return
+            if error is None and unchanged and self._rebase_publication_current(key, publication) and git_filename == self.repository.git_filename:
+                self.worktree_state_controller.mark_pause_observed(key, REBASE_PAUSE_OBSERVATION)
+                complete(publication.state)
+                return
+            read_through_git()
+
+        self.worktree_service.run(context, git_filename, prove(), proven)
+
+    def open_rebase_dialog(self, session_id: str) -> RebaseDialog | None:
+        """Show the shared observation without resuming or modifying the native operation."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return None
+        window = self.session_registry_controller.window_by_session[session_id]
+        state = self.rebase.state_by_key.get(WorktreeKey.from_context(window.context))
+        if window.context.is_bare or state is None or state.state == "absent":
+            return None
+        dialog = self.rebase_dialog_by_session.get(session_id)
+        if dialog is None or not isValid(dialog):
+            dialog = self._create_rebase_dialog(session_id, state)
+        dialog.show_state(state)
+        dialog.show()
+        dialog.raise_()
+        return dialog
+
+    def _create_rebase_dialog(self, session_id: str, state: RebaseSnapshot) -> RebaseDialog:
+        """Create the single tracking window wiring so launch and reopen behave identically, releasing the window it replaces."""
+        previous = self.rebase_dialog_by_session.get(session_id)
+        if previous is not None and isValid(previous):
+            # A finished rebase leaves its tracking window parented to the repository window; a new launch replaces it rather than stacking another one.
+            previous.close()
+            previous.deleteLater()
+        dialog = RebaseDialog(state, self.session_registry_controller.window_by_session[session_id])
+        dialog.installEventFilter(self.window_activation_controller)
+        requested_oid_set: set[str] = set()
+
+        def read_commit_details(steps: tuple[RebaseStep, ...]) -> None:
+            """Load each original commit once without delaying or replacing native rebase observations."""
+            missing_steps = []
+            for step in steps:
+                if step.oid and step.oid not in requested_oid_set:
+                    requested_oid_set.add(step.oid)
+                    missing_steps.append(step)
+            if not missing_steps:
+                return
+
+            def complete(commits: tuple[RebaseCommit, ...] | None, error: Exception | None) -> None:
+                """Discard late display results when their tracking window has been replaced or closed."""
+                if isValid(dialog) and self.rebase_dialog_by_session.get(session_id) is dialog and error is None and commits:
+                    dialog.show_commits(commits)
+
+            self.worktree_service.run(self.session_registry_controller.window_by_session[session_id].context, self.repository.git_filename, read_rebase_commits(tuple(missing_steps)), complete)
+
+        dialog.commit_details_requested.connect(read_commit_details)
+        # The window showed its first state before this connection existed, and an equal state keeps its rows without asking again.
+        dialog.request_commit_details()
+        dialog.refresh_requested.connect(requested_oid_set.clear)
+        dialog.refresh_requested.connect(lambda: self.observe_rebase(session_id))
+        dialog.edit_todo_requested.connect(lambda: self.edit_rebase_todo(session_id))
+        dialog.amend_requested.connect(lambda state: self.amend_rebase_commit(session_id, state))
+        dialog.continue_requested.connect(lambda state: self.continue_rebase(session_id, state))
+        dialog.abort_requested.connect(lambda state: self.abort_rebase(session_id, state))
+        dialog.solve_conflicts_requested.connect(lambda: self.conflict_list_requested.emit(session_id))
+        self.rebase_dialog_by_session[session_id] = dialog
+        dialog.show_state(state)
+        # No periodic recomputation comes after this one: a window created while another operation owns the
+        # repository has to show it at once.
+        self.rebase_actions_changed()
+        return dialog
+
+    def amend_rebase_commit(self, session_id: str, state: RebaseSnapshot) -> None:
+        """Open the existing staging view for one explicitly selected native edit pause."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return
+        context = self.session_registry_controller.session_by_id[session_id].repository_context
+        if state.key != WorktreeKey.from_context(context) or state.state != "edit" or not state.fresh:
+            return
+        staging = self.staging_session_registry_controller.staging_session(context)
+        if staging.action_diagnostic(OperationAction.AMEND):
+            self.observe_rebase(session_id)
+            return
+        if self.staging_controller.open_staging(session_id) is not None:
+            staging.request_rebase_amend(state)
+
+    def abort_rebase(self, session_id: str, state: RebaseSnapshot) -> None:
+        """Submit an immediate native Abort independently of the launch confirmation."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        if state.key != WorktreeKey.from_context(session.repository_context) or state.identity is None:
+            return
+        for active in self.repository_operation.active_by_id.values():
+            if active.action == OperationAction.REBASE_ABORT and active.key == state.key:
+                return
+        operation = OperationIntent.capture(uuid.uuid4().hex, session.repository_context, self.repository.git_filename,
+                                            session_id=session_id, generation=self.session_registry_controller.generation_by_session[session_id], operation="Abort rebase",
+                                            action=OperationAction.REBASE_ABORT)
+        intent = RebaseIntent(operation, state.identity.onto_oid, state.head_oid, state.identity.head_name)
+        if self.mergetool.owns_repository(operation.common_git_dir):
+            self._rebase_refused(intent, ValueError("Wait for the merge tool and its series to finish before aborting the rebase."))
+            return
+        output = self._create_rebase_output(intent)
+        output.set_running()
+        self.rebase_progress(operation.operation_id, "Aborting rebase…")
+        try:
+            self.rebase.abort(operation, state, is_current=lambda: self.operation_policy_controller.operation_allowed(operation)
+                              and not self.mergetool.owns_repository(operation.common_git_dir))
+        except (ValueError, OSError) as error:
+            diagnostic = Diagnostic("Abort rebase", operation.context.repository_dir, operation.git_filename, [], str(error)).prepare()
+            self.rebase_finished(OperationOutcome(operation.operation_id, OperationStatus.REFUSED, diagnostic=diagnostic))
+
+    def continue_rebase(self, session_id: str, state: RebaseSnapshot) -> None:
+        """Reserve a distinct explicit Continue and route its native result to the tracking view."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        if state.key != WorktreeKey.from_context(session.repository_context) or state.identity is None:
+            return
+        operation = OperationIntent.capture(uuid.uuid4().hex, session.repository_context, self.repository.git_filename,
+                                            session_id=session_id, generation=self.session_registry_controller.generation_by_session[session_id], operation="Continue rebase",
+                                            action=OperationAction.REBASE_CONTINUE)
+        intent = RebaseIntent(operation, state.identity.onto_oid, state.head_oid, state.identity.head_name)
+        if self.mergetool.owns_repository(operation.common_git_dir):
+            self._rebase_refused(intent, ValueError("Wait for the merge tool and its series to finish before continuing the rebase."))
+            return
+        output = self._create_rebase_output(intent)
+        output.set_running()
+        self.rebase_progress(operation.operation_id, SharedText.REBASE_APPLYING_COMMITS.value)
+        self._expect_edits(operation, EditorValidation.CONTINUE)
+        try:
+            self.rebase.continue_rebase(operation, state,
+                                       is_current=lambda: self.operation_policy_controller.operation_allowed(operation) and not self.mergetool.owns_repository(operation.common_git_dir))
+        except (ValueError, OSError) as error:
+            diagnostic = Diagnostic("Continue rebase", operation.context.repository_dir, operation.git_filename, [], str(error)).prepare()
+            self.rebase_finished(OperationOutcome(operation.operation_id, OperationStatus.REFUSED, diagnostic=diagnostic))