From 2b7995a941649946cfd343c85d14b889f76058e5 Mon Sep 17 00:00:00 2001
From: nicolasestrem <103498114+nicolasestrem@users.noreply.github.com>
Date: Mon, 10 Aug 2026 00:57:12 +0200
Subject: [PATCH 1/3] fix(wpf): harden restore completion and consent

---
 CHANGELOG.md                                  | 10 +++
 .../BackupRestoreOrchestrator.cs              |  7 +-
 src/WinRestoreKit.Core/Results/RestorePlan.cs | 81 +++++++++++++++----
 .../BackupWorkspaceViewModelTests.cs          | 32 ++++++++
 .../BackupWorkspaceViewTests.cs               | 47 ++++++++---
 .../ConfirmViewModelTests.cs                  | 45 ++++++++++-
 .../RebrandIdentityTests.cs                   | 10 +++
 .../RestoreConsentDialogTests.cs              | 36 +++++++++
 src/WinRestoreKit.Tests/RestorePlanTests.cs   | 59 ++++++++++++--
 .../ResultWorkspaceViewModelTests.cs          | 38 +++++++--
 .../Navigation/CompareWorkflowNavigator.cs    |  3 +-
 .../ViewModels/BackupWorkspaceViewModel.cs    | 35 +++++++-
 .../ViewModels/ConfirmViewModel.cs            | 29 ++++++-
 .../ViewModels/ResultWorkspaceViewModel.cs    |  3 +
 .../ViewModels/ShellViewModel.cs              |  4 +
 .../Views/BackupWorkspaceView.xaml            |  6 +-
 src/WinRestoreKit.Wpf/Views/ConfirmView.xaml  | 10 +--
 .../Views/Dialogs/RestoreConsentDialog.xaml   | 42 +++++++---
 .../Dialogs/RestoreConsentDialog.xaml.cs      | 14 +++-
 .../Views/ResultWorkspaceView.xaml            |  9 ++-
 .../WinRestoreKit.Wpf.csproj                  |  6 ++
 21 files changed, 453 insertions(+), 73 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4e05459..3f48cb7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,16 @@ version numbers, because that is what those releases were called.
 
 ## [Unreleased]
 
+### Fixed: WPF restore completion and release truth
+
+- Aligned the WPF shell assembly and displayed product version with the canonical 0.0.1 release.
+- Cleared snapshot validation as soon as invalid input is corrected and exposed the full validation,
+  severity, headline, and detail text to assistive technology.
+- Made final restore consent resizable and scrollable so long paths wrap without clipping, and only
+  promised a pre-restore snapshot for modules that actually write settings.
+- Routed completed restores to the result workspace and prevented the same confirmation page from
+  accidentally starting a second restore.
+
 ### Fixed: restore and snapshot integrity
 
 - Verified successful manifest rows against their physical artifacts and kept unavailable modules out
diff --git a/src/WinRestoreKit.Application/Orchestration/BackupRestoreOrchestrator.cs b/src/WinRestoreKit.Application/Orchestration/BackupRestoreOrchestrator.cs
index a3a20dc..4fb2e4a 100644
--- a/src/WinRestoreKit.Application/Orchestration/BackupRestoreOrchestrator.cs
+++ b/src/WinRestoreKit.Application/Orchestration/BackupRestoreOrchestrator.cs
@@ -1152,9 +1152,10 @@ private async Task RunRestoreCore(IReadOnlyList<BackupBase> selection)
                 logger.LogMessage("Could not choose a snapshot folder name: " + ex.Message);
             }
 
-            // Composing the plan reads four virtual members off every selected module -
-            // RestoreTargets, ProcessesToCloseBeforeRestore, Title and WarningMessage - and any of
-            // the four can throw from a module written later. This stage sits between the try above
+            // Composing the plan reads five virtual members off every selected module:
+            // RestoreTargets, ProcessesToCloseBeforeRestore, Title, WarningMessage, and
+            // RestoreMakesChanges. Any of them can throw from a module written later. This stage sits
+            // between the try above
             // and the confirmation dialog, and the whole chain up to the async void click handler
             // has no catch, so an escaping exception here would surface as WinForms' unhandled
             // exception dialog mid-restore.
diff --git a/src/WinRestoreKit.Core/Results/RestorePlan.cs b/src/WinRestoreKit.Core/Results/RestorePlan.cs
index 02a1092..92fa062 100644
--- a/src/WinRestoreKit.Core/Results/RestorePlan.cs
+++ b/src/WinRestoreKit.Core/Results/RestorePlan.cs
@@ -48,15 +48,15 @@ public sealed class RestorePlan
         /// strongly in one place than in another. Both restore mechanisms are additive - regedit /s
         /// merges, and CopyFolder leaves destination files absent from the source in place - so
         /// offering "rollback" without this sentence would claim a guarantee the app does not hold.
-        ///
-        /// Written with an escaped dash so the sentence survives being compiled from a source file
-        /// with no byte order mark.
         /// </remarks>
         public const string FidelityCaveat =
             "The snapshot can put back settings this restore overwrites. It cannot remove registry " +
-            "values or files that this restore adds \u2014 restoring the snapshot merges it over the " +
+            "values or files that this restore adds; restoring the snapshot merges it over the " +
             "current state rather than resetting to it.";
 
+        public const string NoSnapshotNotice =
+            "No pre-restore snapshot is created because the selected items do not write settings by themselves.";
+
         public IReadOnlyList<BackupBase> Modules { get; }
 
         /// <summary>The folder the restore reads from.</summary>
@@ -68,6 +68,12 @@ public sealed class RestorePlan
         /// <summary>The module-by-module text: title, declared targets, and any warning.</summary>
         public string ConfirmationText { get; }
 
+        /// <summary>Whether any selected module writes settings and therefore needs a safety snapshot.</summary>
+        public bool NeedsSnapshot { get; }
+
+        /// <summary>The exact safety-snapshot promise, or the reason no snapshot is created.</summary>
+        public string SnapshotNotice { get; }
+
         /// <summary>One entry per distinct process that may only be closed with consent.</summary>
         public IReadOnlyList<RestoreConsentEntry> ConsentEntries { get; }
 
@@ -99,7 +105,12 @@ public RestorePlan(IReadOnlyList<BackupBase> modules, string restoreSourcePath,
 
             ConsentEntries = consent;
             InformationalCloseLines = informational;
-            ConfirmationText = Compose(Modules, restoreSourcePath, snapshotDestination);
+            List<BackupBase> changeMaking = new List<BackupBase>();
+            List<BackupBase> interactive = new List<BackupBase>();
+            ClassifyModules(Modules, changeMaking, interactive);
+            NeedsSnapshot = changeMaking.Count > 0;
+            SnapshotNotice = NeedsSnapshot ? FidelityCaveat : NoSnapshotNotice;
+            ConfirmationText = Compose(changeMaking, interactive, restoreSourcePath, snapshotDestination);
         }
 
         private static IReadOnlyList<BackupBase> Compact(IReadOnlyList<BackupBase> modules)
@@ -144,17 +155,64 @@ private static void CollectCloses(IReadOnlyList<BackupBase> modules,
             }
         }
 
