Cut over the window to Explorer.Host.exe so only the host writes the index.

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

tests/Explorer.Hosting.Tests/CoreRegistrationTests.cs

@@ -3,6 +3,7 @@ using Explorer.Domain;
 using Explorer.Domain.Abstractions;
 using Explorer.Hosting;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
 
 namespace Explorer.Hosting.Tests;
 
@@ -23,6 +24,7 @@ public class CoreRegistrationTests
             Assert.NotNull(sp.GetService<IWorkbenchHost>());
             Assert.NotNull(sp.GetService<IIndexingHost>());
             Assert.NotNull(sp.GetService<ITransferHost>());
+            Assert.NotNull(sp.GetService<IIndexMutations>());
             Assert.Null(sp.GetService<IOsClipboard>());
         }
         finally
@@ -31,6 +33,35 @@ public class CoreRegistrationTests
         }
     }
 
+    [Fact]
+    public async Task AddExplorerClient_uses_read_only_store_without_indexing_workers()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "ew-hosting", Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        try
+        {
+            var workbench = new StubWorkbench();
+            var services = new ServiceCollection();
+            services.AddLogging();
+            services.AddSingleton<IAppEnvironment>(new TempEnv(dir));
+            services.AddExplorerClient(workbench);
+            await using var sp = services.BuildServiceProvider();
+            Assert.Same(workbench, sp.GetService<IWorkbenchHost>());
+            Assert.Same(workbench.Indexing, sp.GetService<IIndexingHost>());
+            Assert.Same(workbench.Transfers, sp.GetService<ITransferHost>());
+            Assert.Same(workbench.Sources, sp.GetService<ISourceHost>());
+            Assert.Same(workbench.Mutations, sp.GetService<IIndexMutations>());
+            Assert.False(sp.GetRequiredService<IIndexStore>().CanWrite);
+            var hosted = sp.GetServices<IHostedService>().ToList();
+            Assert.Contains(hosted, s => s is IndexStoreLifetime);
+            Assert.DoesNotContain(hosted, s => s.GetType().Name is "IndexingCoordinator" or "TransferQueue" or "WatcherHostedService");
+        }
+        finally
+        {
+            try { Directory.Delete(dir, true); } catch { /* ignore */ }
+        }
+    }
+
     private sealed class TempEnv : IAppEnvironment
     {
         public TempEnv(string dir)
@@ -45,4 +76,65 @@ public class CoreRegistrationTests
         public string DatabasePath { get; }
         public string LogDirectory { get; }
     }
+
+    private sealed class StubWorkbench : IWorkbenchHost
+    {
+        public IIndexingHost Indexing { get; } = new StubIndexing();
+        public ITransferHost Transfers { get; } = new StubTransfers();
+        public ISourceHost Sources { get; } = new StubSources();
+        public IIndexMutations Mutations { get; } = new StubMutations();
+    }
+
+    private sealed class StubIndexing : IIndexingHost
+    {
+        public event EventHandler<ScanProgress>? ProgressChanged = delegate { };
+        public void EnqueueFullScan(long sourceId) { }
+        public void EnqueueFolderScan(long sourceId, string pathRel) { }
+        public void EnqueueReconcile(long sourceId, string pathRel) { }
+        public void Cancel(long sourceId) { }
+    }
+
+    private sealed class StubTransfers : ITransferHost
+    {
+        public event EventHandler? Changed = delegate { };
+        public event EventHandler<TransferJob>? JobFinished = delegate { };
+        public bool IsPaused => false;
+        public IReadOnlyList<TransferJob> Snapshot() => [];
+        public void PauseAll() { }
+        public void ResumeAll() { }
+        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;
+    }
+
+    private sealed class StubSources : ISourceHost
+    {
+        public Task RefreshAsync(CancellationToken cancellationToken = default) => Task.CompletedTask;
+        public Task<Source> AddUncAsync(string path, CancellationToken cancellationToken = default)
+            => Task.FromResult(new Source { StableKey = "x", DisplayName = path });
+        public Task<Source?> EnsureForPathAsync(string path, CancellationToken cancellationToken = default)
+            => Task.FromResult<Source?>(null);
+        public Task<bool> ForgetAsync(string path, CancellationToken cancellationToken = default)
+            => Task.FromResult(false);
+    }
+
+    private sealed class StubMutations : IIndexMutations
+    {
+        public Task<long> UpsertSyncProfileAsync(SyncProfile profile, CancellationToken cancellationToken = default)
+            => Task.FromResult(0L);
+        public Task DeleteSyncProfileAsync(long id, CancellationToken cancellationToken = default) => Task.CompletedTask;
+        public Task<long> UpsertOperationProfileAsync(OperationProfile profile, CancellationToken cancellationToken = default)
+            => Task.FromResult(0L);
+        public Task DeleteOperationProfileAsync(long id, CancellationToken cancellationToken = default) => Task.CompletedTask;
+        public Task<long> CreateRenameBatchAsync(IReadOnlyList<RenameBatchItem> items, CancellationToken cancellationToken = default)
+            => Task.FromResult(0L);
+        public Task MarkRenameBatchUndoneAsync(long id, CancellationToken cancellationToken = default) => Task.CompletedTask;
+        public Task EnqueueHashCollisionsAsync(long? sourceId, CancellationToken cancellationToken = default) => Task.CompletedTask;
+        public Task UpsertRelationAsync(FileRelation relation, CancellationToken cancellationToken = default) => Task.CompletedTask;
+    }
 }