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

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

src/ClaudeDo.Ui/Services/UpdateCheckService.cs

@@ -1,4 +1,5 @@
 using ClaudeDo.Releases;
+using ClaudeDo.Ui.Localization;
 using CommunityToolkit.Mvvm.ComponentModel;
 
 namespace ClaudeDo.Ui.Services;
@@ -15,10 +16,11 @@ public sealed partial class UpdateCheckService : ObservableObject
 {
     private readonly IReleaseClient _releases;
 
+    public OperationStatus Op { get; } = new();
+
     [ObservableProperty] private bool _isUpdateAvailable;
     [ObservableProperty] private string? _latestVersion;
     [ObservableProperty] private string _currentVersion;
-    [ObservableProperty] private bool _isChecking;
     [ObservableProperty] private UpdateCheckStatus _lastCheckStatus = UpdateCheckStatus.NeverChecked;
 
     public UpdateCheckService(IReleaseClient releases, string currentVersion)
@@ -29,45 +31,39 @@ public sealed partial class UpdateCheckService : ObservableObject
 
     public async Task CheckNowAsync(CancellationToken ct)
     {
-        IsChecking = true;
+        using var op = Op.Begin(Loc.T("ops.updateCheck.checking"));
+
+        GiteaRelease? rel;
         try
         {
-            GiteaRelease? rel;
-            try
-            {
-                rel = await _releases.GetLatestReleaseAsync(ct);
-            }
-            catch
-            {
-                LastCheckStatus = UpdateCheckStatus.CheckFailed;
-                IsUpdateAvailable = false;
-                return;
-            }
-
-            if (rel is null)
-            {
-                LastCheckStatus = UpdateCheckStatus.CheckFailed;
-                IsUpdateAvailable = false;
-                return;
-            }
-
-            var latest = (rel.TagName ?? "").TrimStart('v', 'V');
-            var cmp = VersionComparer.Compare(latest, CurrentVersion);
-            if (cmp.IsNewer)
-            {
-                LatestVersion = latest;
-                IsUpdateAvailable = true;
-                LastCheckStatus = UpdateCheckStatus.UpdateAvailable;
-            }
-            else
-            {
-                IsUpdateAvailable = false;
-                LastCheckStatus = UpdateCheckStatus.UpToDate;
-            }
+            rel = await _releases.GetLatestReleaseAsync(ct);
         }
-        finally
+        catch
         {
-            IsChecking = false;
+            LastCheckStatus = UpdateCheckStatus.CheckFailed;
+            IsUpdateAvailable = false;
+            return;
+        }
+
+        if (rel is null)
+        {
+            LastCheckStatus = UpdateCheckStatus.CheckFailed;
+            IsUpdateAvailable = false;
+            return;
+        }
+
+        var latest = (rel.TagName ?? "").TrimStart('v', 'V');
+        var cmp = VersionComparer.Compare(latest, CurrentVersion);
+        if (cmp.IsNewer)
+        {
+            LatestVersion = latest;
+            IsUpdateAvailable = true;
+            LastCheckStatus = UpdateCheckStatus.UpdateAvailable;
+        }
+        else
+        {
+            IsUpdateAvailable = false;
+            LastCheckStatus = UpdateCheckStatus.UpToDate;
         }
     }
 }

src/ClaudeDo.Ui/ViewModels/IslandsShellViewModel.cs

@@ -377,6 +377,10 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
                 RefreshBannerFromStatus();
             }
         };