-        private static string Compose(IReadOnlyList<BackupBase> modules, string restoreSourcePath,
-                                      string snapshotDestination)
+        private static void ClassifyModules(IReadOnlyList<BackupBase> modules,
+                                            ICollection<BackupBase> changeMaking,
+                                            ICollection<BackupBase> interactive)
+        {
+            foreach (BackupBase module in modules)
+            {
+                if (module.RestoreMakesChanges)
+                    changeMaking.Add(module);
+                else
+                    interactive.Add(module);
+            }
+        }
+
+        private static string Compose(IReadOnlyList<BackupBase> changeMaking,
+                                      IReadOnlyList<BackupBase> interactive,
+                                      string restoreSourcePath, string snapshotDestination)
         {
             StringBuilder sb = new StringBuilder();
 
             sb.AppendLine("Restoring from:");
             sb.AppendLine("  " + restoreSourcePath);
             sb.AppendLine();
-            sb.AppendLine("These items will be overwritten with what was backed up:");
-            sb.AppendLine();
 
+            if (changeMaking.Count > 0)
+            {
+                sb.AppendLine("These items will be overwritten with what was backed up:");
+                sb.AppendLine();
+                AppendModules(sb, changeMaking);
+            }
+
+            if (interactive.Count > 0)
+            {
+                sb.AppendLine("These items open an interactive restore step and do not write settings by themselves:");
+                sb.AppendLine();
+                AppendModules(sb, interactive);
+            }
+
+            if (changeMaking.Count == 0 && interactive.Count == 0)
+            {
+                sb.AppendLine("No restore items were selected.");
+                sb.AppendLine();
+            }
+
+            if (changeMaking.Count > 0)
+            {
+                sb.AppendLine("The current settings will first be copied to:");
+                sb.AppendLine("  " + snapshotDestination);
+            }
+            else
+            {
+                sb.AppendLine(NoSnapshotNotice);
+            }
+
+            return sb.ToString();
+        }
+
+        private static void AppendModules(StringBuilder sb, IReadOnlyList<BackupBase> modules)
+        {
             foreach (BackupBase module in modules)
             {
                 sb.AppendLine(module.Title);
@@ -167,11 +225,6 @@ private static string Compose(IReadOnlyList<BackupBase> modules, string restoreS
 
                 sb.AppendLine();
             }
-
-            sb.AppendLine("The current settings will first be copied to:");
-            sb.AppendLine("  " + snapshotDestination);
-
-            return sb.ToString();
         }
 
         /// <remarks>
diff --git a/src/WinRestoreKit.Tests/BackupWorkspaceViewModelTests.cs b/src/WinRestoreKit.Tests/BackupWorkspaceViewModelTests.cs
index a2f2b9d..e92c1a2 100644
--- a/src/WinRestoreKit.Tests/BackupWorkspaceViewModelTests.cs
+++ b/src/WinRestoreKit.Tests/BackupWorkspaceViewModelTests.cs
@@ -72,6 +72,38 @@ public async Task StartAsync_BlankDestinationWithSelection_ShowsDestinationValid
             Assert.Equal("Choose a destination folder before capturing.", vm.ValidationMessage);
         }
 
+        [Fact]
+        public async Task Validation_ClearsAsSoonAsTheInvalidFieldOrSelectionIsCorrected()
+        {
+            var vm = new BackupWorkspaceViewModel(_ => Task.CompletedTask, string.Empty);
+            foreach (BackupScopeItemViewModel scope in vm.Scopes)
+                scope.IsSelected = false;
+
+            await vm.StartAsync();
+            Assert.NotNull(vm.ValidationMessage);
+
+            vm.Scopes.Single(scope => scope.Name == "Explorer & shell").IsSelected = true;
+            Assert.Null(vm.ValidationMessage);
+
+            await vm.StartAsync();
+            Assert.NotNull(vm.ValidationMessage);
+
+            vm.Destination = @"C:\snapshots";
+            Assert.Null(vm.ValidationMessage);
+        }
+
+        [Fact]
+        public async Task Validation_AutomationNameCarriesTheActualDiagnostic()
+        {
+            var vm = new BackupWorkspaceViewModel(_ => Task.CompletedTask, string.Empty);
+            foreach (BackupScopeItemViewModel scope in vm.Scopes)
+                scope.IsSelected = false;
+
+            await vm.StartAsync();
+
+            Assert.Equal("Snapshot validation: " + vm.ValidationMessage, vm.ValidationAutomationName);
+        }
+
         [Fact]
         public void UnfilteredEnvironmentScope_StartsUnselectedAndExposesItsCaution()
         {
diff --git a/src/WinRestoreKit.Tests/BackupWorkspaceViewTests.cs b/src/WinRestoreKit.Tests/BackupWorkspaceViewTests.cs
index bcbebae..d6033db 100644
--- a/src/WinRestoreKit.Tests/BackupWorkspaceViewTests.cs
+++ b/src/WinRestoreKit.Tests/BackupWorkspaceViewTests.cs
@@ -1,6 +1,9 @@
+using System;
 using System.Threading.Tasks;
+using System.Windows;
 using System.Windows.Automation;
 using System.Windows.Controls;
+using System.Windows.Threading;
 using WinRestoreKit.Wpf.ViewModels;
 using WinRestoreKit.Wpf.Views;
 using Xunit;
@@ -14,21 +17,43 @@ public void View_ExposesScopeWarningsLabeledCompressionAndExactAutomationIds()
         {
             WpfTestHost.Run(() =>
             {
+                var viewModel = new BackupWorkspaceViewModel(_ => Task.CompletedTask, @"C:\snapshots");
+                foreach (BackupScopeItemViewModel scope in viewModel.Scopes)
+                    scope.IsSelected = false;
+                viewModel.StartAsync().GetAwaiter().GetResult();
+
                 var view = new BackupWorkspaceView
                 {
-                    DataContext = new BackupWorkspaceViewModel(_ => Task.CompletedTask, @"C:\snapshots")
+                    DataContext = viewModel
                 };
+                var host = new Window { Content = view, Width = 1024, Height = 720 };
+                host.Show();
+                host.UpdateLayout();
+                Dispatcher.CurrentDispatcher.Invoke(
+                    DispatcherPriority.ApplicationIdle,
+                    new Action(() => { }));
+
+                try
+                {
+                    Assert.Equal("BackupWorkspace", AutomationProperties.GetAutomationId(view));
+                    Assert.NotNull(view.FindName("BackupScopeList"));
+                    Assert.NotNull(view.FindName("CreateSnapshotButton"));
+                    Assert.NotNull(view.FindName("CompressionComboBox"));
+                    Assert.Equal("BackupDestinationTextBox", AutomationProperties.GetAutomationId(
+                        Assert.IsType<TextBox>(view.FindName("DestinationTextBox"))));
+                    Assert.Equal("CreateSnapshotButton", AutomationProperties.GetAutomationId(
+                        Assert.IsType<Button>(view.FindName("CreateSnapshotButton"))));
+                    Assert.Equal("CompressionComboBox", AutomationProperties.GetAutomationId(
+                        Assert.IsType<ComboBox>(view.FindName("CompressionComboBox"))));
 
-                Assert.Equal("BackupWorkspace", AutomationProperties.GetAutomationId(view));
-                Assert.NotNull(view.FindName("BackupScopeList"));
-                Assert.NotNull(view.FindName("CreateSnapshotButton"));
-                Assert.NotNull(view.FindName("CompressionComboBox"));
-                Assert.Equal("BackupDestinationTextBox", AutomationProperties.GetAutomationId(
-                    Assert.IsType<TextBox>(view.FindName("DestinationTextBox"))));
-                Assert.Equal("CreateSnapshotButton", AutomationProperties.GetAutomationId(
-                    Assert.IsType<Button>(view.FindName("CreateSnapshotButton"))));
-                Assert.Equal("CompressionComboBox", AutomationProperties.GetAutomationId(
-                    Assert.IsType<ComboBox>(view.FindName("CompressionComboBox"))));
+                    TextBlock validation = Assert.IsType<TextBlock>(view.FindName("BackupValidationText"));
+                    Assert.Equal(viewModel.ValidationAutomationName, AutomationProperties.GetName(validation));
+                    Assert.Equal(viewModel.ValidationMessage, AutomationProperties.GetHelpText(validation));
+                }
+                finally
+                {
+                    host.Close();
+                }
             });
         }
     }
diff --git a/src/WinRestoreKit.Tests/ConfirmViewModelTests.cs b/src/WinRestoreKit.Tests/ConfirmViewModelTests.cs
index 3da0c3b..49a0bae 100644
--- a/src/WinRestoreKit.Tests/ConfirmViewModelTests.cs
+++ b/src/WinRestoreKit.Tests/ConfirmViewModelTests.cs
@@ -33,6 +33,22 @@ public void Confirm_GroupsOnlyExistingProcessAndExplorerImpacts()
                 Assert.Contains(viewModel.ConsentProcesses, item => item.DisplayName == "Visual Studio Code");
                 Assert.Contains(viewModel.ExplorerRestartModules, item => item.Title == "Taskbar");
                 Assert.Contains(viewModel.ModuleWarnings, item => item.Text == "Existing sign-out warning.");
+                Assert.Equal("2 selected modules will be evaluated for restore from this snapshot.",
+                    viewModel.RestoreSelectionSummary);
+            });
+        }
+
+        [Fact]
+        public void Confirm_InteractiveOnlyModuleUsesSingularGrammarAndNoSnapshotNotice()
+        {
+            WpfTestHost.Run(() =>
+            {
+                ConfirmViewModel viewModel = new ConfirmViewModel(Snapshot(),
+                    new BackupBase[] { new InteractiveModule("Remember installed apps") });
+
+                Assert.Equal("1 selected module will be evaluated for restore from this snapshot.",
+                    viewModel.RestoreSelectionSummary);
+                Assert.Equal(RestorePlan.NoSnapshotNotice, viewModel.FidelityCaveat);
             });
         }
 
