diff --git a/src/TableCloth.App/Dialogs/SkillMarketplaceWindow.axaml b/src/TableCloth.App/Dialogs/SkillMarketplaceWindow.axaml
index eca6d06c..d4dee1d3 100644
--- a/src/TableCloth.App/Dialogs/SkillMarketplaceWindow.axaml
+++ b/src/TableCloth.App/Dialogs/SkillMarketplaceWindow.axaml
@@ -2,6 +2,8 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:vm="using:TableCloth.ViewModels"
         xmlns:ai="using:TableCloth.ManagedAi"
+        xmlns:automation="using:Avalonia.Automation"
+        xmlns:ui="using:TableCloth.Theme.Controls"
         x:Class="TableCloth.Dialogs.SkillMarketplaceWindow"
         x:DataType="vm:SkillMarketplaceWindowViewModel"
         Title="{x:Static ai:ManagedAiText.MarketplaceTitle}"
@@ -22,6 +24,26 @@
             <TextBlock Text="{x:Static ai:ManagedAiText.MarketplaceDescription}" TextWrapping="Wrap" />
             <TextBlock Text="{x:Static ai:ManagedAiText.MarketplaceScope}" FontSize="11"
                        Foreground="{DynamicResource ControlSecondaryForeground}" />
+            <Border x:Name="MarketplaceActivity" IsVisible="{Binding IsBusy}" Margin="0 7 0 0"
+                    Background="{DynamicResource ControlFillColorSecondaryBrush}"
+                    BorderBrush="{DynamicResource OptionsListBorderBrush}" BorderThickness="1" CornerRadius="4" Padding="12 10">
+                <Grid ColumnDefinitions="Auto,*" ColumnSpacing="12">
+                    <ui:ProgressRing x:Name="MarketplaceProgress" IsIndeterminate="True" IsActive="{Binding IsBusy}"
+                                     Width="24" Height="24" VerticalAlignment="Center"
+                                     automation:AutomationProperties.Name="{x:Static ai:ManagedAiText.MarketplaceTitle}" />
+                    <StackPanel Grid.Column="1" Spacing="6" VerticalAlignment="Center">
+                        <TextBlock x:Name="CatalogActivity" Text="{Binding CatalogActivityText}" IsVisible="{Binding CatalogBusy}"
+                                   TextWrapping="Wrap" FontSize="12" automation:AutomationProperties.LiveSetting="Polite"
+                                   automation:AutomationProperties.Name="{Binding CatalogActivityText}" />
+                        <TextBlock x:Name="LocalActivity" Text="{Binding LocalActivityText}" IsVisible="{Binding HasLocalActivity}"
+                                   TextWrapping="Wrap" FontSize="12" automation:AutomationProperties.LiveSetting="Polite"
+                                   automation:AutomationProperties.Name="{Binding LocalActivityText}" />
+                        <TextBlock x:Name="RuntimeActivity" Text="{Binding SkillRuntimeNotice}" IsVisible="{Binding SkillRuntimeBusy}"
+                                   TextWrapping="Wrap" FontSize="12" automation:AutomationProperties.LiveSetting="Polite"
+                                   automation:AutomationProperties.Name="{Binding SkillRuntimeNotice}" />
+                    </StackPanel>
+                </Grid>
+            </Border>
         </StackPanel>
         <TabControl Grid.Row="1" x:Name="MarketplaceTabs">
             <TabItem Header="{x:Static ai:ManagedAiText.MarketplaceBrowse}">
@@ -86,7 +108,7 @@
                             </WrapPanel>
                         </Grid>
                     </Grid>
-                    <TextBlock Grid.Row="3" x:Name="CatalogNotice" Text="{Binding CatalogNotice}" TextWrapping="Wrap" FontSize="12"
+                    <TextBlock Grid.Row="3" x:Name="CatalogNotice" Text="{Binding CatalogNotice}" TextWrapping="Wrap" FontSize="12" IsVisible="{Binding !CatalogBusy}"
                                Foreground="{DynamicResource ControlSecondaryForeground}" />
                 </Grid>
             </TabItem>
@@ -141,12 +163,12 @@
                         <Button x:Name="InstalledRefresh" Content="{x:Static ai:ManagedAiText.SkillsRefresh}" Command="{Binding RefreshInstalledCommand}" />
                         <Button x:Name="InstalledRootFolder" Content="{x:Static ai:ManagedAiText.SkillsOpenFolder}" Command="{Binding OpenRootFolderCommand}" />
                     </WrapPanel>
-                    <TextBlock Grid.Row="4" x:Name="InstalledNotice" Text="{Binding LocalNotice}" TextWrapping="Wrap" FontSize="12"
+                    <TextBlock Grid.Row="4" x:Name="InstalledNotice" Text="{Binding LocalNotice}" TextWrapping="Wrap" FontSize="12" IsVisible="{Binding !HasLocalActivity}"
                                Foreground="{DynamicResource ControlSecondaryForeground}" />
                 </Grid>
             </TabItem>
             <TabItem Header="{x:Static ai:ManagedAiText.MarketplaceRuntimes}">
-                <Grid Margin="12 16" RowDefinitions="*,Auto,Auto,Auto" RowSpacing="10">
+                <Grid Margin="12 16" RowDefinitions="*,Auto,Auto" RowSpacing="10">
                     <ScrollViewer VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Disabled">
                         <StackPanel Spacing="14" MaxWidth="680" HorizontalAlignment="Left">
                             <TextBlock Text="{x:Static ai:ManagedAiText.SkillRuntimeDescription}" TextWrapping="Wrap" />
