chore(claude-do): [A3] Settings + Update-Check: OperationStatus für Skill-Inst

Vorgaben: `docs/superpowers/plans/2026-08-11-operation-feedback.md`, Gruppe A, Entwurf A3. P0-1 ist gemergt: `src/ClaudeDo.Ui/Services/OperationStatus.cs` + `src/ClaudeDo.Ui/Views/Controls/OperationIndicator.axaml`.

SCOPE-ÄNDERUNG (Nutzer, 2026-08-12): OnlineInbox Sign-In/Sign-Out ist AUS DEM SCOPE GENOMMEN — vorerst unwichtig. `ViewModels/Modals/Settings/OnlineInboxSettingsViewModel.cs` und die

ClaudeDo-Task: 2356806f-f16e-4652-b615-4562e95c3a65

tests/ClaudeDo.Ui.Tests/Services/UpdateCheckServiceTests.cs

@@ -10,9 +10,11 @@ public class UpdateCheckServiceTests
     {
         public GiteaRelease? Release { get; set; }
         public bool Throw { get; set; }
+        public TaskCompletionSource<GiteaRelease?>? Gate { get; set; }
 
         public Task<GiteaRelease?> GetLatestReleaseAsync(CancellationToken ct)
         {
+            if (Gate is not null) return Gate.Task;
             if (Throw) throw new HttpRequestException();
             return Task.FromResult(Release);
         }
@@ -58,5 +60,22 @@ public class UpdateCheckServiceTests
         var svc = new UpdateCheckService(new FakeReleaseClient { Throw = true }, "0.1.0");
         await svc.CheckNowAsync(CancellationToken.None);
         Assert.Equal(UpdateCheckStatus.CheckFailed, svc.LastCheckStatus);
+        Assert.False(svc.Op.IsRunning);
+    }
+
+    [Fact]
+    public async Task CheckNowAsync_WhileRunning_OpIsRunningTrue_ThenResetAfterCompletion()
+    {
+        var releases = new FakeReleaseClient { Gate = new TaskCompletionSource<GiteaRelease?>() };
+        var svc = new UpdateCheckService(releases, "0.1.0");
+
+        var check = svc.CheckNowAsync(CancellationToken.None);
+
+        Assert.True(svc.Op.IsRunning);
+
+        releases.Gate.SetResult(new GiteaRelease("v0.1.0", "r", new[] { new ReleaseAsset("ClaudeDo-0.1.0-win-x64.zip", "u", 1) }));
+        await check;
+
+        Assert.False(svc.Op.IsRunning);
     }
 }

tests/ClaudeDo.Ui.Tests/ViewModels/FilesSettingsTabViewModelTests.cs

@@ -24,8 +24,14 @@ public class FilesSettingsTabViewModelTests
             throw new Exception(ExceptionMessage);
     }
 
+    private sealed class BlockingWorker : StubWorkerClient
+    {
+        public TaskCompletionSource<SeedResultDto?> Gate { get; } = new();
+        public override Task<SeedResultDto?> RestoreDefaultAgentsAsync() => Gate.Task;
+    }
+
     [Fact]
-    public async Task RestoreDefaultAgents_WhenWorkerThrows_ShowsExceptionMessage_NotGenericOffline()
+    public async Task RestoreDefaultAgents_WhenWorkerThrows_ShowsExceptionMessage_AndResetsOperationState()
     {
         var worker = new ThrowingWorker();
         var vm = new FilesSettingsTabViewModel(worker);
@@ -33,6 +39,25 @@ public class FilesSettingsTabViewModelTests
         await vm.RestoreDefaultAgentsCommand.ExecuteAsync(null);
 
         Assert.Contains(worker.ExceptionMessage, vm.StatusMessage);
-        Assert.False(vm.IsBusy);
+        Assert.False(vm.RestoreOp.IsRunning);
+        Assert.True(vm.RestoreDefaultAgentsCommand.CanExecute(null));
+    }
+
+    [Fact]
+    public async Task RestoreDefaultAgents_WhileRunning_IsRunningTrue_AndCommandLocked()
+    {
+        var worker = new BlockingWorker();
+        var vm = new FilesSettingsTabViewModel(worker);
+
+        var execution = vm.RestoreDefaultAgentsCommand.ExecuteAsync(null);
+
+        Assert.True(vm.RestoreOp.IsRunning);
+        Assert.False(vm.RestoreDefaultAgentsCommand.CanExecute(null));
+
+        worker.Gate.SetResult(new SeedResultDto(1, 0));
+        await execution;
+
+        Assert.False(vm.RestoreOp.IsRunning);
+        Assert.True(vm.RestoreDefaultAgentsCommand.CanExecute(null));
     }
 }

tests/ClaudeDo.Ui.Tests/ViewModels/RepoImportModalViewModelTests.cs