@@ -58,7 +74,18 @@ await WpfTestHost.RunAsync(async () =>
                 try
                 {
                     CancelingRunDialogService dialogs = new CancelingRunDialogService();
-                    ConfirmViewModel viewModel = new ConfirmViewModel(Snapshot(SnapshotEventKind.Verified, source), new BackupBase[] { new TestModule("Module") });
+                    int completions = 0;
+                    bool callbackSawReleasedRun = false;
+                    RunSummary completedSummary = null;
+                    ConfirmViewModel viewModel = new ConfirmViewModel(
+                        Snapshot(SnapshotEventKind.Verified, source),
+                        new BackupBase[] { new TestModule("Module") },
+                        showResult: (summary, _) =>
+                        {
+                            completions++;
+                            completedSummary = summary;
+                            callbackSawReleasedRun = !RunCoordinator.IsRunning;
+                        });
                     Window owner = new Window();
                     viewModel.AttachRunSurfaces(Dispatcher.CurrentDispatcher, () => owner, dialogs);
 
@@ -67,7 +94,15 @@ await WpfTestHost.RunAsync(async () =>
                     Assert.Equal(Path.GetFullPath(source), dialogs.LastRestorePlan.RestoreSourcePath);
                     Assert.Single(dialogs.LastRestorePlan.Modules);
                     Assert.Contains("canceled", viewModel.Summary.Headline, StringComparison.OrdinalIgnoreCase);
+                    Assert.Same(viewModel.Summary, completedSummary);
+                    Assert.Equal(1, completions);
+                    Assert.True(callbackSawReleasedRun);
+                    Assert.True(viewModel.HasCompleted);
+                    Assert.False(viewModel.CanStartRestore);
                     Assert.False(RunCoordinator.IsRunning);
+
+                    await viewModel.StartRestoreAsync();
+                    Assert.Equal(1, completions);
                     owner.Close();
                 }
                 finally
@@ -92,7 +127,7 @@ private sealed class CancelingRunDialogService : IRunDialogService
             public void ShowPlanCompositionError(string text, string caption) { }
         }
 
-        private sealed class TestModule : BackupBase
+        private class TestModule : BackupBase
         {
             internal TestModule(string title) => Title = title;
             internal IReadOnlyList<RestoreCloseRequirement> Processes { get; set; } = Array.Empty<RestoreCloseRequirement>();
@@ -102,5 +137,11 @@ private sealed class TestModule : BackupBase
             public override bool RequiresExplorerRestart => Explorer;
             public override string WarningMessage => Warning;
         }
+
+        private sealed class InteractiveModule : TestModule
+        {
+            internal InteractiveModule(string title) : base(title) { }
+            public override bool RestoreMakesChanges => false;
+        }
     }
 }
diff --git a/src/WinRestoreKit.Tests/RebrandIdentityTests.cs b/src/WinRestoreKit.Tests/RebrandIdentityTests.cs
index 9bc076a..0ade87d 100644
--- a/src/WinRestoreKit.Tests/RebrandIdentityTests.cs
+++ b/src/WinRestoreKit.Tests/RebrandIdentityTests.cs
@@ -76,5 +76,15 @@ public void ParseLatestVersion_OnRealAssemblyInfo_ReturnsPinnedFallbackVersion()
             Assert.True(File.Exists(path), $"Expected AssemblyInfo test data at '{path}'.");
             Assert.Equal("0.0.1", global::DataHelper.Data.ParseLatestVersion(File.ReadAllText(path)));
         }
+
+        [Fact]
+        public void WpfShell_ReportsTheCanonicalProductVersion()
+        {
+            string path = Path.Combine(AppContext.BaseDirectory, "TestData", "AssemblyInfo.cs");
+            string canonical = global::DataHelper.Data.ParseLatestVersion(File.ReadAllText(path));
+
+            Assert.Equal(canonical,
+                global::WinRestoreKit.VersionInfo.GetCurrentVersion(typeof(global::WinRestoreKit.Wpf.App).Assembly));
+        }
     }
 }
diff --git a/src/WinRestoreKit.Tests/RestoreConsentDialogTests.cs b/src/WinRestoreKit.Tests/RestoreConsentDialogTests.cs
index 0ae011b..011cb1c 100644
--- a/src/WinRestoreKit.Tests/RestoreConsentDialogTests.cs
+++ b/src/WinRestoreKit.Tests/RestoreConsentDialogTests.cs
@@ -1,6 +1,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Windows;
+using System.Windows.Automation;
+using System.Windows.Controls;
 using WinRestoreKit;
 using WinRestoreKit.Wpf.Views.Dialogs;
 using Xunit;
@@ -26,6 +28,35 @@ public void RestoreConsentDialog_IsOwnerBoundAndDefaultsToNoConsentedProcesses()
             });
         }
 
+        [Fact]
+        public void RestoreConsentDialog_IsResizableScrollableAndWrapsLongConsentText()
+        {
+            WpfTestHost.Run(() =>
+            {
+                Window owner = new Window();
+                owner.Show();
+                RestorePlan plan = PlanWithOneConsentEntry();
+                RestoreConsentDialog dialog = RestoreConsentDialog.Create(owner, plan);
+                dialog.Show();
+                dialog.UpdateLayout();
+
+                Assert.Equal(ResizeMode.CanResizeWithGrip, dialog.ResizeMode);
+                Assert.Equal(SizeToContent.Manual, dialog.SizeToContent);
+                Assert.True(dialog.Width <= SystemParameters.WorkArea.Width);
+                Assert.True(dialog.Height <= SystemParameters.WorkArea.Height);
+                Assert.NotNull(dialog.FindName("ConsentScrollViewer"));
+                TextBlock confirmation = Assert.IsType<TextBlock>(dialog.FindName("ConsentConfirmationText"));
+                TextBlock notice = Assert.IsType<TextBlock>(dialog.FindName("ConsentSnapshotNotice"));
+                Assert.Equal(TextWrapping.Wrap, confirmation.TextWrapping);
+                Assert.Equal(TextWrapping.Wrap, notice.TextWrapping);
+                Assert.Equal(plan.ConfirmationText, AutomationProperties.GetHelpText(confirmation));
+                Assert.Equal(plan.SnapshotNotice, AutomationProperties.GetHelpText(notice));
+
+                dialog.Close();
+                owner.Close();
+            });
+        }
+
         private static RestorePlan PlanWithOneConsentEntry()
         {
             ConsentModule module = new ConsentModule();
@@ -35,6 +66,11 @@ private static RestorePlan PlanWithOneConsentEntry()
         private sealed class ConsentModule : BackupBase
         {
             public ConsentModule() => Title = "Code";
+            public override IReadOnlyList<RestoreTarget> RestoreTargets
+                => new[]
+                {
+                    RestoreTarget.File(Path.Combine(Path.GetTempPath(), new string('x', 220), "settings.json"))
+                };
             public override IReadOnlyList<RestoreCloseRequirement> ProcessesToCloseBeforeRestore
                 => new[] { new RestoreCloseRequirement("code", "Visual Studio Code", true) };
         }
diff --git a/src/WinRestoreKit.Tests/RestorePlanTests.cs b/src/WinRestoreKit.Tests/RestorePlanTests.cs
index 43f4486..9db3ecf 100644
--- a/src/WinRestoreKit.Tests/RestorePlanTests.cs
+++ b/src/WinRestoreKit.Tests/RestorePlanTests.cs
@@ -18,15 +18,18 @@ private sealed class FakeModule : BackupBase
         {
             private readonly IReadOnlyList<RestoreTarget> targets;
             private readonly IReadOnlyList<RestoreCloseRequirement> closes;
+            private readonly bool makesChanges;
 
             public FakeModule(string title,
-                              IReadOnlyList<RestoreTarget> targets = null,
-                              IReadOnlyList<RestoreCloseRequirement> closes = null,
-                              string warning = "")
+                               IReadOnlyList<RestoreTarget> targets = null,
+                               IReadOnlyList<RestoreCloseRequirement> closes = null,
+                               string warning = "",
+                               bool makesChanges = true)
             {
                 Title = title;
                 this.targets = targets;
                 this.closes = closes;
+                this.makesChanges = makesChanges;
                 WarningMessage = warning;
             }
 
@@ -35,6 +38,17 @@ public override IReadOnlyList<RestoreTarget> RestoreTargets
 
             public override IReadOnlyList<RestoreCloseRequirement> ProcessesToCloseBeforeRestore
                 => closes ?? base.ProcessesToCloseBeforeRestore;
+
+            public int RestoreMakesChangesReads { get; private set; }
+
+            public override bool RestoreMakesChanges
+            {
+                get
+                {
+                    RestoreMakesChangesReads++;
+                    return makesChanges;
+                }
+            }
         }
 
         private static RestorePlan PlanFor(params BackupBase[] modules)
