From ce8d0dfe8d9b32eaefb8b49f8ec4034e15281588 Mon Sep 17 00:00:00 2001
From: Stuart Meeks <stuart.meeks@stuartmeeks.net>
Date: Fri, 29 May 2026 17:57:04 +0000
Subject: [PATCH 1/3] Phase 6: editable settings + Velopack update check
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Settings page becomes interactive:
  - Theme combo (System/Light/Dark) applies live via IThemeApplier ->
    MainWindow.Content.RequestedTheme.
  - Close behaviour combo (Hide-to-tray vs Exit) persists immediately.
  - Hotkey + storage location shown read-only with a note about future
    rebind / move support.

About expander reads real assembly metadata (InformationalVersion,
copyright) from Directory.Build.props.

WindowsUpdateService wraps Velopack's UpdateManager pointed at the
StuartMeeks/Snipdeck GitHub releases. Check button surfaces the available
version; Apply button (visible only when an update is available) downloads
and restarts. Dev builds gracefully no-op via UpdateManager.IsInstalled.

ShellViewModel.OpenSettings now takes a SettingsViewModel parameter —
ShellPage code-behind resolves it from DI on each click so the page reads
fresh config state.

New abstractions: IThemeApplier, IUpdateService.
New App services: WindowsThemeApplier, WindowsUpdateService.

This PR is the fourth and last in the stack. Base: feat/phase-5-platform.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  15 ++
 src/Snipdeck.App/Bootstrap.cs                 |   3 +
 .../Services/WindowsThemeApplier.cs           |  33 ++++
 .../Services/WindowsUpdateService.cs          |  71 +++++++
 src/Snipdeck.App/Views/ShellPage.xaml         |  56 ++++--
 src/Snipdeck.App/Views/ShellPage.xaml.cs      |   4 +-
 .../Abstractions/IThemeApplier.cs             |  13 ++
 .../Abstractions/IUpdateService.cs            |  15 ++
 .../ViewModels/SettingsViewModel.cs           | 175 +++++++++++++++++-
 .../ViewModels/ShellViewModel.cs              |   5 +-
 .../Support/FakePathProvider.cs               |  15 ++
 .../Support/FakeSettingsStore.cs              |  24 +++
 .../Support/FakeThemeApplier.cs               |  15 ++
 .../Support/FakeUpdateService.cs              |  27 +++
 .../ViewModels/ShellViewModelTests.cs         |  14 +-
 15 files changed, 457 insertions(+), 28 deletions(-)
 create mode 100644 src/Snipdeck.App/Services/WindowsThemeApplier.cs
 create mode 100644 src/Snipdeck.App/Services/WindowsUpdateService.cs
 create mode 100644 src/Snipdeck.Core/Abstractions/IThemeApplier.cs
 create mode 100644 src/Snipdeck.Core/Abstractions/IUpdateService.cs
 create mode 100644 tests/Snipdeck.Core.Tests/Support/FakePathProvider.cs
 create mode 100644 tests/Snipdeck.Core.Tests/Support/FakeSettingsStore.cs
 create mode 100644 tests/Snipdeck.Core.Tests/Support/FakeThemeApplier.cs
 create mode 100644 tests/Snipdeck.Core.Tests/Support/FakeUpdateService.cs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2e468ab..dad9efa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added — Phase 6: Settings page + Velopack updater
