Auto-refresh PR diffs when GitHub head/base SHAs move

When DiffViewer is showing a GitHub pull request, the diff was previously
frozen at the SHAs the resolver pinned on launch. Force-pushing the PR
or advancing the base branch had no visible effect until the user
relaunched. This commit ships PR auto-refresh end-to-end in three
phases, all in one ship:

Phase 1 - Manual refresh extension. The existing F5 (RefreshCommand)
now also kicks IPullRequestWatcher.RequestImmediatePoll in PR mode
before re-running the change-list enumerate; the existing title-bar
toast continues to confirm the action.

Phase 2 - Periodic polling. A new IPullRequestWatcher (sibling to
IRepositoryWatcher) polls GitHub's PR endpoint via an ETag-aware
GetPullRequestPolledAsync addition to IGitHubClient. The coordinator
subscribes to Changed events and rebuilds the context via the existing
SwitchContextCoreAsync path when head or base SHAs move - the same
atomic-swap recents-row clicks use. Lifecycle changes (closed / merged)
surface as toasts without rebuilding. PullRequestAutoRefresh and
PullRequestPollIntervalSeconds (default 300s, clamp 30..3600) ship as
new AppSettings fields (schema v10), exposed in the Settings dialog
under a new Pull requests section. The toolbar Live ToggleButton is
context-aware: in PR mode it routes to PullRequestAutoRefresh; in
working-tree mode it routes to LiveUpdates. Ctrl+L follows the same
routing.

Phase 3 - Polish. IWindowVisibilityProbe pauses polling while the
window is hidden (restoring visibility kicks one immediate poll).
X-RateLimit-Remaining < 100 triggers 4x backoff. 401/403 stops polling
permanently with a one-time toast carrying the GitHub message.
Conditional-get via If-None-Match keeps unchanged polls to one
round-trip with zero body bytes. Recents recording is suppressed on
auto-refresh - only initial open and explicit re-clicks update the
timestamp.

45 new tests across PullRequestWatcherTests (poll cadence, snapshot
diff, suspend semantics, visibility pause, rate-limit backoff,
terminal stop), PullRequestAutoRefreshSettingsTests (round-trip,
clamp, v9->v10 migration), GitHubClientTests (304, ETag, rate-limit
header), MainWindowCoordinatorTests (subscription wiring, rebuild on
SHA move with no recents re-record, toast-only paths), and
MainViewModelKeyboardShortcutTests (F5 calls RequestImmediatePoll,
Ctrl+L routes correctly in PR mode, re-enabling kicks one poll).

Also fixes a latent bug in the shared test-helper ManualTimer that
clobbered a callback-re-armed schedule with the post-callback
"one-shot done" branch; existing tests don't trigger it because
RepositoryEventDebouncer's callback never re-arms its own timer.

AI-Local-Session: 6df9761f-b968-469a-87e4-376987d4353a
AI-Cloud-Session: 4080c61e-0c31-4ba9-9c66-2bbaf6fb6bf6
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Geeven Singh

CHANGELOG.md

@@ -12,6 +12,26 @@ body. Keep section headings exact and write notes in Markdown.
 
 ## [Unreleased]
 
+### Added
+
+- **Pull-request auto-refresh.** When DiffViewer is showing a GitHub
+  pull request, it now polls GitHub's REST API for head/base SHA
+  shifts and PR lifecycle transitions (open/closed/merged) on a
+  configurable interval (default 5 minutes; clamped 30 s..1 h). When
+  the head or base SHA moves — typically a force-push or a new commit
+  to either side — the diff is automatically rebuilt with the new
+  SHAs and a title-bar toast announces what changed. Lifecycle
+  transitions ("This PR is now merged.") surface as toasts without
+  rebuilding the diff. F5 always forces an immediate poll, regardless
+  of the auto-refresh toggle state. The toolbar **Live** button is
+  context-aware: in PR mode it controls auto-polling; in working-tree
+  mode it controls the existing FSW-driven refresh. Both settings
+  persist independently so toggling one does not affect the other.
+  Polling is paused while the main window is hidden, backs off on
+  GitHub rate-limit pressure, and stops after a terminal 401/403 with
+  a one-time toast. Settings dialog exposes both the toggle and the
+  interval under a new "Pull requests" section.
+
 ## [1.8.0] - 2026-06-06
 
 ### Added

DiffViewer.Tests/MainWindowCoordinatorTests.cs