+        _updateCheck.Op.PropertyChanged += (_, e) =>
+        {
+            if (e.PropertyName == nameof(OperationStatus.IsRunning)) CheckForUpdatesCommand.NotifyCanExecuteChanged();
+        };
         // Fire-and-forget startup check — never block UI.
         _ = Task.Run(async () =>
         {
@@ -578,7 +582,9 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         finally { _usageMonitorOpen = false; }
     }
 
-    [RelayCommand]
+    private bool CanCheckForUpdates() => !_updateCheck.Op.IsRunning;
+
+    [RelayCommand(CanExecute = nameof(CanCheckForUpdates))]
     private async Task CheckForUpdatesAsync()
     {
         await _updateCheck.CheckNowAsync(CancellationToken.None);

src/ClaudeDo.Ui/ViewModels/Modals/RepoImportModalViewModel.cs

@@ -33,6 +33,8 @@ public sealed partial class RepoImportModalViewModel : ViewModelBase
     private readonly HashSet<string> _existingDirs = new(StringComparer.OrdinalIgnoreCase);
     private readonly List<string> _folders = new();
 
+    public OperationStatus ScanOp { get; } = new();
+
     public ObservableCollection<RepoImportItemViewModel> Repos { get; } = new();
 
     public Action? CloseAction { get; set; }
@@ -96,6 +98,7 @@ public sealed partial class RepoImportModalViewModel : ViewModelBase
 
     private async Task ScanAndAddAsync(IEnumerable<string> folders)
     {
+        using var op = ScanOp.Begin(Loc.T("ops.repoImport.scanning"));
         var current = new HashSet<string>(
             Repos.Select(r => r.FullPath), StringComparer.OrdinalIgnoreCase);
 

src/ClaudeDo.Ui/ViewModels/Modals/Settings/FilesSettingsTabViewModel.cs

@@ -11,8 +11,9 @@ public sealed partial class FilesSettingsTabViewModel : ViewModelBase
 {
     private readonly IWorkerClient _worker;
 
+    public OperationStatus RestoreOp { get; } = new();
+
     [ObservableProperty] private string _statusMessage = "";
-    [ObservableProperty] private bool _isBusy;
     [ObservableProperty] private bool _hasCustomizedPrompts;
     [ObservableProperty] private string? _viewedKindName;
     [ObservableProperty] private string _viewedContent = "";
@@ -30,12 +31,19 @@ public sealed partial class FilesSettingsTabViewModel : ViewModelBase
     {
         _worker = worker;
         RefreshCustomizedPrompts();
+        RestoreOp.PropertyChanged += (_, e) =>
+        {
+            if (e.PropertyName == nameof(OperationStatus.IsRunning)) RestoreDefaultAgentsCommand.NotifyCanExecuteChanged();
+        };
     }
 
-    [RelayCommand]
+    private bool CanRestoreDefaultAgents() => !RestoreOp.IsRunning;
+
+    [RelayCommand(CanExecute = nameof(CanRestoreDefaultAgents))]
     private async Task RestoreDefaultAgents()
     {
-        IsBusy = true; StatusMessage = "";
+        StatusMessage = "";
+        using var op = RestoreOp.Begin(Loc.T("ops.skills.restoringDefaults"));
         try
         {
             var r = await _worker.RestoreDefaultAgentsAsync();
@@ -46,7 +54,6 @@ public sealed partial class FilesSettingsTabViewModel : ViewModelBase
             await _worker.RefreshAgentsAsync();
         }
         catch (Exception ex) { StatusMessage = Loc.T("vm.filesTab.restoreFailed", ex.Message); }
-        finally { IsBusy = false; }
     }
 
     [RelayCommand]

src/ClaudeDo.Ui/ViewModels/Modals/Settings/SessionSkillsSettingsTabViewModel.cs

@@ -10,6 +10,9 @@ public sealed partial class SessionSkillsSettingsTabViewModel : ViewModelBase
 {
     private readonly IWorkerClient _worker;
 
+    public OperationStatus InstallOp { get; } = new();
+    public OperationStatus UpdateOp { get; } = new();
+
     [ObservableProperty] private string _installUrl = "";
     [ObservableProperty] private string _statusMessage = "";
     [ObservableProperty] private bool _isBusy;
@@ -17,7 +20,18 @@ public sealed partial class SessionSkillsSettingsTabViewModel : ViewModelBase
 
     public ObservableCollection<SessionSkillDto> Skills { get; } = new();
 
-    public SessionSkillsSettingsTabViewModel(IWorkerClient worker) => _worker = worker;
+    public SessionSkillsSettingsTabViewModel(IWorkerClient worker)
+    {
+        _worker = worker;
+        InstallOp.PropertyChanged += (_, e) =>
+        {
+            if (e.PropertyName == nameof(OperationStatus.IsRunning)) InstallCommand.NotifyCanExecuteChanged();
+        };
+        UpdateOp.PropertyChanged += (_, e) =>
+        {
+            if (e.PropertyName == nameof(OperationStatus.IsRunning)) UpdateCommand.NotifyCanExecuteChanged();
+        };
+    }
 
     public async Task LoadAsync()
     {
@@ -32,11 +46,14 @@ public sealed partial class SessionSkillsSettingsTabViewModel : ViewModelBase
         finally { IsBusy = false; }
     }
 
-    [RelayCommand]
+    private bool CanInstall() => !InstallOp.IsRunning;
+
+    [RelayCommand(CanExecute = nameof(CanInstall))]
     private async Task InstallAsync()
     {
         if (string.IsNullOrWhiteSpace(InstallUrl)) return;
-        IsBusy = true; StatusMessage = "";
+        StatusMessage = "";
+        using var op = InstallOp.Begin(Loc.T("ops.skills.installing"));
         try
         {
             var installed = await _worker.InstallSessionSkillAsync(InstallUrl.Trim());
@@ -45,14 +62,16 @@ public sealed partial class SessionSkillsSettingsTabViewModel : ViewModelBase
             await LoadAsync();
         }
         catch (Exception ex) { StatusMessage = Loc.T("vm.sessionSkillsTab.installFailed", ex.Message); }
-        finally { IsBusy = false; }
     }
 
-    [RelayCommand]
+    private bool CanUpdate(string? sourceUrl) => !UpdateOp.IsRunning;
+
+    [RelayCommand(CanExecute = nameof(CanUpdate))]
     private async Task UpdateAsync(string? sourceUrl)
     {
         if (string.IsNullOrWhiteSpace(sourceUrl)) return;
-        IsBusy = true; StatusMessage = "";
+        StatusMessage = "";
+        using var op = UpdateOp.Begin(Loc.T("ops.skills.updating"));
         try
         {
             await _worker.UpdateSessionSkillAsync(sourceUrl);
@@ -60,7 +79,6 @@ public sealed partial class SessionSkillsSettingsTabViewModel : ViewModelBase
             await LoadAsync();
         }
         catch (Exception ex) { StatusMessage = Loc.T("vm.sessionSkillsTab.updateFailed", ex.Message); }
-        finally { IsBusy = false; }
     }
 
     [RelayCommand]

src/ClaudeDo.Ui/Views/MainWindow.axaml

@@ -83,6 +83,7 @@
               <MenuItem Header="{loc:Tr shell.menu.about}" Command="{Binding OpenAboutCommand}"/>
             </MenuItem>
           </Menu>
+          <controls:OperationIndicator DataContext="{Binding UpdateCheck.Op}" Margin="8,0,0,0"/>
         </StackPanel>
 
         <!-- Middle: draggable strip -->

src/ClaudeDo.Ui/Views/Modals/RepoImportModalView.axaml

@@ -39,6 +39,7 @@
                   Command="{Binding ForgetFoldersCommand}"
                   IsVisible="{Binding HasFolders}"/>
         </Grid>
+        <ctl:OperationIndicator DataContext="{Binding ScanOp}"/>
       </StackPanel>
 
       <!-- Repo checklist -->

src/ClaudeDo.Ui/Views/Modals/SettingsModalView.axaml

@@ -280,8 +280,8 @@
                            TextWrapping="Wrap"/>
                 <Button Classes="btn" Content="{loc:Tr settings.files.restoreDefaultAgents}"
                         Command="{Binding Files.RestoreDefaultAgentsCommand}"
-                        IsEnabled="{Binding !Files.IsBusy}"
                         HorizontalAlignment="Left"/>
+                <ctl:OperationIndicator DataContext="{Binding Files.RestoreOp}"/>
               </StackPanel>
               <StackPanel Spacing="6">
                 <TextBlock Classes="section-label" Text="{loc:Tr settings.files.promptsSection}"/>
@@ -502,15 +502,16 @@
                   <TextBox Grid.Column="0" Text="{Binding SessionSkills.InstallUrl, Mode=TwoWay}"
                            PlaceholderText="{loc:Tr settings.skills.installUrlPlaceholder}"/>
                   <Button Grid.Column="1" Classes="btn" Content="{loc:Tr settings.skills.installButton}"
-                          Command="{Binding SessionSkills.InstallCommand}"
-                          IsEnabled="{Binding !SessionSkills.IsBusy}"/>
+                          Command="{Binding SessionSkills.InstallCommand}"/>
                 </Grid>
+                <ctl:OperationIndicator DataContext="{Binding SessionSkills.InstallOp}"/>
               </StackPanel>
 
               <Border BorderBrush="{DynamicResource LineBrush}" BorderThickness="0,1,0,0" Margin="0,2,0,0"/>
 
               <StackPanel Spacing="6">
                 <TextBlock Classes="section-label" Text="{loc:Tr settings.skills.installedSection}"/>
+                <ctl:OperationIndicator DataContext="{Binding SessionSkills.UpdateOp}"/>
                 <ItemsControl ItemsSource="{Binding SessionSkills.Skills}">
                   <ItemsControl.ItemTemplate>
                     <DataTemplate x:DataType="services:SessionSkillDto">

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()
     {