@@ -179,8 +201,7 @@
                         <Button x:Name="SkillRuntimeInstall" Content="{x:Static ai:ManagedAiText.SkillRuntimeInstall}" Command="{Binding InstallSkillRuntimesCommand}" />
                         <Button x:Name="SkillRuntimeRefresh" Content="{x:Static ai:ManagedAiText.SkillRuntimeRefresh}" Command="{Binding RefreshSkillRuntimeStatusCommand}" />
                     </WrapPanel>
-                    <ProgressBar Grid.Row="2" x:Name="SkillRuntimeProgress" IsIndeterminate="True" IsVisible="{Binding SkillRuntimeBusy}" Height="4" />
-                    <TextBlock Grid.Row="3" x:Name="SkillRuntimeNotice" Text="{Binding SkillRuntimeNotice}" TextWrapping="Wrap"
+                    <TextBlock Grid.Row="2" x:Name="SkillRuntimeNotice" Text="{Binding SkillRuntimeNotice}" TextWrapping="Wrap" IsVisible="{Binding !SkillRuntimeBusy}"
                                Foreground="{DynamicResource ControlSecondaryForeground}" />
                 </Grid>
             </TabItem>
diff --git a/src/TableCloth.App/ViewModels/SkillMarketplaceWindowViewModel.Runtimes.cs b/src/TableCloth.App/ViewModels/SkillMarketplaceWindowViewModel.Runtimes.cs
index e52a4d46..6b52ccb1 100644
--- a/src/TableCloth.App/ViewModels/SkillMarketplaceWindowViewModel.Runtimes.cs
+++ b/src/TableCloth.App/ViewModels/SkillMarketplaceWindowViewModel.Runtimes.cs
@@ -47,6 +47,7 @@ public partial class SkillMarketplaceWindowViewModel
 
     partial void OnSkillRuntimeBusyChanged(bool value)
     {
+        OnPropertyChanged(nameof(IsBusy));
         InstallSkillRuntimesCommand.NotifyCanExecuteChanged();
         RefreshSkillRuntimeStatusCommand.NotifyCanExecuteChanged();
     }
diff --git a/src/TableCloth.App/ViewModels/SkillMarketplaceWindowViewModel.cs b/src/TableCloth.App/ViewModels/SkillMarketplaceWindowViewModel.cs
index 33cdd29f..41fba7a9 100644
--- a/src/TableCloth.App/ViewModels/SkillMarketplaceWindowViewModel.cs
+++ b/src/TableCloth.App/ViewModels/SkillMarketplaceWindowViewModel.cs
@@ -87,12 +87,17 @@ public SkillMarketplaceWindowViewModel(IManagedAiSkillManager manager, IManagedA
     [ObservableProperty] private bool _localBusy;
     [ObservableProperty] private string _catalogNotice = string.Empty;
     [ObservableProperty] private string _localNotice = string.Empty;
+    [ObservableProperty] private string _localActivityText = string.Empty;
 
     public bool HasSelectedCatalogSkill => SelectedCatalogSkill is not null;
     public bool HasSelectedInstalledSkill => SelectedInstalledSkill is not null;
-    public bool CatalogEmpty => CatalogSkills.Count == 0;
-    public bool InstalledEmpty => InstalledSkills.Count == 0;
-    public string CatalogSummary => ManagedAiText.Select($"후보 {_catalog.Count}개, 표시 {CatalogSkills.Count}개", $"{_catalog.Count} candidates, {CatalogSkills.Count} shown");
+    public bool IsBusy => CatalogBusy || LocalBusy || SkillRuntimeBusy;
+    public bool HasLocalActivity => LocalBusy && LocalActivityText.Length > 0;
+    public string CatalogActivityText => ManagedAiText.Select("스킬 카탈로그를 불러오고 있습니다.", "Loading the skill catalog.");
+    public bool CatalogEmpty => !CatalogBusy && CatalogSkills.Count == 0;
+    public bool InstalledEmpty => !LocalBusy && InstalledSkills.Count == 0;
+    public string CatalogSummary => CatalogBusy ? CatalogActivityText
+        : ManagedAiText.Select($"후보 {_catalog.Count}개, 표시 {CatalogSkills.Count}개", $"{_catalog.Count} candidates, {CatalogSkills.Count} shown");
     public string InstalledSummary => ManagedAiText.Select($"보유 스킬 {_installed.Count}개, 활성 스킬 {_installed.Count(x => x.Enabled)}개, 표시 {InstalledSkills.Count}개",
         $"{_installed.Count} installed, {_installed.Count(x => x.Enabled)} enabled, {InstalledSkills.Count} shown");
     public string ToggleLabel => SelectedInstalledSkill?.Enabled == true ? ManagedAiText.Select("비활성화", "Disable") : ManagedAiText.Select("활성화", "Enable");
@@ -114,9 +119,19 @@ partial void OnSelectedInstalledSkillChanged(SkillSettingsItem? value)
         OnPropertyChanged(nameof(ToggleLabel));
         NotifyLocalCommands();
     }