@@ -222,7 +222,8 @@ public async Task InitialLaunchAsync_ParseFailure_WithRecents_FallsBackToEmptyCo
         recents.SeededItems.Add(MakeContext(@"C:\repos\foo", "main"));
         var services = new AppServices(
             new SettingsService(), new DiffService(), new ExternalAppLauncher(null), recents,
-            new FakePullRequestResolver(), new FakeMissingClonePromptHost(), new FakeNewDiffDialogHost());
+            new FakePullRequestResolver(), new FakeMissingClonePromptHost(), new FakeNewDiffDialogHost(),
+            new StubGitHubClient(), new StubPullRequestLocalFetcher(), new StubWindowVisibilityProbe());
 
         var coordinator = new MainWindowCoordinator(
             services, dialog, default, shutdownAction: c => exitCode = c);
@@ -456,11 +457,11 @@ public async Task SwitchContextAsync_PopulatesSwitchingStatusInFlight_AndClearsO
         bool? isSwitchingInFlight = null;
         var coordinator = new MainWindowCoordinator(
             services, dialog, shutdownAction: _ => { },
-            contextFactory: async (p, s, sc, ct) =>
+            contextFactory: async (p, s, sc, ct, review) =>
             {
                 statusInFlight ??= coordinatorRef!.SwitchingStatus;
                 isSwitchingInFlight ??= coordinatorRef!.IsSwitching;
-                return await CompositionRoot.BuildContextAsync(p, s, sc, ct);
+                return await CompositionRoot.BuildContextAsync(p, s, sc, ct, review);
             });
         coordinatorRef = coordinator;
 
@@ -489,14 +490,14 @@ public async Task SwitchContextAsync_OnContextBuildFailure_ClearsSwitchingStatus
         bool factoryHasThrown = false;
         var coordinator = new MainWindowCoordinator(
             services, dialog, shutdownAction: _ => { },
-            contextFactory: (p, s, sc, ct) =>
+            contextFactory: (p, s, sc, ct, review) =>
             {
                 if (!factoryHasThrown)
                 {
                     // First call (StartFromParsedAsync below) succeeds so
                     // there's a real outgoing context. Second call (the
                     // SwitchContextAsync under test) throws.
-                    return CompositionRoot.BuildContextAsync(p, s, sc, ct);
+                    return CompositionRoot.BuildContextAsync(p, s, sc, ct, review);
                 }
                 throw new ContextBuildException("simulated build failure");
             });
@@ -572,7 +573,10 @@ private static AppServices BuildServices(
             recents,
             prResolver,
             prompt,
-            new FakeNewDiffDialogHost());
+            new FakeNewDiffDialogHost(),
+            new StubGitHubClient(),
+            new StubPullRequestLocalFetcher(),
+            new StubWindowVisibilityProbe());
     }
 
     private static TempRepo MakeRepoWithCommit()
@@ -674,6 +678,34 @@ internal sealed class FakeNewDiffDialogHost : INewDiffDialogHost
         }
     }
 
+    internal sealed class StubGitHubClient : IGitHubClient
+    {
+        public Task<DiffViewer.Services.PullRequestInfo> GetPullRequestAsync(
+            DiffViewer.Models.PullRequestRef pr, System.Threading.CancellationToken ct)
+            => throw new NotSupportedException("PR mode not exercised by these tests.");
+
+        public Task<DiffViewer.Models.PullRequestPolledResult> GetPullRequestPolledAsync(
+            DiffViewer.Models.PullRequestRef pr, string? ifNoneMatch, System.Threading.CancellationToken ct)
+            => throw new NotSupportedException("PR mode not exercised by these tests.");
+    }
+
+    internal sealed class StubPullRequestLocalFetcher : IPullRequestLocalFetcher
+    {
+        public Task<DiffViewer.Services.PullRequestFetchResult> FetchAsync(
+            string repoPath, DiffViewer.Services.PullRequestInfo info, System.Threading.CancellationToken ct)
+            => throw new NotSupportedException("PR mode not exercised by these tests.");
+    }
+
+    internal sealed class StubWindowVisibilityProbe : IWindowVisibilityProbe
+    {
+        public bool IsVisible => true;
+        public event EventHandler? VisibilityChanged
+        {
+            add { _ = value; }
+            remove { _ = value; }
+        }
+    }
+
     // ---- IsStashRef tests ----
 
     [Theory]
@@ -695,4 +727,214 @@ public void IsStashRef_WorkingTree_ReturnsFalse()
     {
         MainWindowCoordinator.IsStashRef(new DiffSide.WorkingTree()).Should().BeFalse();
     }