@@ -165,11 +179,43 @@ public void FidelityCaveat_IsWordedExactly()
         {
             Assert.Equal(
                 "The snapshot can put back settings this restore overwrites. It cannot remove " +
-                "registry values or files that this restore adds \u2014 restoring the snapshot " +
+                "registry values or files that this restore adds; restoring the snapshot " +
                 "merges it over the current state rather than resetting to it.",
                 RestorePlan.FidelityCaveat);
         }
 
+        [Fact]
+        public void InteractiveOnlyPlan_DoesNotPromiseWritesOrAPreRestoreSnapshot()
+        {
+            RestorePlan plan = PlanFor(new FakeModule("Remember installed apps",
+                new[] { RestoreTarget.Command("opens the app reinstall dialog") }, makesChanges: false));
+
+            Assert.False(plan.NeedsSnapshot);
+            Assert.Equal(RestorePlan.NoSnapshotNotice, plan.SnapshotNotice);
+            Assert.Contains("interactive restore step", plan.ConfirmationText);
+            Assert.DoesNotContain("overwritten", plan.ConfirmationText);
+            Assert.DoesNotContain(Snapshot, plan.ConfirmationText);
+        }
+
+        [Fact]
+        public void MixedPlan_SeparatesInteractiveItemsFromSettingsWritesAndStillNamesTheSnapshot()
+        {
+            var mouse = new FakeModule("Mouse", new[] { RestoreTarget.RegistryKey("HKCU\\Mouse") });
+            var apps = new FakeModule("Remember installed apps",
+                new[] { RestoreTarget.Command("opens the app reinstall dialog") }, makesChanges: false);
+            RestorePlan plan = PlanFor(
+                mouse,
+                apps);
+
+            Assert.True(plan.NeedsSnapshot);
+            Assert.Equal(RestorePlan.FidelityCaveat, plan.SnapshotNotice);
+            Assert.Contains("overwritten", plan.ConfirmationText);
+            Assert.Contains("interactive restore step", plan.ConfirmationText);
+            Assert.Contains(Snapshot, plan.ConfirmationText);
+            Assert.Equal(1, mouse.RestoreMakesChangesReads);
+            Assert.Equal(1, apps.RestoreMakesChangesReads);
+        }
+
         // The dialog shows the caveat from the constant, prominently and on its own. Composing it
         // into the scrolling module text as well would let one copy drift from the other.
         [Fact]
@@ -374,13 +420,14 @@ public void Plan_WithoutASourceOrASnapshotDestination_Throws(string missing)
         }
 
         [Fact]
-        public void Plan_WithNoModules_StillStatesWhereItRestoresFromAndSnapshotsTo()
+        public void Plan_WithNoModules_StatesTheSourceAndTruthfullyDeclinesASnapshot()
         {
             RestorePlan plan = new RestorePlan(null, Source, Snapshot);
 
             Assert.Empty(plan.Modules);
             Assert.Contains(Source, plan.ConfirmationText);
-            Assert.Contains(Snapshot, plan.ConfirmationText);
+            Assert.DoesNotContain(Snapshot, plan.ConfirmationText);
+            Assert.Contains(RestorePlan.NoSnapshotNotice, plan.ConfirmationText);
         }
     }
 }
diff --git a/src/WinRestoreKit.Tests/ResultWorkspaceViewModelTests.cs b/src/WinRestoreKit.Tests/ResultWorkspaceViewModelTests.cs
index c6a4aad..41814c2 100644
--- a/src/WinRestoreKit.Tests/ResultWorkspaceViewModelTests.cs
+++ b/src/WinRestoreKit.Tests/ResultWorkspaceViewModelTests.cs
@@ -1,5 +1,9 @@
 using System;
 using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Automation;
+using System.Windows.Controls;
+using System.Windows.Threading;
 using WinRestoreKit;
 using WinRestoreKit.Wpf.ViewModels;
 using Xunit;
@@ -54,16 +58,38 @@ public void ResultView_ExposesNeutralSeverityAndReturnToTimelineAction()
         {
             WpfTestHost.Run(() =>
             {
+                ResultWorkspaceViewModel viewModel = ResultWorkspaceViewModel.From(
+                    RunSummary.For(new[] { SucceededOutcome() }, true, RunVerb.Backup),
+                    new[] { SucceededOutcome() }, () => Task.CompletedTask);
                 var view = new WinRestoreKit.Wpf.Views.ResultWorkspaceView
                 {
-                    DataContext = ResultWorkspaceViewModel.From(
-                        RunSummary.For(new[] { SucceededOutcome() }, true, RunVerb.Backup),
-                        new[] { SucceededOutcome() }, () => Task.CompletedTask)
+                    DataContext = viewModel
                 };
+                var host = new Window { Content = view, Width = 1024, Height = 720 };
+                host.Show();
+                host.UpdateLayout();
+                Dispatcher.CurrentDispatcher.Invoke(
+                    DispatcherPriority.ApplicationIdle,
+                    new Action(() => { }));
 
-                Assert.NotNull(view.FindName("RunSeverityText"));
-                Assert.NotNull(view.FindName("RunOutcomesList"));
-                Assert.NotNull(view.FindName("ReturnTimelineButton"));
+                try
+                {
+                    TextBlock severity = Assert.IsType<TextBlock>(view.FindName("RunSeverityText"));
+                    TextBlock headline = Assert.IsType<TextBlock>(view.FindName("RunHeadlineText"));
+                    TextBlock detail = Assert.IsType<TextBlock>(view.FindName("RunDetailText"));
+                    Assert.Equal(viewModel.SeverityAutomationName,
+                        AutomationProperties.GetName(severity));
+                    Assert.Equal(viewModel.HeadlineAutomationName,
+                        AutomationProperties.GetName(headline));
+                    Assert.Equal(viewModel.DetailAutomationName,
+                        AutomationProperties.GetName(detail));
+                    Assert.NotNull(view.FindName("RunOutcomesList"));
+                    Assert.NotNull(view.FindName("ReturnTimelineButton"));
+                }
+                finally
+                {
+                    host.Close();
+                }
             });
         }
 
diff --git a/src/WinRestoreKit.Wpf/Navigation/CompareWorkflowNavigator.cs b/src/WinRestoreKit.Wpf/Navigation/CompareWorkflowNavigator.cs
index 2cba65c..e3f3c88 100644
--- a/src/WinRestoreKit.Wpf/Navigation/CompareWorkflowNavigator.cs
+++ b/src/WinRestoreKit.Wpf/Navigation/CompareWorkflowNavigator.cs
@@ -98,7 +98,8 @@ private async Task ReplaceWorkspaceAsync(SnapshotPayloadPreparation incoming, in
 
         private void ShowConfirm(SnapshotEvent snapshot, IReadOnlyList<BackupBase> modules)
         {
-            ConfirmViewModel confirm = new ConfirmViewModel(snapshot, modules, () => shell.ShowCompare(currentWorkspace));
+            ConfirmViewModel confirm = new ConfirmViewModel(snapshot, modules,
+                () => shell.ShowCompare(currentWorkspace), shell.ShowResult);
             shell.ShowConfirm(confirm);
         }
     }
