diff --git a/CHANGELOG.md b/CHANGELOG.md
index 93e2b42..0328e5f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,17 @@ version numbers, because that is what those releases were called.
 
 ## [Unreleased]
 
+### Fixed: WPF lifecycle-safe navigation
+
+- Added explicit Timeline and Advanced history destinations to the command bar so every read-only
+  snapshot workspace is reachable and users can always leave Compare.
+- Cancelled and cleared an active comparison before user-driven navigation, including when the same
+  snapshot is opened again later.
+- Disabled workspace navigation while backup or restore work is running, and prevented the final WPF
+  window from closing until the active run finishes or is cancelled.
+- Moved Advanced history catalog reads off the UI thread so a slow disk or large snapshot collection
+  does not freeze the window.
+
 ### Added — WPF Timeline + Compare shell (side-by-side with WinForms)
 
 A new WPF application (`WinRestoreKit.Wpf`) ships alongside the existing WinForms app, implementing the
diff --git a/src/WinRestoreKit.Tests/AdvancedHistoryViewModelTests.cs b/src/WinRestoreKit.Tests/AdvancedHistoryViewModelTests.cs
index 0643580..49fb4bf 100644
--- a/src/WinRestoreKit.Tests/AdvancedHistoryViewModelTests.cs
+++ b/src/WinRestoreKit.Tests/AdvancedHistoryViewModelTests.cs
@@ -18,37 +18,60 @@ public sealed class AdvancedHistoryViewModelTests
         [Fact]
         public async Task SearchText_FiltersTheSharedProjectionByDisplayMachinePathAndStatus()
         {
-            SnapshotEvent verified = NewEvent(SnapshotEventKind.Verified, @"C:\history\alpha", "ALPHA-PC");
-            SnapshotEvent partial = NewEvent(SnapshotEventKind.Partial, @"C:\history\bravo", "BRAVO-PC");
-            SnapshotEvent failed = NewEvent(SnapshotEventKind.Failed, @"C:\history\charlie", "CHARLIE-PC", "disk full");
-            FakeCatalog catalog = new FakeCatalog(verified, partial, failed);
-            AdvancedHistoryViewModel history = new AdvancedHistoryViewModel(catalog);
-
-            await history.RefreshAsync();
-
-            AssertVisible(history, verified, "alpha");
-            AssertVisible(history, partial, "BRAVO-PC");
-            AssertVisible(history, partial, "history\\bravo");
-            AssertVisible(history, partial, "partial snapshot");
+            await WpfTestHost.RunAsync(async () =>
+            {
+                SnapshotEvent verified = NewEvent(SnapshotEventKind.Verified, @"C:\history\alpha", "ALPHA-PC");
+                SnapshotEvent partial = NewEvent(SnapshotEventKind.Partial, @"C:\history\bravo", "BRAVO-PC");
+                SnapshotEvent failed = NewEvent(SnapshotEventKind.Failed, @"C:\history\charlie", "CHARLIE-PC", "disk full");
+                FakeCatalog catalog = new FakeCatalog(verified, partial, failed);
+                AdvancedHistoryViewModel history = new AdvancedHistoryViewModel(catalog);
+
+                await history.RefreshAsync();
+
+                AssertVisible(history, verified, "alpha");
+                AssertVisible(history, partial, "BRAVO-PC");
+                AssertVisible(history, partial, "history\\bravo");
+                AssertVisible(history, partial, "partial snapshot");
+            });
         }
 
         [Fact]
         public async Task RefreshAsync_ReusesTheSameStableStatusProjectionAsTimeline()
         {
-            SnapshotEvent failed = NewEvent(SnapshotEventKind.Failed, @"C:\history\failed", "TEST-PC", "disk full");
-            FakeCatalog catalog = new FakeCatalog(failed);
-            TimelineViewModel timeline = new TimelineViewModel(
-                catalog, new FakePreparationService(), new RecordingNavigator());
-            AdvancedHistoryViewModel history = new AdvancedHistoryViewModel(catalog);
-
-            await timeline.RefreshAsync();
-            await history.RefreshAsync();
-
-            SnapshotEventViewModel timelineEvent = Assert.Single(timeline.Events);
-            SnapshotEventViewModel historyEvent = Assert.Single(history.Events.Cast<SnapshotEventViewModel>());
-            Assert.Same(timelineEvent.Status, historyEvent.Status);
-            Assert.Equal("Backup failed", historyEvent.Status.Label);
-            Assert.Equal("disk full", historyEvent.DiagnosticReason);
+            await WpfTestHost.RunAsync(async () =>
+            {
+                SnapshotEvent failed = NewEvent(SnapshotEventKind.Failed, @"C:\history\failed", "TEST-PC", "disk full");
+                FakeCatalog catalog = new FakeCatalog(failed);
+                TimelineViewModel timeline = new TimelineViewModel(
+                    catalog, new FakePreparationService(), new RecordingNavigator());
+                AdvancedHistoryViewModel history = new AdvancedHistoryViewModel(catalog);
+
+                await timeline.RefreshAsync();
+                await history.RefreshAsync();
+
+                SnapshotEventViewModel timelineEvent = Assert.Single(timeline.Events);
+                SnapshotEventViewModel historyEvent = Assert.Single(history.Events.Cast<SnapshotEventViewModel>());
+                Assert.Same(timelineEvent.Status, historyEvent.Status);
+                Assert.Equal("Backup failed", historyEvent.Status.Label);
+                Assert.Equal("disk full", historyEvent.DiagnosticReason);
+            });
+        }
+
+        [Fact]
+        public async Task RefreshAsync_ReadsTheCatalogAwayFromTheUiThread()
+        {
+            await WpfTestHost.RunAsync(async () =>
+            {
+                int uiThreadId = Thread.CurrentThread.ManagedThreadId;
+                FakeCatalog catalog = new FakeCatalog(
+                    NewEvent(SnapshotEventKind.Verified, @"C:\history\alpha", "ALPHA-PC"));
+                AdvancedHistoryViewModel history = new AdvancedHistoryViewModel(catalog);
+
+                await history.RefreshAsync();
+
+                Assert.NotEqual(uiThreadId, catalog.ReadThreadId);
+                Assert.Single(history.Events.Cast<SnapshotEventViewModel>());
+            });
         }
 
         private static void AssertVisible(AdvancedHistoryViewModel history, SnapshotEvent expected, string search)
