diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6be3a53..67a1f27 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,6 +17,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   IL2104 on the WinAppSDK/WinRT/Jdenticon assemblies, which aren't trim-safe.
 
 ### Added
+- **Change the storage location.** A "Change…" button on Settings → Storage
+  location lets you pick a new folder for your snips. If the folder already
+  contains a Snipdeck store it's adopted (your current snips are left where
+  they are); otherwise your store and icons are copied there (the old folder
+  is kept as a backup). The choice is confirmed first, and Snipdeck restarts
+  to apply it — the storage path is read at startup, so restarting keeps
+  everything consistent and avoids writing to the old location after the
+  switch. If the automatic restart can't run, you're prompted to restart
+  manually.
 - **Rebindable global hotkey.** The global hotkey is now editable from
   Settings: click the capture box and press a shortcut (at least one of
   Ctrl/Alt/Shift plus a key). The new binding registers and persists
diff --git a/src/Snipdeck.App/Bootstrap.cs b/src/Snipdeck.App/Bootstrap.cs
index 52bc1f4..d2e976b 100644
--- a/src/Snipdeck.App/Bootstrap.cs
+++ b/src/Snipdeck.App/Bootstrap.cs
@@ -42,6 +42,9 @@ public static IServiceProvider Build()
                 .AddSingleton<IClipboardService, WindowsClipboardService>()
                 .AddSingleton<IIconNormaliser, WindowsIconNormaliser>()
                 .AddSingleton<IFilePickerService, WindowsFilePickerService>()
+                .AddSingleton<IFolderPickerService, WindowsFolderPickerService>()
+                .AddSingleton<IAppRestartService, WindowsAppRestartService>()
+                .AddSingleton<IStorageRelocationService>(new StorageRelocationService(_snipStoreFileName))
                 .AddSingleton<IHotkeyService, WindowsHotkeyService>()
                 .AddSingleton<ITrayService, HNotifyIconTrayService>()
                 .AddSingleton<IShellInteractions, WindowsShellInteractions>()
diff --git a/src/Snipdeck.App/Services/WindowsAppRestartService.cs b/src/Snipdeck.App/Services/WindowsAppRestartService.cs
new file mode 100644
index 0000000..4084942
--- /dev/null
+++ b/src/Snipdeck.App/Services/WindowsAppRestartService.cs
@@ -0,0 +1,18 @@
+using Snipdeck.Core.Abstractions;
+
+using Microsoft.Windows.AppLifecycle;
+
+namespace Snipdeck.App.Services
+{
+    internal sealed class WindowsAppRestartService : IAppRestartService
+    {
+        public bool Restart()
+        {
+            // On success Windows App SDK terminates the process and this never
+            // returns. If it returns, it failed (it yields a failure reason
+            // rather than throwing), so report that to the caller.
+            _ = AppInstance.Restart(string.Empty);
+            return false;
+        }
+    }
+}
diff --git a/src/Snipdeck.App/Services/WindowsFolderPickerService.cs b/src/Snipdeck.App/Services/WindowsFolderPickerService.cs
new file mode 100644
index 0000000..3a7116f
--- /dev/null
+++ b/src/Snipdeck.App/Services/WindowsFolderPickerService.cs
@@ -0,0 +1,33 @@
+using Snipdeck.Core.Abstractions;
+
+using Windows.Storage.Pickers;
+
+namespace Snipdeck.App.Services
+{
+    internal sealed class WindowsFolderPickerService : IFolderPickerService
+    {
+        private readonly IServiceProvider _services;
+
+        public WindowsFolderPickerService(IServiceProvider services)
+        {
+            ArgumentNullException.ThrowIfNull(services);
+            _services = services;
+        }
+
+        public async Task<string?> PickFolderAsync()
+        {
+            var picker = new FolderPicker
+            {
+                SuggestedStartLocation = PickerLocationId.DocumentsLibrary,
+            };
+            picker.FileTypeFilter.Add("*");
+
+            var mainWindow = (MainWindow)_services.GetService(typeof(MainWindow))!;
+            var hwnd = WinRT.Interop.WindowNative.GetWindowHandle(mainWindow);
+            WinRT.Interop.InitializeWithWindow.Initialize(picker, hwnd);
+
+            var folder = await picker.PickSingleFolderAsync();
+            return folder?.Path;
+        }
+    }
+}
diff --git a/src/Snipdeck.App/Views/ShellPage.xaml b/src/Snipdeck.App/Views/ShellPage.xaml
index 55bd998..e4f81df 100644
--- a/src/Snipdeck.App/Views/ShellPage.xaml
+++ b/src/Snipdeck.App/Views/ShellPage.xaml
@@ -187,11 +187,16 @@
                     </tk:SettingsCard>
 
                     <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" />