+
+    // ===================== PR auto-refresh subscription =====================
+
+    private static PullRequestRef SamplePr() => new("github.com", "owner", "repo", 42);
+
+    [Fact]
+    public async Task SwitchToGitHubPullRequest_SubscribesToWatcherChanged_AndStartsIt()
+    {
+        using var repo = MakeRepoWithCommit();
+        var services = BuildServices(out _, out var prResolver, out _);
+
+        // Resolver returns Ready with the repo path the test owns.
+        // Use HEAD (the only known ref in MakeRepoWithCommit) so the
+        // initial LoadInitialChangesAsync succeeds.
+        prResolver.Results.Enqueue(new PullRequestResolution.Ready(
+            new ParsedCommandLine(repo.Path, new DiffSide.CommitIsh("HEAD"), new DiffSide.CommitIsh("HEAD")),
+            SamplePr()));
+
+        var prWatchers = new List<RecordingPullRequestWatcher>();
+        var coordinator = new MainWindowCoordinator(
+            services, new FakeDialog(), default,
+            contextFactory: (parsed, svc, scope, ct, review) =>
+                BuildVmWithWatcher(parsed, svc, scope, ct, review, prWatchers));
+
+        var ok = await coordinator.SwitchToAsync(
+            new DiffLaunchSource.GitHubPullRequest(SamplePr()));
+
+        ok.Should().BeTrue();
+        prWatchers.Should().ContainSingle();
+        prWatchers[0].StartCount.Should().Be(1);
+        prWatchers[0].ChangedSubscriberCount.Should().Be(1,
+            "the coordinator must subscribe to Changed after a successful PR swap");
+
+        await coordinator.DisposeCurrentAsync();
+    }
+
+    [Fact]
+    public async Task PullRequestWatcher_FiresHeadMoved_TriggersContextRebuild_WithoutRecordsing()
+    {
+        using var repo = MakeRepoWithCommit();
+        var services = BuildServices(out var recents, out var prResolver, out _);
+
+        // Initial swap uses HEAD; auto-refresh rebuild uses HEAD too —
+        // both must resolve. Real PR rebuilds receive real SHAs from
+        // the watcher's snapshot; here we use HEAD so libgit2 is happy.
+        prResolver.Results.Enqueue(new PullRequestResolution.Ready(
+            new ParsedCommandLine(repo.Path, new DiffSide.CommitIsh("HEAD"), new DiffSide.CommitIsh("HEAD")),
+            SamplePr()));
+
+        var prWatchers = new List<RecordingPullRequestWatcher>();
+        var coordinator = new MainWindowCoordinator(
+            services, new FakeDialog(), default,
+            contextFactory: (parsed, svc, scope, ct, review) =>
+                BuildVmWithWatcher(parsed, svc, scope, ct, review, prWatchers));
+
+        (await coordinator.SwitchToAsync(new DiffLaunchSource.GitHubPullRequest(SamplePr())))
+            .Should().BeTrue();
+        recents.RecordedRepoPaths.Count.Should().Be(1, "initial swap records");
+
+        // Watcher detects a head move. The watcher's pre-resolved
+        // snapshot carries the SHAs the rebuild will use — point them
+        // at HEAD so libgit2 can resolve them in the rebuild path.
+        var snapshot = new RemoteRefSnapshot("HEAD", "HEAD");
+        prWatchers[0].RaiseChanged(new PullRequestChangedEventArgs(
+            PullRequestChangeKind.HeadMoved,
+            NewInfo: null,
+            NewSnapshot: snapshot,
+            FailureMessage: null,
+            UtcTimestamp: DateTime.UtcNow));
+
+        // Auto-refresh rebuilds via SwitchContextCoreAsync → a SECOND
+        // contextFactory call with the new SHAs.
+        prWatchers.Should().HaveCount(2,
+            "the auto-refresh path must produce a new VM with a new watcher");
+        recents.RecordedRepoPaths.Count.Should().Be(1,
+            "auto-refresh must NOT re-record the recents row (decision 5)");
+
+        await coordinator.DisposeCurrentAsync();
+    }
+
+    [Fact]
+    public async Task PullRequestWatcher_FiresStateChanged_TogglesToast_WithoutRebuild()
+    {
+        using var repo = MakeRepoWithCommit();
+        var services = BuildServices(out _, out var prResolver, out _);
+
+        prResolver.Results.Enqueue(new PullRequestResolution.Ready(
+            new ParsedCommandLine(repo.Path, new DiffSide.CommitIsh("HEAD"), new DiffSide.CommitIsh("HEAD")),
+            SamplePr()));
+
+        var prWatchers = new List<RecordingPullRequestWatcher>();
+        var coordinator = new MainWindowCoordinator(
+            services, new FakeDialog(), default,
+            contextFactory: (parsed, svc, scope, ct, review) =>
+                BuildVmWithWatcher(parsed, svc, scope, ct, review, prWatchers));
+
+        (await coordinator.SwitchToAsync(new DiffLaunchSource.GitHubPullRequest(SamplePr())))
+            .Should().BeTrue();
+        var toasts = new List<string>();
+        ((MainViewModel)coordinator.Current!).ToastHandler = toasts.Add;
+
+        var info = new DiffViewer.Services.PullRequestInfo(
+            Number: 42, Title: "t", State: "closed", Merged: true,
+            BaseRef: "main", BaseSha: "BASE", HeadRef: "feat", HeadSha: "HEAD",
+            HeadRepoCloneUrl: "u", BaseRepoCloneUrl: "u");
+
+        prWatchers[0].RaiseChanged(new PullRequestChangedEventArgs(
+            PullRequestChangeKind.StateChanged,
+            NewInfo: info,
+            NewSnapshot: null,
+            FailureMessage: null,
+            UtcTimestamp: DateTime.UtcNow));
+
+        prWatchers.Should().HaveCount(1,
+            "lifecycle changes must not rebuild the context");
+        toasts.Should().ContainSingle().Which.Should().Contain("merged");
+
+        await coordinator.DisposeCurrentAsync();
+    }
+
+    [Fact]
+    public async Task PullRequestWatcher_FiresPollFailed_Toasts_WithoutRebuild()
+    {
+        using var repo = MakeRepoWithCommit();
+        var services = BuildServices(out _, out var prResolver, out _);
+
+        prResolver.Results.Enqueue(new PullRequestResolution.Ready(
+            new ParsedCommandLine(repo.Path, new DiffSide.CommitIsh("HEAD"), new DiffSide.CommitIsh("HEAD")),
+            SamplePr()));
+
+        var prWatchers = new List<RecordingPullRequestWatcher>();
+        var coordinator = new MainWindowCoordinator(
+            services, new FakeDialog(), default,
+            contextFactory: (parsed, svc, scope, ct, review) =>
+                BuildVmWithWatcher(parsed, svc, scope, ct, review, prWatchers));
+
+        (await coordinator.SwitchToAsync(new DiffLaunchSource.GitHubPullRequest(SamplePr())))
+            .Should().BeTrue();
+        var toasts = new List<string>();
+        ((MainViewModel)coordinator.Current!).ToastHandler = toasts.Add;
+
+        prWatchers[0].RaiseChanged(new PullRequestChangedEventArgs(
+            PullRequestChangeKind.PollFailed,
+            NewInfo: null,
+            NewSnapshot: null,
+            FailureMessage: "GitHub rejected the auth token.",
+            UtcTimestamp: DateTime.UtcNow));
+
+        prWatchers.Should().HaveCount(1, "terminal failures don't rebuild");
+        toasts.Should().ContainSingle().Which.Should().Contain("rejected the auth token");
+
+        await coordinator.DisposeCurrentAsync();
+    }
+
+    private static async Task<MainViewModel> BuildVmWithWatcher(
+        ParsedCommandLine parsed,
+        AppServices services,
+        ContextScope scope,
+        System.Threading.CancellationToken ct,
+        IReviewRef? review,
+        List<RecordingPullRequestWatcher> sink)
+    {
+        var repo = new RepositoryService(parsed.RepoPath);
+        scope.Register(repo);
+
+        RecordingPullRequestWatcher? watcher = null;
+        if (review is PullRequestRef)
+        {
+            watcher = new RecordingPullRequestWatcher();
+            sink.Add(watcher);
+            scope.Register(watcher);
+        }
+
+        var vm = new MainViewModel(
+            repository: repo,
+            left: parsed.Left,
+            right: parsed.Right,
+            scope: scope,
+            pullRequestWatcher: watcher);
+
+        await vm.LoadInitialChangesAsync(ct).ConfigureAwait(true);
+        return vm;
+    }
+
+    internal sealed class RecordingPullRequestWatcher : IPullRequestWatcher
+    {
+        public int StartCount { get; private set; }
+        public int ImmediatePollCount { get; private set; }
+        public bool Disposed { get; private set; }
+        public int ChangedSubscriberCount { get; private set; }
+        private EventHandler<PullRequestChangedEventArgs>? _changed;
+
+        public event EventHandler<PullRequestChangedEventArgs>? Changed
+        {
+            add { _changed += value; ChangedSubscriberCount++; }
+            remove { _changed -= value; ChangedSubscriberCount--; }
+        }
+
+        public void Start() => StartCount++;
+        public IDisposable Suspend() => new NoopToken();
+        public void RequestImmediatePoll() => ImmediatePollCount++;
+        public void Dispose() => Disposed = true;
+
+        public void RaiseChanged(PullRequestChangedEventArgs args) => _changed?.Invoke(this, args);
+
+        private sealed class NoopToken : IDisposable
+        {
+            public void Dispose() { }
+        }
+    }
 }