@@ -68,7 +91,13 @@ private sealed class FakeCatalog : ISnapshotEventReader
 
             internal FakeCatalog(params SnapshotEvent[] events) => this.events = events;
 
-            public IReadOnlyList<SnapshotEvent> Read() => events;
+            internal int ReadThreadId { get; private set; }
+
+            public IReadOnlyList<SnapshotEvent> Read()
+            {
+                ReadThreadId = Thread.CurrentThread.ManagedThreadId;
+                return events;
+            }
         }
 
         private sealed class FakePreparationService : ISnapshotPayloadPreparationService
diff --git a/src/WinRestoreKit.Tests/ComparisonWorkspaceViewModelTests.cs b/src/WinRestoreKit.Tests/ComparisonWorkspaceViewModelTests.cs
index fef311d..01cfc50 100644
--- a/src/WinRestoreKit.Tests/ComparisonWorkspaceViewModelTests.cs
+++ b/src/WinRestoreKit.Tests/ComparisonWorkspaceViewModelTests.cs
@@ -117,6 +117,43 @@ await WpfTestHost.RunAsync(async () =>
             });
         }
 
+        [Fact]
+        public async Task Navigator_LeavingCompareClearsStateAndAllowsTheSameSnapshotToOpenAgain()
+        {
+            await WpfTestHost.RunAsync(async () =>
+            {
+                Window owner = new Window();
+                ShellViewModel shell = TestShell();
+                CompareWorkflowNavigator navigator = new CompareWorkflowNavigator(
+                    shell, owner, new TestDiscardDialog(true));
+                string path = Path.Combine(Path.GetTempPath(), "WinRestoreKit.Tests", Guid.NewGuid().ToString("N"));
+
+                Directory.CreateDirectory(path);
+                navigator.OpenCompare(PreparedAt(path, "same snapshot"));
+                await navigator.PendingTransition;
+                ComparisonWorkspaceViewModel firstWorkspace = navigator.CurrentWorkspace;
+                firstWorkspace.RestoreSet.Add(new ModuleComparison(
+                    firstWorkspace.Rows[0].Registration.Module,
+                    ComparisonState.Unavailable, true, "Artifact captured.", "Comparison unavailable."));
+
+                await navigator.LeaveCompareAsync();
+
+                Assert.Null(navigator.CurrentWorkspace);
+                Assert.False(firstWorkspace.RestoreSet.HasItems);
+
+                Directory.CreateDirectory(path);
+                navigator.OpenCompare(PreparedAt(path, "same snapshot"));
+                await navigator.PendingTransition;
+
+                Assert.NotNull(navigator.CurrentWorkspace);
+                Assert.NotSame(firstWorkspace, navigator.CurrentWorkspace);
+                Assert.Equal(Path.GetFullPath(path), navigator.CurrentWorkspace.Snapshot.CanonicalPath);
+
+                await navigator.LeaveCompareAsync();
+                owner.Close();
+            });
+        }
+
         private static async Task<ComparisonWorkspaceViewModel> LoadedWorkspace(
             params TestModule[] modules)
             => await LoadedWorkspace(modules, (_, __) => { });