diff --git a/src/WinRestoreKit.Wpf/ViewModels/BackupWorkspaceViewModel.cs b/src/WinRestoreKit.Wpf/ViewModels/BackupWorkspaceViewModel.cs
index 860d05f..f57040b 100644
--- a/src/WinRestoreKit.Wpf/ViewModels/BackupWorkspaceViewModel.cs
+++ b/src/WinRestoreKit.Wpf/ViewModels/BackupWorkspaceViewModel.cs
@@ -26,6 +26,14 @@ internal BackupWorkspaceViewModel(Func<BackupRunRequest, Task> startRunAsync,
             compression = SnapshotCompression.Fast;
             Scopes = new ObservableCollection<BackupScopeItemViewModel>(
                 ScopeGroups.Build().Select(scope => new BackupScopeItemViewModel(scope)));
+            foreach (BackupScopeItemViewModel scope in Scopes)
+            {
+                scope.PropertyChanged += (_, e) =>
+                {
+                    if (e.PropertyName == nameof(BackupScopeItemViewModel.IsSelected))
+                        SetValidationMessage(null);
+                };
+            }
             StartCommand = new AsyncDelegateCommand(StartAsync, ex => SetValidationMessage(ex.Message));
             SelectAllCommand = new DelegateCommand(_ => SelectAll());
             ClearCommand = new DelegateCommand(_ => Clear());
@@ -44,19 +52,31 @@ internal BackupWorkspaceViewModel(Func<BackupRunRequest, Task> startRunAsync,
         public string SnapshotName
         {
             get => snapshotName;
-            set => SetProperty(ref snapshotName, value ?? string.Empty, nameof(SnapshotName));
+            set
+            {
+                if (SetProperty(ref snapshotName, value ?? string.Empty, nameof(SnapshotName)))
+                    SetValidationMessage(null);
+            }
         }
 
         public string Destination
         {
             get => destination;
-            set => SetProperty(ref destination, value ?? string.Empty, nameof(Destination));
+            set
+            {
+                if (SetProperty(ref destination, value ?? string.Empty, nameof(Destination)))
+                    SetValidationMessage(null);
+            }
         }
 
         public SnapshotCompression Compression
         {
             get => compression;
-            set => SetProperty(ref compression, value, nameof(Compression));
+            set
+            {
+                if (SetProperty(ref compression, value, nameof(Compression)))
+                    SetValidationMessage(null);
+            }
         }
 
         public string ValidationMessage
@@ -65,6 +85,10 @@ public string ValidationMessage
             private set => SetProperty(ref validationMessage, value, nameof(ValidationMessage));
         }
 
+        public string ValidationAutomationName => string.IsNullOrWhiteSpace(ValidationMessage)
+            ? "Snapshot validation"
+            : "Snapshot validation: " + ValidationMessage;
+
         public ICommand StartCommand { get; }
         public ICommand SelectAllCommand { get; }
         public ICommand ClearCommand { get; }
@@ -120,6 +144,9 @@ private void SelectModulesByTypeName(IEnumerable<string> moduleTypeNames,
         }
 
         private void SetValidationMessage(string message)
-            => ValidationMessage = string.IsNullOrWhiteSpace(message) ? null : message;
+        {
+            ValidationMessage = string.IsNullOrWhiteSpace(message) ? null : message;
+            OnPropertyChanged(nameof(ValidationAutomationName));
+        }
     }
 }