-    partial void OnLocalBusyChanged(bool value) => NotifyLocalCommands();
+    partial void OnLocalActivityTextChanged(string value) => OnPropertyChanged(nameof(HasLocalActivity));
+    partial void OnLocalBusyChanged(bool value)
+    {
+        NotifyLocalCommands();
+        OnPropertyChanged(nameof(IsBusy));
+        OnPropertyChanged(nameof(HasLocalActivity));
+        OnPropertyChanged(nameof(InstalledEmpty));
+    }
     partial void OnCatalogBusyChanged(bool value)
     {
+        OnPropertyChanged(nameof(IsBusy));
+        OnPropertyChanged(nameof(CatalogEmpty));
+        OnPropertyChanged(nameof(CatalogSummary));
         RefreshCatalogCommand.NotifyCanExecuteChanged();
         InstallSkillCommand.NotifyCanExecuteChanged();
         UpdateCatalogSkillCommand.NotifyCanExecuteChanged();
@@ -183,54 +198,63 @@ private async Task RefreshCatalog()
     }
 
     [RelayCommand(CanExecute = nameof(CanUseLocal))]
-    private Task RefreshInstalled() => RunLocalAsync(() => _manager.ListAsync(_token), ManagedAiText.Select("설치된 스킬을 새로 불러왔습니다.", "Installed skills refreshed."));
+    private Task RefreshInstalled() => RunLocalAsync(() => _manager.ListAsync(_token),
+        ManagedAiText.Select("설치된 스킬을 불러오고 있습니다.", "Loading installed skills."),
+        ManagedAiText.Select("설치된 스킬을 새로 불러왔습니다.", "Installed skills refreshed."));
 
     [RelayCommand(CanExecute = nameof(CanUseLocal))]
     private async Task ImportSkill()
     {
         if (!CanUseLocal() || PickFolderAsync is null) return;
+        LocalActivityText = ManagedAiText.Select("가져올 스킬 폴더를 선택하고 있습니다.", "Selecting a skill folder to import.");
         LocalBusy = true;
         string? source;
         try { source = await PickFolderAsync(); }
         catch { LocalNotice = ManagedAiText.Select("스킬 폴더를 선택하지 못했습니다.", "Could not select a skill folder."); return; }
-        finally { LocalBusy = false; }
+        finally { LocalBusy = false; LocalActivityText = string.Empty; }
         if (!string.IsNullOrWhiteSpace(source)) await ImportFromDirectoryAsync(source);
     }
 
     public Task ImportFromDirectoryAsync(string source) => RunLocalAsync(() => _manager.ImportAsync(source, _token),
+        ManagedAiText.Select("스킬을 전용 폴더로 가져오고 있습니다.", "Importing the skill into the dedicated folder."),
         ManagedAiText.Select("스킬을 전용 폴더로 가져왔습니다.", "Skill imported into the dedicated folder."));
 
     [RelayCommand(CanExecute = nameof(CanInstall))]
     private Task InstallSkill()
     {
         if (!CanInstall()) return Task.CompletedTask;
-        var id = SelectedCatalogSkill!.Id;
-        return RunMarketplaceActionAsync(() => _marketplace.InstallAsync(id, _token), ManagedAiText.Select("스킬을 설치했습니다.", "Skill installed."), true);
+        var selected = SelectedCatalogSkill!;
+        return RunMarketplaceActionAsync(() => _marketplace.InstallAsync(selected.Id, _token),
+            ManagedAiText.Select($"{selected.Name} 스킬을 설치하고 있습니다.", $"Installing {selected.Name}."),
+            ManagedAiText.Select("스킬을 설치했습니다.", "Skill installed."), true);
     }
 
     [RelayCommand(CanExecute = nameof(CanUpdateCatalog))]
     private Task UpdateCatalogSkill()
     {
         if (!CanUpdateCatalog()) return Task.CompletedTask;
-        return UpdateAsync(SelectedCatalogSkill!.Id, true);
+        var selected = SelectedCatalogSkill!;
+        return UpdateAsync(selected.Id, selected.Name, true);
     }
 
     [RelayCommand(CanExecute = nameof(CanUpdateInstalled))]
     private Task UpdateInstalledSkill()
     {
         if (!CanUpdateInstalled()) return Task.CompletedTask;
-        return UpdateAsync(SelectedInstalledSkill!.Id);
+        var selected = SelectedInstalledSkill!;
+        return UpdateAsync(selected.Id, selected.Name);
     }
 
-    private Task UpdateAsync(string id, bool fromCatalog = false)
+    private Task UpdateAsync(string id, string name, bool fromCatalog = false)
     {
         var success = ManagedAiText.Select("스킬 파일을 카탈로그의 커밋으로 업데이트했습니다.", "Skill files updated to the catalog commit.");
-        return RunMarketplaceActionAsync(() => _marketplace.UpdateAsync(id, _token), success, fromCatalog);
+        return RunMarketplaceActionAsync(() => _marketplace.UpdateAsync(id, _token),
+            ManagedAiText.Select($"{name} 스킬을 업데이트하고 있습니다.", $"Updating {name}."), success, fromCatalog);
     }
 