@@ -146,10 +183,13 @@ private static SnapshotPayloadPreparation Prepared(string name)
         {
             string path = Path.Combine(Path.GetTempPath(), "WinRestoreKit.Tests", Guid.NewGuid().ToString("N"));
             Directory.CreateDirectory(path);
-            SnapshotEvent snapshot = SnapshotFor(path, name);
-            return new SnapshotPayloadPreparation(snapshot, new BackupPayload.ReadScope(path, path), null);
+            return PreparedAt(path, name);
         }
 
+        private static SnapshotPayloadPreparation PreparedAt(string path, string name)
+            => new SnapshotPayloadPreparation(
+                SnapshotFor(path, name), new BackupPayload.ReadScope(path, path), null);
+
         private static SnapshotEvent SnapshotFor(string path, string name)
             => new SnapshotEvent(SnapshotEventKind.Verified, DateTime.UtcNow, name, path,
                 string.Empty, string.Empty, 0, true, null);
diff --git a/src/WinRestoreKit.Tests/WpfShellTests.cs b/src/WinRestoreKit.Tests/WpfShellTests.cs
index 26ec570..cb28427 100644
--- a/src/WinRestoreKit.Tests/WpfShellTests.cs
+++ b/src/WinRestoreKit.Tests/WpfShellTests.cs
@@ -6,6 +6,7 @@
 using WinRestoreKit.Wpf;
 using WinRestoreKit.Wpf.Services;
 using WinRestoreKit.Wpf.ViewModels;
+using WinRestoreKit.Wpf.ViewModels.History;
 using WinRestoreKit.Wpf.ViewModels.Timeline;
 using Xunit;
 
@@ -28,22 +29,85 @@ public void Shell_ComposesTheRealTimelineWorkflow()
         }
 
         [Fact]
-        public void Shell_SettingsAndAboutCommandsReturnToTheRealTimeline()
+        public void Shell_PrimaryNavigationCommandsReachEveryWorkspaceAndReturnToTimeline()
         {
             WpfTestHost.Run(() =>
             {
                 ShellViewModel shell = CreateShell();
                 MainWindow window = new MainWindow(shell);
+                shell.ShowAdvancedHistoryCommand.Execute(null);
+                Assert.Equal("Advanced history", shell.WorkflowLabel);
+                Assert.IsType<AdvancedHistoryViewModel>(shell.CurrentWorkspace);
                 shell.ShowSettingsCommand.Execute(null);
                 Assert.Equal("Settings", shell.WorkflowLabel);
                 shell.ShowAboutCommand.Execute(null);
                 Assert.Equal("About", shell.WorkflowLabel);
-                shell.ShowTimeline();
+                shell.ShowTimelineCommand.Execute(null);
                 Assert.IsType<TimelineViewModel>(shell.CurrentWorkspace);
                 window.Close();
             });
         }
 