diff --git a/src/WinRestoreKit.Wpf/ViewModels/ConfirmViewModel.cs b/src/WinRestoreKit.Wpf/ViewModels/ConfirmViewModel.cs
index 7245140..26d62c6 100644
--- a/src/WinRestoreKit.Wpf/ViewModels/ConfirmViewModel.cs
+++ b/src/WinRestoreKit.Wpf/ViewModels/ConfirmViewModel.cs
@@ -26,20 +26,27 @@ internal Notice(string title, string text)
     internal sealed class ConfirmViewModel : ObservableObject, IRunPresentation
     {
         private readonly Action backToCompare;
+        private readonly Action<RunSummary, IReadOnlyList<ModuleOutcome>> showResult;
         private readonly ObservableCollection<string> logLines = new ObservableCollection<string>();
+        private IReadOnlyList<ModuleOutcome> summaryOutcomes = Array.Empty<ModuleOutcome>();
         private Dispatcher dispatcher;
         private IRunDialogService dialogService;
         private Func<Window> ownerProvider;
         private RunControl activeControl;
         private bool isRestoring;
 
-        internal ConfirmViewModel(SnapshotEvent snapshot, IReadOnlyList<BackupBase> modules, Action backToCompare = null)
+        internal ConfirmViewModel(SnapshotEvent snapshot, IReadOnlyList<BackupBase> modules,
+            Action backToCompare = null,
+            Action<RunSummary, IReadOnlyList<ModuleOutcome>> showResult = null)
         {
             Snapshot = snapshot ?? throw new ArgumentNullException(nameof(snapshot));
             Modules = modules == null ? Array.Empty<BackupBase>() : modules.Where(module => module != null).ToArray();
             this.backToCompare = backToCompare;
+            this.showResult = showResult;
             LogLines = new ReadOnlyObservableCollection<string>(logLines);
-            FidelityCaveat = RestorePlan.FidelityCaveat;
+            FidelityCaveat = Modules.Any(module => module.RestoreMakesChanges)
+                ? RestorePlan.FidelityCaveat
+                : RestorePlan.NoSnapshotNotice;
             ConsentProcesses = SelectProcesses(true);
             InformationalProcesses = SelectProcesses(false);
             ExplorerRestartModules = Modules.Where(module => module.RequiresExplorerRestart).ToArray();
@@ -58,6 +65,9 @@ internal ConfirmViewModel(SnapshotEvent snapshot, IReadOnlyList<BackupBase> modu
         public IReadOnlyList<BackupBase> ExplorerRestartModules { get; }
         public IReadOnlyList<Notice> ModuleWarnings { get; }
         public string FidelityCaveat { get; }
+        public string RestoreSelectionSummary => Modules.Count == 1
+            ? "1 selected module will be evaluated for restore from this snapshot."
+            : Modules.Count + " selected modules will be evaluated for restore from this snapshot.";
         public bool IsSourcePartial => Snapshot.Kind == SnapshotEventKind.Partial;
         public bool IsRestoring
         {
@@ -77,7 +87,9 @@ private set
             }
         }
 
-        public bool CanStartRestore => Modules.Count != 0 && !IsRestoring && dialogService != null && ownerProvider != null;
+        public bool HasCompleted { get; private set; }
+        public bool CanStartRestore => Modules.Count != 0 && !IsRestoring && !HasCompleted
+            && dialogService != null && ownerProvider != null;
         public bool CanNavigate => !IsRestoring;
         public string ProgressText { get; private set; } = string.Empty;
         public RunSummary Summary { get; private set; }
@@ -98,7 +110,8 @@ internal void AttachRunSurfaces(Dispatcher dispatcher, Func<Window> ownerProvide
 
         internal async Task StartRestoreAsync()
         {
-            if (Modules.Count == 0 || IsRestoring || dialogService == null || ownerProvider == null || !RunCoordinator.TryStart())
+            if (Modules.Count == 0 || IsRestoring || HasCompleted || dialogService == null
+                || ownerProvider == null || !RunCoordinator.TryStart())
                 return;
 
             activeControl = new RunControl();
@@ -126,6 +139,9 @@ internal async Task StartRestoreAsync()
                 IsRestoring = false;
                 RunCoordinator.SetRunning(false);
             }
+
+            if (Summary != null)
+                showResult?.Invoke(Summary, summaryOutcomes);
         }
 
         public void SetProgressText(string text)
@@ -140,7 +156,12 @@ public void SetProgressDetail(string groupInfo, string elapsed, string remaining
         public void ShowSummary(RunSummary summary, string caption, IReadOnlyList<ModuleOutcome> outcomes)
         {
             Summary = summary;
+            summaryOutcomes = outcomes ?? Array.Empty<ModuleOutcome>();
+            HasCompleted = summary != null;
             OnPropertyChanged(nameof(Summary));
+            OnPropertyChanged(nameof(HasCompleted));
+            OnPropertyChanged(nameof(CanStartRestore));
+            StartRestoreCommand.RaiseCanExecuteChanged();
         }
 
         public void SetExplorerRestartVisible(bool visible)
diff --git a/src/WinRestoreKit.Wpf/ViewModels/ResultWorkspaceViewModel.cs b/src/WinRestoreKit.Wpf/ViewModels/ResultWorkspaceViewModel.cs
index 8205b88..be7ebb6 100644
--- a/src/WinRestoreKit.Wpf/ViewModels/ResultWorkspaceViewModel.cs
+++ b/src/WinRestoreKit.Wpf/ViewModels/ResultWorkspaceViewModel.cs
@@ -32,6 +32,9 @@ private ResultWorkspaceViewModel(RunSummary summary, IReadOnlyList<ModuleOutcome
             RunSeverity.Error => "Error",
             _ => "Information"
         };
+        public string SeverityAutomationName => "Run severity: " + SeverityText;
+        public string HeadlineAutomationName => "Run headline: " + Headline;
+        public string DetailAutomationName => "Run detail: " + Detail;
         public ICommand ReturnToTimelineCommand { get; }
 
         internal static ResultWorkspaceViewModel From(RunSummary summary,
diff --git a/src/WinRestoreKit.Wpf/ViewModels/ShellViewModel.cs b/src/WinRestoreKit.Wpf/ViewModels/ShellViewModel.cs
index 9b78cbc..56f7455 100644
--- a/src/WinRestoreKit.Wpf/ViewModels/ShellViewModel.cs
+++ b/src/WinRestoreKit.Wpf/ViewModels/ShellViewModel.cs
@@ -1,5 +1,6 @@
 using DataHelper;
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Input;
@@ -109,6 +110,9 @@ internal void ShowCompare(ComparisonWorkspaceViewModel workspace)
         internal void ShowConfirm(ConfirmViewModel confirm)
             => NavigateTo(confirm ?? throw new ArgumentNullException(nameof(confirm)), "Confirm");
 
+        internal void ShowResult(RunSummary summary, IReadOnlyList<ModuleOutcome> outcomes)
+            => NavigateTo(ResultWorkspaceViewModel.From(summary, outcomes, ReturnToTimelineAsync), "Restore result");
+
         internal bool RequestWindowClose()
         {
             if (!RunCoordinator.IsRunning)
diff --git a/src/WinRestoreKit.Wpf/Views/BackupWorkspaceView.xaml b/src/WinRestoreKit.Wpf/Views/BackupWorkspaceView.xaml
index bb79674..ec1dea8 100644
--- a/src/WinRestoreKit.Wpf/Views/BackupWorkspaceView.xaml
+++ b/src/WinRestoreKit.Wpf/Views/BackupWorkspaceView.xaml
@@ -317,13 +317,15 @@
                          Foreground="{DynamicResource WarningTextBrush}"
                          Margin="0,0,10,0"
                          VerticalAlignment="Center" />
-              <TextBlock Text="{Binding ValidationMessage}"
+              <TextBlock x:Name="BackupValidationText"
+                         Text="{Binding ValidationMessage}"
                          Style="{DynamicResource BodyTextStyle}"
                          TextWrapping="Wrap"
                          MaxWidth="520"
                          Foreground="{DynamicResource WarningTextBrush}"
                          AutomationProperties.LiveSetting="Polite"
-                         AutomationProperties.Name="Snapshot validation"
+                         AutomationProperties.Name="{Binding ValidationAutomationName}"
+                         AutomationProperties.HelpText="{Binding ValidationMessage}"
                          AutomationProperties.AutomationId="BackupValidationMessage" />
             </StackPanel>
           </Border>
diff --git a/src/WinRestoreKit.Wpf/Views/ConfirmView.xaml b/src/WinRestoreKit.Wpf/Views/ConfirmView.xaml
index c888a42..d36d4d8 100644
--- a/src/WinRestoreKit.Wpf/Views/ConfirmView.xaml
+++ b/src/WinRestoreKit.Wpf/Views/ConfirmView.xaml
@@ -66,7 +66,7 @@
           <StackPanel>
             <TextBlock Text="Selected source is partial." TextWrapping="Wrap" FontSize="13" FontWeight="SemiBold"
                        Foreground="{DynamicResource WarningTextBrush}" />
-            <TextBlock Text="Some modules may be missing from this snapshot. You will be asked to consent again before anything is written."
+            <TextBlock Text="Some modules may be missing from this snapshot. You will be asked to consent again before the restore continues."
                        TextWrapping="Wrap" FontSize="12" Margin="0,3,0,0"
                        Foreground="{DynamicResource MutedTextBrush}" />
           </StackPanel>
@@ -341,10 +341,10 @@
           <ColumnDefinition Width="*" />
           <ColumnDefinition Width="Auto" />
         </Grid.ColumnDefinitions>
-        <TextBlock VerticalAlignment="Center" FontSize="13" Foreground="{DynamicResource MutedTextBrush}">
-          <Run Text="{Binding Modules.Count, Mode=OneWay}" />
-          <Run Text="modules will be written from this snapshot." />
-        </TextBlock>
+        <TextBlock Text="{Binding RestoreSelectionSummary}"
+                   VerticalAlignment="Center" FontSize="13"
+                   TextWrapping="Wrap"
+                   Foreground="{DynamicResource MutedTextBrush}" />
         <StackPanel Grid.Column="1" Orientation="Horizontal" HorizontalAlignment="Right">
           <Button Content="Back to compare" Command="{Binding BackToCompareCommand}" IsEnabled="{Binding CanNavigate}"
                   Style="{DynamicResource SecondaryButtonStyle}" />
diff --git a/src/WinRestoreKit.Wpf/Views/Dialogs/RestoreConsentDialog.xaml b/src/WinRestoreKit.Wpf/Views/Dialogs/RestoreConsentDialog.xaml
index a612e48..d853f7b 100644
--- a/src/WinRestoreKit.Wpf/Views/Dialogs/RestoreConsentDialog.xaml
+++ b/src/WinRestoreKit.Wpf/Views/Dialogs/RestoreConsentDialog.xaml
@@ -4,22 +4,34 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         Title="Restore" WindowStartupLocation="CenterOwner"
         AutomationProperties.Name="Restore consent"
+        AutomationProperties.IsDialog="True"
         Background="{DynamicResource WindowBackgroundBrush}"
         Foreground="{DynamicResource TextBrush}"
-        Width="560" MinWidth="480" MaxHeight="720"
-        SizeToContent="Height" ResizeMode="NoResize" ShowInTaskbar="False">
+        Width="680" Height="620" MinWidth="400" MinHeight="320" MaxWidth="960"
+        SizeToContent="Manual" ResizeMode="CanResizeWithGrip" ShowInTaskbar="False">
   <!-- Shared keys use DynamicResource: this dialog is constructed in tests on a bare STA thread
        with no Application, where a StaticResource lookup for an app-level key would throw. -->
   <Grid Margin="24">
     <Grid.RowDefinitions><RowDefinition Height="*"/><RowDefinition Height="Auto"/></Grid.RowDefinitions>
-    <ScrollViewer VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Disabled"><StackPanel>
-      <StackPanel Orientation="Horizontal">
+    <ScrollViewer x:Name="ConsentScrollViewer"
+                  VerticalScrollBarVisibility="Auto"
+                  HorizontalScrollBarVisibility="Disabled"><StackPanel>
+      <Grid>
+        <Grid.ColumnDefinitions>
+          <ColumnDefinition Width="Auto" />
+          <ColumnDefinition Width="*" />
+        </Grid.ColumnDefinitions>
         <TextBlock Text="&#xE7BA;" FontFamily="Segoe Fluent Icons, Segoe MDL2 Assets" FontSize="18"
                    VerticalAlignment="Top" Margin="0,1,12,0"
                    Foreground="{DynamicResource WarningTextBrush}" />
-        <TextBlock Text="{Binding ConfirmationText}" TextWrapping="Wrap" FontSize="14"
-                   Foreground="{DynamicResource TextBrush}" />
-      </StackPanel>
+        <TextBlock x:Name="ConsentConfirmationText"
+                   Grid.Column="1"
+                   Text="{Binding ConfirmationText}"
+                   TextWrapping="Wrap" TextTrimming="None" FontSize="14"
+                   Foreground="{DynamicResource TextBrush}"
+                   AutomationProperties.Name="Restore impact details"
+                   AutomationProperties.HelpText="{Binding ConfirmationText}" />
+      </Grid>
 
       <Grid>
         <Grid.Style>
@@ -69,13 +81,21 @@
         </ItemsControl>
       </StackPanel>
 
-      <StackPanel Orientation="Horizontal" Margin="0,18,0,0">
+      <Grid Margin="0,18,0,0">
+        <Grid.ColumnDefinitions>
+          <ColumnDefinition Width="Auto" />
+          <ColumnDefinition Width="*" />
+        </Grid.ColumnDefinitions>
         <TextBlock Text="&#xE946;" FontFamily="Segoe Fluent Icons, Segoe MDL2 Assets" FontSize="13"
                    VerticalAlignment="Top" Margin="0,1,10,0"
                    Foreground="{DynamicResource MutedTextBrush}" />
-        <TextBlock Text="{Binding FidelityCaveat}" TextWrapping="Wrap" FontSize="12"
-                   Foreground="{DynamicResource MutedTextBrush}" />
-      </StackPanel>
+        <TextBlock x:Name="ConsentSnapshotNotice"
+                   Grid.Column="1"
+                   Text="{Binding SnapshotNotice}" TextWrapping="Wrap" TextTrimming="None" FontSize="12"
+                   Foreground="{DynamicResource MutedTextBrush}"
+                   AutomationProperties.Name="Snapshot notice"
+                   AutomationProperties.HelpText="{Binding SnapshotNotice}" />
+      </Grid>
     </StackPanel></ScrollViewer>
     <StackPanel Grid.Row="1" Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,20,0,0">
       <Button Content="Cancel" IsCancel="True" Style="{DynamicResource SecondaryButtonStyle}" />
diff --git a/src/WinRestoreKit.Wpf/Views/Dialogs/RestoreConsentDialog.xaml.cs b/src/WinRestoreKit.Wpf/Views/Dialogs/RestoreConsentDialog.xaml.cs
index c13489d..3ad3018 100644
--- a/src/WinRestoreKit.Wpf/Views/Dialogs/RestoreConsentDialog.xaml.cs
+++ b/src/WinRestoreKit.Wpf/Views/Dialogs/RestoreConsentDialog.xaml.cs
@@ -44,6 +44,8 @@ internal RestoreConsentDialog(RestorePlan plan)
             this.plan = plan ?? throw new ArgumentNullException(nameof(plan));
             consentChoices = new ObservableCollection<ConsentChoice>(this.plan.ConsentEntries.Select(entry => new ConsentChoice(entry)));
             InitializeComponent();
+            ConstrainToWorkArea();
+            Loaded += (_, _) => ConstrainToWorkArea();
             DataContext = this;
         }
 
@@ -51,7 +53,7 @@ internal static RestoreConsentDialog Create(Window owner, RestorePlan plan)
             => new RestoreConsentDialog(plan) { Owner = owner ?? throw new ArgumentNullException(nameof(owner)) };
 
         public string ConfirmationText => plan.ConfirmationText;
-        public string FidelityCaveat => RestorePlan.FidelityCaveat;
+        public string SnapshotNotice => plan.SnapshotNotice;
         public IReadOnlyList<string> InformationalCloseLines => plan.InformationalCloseLines;
         public IEnumerable ConsentChoices => consentChoices;
         public IReadOnlyList<string> ConsentedProcessNames
@@ -61,5 +63,15 @@ private void Restore_Click(object sender, RoutedEventArgs e)
         {
             DialogResult = true;
         }
+
+        private void ConstrainToWorkArea()
+        {
+            const double workAreaInset = 32;
+            Rect workArea = SystemParameters.WorkArea;
+            MaxWidth = Math.Max(MinWidth, Math.Min(960, workArea.Width - workAreaInset));
+            MaxHeight = Math.Max(MinHeight, workArea.Height - workAreaInset);
+            Width = Math.Min(680, MaxWidth);
+            Height = Math.Min(620, MaxHeight);
+        }
     }
 }
diff --git a/src/WinRestoreKit.Wpf/Views/ResultWorkspaceView.xaml b/src/WinRestoreKit.Wpf/Views/ResultWorkspaceView.xaml
index 3fe8083..7ab4612 100644
--- a/src/WinRestoreKit.Wpf/Views/ResultWorkspaceView.xaml
+++ b/src/WinRestoreKit.Wpf/Views/ResultWorkspaceView.xaml
@@ -130,7 +130,8 @@
               <TextBlock x:Name="RunSeverityText"
                          Text="{Binding SeverityText}"
                          Style="{StaticResource SeverityTextStyle}"
-                         AutomationProperties.Name="Run severity"
+                         AutomationProperties.Name="{Binding SeverityAutomationName}"
+                         AutomationProperties.HelpText="{Binding SeverityText}"
                          AutomationProperties.AutomationId="RunSeverityText" />
             </Border>
             <TextBlock Text="{Binding StatusLabel}"
@@ -148,7 +149,8 @@
                      FontWeight="SemiBold"
                      TextWrapping="Wrap"
                      Margin="0,14,0,0"
-                     AutomationProperties.Name="Run headline"
+                     AutomationProperties.Name="{Binding HeadlineAutomationName}"
+                     AutomationProperties.HelpText="{Binding Headline}"
                      AutomationProperties.AutomationId="RunHeadlineText" />
           <TextBlock x:Name="RunDetailText"
                      Text="{Binding Detail}"
@@ -156,7 +158,8 @@
                      Foreground="{DynamicResource MutedTextBrush}"
                      TextWrapping="Wrap"
                      Margin="0,8,0,0"
-                     AutomationProperties.Name="Run detail"
+                     AutomationProperties.Name="{Binding DetailAutomationName}"
+                     AutomationProperties.HelpText="{Binding Detail}"
                      AutomationProperties.AutomationId="RunDetailText" />
         </StackPanel>
       </Border>
diff --git a/src/WinRestoreKit.Wpf/WinRestoreKit.Wpf.csproj b/src/WinRestoreKit.Wpf/WinRestoreKit.Wpf.csproj
index 92aa7c0..b35bda9 100644
--- a/src/WinRestoreKit.Wpf/WinRestoreKit.Wpf.csproj
+++ b/src/WinRestoreKit.Wpf/WinRestoreKit.Wpf.csproj
@@ -17,6 +17,12 @@
     <ImplicitUsings>disable</ImplicitUsings>
     <Platforms>AnyCPU</Platforms>
     <Deterministic>true</Deterministic>
+    <!-- Keep the side-by-side WPF shell aligned with the canonical product version in
+         WinRestoreKit/Properties/AssemblyInfo.cs. RebrandIdentityTests guards this duplicate. -->
+    <Version>0.0.1</Version>
+    <AssemblyVersion>0.0.1.0</AssemblyVersion>
+    <FileVersion>0.0.1.0</FileVersion>
+    <InformationalVersion>0.0.1</InformationalVersion>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\WinRestoreKit.Application\WinRestoreKit.Application.csproj" />

From 36d1e90e9d4a876818ec5883f3a4c6993ca85624 Mon Sep 17 00:00:00 2001
From: nicolasestrem <103498114+nicolasestrem@users.noreply.github.com>
Date: Mon, 10 Aug 2026 01:42:47 +0200
Subject: [PATCH 2/3] fix(wpf): make Escape leave comparison

---
 CHANGELOG.md                             |  3 ++-
 src/WinRestoreKit.Tests/WpfShellTests.cs | 24 ++++++++++++++++++++++++
 src/WinRestoreKit.Wpf/MainWindow.xaml    |  3 ++-
 src/WinRestoreKit.Wpf/MainWindow.xaml.cs | 20 ++++++++++++++++++++
 4 files changed, 48 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3f48cb7..1fbc6db 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -41,7 +41,8 @@ version numbers, because that is what those releases were called.
 ### 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.
+  snapshot workspace is reachable, and bound Escape to Timeline so keyboard 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
diff --git a/src/WinRestoreKit.Tests/WpfShellTests.cs b/src/WinRestoreKit.Tests/WpfShellTests.cs
index cb28427..6925241 100644
--- a/src/WinRestoreKit.Tests/WpfShellTests.cs
+++ b/src/WinRestoreKit.Tests/WpfShellTests.cs
@@ -48,6 +48,30 @@ public void Shell_PrimaryNavigationCommandsReachEveryWorkspaceAndReturnToTimelin
             });
         }
 