-    private async Task RunMarketplaceActionAsync(Func<Task<IReadOnlyList<AiSkill>>> action, string success, bool fromCatalog)
+    private async Task RunMarketplaceActionAsync(Func<Task<IReadOnlyList<AiSkill>>> action, string activity, string success, bool fromCatalog)
     {
-        if (await RunLocalAsync(action, success))
+        if (await RunLocalAsync(action, activity, success))
         {
             await RefreshCatalog();
             LocalNotice = _catalogAvailable ? success : success + " " + CatalogNotice;
@@ -244,6 +268,7 @@ private Task ToggleSkill()
         if (!CanToggleSelected()) return Task.CompletedTask;
         var selected = SelectedInstalledSkill!;
         return RunLocalAsync(() => _manager.SetEnabledAsync(selected.Id, !selected.Enabled, _token),
+            ManagedAiText.Select($"{selected.Name} 스킬 사용 설정을 변경하고 있습니다.", $"Updating the enabled state of {selected.Name}."),
             ManagedAiText.Select("스킬 사용 설정을 변경했습니다. 다음 대화부터 적용합니다.", "Skill state updated. The next chat uses this setting."));
     }
 
@@ -257,17 +282,20 @@ private Task RemoveSkill()
             return Task.CompletedTask;
         // A modal confirmation can run a nested UI loop. Recheck the captured selection before mutation.
         if (!CanUseSelectedLocal() || !ReferenceEquals(selected, SelectedInstalledSkill)) return Task.CompletedTask;
-        return RunLocalAsync(() => _manager.RemoveAsync(selected.Id, _token), ManagedAiText.Select("스킬을 제거했습니다.", "Skill removed."));
+        return RunLocalAsync(() => _manager.RemoveAsync(selected.Id, _token),
+            ManagedAiText.Select($"{selected.Name} 스킬을 제거하고 있습니다.", $"Removing {selected.Name}."),
+            ManagedAiText.Select("스킬을 제거했습니다.", "Skill removed."));
     }
 
-    private async Task<bool> RunLocalAsync(Func<Task<IReadOnlyList<AiSkill>>> action, string success)
+    private async Task<bool> RunLocalAsync(Func<Task<IReadOnlyList<AiSkill>>> action, string activity, string success)
     {
         if (!CanUseLocal()) return false;
         var succeeded = false;
         var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
         _localCompletion = completion;
+        LocalActivityText = activity;
         LocalBusy = true;
-        LocalNotice = ManagedAiText.Select("전용 스킬을 확인하고 있습니다.", "Checking dedicated skills.");
+        LocalNotice = activity;
         try
         {
             _installed = await Task.Run(action, _token);
@@ -290,7 +318,7 @@ private async Task<bool> RunLocalAsync(Func<Task<IReadOnlyList<AiSkill>>> action
             };
         }
         catch { LocalNotice = ManagedAiText.Select("스킬 작업을 완료하지 못했습니다. 잠시 후 다시 시도할 수 있습니다.", "Could not complete the skill operation. Try again shortly."); }
-        finally { LocalBusy = false; completion.TrySetResult(); }
+        finally { LocalBusy = false; LocalActivityText = string.Empty; completion.TrySetResult(); }
         return succeeded;
     }
 