+        [Fact]
+        public void Shell_PrimaryNavigationCommandsCannotHideAnActiveRun()
+        {
+            WpfTestHost.Run(() =>
+            {
+                RunCoordinator.SetRunning(false);
+                ShellViewModel shell = CreateShell();
+                MainWindow window = new MainWindow(shell);
+                try
+                {
+                    RunCoordinator.SetRunning(true);
+
+                    Assert.False(shell.CreateSnapshotCommand.CanExecute(null));
+                    Assert.False(shell.ShowTimelineCommand.CanExecute(null));
+                    Assert.False(shell.ShowAdvancedHistoryCommand.CanExecute(null));
+                    Assert.False(shell.ShowSettingsCommand.CanExecute(null));
+                    Assert.False(shell.ShowAboutCommand.CanExecute(null));
+
+                    shell.ShowSettingsCommand.Execute(null);
+                    Assert.Equal("Timeline", shell.WorkflowLabel);
+                    Assert.IsType<TimelineViewModel>(shell.CurrentWorkspace);
+                }
+                finally
+                {
+                    RunCoordinator.SetRunning(false);
+                    window.Close();
+                }
+            });
+        }
+
+        [Fact]
+        public void MainWindow_CloseIsCanceledUntilTheActiveRunFinishes()
+        {
+            WpfTestHost.Run(() =>
+            {
+                RunCoordinator.SetRunning(false);
+                ShellViewModel shell = ShellViewModel.ForTest(
+                    _ => Task.FromResult<BackupRunCompletion>(null),
+                    new SnapshotEventCatalog(),
+                    () => Task.CompletedTask);
+                MainWindow window = new MainWindow(shell);
+                window.Show();
+                try
+                {
+                    RunCoordinator.SetRunning(true);
+                    window.Close();
+
+                    Assert.True(window.IsVisible);
+                    Assert.Equal("Run in progress", shell.WorkflowLabel);
+                }
+                finally
+                {
+                    RunCoordinator.SetRunning(false);
+                    window.Close();
+                }
+
+                Assert.False(window.IsVisible);
+            });
+        }
+
         [Fact]
         public void Shell_ShowAbout_RendersReadOnlyVersionBinding()
         {
diff --git a/src/WinRestoreKit.Wpf/Infrastructure/AsyncDelegateCommand.cs b/src/WinRestoreKit.Wpf/Infrastructure/AsyncDelegateCommand.cs
index 50a5757..61c24dd 100644
--- a/src/WinRestoreKit.Wpf/Infrastructure/AsyncDelegateCommand.cs
+++ b/src/WinRestoreKit.Wpf/Infrastructure/AsyncDelegateCommand.cs
@@ -8,21 +8,24 @@ internal sealed class AsyncDelegateCommand : ICommand
     {
         private readonly Func<Task> executeAsync;
         private readonly Action<Exception> reportFailure;
+        private readonly Func<bool> canExecute;
         private bool executing;
 
-        internal AsyncDelegateCommand(Func<Task> executeAsync, Action<Exception> reportFailure = null)
+        internal AsyncDelegateCommand(Func<Task> executeAsync, Action<Exception> reportFailure = null,
+            Func<bool> canExecute = null)
         {
             this.executeAsync = executeAsync ?? throw new ArgumentNullException(nameof(executeAsync));
             this.reportFailure = reportFailure;
+            this.canExecute = canExecute;
         }
 
         public event EventHandler CanExecuteChanged;
 
-        public bool CanExecute(object parameter) => !executing;
+        public bool CanExecute(object parameter) => !executing && (canExecute?.Invoke() ?? true);
 
         public async void Execute(object parameter)
         {
-            if (executing)
+            if (!CanExecute(parameter))
                 return;
 
             executing = true;
@@ -41,5 +44,8 @@ public async void Execute(object parameter)
                 CanExecuteChanged?.Invoke(this, EventArgs.Empty);
             }
         }
+
+        internal void RaiseCanExecuteChanged()
+            => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
     }
 }
diff --git a/src/WinRestoreKit.Wpf/MainWindow.xaml b/src/WinRestoreKit.Wpf/MainWindow.xaml
index aa028c4..9fd3d7e 100644
--- a/src/WinRestoreKit.Wpf/MainWindow.xaml
+++ b/src/WinRestoreKit.Wpf/MainWindow.xaml
@@ -3,6 +3,7 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:views="clr-namespace:WinRestoreKit.Wpf.Views"
         xmlns:vm="clr-namespace:WinRestoreKit.Wpf.ViewModels"
+        xmlns:history="clr-namespace:WinRestoreKit.Wpf.ViewModels.History"
         xmlns:timeline="clr-namespace:WinRestoreKit.Wpf.ViewModels.Timeline"
         Title="WinRestoreKit" MinWidth="1024" MinHeight="640"
         UseLayoutRounding="True"
@@ -13,6 +14,7 @@
         Background="{DynamicResource WindowBackgroundBrush}">
   <Window.Resources>
     <DataTemplate DataType="{x:Type timeline:TimelineViewModel}"><views:TimelineView /></DataTemplate>
+    <DataTemplate DataType="{x:Type history:AdvancedHistoryViewModel}"><views:AdvancedHistoryView /></DataTemplate>
     <DataTemplate DataType="{x:Type vm:ComparisonWorkspaceViewModel}"><views:ComparisonWorkspaceView /></DataTemplate>
     <DataTemplate DataType="{x:Type vm:ConfirmViewModel}"><views:ConfirmView /></DataTemplate>
     <DataTemplate DataType="{x:Type vm:BackupWorkspaceViewModel}"><views:BackupWorkspaceView /></DataTemplate>
@@ -24,7 +26,7 @@
   <DockPanel>
     <!--
       Compact command bar, not a navigation chrome: wordmark, the stage the user is in, and the
-      three always-available commands. Everything else belongs to the workspace below it.
+      primary workspace commands. Everything else belongs to the workspace below it.
     -->
     <Border DockPanel.Dock="Top"
             Background="{DynamicResource SurfaceBrush}"
@@ -38,6 +40,8 @@
           <ColumnDefinition Width="Auto" />
           <ColumnDefinition Width="Auto" />
           <ColumnDefinition Width="Auto" />
+          <ColumnDefinition Width="Auto" />
+          <ColumnDefinition Width="Auto" />
         </Grid.ColumnDefinitions>
 
         <StackPanel Orientation="Horizontal" VerticalAlignment="Center">
@@ -60,24 +64,43 @@
         </StackPanel>
 
         <Button Grid.Column="1"