+                                     Description="Where your snips live. Changing it restarts Snipdeck to load the new location.">
+                        <StackPanel Orientation="Horizontal" Spacing="8" VerticalAlignment="Center">
+                            <TextBlock Text="{x:Bind StorageDirectory, Mode=OneWay}"
+                                       Style="{ThemeResource CaptionTextBlockStyle}"
+                                       VerticalAlignment="Center"
+                                       TextTrimming="CharacterEllipsis"
+                                       MaxWidth="260" />
+                            <Button Content="Change…"
+                                    Command="{x:Bind ChangeStoragePathCommand}" />
+                        </StackPanel>
                     </tk:SettingsCard>
 
                     <tk:SettingsCard Header="Backups to keep"
diff --git a/src/Snipdeck.Core/Abstractions/IAppRestartService.cs b/src/Snipdeck.Core/Abstractions/IAppRestartService.cs
new file mode 100644
index 0000000..17478e0
--- /dev/null
+++ b/src/Snipdeck.Core/Abstractions/IAppRestartService.cs
@@ -0,0 +1,18 @@
+namespace Snipdeck.Core.Abstractions
+{
+    /// <summary>
+    /// Restarts the running application. Used to apply changes that are only
+    /// read at startup (e.g. the storage location), so the app reloads cleanly
+    /// rather than continuing against stale, immutable startup state.
+    /// </summary>
+    public interface IAppRestartService
+    {
+        /// <summary>
+        /// Requests an application restart. On success the process is terminated
+        /// and this does not return; it returns <c>false</c> if the restart
+        /// could not be initiated, so the caller can fall back (e.g. ask the
+        /// user to restart manually).
+        /// </summary>
+        bool Restart();
+    }
+}
diff --git a/src/Snipdeck.Core/Abstractions/IFolderPickerService.cs b/src/Snipdeck.Core/Abstractions/IFolderPickerService.cs
new file mode 100644
index 0000000..55803e8
--- /dev/null
+++ b/src/Snipdeck.Core/Abstractions/IFolderPickerService.cs
@@ -0,0 +1,11 @@
+namespace Snipdeck.Core.Abstractions
+{
+    /// <summary>
+    /// Lets the user pick a directory (e.g. a new storage location). Returns the
+    /// absolute path, or null if the picker was cancelled.
+    /// </summary>
+    public interface IFolderPickerService
+    {
+        Task<string?> PickFolderAsync();
+    }
+}
diff --git a/src/Snipdeck.Core/Abstractions/IStorageRelocationService.cs b/src/Snipdeck.Core/Abstractions/IStorageRelocationService.cs
new file mode 100644
index 0000000..b315cd7
--- /dev/null
+++ b/src/Snipdeck.Core/Abstractions/IStorageRelocationService.cs
@@ -0,0 +1,51 @@
+namespace Snipdeck.Core.Abstractions
+{
+    /// <summary>
+    /// What changing the storage directory to a given target implies.
+    /// </summary>
+    public enum StorageChangeOutcome
+    {
+        /// <summary>Target is the current directory — nothing to do.</summary>
+        NoChange,
+
+        /// <summary>
+        /// Target is nested inside the current storage directory (or vice
+        /// versa) — relocating would copy a directory into itself / delete the
+        /// copy. Reject it.
+        /// </summary>
+        Invalid,
+
+        /// <summary>Neither current nor target holds a store — just adopt the empty target.</summary>
+        SetEmptyTarget,
+
+        /// <summary>Current holds a store and the target is empty — move the store there.</summary>
+        MoveToTarget,
+
+        /// <summary>The target already holds a store — adopt it (the current store is left in place).</summary>
+        AdoptTarget,
+    }
+
+    /// <summary>
+    /// Decides what a storage-directory change means and performs the on-disk
+    /// relocation. UI-free and filesystem-only so it can be unit-tested against
+    /// real temp directories.
+    /// </summary>
+    public interface IStorageRelocationService
+    {
+        /// <summary>The store file name within a storage directory (e.g. "store.json").</summary>
+        string StoreFileName { get; }
+
+        /// <summary>Classifies a proposed change from <paramref name="currentDirectory"/> to <paramref name="targetDirectory"/>.</summary>
+        StorageChangeOutcome Inspect(string currentDirectory, string targetDirectory);
+
+        /// <summary>
+        /// Copies the store file and the icons subdirectory from the current
+        /// directory to the target. Non-destructive: the originals are left in
+        /// place as a safety copy. We never delete the old store from the
+        /// running process — the storage path is only re-read after the restart,
+        /// and a failed restart would otherwise leave the app writing to a
+        /// directory we'd already emptied.
+        /// </summary>
+        void CopyStore(string currentDirectory, string targetDirectory);
+    }
+}
diff --git a/src/Snipdeck.Core/Services/StorageRelocationService.cs b/src/Snipdeck.Core/Services/StorageRelocationService.cs
new file mode 100644
index 0000000..7849ea6
--- /dev/null
+++ b/src/Snipdeck.Core/Services/StorageRelocationService.cs
@@ -0,0 +1,84 @@
+using Snipdeck.Core.Abstractions;
+
+namespace Snipdeck.Core.Services
+{
+    /// <summary>
+    /// Filesystem implementation of <see cref="IStorageRelocationService"/>.
+    /// Relocates the store file plus the icons subdirectory and leaves the
+    /// settings/backups alone (those have their own locations).
+    /// </summary>
+    public sealed class StorageRelocationService : IStorageRelocationService
+    {
+        private const string _iconsSubdirectory = "icons";
+
+        public StorageRelocationService(string storeFileName = "store.json")
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(storeFileName);
+            StoreFileName = storeFileName;
+        }
+
+        public string StoreFileName { get; }
+
+        public StorageChangeOutcome Inspect(string currentDirectory, string targetDirectory)
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(currentDirectory);
+            ArgumentException.ThrowIfNullOrWhiteSpace(targetDirectory);
+
+            return PathsEqual(currentDirectory, targetDirectory) ? StorageChangeOutcome.NoChange
+                : IsNested(targetDirectory, currentDirectory) || IsNested(currentDirectory, targetDirectory) ? StorageChangeOutcome.Invalid
+                : File.Exists(StorePath(targetDirectory)) ? StorageChangeOutcome.AdoptTarget
+                : File.Exists(StorePath(currentDirectory)) ? StorageChangeOutcome.MoveToTarget
+                : StorageChangeOutcome.SetEmptyTarget;
+        }
+
+        public void CopyStore(string currentDirectory, string targetDirectory)
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(currentDirectory);
+            ArgumentException.ThrowIfNullOrWhiteSpace(targetDirectory);
+
+            _ = Directory.CreateDirectory(targetDirectory);
+
+            var sourceStore = StorePath(currentDirectory);
+            if (File.Exists(sourceStore))
+            {
+                File.Copy(sourceStore, StorePath(targetDirectory), overwrite: true);
+            }
+
+            var sourceIcons = Path.Combine(currentDirectory, _iconsSubdirectory);
+            if (Directory.Exists(sourceIcons))
+            {
+                CopyDirectory(sourceIcons, Path.Combine(targetDirectory, _iconsSubdirectory));
+            }
+        }
+
+        private string StorePath(string directory) => Path.Combine(directory, StoreFileName);
+
+        private static bool PathsEqual(string a, string b) =>
+            string.Equals(Normalize(a), Normalize(b), StringComparison.OrdinalIgnoreCase);
+
+        // True when "descendant" is a proper subdirectory of "ancestor".
+        private static bool IsNested(string descendant, string ancestor)
+        {
+            var d = Normalize(descendant);
+            var a = Normalize(ancestor);
+            return d.Length > a.Length
+                && d.StartsWith(a + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static string Normalize(string path) =>
+            Path.TrimEndingDirectorySeparator(Path.GetFullPath(path));
+
+        private static void CopyDirectory(string source, string destination)
+        {
+            _ = Directory.CreateDirectory(destination);
+            foreach (var file in Directory.EnumerateFiles(source))
+            {
+                File.Copy(file, Path.Combine(destination, Path.GetFileName(file)), overwrite: true);
+            }
+            foreach (var directory in Directory.EnumerateDirectories(source))
+            {
+                CopyDirectory(directory, Path.Combine(destination, Path.GetFileName(directory)));
+            }
+        }
+    }
+}
diff --git a/src/Snipdeck.Core/ViewModels/SettingsViewModel.cs b/src/Snipdeck.Core/ViewModels/SettingsViewModel.cs
index 55fdb8f..42346dd 100644
--- a/src/Snipdeck.Core/ViewModels/SettingsViewModel.cs
+++ b/src/Snipdeck.Core/ViewModels/SettingsViewModel.cs
@@ -19,6 +19,11 @@ public sealed partial class SettingsViewModel : ObservableObject
         private readonly IThemeApplier _themeApplier;
         private readonly IUpdateService _updateService;
         private readonly IHotkeyService _hotkeyService;