+        [Fact]
+        public void MainWindow_EscapeReturnsFromCompareToTimeline()
+        {
+            WpfTestHost.Run(() =>
+            {
+                ShellViewModel shell = CreateShell();
+                MainWindow window = new MainWindow(shell);
+                var snapshot = new SnapshotEvent(SnapshotEventKind.Partial, DateTime.UtcNow, "snapshot",
+                    string.Empty, string.Empty, string.Empty, 0, true, null);
+                var comparison = new ComparisonWorkspaceViewModel(snapshot,
+                    Array.Empty<BackupModuleRegistration>(), new SnapshotComparisonService(), (_, _) => { });
+
+                shell.ShowCompare(comparison);
+                Assert.True(window.ReturnToTimelineFromCompare());
+                Dispatcher.CurrentDispatcher.Invoke(
+                    DispatcherPriority.ApplicationIdle,
+                    new Action(() => { }));
+
+                Assert.Equal("Timeline", shell.WorkflowLabel);
+                Assert.IsType<TimelineViewModel>(shell.CurrentWorkspace);
+                window.Close();
+            });
+        }
+
         [Fact]
         public void Shell_PrimaryNavigationCommandsCannotHideAnActiveRun()
         {
diff --git a/src/WinRestoreKit.Wpf/MainWindow.xaml b/src/WinRestoreKit.Wpf/MainWindow.xaml
index 9fd3d7e..00e7e0a 100644
--- a/src/WinRestoreKit.Wpf/MainWindow.xaml
+++ b/src/WinRestoreKit.Wpf/MainWindow.xaml
@@ -11,7 +11,8 @@
         FontFamily="{DynamicResource ApplicationFont}"
         FontSize="13"
         Foreground="{DynamicResource TextBrush}"
-        Background="{DynamicResource WindowBackgroundBrush}">
+        Background="{DynamicResource WindowBackgroundBrush}"
+        PreviewKeyDown="OnPreviewKeyDown">
   <Window.Resources>
     <DataTemplate DataType="{x:Type timeline:TimelineViewModel}"><views:TimelineView /></DataTemplate>
     <DataTemplate DataType="{x:Type history:AdvancedHistoryViewModel}"><views:AdvancedHistoryView /></DataTemplate>
diff --git a/src/WinRestoreKit.Wpf/MainWindow.xaml.cs b/src/WinRestoreKit.Wpf/MainWindow.xaml.cs
index 11e2c38..c567a7a 100644
--- a/src/WinRestoreKit.Wpf/MainWindow.xaml.cs
+++ b/src/WinRestoreKit.Wpf/MainWindow.xaml.cs
@@ -1,6 +1,7 @@
 using System;
 using System.ComponentModel;
 using System.Windows;
+using System.Windows.Input;
 using WinRestoreKit;
 using WinRestoreKit.Wpf.Navigation;
 using WinRestoreKit.Wpf.Services;
@@ -30,5 +31,24 @@ protected override void OnClosing(CancelEventArgs e)
 
             base.OnClosing(e);
         }