+- **Settings page becomes editable.** Theme switches live (System/Light/Dark
+  apply immediately via `IThemeApplier` → `MainWindow`'s content tree). Close
+  behaviour (Hide-to-tray vs Exit) persists to `AppConfig` as you change it.
+  Global hotkey is shown read-only for now — rebinding lands later.
+- **About expander** is populated from real assembly metadata: name,
+  `InformationalVersion`, and copyright (from `Directory.Build.props`).
+- **Manual update check** via `IUpdateService` (Velopack-backed,
+  `WindowsUpdateService`). Points at the GitHub releases for this repo,
+  catches dev-build / network-failure cases, and exposes a Check / Apply
+  pair on the Settings page.
+- `SettingsViewModel` now lives in the DI container as transient — a fresh
+  instance is resolved each time the Settings entry is clicked so reading
+  config state is always current.
+
 ### Added — Phase 5: Platform services
 - **Global hotkey** via Win32 `RegisterHotKey`. Default Ctrl+Alt+S; pressed
   anywhere brings the existing Snipdeck window to the foreground.
diff --git a/src/Snipdeck.App/Bootstrap.cs b/src/Snipdeck.App/Bootstrap.cs
index c454872..9059fdb 100644
--- a/src/Snipdeck.App/Bootstrap.cs
+++ b/src/Snipdeck.App/Bootstrap.cs
@@ -45,11 +45,14 @@ public static IServiceProvider Build()
                 .AddSingleton<IHotkeyService, WindowsHotkeyService>()
                 .AddSingleton<ITrayService, HNotifyIconTrayService>()
                 .AddSingleton<IShellInteractions, WindowsShellInteractions>()
+                .AddSingleton<IThemeApplier, WindowsThemeApplier>()
+                .AddSingleton<IUpdateService, WindowsUpdateService>()
                 .AddSingleton<ISettingsStore>(settingsStore)
                 .AddSingleton<ISnipStore>(snipStore)
                 .AddSingleton<IBackupService>(backupService)
                 .AddSingleton<IIconAssetStorage>(iconStorage)
                 .AddSingleton(config)
+                .AddTransient<SettingsViewModel>()
                 .AddSingleton<ShellViewModel>()
                 .AddSingleton<ShellPage>()
                 .AddSingleton<MainWindow>();
diff --git a/src/Snipdeck.App/Services/WindowsThemeApplier.cs b/src/Snipdeck.App/Services/WindowsThemeApplier.cs
new file mode 100644
index 0000000..f91346f
--- /dev/null
+++ b/src/Snipdeck.App/Services/WindowsThemeApplier.cs
@@ -0,0 +1,33 @@
+using Microsoft.UI.Xaml;
+
+using Snipdeck.Core.Abstractions;
+using Snipdeck.Core.Models;
+
+namespace Snipdeck.App.Services
+{
+    internal sealed class WindowsThemeApplier : IThemeApplier
+    {
+        private readonly IServiceProvider _services;
+
+        public WindowsThemeApplier(IServiceProvider services)
+        {
+            ArgumentNullException.ThrowIfNull(services);
+            _services = services;
+        }
+
+        public void Apply(ThemePreference theme)
+        {
+            var mainWindow = (MainWindow?)_services.GetService(typeof(MainWindow));
+            if (mainWindow?.Content is FrameworkElement root)
+            {
+                root.RequestedTheme = theme switch
+                {
+                    ThemePreference.Light => ElementTheme.Light,
+                    ThemePreference.Dark => ElementTheme.Dark,
+                    ThemePreference.System => ElementTheme.Default,
+                    _ => ElementTheme.Default,
+                };
+            }
+        }
+    }
+}
diff --git a/src/Snipdeck.App/Services/WindowsUpdateService.cs b/src/Snipdeck.App/Services/WindowsUpdateService.cs
new file mode 100644
index 0000000..1c2bd91
--- /dev/null
+++ b/src/Snipdeck.App/Services/WindowsUpdateService.cs
@@ -0,0 +1,71 @@
+using Snipdeck.Core.Abstractions;
+
+using Velopack;
+using Velopack.Sources;
+
+namespace Snipdeck.App.Services
+{
+    /// <summary>
+    /// Velopack-backed updater. Points at the GitHub releases for Snipdeck;
+    /// silently no-ops when running from a dev tree (not installed) so the
+    /// dev experience matches release-build expectations.
+    /// </summary>
+    internal sealed class WindowsUpdateService : IUpdateService
+    {
+        private const string _githubRepoUrl = "https://github.com/StuartMeeks/Snipdeck";
+
+        private readonly UpdateManager _manager;
+        private UpdateInfo? _pendingUpdate;
+
+        public WindowsUpdateService()
+        {
+            _manager = new UpdateManager(new GithubSource(_githubRepoUrl, accessToken: null, prerelease: false));
+        }
+
+        public async Task<UpdateCheckResult> CheckForUpdatesAsync(CancellationToken cancellationToken = default)
+        {
+            if (!_manager.IsInstalled)
+            {
+                return new UpdateCheckResult(UpdateAvailable: false, AvailableVersion: null);
+            }
+
+            try
+            {
+                _pendingUpdate = await _manager.CheckForUpdatesAsync().ConfigureAwait(false);
+            }
+            catch (Exception)
+            {
+                // Network errors / missing release feed shouldn't crash the app — surface as "no update".
+                return new UpdateCheckResult(UpdateAvailable: false, AvailableVersion: null);
+            }
+
+            if (_pendingUpdate is null)
+            {
+                return new UpdateCheckResult(UpdateAvailable: false, AvailableVersion: null);
+            }
+
+            return new UpdateCheckResult(
+                UpdateAvailable: true,
+                AvailableVersion: _pendingUpdate.TargetFullRelease.Version.ToString());
+        }
+
+        public async Task<bool> ApplyUpdateAndRestartAsync(CancellationToken cancellationToken = default)
+        {
+            if (_pendingUpdate is null || !_manager.IsInstalled)
+            {
+                return false;
+            }
+
+            try
+            {
+                await _manager.DownloadUpdatesAsync(_pendingUpdate).ConfigureAwait(false);
+                _manager.ApplyUpdatesAndRestart(_pendingUpdate);
+                return true;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+    }
+}
diff --git a/src/Snipdeck.App/Views/ShellPage.xaml b/src/Snipdeck.App/Views/ShellPage.xaml
index cf87796..ba97529 100644
--- a/src/Snipdeck.App/Views/ShellPage.xaml
+++ b/src/Snipdeck.App/Views/ShellPage.xaml
@@ -144,25 +144,51 @@
                                Style="{ThemeResource TitleTextBlockStyle}"
                                Margin="0,0,0,8" />
 
-                    <tk:SettingsCard Header="Storage location"
-                                     Description="Where snipdeck keeps your snips. Configurable in Phase 6."
-                                     IsEnabled="False" />
-
-                    <tk:SettingsCard Header="Backups"
-                                     Description="Backup directory and retention. Configurable in Phase 6."
-                                     IsEnabled="False" />
-
                     <tk:SettingsCard Header="Theme"
-                                     Description="Light, Dark, or System. Live switching in Phase 6."
-                                     IsEnabled="False" />
+                                     Description="Applies immediately. System follows your Windows preference.">
+                        <ComboBox SelectedIndex="{x:Bind ThemeIndex, Mode=TwoWay}" MinWidth="160">
+                            <x:String>System</x:String>
+                            <x:String>Light</x:String>
+                            <x:String>Dark</x:String>
+                        </ComboBox>
+                    </tk:SettingsCard>
+
+                    <tk:SettingsCard Header="Close behaviour"
+                                     Description="Hide-to-tray keeps the hotkey live. Exit closes the process.">
+                        <ComboBox SelectedIndex="{x:Bind CloseBehaviourIndex, Mode=TwoWay}" MinWidth="200">
+                            <x:String>Hide to tray</x:String>
+                            <x:String>Exit on close</x:String>
+                        </ComboBox>
+                    </tk:SettingsCard>
 
                     <tk:SettingsCard Header="Global hotkey"
-                                     Description="Default Ctrl+Alt+S. Rebinding in Phase 6."
-                                     IsEnabled="False" />
+                                     Description="Rebinding lands in a future phase.">
+                        <TextBlock Text="{x:Bind HotkeyDisplay}"
+                                   Style="{ThemeResource BodyStrongTextBlockStyle}" />
+                    </tk:SettingsCard>
 
-                    <tk:SettingsCard Header="Close behaviour"
-                                     Description="Hide-to-tray vs exit. Configurable in Phase 6."
-                                     IsEnabled="False" />
+                    <tk:SettingsCard Header="Storage location"
+                                     Description="Where snips and backups live. Move support lands in a future phase.">
+                        <TextBlock Text="{x:Bind StorageDirectory}"
+                                   Style="{ThemeResource CaptionTextBlockStyle}"
+                                   TextTrimming="CharacterEllipsis"
+                                   MaxWidth="320" />
+                    </tk:SettingsCard>
+
+                    <tk:SettingsCard Header="Updates"
+                                     Description="Check the GitHub releases feed for a newer build.">
+                        <StackPanel Orientation="Horizontal" Spacing="8">
+                            <TextBlock Text="{x:Bind UpdateStatusMessage, Mode=OneWay}"
+                                       VerticalAlignment="Center"
+                                       Style="{ThemeResource CaptionTextBlockStyle}" />
+                            <Button Content="Check for updates"
+                                    Command="{x:Bind CheckForUpdatesCommand}" />
+                            <Button Content="Apply &amp; restart"
+                                    Command="{x:Bind ApplyUpdateCommand}"
+                                    Style="{ThemeResource AccentButtonStyle}"
+                                    Visibility="{x:Bind UpdateAvailable, Mode=OneWay, Converter={StaticResource BoolToVisibility}}" />
+                        </StackPanel>
+                    </tk:SettingsCard>
 
                     <tk:SettingsExpander Header="About">
                         <tk:SettingsExpander.Items>
diff --git a/src/Snipdeck.App/Views/ShellPage.xaml.cs b/src/Snipdeck.App/Views/ShellPage.xaml.cs
index 2e899a6..7b66bc0 100644
--- a/src/Snipdeck.App/Views/ShellPage.xaml.cs
+++ b/src/Snipdeck.App/Views/ShellPage.xaml.cs
@@ -1,3 +1,4 @@
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
 
@@ -24,7 +25,8 @@ private async void OnLoaded(object sender, RoutedEventArgs e)
 
         private void OnSettingsClicked(object sender, RoutedEventArgs e)
         {
-            ViewModel.OpenSettings();
+            var settings = App.Services.GetRequiredService<SettingsViewModel>();
+            ViewModel.OpenSettings(settings);
         }
 
         private void OnNavigationSelectionChanged(
diff --git a/src/Snipdeck.Core/Abstractions/IThemeApplier.cs b/src/Snipdeck.Core/Abstractions/IThemeApplier.cs
new file mode 100644
index 0000000..088fcb0
--- /dev/null
+++ b/src/Snipdeck.Core/Abstractions/IThemeApplier.cs
@@ -0,0 +1,13 @@
+using Snipdeck.Core.Models;
+
+namespace Snipdeck.Core.Abstractions
+{
+    /// <summary>
+    /// Applies a <see cref="ThemePreference"/> to the live UI. Implemented in
+    /// the App project so view models in Core stay WinUI-free.
+    /// </summary>
+    public interface IThemeApplier
+    {
+        void Apply(ThemePreference theme);
+    }
+}
diff --git a/src/Snipdeck.Core/Abstractions/IUpdateService.cs b/src/Snipdeck.Core/Abstractions/IUpdateService.cs
new file mode 100644
index 0000000..498d397
--- /dev/null
+++ b/src/Snipdeck.Core/Abstractions/IUpdateService.cs
@@ -0,0 +1,15 @@
+namespace Snipdeck.Core.Abstractions
+{
+    public sealed record UpdateCheckResult(bool UpdateAvailable, string? AvailableVersion);
+
+    /// <summary>
+    /// Thin wrapper around Velopack so the UI can request an update check
+    /// without referencing the SDK directly.
+    /// </summary>
+    public interface IUpdateService
+    {
+        Task<UpdateCheckResult> CheckForUpdatesAsync(CancellationToken cancellationToken = default);
+
+        Task<bool> ApplyUpdateAndRestartAsync(CancellationToken cancellationToken = default);
+    }
+}
diff --git a/src/Snipdeck.Core/ViewModels/SettingsViewModel.cs b/src/Snipdeck.Core/ViewModels/SettingsViewModel.cs
index 9ad2cf9..f59711d 100644
--- a/src/Snipdeck.Core/ViewModels/SettingsViewModel.cs
+++ b/src/Snipdeck.Core/ViewModels/SettingsViewModel.cs
@@ -1,18 +1,54 @@
 using System.Reflection;
 
 using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+
+using Snipdeck.Core.Abstractions;
+using Snipdeck.Core.Models;
 
 namespace Snipdeck.Core.ViewModels
 {
     /// <summary>
-    /// Settings stub for Phase 3 — real settings UI (storage path, backups,
-    /// theme, hotkey, close behaviour) lands in Phase 6, About becomes a
-    /// fully-fledged expander backed by Nerdbank.GitVersioning then.
+    /// Editable application settings. Changes are persisted to
+    /// <see cref="ISettingsStore"/> as they happen; theme changes also fire
+    /// <see cref="IThemeApplier.Apply"/> so the UI updates live.
     /// </summary>
     public sealed partial class SettingsViewModel : ObservableObject
     {
-        public SettingsViewModel()
+        private readonly ISettingsStore _settingsStore;
+        private readonly IThemeApplier _themeApplier;
+        private readonly IUpdateService _updateService;
+        private readonly AppConfig _config;
+        private bool _suppressPersist;
+
+        public SettingsViewModel(
+            ISettingsStore settingsStore,
+            IThemeApplier themeApplier,
+            IUpdateService updateService,
+            IPathProvider pathProvider,
+            AppConfig config)
         {
+            ArgumentNullException.ThrowIfNull(settingsStore);
+            ArgumentNullException.ThrowIfNull(themeApplier);
+            ArgumentNullException.ThrowIfNull(updateService);
+            ArgumentNullException.ThrowIfNull(pathProvider);
+            ArgumentNullException.ThrowIfNull(config);
+
+            _settingsStore = settingsStore;
+            _themeApplier = themeApplier;
+            _updateService = updateService;
+            _config = config;
+
+            _suppressPersist = true;
+            Theme = config.Theme;
+            ThemeIndex = ThemeIndexFor(config.Theme);
+            CloseBehaviour = config.CloseBehaviour;
+            CloseBehaviourIndex = CloseBehaviourIndexFor(config.CloseBehaviour);
+            HotkeyDisplay = FormatHotkey(config.Hotkey);
+            StorageDirectory = config.StoragePath ?? pathProvider.DefaultStorageDirectory;
+            BackupDirectory = config.BackupDirectory ?? pathProvider.DefaultBackupDirectory;
+            _suppressPersist = false;
+
             var assembly = typeof(SettingsViewModel).Assembly;
             VersionDisplay = assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion
                 ?? assembly.GetName().Version?.ToString()
@@ -21,10 +57,7 @@ public SettingsViewModel()
                 ?? "Copyright © Stuart Meeks";
         }
 
-        // Instance properties (not static) so x:Bind in XAML resolves them via
-        // the bound DataContext. CA1822 doesn't matter here — these are cheap
-        // and only ever live for the duration of the open Settings view.
-#pragma warning disable CA1822
+#pragma warning disable CA1822 // not actually static — bound from XAML via DataContext.
         public string AppName => "Snipdeck";
 
         public string TaglineDisplay => "Parameterised CLI snippet manager.";
@@ -33,5 +66,131 @@ public SettingsViewModel()
         public string VersionDisplay { get; }
 
         public string CopyrightDisplay { get; }
+
+        public string StorageDirectory { get; }
+
+        public string BackupDirectory { get; }
+
+        public string HotkeyDisplay { get; }
+
+        [ObservableProperty]
+        public partial ThemePreference Theme { get; set; }
+
+        [ObservableProperty]
+        public partial int ThemeIndex { get; set; }
+
+        [ObservableProperty]
+        public partial CloseBehaviour CloseBehaviour { get; set; }
+
+        [ObservableProperty]
+        public partial int CloseBehaviourIndex { get; set; }
+
+        [ObservableProperty]
+        public partial string UpdateStatusMessage { get; set; } = string.Empty;
+
+        [ObservableProperty]
+        public partial bool IsCheckingForUpdates { get; set; }
+
+        [ObservableProperty]
+        public partial bool UpdateAvailable { get; set; }
+
+        partial void OnThemeIndexChanged(int value)
+        {
+            Theme = value switch
+            {
+                1 => ThemePreference.Light,
+                2 => ThemePreference.Dark,
+                _ => ThemePreference.System,
+            };
+            _themeApplier.Apply(Theme);
+            _ = PersistAsync();
+        }
+
+        partial void OnCloseBehaviourIndexChanged(int value)
+        {
+            CloseBehaviour = value == 1 ? CloseBehaviour.Exit : CloseBehaviour.HideToTray;
+            _ = PersistAsync();
+        }
+
+        [RelayCommand]
+        private async Task CheckForUpdatesAsync()
+        {
+            IsCheckingForUpdates = true;
+            try
+            {
+                var result = await _updateService.CheckForUpdatesAsync().ConfigureAwait(true);
+                UpdateAvailable = result.UpdateAvailable;
+                UpdateStatusMessage = result.UpdateAvailable
+                    ? $"Update available: {result.AvailableVersion}"
+                    : "You're on the latest version.";
+            }
+            finally
+            {
+                IsCheckingForUpdates = false;
+            }
+        }
+
+        [RelayCommand]
+        private async Task ApplyUpdateAsync()
+        {
+            var applied = await _updateService.ApplyUpdateAndRestartAsync().ConfigureAwait(true);
+            if (!applied)
+            {
+                UpdateStatusMessage = "Couldn't apply the update; try again later.";
+            }
+        }
+
+        private async Task PersistAsync()
+        {
+            if (_suppressPersist)
+            {
+                return;
+            }
+            _config.Theme = Theme;
+            _config.CloseBehaviour = CloseBehaviour;
+            await _settingsStore.SaveAsync(_config).ConfigureAwait(true);
+        }
+
+        private static int ThemeIndexFor(ThemePreference theme) => theme switch
+        {
+            ThemePreference.System => 0,
+            ThemePreference.Light => 1,
+            ThemePreference.Dark => 2,
+            _ => 0,
+        };
+
+        private static int CloseBehaviourIndexFor(CloseBehaviour behaviour) => behaviour switch
+        {
+            CloseBehaviour.HideToTray => 0,
+            CloseBehaviour.Exit => 1,
+            _ => 0,
+        };
+
+        private static string FormatHotkey(HotkeyBinding binding)
+        {
+            if (binding.IsEmpty)
+            {
+                return "(unbound)";
+            }
+            var parts = new List<string>();
+            if (binding.Modifiers.HasFlag(HotkeyModifiers.Control))
+            {
+                parts.Add("Ctrl");
+            }
+            if (binding.Modifiers.HasFlag(HotkeyModifiers.Alt))
+            {
+                parts.Add("Alt");
+            }
+            if (binding.Modifiers.HasFlag(HotkeyModifiers.Shift))
+            {
+                parts.Add("Shift");
+            }
+            if (binding.Modifiers.HasFlag(HotkeyModifiers.Windows))
+            {
+                parts.Add("Win");
+            }
+            parts.Add(binding.Key);
+            return string.Join('+', parts);
+        }
     }
 }
diff --git a/src/Snipdeck.Core/ViewModels/ShellViewModel.cs b/src/Snipdeck.Core/ViewModels/ShellViewModel.cs
index 17bfd7d..70f408b 100644
--- a/src/Snipdeck.Core/ViewModels/ShellViewModel.cs
+++ b/src/Snipdeck.Core/ViewModels/ShellViewModel.cs
@@ -71,9 +71,10 @@ public async Task LoadAsync(CancellationToken cancellationToken = default)
             SelectedCliChoice = CliChoices.FirstOrDefault();
         }
 
-        public void OpenSettings()
+        public void OpenSettings(SettingsViewModel settings)
         {
-            CurrentContent = new SettingsViewModel();
+            ArgumentNullException.ThrowIfNull(settings);
+            CurrentContent = settings;
         }
 
         public void GoHome()
diff --git a/tests/Snipdeck.Core.Tests/Support/FakePathProvider.cs b/tests/Snipdeck.Core.Tests/Support/FakePathProvider.cs
new file mode 100644
index 0000000..3e9562b
--- /dev/null
+++ b/tests/Snipdeck.Core.Tests/Support/FakePathProvider.cs
@@ -0,0 +1,15 @@
+using Snipdeck.Core.Abstractions;
+
+namespace Snipdeck.Core.Tests.Support
+{
+    public sealed class FakePathProvider : IPathProvider
+    {
+        public string AppDataDirectory { get; init; } = "/data";
+
+        public string SettingsFilePath { get; init; } = "/data/settings.json";
+
+        public string DefaultStorageDirectory { get; init; } = "/data/store";
+
+        public string DefaultBackupDirectory { get; init; } = "/data/backups";
+    }
+}
diff --git a/tests/Snipdeck.Core.Tests/Support/FakeSettingsStore.cs b/tests/Snipdeck.Core.Tests/Support/FakeSettingsStore.cs
new file mode 100644
index 0000000..f58c3a3
--- /dev/null
+++ b/tests/Snipdeck.Core.Tests/Support/FakeSettingsStore.cs
@@ -0,0 +1,24 @@
+using Snipdeck.Core.Abstractions;
+using Snipdeck.Core.Models;
+
+namespace Snipdeck.Core.Tests.Support
+{
+    public sealed class FakeSettingsStore : ISettingsStore
+    {
+        public AppConfig Current { get; private set; } = new();
+
+        public int SaveCount { get; private set; }
+
+        public string FilePath => "in-memory-settings";
+
+        public Task<AppConfig> LoadAsync(CancellationToken cancellationToken = default) =>
+            Task.FromResult(Current);
+
+        public Task SaveAsync(AppConfig config, CancellationToken cancellationToken = default)
+        {
+            Current = config;
+            SaveCount++;
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/tests/Snipdeck.Core.Tests/Support/FakeThemeApplier.cs b/tests/Snipdeck.Core.Tests/Support/FakeThemeApplier.cs
new file mode 100644
index 0000000..2151d5c
--- /dev/null
+++ b/tests/Snipdeck.Core.Tests/Support/FakeThemeApplier.cs
@@ -0,0 +1,15 @@
+using Snipdeck.Core.Abstractions;
+using Snipdeck.Core.Models;
+
+namespace Snipdeck.Core.Tests.Support
+{
+    public sealed class FakeThemeApplier : IThemeApplier
+    {
+        public ThemePreference? LastAppliedTheme { get; private set; }
+
+        public void Apply(ThemePreference theme)
+        {
+            LastAppliedTheme = theme;
+        }
+    }
+}
diff --git a/tests/Snipdeck.Core.Tests/Support/FakeUpdateService.cs b/tests/Snipdeck.Core.Tests/Support/FakeUpdateService.cs
new file mode 100644
index 0000000..02078f5
--- /dev/null
+++ b/tests/Snipdeck.Core.Tests/Support/FakeUpdateService.cs
@@ -0,0 +1,27 @@
+using Snipdeck.Core.Abstractions;
+
+namespace Snipdeck.Core.Tests.Support
+{
+    public sealed class FakeUpdateService : IUpdateService
+    {
+        public UpdateCheckResult NextCheckResult { get; set; } = new(false, null);
+
+        public bool NextApplyResult { get; set; }
+
+        public int CheckCallCount { get; private set; }
+
+        public int ApplyCallCount { get; private set; }
+
+        public Task<UpdateCheckResult> CheckForUpdatesAsync(CancellationToken cancellationToken = default)
+        {
+            CheckCallCount++;
+            return Task.FromResult(NextCheckResult);
+        }
+
+        public Task<bool> ApplyUpdateAndRestartAsync(CancellationToken cancellationToken = default)
+        {
+            ApplyCallCount++;
+            return Task.FromResult(NextApplyResult);
+        }
+    }
+}
diff --git a/tests/Snipdeck.Core.Tests/ViewModels/ShellViewModelTests.cs b/tests/Snipdeck.Core.Tests/ViewModels/ShellViewModelTests.cs
index 1892f92..fc99c65 100644
--- a/tests/Snipdeck.Core.Tests/ViewModels/ShellViewModelTests.cs
+++ b/tests/Snipdeck.Core.Tests/ViewModels/ShellViewModelTests.cs
@@ -23,6 +23,16 @@ public Task SaveAsync(SnipStoreDocument document, CancellationToken cancellation
             }
         }
 
+        private static SettingsViewModel NewSettingsViewModel()
+        {
+            return new SettingsViewModel(
+                new FakeSettingsStore(),
+                new FakeThemeApplier(),
+                new FakeUpdateService(),
+                new FakePathProvider(),
+                new AppConfig());
+        }
+
         private static ShellViewModel NewShellViewModel(
             ISnipStore store,
             FakeClipboardService? clipboard = null,
@@ -140,7 +150,7 @@ public async Task OpenSettings_swaps_content_for_a_SettingsViewModel()
             var vm = NewShellViewModel(new InMemorySnipStore(doc));
             await vm.LoadAsync();
 
-            vm.OpenSettings();
+            vm.OpenSettings(NewSettingsViewModel());
 
             _ = Assert.IsType<SettingsViewModel>(vm.CurrentContent);
         }
@@ -152,7 +162,7 @@ public async Task Changing_cli_after_OpenSettings_returns_to_shell_content()
             var vm = NewShellViewModel(new InMemorySnipStore(doc));
             await vm.LoadAsync();
 
-            vm.OpenSettings();
+            vm.OpenSettings(NewSettingsViewModel());
             vm.SelectedCliChoice = vm.CliChoices.Single(c => c.Cli?.Id == plAppId);
 
             _ = Assert.IsType<CliViewModel>(vm.CurrentContent);

From 25db915a1945eac645920db8bbee468d3553f0c3 Mon Sep 17 00:00:00 2001
From: Stuart Meeks <stuart.meeks@stuartmeeks.net>
Date: Fri, 29 May 2026 18:00:20 +0000
Subject: [PATCH 2/3] Fix WindowsUpdateService: forward CT to
 DownloadUpdatesAsync and inline the null check

CA2016: pass cancellationToken through to Velopack's DownloadUpdatesAsync via
its cancelToken named parameter.

IDE0046: fold the trailing null check into a single ternary return so the
analyser stops asking for it.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/Snipdeck.App/Services/WindowsUpdateService.cs | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/Snipdeck.App/Services/WindowsUpdateService.cs b/src/Snipdeck.App/Services/WindowsUpdateService.cs
index 1c2bd91..2c49936 100644
--- a/src/Snipdeck.App/Services/WindowsUpdateService.cs
+++ b/src/Snipdeck.App/Services/WindowsUpdateService.cs
@@ -39,14 +39,11 @@ public async Task<UpdateCheckResult> CheckForUpdatesAsync(CancellationToken canc
                 return new UpdateCheckResult(UpdateAvailable: false, AvailableVersion: null);
             }
 
-            if (_pendingUpdate is null)
-            {
-                return new UpdateCheckResult(UpdateAvailable: false, AvailableVersion: null);
-            }
-
-            return new UpdateCheckResult(
-                UpdateAvailable: true,
-                AvailableVersion: _pendingUpdate.TargetFullRelease.Version.ToString());
+            return _pendingUpdate is null
+                ? new UpdateCheckResult(UpdateAvailable: false, AvailableVersion: null)
+                : new UpdateCheckResult(
+                    UpdateAvailable: true,
+                    AvailableVersion: _pendingUpdate.TargetFullRelease.Version.ToString());
         }
 
         public async Task<bool> ApplyUpdateAndRestartAsync(CancellationToken cancellationToken = default)
@@ -58,7 +55,7 @@ public async Task<bool> ApplyUpdateAndRestartAsync(CancellationToken cancellatio
 
             try
             {
-                await _manager.DownloadUpdatesAsync(_pendingUpdate).ConfigureAwait(false);
+                await _manager.DownloadUpdatesAsync(_pendingUpdate, cancelToken: cancellationToken).ConfigureAwait(false);
                 _manager.ApplyUpdatesAndRestart(_pendingUpdate);
                 return true;
             }

From 2336fc1950304c28637b853d7da526fcac75c2ac Mon Sep 17 00:00:00 2001
From: Stuart Meeks <stuart.meeks@stuartmeeks.net>
Date: Fri, 29 May 2026 18:03:14 +0000
Subject: [PATCH 3/3] Update TODO.md with everything deferred out of the phase
 stack

The Phase 4-6 PRs trimmed several items to stay reviewable. Capture them
here with enough detail to pick up cold: hotkey rebinding UI, storage path
move/adopt/conflict flow, configurable backup retention, CLI delete cascade
decision, NBGV integration, markdown rendering for descriptions, trash UI.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 TODO.md | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/TODO.md b/TODO.md
index b4e3cf9..22a171c 100644
--- a/TODO.md
+++ b/TODO.md
@@ -50,3 +50,32 @@ locally on a Snip when something one-off is needed.
   from shared scope.
 
 This is the single biggest content-quality-of-life feature after v1 ships.
+
+---
+
+## Carried over from the phase stack
+
+These were trimmed out of Phase 4–6 to keep the PRs reviewable. None are
+load-bearing for the v1 demo, but they're the obvious next-pulls.
+
+- **Hotkey rebinding UI.** The setting is editable in `AppConfig` already;
+  what's missing is a key-capture control on the Settings page and the call
+  to `IHotkeyService.TryRegister` after the change. Tooling: a small custom
+  `Control` that listens for a single key chord then displays it formatted.
+- **Storage path: move / adopt / warn-on-conflict.** Per `CLAUDE.md`, when
+  the user changes the storage path we need three flows: move the existing
+  store to the new path; adopt a store already at the new path; warn when
+  both exist. UI: a "Change…" button next to the read-only path display.
+- **Backup retention configurable.** Plumbing: `BackupService` takes
+  retention at construction time today; either re-create it on the relevant
+  config change or have it read from `AppConfig` lazily.
+- **CLI delete.** Settle cascade semantics — must-be-empty vs trash-all-child-snips —
+  before wiring the UI.
+- **Nerdbank.GitVersioning.** Right now `InformationalVersion` falls back to
+  the assembly's compile-time version. NBGV would give us a real git-tag-derived
+  string at build time (`v1.2.3+gabcdef0`).
+- **Markdown rendering for Snip descriptions.** Stored as plain text right
+  now; render via a markdown control on the parameter-fill / detail view.
+- **Trash UI.** Soft-deleted Snips currently just vanish from the views.
+  Need a "Trash" entry in the pane footer that lists trashed Snips with a
+  restore action and a hard-delete option.