+        private readonly IFolderPickerService _folderPicker;
+        private readonly IStorageRelocationService _relocation;
+        private readonly IAppRestartService _restart;
+        private readonly IShellInteractions _interactions;
+        private readonly IPathProvider _pathProvider;
         private readonly AppConfig _config;
         private bool _suppressPersist;
 
@@ -27,6 +32,10 @@ public SettingsViewModel(
             IThemeApplier themeApplier,
             IUpdateService updateService,
             IHotkeyService hotkeyService,
+            IFolderPickerService folderPicker,
+            IStorageRelocationService relocation,
+            IAppRestartService restart,
+            IShellInteractions interactions,
             IPathProvider pathProvider,
             AppConfig config)
         {
@@ -34,6 +43,10 @@ public SettingsViewModel(
             ArgumentNullException.ThrowIfNull(themeApplier);
             ArgumentNullException.ThrowIfNull(updateService);
             ArgumentNullException.ThrowIfNull(hotkeyService);
+            ArgumentNullException.ThrowIfNull(folderPicker);
+            ArgumentNullException.ThrowIfNull(relocation);
+            ArgumentNullException.ThrowIfNull(restart);
+            ArgumentNullException.ThrowIfNull(interactions);
             ArgumentNullException.ThrowIfNull(pathProvider);
             ArgumentNullException.ThrowIfNull(config);
 
@@ -41,6 +54,11 @@ public SettingsViewModel(
             _themeApplier = themeApplier;
             _updateService = updateService;
             _hotkeyService = hotkeyService;
+            _folderPicker = folderPicker;
+            _relocation = relocation;
+            _restart = restart;
+            _interactions = interactions;
+            _pathProvider = pathProvider;
             _config = config;
 
             _suppressPersist = true;
@@ -72,7 +90,8 @@ public SettingsViewModel(
 
         public string CopyrightDisplay { get; }
 
-        public string StorageDirectory { get; }
+        [ObservableProperty]
+        public partial string StorageDirectory { get; set; } = string.Empty;
 
         public string BackupDirectory { get; }
 
@@ -196,6 +215,96 @@ private void ResetHotkey()
             RebindHotkey(HotkeyBinding.Default);
         }
 
+        [RelayCommand]
+        private async Task ChangeStoragePathAsync()
+        {
+            var target = await _folderPicker.PickFolderAsync().ConfigureAwait(true);
+            if (string.IsNullOrWhiteSpace(target))
+            {
+                return;
+            }
+
+            var current = _config.StoragePath ?? _pathProvider.DefaultStorageDirectory;
+            var outcome = _relocation.Inspect(current, target);
+
+            // The storage path is only read at startup, so apply-then-restart keeps
+            // the immutable startup state consistent and avoids the running app
+            // writing snips to the old location after the switch.
+            switch (outcome)
+            {
+                case StorageChangeOutcome.NoChange:
+                    return;
+
+                case StorageChangeOutcome.Invalid:
+                    await _interactions.NotifyAsync(
+                        "Can't use that folder",
+                        "Choose a folder that isn't inside (or a parent of) your current storage folder.").ConfigureAwait(true);
+                    return;
+
+                case StorageChangeOutcome.AdoptTarget:
+                    if (!await _interactions.ConfirmAsync(
+                        "Use this folder?",
+                        $"“{target}” already contains a Snipdeck store. Snipdeck will use it from now on; the snips in your current folder won't be moved. Snipdeck will restart to apply this.",
+                        "Use it",
+                        "Cancel").ConfigureAwait(true))
+                    {
+                        return;
+                    }
+                    break;
+
+                case StorageChangeOutcome.MoveToTarget:
+                    if (!await _interactions.ConfirmAsync(
+                        "Move storage?",
+                        $"Move your snips to “{target}”? Snipdeck will restart to apply this.",
+                        "Move",
+                        "Cancel").ConfigureAwait(true))
+                    {
+                        return;
+                    }
+                    // Copy the snips to the target; the originals are left as a
+                    // safety copy and never deleted from the running process (a
+                    // failed restart must not leave us writing to a removed dir).
+                    _relocation.CopyStore(current, target);
+                    break;
+
+                case StorageChangeOutcome.SetEmptyTarget:
+                    if (!await _interactions.ConfirmAsync(
+                        "Change storage location?",
+                        $"Use “{target}” as the storage location? Snipdeck will restart to apply this.",
+                        "Change",
+                        "Cancel").ConfigureAwait(true))
+                    {
+                        return;
+                    }
+                    break;
+
+                default:
+                    return;
+            }
+
+            var previousPath = _config.StoragePath;
+            _config.StoragePath = target;
+            await PersistAsync().ConfigureAwait(true);
+            StorageDirectory = target;
+
+            // On success the process terminates inside Restart() and nothing below
+            // runs. If it returns false the relaunch didn't happen, so the running
+            // app is still bound to the old location — roll the persisted switch
+            // back so this session and future launches stay on the old store
+            // (otherwise edits made before a manual restart would land in the old
+            // store and vanish once the new one loads). The copied target files are
+            // left as a harmless backup.
+            if (!_restart.Restart())
+            {
+                _config.StoragePath = previousPath;
+                await PersistAsync().ConfigureAwait(true);
+                StorageDirectory = previousPath ?? _pathProvider.DefaultStorageDirectory;
+                await _interactions.NotifyAsync(
+                    "Couldn't change storage location",
+                    "Snipdeck couldn't restart, so the storage location is unchanged. Please try again.").ConfigureAwait(true);
+            }
+        }
+
         private async Task PersistAsync()
         {
             if (_suppressPersist)
diff --git a/tests/Snipdeck.Core.Tests/Services/StorageRelocationServiceTests.cs b/tests/Snipdeck.Core.Tests/Services/StorageRelocationServiceTests.cs
new file mode 100644
index 0000000..fbf2df0
--- /dev/null
+++ b/tests/Snipdeck.Core.Tests/Services/StorageRelocationServiceTests.cs
@@ -0,0 +1,120 @@
+using Snipdeck.Core.Abstractions;
+using Snipdeck.Core.Services;
+
+namespace Snipdeck.Core.Tests.Services
+{
+    public class StorageRelocationServiceTests
+    {
+        private static string NewTempDir() => Directory.CreateTempSubdirectory("snipdeck-reloc-").FullName;
+
+        [Fact]
+        public void Inspect_returns_NoChange_for_the_same_directory()
+        {
+            var dir = NewTempDir();
+            try
+            {
+                Assert.Equal(StorageChangeOutcome.NoChange, new StorageRelocationService().Inspect(dir, dir));
+            }
+            finally
+            {
+                Directory.Delete(dir, recursive: true);
+            }
+        }
+
+        [Fact]
+        public void Inspect_returns_AdoptTarget_when_the_target_already_has_a_store()
+        {
+            var current = NewTempDir();
+            var target = NewTempDir();
+            try
+            {
+                File.WriteAllText(Path.Combine(target, "store.json"), "{}");
+                Assert.Equal(StorageChangeOutcome.AdoptTarget, new StorageRelocationService().Inspect(current, target));
+            }
+            finally
+            {
+                Directory.Delete(current, recursive: true);
+                Directory.Delete(target, recursive: true);
+            }
+        }
+
+        [Fact]
+        public void Inspect_returns_MoveToTarget_when_only_the_current_has_a_store()
+        {
+            var current = NewTempDir();
+            var target = NewTempDir();
+            try
+            {
+                File.WriteAllText(Path.Combine(current, "store.json"), "{}");
+                Assert.Equal(StorageChangeOutcome.MoveToTarget, new StorageRelocationService().Inspect(current, target));
+            }
+            finally
+            {
+                Directory.Delete(current, recursive: true);
+                Directory.Delete(target, recursive: true);
+            }
+        }
+
+        [Fact]
+        public void Inspect_returns_SetEmptyTarget_when_neither_has_a_store()
+        {
+            var current = NewTempDir();
+            var target = NewTempDir();
+            try
+            {
+                Assert.Equal(StorageChangeOutcome.SetEmptyTarget, new StorageRelocationService().Inspect(current, target));
+            }
+            finally
+            {
+                Directory.Delete(current, recursive: true);
+                Directory.Delete(target, recursive: true);
+            }
+        }
+
+        [Fact]
+        public void Inspect_returns_Invalid_when_the_target_is_nested_inside_the_current()
+        {
+            var current = NewTempDir();
+            try
+            {
+                var nested = Path.Combine(current, "icons");
+                _ = Directory.CreateDirectory(nested);
+                Assert.Equal(StorageChangeOutcome.Invalid, new StorageRelocationService().Inspect(current, nested));
+                // ...and the reverse nesting (current inside target) is also rejected.
+                Assert.Equal(StorageChangeOutcome.Invalid, new StorageRelocationService().Inspect(nested, current));
+            }
+            finally
+            {
+                Directory.Delete(current, recursive: true);
+            }
+        }
+
+        [Fact]
+        public void CopyStore_copies_store_and_icons_and_leaves_the_originals()
+        {
+            var current = NewTempDir();
+            var target = NewTempDir();
+            try
+            {
+                File.WriteAllText(Path.Combine(current, "store.json"), "{\"snips\":[]}");
+                _ = Directory.CreateDirectory(Path.Combine(current, "icons"));
+                File.WriteAllText(Path.Combine(current, "icons", "abc.png"), "icon-bytes");
+                Directory.Delete(target);
+
+                new StorageRelocationService().CopyStore(current, target);
+
+                Assert.Equal("{\"snips\":[]}", File.ReadAllText(Path.Combine(target, "store.json")));
+                Assert.Equal("icon-bytes", File.ReadAllText(Path.Combine(target, "icons", "abc.png")));
+                // Non-destructive: originals remain until RemoveStore runs.
+                Assert.True(File.Exists(Path.Combine(current, "store.json")));
+                Assert.True(Directory.Exists(Path.Combine(current, "icons")));
+            }
+            finally
+            {
+                if (Directory.Exists(current)) { Directory.Delete(current, recursive: true); }
+                if (Directory.Exists(target)) { Directory.Delete(target, recursive: true); }
+            }
+        }
+
+    }
+}
diff --git a/tests/Snipdeck.Core.Tests/Support/FakeAppRestartService.cs b/tests/Snipdeck.Core.Tests/Support/FakeAppRestartService.cs
new file mode 100644
index 0000000..274ea0c
--- /dev/null
+++ b/tests/Snipdeck.Core.Tests/Support/FakeAppRestartService.cs
@@ -0,0 +1,18 @@
+using Snipdeck.Core.Abstractions;
+
+namespace Snipdeck.Core.Tests.Support
+{
+    public sealed class FakeAppRestartService : IAppRestartService
+    {
+        public int RestartCount { get; private set; }
+
+        /// <summary>Simulates whether the restart could be initiated.</summary>
+        public bool NextRestartResult { get; set; } = true;
+
+        public bool Restart()
+        {
+            RestartCount++;
+            return NextRestartResult;
+        }
+    }
+}
diff --git a/tests/Snipdeck.Core.Tests/Support/FakeFolderPickerService.cs b/tests/Snipdeck.Core.Tests/Support/FakeFolderPickerService.cs
new file mode 100644
index 0000000..6285f1c
--- /dev/null
+++ b/tests/Snipdeck.Core.Tests/Support/FakeFolderPickerService.cs
@@ -0,0 +1,11 @@
+using Snipdeck.Core.Abstractions;
+
+namespace Snipdeck.Core.Tests.Support
+{
+    public sealed class FakeFolderPickerService : IFolderPickerService
+    {
+        public string? NextFolder { get; set; }
+
+        public Task<string?> PickFolderAsync() => Task.FromResult(NextFolder);
+    }
+}
diff --git a/tests/Snipdeck.Core.Tests/ViewModels/SettingsViewModelTests.cs b/tests/Snipdeck.Core.Tests/ViewModels/SettingsViewModelTests.cs
index 6bac819..263c102 100644
--- a/tests/Snipdeck.Core.Tests/ViewModels/SettingsViewModelTests.cs
+++ b/tests/Snipdeck.Core.Tests/ViewModels/SettingsViewModelTests.cs
@@ -1,4 +1,5 @@
 using Snipdeck.Core.Models;
+using Snipdeck.Core.Services;
 using Snipdeck.Core.Tests.Support;
 using Snipdeck.Core.ViewModels;
 
@@ -11,17 +12,47 @@ private static SettingsViewModel Build(
             out FakeSettingsStore store,
             AppConfig? config = null)
         {
-            hotkey = new FakeHotkeyService();
             store = new FakeSettingsStore();
+            hotkey = new FakeHotkeyService();
             return new SettingsViewModel(
                 store,
                 new FakeThemeApplier(),
                 new FakeUpdateService(),
                 hotkey,
+                new FakeFolderPickerService(),
+                new StorageRelocationService(),
+                new FakeAppRestartService(),
+                new FakeShellInteractions(),
                 new FakePathProvider(),
                 config ?? new AppConfig());
         }
 
+        private static SettingsViewModel BuildForStorage(
+            string currentDirectory,
+            out FakeFolderPickerService folderPicker,
+            out FakeShellInteractions interactions,
+            out FakeAppRestartService restart,
+            out FakeSettingsStore store,
+            AppConfig? config = null)
+        {
+            folderPicker = new FakeFolderPickerService();
+            interactions = new FakeShellInteractions();
+            restart = new FakeAppRestartService();
+            store = new FakeSettingsStore();
+            var pathProvider = new FakePathProvider { DefaultStorageDirectory = currentDirectory };
+            return new SettingsViewModel(
+                store,
+                new FakeThemeApplier(),
+                new FakeUpdateService(),
+                new FakeHotkeyService(),
+                folderPicker,
+                new StorageRelocationService(),
+                restart,
+                interactions,
+                pathProvider,
+                config ?? new AppConfig());
+        }
+
         [Fact]
         public void Initial_hotkey_display_reflects_config()
         {
@@ -86,5 +117,168 @@ public void ResetHotkey_rebinds_to_the_default_chord()
             Assert.Equal(HotkeyBinding.Default.Modifiers, hotkey.LastRegistered!.Modifiers);
             Assert.Equal("S", hotkey.LastRegistered.Key);
         }
+
+        [Fact]
+        public async Task ChangeStoragePath_moves_the_store_to_an_empty_target_then_restarts()
+        {
+            var current = Directory.CreateTempSubdirectory("snipdeck-cur-").FullName;
+            var target = Directory.CreateTempSubdirectory("snipdeck-tgt-").FullName;
+            try
+            {
+                await File.WriteAllTextAsync(Path.Combine(current, "store.json"), "{}");
+                _ = Directory.CreateDirectory(Path.Combine(current, "icons"));
+                await File.WriteAllTextAsync(Path.Combine(current, "icons", "a.png"), "x");
+                Directory.Delete(target); // target must not exist yet for a clean "move"
+
+                var vm = BuildForStorage(current, out var picker, out var ix, out var restart, out var store);
+                picker.NextFolder = target;
+                ix.NextConfirmResult = true;
+
+                await vm.ChangeStoragePathCommand.ExecuteAsync(null);
+
+                Assert.True(File.Exists(Path.Combine(target, "store.json")));
+                Assert.True(File.Exists(Path.Combine(target, "icons", "a.png")));
+                // The original is left as a safety copy (never deleted from the running process).
+                Assert.True(File.Exists(Path.Combine(current, "store.json")));
+                Assert.Equal(target, store.Current.StoragePath);
+                Assert.Equal(target, vm.StorageDirectory);
+                Assert.Equal(1, restart.RestartCount);
+            }
+            finally
+            {
+                Directory.Delete(current, recursive: true);
+                if (Directory.Exists(target)) { Directory.Delete(target, recursive: true); }
+            }
+        }
+
+        [Fact]
+        public async Task ChangeStoragePath_adopts_an_existing_store_without_moving_the_current_one()
+        {
+            var current = Directory.CreateTempSubdirectory("snipdeck-cur-").FullName;
+            var target = Directory.CreateTempSubdirectory("snipdeck-tgt-").FullName;
+            try
+            {
+                await File.WriteAllTextAsync(Path.Combine(current, "store.json"), "{}");
+                await File.WriteAllTextAsync(Path.Combine(target, "store.json"), "{}"); // target already has a store
+
+                var vm = BuildForStorage(current, out var picker, out var ix, out var restart, out var store);
+                picker.NextFolder = target;
+                ix.NextConfirmResult = true;
+
+                await vm.ChangeStoragePathCommand.ExecuteAsync(null);
+
+                // Adopt: current store is left in place, target's store untouched.
+                Assert.True(File.Exists(Path.Combine(current, "store.json")));
+                Assert.Equal(target, store.Current.StoragePath);
+                Assert.Equal(1, restart.RestartCount);
+            }
+            finally
+            {
+                Directory.Delete(current, recursive: true);
+                Directory.Delete(target, recursive: true);
+            }
+        }
+
+        [Fact]
+        public async Task ChangeStoragePath_does_nothing_when_the_user_cancels()
+        {
+            var current = Directory.CreateTempSubdirectory("snipdeck-cur-").FullName;
+            var target = Directory.CreateTempSubdirectory("snipdeck-tgt-").FullName;
+            try
+            {
+                await File.WriteAllTextAsync(Path.Combine(current, "store.json"), "{}");
+
+                var vm = BuildForStorage(current, out var picker, out var ix, out var restart, out var store);
+                picker.NextFolder = target;
+                ix.NextConfirmResult = false; // cancelled
+
+                await vm.ChangeStoragePathCommand.ExecuteAsync(null);
+
+                Assert.Null(store.Current.StoragePath);
+                Assert.Equal(0, restart.RestartCount);
+                Assert.True(File.Exists(Path.Combine(current, "store.json")));
+            }
+            finally
+            {
+                Directory.Delete(current, recursive: true);
+                Directory.Delete(target, recursive: true);
+            }
+        }
+
+        [Fact]
+        public async Task ChangeStoragePath_notifies_when_the_restart_cannot_be_initiated()
+        {
+            var current = Directory.CreateTempSubdirectory("snipdeck-cur-").FullName;
+            var target = Directory.CreateTempSubdirectory("snipdeck-tgt-").FullName;
+            try
+            {
+                await File.WriteAllTextAsync(Path.Combine(target, "store.json"), "{}"); // adopt path, no file ops
+
+                var vm = BuildForStorage(current, out var picker, out var ix, out var restart, out var store);
+                picker.NextFolder = target;
+                ix.NextConfirmResult = true;
+                restart.NextRestartResult = false; // restart denied
+
+                await vm.ChangeStoragePathCommand.ExecuteAsync(null);
+
+                // Restart failed, so the switch is rolled back: config stays on the
+                // old location (here: unset/default) and the user is notified.
+                Assert.Null(store.Current.StoragePath);
+                Assert.Equal(current, vm.StorageDirectory);
+                Assert.Equal(1, restart.RestartCount);
+                Assert.Equal(1, ix.NotifyCount);
+            }
+            finally
+            {
+                Directory.Delete(current, recursive: true);
+                Directory.Delete(target, recursive: true);
+            }
+        }
+
+        [Fact]
+        public async Task ChangeStoragePath_rejects_a_folder_nested_in_the_current_store()
+        {
+            var current = Directory.CreateTempSubdirectory("snipdeck-cur-").FullName;
+            try
+            {
+                await File.WriteAllTextAsync(Path.Combine(current, "store.json"), "{}");
+                var nested = Path.Combine(current, "icons");
+                _ = Directory.CreateDirectory(nested);
+
+                var vm = BuildForStorage(current, out var picker, out var ix, out var restart, out var store);
+                picker.NextFolder = nested;
+                ix.NextConfirmResult = true; // even if confirmed, the guard fires first
+
+                await vm.ChangeStoragePathCommand.ExecuteAsync(null);
+
+                Assert.Equal(1, ix.NotifyCount);
+                Assert.Equal(0, restart.RestartCount);
+                Assert.Null(store.Current.StoragePath);
+            }
+            finally
+            {
+                Directory.Delete(current, recursive: true);
+            }
+        }
+
+        [Fact]
+        public async Task ChangeStoragePath_no_ops_when_the_picker_is_cancelled()
+        {
+            var current = Directory.CreateTempSubdirectory("snipdeck-cur-").FullName;
+            try
+            {
+                var vm = BuildForStorage(current, out var picker, out _, out var restart, out var store);
+                picker.NextFolder = null; // user cancelled the folder picker
+
+                await vm.ChangeStoragePathCommand.ExecuteAsync(null);
+
+                Assert.Equal(0, restart.RestartCount);
+                Assert.Equal(0, store.SaveCount);
+            }
+            finally
+            {
+                Directory.Delete(current, recursive: true);
+            }
+        }
     }
 }
diff --git a/tests/Snipdeck.Core.Tests/ViewModels/ShellViewModelTests.cs b/tests/Snipdeck.Core.Tests/ViewModels/ShellViewModelTests.cs
index 1332cc9..098a292 100644
--- a/tests/Snipdeck.Core.Tests/ViewModels/ShellViewModelTests.cs
+++ b/tests/Snipdeck.Core.Tests/ViewModels/ShellViewModelTests.cs
@@ -1,5 +1,6 @@
 using Snipdeck.Core.Abstractions;
 using Snipdeck.Core.Models;
+using Snipdeck.Core.Services;
 using Snipdeck.Core.Tests.Support;
 using Snipdeck.Core.ViewModels;
 
@@ -30,6 +31,10 @@ private static SettingsViewModel NewSettingsViewModel()
                 new FakeThemeApplier(),
                 new FakeUpdateService(),
                 new FakeHotkeyService(),
+                new FakeFolderPickerService(),
+                new StorageRelocationService(),
+                new FakeAppRestartService(),
+                new FakeShellInteractions(),
                 new FakePathProvider(),
                 new AppConfig());
         }