+
+        private void OnPreviewKeyDown(object sender, KeyEventArgs e)
+        {
+            if (e.Key == Key.Escape && ReturnToTimelineFromCompare())
+                e.Handled = true;
+        }
+
+        internal bool ReturnToTimelineFromCompare()
+        {
+            if (DataContext is not ShellViewModel shell
+                || shell.CurrentWorkspace is not ComparisonWorkspaceViewModel
+                || !shell.ShowTimelineCommand.CanExecute(null))
+            {
+                return false;
+            }
+
+            shell.ShowTimelineCommand.Execute(null);
+            return true;
+        }
     }
 }

From 41ed18a4a08ca386be39f8150a9afd3bb1926c0f Mon Sep 17 00:00:00 2001
From: nicolasestrem <103498114+nicolasestrem@users.noreply.github.com>
Date: Mon, 10 Aug 2026 02:02:27 +0200
Subject: [PATCH 3/3] fix(wpf): keep long result actions reachable

---
 CHANGELOG.md                                  |  3 +-
 .../ResultWorkspaceViewModelTests.cs          | 46 +++++++++++++++++++
 .../Views/ResultWorkspaceView.xaml            | 24 ++++++----
 3 files changed, 63 insertions(+), 10 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1fbc6db..11b7f1a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,7 +16,8 @@ version numbers, because that is what those releases were called.
 - Made final restore consent resizable and scrollable so long paths wrap without clipping, and only
   promised a pre-restore snapshot for modules that actually write settings.
 - Routed completed restores to the result workspace and prevented the same confirmation page from
-  accidentally starting a second restore.
+  accidentally starting a second restore, while keeping long result summaries scrollable so the
+  Timeline action stays reachable.
 
 ### Fixed: restore and snapshot integrity
 
diff --git a/src/WinRestoreKit.Tests/ResultWorkspaceViewModelTests.cs b/src/WinRestoreKit.Tests/ResultWorkspaceViewModelTests.cs
index 41814c2..e8b4bcd 100644
--- a/src/WinRestoreKit.Tests/ResultWorkspaceViewModelTests.cs
+++ b/src/WinRestoreKit.Tests/ResultWorkspaceViewModelTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Automation;
@@ -93,6 +94,51 @@ public void ResultView_ExposesNeutralSeverityAndReturnToTimelineAction()
             });
         }
 
+        [Fact]
+        public void ResultView_LongSummaryKeepsTimelineActionReachable()
+        {
+            WpfTestHost.Run(() =>
+            {
+                ModuleOutcome[] outcomes = Enumerable.Range(1, 29)
+                    .Select(index => new ModuleOutcome($"Module {index}", ModuleResult.Aggregate(new[]
+                    {
+                        StepResult.Failed($"Step {index}",
+                            $"Detailed failure {index} that must remain readable without pushing actions away.")
+                    })))
+                    .ToArray();
+                ResultWorkspaceViewModel viewModel = ResultWorkspaceViewModel.From(
+                    RunSummary.For(outcomes, true, RunVerb.Backup), outcomes, () => Task.CompletedTask);
+                var view = new WinRestoreKit.Wpf.Views.ResultWorkspaceView
+                {
+                    DataContext = viewModel
+                };
+                var host = new Window { Content = view, Width = 1024, Height = 620 };
+                host.Show();
+                host.UpdateLayout();
+                Dispatcher.CurrentDispatcher.Invoke(
+                    DispatcherPriority.ApplicationIdle,
+                    new Action(() => { }));
+
+                try
+                {
+                    ScrollViewer detailScroller = Assert.IsType<ScrollViewer>(
+                        view.FindName("RunDetailScroller"));
+                    Button returnButton = Assert.IsType<Button>(view.FindName("ReturnTimelineButton"));
+                    Rect buttonBounds = returnButton.TransformToAncestor(view)
+                        .TransformBounds(new Rect(returnButton.RenderSize));
+
+                    Assert.True(detailScroller.ScrollableHeight > 0);
+                    Assert.InRange(detailScroller.ActualHeight, 1, 180);
+                    Assert.True(buttonBounds.Top >= 0);
+                    Assert.True(buttonBounds.Bottom <= view.ActualHeight);
+                }
+                finally
+                {
+                    host.Close();
+                }
+            });
+        }
+
         [Fact]
         public async Task Result_ReturnToTimelineCommand_InvokesTheSuppliedAction()
         {
diff --git a/src/WinRestoreKit.Wpf/Views/ResultWorkspaceView.xaml b/src/WinRestoreKit.Wpf/Views/ResultWorkspaceView.xaml
index 7ab4612..de8c7b2 100644
--- a/src/WinRestoreKit.Wpf/Views/ResultWorkspaceView.xaml
+++ b/src/WinRestoreKit.Wpf/Views/ResultWorkspaceView.xaml
@@ -152,15 +152,21 @@
                      AutomationProperties.Name="{Binding HeadlineAutomationName}"
                      AutomationProperties.HelpText="{Binding Headline}"
                      AutomationProperties.AutomationId="RunHeadlineText" />
-          <TextBlock x:Name="RunDetailText"
-                     Text="{Binding Detail}"
-                     Style="{DynamicResource BodyTextStyle}"
-                     Foreground="{DynamicResource MutedTextBrush}"
-                     TextWrapping="Wrap"
-                     Margin="0,8,0,0"
-                     AutomationProperties.Name="{Binding DetailAutomationName}"
-                     AutomationProperties.HelpText="{Binding Detail}"
-                     AutomationProperties.AutomationId="RunDetailText" />
+          <ScrollViewer x:Name="RunDetailScroller"
+                        MaxHeight="180"
+                        Margin="0,8,0,0"
+                        HorizontalScrollBarVisibility="Disabled"
+                        VerticalScrollBarVisibility="Auto"
+                        CanContentScroll="False">
+            <TextBlock x:Name="RunDetailText"
+                       Text="{Binding Detail}"
+                       Style="{DynamicResource BodyTextStyle}"
+                       Foreground="{DynamicResource MutedTextBrush}"
+                       TextWrapping="Wrap"
+                       AutomationProperties.Name="{Binding DetailAutomationName}"
+                       AutomationProperties.HelpText="{Binding Detail}"
+                       AutomationProperties.AutomationId="RunDetailText" />
+          </ScrollViewer>
         </StackPanel>
       </Border>