gitpane 1.0.0__py3-none-any.whl

gitpane/controller/replay_controller.py

@@ -0,0 +1,805 @@
+"""Cherry-pick or revert commits from a repository window, through their pauses."""
+
+from __future__ import annotations
+
+import os
+import time
+import uuid
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, QTimer, Signal
+from PySide6.QtWidgets import QMessageBox
+from shiboken6 import isValid
+
+from gitpane.config import ProcessPriority
+from gitpane.controller.refresh_controller import ReplayRefreshPublication
+from gitpane.history.file_history import WindowCapability
+from gitpane.operation.console_line import COMPLETED_STATUS_SET
+from gitpane.operation.console_tone import ConsoleTone
+from gitpane.operation.diagnostic import Diagnostic
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.operation.repository_operation import REPLAY_PAUSE_OBSERVATION, OperationAction, OperationIntent, OperationOutcome
+from gitpane.sequencer.replay import ReplayIntent
+from gitpane.sequencer.replay_state import COMMIT_OPERATION_LABEL, REPLAY_REFRESH_INTERVAL_MS, ReplayAction, ReplayCommitMode, ReplayKind, replay_action_diagnostic, replay_auto_continue_ready, replay_effect_message, replay_may_be_present
+from gitpane.system.path_identity import canonical_path
+from gitpane.ui.reference.revision_dialog import RevisionChoiceDialog
+from gitpane.ui.repository.repository_window import LEGACY_BACKUP_NOTICE_KIND
+from gitpane.ui.sequencer.replay_conflict_prompt import ReplayConflictPrompt
+from gitpane.ui.sequencer.replay_dialog import ReplayDialog
+from gitpane.ui.window_control.dialog_modality import open_window_modal, prepare_message_box
+from gitpane.worktree.worktree_snapshot import WorktreeKey
+
+if TYPE_CHECKING:
+    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.reference_form_controller import ReferenceFormController
+    from gitpane.controller.reference_read_controller import ReferenceReadController
+    from gitpane.controller.refresh_controller import FullRefreshRead, RefreshController
+    from gitpane.controller.session_registry import SessionRegistry
+    from gitpane.controller.staging_session_registry import StagingSessionRegistry
+    from gitpane.controller.worktree_state_controller import WorktreeStateController
+    from gitpane.history.repository import GitRepository
+    from gitpane.history.repository_value import RepositoryContext, RequestIdentity
+    from gitpane.operation.diagnostic import DiagnosticLog, PreparedDiagnostic
+    from gitpane.operation.repository_operation import RepositoryOperationService
+    from gitpane.reference.reference_snapshot import ReferenceSnapshot
+    from gitpane.sequencer.mergetool import MergetoolService
+    from gitpane.sequencer.replay import ReplayService, ReplaySource
+    from gitpane.sequencer.replay_state import ReplaySnapshot
+    from gitpane.worktree.worktree_snapshot import PassiveObservationSource
+
+REPLAY_SUBMISSION_REFUSED_TEXT = "This window can no longer start the operation. Refresh the repository and try again."
+# Cherry-picking the checked-out commit onto itself has nothing to apply; the graph menu greys the action out on it too.
+REPLAY_CURRENT_COMMIT_REFUSED_TEXT = "This is the current commit: there is nothing to cherry-pick. Choose another revision."
+REPLAY_AUTO_CONTINUE_TEXT = "All conflicts are marked as solved. Continuing automatically."
+# Written in the console once Git's own Abort has ended a Cherry-pick or Revert: Git brought the checkout back, GitPane checked nothing more.
+REPLAY_ABORT_FINISHED_TEXT = "Abort finished. Git restored the checkout the operation started from."
+# Followed by the folder holding the backups and a final period.
+LEGACY_REPLAY_BACKUP_NOTICE_PREFIX = "An earlier GitPane version kept backups of an interrupted cherry-pick or revert in "
+
+
+@dataclass(frozen=True)
+class ReplayResumeObservation:
+    """The complete replay read that qualified an automatic Continue, with where it came from.
+
+    It was asked by the automatic request itself, through Git, for this session under this request identity and Git
+    executable. It replaces only the reread the Continue would otherwise make before submitting; the reservation
+    still captures the pause twice and checks it before Git runs.
+    """
+
+    session_id: str
+    identity: RequestIdentity
+    git_filename: str
+    state: ReplaySnapshot
+
+
+@dataclass(frozen=True)
+class ReplayAutoContinueRequest:
+    """Remember that a conflict resolution made in GitPane asked to continue its paused Cherry-pick or Revert.
+
+    ``known_generation`` is the replay read generation when the request was made: only a later read can show the
+    staged resolution, so an older state still listing the conflict must neither launch nor cancel the request.
+    ``observation`` is the read the request asked for, once it answered with a newer state; the Continue uses it once.
+    """
+
+    session_id: str
+    known_generation: int
+    observation: ReplayResumeObservation | None = None
+
+
+# A successful launch or Continue has just created a commit (or changed the checkout); its console only reports
+# success once the refreshed graph shows that result.
+REPLAY_GRAPH_WAITING_ACTION_SET = frozenset((OperationAction.REPLAY_START, OperationAction.REPLAY_CONTINUE))
+
+
+@dataclass(frozen=True)
+class PendingReplayRefresh:
+    """A successful Cherry-pick, Revert or Continue whose console waits for a graph that shows its result.
+
+    ``required_generation`` is the first history generation read after the result: a graph read that started
+    earlier, before the commit existed, must not report it.
+    """
+
+    outcome: OperationOutcome
+    required_generation: int
+
+
+class ReplayController(QObject):
+    """The Cherry-pick and Revert of every repository window: form, launch, console waiting for the refreshed graph, pause banner with Continue and Abort, automatic Continue, and the backups an earlier version left."""
+
+    # Tells whether the conflict window of a repository window must refuse writes while a replay may be present and
+    # another write or the merge tool holds its worktree: the session id and True to lock, False to unlock.
+    conflict_write_availability_changed = Signal(str, bool)
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, operation_policy_controller: OperationPolicy, staging_session_registry_controller: StagingSessionRegistry, console_registry_controller: ConsoleRegistry,
+                 reference_read_controller: ReferenceReadController, refresh_controller: RefreshController, worktree_state_controller: WorktreeStateController, history_read_controller: HistoryReadController,
+                 reference_form_controller: ReferenceFormController, repository: GitRepository, repository_operation: RepositoryOperationService, replay: ReplayService, mergetool: MergetoolService, diagnostic_log: DiagnosticLog | None,
+                 parent: QObject | None = None) -> None:
+        """Receive the services and the lower controllers a replay works with; the wiring builds it after the reference form controller, and the rebase, the conflict and the repository windows reach it through the wiring."""
+        super().__init__(parent)
+        self.session_registry_controller = session_registry_controller
+        self.operation_policy_controller = operation_policy_controller
+        self.staging_session_registry_controller = staging_session_registry_controller
+        self.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.reference_form_controller = reference_form_controller
+        self.repository = repository
+        self.repository_operation = repository_operation
+        self.replay = replay
+        self.mergetool = mergetool
+        self.diagnostic_log = diagnostic_log
+        self.replay_dialog_by_session: dict[str, ReplayDialog] = {}
+        self.replay_prompt_by_session: dict[str, ReplayConflictPrompt | QMessageBox] = {}
+        self.replay_intent_by_id: dict[str, ReplayIntent] = {}
+        # Every successful launch of a session still waiting for the refreshed graph, in launch order: a second launch
+        # can be accepted before the first one's graph is published, and each console must still get its result.
+        self.replay_refresh_by_session: dict[str, list[PendingReplayRefresh]] = {}
+        self.replay_auto_continue_by_key: dict[WorktreeKey, ReplayAutoContinueRequest] = {}
+        # Worktrees whose Continue or Abort is rereading the pause before it reserves the repository, with the requesting
+        # session. Until the reservation exists nothing else marks the worktree busy, so a second Continue could start.
+        self.replay_resume_session_by_key: dict[WorktreeKey, str] = {}
+        self.replay_observed_at_by_key: dict[WorktreeKey, float] = {}
+        # Repositories, by canonical common Git folder, whose anchor references left by earlier versions were already
+        # looked at during this run of the program.
+        self.legacy_replay_checked_common_dir_set: set[str] = set()
+        # What the retirement answered for each canonical common Git folder during this run: the backup folders an
+        # earlier version kept there. Every working tree of that repository opened later is told from this answer.
+        self.legacy_replay_kept_dirs_by_common_dir: dict[str, tuple[str, ...]] = {}
+        # Working trees already told about those backups during this run, so that each is told once.
+        self.legacy_replay_notified_worktree_set: set[WorktreeKey] = set()
+
+    def open_replay(self, session_id: str, source_oid: str, kind: ReplayKind, snapshot: ReferenceSnapshot | None = None) -> ReplayDialog | None:
+        """Open read-only source metadata while capturing the current destination checkout."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return None
+        session = self.session_registry_controller.session_by_id[session_id]
+        window = self.session_registry_controller.window_by_session[session_id]
+        snapshot = snapshot or self.reference_read_controller.reference_snapshot_by_session.get(session_id)
+        if window.context.is_bare or snapshot is None:
+            return None
+        existing = self.replay_dialog_by_session.get(session_id)
+        if existing is not None and isValid(existing) and not existing.closed:
+            existing.raise_()
+            return existing
+        dialog = ReplayDialog(session_id, source_oid, kind, window)
+        self.replay_dialog_by_session[session_id] = dialog
+        operation = OperationIntent.capture(uuid.uuid4().hex, snapshot.context, snapshot.git_filename, generation=snapshot.generation,
+                                            session_id=session_id, operation="Cherry pick" if kind == ReplayKind.CHERRY_PICK else "Revert", action=OperationAction.REPLAY_START, from_form=True)
+        intent = ReplayIntent(operation, kind, source_oid, snapshot.head_oid, snapshot.head_ref)
+        dialog.replay_requested.connect(lambda captured: self.submit_replay(session_id, captured))
+        dialog.revision_requested.connect(lambda: self.open_replay_revision(session_id))
+        open_window_modal(dialog)
+
+        def current() -> bool:
+            """Discard preparation after session replacement or closing the source form."""
+            return (isValid(dialog) and not dialog.closed and not session.is_closed and session.repository_context == operation.context
+                    and self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE) and self.repository.git_filename == operation.git_filename)
+
+        def prepared(captured: ReplayIntent | None, error: Exception | None) -> None:
+            """Read complete metadata only after destination and source validation."""
+            if not current():
+                return
+            if error is not None:
+                dialog.show_error(str(error))
+                return
+
+            def metadata_complete(source: ReplaySource | None, error: Exception | None) -> None:
+                """Publish real commit details without allowing stale reads to enable a closed form."""
+                if not current():
+                    return
+                if error is not None:
+                    dialog.show_error(str(error))
+                    return
+                dialog.populate(captured, source.fields, source.parents)
+                dialog.summary.show_references(snapshot)
+
+            # The preparation has just resolved and checked this very commit: only its metadata remains to be read.
+            self.replay.read_source(operation.context, operation.git_filename, captured.source_oid, callback=metadata_complete, resolved=True)
+
+        self.replay.prepare(intent, is_current=current, callback=prepared)
+        return dialog
+
+    def open_replay_revision(self, session_id: str) -> None:
+        """Replace a prepared source only after the latest local revision read succeeds."""
+        dialog = self.replay_dialog_by_session.get(session_id)
+        if (dialog is None or dialog.closed or dialog.busy or dialog.completed or dialog.kind != ReplayKind.CHERRY_PICK
+                or dialog.intent is None or not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE)):
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        window = self.session_registry_controller.window_by_session[session_id]
+        if dialog.revision_dialog is not None and not dialog.revision_dialog.closed:
+            dialog.revision_dialog.raise_()
+            return
+        selector = RevisionChoiceDialog(window.history_model.commits, dialog)
+        dialog.revision_dialog = selector
+        dialog.source_generation += 1
+        source_generation = dialog.source_generation
+        captured = dialog.intent
+
+        def read_revision(revision: str) -> None:
+            """Capture the edit generation so older callbacks cannot overwrite later choices."""
+            generation = selector.generation
+
+            def complete(source: ReplaySource | None, error: Exception | None) -> None:
+                """Publish the new frame and empty parent choice only in the original session."""
+                if (not isValid(dialog) or not isValid(selector) or dialog.closed or dialog.busy or dialog.completed or selector.closed
+                        or selector.generation != generation or dialog.source_generation != source_generation or session.is_closed
+                        or session.repository_context != captured.operation.context or self.repository.git_filename != captured.operation.git_filename
+                        or not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE)):
+                    return
+                if error is not None or source is None:
+                    selector.show_error()
+                    return
+                if source.oid == captured.original_head_oid:
+                    selector.show_error(REPLAY_CURRENT_COMMIT_REFUSED_TEXT)
+                    return
+                dialog.source_generation += 1
+                dialog.populate(replace(captured, source_oid=source.oid), source.fields, source.parents)
+                snapshot = self.reference_read_controller.reference_snapshot_by_session.get(session_id)
+                if snapshot is not None:
+                    dialog.summary.show_references(snapshot)
+                selector.accept()
+
+            self.replay.read_source(captured.operation.context, captured.operation.git_filename, revision, callback=complete)
+
+        selector.revision_requested.connect(read_revision)
+        open_window_modal(selector)
+        selector.revision_edit.setFocus()
+
+    def submit_replay(self, session_id: str, intent: ReplayIntent) -> str | None:
+        """Open a non-modal console, launch the captured native operation, then close the form.
+
+        The form closes as soon as the launch is accepted: a form or console left window-modal on the repository
+        window would block the conflict prompt and the banner once Git pauses. Results,
+        errors and refusals from then on are shown in the console.
+        """
+        dialog = self.replay_dialog_by_session.get(session_id)
+        if dialog is None or not isValid(dialog):
+            return None
+        if (not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE) or dialog.closed or dialog.intent != intent
+                or intent.operation.session_id != session_id or intent.operation.operation_id in self.replay_intent_by_id):
+            dialog.show_submission_refused(REPLAY_SUBMISSION_REFUSED_TEXT)
+            return None
+        session = self.session_registry_controller.session_by_id[session_id]
+
+        def current() -> bool:
+            """Retain requester and worktree identity through the last native launch check."""
+            return (not session.is_closed and session.repository_context == intent.operation.context
+                    and self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE) and self.repository.git_filename == intent.operation.git_filename)
+
+        self.replay_intent_by_id[intent.operation.operation_id] = intent
+        self.reference_form_controller.open_reference_output(intent, dialog, modal=False)
+        try:
+            operation_id = self.replay.start(intent, is_current=current)
+        except ValueError as error:
+            # The service refused before any Git command ran (it is closed or unavailable): release the request and end
+            # the console just opened with the cause, so neither the form nor the console stays stuck as running.
+            self.replay_intent_by_id.pop(intent.operation.operation_id, None)
+            diagnostic = Diagnostic(intent.operation.operation, intent.operation.context.repository_dir, intent.operation.git_filename, [], str(error)).prepare()
+            if self.diagnostic_log is not None:
+                self.diagnostic_log.write(diagnostic)
+            self.reference_form_controller.finish_reference_output(OperationOutcome(intent.operation.operation_id, OperationStatus.REFUSED, diagnostic=diagnostic))
+            dialog.close_after_submission()
+            return None
+        dialog.close_after_submission()
+        return operation_id
+
+    def replay_finished(self, outcome: OperationOutcome) -> None:
+        """Refresh live repository views, publish the console result and offer resolution for a fresh conflict."""
+        intent = self.replay_intent_by_id.pop(outcome.operation_id, None)
+        if intent is None:
+            return
+        self.replay.outcome_by_id[outcome.operation_id] = outcome
+        if outcome.status == OperationStatus.ABORTED:
+            trace = self.reference_form_controller.reference_trace_by_id.get(outcome.operation_id)
+            if trace is not None:
+                # The Abort was verified before this line is written: like the result line after it, it tells a success.
+                trace.append_event(outcome.operation_id, "status", REPLAY_ABORT_FINISHED_TEXT, ConsoleTone.SUCCESS)
+        session = self.session_registry_controller.session_by_id.get(intent.operation.session_id)
+        conflict_state = None
+        waits_for_graph = False
+        if session is not None and not session.is_closed and session.repository_context == intent.operation.context:
+            state = self.replay.state_by_key.get(intent.operation.key)
+            if outcome.status == OperationStatus.PAUSED and state is not None and state.fresh and state.unmerged_paths and intent.operation.action == OperationAction.REPLAY_START:
+                conflict_state = state
+            if outcome.status == OperationStatus.SUCCESS and intent.operation.action in REPLAY_GRAPH_WAITING_ACTION_SET:
+                self.history_read_controller.history_top_session_set.add(intent.operation.session_id)
+                # The next history read, queued behind any read already running, is the first one that can show the commit.
+                required_generation = session.generation + 1
+                self.replay_refresh_by_session.setdefault(intent.operation.session_id, []).append(PendingReplayRefresh(outcome, required_generation))
+                waits_for_graph = True
+            shared_by_key: dict[WorktreeKey, FullRefreshRead] = {}
+            for session_id, current_session in tuple(self.session_registry_controller.session_by_id.items()):
+                if not current_session.is_closed and canonical_path(current_session.repository_context.common_git_dir) == intent.operation.common_git_dir:
+                    self.refresh_controller.refresh(session_id, full_refresh_read=self.refresh_controller.full_refresh_read_for(current_session, shared_by_key))
+            shared = shared_by_key.get(intent.operation.key)
+            if shared is not None:
+                # The operation has just published the state of its own worktree; the refresh shows it instead of reading
+                # it again. Other worktrees of the repository read their own state.
+                shared.replay_publication = self._replay_finish_publication(intent.operation.key)
+            self.refresh_controller.observe_full_refresh_pauses(shared_by_key)
+        if not waits_for_graph:
+            # A replay refused before Git ran says why in GitPane's own words (files a submodule would lose, staged
+            # changes, a path outside the working tree), which the user needs in plain sight to fix and try again.
+            refusal_text = outcome.diagnostic.cause if outcome.status == OperationStatus.REFUSED and outcome.diagnostic is not None else ""
+            self.reference_form_controller.finish_reference_output(outcome, failure_text=refusal_text)
+        if outcome.status == OperationStatus.PAUSED:
+            self.console_registry_controller.paused_console_ids_by_key.setdefault(intent.operation.key, []).append(outcome.operation_id)
+        elif outcome.status in COMPLETED_STATUS_SET:
+            self.console_registry_controller.settle_paused_consoles(intent.operation.key)
+        if conflict_state is not None:
+            self._offer_replay_resolution(intent.operation.session_id, conflict_state, outcome.operation_id)
+
+    def _replay_finish_publication(self, key: WorktreeKey) -> ReplayRefreshPublication | None:
+        """Answer the state the replay operation that just ended published for this worktree, while nothing newer replaced it.
+
+        Only a fresh state without a message of its own is offered. A published message (an Abort's result, a refusal,
+        a result that could not be verified) stays on the banner until the next read replaces the state, so that read
+        still runs and the banner reads exactly as before.
+        """
+        state = self.replay.state_by_key.get(key)
+        if (state is None or not state.fresh or state.diagnostic or state.generation != self.replay.published_generation_by_key.get(key)
+                or state.generation != self.replay.generation_by_key.get(key)):
+            return None
+        return ReplayRefreshPublication(state, self.repository.git_filename)
+
+    def _replay_publication_current(self, key: WorktreeKey, publication: ReplayRefreshPublication) -> bool:
+        """Tell whether a finish publication may still be shown: the latest state of this worktree, same Git, and no read started since."""
+        state = publication.state
+        return (state.key == key and publication.git_filename == self.repository.git_filename and self.replay.state_by_key.get(key) is state
+                and self.replay.generation_by_key.get(key) == state.generation and key not in self.replay.observers_by_key)
+
+    def finish_replay_refresh(self, session_id: str, diagnostic: PreparedDiagnostic | None = None, *, published_generation: int | None = None) -> None:
+        """Finish the launches this published graph can show, retaining a failed refresh for inspection.
+
+        A failed refresh (``diagnostic``) drops any queued refresh, so it finishes every waiting launch as partial.
+        A published graph only finishes the launches whose result it was read after; later ones wait for the queued refresh.
+        """
+        remaining_pendings = []
+        finished_pendings = []
+        for pending in self.replay_refresh_by_session.pop(session_id, []):
+            if diagnostic is None and published_generation is not None and pending.required_generation > published_generation:
+                remaining_pendings.append(pending)
+            else:
+                finished_pendings.append(pending)
+        if remaining_pendings:
+            self.replay_refresh_by_session[session_id] = remaining_pendings
+        for pending in finished_pendings:
+            self._finish_replay_launch(session_id, pending.outcome, diagnostic)
+
+    def _finish_replay_launch(self, session_id: str, outcome: OperationOutcome, diagnostic: PreparedDiagnostic | None) -> None:
+        """Publish one launch result now that its commit is visible, with any "no commit was created" message."""
+        if diagnostic is not None:
+            outcome = replace(outcome, status=OperationStatus.PARTIAL, diagnostic=diagnostic)
+        self.reference_form_controller.finish_reference_output(outcome)
+        if outcome.status == OperationStatus.SUCCESS:
+            for step in outcome.steps:
+                message = replay_effect_message(step.effect)
+                if message:
+                    prompt = QMessageBox(QMessageBox.Icon.Information, COMMIT_OPERATION_LABEL, message, QMessageBox.StandardButton.Ok, self.session_registry_controller.window_by_session[session_id])
+                    prepare_message_box(prompt, COMMIT_OPERATION_LABEL)
+                    prompt.finished.connect(lambda _result, prompt=prompt: self._release_replay_message(session_id, prompt))
+                    self._replace_replay_prompt(session_id, prompt)
+                    open_window_modal(prompt)
+                    trace = self.reference_form_controller.reference_trace_by_id.get(outcome.operation_id)
+                    if trace is not None:
+                        trace.append_event(outcome.operation_id, "status", message)
+
+    def observe_replay(self, session_id: str, *, automatic: bool = False, publication: ReplayRefreshPublication | None = None,
+                       auto_continue_request: ReplayAutoContinueRequest | None = None) -> None:
+        """Publish a passive native replay banner only to the original current views.
+
+        ``publication`` is the state an operation just published when it ended: while it is still the service's latest
+        state it is shown as the answer, and no read starts. ``auto_continue_request`` is the automatic Continue request
+        this read is asked for: the complete read that answers it is kept with the request, for that Continue to use.
+        """
+        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
+        key = WorktreeKey.from_context(context)
+        identity = self.session_registry_controller.identity_by_session[session_id]
+        git_filename = self.repository.git_filename
+        # 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.replay_observed_at_by_key.get(key, 0)) * 1000 < REPLAY_REFRESH_INTERVAL_MS:
+            return
+        self.replay_observed_at_by_key[key] = now
+        self.worktree_state_controller.mark_pause_observed(key, REPLAY_PAUSE_OBSERVATION)
+        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 session identity as well as canonical worktree identity."""
+            return (self.session_registry_controller.session_by_id.get(session_id) is session and self.session_registry_controller.identity_by_session.get(session_id) == identity
+                    and not session.is_closed and WorktreeKey.from_context(session.repository_context) == key)
+
+        def complete(state: ReplaySnapshot) -> None:
+            """Refresh all captured current views without opening any auxiliary window."""
+            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 target_session and self.session_registry_controller.identity_by_session.get(target_id) == target_identity
+                        and not target_session.is_closed and window is not None and isValid(window) and not window.is_closed):
+                    self._show_replay_state(target_id, state)
+            if qualifying_request is not None:
+                self._qualify_replay_auto_continue(key, qualifying_request, ReplayResumeObservation(session_id, identity, git_filename, state))
+            self._continue_requested_replay(key)
+            if current():
+                self._retire_legacy_replay_anchors(session_id, state)
+
+        if publication is not None and self._replay_publication_current(key, publication):
+            # Shown for display only: a publication never qualifies an automatic Continue.
+            qualifying_request = None
+            complete(publication.state)
+            return
+        source = self.passive_observation_source(key) if automatic else None
+        # Only a complete read through Git, asked by the request itself, may qualify it.
+        qualifying_request = auto_continue_request if source is None else None
+        # 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
+        if source is None:
+            self.replay.observe(context, git_filename, is_current=current, callback=complete, priority=priority)
+            return
+        self.replay.observe_passive(context, git_filename, source, is_current=current, callback=complete, priority=priority)
+
+    def _retire_legacy_replay_anchors(self, session_id: str, state: ReplaySnapshot) -> None:
+        """Retire, once per repository and run, the anchor references earlier versions left, and tell each working tree once per run about kept backups.
+
+        The retirement waits for a fresh read showing no Cherry-pick or Revert, and a repository another write holds
+        waits for a later read. When an earlier version stopped in the middle of a restoration, its backups stay and
+        every working tree of that repository opened during the run gets a notice naming their folder, including one
+        opened after the retirement already ran for another working tree.
+        """
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None or session.is_closed:
+            return
+        context = session.repository_context
+        if context.is_bare:
+            return
+        common_git_dir = canonical_path(context.common_git_dir)
+        if common_git_dir in self.legacy_replay_checked_common_dir_set:
+            # The notice does not depend on the replay state; before the answer arrives, the retirement's callback tells this window.
+            self._announce_legacy_replay_backups(common_git_dir)
+            return
+        if not state.fresh or state.kind != ReplayKind.ABSENT or state.unmerged_paths or self.replay_writer_busy(context):
+            return
+        self.legacy_replay_checked_common_dir_set.add(common_git_dir)
+        identity = self.session_registry_controller.identity_by_session.get(session_id)
+
+        def current() -> bool:
+            """Require the same open session as when the retirement was asked."""
+            return self.session_registry_controller.session_by_id.get(session_id) is session and self.session_registry_controller.identity_by_session.get(session_id) == identity and not session.is_closed
+
+        def retired(kept_dirs: tuple[str, ...]) -> None:
+            """Keep the answer for the whole run, even when the asking window closed meanwhile, and tell every open working tree of this repository."""
+            self.legacy_replay_kept_dirs_by_common_dir[common_git_dir] = kept_dirs
+            self._announce_legacy_replay_backups(common_git_dir)
+
+        self.replay.retire_legacy_anchors(context, self.repository.git_filename, is_current=current, callback=retired, session_id=session_id,
+                                          generation=self.session_registry_controller.generation_by_session.get(session_id, 0))
+
+    def _announce_legacy_replay_backups(self, common_git_dir: str) -> None:
+        """Name, once per working tree and run, the folder of the backups an earlier version kept for this repository.
+
+        Only windows that manage their working tree are told. The notice stays on the history status line of the
+        window, so that the lines a loading history writes next do not hide it.
+        """
+        kept_dirs = self.legacy_replay_kept_dirs_by_common_dir.get(common_git_dir, ())
+        if not kept_dirs:
+            return
+        notice = LEGACY_REPLAY_BACKUP_NOTICE_PREFIX + os.path.commonpath(kept_dirs) + "."
+        for session_id, session in tuple(self.session_registry_controller.session_by_id.items()):
+            if session.is_closed or WindowCapability.MANAGE not in session.capabilities:
+                continue
+            if canonical_path(session.repository_context.common_git_dir) != common_git_dir:
+                continue
+            key = WorktreeKey.from_context(session.repository_context)
+            window = self.session_registry_controller.window_by_session.get(session_id)
+            if key in self.legacy_replay_notified_worktree_set or window is None or not isValid(window):
+                continue
+            self.legacy_replay_notified_worktree_set.add(key)
+            window.show_status_notice(key, LEGACY_BACKUP_NOTICE_KIND, notice)
+
+    def _show_replay_state(self, session_id: str, state: ReplaySnapshot, *, busy: bool | None = None) -> None:
+        """Publish one observed pause to the repository banner with common writer availability."""
+        window = self.session_registry_controller.window_by_session.get(session_id)
+        if window is None or not isValid(window):
+            return
+        if busy is None:
+            busy = self.replay_writer_busy(window.context)
+        busy = busy or WorktreeKey.from_context(window.context) in self.replay_resume_session_by_key
+        abort_available = callable(getattr(self.replay, "abort", None))
+        window.show_replay_state(state, busy=busy, abort_available=abort_available)
+
+    def replay_actions_changed(self) -> None:
+        """Reconcile action buttons whenever shared writing or tool ownership changes."""
+        busy_by_key = {}
+        for session_id, session in tuple(self.session_registry_controller.session_by_id.items()):
+            if session.is_closed:
+                continue
+            key = WorktreeKey.from_context(session.repository_context)
+            state = self.replay.state_by_key.get(key)
+            if state is not None:
+                if key not in busy_by_key:
+                    busy_by_key[key] = self.replay_writer_busy(session.repository_context)
+                self._show_replay_state(session_id, state, busy=busy_by_key[key])
+                locked = busy_by_key[key] and replay_may_be_present(state)
+                self.conflict_write_availability_changed.emit(session_id, locked)
+        for key in tuple(self.replay_auto_continue_by_key):
+            self._continue_requested_replay(key, busy=busy_by_key.get(key))
+
+    def replay_writer_busy(self, context: RepositoryContext) -> bool:
+        """Tell whether another write or the merge tool currently holds this worktree, which blocks every replay action."""
+        operation = OperationIntent.capture("replay-availability", context, self.repository.git_filename, action=OperationAction.CONFLICT_STAGE)
+        return bool(self.repository_operation.availability_diagnostic(operation)) or self.mergetool.owns_repository(operation.common_git_dir)
+
+    def _qualify_replay_auto_continue(self, key: WorktreeKey, request: ReplayAutoContinueRequest, observation: ReplayResumeObservation) -> None:
+        """Keep the read an automatic request asked for with that request, when the request is still armed and the read is newer than it."""
+        if self.replay_auto_continue_by_key.get(key) is not request or observation.state.key != key or observation.state.generation <= request.known_generation:
+            return
+        self.replay_auto_continue_by_key[key] = replace(request, observation=observation)
+
+    def _replay_resume_observation_holds(self, observation: ReplayResumeObservation, session_id: str, state: ReplaySnapshot) -> bool:
+        """Tell whether a qualifying read still describes this very pause for this session, so a Continue may use it instead of reading again.
+
+        It must be this state object, for this session under the same request identity and Git executable, and still the
+        service's latest state of its worktree with no read started since; a window closing or leaving refuses it.
+        """
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        key = state.key
+        return (observation.session_id == session_id and observation.state is state and session is not None and not session.is_closed
+                and WorktreeKey.from_context(session.repository_context) == key and self.session_registry_controller.identity_by_session.get(session_id) == observation.identity
+                and observation.git_filename == self.repository.git_filename and self.replay.state_by_key.get(key) is state
+                and self.replay.generation_by_key.get(key) == state.generation and key not in self.replay.observers_by_key
+                and not self.replay_session_leaving(session_id))
+
+    def _take_auto_continue_observation(self, session_id: str, state: ReplaySnapshot) -> ReplayResumeObservation | None:
+        """Take the armed automatic request of this worktree, so it starts one Continue at most, and answer its read while that still holds."""
+        request = self.replay_auto_continue_by_key.pop(state.key, None)
+        if request is None or request.observation is None or request.session_id != session_id:
+            return None
+        if not self._replay_resume_observation_holds(request.observation, session_id, state):
+            return None
+        return request.observation
+
+    def replay_session_leaving(self, session_id: str) -> bool:
+        """Tell whether the user asked to close, quit or leave this repository window, which must not start a new Continue on its own."""
+        return self.session_registry_controller.quit_pending or session_id in self.session_registry_controller.close_session_set or session_id in self.session_registry_controller.navigation_request_by_session
+
+    def _continue_requested_replay(self, key: WorktreeKey, *, busy: bool | None = None) -> None:
+        """Start the requested automatic Continue once, only when a newer read qualifies and nothing holds the worktree.
+
+        A read older than the request is ignored. A busy worktree keeps the request for the next read or availability
+        change. Any other newer state ends the request, starting Continue only when every conflict is solved. A request
+        that starts its Continue stays armed until that Continue takes it, with the read that qualified it.
+        """
+        request = self.replay_auto_continue_by_key.get(key)
+        if request is None:
+            return
+        session = self.session_registry_controller.session_by_id.get(request.session_id)
+        if session is None or session.is_closed or WorktreeKey.from_context(session.repository_context) != key or self.replay_session_leaving(request.session_id):
+            self.replay_auto_continue_by_key.pop(key, None)
+            return
+        state = self.replay.state_by_key.get(key)
+        if state is None or state.generation <= request.known_generation:
+            return
+        if busy is None:
+            busy = self.replay_writer_busy(session.repository_context)
+        if busy:
+            return
+        ready = replay_auto_continue_ready(state)
+        if not ready:
+            self.replay_auto_continue_by_key.pop(key, None)
+        if self.diagnostic_log is not None:
+            decision = "starting Continue" if ready else "Continue left to the user (" + (state.diagnostic or "conflicts remain or the commit mode is unknown") + ")"
+            self.diagnostic_log.write(Diagnostic("Automatic replay continue", session.repository_context.repository_dir, self.repository.git_filename, [],
+                                                 "Conflict resolution finished in GitPane: " + decision + ".").prepare())
+        if ready:
+            self.continue_replay(request.session_id, state, automatic=True)
+            # The Continue takes the request before it submits anything; should it not have, the request still ends here,
+            # so that it can never start a second Continue.
+            remaining = self.replay_auto_continue_by_key.get(key)
+            if remaining is not None and (remaining.session_id, remaining.known_generation) == (request.session_id, request.known_generation):
+                del self.replay_auto_continue_by_key[key]
+
+    def _replace_replay_prompt(self, session_id: str, prompt: ReplayConflictPrompt | QMessageBox) -> None:
+        """Keep one replay question or message per session, closing and deleting the one it replaces."""
+        previous = self.replay_prompt_by_session.get(session_id)
+        if previous is not None and previous is not prompt and isValid(previous):
+            previous.close()
+            previous.deleteLater()
+        self.replay_prompt_by_session[session_id] = prompt
+
+    def _release_replay_message(self, session_id: str, prompt: QMessageBox) -> None:
+        """Forget and delete an answered "no commit was created" message instead of keeping it under the window."""
+        if self.replay_prompt_by_session.get(session_id) is prompt:
+            del self.replay_prompt_by_session[session_id]
+        if isValid(prompt):
+            prompt.deleteLater()
+
+    def _offer_replay_resolution(self, session_id: str, state: ReplaySnapshot, operation_id: str) -> None:
+        """Ask once after a locally launched conflict independently of other prompt preferences.
+
+        The launch console already closed on the pause unless Keep dialog open is checked. Whatever the answer (Yes,
+        No, Escape or the title-bar close), that console has done its job and is settled, so unchecking the option later
+        still closes it.
+        """
+        prompt = ReplayConflictPrompt(self.session_registry_controller.window_by_session[session_id])
+        self._replace_replay_prompt(session_id, prompt)
+        prompt.resolve_requested.connect(lambda: self.resolve_replay(session_id, state))
+        prompt.finished.connect(lambda _result: self.console_registry_controller.settle_answered_console(operation_id))
+
+        def present() -> None:
+            """Bring the prompt to the front after the console has published the pause."""
+            if not isValid(prompt) or self.replay_prompt_by_session.get(session_id) is not prompt:
+                return
+            prompt.show()
+            prompt.raise_()
+            prompt.activateWindow()
+
+        # The console publishes its pause from a zero timer queued just before this one; presenting the prompt
+        # afterwards keeps the console from ending up in front of it.
+        QTimer.singleShot(0, present)
+
+    def resolve_replay(self, session_id: str, state: ReplaySnapshot) -> None:
+        """Refresh the existing conflict list before opening it; never launch a tool here."""
+        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):
+            return
+        self.session_registry_controller.replay_pending_resolve_set.add(session_id)
+        self.staging_session_registry_controller.staging_session(context).refresh(explicit=True)
+        self.observe_replay(session_id)
+
+    def continue_replay(self, session_id: str, state: ReplaySnapshot, *, automatic: bool = False) -> None:
+        """Relate a Continue to its original pause and a new write reservation.
+
+        ``automatic`` marks the Continue GitPane starts by itself after the last conflict was solved in its own list;
+        it goes through exactly the same checks as the button and says so in its console. It takes the armed request
+        of its worktree, and submits the read that qualified it instead of reading the pause again while that read holds.
+        """
+        observed = self._take_auto_continue_observation(session_id, state) if automatic else None
+        self._submit_replay_resume(session_id, state, abort=False, automatic=automatic, observed=observed)
+
+    def _submit_replay_resume(self, session_id: str, state: ReplaySnapshot, *, abort: bool, automatic: bool = False,
+                              observed: ReplayResumeObservation | None = None) -> None:
+        """Reobserve before submitting, keeping changed identities and active tools refused.
+
+        ``observed`` is the read that qualified an automatic Continue of this very pause: it is checked the same way as
+        a reread and handed to the service in its place while it still holds; otherwise the pause is read again. The
+        service captures the pause twice again inside its reservation either way.
+        """
+        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
+        git_filename = self.repository.git_filename
+        if state.key != WorktreeKey.from_context(context):
+            return
+        action = ReplayAction.ABORT if abort else ReplayAction.CONTINUE
+        resume = getattr(self.replay, "abort" if abort else "continue_replay", None)
+        diagnostic = replay_action_diagnostic(state, action, busy=self.mergetool.owns_repository(context.common_git_dir), abort_available=callable(resume))
+        if diagnostic or not callable(resume):
+            self.session_registry_controller.window_by_session[session_id].statusBar().showMessage(diagnostic or "This recovery action is unavailable.")
+            return
+        key = state.key
+        if key in self.replay_resume_session_by_key:
+            self.session_registry_controller.window_by_session[session_id].statusBar().showMessage("A Continue or Abort of this commit operation is already starting.")
+            return
+        self.replay_resume_session_by_key[key] = session_id
+        self.replay_actions_changed()
+
+        def current() -> bool:
+            """Hold session and tool ownership until the service's final launch check."""
+            return (self.session_registry_controller.session_by_id.get(session_id) is session and not session.is_closed and self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE)
+                    and session.repository_context == context and self.repository.git_filename == git_filename
+                    and not self.mergetool.owns_repository(context.common_git_dir))
+
+        def read_current() -> bool:
+            """Release the starting mark when the reread is dropped, so the banner does not stay disabled."""
+            if current():
+                return True
+            self._release_replay_resume(key, session_id)
+            return False
+
+        def complete(observed: ReplaySnapshot) -> None:
+            """Refuse a different pause rather than applying a click to replacement metadata."""
+            try:
+                submit(observed)
+            finally:
+                self._release_replay_resume(key, session_id)
+
+        def submit(observed: ReplaySnapshot) -> None:
+            """Open the console and hand the checked pause to the service, which reserves the repository."""
+            if not current():
+                return
+            if (observed.identity != state.identity or observed.head_oid != state.head_oid or observed.symbolic_ref != state.symbolic_ref
+                    or observed.launch != state.launch or replay_action_diagnostic(observed, action, abort_available=callable(resume))):
+                self._show_replay_state(session_id, observed)
+                self.session_registry_controller.window_by_session[session_id].statusBar().showMessage("The commit operation changed. Review its current state before trying again.")
+                return
+            operation = OperationIntent.capture(uuid.uuid4().hex, context, self.repository.git_filename, session_id=session_id,
+                                                generation=self.session_registry_controller.generation_by_session[session_id], operation="Abort replay" if abort else "Continue replay",
+                                                action=OperationAction.REPLAY_ABORT if abort else OperationAction.REPLAY_CONTINUE)
+            # A pause GitPane launched in this run keeps the source and the choices of its form; any other one is named by Git's instruction.
+            launch = observed.launch
+            source_oid = launch.source_oid if launch is not None else next(iter(observed.instruction_oids))
+            add_reference = launch.add_reference if launch is not None else False
+            intent = ReplayIntent(operation, observed.kind, source_oid, observed.head_oid, observed.symbolic_ref, create_commit=observed.mode == ReplayCommitMode.COMMIT,
+                                  add_reference=add_reference)
+            self.replay_intent_by_id[operation.operation_id] = intent
+            self.reference_form_controller.open_reference_output(intent, None, modal=False)
+            trace = self.reference_form_controller.reference_trace_by_id.get(operation.operation_id)
+            if automatic and trace is not None:
+                trace.append_event(operation.operation_id, "status", REPLAY_AUTO_CONTINUE_TEXT)
+            resume(operation, observed, is_current=current)
+
+        if observed is None:
+            self.replay.observe(context, self.repository.git_filename, is_current=read_current, callback=complete)
+            return
+        qualified = observed
+
+        def hand_over_qualified_read() -> None:
+            """Submit with the qualifying read while it still holds, or read the pause again as for a click."""
+            if not read_current():
+                return
+            if self._replay_resume_observation_holds(qualified, session_id, qualified.state):
+                complete(qualified.state)
+                return
+            self.replay.observe(context, self.repository.git_filename, is_current=read_current, callback=complete)
+
+        # Handed over on the next turn of the event loop, the way a read answers: until then the starting mark stays set,
+        # so a banner click in between is refused as for a Continue already starting.
+        QTimer.singleShot(0, self, hand_over_qualified_read)
+
+    def _release_replay_resume(self, key: WorktreeKey, session_id: str) -> None:
+        """End the starting mark of a Continue or Abort once it reserved the repository or gave up, then refresh the buttons.
+
+        The buttons are refreshed from a zero timer because this can run while the replay service is still publishing a read.
+        """
+        if self.replay_resume_session_by_key.get(key) != session_id:
+            return
+        del self.replay_resume_session_by_key[key]
+        QTimer.singleShot(0, self, self.replay_actions_changed)
+
+    def passive_observation_source(self, key: WorktreeKey) -> PassiveObservationSource | None:
+        """Answer what the automatic refresh of this worktree has just read, or nothing when the observation must read through Git."""
+        # While a Continue or an Abort waits for its decision, that decision is taken on a state read through Git.
+        if key in self.replay_auto_continue_by_key or key in self.replay_resume_session_by_key:
+            return None
+        staging = self.staging_session_registry_controller.staging_by_key.get(key)
+        if staging is None:
+            return None
+        return staging.passive_observation_source()
+
+    def request_replay_auto_continue(self, session_id: str, key: WorktreeKey) -> None:
+        """Ask to continue a Cherry-pick or Revert once a new read proves that its last conflict is solved.
+
+        Only a resolution made in GitPane's conflict list or merge tool series calls this; nothing here runs on a passive
+        refresh or a reopening. The pause may have been started by GitPane or in a terminal: the newer read decides, and
+        only a pause the banner Continue accepts (known commit mode) is continued.
+        """
+        state = self.replay.state_by_key.get(key)
+        if not replay_may_be_present(state) or session_id not in self.session_registry_controller.session_by_id or self.replay_session_leaving(session_id):
+            return
+        request = ReplayAutoContinueRequest(session_id, self.replay.generation_by_key.get(key, 0))
+        self.replay_auto_continue_by_key[key] = request
+        self.observe_replay(session_id, auto_continue_request=request)
+
+    def abort_replay(self, session_id: str, state: ReplaySnapshot) -> None:
+        """Submit Git's own Abort of the pause the banner shows, after the same checks as Continue."""
+        self._submit_replay_resume(session_id, state, abort=True)