diff --git a/src/TableCloth.Test/SkillMarketplaceTests.Progress.cs b/src/TableCloth.Test/SkillMarketplaceTests.Progress.cs
new file mode 100644
index 00000000..31f1e3b8
--- /dev/null
+++ b/src/TableCloth.Test/SkillMarketplaceTests.Progress.cs
@@ -0,0 +1,421 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Avalonia.Styling;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using TableCloth.Dialogs;
+using TableCloth.ManagedAi;
+using TableCloth.Theme.Controls;
+using TableCloth.ViewModels;
+
+namespace TableCloth.Test;
+
+public sealed partial class SkillMarketplaceTests
+{
+    [TestMethod]
+    [DataRow("en-US", false, true)]
+    [DataRow("ko-KR", true, false)]
+    public Task PendingDiscoveryShowsBoundProgressAndSuppressesPrematureEmptyResults(
+        string cultureName, bool dark, bool catalogFirst) => OnUiThread(async () =>
+    {
+        using var culture = new UiCultureScope(cultureName);
+        Application.Current!.RequestedThemeVariant = dark ? ThemeVariant.Dark : ThemeVariant.Light;
+        var manager = new SkillManager { Items = [], ListGate = NewProgressCompletion() };
+        var remote = new Marketplace(manager) { Entries = [], ListGate = NewProgressCompletion() };
+        using var model = new SkillMarketplaceWindowViewModel(manager, remote, new Messages());
+        var window = ProgressWindow(model);
+        var load = model.LoadAsync();
+        try
+        {
+            await Task.WhenAll(manager.ListStarted.Task, remote.Started.Task).WaitAsync(TimeSpan.FromSeconds(5));
+            Dispatcher.UIThread.RunJobs();
+            Assert.IsTrue(model.CatalogBusy);
+            Assert.IsTrue(model.LocalBusy);
+            Assert.IsFalse(model.CatalogEmpty);
+            Assert.IsFalse(model.InstalledEmpty);
+            AssertProgressVisible(window, model);
+            Assert.AreEqual(model.CatalogActivityText, window.FindControl<TextBlock>("CatalogActivity")!.Text);
+            Assert.AreEqual(model.LocalActivityText, window.FindControl<TextBlock>("LocalActivity")!.Text);
+            Assert.IsTrue(window.FindControl<TextBlock>("CatalogActivity")!.IsEffectivelyVisible);
+            Assert.IsTrue(window.FindControl<TextBlock>("LocalActivity")!.IsEffectivelyVisible);
+            Assert.IsFalse(window.GetVisualDescendants().OfType<TextBlock>()
+                .Any(x => x.Text == ManagedAiText.MarketplaceNoResults && x.IsEffectivelyVisible));
+            Assert.IsFalse(window.FindControl<Button>("CatalogRefresh")!.IsEffectivelyEnabled);
+            await SaveProgressAsync(window, $"marketplace-progress-{cultureName}-{(dark ? "dark" : "light")}-loading.png");
+
+            if (catalogFirst)
+            {
+                remote.ListGate.SetResult();
+                await Until(() => !model.CatalogBusy);
+                Assert.IsTrue(model.LocalBusy);
+                Assert.IsFalse(model.InstalledEmpty);
+            }
+            else
+            {
+                manager.ListGate.SetResult();
+                await Until(() => !model.LocalBusy);
+                Assert.IsTrue(model.CatalogBusy);
+                Assert.IsFalse(model.CatalogEmpty);
+            }
+            AssertProgressVisible(window, model);
+            manager.ListGate.TrySetResult();
+            remote.ListGate.TrySetResult();
+            await load.WaitAsync(TimeSpan.FromSeconds(5));
+            Dispatcher.UIThread.RunJobs();
+            Assert.IsFalse(model.IsBusy);
+            Assert.IsFalse(model.HasLocalActivity);
+            Assert.IsTrue(model.CatalogEmpty);
+            Assert.IsTrue(model.InstalledEmpty);
+            Assert.IsFalse(window.FindControl<Control>("MarketplaceActivity")!.IsVisible);
+            Assert.IsTrue(window.FindControl<Button>("CatalogRefresh")!.IsEffectivelyEnabled);
+        }
+        finally
+        {
+            manager.ListGate.TrySetResult();
+            remote.ListGate.TrySetResult();
+            window.Close();
+        }
+    });
+
+    [TestMethod]
+    [DataRow("en-US", false, "install")]
+    [DataRow("ko-KR", true, "remove")]
+    [DataRow("en-US", false, "update")]
+    public Task PendingMutationShowsItsCapturedTargetAcrossTabsAndDisablesFurtherActions(
+        string cultureName, bool dark, string operation) => OnUiThread(async () =>
+    {
+        using var culture = new UiCultureScope(cultureName);
+        Application.Current!.RequestedThemeVariant = dark ? ThemeVariant.Dark : ThemeVariant.Light;
+        var state = new SkillManager { Items = [TrackedSkill()] };
+        var manager = new ProgressSkillManager(state);
+        var remote = new ProgressMarketplace(new Marketplace(state));
+        using var model = new SkillMarketplaceWindowViewModel(manager, remote, new Messages());
+        await model.LoadAsync();
+        SelectProgressTarget(model, operation);
+        var target = operation == "install" ? model.SelectedCatalogSkill!.Name : model.SelectedInstalledSkill!.Name;
+        var gate = ProgressGateFor(manager, remote, operation);
+        var window = ProgressWindow(model);
+        var task = ExecuteProgressMutation(model, operation);
+        try
+        {
+            await gate.Started.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            Assert.IsTrue(model.HasLocalActivity);
+            Assert.Contains(target, model.LocalActivityText);
+            var verb = cultureName == "ko-KR"
+                ? operation switch { "install" => "설치", "update" => "업데이트", _ => "제거" }
+                : operation switch { "install" => "Installing", "update" => "Updating", _ => "Removing" };
+            Assert.Contains(verb, model.LocalActivityText);
+            Assert.IsFalse(model.ImportSkillCommand.CanExecute(null));
+            Assert.IsFalse(model.RefreshInstalledCommand.CanExecute(null));
+            Assert.IsFalse(model.InstallSkillCommand.CanExecute(null));
+            Assert.IsFalse(model.UpdateInstalledSkillCommand.CanExecute(null));
+            Assert.IsFalse(model.RemoveSkillCommand.CanExecute(null));
+            var capturedActivity = model.LocalActivityText;
+            model.SelectedCatalogSkill = model.CatalogSkills.FirstOrDefault(x => x.Id == "another");
+            model.SelectedInstalledSkill = null;
+            var tabs = window.FindControl<TabControl>("MarketplaceTabs")!;
+            foreach (var tab in new[] { 0, 1, 2 })
+            {
+                tabs.SelectedIndex = tab;
+                Dispatcher.UIThread.RunJobs();
+                AssertProgressVisible(window, model);
+                var activity = window.FindControl<TextBlock>("LocalActivity")!;
+                Assert.IsTrue(activity.IsEffectivelyVisible);
+                Assert.AreEqual(capturedActivity, activity.Text);
+            }
+            tabs.SelectedIndex = operation == "install" ? 0 : 1;
+            Dispatcher.UIThread.RunJobs();
+            Assert.IsFalse(window.FindControl<Button>(operation == "install" ? "CatalogInstall" : "InstalledRemove")!.IsEffectivelyEnabled);
+            await SaveProgressAsync(window, $"marketplace-progress-{cultureName}-{(dark ? "dark" : "light")}-{operation}.png");
+            gate.Release.TrySetResult();
+            await task.WaitAsync(TimeSpan.FromSeconds(5));
+            Dispatcher.UIThread.RunJobs();
+            Assert.IsFalse(model.IsBusy);
+            Assert.IsFalse(model.HasLocalActivity);
+            Assert.AreEqual(string.Empty, model.LocalActivityText);
+            Assert.IsFalse(window.FindControl<Control>("MarketplaceActivity")!.IsVisible);
+            if (operation == "install") Assert.IsTrue(state.Items.Any(x => x.Id == "available"));
+            if (operation == "remove") Assert.IsEmpty(state.Items);
+            if (operation == "update") Assert.AreEqual(new string('b', 40), state.Items.Single().Source!.SourceRef);
+        }
+        finally { gate.Release.TrySetResult(); window.Close(); }
+    });
+
+    [TestMethod]
+    [DataRow("install", "failure")]
+    [DataRow("install", "cancel")]
+    [DataRow("update", "failure")]
+    [DataRow("update", "cancel")]
+    [DataRow("remove", "failure")]
+    [DataRow("remove", "cancel")]
+    public Task MutationFailureOrCancellationClearsActivityAndRestoresLocalControls(string operation, string outcome) => OnUiThread(async () =>
+    {
+        using var culture = new UiCultureScope("en-US");
+        var state = new SkillManager { Items = [TrackedSkill()] };
+        var manager = new ProgressSkillManager(state);
+        var remote = new ProgressMarketplace(new Marketplace(state));
+        using var model = new SkillMarketplaceWindowViewModel(manager, remote, new Messages());
+        await model.LoadAsync();
+        SelectProgressTarget(model, operation);
+        var gate = ProgressGateFor(manager, remote, operation);
+        gate.Outcome = outcome;
+        var task = ExecuteProgressMutation(model, operation);
+        try
+        {
+            await gate.Started.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            Assert.IsTrue(model.IsBusy);
+            Assert.IsTrue(model.HasLocalActivity);
+            gate.Release.TrySetResult();
+            await task.WaitAsync(TimeSpan.FromSeconds(5));
+            Assert.IsFalse(model.IsBusy);
+            Assert.IsFalse(model.LocalBusy);
+            Assert.IsFalse(model.HasLocalActivity);
+            Assert.AreEqual(string.Empty, model.LocalActivityText);
+            Assert.IsTrue(model.ImportSkillCommand.CanExecute(null));
+            Assert.IsTrue(model.RefreshInstalledCommand.CanExecute(null));
+            Assert.IsTrue(model.RemoveSkillCommand.CanExecute(null));
+            Assert.HasCount(1, state.Items);
+            Assert.AreEqual(new string('a', 40), state.Items.Single().Source!.SourceRef);
+            Assert.IsFalse(string.IsNullOrWhiteSpace(model.LocalNotice));
+            if (outcome == "cancel") Assert.AreEqual("Skill operation canceled.", model.LocalNotice);
+        }
+        finally { gate.Release.TrySetResult(); }
+    });
+
+    [TestMethod]
+    [DataRow(true)]
+    [DataRow(false)]
+    public Task ConcurrentCatalogAndRemovalKeepTheOtherActivityVisibleWhenEitherFinishes(bool catalogFirst) => OnUiThread(async () =>
+    {
+        var state = new SkillManager { Items = [TrackedSkill()] };
+        var manager = new ProgressSkillManager(state);
+        var catalog = new Marketplace(state);
+        using var model = new SkillMarketplaceWindowViewModel(manager, new ProgressMarketplace(catalog), new Messages());
+        await model.LoadAsync();
+        SelectProgressTarget(model, "remove");
+        var removal = model.RemoveSkillCommand.ExecuteAsync(null);
+        await manager.Removal.Started.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        catalog.ListGate = NewProgressCompletion();
+        var refresh = model.RefreshCatalogCommand.ExecuteAsync(null);
+        var window = ProgressWindow(model);
+        try
+        {
+            await Until(() => model.CatalogBusy && model.LocalBusy);
+            AssertProgressVisible(window, model);
+            if (catalogFirst)
+            {
+                catalog.ListGate.TrySetResult();
+                await refresh.WaitAsync(TimeSpan.FromSeconds(5));
+                Assert.IsFalse(model.CatalogBusy);
+                Assert.IsTrue(model.LocalBusy);
+                Dispatcher.UIThread.RunJobs();
+                Assert.IsTrue(window.FindControl<TextBlock>("LocalActivity")!.IsEffectivelyVisible);
+                AssertProgressVisible(window, model);
+                manager.Removal.Release.TrySetResult();
+            }
+            else
+            {
+                manager.Removal.Release.TrySetResult();
+                await removal.WaitAsync(TimeSpan.FromSeconds(5));
+                Assert.IsFalse(model.LocalBusy);
+                Assert.IsTrue(model.CatalogBusy);
+                Assert.IsFalse(model.HasLocalActivity);
+                Dispatcher.UIThread.RunJobs();
+                Assert.IsTrue(window.FindControl<TextBlock>("CatalogActivity")!.IsEffectivelyVisible);
+                AssertProgressVisible(window, model);
+                catalog.ListGate.TrySetResult();
+            }
+            await Task.WhenAll(removal, refresh).WaitAsync(TimeSpan.FromSeconds(5));
+            Assert.IsFalse(model.IsBusy);
+        }
+        finally { manager.Removal.Release.TrySetResult(); catalog.ListGate.TrySetResult(); window.Close(); }
+    });
+
+    [TestMethod]
+    [DataRow("success")]
+    [DataRow("failure")]
+    [DataRow("cancel")]
+    public Task RuntimeCheckKeepsCommonProgressVisibleAndClearsItOnEveryOutcome(string outcome) => OnUiThread(async () =>
+    {
+        var manager = new SkillManager();
+        var runtimes = new ProgressRuntimes();
+        runtimes.Check.Outcome = outcome;
+        using var model = new SkillMarketplaceWindowViewModel(manager, new Marketplace(manager), new Messages(), runtimes);
+        var load = model.LoadAsync();
+        var window = ProgressWindow(model);
+        try
+        {
+            await runtimes.Check.Started.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            await Until(() => !model.CatalogBusy && !model.LocalBusy);
+            Assert.IsTrue(model.SkillRuntimeBusy);
+            Assert.IsFalse(model.HasLocalActivity);
+            AssertProgressVisible(window, model);
+            Assert.IsTrue(window.FindControl<TextBlock>("RuntimeActivity")!.IsEffectivelyVisible);
+            Assert.AreEqual(model.SkillRuntimeNotice, window.FindControl<TextBlock>("RuntimeActivity")!.Text);
+            runtimes.Check.Release.TrySetResult();
+            await load.WaitAsync(TimeSpan.FromSeconds(5));
+            Dispatcher.UIThread.RunJobs();
+            Assert.IsFalse(model.IsBusy);
+            Assert.IsFalse(window.FindControl<Control>("MarketplaceActivity")!.IsVisible);
+        }
+        finally { runtimes.Check.Release.TrySetResult(); window.Close(); }
+    });
+
+    [TestMethod]
+    public Task DelayedDiscoveryFailureClearsProgressAndRestoresEmptyStateAndRefresh() => OnUiThread(async () =>
+    {
+        var manager = new SkillManager { Items = [], ListGate = NewProgressCompletion() };
+        var remote = new Marketplace(manager) { Failure = true, ListGate = NewProgressCompletion() };
+        using var model = new SkillMarketplaceWindowViewModel(manager, remote, new Messages());
+        var load = model.LoadAsync();
+        var window = ProgressWindow(model);
+        try
+        {
+            await Task.WhenAll(manager.ListStarted.Task, remote.Started.Task).WaitAsync(TimeSpan.FromSeconds(5));
+            AssertProgressVisible(window, model);
+            Assert.IsFalse(model.CatalogEmpty);
+            Assert.IsFalse(model.InstalledEmpty);
+            manager.ListGate.TrySetException(new ManagedAiException(AiFailureCode.SkillInvalid));
+            remote.ListGate.TrySetResult();
+            await load.WaitAsync(TimeSpan.FromSeconds(5));
+            Dispatcher.UIThread.RunJobs();
+            Assert.IsFalse(model.IsBusy);
+            Assert.IsFalse(model.HasLocalActivity);
+            Assert.IsTrue(model.CatalogEmpty);
+            Assert.IsTrue(model.InstalledEmpty);
+            Assert.IsTrue(model.RefreshCatalogCommand.CanExecute(null));
+            Assert.IsTrue(model.RefreshInstalledCommand.CanExecute(null));
+            Assert.IsFalse(window.FindControl<Control>("MarketplaceActivity")!.IsVisible);
+        }
+        finally { manager.ListGate.TrySetResult(); remote.ListGate.TrySetResult(); window.Close(); }
+    });
+
+    [TestMethod]
+    public Task ClosingDuringDiscoveryCancelsPendingCallsAndClearsAllBusyIndicators() => OnUiThread(async () =>
+    {
+        var manager = new SkillManager { ListGate = NewProgressCompletion() };
+        var remote = new Marketplace(manager) { ListGate = NewProgressCompletion() };
+        using var model = new SkillMarketplaceWindowViewModel(manager, remote, new Messages());
+        var load = model.LoadAsync();
+        try
+        {
+            await Task.WhenAll(manager.ListStarted.Task, remote.Started.Task).WaitAsync(TimeSpan.FromSeconds(5));
+            Assert.IsTrue(model.IsBusy);
+            model.Dispose();
+            await load.WaitAsync(TimeSpan.FromSeconds(5));
+            Assert.IsFalse(model.IsBusy);
+            Assert.IsFalse(model.CatalogBusy);
+            Assert.IsFalse(model.LocalBusy);
+            Assert.IsFalse(model.HasLocalActivity);
+            Assert.AreEqual(string.Empty, model.LocalActivityText);
+        }
+        finally { manager.ListGate.TrySetResult(); remote.ListGate.TrySetResult(); }
+    });
+
+    private static TaskCompletionSource NewProgressCompletion() => new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+    private static SkillMarketplaceWindow ProgressWindow(SkillMarketplaceWindowViewModel model)
+    {
+        var window = new SkillMarketplaceWindow { DataContext = model, Width = 760, Height = 560 };
+        window.Show();
+        Dispatcher.UIThread.RunJobs();
+        return window;
+    }
+
+    private static async Task SaveProgressAsync(Window window, string filename)
+    {
+        // Advance composition time beyond the ring's initial zero-length arc before capturing.
+        for (var frame = 0; frame < 6; frame++)
+        {
+            await Task.Delay(50);
+            Dispatcher.UIThread.RunJobs();
+            AvaloniaHeadlessPlatform.ForceRenderTimerTick();
+        }
+        Save(window, filename);
+    }
+
+    private static void AssertProgressVisible(SkillMarketplaceWindow window, SkillMarketplaceWindowViewModel model)
+    {
+        Dispatcher.UIThread.RunJobs();
+        Assert.IsTrue(model.IsBusy);
+        var activity = window.FindControl<Control>("MarketplaceActivity")!;
+        Assert.IsTrue(activity.IsEffectivelyVisible);
+        var progress = window.FindControl<ProgressRing>("MarketplaceProgress");
+        Assert.IsNotNull(progress);
+        Assert.IsTrue(progress.IsIndeterminate);
+        Assert.IsTrue(progress.IsActive);
+        Assert.IsNotNull(progress.Template, "The progress indicator must have its product theme template.");
+        Assert.IsTrue(progress.Bounds.Width > 0 && progress.Bounds.Height > 0,
+            "The progress indicator must occupy a visible layout area.");
+        var animatedVisual = progress.GetVisualDescendants().OfType<ProgressRingAnimatedVisual>().SingleOrDefault();
+        Assert.IsNotNull(animatedVisual, "The progress template must create its animated visual.");
+        Assert.IsTrue(animatedVisual.IsEffectivelyVisible);
+        Assert.IsTrue(animatedVisual.Bounds.Width > 0 && animatedVisual.Bounds.Height > 0,
+            "The animated visual must occupy a visible layout area.");
+        var position = activity.TranslatePoint(new Point(0, 0), window);
+        Assert.IsNotNull(position);
+        Assert.IsTrue(position.Value.Y >= 0 && position.Value.Y + activity.Bounds.Height < window.Bounds.Height,
+            "Common progress must remain inside the minimum-size window.");
+    }
+
+    private static void SelectProgressTarget(SkillMarketplaceWindowViewModel model, string operation)
+    {
+        model.SelectedInstalledSkill = model.InstalledSkills.Single();
+        model.SelectedCatalogSkill = model.CatalogSkills.Single(x => x.Id == (operation == "install" ? "available" : "FIXTURE"));
+    }
+
+    private static Task ExecuteProgressMutation(SkillMarketplaceWindowViewModel model, string operation) => operation switch
+    {
+        "install" => model.InstallSkillCommand.ExecuteAsync(null),
+        "update" => model.UpdateInstalledSkillCommand.ExecuteAsync(null),
+        _ => model.RemoveSkillCommand.ExecuteAsync(null)
+    };
+
+    private static ProgressOperation ProgressGateFor(ProgressSkillManager manager, ProgressMarketplace remote, string operation)
+        => operation switch { "install" => remote.Installation, "update" => remote.Update, _ => manager.Removal };
+
+    private sealed class ProgressOperation
+    {
+        public TaskCompletionSource Started { get; } = NewProgressCompletion();
+        public TaskCompletionSource Release { get; } = NewProgressCompletion();
+        public string Outcome = "success";
+        public async Task WaitAsync(CancellationToken token)
+        {
+            Started.TrySetResult();
+            await Release.Task.WaitAsync(token);
+            if (Outcome == "failure") throw new ManagedAiException(AiFailureCode.SkillInvalid);
+            if (Outcome == "cancel") throw new OperationCanceledException();
+        }
+    }
+
+    private sealed class ProgressSkillManager(SkillManager inner) : IManagedAiSkillManager
+    {
+        public ProgressOperation Removal { get; } = new();
+        public string StorageDirectory => inner.StorageDirectory;
+        public Task<IReadOnlyList<AiSkill>> ListAsync(CancellationToken token) => inner.ListAsync(token);
+        public Task<IReadOnlyList<AiSkill>> ImportAsync(string source, CancellationToken token) => inner.ImportAsync(source, token);
+        public Task<IReadOnlyList<AiSkill>> SetEnabledAsync(string id, bool enabled, CancellationToken token) => inner.SetEnabledAsync(id, enabled, token);
+        public async Task<IReadOnlyList<AiSkill>> RemoveAsync(string id, CancellationToken token)
+        { await Removal.WaitAsync(token); return await inner.RemoveAsync(id, token); }
+    }
+
+    private sealed class ProgressMarketplace(Marketplace inner) : IManagedAiSkillMarketplace
+    {
+        public ProgressOperation Installation { get; } = new();
+        public ProgressOperation Update { get; } = new();
+        public Task<IReadOnlyList<SkillCatalogEntry>> ListAsync(CancellationToken token) => inner.ListAsync(token);
+        public async Task<IReadOnlyList<AiSkill>> InstallAsync(string id, CancellationToken token)
+        { await Installation.WaitAsync(token); return await inner.InstallAsync(id, token); }
+        public async Task<IReadOnlyList<AiSkill>> UpdateAsync(string id, CancellationToken token)
+        { await Update.WaitAsync(token); return await inner.UpdateAsync(id, token); }
+    }
+
+    private sealed class ProgressRuntimes : IManagedAiScriptRuntimeManager
+    {
+        public ProgressOperation Check { get; } = new();
+        public async Task<AiScriptRuntimeStatus> GetStatusAsync(CancellationToken token)
+        { await Check.WaitAsync(token); return RuntimeStatus(true, true); }
+        public Task<AiScriptRuntimeStatus> EnsureInstalledAsync(CancellationToken token) => GetStatusAsync(token);
+    }
+}