@@ -69,6 +69,18 @@ public sealed class RepoImportModalViewModelTests : IDisposable
         Assert.Null(reportedError);
     }
 
+    [Fact]
+    public async Task LoadAsync_ScanCompletes_ScanOpIsRunningResetToFalse()
+    {
+        var worker = new FakeWorkerClient { Folders = new List<string> { @"C:\src" } };
+        var vm = new RepoImportModalViewModel(new TestDbFactory(NewContext), worker);
+
+        await vm.LoadAsync();
+
+        Assert.False(vm.ScanOp.IsRunning);
+        Assert.False(vm.ScanOp.ShowIndicator);
+    }
+
     [Fact]
     public async Task LoadAsync_HubFailure_ReportsErrorInsteadOfSilentEmptyList()
     {

tests/ClaudeDo.Ui.Tests/ViewModels/SessionSkillsSettingsTabViewModelTests.cs

@@ -25,18 +25,33 @@ public class SessionSkillsSettingsTabViewModelTests
         public string? UpdatedSourceUrl;
         public string? RemovedSourceUrl;
         public Exception? InstallError;
+        public TaskCompletionSource<List<string>>? InstallGate;
+        public TaskCompletionSource? UpdateGate;
 
         public override Task<List<SessionSkillDto>> GetSessionSkillsAsync() => Task.FromResult(Installed);
 
         public override Task<List<string>> InstallSessionSkillAsync(string url)
         {
             if (InstallError is not null) throw InstallError;
+            if (InstallGate is not null) return AwaitInstallGateAsync(url);
             InstallUrlReceived = url;
             Installed = Installed.Append(new SessionSkillDto("new-skill", "desc", url, "abc123", DateTimeOffset.UtcNow)).ToList();
             return Task.FromResult(new List<string> { "new-skill" });
         }
 
-        public override Task UpdateSessionSkillAsync(string sourceUrl) { UpdatedSourceUrl = sourceUrl; return Task.CompletedTask; }
+        private async Task<List<string>> AwaitInstallGateAsync(string url)
+        {
+            var installed = await InstallGate!.Task;
+            InstallUrlReceived = url;
+            return installed;
+        }
+
+        public override async Task UpdateSessionSkillAsync(string sourceUrl)
+        {
+            if (UpdateGate is not null) await UpdateGate.Task;
+            UpdatedSourceUrl = sourceUrl;
+        }
+
         public override Task RemoveSessionSkillAsync(string sourceUrl)
         {
             RemovedSourceUrl = sourceUrl;
@@ -84,6 +99,8 @@ public class SessionSkillsSettingsTabViewModelTests
 
         Assert.Contains("already installed", vm.StatusMessage);
         Assert.Empty(vm.Skills);
+        Assert.False(vm.InstallOp.IsRunning);
+        Assert.True(vm.InstallCommand.CanExecute(null));
     }
 
     [Fact]
@@ -97,6 +114,47 @@ public class SessionSkillsSettingsTabViewModelTests
         Assert.Null(w.InstallUrlReceived);
     }
 
+    [Fact]
+    public async Task InstallAsync_WhileRunning_IsRunningTrue_AndCommandLocked()
+    {
+        var w = new FakeWorker { InstallGate = new TaskCompletionSource<List<string>>() };
+        var vm = new SessionSkillsSettingsTabViewModel(w) { InstallUrl = "https://example.com/repo.git" };
+
+        var execution = vm.InstallCommand.ExecuteAsync(null);
+
+        Assert.True(vm.InstallOp.IsRunning);
+        Assert.False(vm.InstallCommand.CanExecute(null));
+
+        w.InstallGate.SetResult(new List<string> { "new-skill" });
+        await execution;
+
+        Assert.False(vm.InstallOp.IsRunning);
+        Assert.True(vm.InstallCommand.CanExecute(null));
+    }
+
+    [Fact]
+    public async Task UpdateAsync_WhileRunning_IsRunningTrue_AndCommandLocked()
+    {
+        var w = new FakeWorker
+        {
+            Installed = new() { new SessionSkillDto("a", "", "url-a", "ref-a", DateTimeOffset.UtcNow) },
+            UpdateGate = new TaskCompletionSource(),
+        };
+        var vm = new SessionSkillsSettingsTabViewModel(w);
+        await vm.LoadAsync();
+
+        var execution = vm.UpdateCommand.ExecuteAsync("url-a");
+
+        Assert.True(vm.UpdateOp.IsRunning);
+        Assert.False(vm.UpdateCommand.CanExecute("url-a"));
+
+        w.UpdateGate.SetResult();
+        await execution;
+
+        Assert.False(vm.UpdateOp.IsRunning);
+        Assert.True(vm.UpdateCommand.CanExecute("url-a"));
+    }
+
     [Fact]
     public async Task RemoveAsync_removes_then_refreshes()
     {