+                Content="Timeline"
+                Command="{Binding ShowTimelineCommand}"
+                Style="{DynamicResource SubtleButtonStyle}"
+                VerticalAlignment="Center"
+                AutomationProperties.AutomationId="NavTimeline"
+                AutomationProperties.Name="Timeline" />
+        <Button Grid.Column="2"
+                Content="History"
+                Command="{Binding ShowAdvancedHistoryCommand}"
+                Style="{DynamicResource SubtleButtonStyle}"
+                Margin="4,0,0,0"
+                VerticalAlignment="Center"
+                AutomationProperties.AutomationId="NavAdvancedHistory"
+                AutomationProperties.Name="Advanced history" />
+        <Button Grid.Column="3"
                 Content="Create snapshot"
                 Command="{Binding CreateSnapshotCommand}"
                 Style="{DynamicResource PrimaryButtonStyle}"
+                Margin="8,0,0,0"
                 VerticalAlignment="Center"
+                AutomationProperties.AutomationId="NavCreateSnapshot"
                 AutomationProperties.Name="Create snapshot" />
-        <Button Grid.Column="2"
+        <Button Grid.Column="4"
                 Content="Settings"
                 Command="{Binding ShowSettingsCommand}"
                 Style="{DynamicResource SubtleButtonStyle}"
                 Margin="8,0,0,0"
                 VerticalAlignment="Center"
+                AutomationProperties.AutomationId="NavSettings"
                 AutomationProperties.Name="Settings" />
-        <Button Grid.Column="3"
+        <Button Grid.Column="5"
                 Content="About"
                 Command="{Binding ShowAboutCommand}"
                 Style="{DynamicResource SubtleButtonStyle}"
                 Margin="4,0,0,0"
                 VerticalAlignment="Center"
+                AutomationProperties.AutomationId="NavAbout"
                 AutomationProperties.Name="About" />
       </Grid>
     </Border>
diff --git a/src/WinRestoreKit.Wpf/MainWindow.xaml.cs b/src/WinRestoreKit.Wpf/MainWindow.xaml.cs
index 26272ed..11e2c38 100644
--- a/src/WinRestoreKit.Wpf/MainWindow.xaml.cs
+++ b/src/WinRestoreKit.Wpf/MainWindow.xaml.cs
@@ -1,4 +1,5 @@
 using System;
+using System.ComponentModel;
 using System.Windows;
 using WinRestoreKit;
 using WinRestoreKit.Wpf.Navigation;
@@ -18,7 +19,16 @@ internal MainWindow(ShellViewModel shell)
             InitializeComponent();
             DataContext = shell;
             CompareWorkflowNavigator navigator = new CompareWorkflowNavigator(shell, this, new CompareDialogService());
+            shell.SetBeforeUserNavigation(navigator.LeaveCompareAsync);
             shell.SetTimeline(new TimelineViewModel(shell.SnapshotEventCatalog, new SnapshotPayloadPreparationService(), navigator));
         }
+
+        protected override void OnClosing(CancelEventArgs e)
+        {
+            if (DataContext is ShellViewModel shell && !shell.RequestWindowClose())
+                e.Cancel = true;
+
+            base.OnClosing(e);
+        }
     }
 }
diff --git a/src/WinRestoreKit.Wpf/Navigation/CompareWorkflowNavigator.cs b/src/WinRestoreKit.Wpf/Navigation/CompareWorkflowNavigator.cs
index a23ec02..2cba65c 100644
--- a/src/WinRestoreKit.Wpf/Navigation/CompareWorkflowNavigator.cs
+++ b/src/WinRestoreKit.Wpf/Navigation/CompareWorkflowNavigator.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using System.Windows;
 using WinRestoreKit;
@@ -14,6 +15,7 @@ internal sealed class CompareWorkflowNavigator : ITimelineNavigator
         private readonly Window owner;
         private readonly ICompareDialogService dialogs;
         private ComparisonWorkspaceViewModel currentWorkspace;
+        private int transitionVersion;
 
         internal CompareWorkflowNavigator(ShellViewModel shell, Window owner, ICompareDialogService dialogs)
         {
@@ -44,20 +46,40 @@ public void OpenCompare(SnapshotPayloadPreparation incoming)
                 return;
             }
 
-            PendingTransition = ReplaceWorkspaceAsync(incoming);
+            int version = Interlocked.Increment(ref transitionVersion);
+            PendingTransition = ReplaceWorkspaceAsync(incoming, version);
         }
 
         public void ShowSnapshotDiagnostic(SnapshotEvent snapshot)
             => dialogs.ShowSnapshotDiagnostic(owner, snapshot);
 
