Extract a per-user background host so indexing can later run outside the window.

Keep the GUI as the index writer for now; mutex, named pipe, and opt-in logon autostart prepare Explorer.Host.exe without two SQLite writers.

Co-authored-by: Cursor <cursoragent@cursor.com>

tests/Explorer.Application.Tests/RemovableAutoIndexPlannerTests.cs

@@ -0,0 +1,73 @@
+using Explorer.Application;
+using Explorer.Domain;
+using Explorer.Windows;
+
+namespace Explorer.Application.Tests;
+
+public class RemovableAutoIndexPlannerTests
+{
+    [Fact]
+    public void Does_nothing_when_disabled()
+    {
+        var sources = new[] { Removable(1, indexed: false) };
+        Assert.Empty(RemovableAutoIndexPlanner.SourceIdsToScan(sources, autoIndexRemovable: false));
+    }
+
+    [Fact]
+    public void Queues_online_unindexed_removable_only()
+    {
+        var sources = new[]
+        {
+            Removable(1, indexed: false),
+            Removable(2, indexed: true),
+            Removable(3, indexed: false, status: SourceStatus.Offline),
+            Cloud(4),
+            Local(5)
+        };
+        Assert.Equal(new[] { 1L }, RemovableAutoIndexPlanner.SourceIdsToScan(sources, autoIndexRemovable: true));
+    }
+
+    private static Source Removable(long id, bool indexed, SourceStatus status = SourceStatus.Online)
+        => new()
+        {
+            Id = id,
+            StableKey = id.ToString(),
+            Kind = SourceKind.Removable,
+            DisplayName = "USB",
+            LastRootPath = @"E:\",
+            Status = status,
+            LastIndexedUtc = indexed ? DateTimeOffset.UtcNow : null
+        };
+
+    private static Source Cloud(long id)
+        => new()
+        {
+            Id = id,
+            StableKey = "cloud",
+            Kind = SourceKind.Cloud,
+            DisplayName = "Cloud",
+            LastRootPath = @"C:\Users\me\OneDrive",
+            Status = SourceStatus.Online
+        };
+
+    private static Source Local(long id)
+        => new()
+        {
+            Id = id,
+            StableKey = "local",
+            Kind = SourceKind.NtfsLocal,
+            DisplayName = "Local",
+            LastRootPath = @"C:\",
+            Status = SourceStatus.Online
+        };
+}
+
+public class ElevatedScanServiceTests
+{
+    [Fact]
+    public void Never_requests_elevation()
+    {
+        IElevatedScanService service = new WindowsElevatedScanService();
+        Assert.False(service.CanRequestElevation);
+    }
+}

tests/Explorer.Application.Tests/UiPreferencesStoreTests.cs

@@ -43,6 +43,18 @@ public class UiPreferencesStoreTests
         Assert.Equal(@"C:\Program Files\Git\cmd\git.exe", prefs.GitPath);
     }
 
+    [Fact]
+    public void Parse_reads_host_and_removable_index_flags()
+    {
+        var prefs = UiPreferencesStore.Parse(
+        [
+            "auto-index-removable=true",
+            "background-host-at-logon=true"
+        ]);
+        Assert.True(prefs.AutoIndexRemovable);
+        Assert.True(prefs.BackgroundHostAtLogon);
+    }
+
     [Fact]
     public void Parse_defaults_missing_keys()
     {
@@ -54,6 +66,8 @@ public class UiPreferencesStoreTests
         Assert.True(prefs.ShowHiddenFiles);
         Assert.False(prefs.ShowProtectedSystemLocations);
         Assert.False(prefs.AutoClearQueueWhenDone);
+        Assert.False(prefs.AutoIndexRemovable);
+        Assert.False(prefs.BackgroundHostAtLogon);
         Assert.Null(prefs.SevenZipPath);
         Assert.Null(prefs.GitPath);
     }
@@ -95,6 +109,8 @@ public class UiPreferencesStoreTests
             Assert.True(loaded.ShowHiddenFiles);
             Assert.False(loaded.ShowProtectedSystemLocations);
             Assert.True(loaded.AutoClearQueueWhenDone);
+            Assert.False(loaded.AutoIndexRemovable);
+            Assert.False(loaded.BackgroundHostAtLogon);
             Assert.Equal(1100, loaded.WindowWidth);
             Assert.Equal(720, loaded.WindowHeight);
             Assert.Equal(300, loaded.TreeWidth);

tests/Explorer.Application.Tests/WorkbenchHostTests.cs

@@ -0,0 +1,60 @@
+using Explorer.Application;
+using Explorer.Contracts;
+using Explorer.Domain;
+
+namespace Explorer.Application.Tests;
+
+public class WorkbenchHostTests
+{
+    [Fact]
+    public void Forwards_indexing_and_transfer_sessions()
+    {
+        var indexing = new FakeIndexing();
+        var transfers = new FakeTransfers();
+        IWorkbenchHost host = new WorkbenchHost(indexing, transfers);
+        Assert.Same(indexing, host.Indexing);
+        Assert.Same(transfers, host.Transfers);
+
+        host.Indexing.EnqueueFullScan(7);
+        host.Transfers.PauseAll();
+        Assert.Equal(7, indexing.FullScanId);
+        Assert.True(transfers.PausedAll);
+    }
+
+    private sealed class FakeIndexing : IIndexingHost
+    {
+        public long FullScanId { get; private set; }
+        public event EventHandler<ScanProgress>? ProgressChanged;
+
+        public void EnqueueFullScan(long sourceId) => FullScanId = sourceId;
+        public void EnqueueFolderScan(long sourceId, string pathRel) { }
+        public void EnqueueReconcile(long sourceId, string pathRel) { }
+        public void Cancel(long sourceId) { }
+
+        public void Raise() => ProgressChanged?.Invoke(this, new ScanProgress
+        {
+            SourceId = 1,
+            CurrentPath = "",
+            Status = ScanJobStatus.Running
+        });
+    }
+
+    private sealed class FakeTransfers : ITransferHost
+    {
+        public bool PausedAll { get; private set; }
+        public event EventHandler? Changed = delegate { };
+        public event EventHandler<TransferJob>? JobFinished = delegate { };
+        public bool IsPaused => PausedAll;
+        public IReadOnlyList<TransferJob> Snapshot() => [];
+        public void PauseAll() => PausedAll = true;
+        public void ResumeAll() => PausedAll = false;
+        public void Pause(long jobId) { }
+        public void Resume(long jobId) { }
+        public void Retry(long jobId) { }
+        public void Cancel(long jobId) { }
+        public void Dismiss(long jobId) { }
+        public void ClearFinished() { }
+        public bool MoveUp(long jobId) => false;
+        public bool MoveDown(long jobId) => false;
+    }
+}