-        private async Task ReplaceWorkspaceAsync(SnapshotPayloadPreparation incoming)
+        internal async Task LeaveCompareAsync()
+        {
+            Interlocked.Increment(ref transitionVersion);
+            ComparisonWorkspaceViewModel workspace = currentWorkspace;
+            currentWorkspace = null;
+            if (workspace == null)
+                return;
+
+            await workspace.CancelAsync();
+            workspace.RestoreSet.Clear();
+        }
+
+        private async Task ReplaceWorkspaceAsync(SnapshotPayloadPreparation incoming, int version)
         {
             bool comparisonStarted = false;
             try
             {
-                if (currentWorkspace != null)
-                    await currentWorkspace.CancelAsync();
-                currentWorkspace?.RestoreSet.Clear();
+                ComparisonWorkspaceViewModel previous = currentWorkspace;
+                if (previous != null)
+                    await previous.CancelAsync();
+                previous?.RestoreSet.Clear();
+
+                if (version != Volatile.Read(ref transitionVersion))
+                {
+                    incoming.Dispose();
+                    return;
+                }
 
                 currentWorkspace = new ComparisonWorkspaceViewModel(incoming.Snapshot,
                     BackupModuleCatalog.CreateAll(), new SnapshotComparisonService(), ShowConfirm);
@@ -69,7 +91,8 @@ private async Task ReplaceWorkspaceAsync(SnapshotPayloadPreparation incoming)
             {
                 if (!comparisonStarted)
                     incoming.Dispose();
-                shell.ShowInlineWorkflowError("Comparison could not start: " + ex.Message);
+                if (version == Volatile.Read(ref transitionVersion))
+                    shell.ShowInlineWorkflowError("Comparison could not start: " + ex.Message);
             }
         }
 
diff --git a/src/WinRestoreKit.Wpf/ViewModels/History/AdvancedHistoryViewModel.cs b/src/WinRestoreKit.Wpf/ViewModels/History/AdvancedHistoryViewModel.cs
index 71f1e67..2f50c7f 100644
--- a/src/WinRestoreKit.Wpf/ViewModels/History/AdvancedHistoryViewModel.cs
+++ b/src/WinRestoreKit.Wpf/ViewModels/History/AdvancedHistoryViewModel.cs
@@ -3,6 +3,7 @@
 using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Windows.Data;
+using System.Windows.Threading;
 using System.Threading;
 using System.Threading.Tasks;
 using WinRestoreKit;
@@ -14,6 +15,7 @@ namespace WinRestoreKit.Wpf.ViewModels.History
     internal sealed class AdvancedHistoryViewModel : ObservableObject
     {
         private readonly ISnapshotEventReader catalog;
+        private readonly Dispatcher dispatcher;
         private readonly ObservableCollection<SnapshotEventViewModel> events;
         private string searchText;
         private SnapshotEventViewModel selectedEvent;
@@ -21,6 +23,7 @@ internal sealed class AdvancedHistoryViewModel : ObservableObject
         internal AdvancedHistoryViewModel(ISnapshotEventReader catalog)
         {
             this.catalog = catalog ?? throw new ArgumentNullException(nameof(catalog));
+            dispatcher = Dispatcher.CurrentDispatcher;
             events = new ObservableCollection<SnapshotEventViewModel>();
             Events = CollectionViewSource.GetDefaultView(events);
             Events.Filter = MatchesSearch;
@@ -44,11 +47,26 @@ public SnapshotEventViewModel SelectedEvent
             set => SetProperty(ref selectedEvent, value, nameof(SelectedEvent));
         }
 
-        internal Task RefreshAsync(CancellationToken cancellationToken = default)
+        internal async Task RefreshAsync(CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
-            IReadOnlyList<SnapshotEvent> snapshots = catalog.Read();
+            IReadOnlyList<SnapshotEvent> snapshots = await Task.Run(catalog.Read, cancellationToken);
 
+            if (!dispatcher.CheckAccess())
+            {
+                await dispatcher.InvokeAsync(
+                    () => ApplySnapshots(snapshots, cancellationToken),
+                    DispatcherPriority.DataBind,
+                    cancellationToken);
+                return;
+            }
+
+            ApplySnapshots(snapshots, cancellationToken);
+        }
+
+        private void ApplySnapshots(IReadOnlyList<SnapshotEvent> snapshots,
+            CancellationToken cancellationToken)
+        {
             events.Clear();
             foreach (SnapshotEvent snapshot in snapshots)
             {
@@ -57,7 +75,6 @@ internal Task RefreshAsync(CancellationToken cancellationToken = default)
             }
 
             SelectedEvent = null;
-            return Task.CompletedTask;
         }
 
         private bool MatchesSearch(object item)
diff --git a/src/WinRestoreKit.Wpf/ViewModels/ShellViewModel.cs b/src/WinRestoreKit.Wpf/ViewModels/ShellViewModel.cs
index 8172468..9b78cbc 100644
--- a/src/WinRestoreKit.Wpf/ViewModels/ShellViewModel.cs
+++ b/src/WinRestoreKit.Wpf/ViewModels/ShellViewModel.cs
@@ -6,6 +6,7 @@
 using System.Windows.Threading;
 using WinRestoreKit.Wpf.Infrastructure;
 using WinRestoreKit.Wpf.Services;
+using WinRestoreKit.Wpf.ViewModels.History;
 using WinRestoreKit.Wpf.ViewModels.Timeline;
 
 namespace WinRestoreKit.Wpf.ViewModels
@@ -18,11 +19,14 @@ internal sealed class ShellViewModel : ObservableObject
         private readonly SettingsViewModel settings;
         private readonly AboutViewModel about;
         private readonly SnapshotEventCatalog snapshotEventCatalog;
+        private readonly AdvancedHistoryViewModel advancedHistory;
         private readonly BackupCompletionPublisher completionPublisher;
         private readonly Func<BackupRunRequest, Task<BackupRunCompletion>> runBackupAsync;
         private readonly Func<Task> refreshTimelineAsync;
+        private Func<Task> beforeUserNavigationAsync = () => Task.CompletedTask;
         private TimelineViewModel timelineWorkspace;
         private BackupWorkspaceViewModel backupWorkspace;
+        private bool navigationInProgress;
 
         internal ShellViewModel(IThemeService themes, WpfUpdatePresenter updates, string currentVersion)
         {
@@ -37,6 +41,7 @@ internal ShellViewModel(IThemeService themes, WpfUpdatePresenter updates, string
             settings = new SettingsViewModel(themes);
             about = new AboutViewModel(updates, currentVersion);
             snapshotEventCatalog = new SnapshotEventCatalog();
+            advancedHistory = new AdvancedHistoryViewModel(snapshotEventCatalog);
             completionPublisher = new BackupCompletionPublisher(snapshotEventCatalog);
             WpfAppRestoreDialog.Register(snapshotEventCatalog);
             runBackupAsync = RunWpfBackupAsync;
@@ -48,6 +53,7 @@ private ShellViewModel(Func<BackupRunRequest, Task<BackupRunCompletion>> runBack
         {
             runBackupAsync = runBackup ?? throw new ArgumentNullException(nameof(runBackup));
             snapshotEventCatalog = catalog ?? throw new ArgumentNullException(nameof(catalog));
+            advancedHistory = new AdvancedHistoryViewModel(snapshotEventCatalog);
             completionPublisher = new BackupCompletionPublisher(snapshotEventCatalog);
             refreshTimelineAsync = refreshTimeline ?? throw new ArgumentNullException(nameof(refreshTimeline));
             InitializeCommands();
@@ -57,6 +63,7 @@ private ShellViewModel(Func<BackupRunRequest, Task<BackupRunCompletion>> runBack
         public string WorkflowLabel { get; private set; }
         public ICommand CreateSnapshotCommand { get; private set; }
         public ICommand ShowTimelineCommand { get; private set; }
+        public ICommand ShowAdvancedHistoryCommand { get; private set; }
         public ICommand ShowSettingsCommand { get; private set; }
         public ICommand ShowAboutCommand { get; private set; }
 
@@ -70,10 +77,13 @@ internal static ShellViewModel ForTest(
         internal void SetTimeline(TimelineViewModel value)
         {
             timelineWorkspace = value ?? throw new ArgumentNullException(nameof(value));
-            (ShowTimelineCommand as DelegateCommand)?.RaiseCanExecuteChanged();
+            (ShowTimelineCommand as AsyncDelegateCommand)?.RaiseCanExecuteChanged();
             ShowTimeline();
         }
 
+        internal void SetBeforeUserNavigation(Func<Task> callback)
+            => beforeUserNavigationAsync = callback ?? throw new ArgumentNullException(nameof(callback));
+
         internal void NavigateTo(object workspace, string workflowLabel)
         {
             if (workspace == null)
@@ -99,6 +109,19 @@ internal void ShowCompare(ComparisonWorkspaceViewModel workspace)
         internal void ShowConfirm(ConfirmViewModel confirm)
             => NavigateTo(confirm ?? throw new ArgumentNullException(nameof(confirm)), "Confirm");
 
+        internal bool RequestWindowClose()
+        {
+            if (!RunCoordinator.IsRunning)
+                return true;
+
+            const string message = "A backup or restore is still running. Wait for it to finish, "
+                + "or use Cancel in the active run before closing WinRestoreKit.";
+            WorkflowLabel = "Run in progress";
+            OnPropertyChanged(nameof(WorkflowLabel));
+            dialogs?.ShowWarning(message, "Run in progress");
+            return false;
+        }
+
         internal void ShowInlineWorkflowError(string text)
         {
             if (string.IsNullOrWhiteSpace(text))
@@ -110,20 +133,64 @@ internal void ShowInlineWorkflowError(string text)
 
         private void InitializeCommands()
         {
-            CreateSnapshotCommand = new DelegateCommand(_ => ShowCreateSnapshot(),
-                _ => !RunCoordinator.IsRunning);
-            ShowTimelineCommand = new DelegateCommand(_ => ShowTimeline(), _ => timelineWorkspace != null);
-            ShowSettingsCommand = new DelegateCommand(_ => NavigateTo(settings, "Settings"));
-            ShowAboutCommand = new DelegateCommand(_ => NavigateTo(about, "About"));
+            Action<Exception> reportNavigationFailure = ex =>
+                ShowInlineWorkflowError("Navigation could not complete: " + ex.Message);
+            CreateSnapshotCommand = new AsyncDelegateCommand(ShowCreateSnapshotAsync,
+                reportNavigationFailure, CanNavigate);
+            ShowTimelineCommand = new AsyncDelegateCommand(
+                () => NavigateUserAsync(() => timelineWorkspace, "Timeline"),
+                reportNavigationFailure,
+                () => timelineWorkspace != null && CanNavigate());
+            ShowAdvancedHistoryCommand = new AsyncDelegateCommand(
+                () => NavigateUserAsync(() => advancedHistory, "Advanced history"),
+                reportNavigationFailure,
+                CanNavigate);
+            ShowSettingsCommand = new AsyncDelegateCommand(
+                () => NavigateUserAsync(() => settings, "Settings"),
+                reportNavigationFailure,
+                () => settings != null && CanNavigate());
+            ShowAboutCommand = new AsyncDelegateCommand(
+                () => NavigateUserAsync(() => about, "About"),
+                reportNavigationFailure,
+                () => about != null && CanNavigate());
             RunCoordinator.RunningChanged += OnRunningChanged;
         }
 
-        private void ShowCreateSnapshot()
+        private Task ShowCreateSnapshotAsync()
+            => NavigateUserAsync(CreateBackupWorkspace, "Create snapshot");
+
+        private object CreateBackupWorkspace()
         {
             backupWorkspace = new BackupWorkspaceViewModel(StartBackupAsync, Data.DataRootDir);
-            NavigateTo(backupWorkspace, "Create snapshot");
+            return backupWorkspace;
+        }
+
+        private async Task NavigateUserAsync(Func<object> workspaceFactory, string workflowLabel)
+        {
+            if (!CanNavigate())
+                return;
+
+            navigationInProgress = true;
+            RefreshNavigationCommandStates();
+            try
+            {
+                await beforeUserNavigationAsync();
+                if (RunCoordinator.IsRunning)
+                    return;
+
+                object workspace = workspaceFactory?.Invoke();
+                if (workspace != null)
+                    NavigateTo(workspace, workflowLabel);
+            }
+            finally
+            {
+                navigationInProgress = false;
+                RefreshNavigationCommandStates();
+            }
         }
 
+        private bool CanNavigate() => !navigationInProgress && !RunCoordinator.IsRunning;
+
         private async Task StartBackupAsync(BackupRunRequest request)
         {
             if (!RunCoordinator.TryStart())
@@ -163,10 +230,7 @@ private async Task<BackupRunCompletion> RunWpfBackupAsync(BackupRunRequest reque
         }
 
         private Task ReturnToTimelineAsync()
-        {
-            ShowTimeline();
-            return Task.CompletedTask;
-        }
+            => NavigateUserAsync(() => timelineWorkspace, "Timeline");
 
         private Task RefreshTimelineAsync()
         {
@@ -178,7 +242,7 @@ private Task RefreshTimelineAsync()
 
         private void OnRunningChanged(bool running)
         {
-            Action refresh = () => (CreateSnapshotCommand as DelegateCommand)?.RaiseCanExecuteChanged();
+            Action refresh = RefreshNavigationCommandStates;
             if (dispatcher == null || dispatcher.HasShutdownStarted || dispatcher.HasShutdownFinished
                 || dispatcher.CheckAccess())
             {
@@ -194,5 +258,14 @@ private void OnRunningChanged(bool running)
             {
             }
         }
+
+        private void RefreshNavigationCommandStates()
+        {
+            (CreateSnapshotCommand as AsyncDelegateCommand)?.RaiseCanExecuteChanged();
+            (ShowTimelineCommand as AsyncDelegateCommand)?.RaiseCanExecuteChanged();
+            (ShowAdvancedHistoryCommand as AsyncDelegateCommand)?.RaiseCanExecuteChanged();
+            (ShowSettingsCommand as AsyncDelegateCommand)?.RaiseCanExecuteChanged();
+            (ShowAboutCommand as AsyncDelegateCommand)?.RaiseCanExecuteChanged();
+        }
     }
 }