diff --git a/src/EventLogExpert.Runtime/Announcement/AnnouncementService.cs b/src/EventLogExpert.Runtime/Announcement/AnnouncementService.cs
new file mode 100644
index 00000000..ee407a69
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Announcement/AnnouncementService.cs
@@ -0,0 +1,61 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+
+namespace EventLogExpert.Runtime.Announcement;
+
+public sealed class AnnouncementService : IAnnouncementService
+{
+    private readonly Lock _stateLock = new();
+    private readonly ITraceLogger _traceLogger;
+
+    private string _currentAnnouncement = string.Empty;
+    private int _seq;
+
+    public AnnouncementService(ITraceLogger traceLogger)
+    {
+        ArgumentNullException.ThrowIfNull(traceLogger);
+
+        _traceLogger = traceLogger;
+    }
+
+    public event Action? StateChanged;
+
+    public string CurrentAnnouncement
+    {
+        get { lock (_stateLock) { return _currentAnnouncement; } }
+    }
+
+    public void Announce(string message)
+    {
+        ArgumentNullException.ThrowIfNull(message);
+
+        lock (_stateLock)
+        {
+            _seq++;
+            // ZWS toggle on odd seq guarantees DOM text mutation between consecutive identical
+            // announcements; SR live regions do not re-announce when the text node does not change.
+            _currentAnnouncement = (_seq % 2 == 0) ? message : message + "\u200B";
+        }
+
+        RaiseStateChangedSafely();
+    }
+
+    private void RaiseStateChangedSafely()
+    {
+        var handler = StateChanged;
+
+        if (handler is null) { return; }
+
+        foreach (Delegate subscriber in handler.GetInvocationList())
+        {
+            try { ((Action)subscriber).Invoke(); }
+            catch (Exception ex)
+            {
+                _traceLogger.Warning(
+                    $"{nameof(AnnouncementService)}.{nameof(StateChanged)} subscriber threw: {ex}");
+            }
+        }
+    }
+}
diff --git a/src/EventLogExpert.Runtime/Announcement/IAnnouncementService.cs b/src/EventLogExpert.Runtime/Announcement/IAnnouncementService.cs
new file mode 100644
index 00000000..f46089f5
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Announcement/IAnnouncementService.cs
@@ -0,0 +1,18 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.Announcement;
+
+/// <summary>
+///     Singleton service backing the application-level polite live region. Survives modal teardown so completion
+///     announcements (e.g., "Settings saved", "Database imported") are still announced by screen readers after the
+///     originating modal closes.
+/// </summary>
+public interface IAnnouncementService
+{
+    event Action? StateChanged;
+
+    string CurrentAnnouncement { get; }
+
+    void Announce(string message);
+}
diff --git a/src/EventLogExpert.Runtime/Banner/BannerService.cs b/src/EventLogExpert.Runtime/Banner/BannerService.cs
index da5c2f3e..b93c6b5f 100644
--- a/src/EventLogExpert.Runtime/Banner/BannerService.cs
+++ b/src/EventLogExpert.Runtime/Banner/BannerService.cs
@@ -26,9 +26,9 @@ internal sealed class BannerService
     private ImmutableHashSet<string> _dismissedAttentionFileNames = ImmutableHashSet<string>.Empty;
     private ImmutableList<ErrorBannerEntry> _errorBanners = ImmutableList<ErrorBannerEntry>.Empty;
     private ImmutableList<BannerInfoEntry> _infoBanners = ImmutableList<BannerInfoEntry>.Empty;
+    private BannerProgressEntry? _manageDatabasesProgress;
     private Func<Task>? _recoveryCallback;
     private object? _recoveryToken;
-    private BannerProgressEntry? _settingsProgress;
 
     public BannerService(IDatabaseService databaseService, ITraceLogger traceLogger)
     {
@@ -128,9 +128,9 @@ public IReadOnlyList<BannerInfoEntry> InfoBanners
         get { lock (_stateLock) { return _infoBanners; } }
     }
 
-    public BannerProgressEntry? SettingsProgress
+    public BannerProgressEntry? ManageDatabasesProgress
     {
-        get { lock (_stateLock) { return _settingsProgress; } }
+        get { lock (_stateLock) { return _manageDatabasesProgress; } }
     }
 
     public void ClearCritical()
@@ -309,8 +309,8 @@ private void AssignProgressSlot(UpgradeProgressScope scope, BannerProgressEntry
             case UpgradeProgressScope.Background:
                 _backgroundProgress = entry;
                 break;
-            case UpgradeProgressScope.SettingsTriggered:
-                _settingsProgress = entry;
+            case UpgradeProgressScope.ManageDatabasesTriggered:
+                _manageDatabasesProgress = entry;
                 break;
             default:
                 throw new ArgumentOutOfRangeException(nameof(scope), scope, "Unknown upgrade progress scope.");
@@ -371,9 +371,9 @@ private void OnUpgradeBatchCompleted(object? sender, UpgradeBatchCompletedEventA
                 _backgroundProgress = null;
                 cleared = true;
             }
-            else if (_settingsProgress is not null && _settingsProgress.BatchId == args.BatchId)
+            else if (_manageDatabasesProgress is not null && _manageDatabasesProgress.BatchId == args.BatchId)
             {
-                _settingsProgress = null;
+                _manageDatabasesProgress = null;
                 cleared = true;
             }
         }
@@ -391,7 +391,7 @@ private void OnUpgradeBatchProgress(object? sender, UpgradeBatchProgressEventArg
         lock (_stateLock)
         {
             BannerProgressEntry? backgroundSlot = _backgroundProgress;
-            BannerProgressEntry? settingsSlot = _settingsProgress;
+            BannerProgressEntry? manageDatabasesSlot = _manageDatabasesProgress;
 
             if (backgroundSlot is not null && backgroundSlot.BatchId == args.BatchId)
             {
@@ -404,16 +404,16 @@ private void OnUpgradeBatchProgress(object? sender, UpgradeBatchProgressEventArg
                 };
                 _backgroundProgress = next;
             }
-            else if (settingsSlot is not null && settingsSlot.BatchId == args.BatchId)
+            else if (manageDatabasesSlot is not null && manageDatabasesSlot.BatchId == args.BatchId)
             {
-                next = settingsSlot with
+                next = manageDatabasesSlot with
                 {
                     CurrentBatchPosition = args.Position,
                     CurrentEntryName = args.FileName,
                     CurrentPhase = args.Phase,
                     QueuedBatchesAfter = _databaseService.QueuedBatchCount
                 };
-                _settingsProgress = next;
+                _manageDatabasesProgress = next;
             }
         }
 
diff --git a/src/EventLogExpert.Runtime/Banner/BannerViewSelector.cs b/src/EventLogExpert.Runtime/Banner/BannerViewSelector.cs
index d18bfa92..b9c4dce2 100644
--- a/src/EventLogExpert.Runtime/Banner/BannerViewSelector.cs
+++ b/src/EventLogExpert.Runtime/Banner/BannerViewSelector.cs
@@ -24,6 +24,7 @@ public static IReadOnlyList<BannerCycleItem> BuildCycle(
         IReadOnlyList<ErrorBannerEntry> errorBanners,
         IReadOnlyList<DatabaseEntry> attentionEntries,
         bool attentionDismissed,
+        bool attentionSuppressedByModalContext,
         BannerProgressEntry? backgroundProgress,
         IReadOnlyList<BannerInfoEntry> infoBanners)
     {
@@ -36,8 +37,12 @@ public static IReadOnlyList<BannerCycleItem> BuildCycle(
             return [new BannerCycleItem(BannerView.Critical, 0, null)];
         }
 
+        bool includeAttention = attentionEntries.Count > 0
+            && !attentionDismissed
+            && !attentionSuppressedByModalContext;
+
         var items = new List<BannerCycleItem>(
-            errorBanners.Count + (attentionEntries.Count > 0 && !attentionDismissed ? 1 : 0)
+            errorBanners.Count + (includeAttention ? 1 : 0)
             + (backgroundProgress is not null ? 1 : 0) + infoBanners.Count);
 
         for (int i = 0; i < errorBanners.Count; i++)
@@ -45,7 +50,7 @@ public static IReadOnlyList<BannerCycleItem> BuildCycle(
             items.Add(new BannerCycleItem(BannerView.Error, i, errorBanners[i].Id));
         }
 
-        if (attentionEntries.Count > 0 && !attentionDismissed)
+        if (includeAttention)
         {
             items.Add(new BannerCycleItem(BannerView.Attention, 0, null));
         }
diff --git a/src/EventLogExpert.Runtime/Banner/IProgressBannerService.cs b/src/EventLogExpert.Runtime/Banner/IProgressBannerService.cs
index 4a489403..47360b7d 100644
--- a/src/EventLogExpert.Runtime/Banner/IProgressBannerService.cs
+++ b/src/EventLogExpert.Runtime/Banner/IProgressBannerService.cs
@@ -9,5 +9,5 @@ public interface IProgressBannerService
 
     BannerProgressEntry? BackgroundProgress { get; }
 
-    BannerProgressEntry? SettingsProgress { get; }
+    BannerProgressEntry? ManageDatabasesProgress { get; }
 }
diff --git a/src/EventLogExpert.Runtime/Database/DatabaseClassificationService.cs b/src/EventLogExpert.Runtime/Database/DatabaseClassificationService.cs
index b0090fad..190844f6 100644
--- a/src/EventLogExpert.Runtime/Database/DatabaseClassificationService.cs
+++ b/src/EventLogExpert.Runtime/Database/DatabaseClassificationService.cs
@@ -45,30 +45,7 @@ public async Task ClassifyEntriesAsync(CancellationToken cancellationToken = def
 
                     foreach (var entry in snapshot)
                     {
-                        cancellationToken.ThrowIfCancellationRequested();
-
-                        try
-                        {
-                            if (!File.Exists(entry.FullPath) || new FileInfo(entry.FullPath).Length == 0)
-                            {
-                                perFile[entry.FileName] = (DatabaseStatus.UnrecognizedSchema, false);
-
-                                continue;
-                            }
-
-                            var state = _maintenance.CheckSchemaState(entry.FullPath);
-                            var status = MapSchemaVersionToStatus(state.CurrentVersion);
-                            var backupExists = ProbeOrCleanupBackup(entry, status);
-
-                            perFile[entry.FileName] = (status, backupExists);
-                        }
-                        catch (Exception ex) when (ex is not OperationCanceledException)
-                        {
-                            perFile[entry.FileName] = (DatabaseStatus.ClassificationFailed, false);
-
-                            DatabaseRegistry.SafeLog(() => _traceLogger.Warning(
-                                $"{nameof(DatabaseClassificationService)}.{nameof(ClassifyEntriesAsync)} failed to classify '{entry.FileName}': {ex}"));
-                        }
+                        perFile[entry.FileName] = ClassifyEntry(entry, cancellationToken);
                     }
 
                     return perFile;
@@ -79,6 +56,36 @@ public async Task ClassifyEntriesAsync(CancellationToken cancellationToken = def
         _entryStore.ApplyClassificationResults(statuses);
     }
 
+    public async Task RetryClassificationAsync(string fileName, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        var entry = _entryStore.SnapshotEntries()
+            .FirstOrDefault(e => string.Equals(e.FileName, fileName, StringComparison.OrdinalIgnoreCase));
+        if (entry is null) { return; }
+
+        try
+        {
+            _entryStore.MarkStatus(fileName, DatabaseStatus.NotClassified);
+        }
+        catch (InvalidOperationException)
+        {
+            // Entry was removed between SnapshotEntries() and MarkStatus(). Stale UI; nothing to retry.
+            return;
+        }
+
+        var result = await Task.Run(
+                () => ClassifyEntry(entry, cancellationToken),
+                cancellationToken)
+            .ConfigureAwait(false);
+
+        _entryStore.ApplyClassificationResults(
+            new Dictionary<string, (DatabaseStatus Status, bool BackupExists)>(StringComparer.OrdinalIgnoreCase)
+            {
+                [fileName] = result
+            });
+    }
+
     private static DatabaseStatus MapSchemaVersionToStatus(int currentVersion) =>
         currentVersion switch
         {
@@ -88,6 +95,34 @@ private static DatabaseStatus MapSchemaVersionToStatus(int currentVersion) =>
             _ => DatabaseStatus.UnrecognizedSchema,
         };
 
+    private (DatabaseStatus Status, bool BackupExists) ClassifyEntry(
+        DatabaseEntry entry,
+        CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        try
+        {
+            if (!File.Exists(entry.FullPath) || new FileInfo(entry.FullPath).Length == 0)
+            {
+                return (DatabaseStatus.UnrecognizedSchema, false);
+            }
+
+            var state = _maintenance.CheckSchemaState(entry.FullPath);
+            var status = MapSchemaVersionToStatus(state.CurrentVersion);
+            var backupExists = ProbeOrCleanupBackup(entry, status);
+
+            return (status, backupExists);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            DatabaseRegistry.SafeLog(() => _traceLogger.Warning(
+                $"{nameof(DatabaseClassificationService)}.{nameof(ClassifyEntry)} failed to classify '{entry.FileName}': {ex}"));
+
+            return (DatabaseStatus.ClassificationFailed, false);
+        }
+    }
+
     private bool ProbeOrCleanupBackup(DatabaseEntry entry, DatabaseStatus status)
     {
         var backupPath = entry.FullPath + DatabaseFileOperations.UpgradeBackupSuffix;
diff --git a/src/EventLogExpert.Runtime/Database/DatabaseOperationCoordinator.cs b/src/EventLogExpert.Runtime/Database/DatabaseOperationCoordinator.cs
index 6e484e63..07fa01e3 100644
--- a/src/EventLogExpert.Runtime/Database/DatabaseOperationCoordinator.cs
+++ b/src/EventLogExpert.Runtime/Database/DatabaseOperationCoordinator.cs
@@ -173,7 +173,7 @@ await _databases.RemoveAsync(
 
     public async Task UpgradeDatabaseAsync(
         string fileName,
-        UpgradeProgressScope scope = UpgradeProgressScope.SettingsTriggered,
+        UpgradeProgressScope scope = UpgradeProgressScope.ManageDatabasesTriggered,
         CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(fileName);
diff --git a/src/EventLogExpert.Runtime/Database/DatabaseService.cs b/src/EventLogExpert.Runtime/Database/DatabaseService.cs
index 67d7d27b..3a7eb89b 100644
--- a/src/EventLogExpert.Runtime/Database/DatabaseService.cs
+++ b/src/EventLogExpert.Runtime/Database/DatabaseService.cs
@@ -97,6 +97,9 @@ public Task RemoveAsync(
     public Task<bool> RestoreFromBackupAsync(string fileName, CancellationToken cancellationToken = default) =>
         _recoveryService.RestoreFromBackupAsync(fileName, cancellationToken);
 
+    public Task RetryClassificationAsync(string fileName, CancellationToken cancellationToken = default) =>
+        _classificationService.RetryClassificationAsync(fileName, cancellationToken);
+
     public void Toggle(string fileName) => _registry.Toggle(fileName);
 
     public Task<UpgradeBatchResult> UpgradeBatchAsync(
diff --git a/src/EventLogExpert.Runtime/Database/IDatabaseOperationCoordinator.cs b/src/EventLogExpert.Runtime/Database/IDatabaseOperationCoordinator.cs
index 8d9f3151..d1d4621a 100644
--- a/src/EventLogExpert.Runtime/Database/IDatabaseOperationCoordinator.cs
+++ b/src/EventLogExpert.Runtime/Database/IDatabaseOperationCoordinator.cs
@@ -28,6 +28,6 @@ Task<RemoveOutcome> RemoveDatabaseAsync(
 
     Task UpgradeDatabaseAsync(
         string fileName,
-        UpgradeProgressScope scope = UpgradeProgressScope.SettingsTriggered,
+        UpgradeProgressScope scope = UpgradeProgressScope.ManageDatabasesTriggered,
         CancellationToken cancellationToken = default);
 }
diff --git a/src/EventLogExpert.Runtime/Database/IDatabaseService.cs b/src/EventLogExpert.Runtime/Database/IDatabaseService.cs
index 90dd9146..cf69e120 100644
--- a/src/EventLogExpert.Runtime/Database/IDatabaseService.cs
+++ b/src/EventLogExpert.Runtime/Database/IDatabaseService.cs
@@ -47,6 +47,8 @@ Task RemoveAsync(
 
     Task<bool> RestoreFromBackupAsync(string fileName, CancellationToken cancellationToken = default);
 
+    Task RetryClassificationAsync(string fileName, CancellationToken cancellationToken = default);
+
     void Toggle(string fileName);
 
     Task<UpgradeBatchResult> UpgradeBatchAsync(
diff --git a/src/EventLogExpert.Runtime/Database/Upgrade/UpgradeProgressScope.cs b/src/EventLogExpert.Runtime/Database/Upgrade/UpgradeProgressScope.cs
index 2956a3c7..12cbaf9e 100644
--- a/src/EventLogExpert.Runtime/Database/Upgrade/UpgradeProgressScope.cs
+++ b/src/EventLogExpert.Runtime/Database/Upgrade/UpgradeProgressScope.cs
@@ -6,5 +6,5 @@ namespace EventLogExpert.Runtime.Database.Upgrade;
 public enum UpgradeProgressScope
 {
     Background,
-    SettingsTriggered
+    ManageDatabasesTriggered
 }
diff --git a/src/EventLogExpert.Runtime/DependencyInjection/RuntimeServiceCollectionExtensions.cs b/src/EventLogExpert.Runtime/DependencyInjection/RuntimeServiceCollectionExtensions.cs
index c19272c9..0b9cd38b 100644
--- a/src/EventLogExpert.Runtime/DependencyInjection/RuntimeServiceCollectionExtensions.cs
+++ b/src/EventLogExpert.Runtime/DependencyInjection/RuntimeServiceCollectionExtensions.cs
@@ -4,6 +4,7 @@
 using EventLogExpert.Logging.Abstractions;
 using EventLogExpert.Provider.Maintenance;
 using EventLogExpert.Provider.Resolution;
+using EventLogExpert.Runtime.Announcement;
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Common.AppTitle;
 using EventLogExpert.Runtime.Common.Files;
@@ -83,6 +84,8 @@ public static IServiceCollection AddEventLogRuntime(this IServiceCollection serv
         services.AddSingleton<IErrorBannerService>(static sp => sp.GetRequiredService<BannerService>());
         services.AddSingleton<IInfoBannerService>(static sp => sp.GetRequiredService<BannerService>());
 
+        services.AddSingleton<IAnnouncementService, AnnouncementService>();
+
         services.AddSingleton<DebugLogService>();
         services.AddSingleton<ITraceLogger>(static sp => sp.GetRequiredService<DebugLogService>());
         services.AddSingleton<IFileLogger>(static sp => sp.GetRequiredService<DebugLogService>());
diff --git a/src/EventLogExpert.Runtime/Menu/IMenuActionService.cs b/src/EventLogExpert.Runtime/Menu/IMenuActionService.cs
index 9f9a2ae6..831b00ac 100644
--- a/src/EventLogExpert.Runtime/Menu/IMenuActionService.cs
+++ b/src/EventLogExpert.Runtime/Menu/IMenuActionService.cs
@@ -23,7 +23,7 @@ public interface IMenuActionService
 
     void LoadNewEvents();
 
-    Task OpenDatabaseToolsAsync();
+    Task<bool> OpenDatabaseToolsAsync();
 
     Task OpenDocsAsync();
 
diff --git a/src/EventLogExpert.UI/Announcement/AnnouncerHost.razor b/src/EventLogExpert.UI/Announcement/AnnouncerHost.razor
new file mode 100644
index 00000000..648a0190
--- /dev/null
+++ b/src/EventLogExpert.UI/Announcement/AnnouncerHost.razor
@@ -0,0 +1,3 @@
+<div aria-atomic="true" aria-live="polite" class="visually-hidden" id="app-announcer" role="status">
+    @AnnouncementService.CurrentAnnouncement
+</div>
diff --git a/src/EventLogExpert.UI/Announcement/AnnouncerHost.razor.cs b/src/EventLogExpert.UI/Announcement/AnnouncerHost.razor.cs
new file mode 100644
index 00000000..4cc4ce58
--- /dev/null
+++ b/src/EventLogExpert.UI/Announcement/AnnouncerHost.razor.cs
@@ -0,0 +1,23 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Announcement;
+using Microsoft.AspNetCore.Components;
+
+namespace EventLogExpert.UI.Announcement;
+
+public sealed partial class AnnouncerHost : ComponentBase, IDisposable
+{
+    [Inject] private IAnnouncementService AnnouncementService { get; init; } = null!;
+
+    public void Dispose() => AnnouncementService.StateChanged -= OnStateChanged;
+
+    protected override void OnInitialized()
+    {
+        AnnouncementService.StateChanged += OnStateChanged;
+
+        base.OnInitialized();
+    }
+
+    private void OnStateChanged() => _ = InvokeAsync(StateHasChanged);
+}
diff --git a/src/EventLogExpert.UI/Announcement/AnnouncerHost.razor.css b/src/EventLogExpert.UI/Announcement/AnnouncerHost.razor.css
new file mode 100644
index 00000000..374331c5
--- /dev/null
+++ b/src/EventLogExpert.UI/Announcement/AnnouncerHost.razor.css
@@ -0,0 +1,11 @@
+.visually-hidden {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border: 0;
+}
diff --git a/src/EventLogExpert.UI/Banner/AttentionBanner.razor b/src/EventLogExpert.UI/Banner/AttentionBanner.razor
index 7a9664c2..dc947f95 100644
--- a/src/EventLogExpert.UI/Banner/AttentionBanner.razor
+++ b/src/EventLogExpert.UI/Banner/AttentionBanner.razor
@@ -1,12 +1,12 @@
 <aside class="banner banner-attention" role="alert">
-    <span class="banner-message">@AttentionCount @DatabasesLabel @NeedsLabel attention. Open Settings to enable or remove them.</span>
+    <span class="banner-message">@AttentionCount @DatabasesLabel @NeedsLabel attention. Open Databases to enable or remove them.</span>
 
     @CycleNav
 
     <button class="banner-action button"
-        @onclick="OnOpenSettingsClickedAsync"
+        @onclick="OnOpenDatabasesClickedAsync"
         type="button">
-        Open Settings
+        Open Databases
     </button>
 
     <button aria-label="Dismiss attention banner"
diff --git a/src/EventLogExpert.UI/Banner/AttentionBanner.razor.cs b/src/EventLogExpert.UI/Banner/AttentionBanner.razor.cs
index 3db18b74..794cca16 100644
--- a/src/EventLogExpert.UI/Banner/AttentionBanner.razor.cs
+++ b/src/EventLogExpert.UI/Banner/AttentionBanner.razor.cs
@@ -31,7 +31,7 @@ public sealed partial class AttentionBanner : ComponentBase
 
     private void OnDismissAttention() => AttentionBannerService.DismissAttention();
 
-    private async Task OnOpenSettingsClickedAsync()
+    private async Task OnOpenDatabasesClickedAsync()
     {
         AttentionBannerService.DismissAttention();
 
@@ -39,7 +39,7 @@ private async Task OnOpenSettingsClickedAsync()
 
         try
         {
-            success = await MenuActionService.OpenSettingsAsync();
+            success = await MenuActionService.OpenDatabaseToolsAsync();
         }
         catch (JSDisconnectedException)
         {
@@ -52,11 +52,11 @@ private async Task OnOpenSettingsClickedAsync()
         catch (Exception ex)
         {
             TraceLogger.Error(
-                $"{nameof(AttentionBanner)}.{nameof(OnOpenSettingsClickedAsync)}: open settings threw: {ex}");
+                $"{nameof(AttentionBanner)}.{nameof(OnOpenDatabasesClickedAsync)}: open databases threw: {ex}");
 
             BannerId errorId = ErrorBannerService.ReportError(
-                "Settings",
-                $"Failed to open settings: {ex.Message}");
+                "Databases",
+                $"Failed to open databases: {ex.Message}");
             await OnFallbackErrorPosted.InvokeAsync(new BannerCycleItem(BannerView.Error, 0, errorId));
 
             return;
@@ -65,11 +65,11 @@ private async Task OnOpenSettingsClickedAsync()
         if (!success)
         {
             TraceLogger.Error(
-                $"{nameof(AttentionBanner)}.{nameof(OnOpenSettingsClickedAsync)}: open settings returned false");
+                $"{nameof(AttentionBanner)}.{nameof(OnOpenDatabasesClickedAsync)}: open databases returned false");
 
             BannerId errorId = ErrorBannerService.ReportError(
-                "Settings",
-                "Failed to open settings; try again from the menu.");
+                "Databases",
+                "Failed to open databases; try again from the menu.");
             await OnFallbackErrorPosted.InvokeAsync(new BannerCycleItem(BannerView.Error, 0, errorId));
         }
     }
diff --git a/src/EventLogExpert.UI/Banner/BannerCycleStateService.cs b/src/EventLogExpert.UI/Banner/BannerCycleStateService.cs
new file mode 100644
index 00000000..c9279ed1
--- /dev/null
+++ b/src/EventLogExpert.UI/Banner/BannerCycleStateService.cs
@@ -0,0 +1,230 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Banner;
+using EventLogExpert.Runtime.Modal;
+using EventLogExpert.UI.DatabaseTools;
+
+namespace EventLogExpert.UI.Banner;
+
+public sealed class BannerCycleStateService : IBannerCycleStateService, IDisposable
+{
+    private readonly IAttentionBannerService _attention;
+    private readonly ICriticalErrorService _critical;
+    private readonly IErrorBannerService _errors;
+    private readonly IInfoBannerService _infos;
+    private readonly IModalCoordinator _modalCoordinator;
+    private readonly IProgressBannerService _progress;
+    private readonly Lock _stateLock = new();
+
+    private BannerView _currentView;
+    private int _displayedIndex;
+    private IReadOnlyList<BannerCycleItem> _items = [];
+    private bool _modalContentDisplayed;
+    private BannerCycleItem? _pendingOverrideItem;
+    private BannerCycleItem? _selectedItem;
+
+    public BannerCycleStateService(
+        IAttentionBannerService attention,
+        IErrorBannerService errors,
+        IInfoBannerService infos,
+        IProgressBannerService progress,
+        ICriticalErrorService critical,
+        IModalCoordinator modalCoordinator)
+    {
+        _attention = attention;
+        _errors = errors;
+        _infos = infos;
+        _progress = progress;
+        _critical = critical;
+        _modalCoordinator = modalCoordinator;
+
+        _attention.StateChanged += OnFacetChanged;
+        _errors.StateChanged += OnFacetChanged;
+        _infos.StateChanged += OnFacetChanged;
+        _progress.StateChanged += OnFacetChanged;
+        _critical.StateChanged += OnFacetChanged;
+        _modalCoordinator.StateChanged += OnFacetChanged;
+
+        RebuildAndReselect();
+    }
+
+    public event Action? StateChanged;
+
+    public BannerView CurrentView
+    {
+        get { using (_stateLock.EnterScope()) { return _currentView; } }
+    }
+
+    public int DisplayedIndex
+    {
+        get { using (_stateLock.EnterScope()) { return _displayedIndex; } }
+    }
+
+    public IReadOnlyList<BannerCycleItem> Items
+    {
+        get { using (_stateLock.EnterScope()) { return _items; } }
+    }
+
+    public bool ModalContentDisplayed
+    {
+        get { using (_stateLock.EnterScope()) { return _modalContentDisplayed; } }
+    }
+
+    public BannerCycleItem? SelectedItem
+    {
+        get { using (_stateLock.EnterScope()) { return _selectedItem; } }
+    }
+
+    public void Dispose()
+    {
+        _attention.StateChanged -= OnFacetChanged;
+        _errors.StateChanged -= OnFacetChanged;
+        _infos.StateChanged -= OnFacetChanged;
+        _progress.StateChanged -= OnFacetChanged;
+        _critical.StateChanged -= OnFacetChanged;
+        _modalCoordinator.StateChanged -= OnFacetChanged;
+    }
+
+    public void MoveNext()
+    {
+        using (_stateLock.EnterScope())
+        {
+            var items = _items;
+            if (_displayedIndex >= items.Count - 1) { return; }
+
+            _displayedIndex++;
+            _selectedItem = items[_displayedIndex];
+            _currentView = _selectedItem.View;
+        }
+
+        StateChanged?.Invoke();
+    }
+
+    public void MovePrev()
+    {
+        using (_stateLock.EnterScope())
+        {
+            var items = _items;
+            if (_displayedIndex <= 0 || items.Count == 0) { return; }
+
+            _displayedIndex--;
+            _selectedItem = items[_displayedIndex];
+            _currentView = _selectedItem.View;
+        }
+
+        StateChanged?.Invoke();
+    }
+
+    public void RegisterFallbackError(BannerCycleItem newCycleItem)
+    {
+        using (_stateLock.EnterScope())
+        {
+            _pendingOverrideItem = newCycleItem;
+            RebuildAndReselectLocked();
+        }
+
+        StateChanged?.Invoke();
+    }
+
+    public void SetModalContentDisplayed(bool displayed)
+    {
+        using (_stateLock.EnterScope())
+        {
+            if (_modalContentDisplayed == displayed) { return; }
+
+            _modalContentDisplayed = displayed;
+        }
+
+        StateChanged?.Invoke();
+    }
+
+    private static bool ItemMatches(BannerCycleItem selected, BannerCycleItem candidate)
+    {
+        if (selected.View != candidate.View) { return false; }
+
+        return selected.EntryId == candidate.EntryId;
+    }
+
+    private void OnFacetChanged()
+    {
+        using (_stateLock.EnterScope())
+        {
+            RebuildAndReselectLocked();
+        }
+
+        StateChanged?.Invoke();
+    }
+
+    private void RebuildAndReselect()
+    {
+        using (_stateLock.EnterScope())
+        {
+            RebuildAndReselectLocked();
+        }
+    }
+
+    private void RebuildAndReselectLocked()
+    {
+        if (_modalCoordinator.ActiveSession is null)
+        {
+            _modalContentDisplayed = false;
+        }
+
+        bool attentionSuppressed =
+            _modalCoordinator.ActiveSession?.ComponentType == typeof(DatabaseToolsModal);
+
+        IReadOnlyList<BannerCycleItem> items = BannerViewSelector.BuildCycle(
+            _critical.CurrentCritical,
+            _errors.ErrorBanners,
+            _attention.AttentionEntries,
+            _attention.AttentionDismissed,
+            attentionSuppressed,
+            _progress.BackgroundProgress,
+            _infos.InfoBanners);
+
+        _items = items;
+
+        if (items.Count == 0)
+        {
+            _selectedItem = null;
+            _displayedIndex = 0;
+            _currentView = BannerView.None;
+            _pendingOverrideItem = null;
+            return;
+        }
+
+        if (_pendingOverrideItem is not null)
+        {
+            for (int i = 0; i < items.Count; i++)
+            {
+                if (!ItemMatches(_pendingOverrideItem, items[i])) { continue; }
+
+                _displayedIndex = i;
+                _selectedItem = items[i];
+                _currentView = _selectedItem.View;
+                _pendingOverrideItem = null;
+                return;
+            }
+
+            _pendingOverrideItem = null;
+        }
+
+        if (_selectedItem is not null)
+        {
+            for (int i = 0; i < items.Count; i++)
+            {
+                if (!ItemMatches(_selectedItem, items[i])) { continue; }
+
+                _displayedIndex = i;
+                _selectedItem = items[i];
+                _currentView = _selectedItem.View;
+                return;
+            }
+        }
+
+        _displayedIndex = Math.Clamp(_displayedIndex, 0, items.Count - 1);
+        _selectedItem = items[_displayedIndex];
+        _currentView = _selectedItem.View;
+    }
+}
diff --git a/src/EventLogExpert.UI/Banner/BannerHost.razor b/src/EventLogExpert.UI/Banner/BannerHost.razor
index 1e80b5de..e90d9f16 100644
--- a/src/EventLogExpert.UI/Banner/BannerHost.razor
+++ b/src/EventLogExpert.UI/Banner/BannerHost.razor
@@ -1,70 +1,66 @@
-@{
+@if (RendersContent)
+{
+    BannerCycleItem? selected = CycleState.SelectedItem;
+    IReadOnlyList<BannerCycleItem> items = CycleState.Items;
+    BannerView view = CycleState.CurrentView;
+    int displayedIndex = CycleState.DisplayedIndex;
+
     Exception? currentCritical = CriticalErrorService.CurrentCritical;
     IReadOnlyList<ErrorBannerEntry> errors = ErrorBannerService.ErrorBanners;
     IReadOnlyList<BannerInfoEntry> infos = InfoBannerService.InfoBanners;
     IReadOnlyList<DatabaseEntry> attentionEntries = AttentionBannerService.AttentionEntries;
-    bool attentionDismissed = AttentionBannerService.AttentionDismissed;
     BannerProgressEntry? backgroundProgress = ProgressBannerService.BackgroundProgress;
 
-    (BannerCycleItem? selected, BannerView view) = RebuildItemsAndPickSelected(
-        currentCritical,
-        errors,
-        attentionEntries,
-        attentionDismissed,
-        backgroundProgress,
-        infos);
-
-    _currentView = view;
-    bool showCyclePagination = _items.Count > 1 && view != BannerView.Critical;
+    bool showCyclePagination = items.Count > 1 && view != BannerView.Critical;
 
     RenderFragment cycleNav = @<text>
                                    @if (showCyclePagination)
                                    {
-                                       <span class="banner-pagination">@(_displayedIndex + 1) of @_items.Count</span>
+                                       <span class="banner-pagination">@(displayedIndex + 1) of @items.Count</span>
                                        <button aria-label="Previous banner"
                                            class="banner-cycle-prev button"
-                                           disabled="@(_displayedIndex == 0)"
-                                           @onclick="OnCyclePrev"
+                                           disabled="@(displayedIndex == 0)"
+                                           @onclick="CycleState.MovePrev"
                                            type="button">
                                            <i aria-hidden="true" class="bi bi-chevron-left"></i>
                                        </button>
                                        <button aria-label="Next banner"
                                            class="banner-cycle-next button"
-                                           disabled="@(_displayedIndex == _items.Count - 1)"
-                                           @onclick="OnCycleNext"
+                                           disabled="@(displayedIndex == items.Count - 1)"
+                                           @onclick="CycleState.MoveNext"
                                            type="button">
                                            <i aria-hidden="true" class="bi bi-chevron-right"></i>
                                        </button>
                                    }
                                </text>;
-}
 
-@switch (view)
-{
-    case BannerView.Critical when currentCritical != null:
-        <CriticalBanner Critical="currentCritical" />
+    @switch (view)
+    {
+        case BannerView.Critical when currentCritical != null:
+            <CriticalBanner Critical="currentCritical" />
 
-        break;
+            break;
 
-    case BannerView.Error when selected != null && selected.IndexWithinSlice < errors.Count:
-        <ErrorBanner CycleNav="cycleNav" Entry="errors[selected.IndexWithinSlice]" />
+        case BannerView.Error when selected != null && selected.IndexWithinSlice < errors.Count:
+            <ErrorBanner CycleNav="cycleNav" Entry="errors[selected.IndexWithinSlice]" />
 
-        break;
+            break;
 
-    case BannerView.Attention when attentionEntries.Count > 0:
-        <AttentionBanner AttentionCount="attentionEntries.Count"
-            CycleNav="cycleNav"
-            OnFallbackErrorPosted="HandleFallbackErrorPosted" />
+        case BannerView.Attention when attentionEntries.Count > 0:
+            <AttentionBanner AttentionCount="attentionEntries.Count"
+                CycleNav="cycleNav"
+                OnFallbackErrorPosted="HandleFallbackErrorPosted" />
 
-        break;
+            break;
 
-    case BannerView.UpgradeProgress when backgroundProgress is { } progress:
-        <UpgradeProgressBanner CycleNav="cycleNav" Progress="progress" />
+        case BannerView.UpgradeProgress when backgroundProgress is { } progress:
+            <UpgradeProgressBanner CycleNav="cycleNav" Progress="progress" />
 
-        break;
+            break;
 
-    case BannerView.Info when selected != null && selected.IndexWithinSlice < infos.Count:
-        <InfoBanner CycleNav="cycleNav" Entry="infos[selected.IndexWithinSlice]" />
+        case BannerView.Info when selected != null && selected.IndexWithinSlice < infos.Count:
+            <InfoBanner CycleNav="cycleNav" Entry="infos[selected.IndexWithinSlice]" />
 
-        break;
+            break;
+    }
 }
diff --git a/src/EventLogExpert.UI/Banner/BannerHost.razor.cs b/src/EventLogExpert.UI/Banner/BannerHost.razor.cs
index 4641207c..5665898f 100644
--- a/src/EventLogExpert.UI/Banner/BannerHost.razor.cs
+++ b/src/EventLogExpert.UI/Banner/BannerHost.razor.cs
@@ -2,127 +2,44 @@
 // // Licensed under the MIT License.
 
 using EventLogExpert.Runtime.Banner;
-using EventLogExpert.Runtime.Database;
 using Microsoft.AspNetCore.Components;
 
 namespace EventLogExpert.UI.Banner;
 
 public sealed partial class BannerHost : ComponentBase, IDisposable
 {
-    private BannerView _currentView;
-    private int _displayedIndex;
-    private IReadOnlyList<BannerCycleItem> _items = [];
-    private BannerCycleItem? _selectedItem;
+    [Parameter] public BannerHostLocation Location { get; set; } = BannerHostLocation.MainLayout;
 
     [Inject] private IAttentionBannerService AttentionBannerService { get; init; } = null!;
 
     [Inject] private ICriticalErrorService CriticalErrorService { get; init; } = null!;
 
+    [Inject] private IBannerCycleStateService CycleState { get; init; } = null!;
+
     [Inject] private IErrorBannerService ErrorBannerService { get; init; } = null!;
 
     [Inject] private IInfoBannerService InfoBannerService { get; init; } = null!;
 
     [Inject] private IProgressBannerService ProgressBannerService { get; init; } = null!;
 
-    public void Dispose() => UnsubscribeAll();
-
-    protected override void OnInitialized()
+    private bool RendersContent => Location switch
     {
-        SubscribeAll();
+        BannerHostLocation.MainLayout => !CycleState.ModalContentDisplayed,
+        BannerHostLocation.InsideModal => CycleState.ModalContentDisplayed,
+        _ => false
+    };
 
-        base.OnInitialized();
-    }
+    public void Dispose() => CycleState.StateChanged -= OnCycleStateChanged;
 
-    private static bool ItemMatches(BannerCycleItem selected, BannerCycleItem candidate)
+    protected override void OnInitialized()
     {
-        if (selected.View != candidate.View)
-        {
-            return false;
-        }
+        CycleState.StateChanged += OnCycleStateChanged;
 
-        return selected.EntryId == candidate.EntryId;
+        base.OnInitialized();
     }
 
     private void HandleFallbackErrorPosted(BannerCycleItem newCycleItem) =>
-        _selectedItem = newCycleItem;
-
-    private void OnCycleNext()
-    {
-        if (_displayedIndex >= _items.Count - 1) { return; }
-
-        _displayedIndex++;
-        _selectedItem = _items[_displayedIndex];
-    }
-
-    private void OnCyclePrev()
-    {
-        if (_displayedIndex <= 0) { return; }
-
-        _displayedIndex--;
-        _selectedItem = _items[_displayedIndex];
-    }
-
-    private void OnStateChanged() => _ = InvokeAsync(StateHasChanged);
+        CycleState.RegisterFallbackError(newCycleItem);
 
-    private (BannerCycleItem? Selected, BannerView View) RebuildItemsAndPickSelected(
-        Exception? currentCritical,
-        IReadOnlyList<ErrorBannerEntry> errors,
-        IReadOnlyList<DatabaseEntry> attentionEntries,
-        bool attentionDismissed,
-        BannerProgressEntry? backgroundProgress,
-        IReadOnlyList<BannerInfoEntry> infos)
-    {
-        IReadOnlyList<BannerCycleItem> items = BannerViewSelector.BuildCycle(
-            currentCritical,
-            errors,
-            attentionEntries,
-            attentionDismissed,
-            backgroundProgress,
-            infos);
-
-        _items = items;
-
-        if (items.Count == 0)
-        {
-            _selectedItem = null;
-            _displayedIndex = 0;
-            return (null, BannerView.None);
-        }
-
-        if (_selectedItem is not null)
-        {
-            for (int i = 0; i < items.Count; i++)
-            {
-                if (!ItemMatches(_selectedItem, items[i])) { continue; }
-
-                _displayedIndex = i;
-                _selectedItem = items[i];
-
-                return (_selectedItem, _selectedItem.View);
-            }
-        }
-
-        _displayedIndex = Math.Clamp(_displayedIndex, 0, items.Count - 1);
-        _selectedItem = items[_displayedIndex];
-
-        return (_selectedItem, _selectedItem.View);
-    }
-
-    private void SubscribeAll()
-    {
-        AttentionBannerService.StateChanged += OnStateChanged;
-        ProgressBannerService.StateChanged += OnStateChanged;
-        CriticalErrorService.StateChanged += OnStateChanged;
-        ErrorBannerService.StateChanged += OnStateChanged;
-        InfoBannerService.StateChanged += OnStateChanged;
-    }
-
-    private void UnsubscribeAll()
-    {
-        AttentionBannerService.StateChanged -= OnStateChanged;
-        ProgressBannerService.StateChanged -= OnStateChanged;
-        CriticalErrorService.StateChanged -= OnStateChanged;
-        ErrorBannerService.StateChanged -= OnStateChanged;
-        InfoBannerService.StateChanged -= OnStateChanged;
-    }
+    private void OnCycleStateChanged() => _ = InvokeAsync(StateHasChanged);
 }
diff --git a/src/EventLogExpert.UI/Banner/BannerHostLocation.cs b/src/EventLogExpert.UI/Banner/BannerHostLocation.cs
new file mode 100644
index 00000000..52798b90
--- /dev/null
+++ b/src/EventLogExpert.UI/Banner/BannerHostLocation.cs
@@ -0,0 +1,10 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.UI.Banner;
+
+public enum BannerHostLocation
+{
+    MainLayout,
+    InsideModal
+}
diff --git a/src/EventLogExpert.UI/Banner/IBannerCycleStateService.cs b/src/EventLogExpert.UI/Banner/IBannerCycleStateService.cs
new file mode 100644
index 00000000..1f5ff4ba
--- /dev/null
+++ b/src/EventLogExpert.UI/Banner/IBannerCycleStateService.cs
@@ -0,0 +1,29 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Banner;
+
+namespace EventLogExpert.UI.Banner;
+
+public interface IBannerCycleStateService
+{
+    event Action? StateChanged;
+
+    BannerView CurrentView { get; }
+
+    int DisplayedIndex { get; }
+
+    IReadOnlyList<BannerCycleItem> Items { get; }
+
+    bool ModalContentDisplayed { get; }
+
+    BannerCycleItem? SelectedItem { get; }
+
+    void MoveNext();
+
+    void MovePrev();
+
+    void RegisterFallbackError(BannerCycleItem newCycleItem);
+
+    void SetModalContentDisplayed(bool displayed);
+}
diff --git a/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor b/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor
index e6177a31..82f096d8 100644
--- a/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor
+++ b/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor
@@ -1,60 +1,127 @@
-<div class="db-entry-row @(_isMouseRevealed ? "db-entry-row--revealed" : null)"
-    @onmouseleave="HandleRowMouseLeave">
-    <button aria-label="@($"Remove database {Entry.FileName}")"
-        class="button button-red db-entry-remove-btn"
-        @onclick="@(() => OnRemove.InvokeAsync())"
-        type="button">
-        <i aria-hidden="true" class="bi bi-trash"></i>
-    </button>
+<div class="db-entry-row @(IsSelected ? "db-entry-row--selected" : null)">
+    <Checkbox AriaLabel="@($"Select {Entry.FileName}")"
+        Value="IsSelected"
+        ValueChanged="@(_ => OnSelectionToggle.InvokeAsync())" />
 
     <div class="db-entry-row-content">
         <div class="db-entry-info">
-            <button class="db-entry-name" @onclick="HandleNameClick" type="button">@Entry.FileName</button>
+            <button class="db-entry-name" id="@_nameButtonId" @ref="_nameButtonRef" type="button">@Entry.FileName</button>
             @if (ShouldShowBadge)
             {
                 <span class="db-entry-badge" data-badge="@BadgeKind">@BadgeLabel</span>
             }
         </div>
 
-        <div class="db-entry-actions">
+        <div class="db-entry-actions @(ShowPendingIndicator ? "db-entry-actions--pending" : null)">
+            @if (ShowPendingIndicator)
+            {
+                <span class="visually-hidden" id="@_pendingStatusId">(pending toggle, unsaved)</span>
+            }
+
             @switch (PrimaryAction)
             {
                 case ActionKind.Toggle:
                 case ActionKind.DisabledToggle:
-                    <BooleanSelect AriaLabel="@Entry.FileName"
+                    <OptionSelect AriaDescribedBy="@(ShowPendingIndicator ? _pendingStatusId : null)"
+                        AriaLabelledBy="@_nameButtonId"
                         Disabled="@(PrimaryAction == ActionKind.DisabledToggle)"
+                        UseStatusColors="true"
                         Value="EffectiveEnabled"
                         ValueChanged="@(_ => OnToggle.InvokeAsync())" />
 
                     break;
 
                 case ActionKind.Spinner:
-                    <span class="db-entry-upgrading" role="status">
-                        <i aria-hidden="true" class="bi bi-arrow-repeat db-entry-spinner"></i>
-                        <span>Upgrading&hellip;</span>
-                    </span>
+                    @if (UpgradeProgress is { } progress)
+                    {
+                        var verb = PhaseVerb(progress.CurrentPhase);
+                        var hasFile = !string.IsNullOrEmpty(progress.CurrentEntryName);
+                        var hasPosition = progress.CurrentBatchSize > 1;
+
+                        var displayText = hasFile
+                            ? (hasPosition ? $"{verb} {progress.CurrentBatchPosition} of {progress.CurrentBatchSize}" : verb)
+                            : $"Preparing upgrade of {progress.CurrentBatchSize} {(progress.CurrentBatchSize == 1 ? "database" : "databases")}\u2026";
+
+                        <span class="db-entry-upgrading">
+                            <span class="db-entry-upgrading-status" role="status">
+                                <i aria-hidden="true" class="bi bi-arrow-repeat db-entry-spinner"></i>
+                                <span class="db-entry-upgrading-text" @key="verb">@displayText</span>
+                                @if (hasFile)
+                                {
+                                    <span class="visually-hidden"> for @Entry.FileName</span>
+                                }
+                            </span>
+                            <button class="button db-entry-cancel-btn" @onclick="OnCancelClick" type="button">
+                                Cancel
+                            </button>
+                        </span>
+                    }
+                    else
+                    {
+                        <span class="db-entry-upgrading" role="status">
+                            <i aria-hidden="true" class="bi bi-arrow-repeat db-entry-spinner"></i>
+                            <span>Upgrading&hellip;</span>
+                        </span>
+                    }
+
                     break;
 
                 case ActionKind.Upgrade:
-                    <button aria-label="@($"Upgrade database {Entry.FileName}")"
+                    <button aria-disabled="@(IsUpgradeBlocked ? "true" : "false")"
+                        aria-label="@($"Upgrade database {Entry.FileName}")"
                         class="button db-entry-upgrade-btn"
-                        disabled="@IsUpgradeBlocked"
-                        @onclick="@(() => OnUpgrade.InvokeAsync())"
+                        @onclick="@(async () =>
+                                  {
+                                      if (!IsUpgradeBlocked) { await OnUpgrade.InvokeAsync(); }
+                                  })"
                         type="button">
                         <i aria-hidden="true" class="bi bi-arrow-up-circle"></i> Upgrade
                     </button>
                     break;
 
                 case ActionKind.Retry:
-                    <button aria-label="@($"Retry upgrade of database {Entry.FileName}")"
+                    <button aria-disabled="@(IsUpgradeBlocked ? "true" : "false")"
+                        aria-label="@($"Retry upgrade of database {Entry.FileName}")"
                         class="button button-red db-entry-upgrade-btn"
-                        disabled="@IsUpgradeBlocked"
-                        @onclick="@(() => OnUpgrade.InvokeAsync())"
+                        @onclick="@(async () =>
+                                  {
+                                      if (!IsUpgradeBlocked) { await OnUpgrade.InvokeAsync(); }
+                                  })"
                         type="button">
                         <i aria-hidden="true" class="bi bi-arrow-clockwise"></i> Retry Upgrade
                     </button>
                     break;
+
+                case ActionKind.RestoreFromBackup:
+                    <button aria-disabled="@(IsRestoreBlocked ? "true" : "false")"
+                        aria-label="@($"Restore database {Entry.FileName} from backup")"
+                        class="button db-entry-restore-btn"
+                        @onclick="@(async () =>
+                                  {
+                                      if (!IsRestoreBlocked) { await OnRestoreFromBackup.InvokeAsync(); }
+                                  })"
+                        type="button">
+                        <i aria-hidden="true" class="bi bi-arrow-counterclockwise"></i> Restore
+                    </button>
+                    break;
+
+                case ActionKind.RetryClassification:
+                    <button aria-label="@($"Retry classification of database {Entry.FileName}")"
+                        class="button db-entry-retry-classification-btn"
+                        @onclick="@(async () => await OnRetryClassification.InvokeAsync())"
+                        type="button">
+                        <i aria-hidden="true" class="bi bi-arrow-repeat"></i> Retry classification
+                    </button>
+                    break;
             }
+
+            <button aria-label="@($"Remove database {Entry.FileName}")"
+                class="button button-red db-entry-remove-btn"
+                @onclick="OnRemoveClick"
+                @ref="_removeButtonRef"
+                type="button">
+                <i aria-hidden="true" class="bi bi-trash"></i>
+            </button>
         </div>
     </div>
 </div>
diff --git a/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor.cs b/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor.cs
index 4bed2816..c746aa64 100644
--- a/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor.cs
+++ b/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor.cs
@@ -1,20 +1,23 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Database;
+using EventLogExpert.Runtime.Database.Upgrade;
 using Microsoft.AspNetCore.Components;
+using Microsoft.JSInterop;
 
 namespace EventLogExpert.UI.Database;
 
 public sealed partial class DatabaseEntryRow : ComponentBase
 {
-    /// <summary>
-    ///     Click-driven reveal flag for the trash strip on the left of the row. Set true when the name button is clicked,
-    ///     cleared when the cursor leaves the row -- so re-entering the row without re-clicking does not re-open the slide,
-    ///     even though the name button may still hold DOM focus. Keyboard navigation drives the reveal via :focus-visible in
-    ///     CSS instead.
-    /// </summary>
-    private bool _isMouseRevealed;
+    private readonly string _nameButtonId = $"db-row-{Guid.NewGuid():N}-name";
+    private readonly string _pendingStatusId = $"db-row-{Guid.NewGuid():N}-pending";
+
+    private ElementReference _nameButtonRef;
+    private ElementReference _removeButtonRef;
+    private bool _shouldFocusNameAfterRender;
 
     private enum ActionKind
     {
@@ -23,7 +26,9 @@ private enum ActionKind
         DisabledToggle,
         Upgrade,
         Retry,
-        Spinner
+        Spinner,
+        RestoreFromBackup,
+        RetryClassification
     }
 
     [Parameter] public bool EffectiveEnabled { get; set; }
@@ -32,27 +37,41 @@ private enum ActionKind
 
     [Parameter] public bool IsClassificationPending { get; set; }
 
+    [Parameter] public bool IsSelected { get; set; }
+
+    [Parameter] public bool IsTogglePending { get; set; }
+
     [Parameter] public bool IsUpgradeBlocked { get; set; }
 
     [Parameter] public bool IsUpgrading { get; set; }
 
     [Parameter] public EventCallback OnRemove { get; set; }
 
+    [Parameter] public EventCallback OnRestoreFromBackup { get; set; }
+
+    [Parameter] public EventCallback OnRetryClassification { get; set; }
+
+    [Parameter] public EventCallback OnSelectionToggle { get; set; }
+
     [Parameter] public EventCallback OnToggle { get; set; }
 
     [Parameter] public EventCallback OnUpgrade { get; set; }
 
+    [Parameter] public BannerProgressEntry? UpgradeProgress { get; set; }
+
     private string BadgeKind => Entry.BackupExists ? "Recovery" : Entry.Status.ToString();
 
     private string BadgeLabel => DatabaseStatusLabels.GetRowBadgeLabel(Entry);
 
+    private bool IsRestoreBlocked => IsUpgradeBlocked || IsUpgrading || UpgradeProgress is not null;
+
     private ActionKind PrimaryAction
     {
         get
         {
-            if (Entry.BackupExists) { return ActionKind.None; }
+            if (Entry.BackupExists) { return ActionKind.RestoreFromBackup; }
 
-            if (IsUpgrading) { return ActionKind.Spinner; }
+            if (IsUpgrading || UpgradeProgress is not null) { return ActionKind.Spinner; }
 
             return Entry.Status switch
             {
@@ -63,7 +82,7 @@ private ActionKind PrimaryAction
                 DatabaseStatus.UpgradeFailed => ActionKind.Retry,
                 DatabaseStatus.UnrecognizedSchema => ActionKind.None,
                 DatabaseStatus.ObsoleteSchema => ActionKind.None,
-                DatabaseStatus.ClassificationFailed => ActionKind.None,
+                DatabaseStatus.ClassificationFailed => ActionKind.RetryClassification,
                 _ => ActionKind.None
             };
         }
@@ -71,10 +90,47 @@ private ActionKind PrimaryAction
 
     private bool ShouldShowBadge => Entry.BackupExists ||
         (!IsUpgrading &&
+            UpgradeProgress is null &&
             Entry.Status != DatabaseStatus.Ready &&
             Entry.Status != DatabaseStatus.UpgradeRequired);
 
-    private void HandleNameClick() => _isMouseRevealed = true;
+    private bool ShowPendingIndicator => IsTogglePending && PrimaryAction != ActionKind.DisabledToggle;
+
+    [Inject] private ITraceLogger TraceLogger { get; init; } = null!;
+
+    public ValueTask FocusRemoveButtonAsync() => _removeButtonRef.FocusAsync(preventScroll: true);
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (!_shouldFocusNameAfterRender) { return; }
+
+        _shouldFocusNameAfterRender = false;
+
+        try { await _nameButtonRef.FocusAsync(preventScroll: true); }
+        catch (ObjectDisposedException) { }
+        catch (JSException) { }
+    }
+
+    private static string PhaseVerb(UpgradePhase phase) => phase switch
+    {
+        UpgradePhase.BackingUp => "Backing up",
+        UpgradePhase.MigratingSchema => "Migrating schema",
+        UpgradePhase.Verifying => "Verifying",
+        _ => "Upgrading"
+    };
+
+    private void OnCancelClick()
+    {
+        _shouldFocusNameAfterRender = true;
+
+        try { UpgradeProgress?.Cancel(); }
+        catch (OperationCanceledException) { }
+        catch (Exception ex)
+        {
+            TraceLogger.Warning(
+                $"{nameof(DatabaseEntryRow)}.{nameof(OnCancelClick)}: cancel threw: {ex}");
+        }
+    }
 
-    private void HandleRowMouseLeave() => _isMouseRevealed = false;
+    private async Task OnRemoveClick() => await OnRemove.InvokeAsync();
 }
diff --git a/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor.css b/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor.css
index 5c6ca977..2f17af33 100644
--- a/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor.css
+++ b/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor.css
@@ -1,46 +1,28 @@
 .db-entry-row {
-    --db-entry-trash-reveal: 2.5rem;
+    display: grid;
+    grid-template-columns: auto 1fr;
+    align-items: center;
+    gap: .5rem;
 
-    position: relative;
-    overflow: hidden;
+    padding: .25rem .5rem;
+    background-color: var(--background-dark);
+
+    border-left: 3px solid transparent;
+
+    transition: background-color 180ms ease, border-left-color 180ms ease;
 }
 
-.db-entry-row-content {
-    position: relative;
+.db-entry-row--selected {
+    border-left-color: var(--clr-lightblue);
+}
 
+.db-entry-row-content {
     display: grid;
     grid-template-columns: 1fr auto;
     align-items: center;
     gap: 1rem;
 
-    /* No left padding: the visible left indent lives on .db-entry-info so the
-       content layer's left edge butts up against the trash strip when slid.
-       Background matches the modal chrome (var(--background-dark)) so rows
-       blend visually but the opaque fill is still required to cover the
-       absolutely-positioned trash button underneath at rest. The trash
-       button is rendered earlier in the DOM than this element, so this
-       element paints above it via source order without needing z-index --
-       which also keeps rows below dialog-level overlays (e.g. inline alerts). */
-    padding: .15rem .5rem .15rem 0;
-    background-color: var(--background-dark);
-
-    transition: transform 200ms ease;
-}
-
-/* Reveal logic:
-   - Mouse: clicking the name button sets the .db-entry-row--revealed flag in
-     code-behind, which keeps the slide open until the cursor leaves the row
-     (@onmouseleave clears the flag). Re-entering the row without re-clicking
-     does NOT re-open the slide, even if the name button still has DOM focus.
-   - Keyboard: :focus-visible on the name button (matched only when focus
-     came from a key press, not a mouse click) opens the slide independently
-     of hover/state, so keyboard users can see what's there.
-   - Trash :focus keeps the strip open during the click (mouse focus or
-     keyboard focus), so the click reliably lands. */
-.db-entry-row.db-entry-row--revealed .db-entry-row-content,
-.db-entry-row:has(.db-entry-name:focus-visible) .db-entry-row-content,
-.db-entry-row:has(.db-entry-remove-btn:focus) .db-entry-row-content {
-    transform: translateX(var(--db-entry-trash-reveal));
+    padding: .25rem 0;
 }
 
 .db-entry-info {
@@ -48,8 +30,6 @@
     align-items: center;
     gap: .5rem;
     min-width: 0;
-
-    padding-left: .5rem;
 }
 
 .db-entry-name {
@@ -108,10 +88,29 @@
 .db-entry-upgrading {
     display: inline-flex;
     align-items: center;
-    gap: .35rem;
+    gap: .5rem;
 
     color: var(--clr-lightblue);
     font-style: italic;
+
+    animation: db-entry-upgrading-fade-in 200ms ease-out;
+}
+
+.db-entry-upgrading-status {
+    display: inline-flex;
+    align-items: center;
+    gap: .35rem;
+    min-width: 0;
+}
+
+.db-entry-upgrading-text {
+    display: inline-block;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+
+    animation: db-entry-upgrading-text-fade 180ms ease-out;
 }
 
 .db-entry-spinner {
@@ -119,32 +118,35 @@
     animation: db-entry-spin 1.5s linear infinite;
 }
 
-.db-entry-remove-btn {
-    position: absolute;
-    left: 0;
-    top: 0;
-    bottom: 0;
-    width: var(--db-entry-trash-reveal);
+.db-entry-cancel-btn {
+    flex: 0 0 auto;
+    padding: .15rem .65rem;
 
-    display: flex;
-    align-items: center;
-    justify-content: center;
+    background: transparent;
+    color: inherit;
+    border: 1px solid currentColor;
+    border-radius: .25rem;
 
-    /* Recessed-well treatment: darker fill plus a soft inner shadow makes the
-       exposed trash strip read as a depression cut into the row, rather than
-       a button floating on top. */
-    background-color: var(--surface-inset);
-    box-shadow: inset 0 0 .35rem rgba(0, 0, 0, .55);
+    font-style: normal;
+
+    transition: background-color 150ms ease;
+
+    &:hover { background-color: rgba(255, 255, 255, 0.12); }
 }
 
-@media (hover: none) {
-    .db-entry-row-content {
-        transform: translateX(var(--db-entry-trash-reveal));
-    }
+.db-entry-remove-btn {
+    flex: 0 0 auto;
+    display: flex;
+    align-items: center;
+    justify-content: center;
 }
 
 @media (prefers-reduced-motion: reduce) {
-    .db-entry-row-content {
+    .db-entry-row,
+    .db-entry-upgrading,
+    .db-entry-upgrading-text,
+    .db-entry-cancel-btn {
+        animation: none;
         transition: none;
     }
 }
@@ -153,3 +155,31 @@
     from { transform: rotate(0deg); }
     to { transform: rotate(360deg); }
 }
+
+@keyframes db-entry-upgrading-fade-in {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+@keyframes db-entry-upgrading-text-fade {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+
+.db-entry-actions ::deep .option-select {
+    border-radius: 4px;
+}
+
+
+.visually-hidden {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border: 0;
+}
\ No newline at end of file
diff --git a/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsModal.razor b/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsModal.razor
index 6eae4113..b9b1ac52 100644
--- a/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsModal.razor
+++ b/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsModal.razor
@@ -1,7 +1,7 @@
 @using EventLogExpert.UI.DatabaseTools.Tabs
 @inherits ModalBase<bool>
 
-<ModalChrome AriaLabel="Database Tools"
+<ModalChrome AriaLabel="Databases"
     Footer="FooterPreset.CloseOnly"
     Height="80%"
     InlineAlert="@CurrentInlineAlert"
@@ -13,76 +13,77 @@
     OnInlineAlertResolved="HandleInlineAlertResolvedAsync"
     @ref="ChromeRef">
     <ChildContent>
-        <CascadingValue Value="_verboseLogging" Name="VerboseLogging">
-            <div class="database-tools">
-                <div aria-orientation="vertical" class="database-tools-tabs" role="tablist" @ref="_tablistRef">
-                    @foreach (var (tab, label) in s_tabs)
-                    {
-                        <button aria-controls="@($"db-tabpanel-{tab}")"
-                            aria-selected="@(tab == _activeTab ? "true" : "false")"
-                            class="@(tab == _activeTab ? "tab active" : "tab")"
-                            id="@($"db-tab-{tab}")"
-                            @onclick="() => SetActiveTab(tab)"
-                            @onkeydown="e => OnTabKeyDown(e, tab)"
-                            @ref="_tabButtonRefs[tab]"
-                            role="tab"
-                            tabindex="@(tab == _activeTab ? "0" : "-1")"
-                            type="button">
-                            @label
-                        </button>
-                    }
-                </div>
+        <CascadingValue Name="VerboseLogging" Value="_verboseLogging">
+            <CascadingValue IsFixed="true" Value="(IInlineAlertSurface)this">
+                <div class="database-tools">
+                    <div aria-orientation="vertical" class="database-tools-tabs" @ref="_tablistRef" role="tablist">
+                        @foreach (var (tab, label) in s_tabs)
+                        {
+                            <button aria-controls="@($"db-tabpanel-{tab}")"
+                                aria-selected="@(tab == _activeTab ? "true" : "false")"
+                                class="@(tab == _activeTab ? "tab active" : "tab")"
+                                id="@($"db-tab-{tab}")"
+                                @onclick="() => SetActiveTab(tab)"
+                                @onkeydown="e => OnTabKeyDown(e, tab)"
+                                @ref="_tabButtonRefs[tab]"
+                                role="tab"
+                                tabindex="@(tab == _activeTab ? "0" : "-1")"
+                                type="button">
+                                @label
+                            </button>
+                        }
+                    </div>
+
+                    <div class="database-tools-content">
+                        @foreach (var (tab, _) in s_tabs)
+                        {
+                            <div aria-labelledby="@($"db-tab-{tab}")"
+                                class="@(tab == _activeTab ? "tabpanel active" : "tabpanel")"
+                                id="@($"db-tabpanel-{tab}")"
+                                role="tabpanel"
+                                style="@(tab == _activeTab ? "" : "display: none")">
+                                @switch (tab)
+                                {
+                                    case DatabaseToolsTab.Show:
+                                        <ShowProvidersTab @ref="_showTab" />
 
-                <div class="database-tools-content">
-                    @foreach (var (tab, _) in s_tabs)
-                    {
-                        <div aria-labelledby="@($"db-tab-{tab}")"
-                            class="@(tab == _activeTab ? "tabpanel active" : "tabpanel")"
-                            id="@($"db-tabpanel-{tab}")"
-                            role="tabpanel"
-                            style="@(tab == _activeTab ? "" : "display: none")">
-                            @switch (tab)
-                            {
-                                case DatabaseToolsTab.Show:
-                                    <ShowProvidersTab @ref="_showTab" />
+                                        break;
+                                    case DatabaseToolsTab.Create:
+                                        <CreateDatabaseTab @ref="_createTab" />
 
-                                    break;
-                                case DatabaseToolsTab.Create:
-                                    <CreateDatabaseTab @ref="_createTab" />
+                                        break;
+                                    case DatabaseToolsTab.Merge:
+                                        <MergeDatabaseTab @ref="_mergeTab" />
 
-                                    break;
-                                case DatabaseToolsTab.Merge:
-                                    <MergeDatabaseTab @ref="_mergeTab" />
+                                        break;
+                                    case DatabaseToolsTab.Diff:
+                                        <DiffDatabasesTab @ref="_diffTab" />
 
-                                    break;
-                                case DatabaseToolsTab.Diff:
-                                    <DiffDatabasesTab @ref="_diffTab" />
+                                        break;
+                                    case DatabaseToolsTab.Upgrade:
+                                        <UpgradeDatabaseTab @ref="_upgradeTab" />
 
-                                    break;
-                                case DatabaseToolsTab.Upgrade:
-                                    <UpgradeDatabaseTab @ref="_upgradeTab" />
+                                        break;
+                                    case DatabaseToolsTab.Manage:
+                                        <ManageDatabasesTab @ref="_manageTab" />
 
-                                    break;
-                            }
-                        </div>
-                    }
+                                        break;
+                                }
+                            </div>
+                        }
+                    </div>
                 </div>
-            </div>
+            </CascadingValue>
         </CascadingValue>
     </ChildContent>
     <ExtraFooterContent>
-        <div class="verbose-mode" role="group" aria-labelledby="verbose-mode-label">
+        <div aria-labelledby="verbose-mode-label" class="verbose-mode" role="group">
             <span class="verbose-mode-label" id="verbose-mode-label">Output</span>
-            <ValueSelect T="bool"
-                AriaDescribedBy="verbose-mode-help"
+            <OptionSelect AriaDescribedBy="verbose-mode-help"
                 AriaLabelledBy="verbose-mode-label"
-                CssClass="input filter-dropdown verbose-mode-select"
-                ToStringFunc="@(v => v ? "Verbose" : "Normal")"
-                @bind-Value="_verboseLogging">
-                <ValueSelectItem T="bool" Value="false">Normal</ValueSelectItem>
-                <ValueSelectItem T="bool" Value="true">Verbose</ValueSelectItem>
-            </ValueSelect>
-            @* Kept as a visually-hidden span so screen readers still announce the help text on the dropdown. *@
+                @bind-Value="_verboseLogging"
+                DisabledString="Normal"
+                EnabledString="Verbose" />
             <span class="visually-hidden" id="verbose-mode-help">
                 Verbose includes trace-level diagnostic details on next run.
             </span>
diff --git a/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsModal.razor.cs b/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsModal.razor.cs
index 85ee133f..2cfb5816 100644
--- a/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsModal.razor.cs
+++ b/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsModal.razor.cs
@@ -1,7 +1,9 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
+using EventLogExpert.Logging.Abstractions;
 using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.DatabaseTools.Tabs;
 using Microsoft.AspNetCore.Components;
@@ -10,10 +12,11 @@
 
 namespace EventLogExpert.UI.DatabaseTools;
 
-public sealed partial class DatabaseToolsModal
+public sealed partial class DatabaseToolsModal : IInlineAlertSurface
 {
     private static readonly (DatabaseToolsTab Tab, string Label)[] s_tabs =
     [
+        (DatabaseToolsTab.Manage, "Manage"),
         (DatabaseToolsTab.Show, "Show Providers"),
         (DatabaseToolsTab.Create, "Create Database"),
         (DatabaseToolsTab.Merge, "Merge Databases"),
@@ -23,9 +26,10 @@ private static readonly (DatabaseToolsTab Tab, string Label)[] s_tabs =
 
     private readonly Dictionary<DatabaseToolsTab, ElementReference> _tabButtonRefs = new();
 
-    private DatabaseToolsTab _activeTab = DatabaseToolsTab.Show;
+    private DatabaseToolsTab _activeTab = DatabaseToolsTab.Manage;
     private CreateDatabaseTab? _createTab;
     private DiffDatabasesTab? _diffTab;
+    private ManageDatabasesTab? _manageTab;
     private MergeDatabaseTab? _mergeTab;
     private DatabaseToolsTab? _pendingFocusTab;
     private ShowProvidersTab? _showTab;
@@ -44,6 +48,10 @@ private static readonly (DatabaseToolsTab Tab, string Label)[] s_tabs =
 
     [Inject] private IJSRuntime JSRuntime { get; init; } = null!;
 
+    [Inject] private ILogReloadCoordinator LogReloadCoordinator { get; init; } = null!;
+
+    [Inject] private ITraceLogger TraceLogger { get; init; } = null!;
+
     protected override async ValueTask DisposeAsyncCore(bool disposing)
     {
         if (disposing && _tabKeyModule is not null)
@@ -65,8 +73,6 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
     {
         if (firstRender)
         {
-            // Inline JS shim: suppresses browser default scrolling on Arrow/Home/End while
-            // keeping Tab/Enter/Space defaults intact for focus + activation.
             try
             {
                 _tabKeyModule = await JSRuntime.InvokeAsync<IJSObjectReference>(
@@ -92,30 +98,83 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
     protected override async Task OnClosingAsync()
     {
         // CancelIfRunning is a no-op when not running; safe to call from all close paths.
+        // Manage tab is not a DatabaseToolsTabBase<TRequest> and has no Run/Cancel surface.
         _showTab?.CancelIfRunning();
         _createTab?.CancelIfRunning();
         _mergeTab?.CancelIfRunning();
         _diffTab?.CancelIfRunning();
         _upgradeTab?.CancelIfRunning();
 
+        if (_manageTab is { HasDatabaseStateChanged: true })
+        {
+            await PromptAndReloadOpenLogs();
+        }
+
         await base.OnClosingAsync();
     }
 
     protected override async Task<bool> OnRequestCloseAsync(ModalCloseRequest request)
     {
-        if (!AnyTabIsRunning) { return true; }
-
-        var confirm = await ShowInlineAlertAsync(
-            new InlineAlertRequest(
-                Title: "Operation in progress",
-                Message: "An operation is running. Cancel and close anyway?",
-                AcceptLabel: "Cancel and close",
-                CancelLabel: "Continue running",
-                IsPrompt: false,
-                PromptInitialValue: null),
-            CancellationToken.None);
-
-        return confirm.Accepted;
+        // 1. Hard-block while Manage-tab-initiated upgrade is in flight.
+        if (_manageTab is { IsUpgradeInFlight: true }) { return false; }
+
+        // 2. Pending toggles → save prompt OR discard prompt.
+        if (_manageTab is { HasPendingChanges: true })
+        {
+            var savePrompt = await ShowInlineAlertAsync(
+                new InlineAlertRequest(
+                    Title: "Unsaved changes",
+                    Message: "You have pending database changes. Save them now?",
+                    AcceptLabel: "Save",
+                    CancelLabel: "Don't save",
+                    IsPrompt: false,
+                    PromptInitialValue: null),
+                CancellationToken.None);
+
+            if (savePrompt.Accepted)
+            {
+                var saved = await _manageTab.ApplyPendingTogglesAsync();
+                if (!saved) { return false; }
+            }
+            else
+            {
+                var closeAnyway = await ShowInlineAlertAsync(
+                    new InlineAlertRequest(
+                        Title: "Discard changes?",
+                        Message: "Close without saving? Pending changes will be lost.",
+                        AcceptLabel: "Close",
+                        CancelLabel: "Stay open",
+                        IsPrompt: false,
+                        PromptInitialValue: null),
+                    CancellationToken.None);
+
+                if (!closeAnyway.Accepted) { return false; }
+            }
+
+            // Re-check after the async prompt round-trip.
+            if (_manageTab is { IsUpgradeInFlight: true }) { return false; }
+        }
+
+        // 3. Existing AnyTabIsRunning prompt — preserves current behavior.
+        if (AnyTabIsRunning)
+        {
+            var confirm = await ShowInlineAlertAsync(
+                new InlineAlertRequest(
+                    Title: "Operation in progress",
+                    Message: "An operation is running. Cancel and close anyway?",
+                    AcceptLabel: "Cancel and close",
+                    CancelLabel: "Continue running",
+                    IsPrompt: false,
+                    PromptInitialValue: null),
+                CancellationToken.None);
+
+            if (!confirm.Accepted) { return false; }
+        }
+
+        // 4. Final upgrade re-check covers upgrades started during the AnyTabIsRunning prompt.
+        if (_manageTab is { IsUpgradeInFlight: true }) { return false; }
+
+        return true;
     }
 
     private static DatabaseToolsTab NextTab(DatabaseToolsTab current)
@@ -153,6 +212,42 @@ private void OnTabKeyDown(KeyboardEventArgs e, DatabaseToolsTab tab)
         }
     }
 
+    private async Task PromptAndReloadOpenLogs()
+    {
+        if (!LogReloadCoordinator.HasActiveLogs) { return; }
+
+        bool yes;
+
+        try
+        {
+            var result = await ShowInlineAlertAsync(
+                new InlineAlertRequest(
+                    Title: "Reload Open Logs Now?",
+                    Message: "In order for these changes to take effect, all currently open logs must be reloaded. " +
+                        "Would you like to reload all open logs now?",
+                    AcceptLabel: "Yes",
+                    CancelLabel: "No",
+                    IsPrompt: false,
+                    PromptInitialValue: null),
+                CancellationToken.None);
+
+            yes = result.Accepted;
+        }
+        catch (ObjectDisposedException) { return; }
+        catch (OperationCanceledException) { return; }
+
+        if (yes)
+        {
+            try { await LogReloadCoordinator.ReloadAllActiveLogsAsync(); }
+            catch (OperationCanceledException) { }
+            catch (TimeoutException ex)
+            {
+                TraceLogger.Warning(
+                    $"{nameof(DatabaseToolsModal)}.{nameof(PromptAndReloadOpenLogs)}: reload did not complete within timeout: {ex}");
+            }
+        }
+    }
+
     private void SetActiveTab(DatabaseToolsTab tab)
     {
         if (_activeTab == tab) { return; }
diff --git a/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsTab.cs b/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsTab.cs
index f490f768..f621995e 100644
--- a/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsTab.cs
+++ b/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsTab.cs
@@ -3,12 +3,9 @@
 
 namespace EventLogExpert.UI.DatabaseTools;
 
-/// <summary>
-///     Identifies the five DatabaseTools tabs in <see cref="DatabaseToolsModal" />. Used as both the tab order and
-///     the discriminator the modal switches on when rendering the active panel.
-/// </summary>
 internal enum DatabaseToolsTab
 {
+    Manage,
     Show,
     Create,
     Merge,
diff --git a/src/EventLogExpert.UI/DatabaseTools/IInlineAlertSurface.cs b/src/EventLogExpert.UI/DatabaseTools/IInlineAlertSurface.cs
new file mode 100644
index 00000000..6f762949
--- /dev/null
+++ b/src/EventLogExpert.UI/DatabaseTools/IInlineAlertSurface.cs
@@ -0,0 +1,18 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Alerts;
+
+namespace EventLogExpert.UI.DatabaseTools;
+
+/// <summary>
+///     Cascading-value surface that lets a child component (e.g. ManageDatabasesTab) raise an inline alert through
+///     its hosting modal. Implemented by <see cref="DatabaseToolsModal" /> via implicit interface satisfaction against the
+///     inherited public <c>ShowInlineAlertAsync</c> from <c>ModalBase</c>.
+/// </summary>
+internal interface IInlineAlertSurface
+{
+    Task<InlineAlertResult> ShowInlineAlertAsync(
+        InlineAlertRequest request,
+        CancellationToken cancellationToken);
+}
diff --git a/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesEmptyState.razor b/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesEmptyState.razor
new file mode 100644
index 00000000..a2980b51
--- /dev/null
+++ b/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesEmptyState.razor
@@ -0,0 +1,3 @@
+<div class="manage-databases-empty">
+    Import a provider database (.db file) using the <strong>Import database&hellip;</strong> button above to resolve events from other providers.
+</div>
diff --git a/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesEmptyState.razor.css b/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesEmptyState.razor.css
new file mode 100644
index 00000000..af1ca7a2
--- /dev/null
+++ b/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesEmptyState.razor.css
@@ -0,0 +1,10 @@
+.manage-databases-empty {
+    color: var(--text-secondary);
+    font-style: italic;
+    padding: 0.5rem;
+    line-height: 1.4;
+}
+
+.manage-databases-empty strong {
+    color: var(--text-primary);
+}
diff --git a/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesTab.razor b/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesTab.razor
new file mode 100644
index 00000000..0b379af9
--- /dev/null
+++ b/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesTab.razor
@@ -0,0 +1,97 @@
+@namespace EventLogExpert.UI.DatabaseTools.Tabs
+
+<div class="manage-databases-tab">
+    @if (IsClassificationPending)
+    {
+        <div class="manage-status-banner manage-status-banner--info" role="status">
+            <i aria-hidden="true" class="bi bi-arrow-repeat manage-status-banner__spinner"></i>
+            <span class="manage-status-banner__message">Classifying databases&hellip;</span>
+        </div>
+    }
+
+    <span aria-atomic="true" aria-live="polite" class="visually-hidden" role="status">@_selectionAnnouncement</span>
+
+    <div class="manage-databases-import-row">
+        <button class="button"
+            id="manage-import-button"
+            @onclick="ImportDatabase"
+            @ref="_importButtonRef"
+            type="button">
+            <i aria-hidden="true" class="bi bi-plus-circle"></i> Import database&hellip;
+        </button>
+    </div>
+
+    <div class="manage-databases-entries">
+        @if (DatabaseService.Entries.Count > 0)
+        {
+            @foreach (var entry in DatabaseService.Entries)
+            {
+                <DatabaseEntryRow EffectiveEnabled="GetEffectiveEnabled(entry)"
+                    Entry="@entry"
+                    IsClassificationPending="@IsClassificationPending"
+                    IsSelected="@_selectedForRemoval.Contains(entry.FileName)"
+                    IsTogglePending="@_pendingToggles.ContainsKey(entry.FileName)"
+                    IsUpgradeBlocked="@IsUpgradeBlocked"
+                    IsUpgrading="@Coordinator.IsUpgradeInFlight(entry.FileName)"
+                    @key="entry.FileName"
+                    OnRemove="@(() => RemoveDatabase(entry))"
+                    OnRestoreFromBackup="@(() => RestoreFromBackup(entry))"
+                    OnRetryClassification="@(() => RetryClassification(entry))"
+                    OnSelectionToggle="@(() => ToggleSelection(entry.FileName))"
+                    OnToggle="@(() => ToggleDatabase(entry.FileName))"
+                    OnUpgrade="@(() => UpgradeEntry(entry.FileName))"
+                    @ref="_removeButtonRefs[entry.FileName]"
+                    UpgradeProgress="@GetUpgradeProgressForEntry(entry)" />
+            }
+        }
+        else if (!IsClassificationPending)
+        {
+            <ManageDatabasesEmptyState />
+        }
+    </div>
+
+    @if (HasSelectedForRemoval)
+    {
+        <div aria-label="Bulk database actions" class="manage-databases-bulk-strip" role="group">
+            <span class="manage-databases-bulk-count">
+                @_selectedForRemoval.Count selected
+            </span>
+            <button class="button"
+                @onclick="ClearSelection"
+                type="button">
+                Clear
+            </button>
+            <button class="button button-red"
+                @onclick="OnBulkRemoveClickAsync"
+                @ref="_bulkRemoveButtonRef"
+                type="button">
+                Remove @_selectedForRemoval.Count
+            </button>
+        </div>
+    }
+
+    @if (HasPendingChanges)
+    {
+        <div aria-label="Pending database changes" class="manage-databases-save-strip" role="group">
+            <span class="manage-databases-pending-count">
+                @_pendingToggles.Count pending change@(_pendingToggles.Count == 1 ? "" : "s")
+            </span>
+            <button class="button"
+                @onclick="DiscardPending"
+                type="button">
+                Discard
+            </button>
+            <button aria-describedby="@(IsUpgradeBlocked ? _saveBlockedHelpId : null)"
+                aria-disabled="@(IsUpgradeBlocked ? "true" : "false")"
+                class="button button-green"
+                id="manage-save"
+                @onclick="OnSaveClickAsync"
+                type="button">
+                Save changes
+            </button>
+            <span aria-live="polite" class="visually-hidden" id="@_saveBlockedHelpId">
+                @(IsUpgradeBlocked ? "Cannot save: a database upgrade is in progress." : string.Empty)
+            </span>
+        </div>
+    }
+</div>
diff --git a/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesTab.razor.cs b/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesTab.razor.cs
new file mode 100644
index 00000000..e00537ca
--- /dev/null
+++ b/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesTab.razor.cs
@@ -0,0 +1,787 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.Runtime.Announcement;
+using EventLogExpert.Runtime.Banner;
+using EventLogExpert.Runtime.Database;
+using EventLogExpert.Runtime.Database.Upgrade;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.UI.Database;
+using Microsoft.AspNetCore.Components;
+using Microsoft.JSInterop;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.UI.DatabaseTools.Tabs;
+
+public sealed partial class ManageDatabasesTab : ComponentBase, IAsyncDisposable
+{
+    private static readonly TimeSpan s_cancelTimeout = TimeSpan.FromSeconds(30);
+
+    private readonly Dictionary<string, bool> _pendingToggles = new(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<string, DatabaseEntryRow?> _removeButtonRefs = new(StringComparer.OrdinalIgnoreCase);
+    private readonly string _saveBlockedHelpId = $"manage-save-blocked-{Guid.NewGuid():N}";
+    private readonly HashSet<string> _selectedForRemoval = new(StringComparer.OrdinalIgnoreCase);
+
+    private ElementReference _bulkRemoveButtonRef;
+    private CancellationTokenSource? _classificationObservationCts;
+    private volatile bool _disposed;
+    private (string FileName, FocusTarget Target)? _focusRestorationTarget;
+    private ElementReference _importButtonRef;
+    private ImmutableHashSet<string> _initialActiveSnapshot = ImmutableHashSet<string>.Empty;
+    private bool _restorationOccurred;
+    private bool _schemaUpgradeOccurred;
+    private string _selectionAnnouncement = string.Empty;
+
+    private enum FocusTarget
+    {
+        SameRowRemove,
+        BulkRemoveButton,
+        ImportButton
+    }
+
+    public bool HasDatabaseStateChanged
+    {
+        get
+        {
+            if (_schemaUpgradeOccurred || _restorationOccurred) { return true; }
+
+            return !_initialActiveSnapshot.SetEquals(ComputeActiveSet());
+        }
+    }
+
+    public bool HasPendingChanges => _pendingToggles.Count > 0;
+
+    public bool HasSelectedForRemoval => _selectedForRemoval.Count > 0;
+
+    public bool IsUpgradeInFlight => Coordinator.IsAnyUpgradeInFlight;
+
+    [CascadingParameter] internal IInlineAlertSurface? AlertSurface { get; set; }
+
+    [Inject] private IAnnouncementService AnnouncementService { get; init; } = null!;
+
+    [Inject] private IDatabaseOperationCoordinator Coordinator { get; init; } = null!;
+
+    [Inject] private IDatabaseService DatabaseService { get; init; } = null!;
+
+    private bool IsClassificationPending => !DatabaseService.InitialClassificationTask.IsCompleted;
+
+    private bool IsUpgradeBlocked => IsUpgradeInFlight;
+
+    [Inject] private ILogReloadCoordinator LogReloadCoordinator { get; init; } = null!;
+
+    [Inject] private IProgressBannerService ProgressBannerService { get; init; } = null!;
+
+    [Inject] private ITraceLogger TraceLogger { get; init; } = null!;
+
+    public async ValueTask DisposeAsync()
+    {
+        if (_disposed) { return; }
+        _disposed = true;
+
+        if (_classificationObservationCts is not null)
+        {
+            try { await _classificationObservationCts.CancelAsync(); }
+            catch (ObjectDisposedException) { }
+            _classificationObservationCts.Dispose();
+            _classificationObservationCts = null;
+        }
+
+        DatabaseService.EntriesChanged -= OnDatabaseEntriesChanged;
+        DatabaseService.UpgradeBatchCompleted -= OnUpgradeBatchCompleted;
+        ProgressBannerService.StateChanged -= OnBannerStateChanged;
+        Coordinator.UpgradeStateChanged -= OnCoordinatorStateChanged;
+    }
+
+    /// <summary>
+    ///     Save wrapper invoked by <see cref="DatabaseToolsModal" /> on the unsaved-changes close prompt and by the
+    ///     inline Save button. Returns true on success or no-op; false when blocked by an in-flight upgrade or when the
+    ///     coordinator apply faulted. Sets <see cref="HasDatabaseStateChanged" /> bookkeeping when active state actually
+    ///     changed.
+    /// </summary>
+    internal async Task<bool> ApplyPendingTogglesAsync()
+    {
+        if (IsUpgradeBlocked) { return false; }
+
+        var snapshot = _pendingToggles.Keys.ToArray();
+        if (snapshot.Length == 0) { return true; }
+
+        try
+        {
+            await Coordinator.ApplyPendingTogglesAsync(snapshot, CancellationToken.None);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            TraceLogger.Warning(
+                $"{nameof(ManageDatabasesTab)}.{nameof(ApplyPendingTogglesAsync)}: {ex}");
+            return false;
+        }
+
+        if (_disposed) { return false; }
+
+        _pendingToggles.Clear();
+
+        if (HasDatabaseStateChanged)
+        {
+            AnnouncementService.Announce("Database changes applied");
+        }
+
+        return true;
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (_focusRestorationTarget is { } target)
+        {
+            _focusRestorationTarget = null;
+
+            try
+            {
+                await (target.Target switch
+                {
+                    FocusTarget.SameRowRemove =>
+                        _removeButtonRefs.GetValueOrDefault(target.FileName)?.FocusRemoveButtonAsync() ?? _importButtonRef.FocusAsync(preventScroll: true),
+                    FocusTarget.BulkRemoveButton when HasSelectedForRemoval =>
+                        _bulkRemoveButtonRef.FocusAsync(preventScroll: true),
+                    FocusTarget.ImportButton =>
+                        _importButtonRef.FocusAsync(preventScroll: true),
+                    _ => ValueTask.CompletedTask
+                });
+            }
+            catch (ObjectDisposedException) { }
+            catch (JSDisconnectedException) { }
+            catch (JSException) { }
+        }
+
+        await base.OnAfterRenderAsync(firstRender);
+    }
+
+    protected override void OnInitialized()
+    {
+        _initialActiveSnapshot = ComputeActiveSet();
+
+        DatabaseService.EntriesChanged += OnDatabaseEntriesChanged;
+        DatabaseService.UpgradeBatchCompleted += OnUpgradeBatchCompleted;
+        ProgressBannerService.StateChanged += OnBannerStateChanged;
+        Coordinator.UpgradeStateChanged += OnCoordinatorStateChanged;
+
+        if (!DatabaseService.InitialClassificationTask.IsCompleted)
+        {
+            _classificationObservationCts = new CancellationTokenSource();
+            _ = ObserveClassificationCompletionAsync(_classificationObservationCts.Token);
+        }
+
+        base.OnInitialized();
+    }
+
+    private static string BuildBulkPlainMessage(IReadOnlyList<string> fileNames)
+    {
+        var list = string.Join(", ", fileNames.Take(5));
+        var more = fileNames.Count > 5 ? $", and {fileNames.Count - 5} more" : string.Empty;
+
+        return $"Are you sure you want to remove these {fileNames.Count} databases? ({list}{more})";
+    }
+
+    private string AppendCloseReopenWarningIfNeeded(string baseMessage, IReadOnlyList<string> fileNames)
+    {
+        if (!LogReloadCoordinator.HasActiveLogs) { return baseMessage; }
+
+        bool anyRemovalAffectsActiveLog = fileNames.Any(f =>
+            DatabaseService.Entries.Any(e =>
+                string.Equals(e.FileName, f, StringComparison.OrdinalIgnoreCase) &&
+                e.IsEnabled &&
+                e.Status == DatabaseStatus.Ready));
+
+        if (!anyRemovalAffectsActiveLog) { return baseMessage; }
+
+        string warning = fileNames.Count == 1
+            ? "Removing will close and reopen any affected log views."
+            : "Removing these databases will close and reopen any affected log views.";
+
+        return $"{baseMessage} {warning}";
+    }
+
+    private async Task<bool> AskOverwriteAsync(string fileName, CancellationToken cancellationToken)
+    {
+        if (_disposed || AlertSurface is null) { return false; }
+
+        try
+        {
+            var result = await AlertSurface.ShowInlineAlertAsync(
+                new InlineAlertRequest(
+                    Title: "Database already exists",
+                    Message: $"{fileName} already exists. Overwrite?",
+                    AcceptLabel: "Overwrite",
+                    CancelLabel: "Skip",
+                    IsPrompt: false,
+                    PromptInitialValue: null),
+                cancellationToken);
+
+            return result.Accepted;
+        }
+        catch (ObjectDisposedException) { return false; }
+    }
+
+    private string BuildCancelThenRemoveMessage(IReadOnlyList<string> fileNames, IReadOnlyList<string> upgradingFiles)
+    {
+        var upgradingList = string.Join(", ", upgradingFiles.Take(5));
+        var moreUpgrading = upgradingFiles.Count > 5 ? $", and {upgradingFiles.Count - 5} more" : string.Empty;
+        var fileList = string.Join(", ", fileNames.Take(5));
+        var moreFiles = fileNames.Count > 5 ? $", and {fileNames.Count - 5} more" : string.Empty;
+
+        string baseMessage = $"Upgrade in progress for: {upgradingList}{moreUpgrading}. " +
+            $"This will cancel the upgrade batch(es) \u2014 which may include other files not in your selection \u2014 " +
+            $"and then remove: {fileList}{moreFiles}. Are you sure?";
+
+        return AppendCloseReopenWarningIfNeeded(baseMessage, fileNames);
+    }
+
+    private string BuildPlainRemoveMessage(IReadOnlyList<string> fileNames)
+    {
+        string baseMessage = fileNames.Count == 1
+            ? $"Are you sure you want to remove {fileNames[0]}?"
+            : BuildBulkPlainMessage(fileNames);
+
+        return AppendCloseReopenWarningIfNeeded(baseMessage, fileNames);
+    }
+
+    private async Task CancelUpgradesAndAwaitCompletionAsync(IReadOnlyList<string> fileNames)
+    {
+        var batchesToCancel = new Dictionary<UpgradeBatchId, Action>();
+        var batchToFiles = new Dictionary<UpgradeBatchId, List<string>>();
+        var entries = DatabaseService.Entries.ToList();
+
+        foreach (var fileName in fileNames)
+        {
+            var entry = entries.FirstOrDefault(
+                e => string.Equals(e.FileName, fileName, StringComparison.OrdinalIgnoreCase));
+
+            if (entry is null) { continue; }
+
+            var progress = GetUpgradeProgressForEntry(entry);
+
+            if (progress is null) { continue; }
+
+            batchesToCancel.TryAdd(progress.BatchId, progress.Cancel);
+
+            if (!batchToFiles.TryGetValue(progress.BatchId, out var files))
+            {
+                files = [];
+                batchToFiles[progress.BatchId] = files;
+            }
+
+            files.Add(fileName);
+        }
+
+        bool coordinatorTrackedAny = fileNames.Any(f => Coordinator.IsUpgradeInFlight(f));
+
+        if (batchesToCancel.Count == 0 && !coordinatorTrackedAny) { return; }
+
+        var pendingBatches = new Dictionary<UpgradeBatchId, TaskCompletionSource>();
+
+        foreach (var batchId in batchesToCancel.Keys)
+        {
+            pendingBatches[batchId] = new TaskCompletionSource(
+                TaskCreationOptions.RunContinuationsAsynchronously);
+        }
+
+        var coordinatorSettleTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        void CompletionHandler(object? sender, UpgradeBatchCompletedEventArgs args)
+        {
+            if (pendingBatches.TryGetValue(args.BatchId, out var tcs))
+            {
+                tcs.TrySetResult();
+            }
+        }
+
+        void StateChangedHandler()
+        {
+            if (!fileNames.Any(f => Coordinator.IsUpgradeInFlight(f)))
+            {
+                coordinatorSettleTcs.TrySetResult();
+            }
+        }
+
+        DatabaseService.UpgradeBatchCompleted += CompletionHandler;
+        Coordinator.UpgradeStateChanged += StateChangedHandler;
+
+        try
+        {
+            foreach (var (batchId, files) in batchToFiles)
+            {
+                bool stillAlive = files.Any(file =>
+                {
+                    var entry = DatabaseService.Entries.FirstOrDefault(
+                        e => string.Equals(e.FileName, file, StringComparison.OrdinalIgnoreCase));
+                    return Coordinator.IsUpgradeInFlight(file) ||
+                           (entry is not null && GetUpgradeProgressForEntry(entry) is not null);
+                });
+                if (!stillAlive) { pendingBatches[batchId].TrySetResult(); }
+            }
+
+            StateChangedHandler();
+
+            foreach (var cancel in batchesToCancel.Values)
+            {
+                try { cancel(); }
+                catch (Exception ex) when (ex is not OperationCanceledException)
+                {
+                    TraceLogger.Warning(
+                        $"{nameof(ManageDatabasesTab)}.{nameof(CancelUpgradesAndAwaitCompletionAsync)}: cancel threw: {ex}");
+                }
+            }
+
+            using var timeoutCts = new CancellationTokenSource(s_cancelTimeout);
+
+            var batchTasks = pendingBatches.Values.Select(tcs => tcs.Task);
+            var allTasks = batchTasks.Append(coordinatorSettleTcs.Task).ToArray();
+
+            try
+            {
+                await Task.WhenAll(allTasks).WaitAsync(timeoutCts.Token);
+            }
+            catch (OperationCanceledException)
+            {
+                TraceLogger.Warning(
+                    $"{nameof(ManageDatabasesTab)}.{nameof(CancelUpgradesAndAwaitCompletionAsync)}: timeout waiting for upgrade cancellation; proceeding anyway.");
+            }
+        }
+        finally
+        {
+            DatabaseService.UpgradeBatchCompleted -= CompletionHandler;
+            Coordinator.UpgradeStateChanged -= StateChangedHandler;
+        }
+    }
+
+    private void ClearSelection()
+    {
+        if (_selectedForRemoval.Count == 0) { return; }
+        _selectedForRemoval.Clear();
+        UpdateSelectionAnnouncement();
+    }
+
+    private ImmutableHashSet<string> ComputeActiveSet() =>
+        DatabaseService.Entries
+            .Where(entry => entry is { IsEnabled: true, Status: DatabaseStatus.Ready })
+            .Select(entry => entry.FileName)
+            .ToImmutableHashSet(StringComparer.OrdinalIgnoreCase);
+
+    private async Task ConfirmAndRemoveAsync(
+        IReadOnlyList<string> fileNames,
+        FocusTarget cancelTarget,
+        FocusTarget completeTarget)
+    {
+        if (_disposed || AlertSurface is null || fileNames.Count == 0) { return; }
+
+        var validFileNames = fileNames
+            .Where(f => DatabaseService.Entries.Any(e =>
+                string.Equals(e.FileName, f, StringComparison.OrdinalIgnoreCase)))
+            .ToList();
+        if (validFileNames.Count == 0) { return; }
+
+        bool requiresCancelFirst = IsAnyFileUpgrading(validFileNames, out var upgradingFiles);
+
+        string title = validFileNames.Count == 1
+            ? "Remove Database"
+            : $"Remove {validFileNames.Count} Databases";
+
+        string acceptLabel = requiresCancelFirst
+            ? $"Cancel {upgradingFiles.Count} upgrade{(upgradingFiles.Count == 1 ? "" : "s")} and remove {validFileNames.Count} database{(validFileNames.Count == 1 ? "" : "s")}"
+            : "Remove";
+
+        string message = requiresCancelFirst
+            ? BuildCancelThenRemoveMessage(validFileNames, upgradingFiles)
+            : BuildPlainRemoveMessage(validFileNames);
+
+        InlineAlertResult result;
+        try
+        {
+            result = await AlertSurface.ShowInlineAlertAsync(
+                new InlineAlertRequest(
+                    Title: title,
+                    Message: message,
+                    AcceptLabel: acceptLabel,
+                    CancelLabel: "Cancel",
+                    IsPrompt: false,
+                    PromptInitialValue: null),
+                CancellationToken.None);
+        }
+        catch (ObjectDisposedException) { return; }
+
+        if (!result.Accepted)
+        {
+            _focusRestorationTarget = (validFileNames[0], cancelTarget);
+            return;
+        }
+        if (_disposed) { return; }
+
+        if (requiresCancelFirst)
+        {
+            await CancelUpgradesAndAwaitCompletionAsync(upgradingFiles);
+            if (_disposed) { return; }
+        }
+
+        await RemoveDatabasesAsync(validFileNames, completeTarget);
+    }
+
+    private void ConsumeReopenedAsBaseline()
+    {
+        _initialActiveSnapshot = ComputeActiveSet();
+        _schemaUpgradeOccurred = false;
+        _restorationOccurred = false;
+    }
+
+    private void DiscardPending()
+    {
+        if (_pendingToggles.Count == 0) { return; }
+        _pendingToggles.Clear();
+    }
+
+    private bool GetEffectiveEnabled(DatabaseEntry entry) =>
+        _pendingToggles.TryGetValue(entry.FileName, out var pending) ? pending : entry.IsEnabled;
+
+    private BannerProgressEntry? GetUpgradeProgressForEntry(DatabaseEntry entry)
+    {
+        var manage = ProgressBannerService.ManageDatabasesProgress;
+        if (manage is not null &&
+            string.Equals(manage.CurrentEntryName, entry.FileName, StringComparison.OrdinalIgnoreCase))
+        {
+            return manage;
+        }
+
+        var background = ProgressBannerService.BackgroundProgress;
+        if (background is not null &&
+            string.Equals(background.CurrentEntryName, entry.FileName, StringComparison.OrdinalIgnoreCase))
+        {
+            return background;
+        }
+
+        return null;
+    }
+
+    private async Task ImportDatabase()
+    {
+        var outcome = await Coordinator.ImportAsync(AskOverwriteAsync);
+
+        if (_disposed) { return; }
+
+        if (outcome.DatabaseStateChanged)
+        {
+            _schemaUpgradeOccurred = true;
+            AnnouncementService.Announce("Database imported");
+        }
+    }
+
+    private async Task InvokeAsyncSafe()
+    {
+        if (_disposed) { return; }
+        try { await InvokeAsync(StateHasChanged); }
+        catch (ObjectDisposedException) { }
+    }
+
+    private bool IsAnyFileUpgrading(IReadOnlyCollection<string> fileNames, out IReadOnlyList<string> upgradingFiles)
+    {
+        var upgrading = new List<string>();
+        var entries = DatabaseService.Entries.ToList();
+
+        foreach (var fileName in fileNames)
+        {
+            var entry = entries.FirstOrDefault(
+                e => string.Equals(e.FileName, fileName, StringComparison.OrdinalIgnoreCase));
+
+            if (entry is null) { continue; }
+
+            bool coordinatorSays = Coordinator.IsUpgradeInFlight(fileName);
+            bool bannerSays = GetUpgradeProgressForEntry(entry) is not null;
+
+            if (coordinatorSays || bannerSays) { upgrading.Add(fileName); }
+        }
+
+        upgradingFiles = upgrading;
+
+        return upgrading.Count > 0;
+    }
+
+    private async Task ObserveClassificationCompletionAsync(CancellationToken cancellationToken)
+    {
+        try
+        {
+            await DatabaseService.InitialClassificationTask
+                .WaitAsync(cancellationToken)
+                .ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) { return; }
+        catch (Exception ex)
+        {
+            TraceLogger.Warning(
+                $"{nameof(ManageDatabasesTab)}.{nameof(ObserveClassificationCompletionAsync)}: {ex}");
+        }
+
+        if (_disposed) { return; }
+
+        _initialActiveSnapshot = ComputeActiveSet();
+
+        await InvokeAsyncSafe();
+    }
+
+    private void OnBannerStateChanged()
+    {
+        if (_disposed) { return; }
+
+        _ = InvokeAsyncSafe();
+    }
+
+    private async Task OnBulkRemoveClickAsync()
+    {
+        var snapshot = _selectedForRemoval.ToArray();
+
+        await ConfirmAndRemoveAsync(snapshot, FocusTarget.BulkRemoveButton, FocusTarget.SameRowRemove);
+    }
+
+    private void OnCoordinatorStateChanged()
+    {
+        if (_disposed) { return; }
+
+        _ = InvokeAsyncSafe();
+    }
+
+    private void OnDatabaseEntriesChanged(object? sender, EventArgs e)
+    {
+        if (_disposed) { return; }
+
+        var currentNames = new HashSet<string>(
+            DatabaseService.Entries.Select(entry => entry.FileName),
+            StringComparer.OrdinalIgnoreCase);
+
+        var orphans = _selectedForRemoval.Where(name => !currentNames.Contains(name)).ToArray();
+
+        foreach (var orphan in orphans) { _selectedForRemoval.Remove(orphan); }
+        
+        if (orphans.Length > 0) { UpdateSelectionAnnouncement(); }
+
+        var deadRefs = _removeButtonRefs
+            .Where(kvp => !currentNames.Contains(kvp.Key) || kvp.Value is null)
+            .Select(kvp => kvp.Key)
+            .ToArray();
+        
+        foreach (var key in deadRefs) { _removeButtonRefs.Remove(key); }
+
+        _ = InvokeAsyncSafe();
+    }
+
+    private async Task OnSaveClickAsync()
+    {
+        if (IsUpgradeBlocked)
+        {
+            AnnouncementService.Announce("Cannot save: a database upgrade is in progress.");
+
+            return;
+        }
+
+        await ApplyPendingTogglesAsync();
+    }
+
+    private void OnUpgradeBatchCompleted(object? sender, UpgradeBatchCompletedEventArgs args)
+    {
+        if (_disposed) { return; }
+
+        if (args.Result.Succeeded.Count > 0)
+        {
+            var activeNow = ComputeActiveSet();
+
+            if (args.Result.Succeeded.Any(activeNow.Contains))
+            {
+                _schemaUpgradeOccurred = true;
+            }
+        }
+
+        _ = InvokeAsyncSafe();
+    }
+
+    private async Task RemoveDatabase(DatabaseEntry entry) =>
+        await ConfirmAndRemoveAsync([entry.FileName], FocusTarget.SameRowRemove, FocusTarget.SameRowRemove);
+
+    private async Task RemoveDatabasesAsync(IReadOnlyList<string> fileNames, FocusTarget completeTarget)
+    {
+        var preRemovalEntries = DatabaseService.Entries.ToList();
+
+        int anchorIdx = fileNames
+            .Select(f => preRemovalEntries.FindIndex(e =>
+                string.Equals(e.FileName, f, StringComparison.OrdinalIgnoreCase)))
+            .Where(i => i >= 0)
+            .DefaultIfEmpty(-1)
+            .Min();
+
+        var succeeded = new List<string>();
+        var failed = new List<(string FileName, string Reason)>();
+        bool anyLogsReopened = false;
+
+        foreach (var fileName in fileNames)
+        {
+            try
+            {
+                var outcome = await Coordinator.RemoveDatabaseAsync(
+                    fileName,
+                    static (_, _) => Task.FromResult(true));
+
+                if (outcome.Removed)
+                {
+                    succeeded.Add(fileName);
+                    _pendingToggles.Remove(fileName);
+
+                    if (outcome.LogsReopened) { anyLogsReopened = true; }
+                }
+                else if (outcome.Confirmed)
+                {
+                    failed.Add((fileName, "removal failed after confirmation"));
+                    TraceLogger.Warning(
+                        $"{nameof(ManageDatabasesTab)}.{nameof(RemoveDatabasesAsync)}: removal of '{fileName}' was confirmed but did not complete.");
+                }
+            }
+            catch (Exception ex) when (ex is not OperationCanceledException)
+            {
+                failed.Add((fileName, ex.Message));
+                TraceLogger.Warning(
+                    $"{nameof(ManageDatabasesTab)}.{nameof(RemoveDatabasesAsync)}: removal of '{fileName}' threw: {ex}");
+            }
+        }
+
+        foreach (var fileName in fileNames)
+        {
+            _selectedForRemoval.Remove(fileName);
+        }
+        UpdateSelectionAnnouncement();
+
+        if (anyLogsReopened)
+        {
+            ConsumeReopenedAsBaseline();
+        }
+
+        if (succeeded.Count > 0)
+        {
+            AnnouncementService.Announce(
+                $"Removed {succeeded.Count} database{(succeeded.Count == 1 ? "" : "s")}.");
+        }
+
+        if (failed.Count > 0)
+        {
+            var (firstFailedFile, firstFailedReason) = failed[0];
+            AnnouncementService.Announce(
+                $"{failed.Count} removal{(failed.Count == 1 ? "" : "s")} failed. First: {firstFailedFile} ({firstFailedReason}).");
+        }
+
+        var remainingEntries = DatabaseService.Entries.ToList();
+
+        if (remainingEntries.Count == 0)
+        {
+            _focusRestorationTarget = (string.Empty, FocusTarget.ImportButton);
+        }
+        else
+        {
+            int clampedIdx = Math.Clamp(anchorIdx, 0, remainingEntries.Count - 1);
+            string anchorFileName = remainingEntries[clampedIdx].FileName;
+            _focusRestorationTarget = (anchorFileName, completeTarget);
+        }
+    }
+
+    private async Task RestoreFromBackup(DatabaseEntry entry)
+    {
+        if (_disposed) { return; }
+
+        if (IsUpgradeBlocked)
+        {
+            AnnouncementService.Announce("Cannot restore: a database upgrade is in progress.");
+
+            return;
+        }
+
+        bool restored;
+
+        try
+        {
+            restored = await DatabaseService.RestoreFromBackupAsync(entry.FileName, CancellationToken.None);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            TraceLogger.Warning(
+                $"{nameof(ManageDatabasesTab)}.{nameof(RestoreFromBackup)} failed for '{entry.FileName}': {ex}");
+            AnnouncementService.Announce($"Could not restore {entry.FileName} from backup.");
+
+            return;
+        }
+
+        if (_disposed) { return; }
+
+        if (restored)
+        {
+            _restorationOccurred = true;
+            AnnouncementService.Announce($"Restored {entry.FileName} from backup.");
+        }
+        else
+        {
+            AnnouncementService.Announce($"Could not restore {entry.FileName} from backup.");
+        }
+    }
+
+    private async Task RetryClassification(DatabaseEntry entry)
+    {
+        if (_disposed) { return; }
+
+        try
+        {
+            await DatabaseService.RetryClassificationAsync(entry.FileName, CancellationToken.None);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            TraceLogger.Warning(
+                $"{nameof(ManageDatabasesTab)}.{nameof(RetryClassification)} failed for '{entry.FileName}': {ex}");
+        }
+    }
+
+    private void ToggleDatabase(string fileName)
+    {
+        var entry = DatabaseService.Entries.FirstOrDefault(e =>
+            string.Equals(e.FileName, fileName, StringComparison.OrdinalIgnoreCase));
+
+        if (entry is null) { return; }
+
+        var newValue = !GetEffectiveEnabled(entry);
+
+        if (newValue == entry.IsEnabled)
+        {
+            _pendingToggles.Remove(fileName);
+        }
+        else
+        {
+            _pendingToggles[fileName] = newValue;
+        }
+    }
+
+    private void ToggleSelection(string fileName)
+    {
+        bool added = _selectedForRemoval.Add(fileName);
+
+        if (!added) { _selectedForRemoval.Remove(fileName); }
+
+        UpdateSelectionAnnouncement();
+    }
+
+    private void UpdateSelectionAnnouncement()
+    {
+        int count = _selectedForRemoval.Count;
+        _selectionAnnouncement = count == 0
+            ? "Selection cleared."
+            : $"{count} database{(count == 1 ? "" : "s")} selected.";
+    }
+
+    private async Task UpgradeEntry(string fileName)
+    {
+        await Coordinator.UpgradeDatabaseAsync(fileName);
+
+        if (_disposed) { return; }
+
+        await InvokeAsyncSafe();
+    }
+}
diff --git a/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesTab.razor.css b/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesTab.razor.css
new file mode 100644
index 00000000..6c1ed51f
--- /dev/null
+++ b/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesTab.razor.css
@@ -0,0 +1,88 @@
+.manage-databases-tab {
+    display: flex;
+    flex-direction: column;
+
+    height: 100%;
+    min-height: 0;
+    padding: 0;
+}
+
+.manage-databases-import-row {
+    flex: none;
+    display: flex;
+    justify-content: flex-end;
+    padding: .5rem 1rem;
+}
+
+.manage-databases-entries {
+    flex: 1 1 auto;
+    overflow-y: auto;
+    min-height: 0;
+    padding: 0 .5rem;
+}
+
+.manage-databases-save-strip {
+    flex: none;
+    position: sticky;
+    bottom: 0;
+    z-index: 1;
+
+    display: flex;
+    gap: .5rem;
+    align-items: center;
+    padding: .5rem 1rem;
+
+    background-color: var(--clr-statusbar);
+    color: var(--text-on-statusbar);
+    box-shadow: 0 -1px 0 var(--clr-border);
+}
+
+.manage-databases-pending-count {
+    flex: 1 1 auto;
+}
+
+.manage-databases-bulk-strip {
+    flex: none;
+    position: sticky;
+    bottom: 0;
+    z-index: 1;
+
+    display: flex;
+    gap: .5rem;
+    align-items: center;
+    padding: .5rem 1rem;
+
+    background-color: var(--clr-statusbar);
+    color: var(--text-on-statusbar);
+    box-shadow: 0 -1px 0 var(--clr-border);
+
+    animation: manage-databases-bulk-strip-fade-in 200ms ease-out;
+}
+
+.manage-databases-bulk-count {
+    flex: 1 1 auto;
+    font-size: .9rem;
+}
+
+@keyframes manage-databases-bulk-strip-fade-in {
+    from { opacity: 0; transform: translateY(8px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+@media (prefers-reduced-motion: reduce) {
+    .manage-databases-bulk-strip {
+        animation: none;
+    }
+}
+
+.visually-hidden {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border: 0;
+}
diff --git a/src/EventLogExpert.UI/FilterEditor/FilterComparisonEditor.razor b/src/EventLogExpert.UI/FilterEditor/FilterComparisonEditor.razor
index 2c8516d9..f3739ebe 100644
--- a/src/EventLogExpert.UI/FilterEditor/FilterComparisonEditor.razor
+++ b/src/EventLogExpert.UI/FilterEditor/FilterComparisonEditor.razor
@@ -20,7 +20,7 @@
 <label aria-label="Value" id="@($"{Id}_Value")">Value: </label>
 @if (IsTextOnlyProperty(Comparison.Property))
 {
-    <TextInput CssClass="input filter-description" @bind-Value="@Comparison.Value" />
+    <TextInput AriaLabelledBy="@($"{Id}_Value")" CssClass="input filter-description" @bind-Value="@Comparison.Value" />
 }
 else if (Comparison.MatchMode == MatchMode.Many)
 {
diff --git a/src/EventLogExpert.UI/FilterEditor/FilterRowChrome.razor b/src/EventLogExpert.UI/FilterEditor/FilterRowChrome.razor
index a5b51feb..2048f04d 100644
--- a/src/EventLogExpert.UI/FilterEditor/FilterRowChrome.razor
+++ b/src/EventLogExpert.UI/FilterEditor/FilterRowChrome.razor
@@ -30,10 +30,10 @@ else
                     if (!Filter.IsExcluded)
                     {
                         <ValueSelect AriaLabel="Highlight Color"
+                            @bind-Value="Filter.Color"
                             CssClass="input color-dropdown"
                             DataHighlight="@Filter.Color.ToCssName()"
-                            T="HighlightColor"
-                            @bind-Value="Filter.Color">
+                            T="HighlightColor">
                             @foreach (var item in Enum.GetValues<HighlightColor>())
                             {
                                 <ValueSelectItem CssClass="color-dropdown-item"
@@ -50,7 +50,7 @@ else
                 {
                     if (string.IsNullOrWhiteSpace(savedFilter.ComparisonText))
                     {
-                        <span>No Filter Specified</span>
+                        <span id="@_filterLabelId">No Filter Specified</span>
                     }
                     else
                     {
@@ -61,11 +61,11 @@ else
 
                         if (savedFilter.IsExcluded)
                         {
-                            <span>Exclude: @savedFilter.ComparisonText</span>
+                            <span id="@_filterLabelId">Exclude: @savedFilter.ComparisonText</span>
                         }
                         else
                         {
-                            <span>@savedFilter.ComparisonText</span>
+                            <span id="@_filterLabelId">@savedFilter.ComparisonText</span>
                         }
                     }
                 }
@@ -76,58 +76,50 @@ else
                 {
                     @ExtraEditingButtons
 
-                    <button class="button button-green" @onclick="OnSave">
+                    <button class="button button-green" @onclick="OnSave" type="button">
                         <i class="bi bi-check-circle"></i> Save
                     </button>
 
-                    <button class="button button-red fixed-width" @onclick="OnCancel">
+                    <button class="button button-red fixed-width" @onclick="OnCancel" type="button">
                         <i class="bi bi-x-circle"></i> Cancel
                     </button>
 
                     @if (!IsPending)
                     {
-                        <button class="button button-red fixed-width" @onclick="OnRemove">
+                        <button class="button button-red fixed-width" @onclick="OnRemove" type="button">
                             <i class="bi bi-dash-circle"></i> Remove
                         </button>
                     }
                 }
                 else if (Value is { } savedFilter)
                 {
-                    <button class="button" @onclick="OnEdit">
+                    <button class="button" @onclick="OnEdit" type="button">
                         <i class="bi bi-funnel"></i> Edit
                     </button>
 
                     @if (savedFilter.IsExcluded)
                     {
-                        <button class="button fixed-width" @onclick="OnToggleExclusion">
+                        <button class="button fixed-width" @onclick="OnToggleExclusion" type="button">
                             <i class="bi bi-plus-circle"></i> Include
                         </button>
                     }
                     else
                     {
-                        <button class="button fixed-width" @onclick="OnToggleExclusion">
+                        <button class="button fixed-width" @onclick="OnToggleExclusion" type="button">
                             <i class="bi bi-dash-circle"></i> Exclude
                         </button>
                     }
 
-                    <button class="button button-red fixed-width" @onclick="OnRemove">
+                    <button class="button button-red fixed-width" @onclick="OnRemove" type="button">
                         <i class="bi bi-dash-circle"></i> Remove
                     </button>
 
                     @if (ShowToggleEnabled)
                     {
-                        if (savedFilter.IsEnabled)
-                        {
-                            <button class="button button-red fixed-width" @onclick="OnToggleEnabled">
-                                <i class="bi bi-dash-circle"></i> Disable
-                            </button>
-                        }
-                        else
-                        {
-                            <button class="button button-green fixed-width" @onclick="OnToggleEnabled">
-                                <i class="bi bi-plus-circle"></i> Enable
-                            </button>
-                        }
+                        <Toggle AriaLabel="Filter enabled"
+                            AriaLabelledBy="@_filterLabelId"
+                            Value="savedFilter.IsEnabled"
+                            ValueChanged="@(_ => OnToggleEnabled.InvokeAsync())" />
                     }
                 }
             </div>
diff --git a/src/EventLogExpert.UI/FilterEditor/FilterRowChrome.razor.cs b/src/EventLogExpert.UI/FilterEditor/FilterRowChrome.razor.cs
index b18d3fcc..ebf2f6f9 100644
--- a/src/EventLogExpert.UI/FilterEditor/FilterRowChrome.razor.cs
+++ b/src/EventLogExpert.UI/FilterEditor/FilterRowChrome.razor.cs
@@ -15,6 +15,8 @@ namespace EventLogExpert.UI.FilterEditor;
 /// </summary>
 public sealed partial class FilterRowChrome : ComponentBase
 {
+    private readonly string _filterLabelId = $"filter-row-label-{Guid.NewGuid():N}";
+
     [Parameter] public RenderFragment? EditingContent { get; set; }
 
     [Parameter] public string? ErrorMessage { get; set; }
diff --git a/src/EventLogExpert.UI/FilterEditor/SubFilterRow.razor b/src/EventLogExpert.UI/FilterEditor/SubFilterRow.razor
index fa269bd4..67eb00c6 100644
--- a/src/EventLogExpert.UI/FilterEditor/SubFilterRow.razor
+++ b/src/EventLogExpert.UI/FilterEditor/SubFilterRow.razor
@@ -2,7 +2,7 @@
 
 <div class="flex-center-aligned-row px-4">
     <div class="flex-align-center">
-        <BooleanSelect AriaLabel="Should Compare" DisabledString="AND" EnabledString="OR" @bind-Value="Value.JoinWithAny" />
+        <OptionSelect AriaLabel="Should Compare" DisabledString="AND" EnabledString="OR" @bind-Value="Value.JoinWithAny" />
 
         <FilterComparisonEditor Comparison="Value.Comparison" Id="@Id" />
     </div>
diff --git a/src/EventLogExpert.UI/Inputs/BooleanSelect.razor b/src/EventLogExpert.UI/Inputs/BooleanSelect.razor
deleted file mode 100644
index e3d11dcf..00000000
--- a/src/EventLogExpert.UI/Inputs/BooleanSelect.razor
+++ /dev/null
@@ -1,9 +0,0 @@
-@inherits InputComponent<bool>
-
-<div aria-label="@AriaLabel" class="toggle" role="radiogroup">
-    <input aria-label="@AriaLabel @DisabledString" checked="@(!Value)" disabled="@Disabled" id="@($"{Id}_false")" name="@Id" @onchange="UpdateValue" type="radio" value="false" />
-    <label data-use-status-colors="@UseStatusColors.ToString().ToLower()" for="@($"{Id}_false")">@DisabledString</label>
-
-    <input aria-label="@AriaLabel @EnabledString" checked="@(Value)" disabled="@Disabled" id="@($"{Id}_true")" name="@Id" @onchange="UpdateValue" type="radio" value="true" />
-    <label data-use-status-colors="@UseStatusColors.ToString().ToLower()" for="@($"{Id}_true")">@EnabledString</label>
-</div>
diff --git a/src/EventLogExpert.UI/Inputs/BooleanSelect.razor.css b/src/EventLogExpert.UI/Inputs/BooleanSelect.razor.css
deleted file mode 100644
index f27e2937..00000000
--- a/src/EventLogExpert.UI/Inputs/BooleanSelect.razor.css
+++ /dev/null
@@ -1,60 +0,0 @@
-.toggle {
-    display: inline-flex;
-    margin-left: 5px;
-    width: fit-content;
-}
-
-.toggle input {
-    position: absolute !important;
-    clip: rect(1px, 1px, 1px, 1px);
-    height: 1px !important;
-    width: 1px !important;
-    border: 0 !important;
-    padding: 0 !important;
-    overflow: hidden;
-}
-
-.toggle label {
-    background-color: var(--background-darkgray);
-    color: var(--clr-lightblue);
-    line-height: 1;
-    text-align: center;
-    user-select: none;
-    padding: 4px 8px;
-    border-top: 1px solid var(--border-divider);
-    border-bottom: 1px solid var(--border-divider);
-    border-left: 1px solid var(--border-divider);
-    transition: background-color 0.1s ease-in-out, color 0.1s ease-in-out;
-    min-width: 4rem;
-    box-sizing: border-box;
-}
-
-.toggle label:last-of-type {
-    border-right: 1px solid var(--border-divider);
-}
-
-.toggle input:checked + label {
-    background-color: var(--clr-lightblue);
-    color: var(--accent-on-fill);
-}
-
-.toggle input:checked + label[data-use-status-colors="true"]:first-of-type {
-    background-color: var(--clr-red);
-    color: var(--clr-on-status-fill);
-}
-
-.toggle input:checked + label[data-use-status-colors="true"]:last-of-type {
-    background-color: var(--clr-green);
-    color: var(--clr-on-status-fill);
-}
-
-.toggle input:focus-visible + label {
-    outline: 2px solid var(--clr-statusbar);
-    outline-offset: -2px;
-}
-
-.toggle input:disabled + label {
-    cursor: not-allowed;
-    opacity: 0.5;
-    pointer-events: none;
-}
diff --git a/src/EventLogExpert.UI/Inputs/Checkbox.razor b/src/EventLogExpert.UI/Inputs/Checkbox.razor
new file mode 100644
index 00000000..efafd1af
--- /dev/null
+++ b/src/EventLogExpert.UI/Inputs/Checkbox.razor
@@ -0,0 +1,15 @@
+@inherits InputComponent<bool>
+
+<label class="checkbox @CssClass" title="@EffectiveAriaLabel">
+    <input aria-describedby="@AriaDescribedBy"
+        aria-label="@EffectiveAriaLabel"
+        aria-labelledby="@AriaLabelledBy"
+        checked="@Value"
+        class="checkbox-input"
+        disabled="@Disabled"
+        @onchange="UpdateValue"
+        type="checkbox" />
+    <span aria-hidden="true" class="checkbox-icon">
+        <i class="bi @(Value ? "bi-check-square-fill" : "bi-square")"></i>
+    </span>
+</label>
diff --git a/src/EventLogExpert.UI/Inputs/Checkbox.razor.cs b/src/EventLogExpert.UI/Inputs/Checkbox.razor.cs
new file mode 100644
index 00000000..4669d4bc
--- /dev/null
+++ b/src/EventLogExpert.UI/Inputs/Checkbox.razor.cs
@@ -0,0 +1,20 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Microsoft.AspNetCore.Components;
+
+namespace EventLogExpert.UI.Inputs;
+
+public sealed partial class Checkbox : InputComponent<bool>
+{
+    [Parameter] public bool Disabled { get; set; }
+
+    private async Task UpdateValue(ChangeEventArgs args)
+    {
+        if (args.Value is not bool value) { return; }
+        if (Disabled) { return; }
+
+        Value = value;
+        await ValueChanged.InvokeAsync(Value);
+    }
+}
diff --git a/src/EventLogExpert.UI/Inputs/Checkbox.razor.css b/src/EventLogExpert.UI/Inputs/Checkbox.razor.css
new file mode 100644
index 00000000..bc1bfeeb
--- /dev/null
+++ b/src/EventLogExpert.UI/Inputs/Checkbox.razor.css
@@ -0,0 +1,60 @@
+.checkbox {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-width: 1.75rem;
+    min-height: 1.75rem;
+    padding: .25rem;
+
+    cursor: pointer;
+    user-select: none;
+}
+
+.checkbox-input {
+    position: absolute !important;
+    width: 1px !important;
+    height: 1px !important;
+    margin: -1px;
+    padding: 0;
+    border: 0;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+}
+
+.checkbox-icon {
+    color: var(--text-secondary);
+    transition: color 150ms ease;
+}
+
+.checkbox-icon i {
+    font-size: 1rem;
+}
+
+.checkbox-input:checked + .checkbox-icon {
+    color: var(--clr-lightblue);
+}
+
+.checkbox-input:focus-visible + .checkbox-icon {
+    outline: 2px solid var(--clr-lightblue);
+    outline-offset: 2px;
+    border-radius: 2px;
+}
+
+.checkbox-input:disabled + .checkbox-icon {
+    opacity: 0.5;
+}
+
+.checkbox-input:disabled ~ * {
+    pointer-events: none;
+}
+
+.checkbox:has(.checkbox-input:disabled) {
+    cursor: not-allowed;
+}
+
+@media (prefers-reduced-motion: reduce) {
+    .checkbox-icon {
+        transition: none;
+    }
+}
diff --git a/src/EventLogExpert.UI/Inputs/InputComponent.cs b/src/EventLogExpert.UI/Inputs/InputComponent.cs
index 90166b64..676fd096 100644
--- a/src/EventLogExpert.UI/Inputs/InputComponent.cs
+++ b/src/EventLogExpert.UI/Inputs/InputComponent.cs
@@ -10,6 +10,12 @@ public abstract class InputComponent<T> : ComponentBase
 {
     private Func<T?, string> _toStringFunc = x => x?.ToString() ?? string.Empty;
 
+    [Parameter] public string? AriaDescribedBy { get; set; }
+
+    [Parameter] public string? AriaLabel { get; set; }
+
+    [Parameter] public string? AriaLabelledBy { get; set; }
+
     [Parameter]
     public string CssClass { get; set; } = string.Empty;
 
@@ -38,8 +44,11 @@ public abstract class InputComponent<T> : ComponentBase
     public EventCallback<T> ValueChanged { get; set; }
 
     [Parameter]
-    public List<T> Values { get; set; } = default!;
+    public List<T> Values { get; set; } = null!;
 
     [Parameter]
     public EventCallback<List<T>> ValuesChanged { get; set; }
+
+    protected string? EffectiveAriaLabel =>
+        string.IsNullOrWhiteSpace(AriaLabelledBy) ? AriaLabel : null;
 }
diff --git a/src/EventLogExpert.UI/Inputs/OptionSelect.razor b/src/EventLogExpert.UI/Inputs/OptionSelect.razor
new file mode 100644
index 00000000..7715e0b4
--- /dev/null
+++ b/src/EventLogExpert.UI/Inputs/OptionSelect.razor
@@ -0,0 +1,27 @@
+@inherits InputComponent<bool>
+
+<div aria-describedby="@AriaDescribedBy"
+    aria-label="@EffectiveAriaLabel"
+    aria-labelledby="@AriaLabelledBy"
+    class="option-select @CssClass"
+    role="radiogroup">
+    <input aria-label="@OptionAriaLabel(DisabledString)"
+        checked="@(!Value)"
+        disabled="@Disabled"
+        id="@($"{Id}_false")"
+        name="@Id"
+        @onchange="UpdateValue"
+        type="radio"
+        value="false" />
+    <label data-use-status-colors="@UseStatusColors.ToString().ToLower()" for="@($"{Id}_false")">@DisabledString</label>
+
+    <input aria-label="@OptionAriaLabel(EnabledString)"
+        checked="@(Value)"
+        disabled="@Disabled"
+        id="@($"{Id}_true")"
+        name="@Id"
+        @onchange="UpdateValue"
+        type="radio"
+        value="true" />
+    <label data-use-status-colors="@UseStatusColors.ToString().ToLower()" for="@($"{Id}_true")">@EnabledString</label>
+</div>
diff --git a/src/EventLogExpert.UI/Inputs/BooleanSelect.razor.cs b/src/EventLogExpert.UI/Inputs/OptionSelect.razor.cs
similarity index 75%
rename from src/EventLogExpert.UI/Inputs/BooleanSelect.razor.cs
rename to src/EventLogExpert.UI/Inputs/OptionSelect.razor.cs
index 89949450..1ab845af 100644
--- a/src/EventLogExpert.UI/Inputs/BooleanSelect.razor.cs
+++ b/src/EventLogExpert.UI/Inputs/OptionSelect.razor.cs
@@ -5,10 +5,8 @@
 
 namespace EventLogExpert.UI.Inputs;
 
-public sealed partial class BooleanSelect : InputComponent<bool>
+public sealed partial class OptionSelect : InputComponent<bool>
 {
-    [Parameter] public string AriaLabel { get; set; } = string.Empty;
-
     [Parameter] public bool Disabled { get; set; }
 
     [Parameter] public string DisabledString { get; set; } = "Disabled";
@@ -19,6 +17,9 @@ public sealed partial class BooleanSelect : InputComponent<bool>
 
     [Parameter] public bool UseStatusColors { get; set; }
 
+    private string OptionAriaLabel(string optionText) =>
+        string.IsNullOrWhiteSpace(EffectiveAriaLabel) ? optionText : $"{EffectiveAriaLabel} {optionText}";
+
     private async Task UpdateValue(ChangeEventArgs args)
     {
         if (!bool.TryParse(args.Value?.ToString(), out bool value)) { return; }
diff --git a/src/EventLogExpert.UI/Inputs/OptionSelect.razor.css b/src/EventLogExpert.UI/Inputs/OptionSelect.razor.css
new file mode 100644
index 00000000..20a46ca5
--- /dev/null
+++ b/src/EventLogExpert.UI/Inputs/OptionSelect.razor.css
@@ -0,0 +1,95 @@
+.option-select {
+    display: inline-flex;
+    margin-left: 5px;
+    width: fit-content;
+}
+
+.option-select input {
+    position: absolute !important;
+    clip: rect(1px, 1px, 1px, 1px);
+    height: 1px !important;
+    width: 1px !important;
+    border: 0 !important;
+    padding: 0 !important;
+    overflow: hidden;
+}
+
+.option-select label {
+    background-color: var(--background-darkgray);
+    color: var(--toggle-accent);
+    line-height: 1;
+    text-align: center;
+    user-select: none;
+
+    /* WCAG 2.5.5 AA: 24px minimum hit target. 5px padding + 14px line-height (10pt
+       font) + 1px border-top/bottom = 25px label cell. */
+    padding: 5px 10px;
+    min-height: 24px;
+    box-sizing: border-box;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+
+    border-top: 1px solid var(--border-divider);
+    border-bottom: 1px solid var(--border-divider);
+    border-left: 1px solid var(--border-divider);
+    transition: background-color 0.1s ease-in-out, color 0.1s ease-in-out,
+        border-color 0.1s ease-in-out;
+    min-width: 4rem;
+}
+
+.option-select label:last-of-type {
+    border-right: 1px solid var(--border-divider);
+}
+
+/* Do not change font-weight on selected state -- bold text causes the label to
+   optically reflow (different kerning width), which shifts adjacent borders by
+   ~1px and breaks center-line alignment between Normal/Verbose-style pairs. */
+.option-select input:checked + label {
+    border-color: var(--toggle-accent);
+    color: var(--toggle-accent);
+}
+
+/* Center-line consistency: when the FIRST label is selected, recolor the SECOND
+   label's border-left to match the accent so the dividing line is one continuous
+   color. (Second-selected case is handled by the rule above since that label
+   owns the divider via its border-left.) */
+.option-select input:checked + label + input + label {
+    border-left-color: var(--toggle-accent);
+}
+
+/* UseStatusColors variant: solid red/green fill for destructive flips
+   (DatabaseEntryRow enable/disable). */
+.option-select input:checked + label[data-use-status-colors="true"]:first-of-type {
+    background-color: var(--clr-red);
+    color: var(--clr-on-status-fill);
+    border-color: var(--clr-red);
+}
+
+.option-select input:checked + label[data-use-status-colors="true"]:last-of-type {
+    background-color: var(--clr-green);
+    color: var(--clr-on-status-fill);
+    border-color: var(--clr-green);
+}
+
+/* Status-colors variant center-line: recolor the second label's border-left to
+   red when the first label (red) is selected. */
+.option-select input:checked + label[data-use-status-colors="true"]:first-of-type + input + label {
+    border-left-color: var(--clr-red);
+}
+
+/* WCAG 2.4.7 / 2.4.11 Focus Appearance: two-tone ring (accent outline + dark
+   box-shadow separator). z-index lifts the focused label above sibling borders. */
+.option-select input:focus-visible + label {
+    position: relative;
+    z-index: 2;
+    outline: 2px solid var(--toggle-accent);
+    outline-offset: 1px;
+    box-shadow: 0 0 0 3px var(--background-dark);
+}
+
+.option-select input:disabled + label {
+    cursor: not-allowed;
+    opacity: 0.5;
+    pointer-events: none;
+}
\ No newline at end of file
diff --git a/src/EventLogExpert.UI/Inputs/TextInput.razor b/src/EventLogExpert.UI/Inputs/TextInput.razor
index ccf6cdbe..9ef7769e 100644
--- a/src/EventLogExpert.UI/Inputs/TextInput.razor
+++ b/src/EventLogExpert.UI/Inputs/TextInput.razor
@@ -1,3 +1,9 @@
 @inherits InputComponent<string>
 
-<input class="@CssClass" @onchange="UpdateValue" type="text" value="@Value" />
+<input aria-describedby="@AriaDescribedBy"
+    aria-label="@EffectiveAriaLabel"
+    aria-labelledby="@AriaLabelledBy"
+    class="@CssClass"
+    @onchange="UpdateValue"
+    type="text"
+    value="@Value" />
diff --git a/src/EventLogExpert.UI/Inputs/Toggle.razor b/src/EventLogExpert.UI/Inputs/Toggle.razor
new file mode 100644
index 00000000..31bf63c2
--- /dev/null
+++ b/src/EventLogExpert.UI/Inputs/Toggle.razor
@@ -0,0 +1,17 @@
+@inherits InputComponent<bool>
+
+<label class="toggle @CssClass" title="@EffectiveAriaLabel">
+    <input aria-describedby="@AriaDescribedBy"
+        aria-label="@EffectiveAriaLabel"
+        aria-labelledby="@AriaLabelledBy"
+        checked="@Value"
+        class="toggle-input"
+        disabled="@Disabled"
+        id="@Id"
+        @onchange="UpdateValue"
+        role="switch"
+        type="checkbox" />
+    <span aria-hidden="true" class="toggle-track">
+        <span class="toggle-knob"></span>
+    </span>
+</label>
diff --git a/src/EventLogExpert.UI/Inputs/Toggle.razor.cs b/src/EventLogExpert.UI/Inputs/Toggle.razor.cs
new file mode 100644
index 00000000..bd725e68
--- /dev/null
+++ b/src/EventLogExpert.UI/Inputs/Toggle.razor.cs
@@ -0,0 +1,21 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Microsoft.AspNetCore.Components;
+
+namespace EventLogExpert.UI.Inputs;
+
+public sealed partial class Toggle : InputComponent<bool>
+{
+    [Parameter] public bool Disabled { get; set; }
+
+    [Parameter] public string Id { get; set; } = Guid.NewGuid().ToString();
+
+    private async Task UpdateValue(ChangeEventArgs args)
+    {
+        if (args.Value is not bool value) { return; }
+
+        Value = value;
+        await ValueChanged.InvokeAsync(Value);
+    }
+}
diff --git a/src/EventLogExpert.UI/Inputs/Toggle.razor.css b/src/EventLogExpert.UI/Inputs/Toggle.razor.css
new file mode 100644
index 00000000..784c80d6
--- /dev/null
+++ b/src/EventLogExpert.UI/Inputs/Toggle.razor.css
@@ -0,0 +1,85 @@
+.toggle {
+    /* WCAG 2.5.5 AA: 24x24px minimum hit target (visible track is 36x18). */
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-height: 24px;
+    padding: 4px;
+
+    cursor: pointer;
+    user-select: none;
+}
+
+.toggle-input {
+    /* Visually hidden but focusable native checkbox; keeps Space-to-toggle, focus,
+       and form participation. */
+    position: absolute !important;
+    width: 1px !important;
+    height: 1px !important;
+    margin: -1px;
+    padding: 0;
+    border: 0;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+}
+
+/* Track: 36x18 border-box (1px borders included); inner box = 34x16. */
+.toggle-track {
+    box-sizing: border-box;
+    position: relative;
+
+    display: inline-block;
+    width: 36px;
+    height: 18px;
+
+    background-color: var(--background-darkgray);
+    border: 1px solid var(--border-divider);
+    border-radius: 9px;
+    transition: background-color 0.15s ease, border-color 0.15s ease;
+}
+
+/* Knob: 14x14, translateX(18px) when checked = symmetric 2px gaps inside the 34x16 inner area. */
+.toggle-knob {
+    position: absolute;
+    top: 1px;
+    left: 1px;
+
+    width: 14px;
+    height: 14px;
+
+    background-color: var(--toggle-accent);
+    border-radius: 50%;
+    transition: transform 0.15s ease, background-color 0.15s ease;
+}
+
+.toggle-input:checked + .toggle-track {
+    background-color: var(--toggle-accent);
+    border-color: var(--toggle-accent);
+}
+
+.toggle-input:checked + .toggle-track .toggle-knob {
+    transform: translateX(18px);
+    background-color: var(--accent-on-fill);
+}
+
+/* WCAG 2.4.7 / 2.4.11 Focus Appearance: two-tone ring (accent outline + dark
+   box-shadow separator). */
+.toggle-input:focus-visible + .toggle-track {
+    outline: 2px solid var(--toggle-accent);
+    outline-offset: 2px;
+    box-shadow: 0 0 0 4px var(--background-dark);
+}
+
+.toggle-input:disabled + .toggle-track {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.toggle-input:disabled ~ * {
+    pointer-events: none;
+}
+
+.toggle:has(.toggle-input:disabled) {
+    cursor: not-allowed;
+}
\ No newline at end of file
diff --git a/src/EventLogExpert.UI/Inputs/ValueSelect.razor b/src/EventLogExpert.UI/Inputs/ValueSelect.razor
index a52eb266..9f275fd6 100644
--- a/src/EventLogExpert.UI/Inputs/ValueSelect.razor
+++ b/src/EventLogExpert.UI/Inputs/ValueSelect.razor
@@ -7,10 +7,11 @@
         aria-describedby="@AriaDescribedBy"
         aria-expanded="@(_isOpen ? "true" : "false")"
         aria-haspopup="listbox"
-        aria-label="@(string.IsNullOrWhiteSpace(AriaLabelledBy) ? AriaLabel : null)"
+        aria-label="@EffectiveAriaLabel"
         aria-labelledby="@AriaLabelledBy"
         class="@CssClass"
         data-highlight="@DataHighlight"
+        id="@Id"
         @oninput="OnInputChange"
         readonly="@(!IsInput || IsMultiSelect)"
         role="combobox"
diff --git a/src/EventLogExpert.UI/Inputs/ValueSelect.razor.cs b/src/EventLogExpert.UI/Inputs/ValueSelect.razor.cs
index 2545ea5c..9f393e5a 100644
--- a/src/EventLogExpert.UI/Inputs/ValueSelect.razor.cs
+++ b/src/EventLogExpert.UI/Inputs/ValueSelect.razor.cs
@@ -20,12 +20,6 @@ public sealed partial class ValueSelect<T> : InputComponent<T>, IAsyncDisposable
     private ElementReference _selectComponent;
     private DotNetObjectReference<ValueSelect<T>>? _selfRef;
 
-    [Parameter] public string? AriaDescribedBy { get; set; }
-
-    [Parameter] public string? AriaLabel { get; set; }
-
-    [Parameter] public string? AriaLabelledBy { get; set; }
-
     [Parameter]
     public RenderFragment ChildContent { get; set; } = null!;
 
@@ -53,6 +47,8 @@ public ValueSelectItem<T>? HighlightedItem
         }
     }
 
+    [Parameter] public string? Id { get; set; }
+
     [Parameter]
     public bool IsInput { get; set; }
 
diff --git a/src/EventLogExpert.UI/Menu/MenuBar.razor.cs b/src/EventLogExpert.UI/Menu/MenuBar.razor.cs
index f57ed1fb..976cefb2 100644
--- a/src/EventLogExpert.UI/Menu/MenuBar.razor.cs
+++ b/src/EventLogExpert.UI/Menu/MenuBar.razor.cs
@@ -194,7 +194,7 @@ private IReadOnlyList<MenuItem> BuildOtherLogsTree(IReadOnlyList<string> logName
 
     private IReadOnlyList<MenuItem> BuildTools() =>
     [
-        MenuItem.Item("Database Tools…", () => Actions.OpenDatabaseToolsAsync()),
+        MenuItem.Item("Databases…", () => Actions.OpenDatabaseToolsAsync()),
         MenuItem.Separator(),
         MenuItem.Item("Settings", () => Actions.OpenSettingsAsync()),
     ];
diff --git a/src/EventLogExpert.UI/Modal/ModalChrome.razor b/src/EventLogExpert.UI/Modal/ModalChrome.razor
index 25b47207..c83e89e2 100644
--- a/src/EventLogExpert.UI/Modal/ModalChrome.razor
+++ b/src/EventLogExpert.UI/Modal/ModalChrome.razor
@@ -10,6 +10,10 @@
     @ref="_dialogRef"
     style="@DialogInlineStyle">
     <div class="dialog-group">
+        <div class="banner-region" inert="@HasInlineAlert">
+            <BannerHost Location="BannerHostLocation.InsideModal" />
+        </div>
+
         @if (!string.IsNullOrEmpty(Title))
         {
             <header class="dialog-header" inert="@HasInlineAlert">
@@ -60,8 +64,7 @@
                             type="button">
                             @SaveLabel
                         </button>
-                        <button autofocus
-                            class="button"
+                        <button class="button"
                             disabled="@(HasInlineAlert || FooterDisabled)"
                             @onclick="HandleCancelButtonAsync"
                             type="button">
diff --git a/src/EventLogExpert.UI/Modal/ModalChrome.razor.cs b/src/EventLogExpert.UI/Modal/ModalChrome.razor.cs
index 96bb8b60..d07f55d2 100644
--- a/src/EventLogExpert.UI/Modal/ModalChrome.razor.cs
+++ b/src/EventLogExpert.UI/Modal/ModalChrome.razor.cs
@@ -2,6 +2,7 @@
 // // Licensed under the MIT License.
 
 using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.UI.Banner;
 using Microsoft.AspNetCore.Components;
 using Microsoft.JSInterop;
 
@@ -84,6 +85,8 @@ public sealed partial class ModalChrome : ComponentBase, IAsyncDisposable
 
     [Parameter] public string? Title { get; set; }
 
+    [Inject] private IBannerCycleStateService CycleState { get; init; } = null!;
+
     private string? DialogInlineStyle
     {
         get
@@ -120,7 +123,11 @@ public async Task CloseAsync()
         }
     }
 
-    public async ValueTask DisposeAsync() => await CloseAsync();
+    public async ValueTask DisposeAsync()
+    {
+        CycleState.SetModalContentDisplayed(false);
+        await CloseAsync();
+    }
 
     protected override async Task OnAfterRenderAsync(bool firstRender)
     {
@@ -129,6 +136,11 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
             try
             {
                 await JSRuntime.InvokeVoidAsync("showModal", _dialogRef);
+
+                if (!_isClosed)
+                {
+                    CycleState.SetModalContentDisplayed(true);
+                }
             }
             catch
             {
diff --git a/src/EventLogExpert.UI/Modal/ModalChrome.razor.css b/src/EventLogExpert.UI/Modal/ModalChrome.razor.css
index e1e6cbde..9f4f7b55 100644
--- a/src/EventLogExpert.UI/Modal/ModalChrome.razor.css
+++ b/src/EventLogExpert.UI/Modal/ModalChrome.razor.css
@@ -61,6 +61,7 @@ dialog:not(:modal) {
 .inline-alert-overlay {
     position: absolute;
     inset: 0;
+    z-index: 2;
 
     background-color: var(--overlay-dim);
 }
@@ -70,6 +71,7 @@ dialog:not(:modal) {
     top: 50%;
     left: 50%;
     transform: translate(-50%, -50%);
+    z-index: 3;
 
     display: flex;
     flex-direction: column;
diff --git a/src/EventLogExpert.UI/Settings/SettingsModal.razor b/src/EventLogExpert.UI/Settings/SettingsModal.razor
index 675a86f3..c958d77a 100644
--- a/src/EventLogExpert.UI/Settings/SettingsModal.razor
+++ b/src/EventLogExpert.UI/Settings/SettingsModal.razor
@@ -5,7 +5,6 @@
 <ModalChrome AriaLabel="Settings"
     CancelLabel="Exit"
     Footer="FooterPreset.SaveCancel"
-    FooterDisabled="@IsCloseBlocked"
     Height="60%"
     InlineAlert="@CurrentInlineAlert"
     OnCancel="HandleCancelButtonClickAsync"
@@ -18,11 +17,9 @@
     <ChildContent>
         <div class="settings-form">
             <div class="flex-column-scroll">
-                <SettingsUpgradeProgressBanner />
-
                 <div class="flex-center-aligned-row tz-row">
-                    <text>Time Zone:</text>
-                    <ValueSelect AriaLabel="Time Zone" @bind-Value="_timeZoneId" CssClass="input timezone-dropdown" T="string">
+                    <label for="settings-timezone">Time Zone:</label>
+                    <ValueSelect @bind-Value="_timeZoneId" CssClass="input timezone-dropdown" Id="settings-timezone" T="string">
                         @foreach (var item in TimeZoneInfo.GetSystemTimeZones())
                         {
                             <ValueSelectItem T="string" Value="item.Id">@item.DisplayName</ValueSelectItem>
@@ -30,52 +27,14 @@
                     </ValueSelect>
                 </div>
 
-                <div class="flex-space-between">
-                    <div>Databases:</div>
-
-                    <button class="button" @onclick="ImportDatabase" type="button">
-                        <i aria-hidden="true" class="bi bi-plus-circle"></i> Import Database
-                    </button>
-                </div>
-
-                @if (IsClassificationPending)
-                {
-                    <div class="classification-pending" role="status">
-                        <i aria-hidden="true" class="banner-spinner bi bi-arrow-repeat"></i>
-                        <span>Classifying databases&hellip;</span>
-                    </div>
-                }
-
-                <div class="flex-column-scroll">
-                    @if (DatabaseService.Entries.Count > 0)
-                    {
-                        @foreach (var entry in DatabaseService.Entries)
-                        {
-                            <DatabaseEntryRow EffectiveEnabled="GetEffectiveEnabled(entry)"
-                                Entry="@entry"
-                                IsClassificationPending="@IsClassificationPending"
-                                IsUpgradeBlocked="@(IsAnyUpgradeInFlight && !Coordinator.IsUpgradeInFlight(entry.FileName))"
-                                IsUpgrading="@Coordinator.IsUpgradeInFlight(entry.FileName)"
-                                @key="entry.FileName"
-                                OnRemove="@(() => RemoveDatabase(entry))"
-                                OnToggle="@(() => ToggleDatabase(entry.FileName))"
-                                OnUpgrade="@(() => UpgradeEntry(entry.FileName))" />
-                        }
-                    }
-                    else
-                    {
-                        <p>None</p>
-                    }
-                </div>
-
                 <div class="flex-center-aligned-row">
                     <text>Expand Display Pane On Selection Change:</text>
-                    <BooleanSelect AriaLabel="Expand Display Pane On Selection Change" @bind-Value="_showDisplayPaneOnSelectionChange" />
+                    <Toggle AriaLabel="Expand Display Pane On Selection Change" @bind-Value="_showDisplayPaneOnSelectionChange" />
                 </div>
 
                 <div class="flex-center-aligned-row">
-                    <text>Theme:</text>
-                    <ValueSelect AriaLabel="Theme" @bind-Value="_theme" CssClass="input filter-dropdown" T="Theme">
+                    <label for="settings-theme">Theme:</label>
+                    <ValueSelect @bind-Value="_theme" CssClass="input filter-dropdown" Id="settings-theme" T="Theme">
                         @foreach (Theme item in Enum.GetValues(typeof(Theme)))
                         {
                             <ValueSelectItem T="Theme" Value="item">@(item == Theme.System ? "Follow System" : item.ToString())</ValueSelectItem>
@@ -84,8 +43,8 @@
                 </div>
 
                 <div class="flex-center-aligned-row">
-                    <text>Keyboard Copy Behavior:</text>
-                    <ValueSelect AriaLabel="Keyboard Copy Behavior" @bind-Value="_copyFormat" CssClass="input filter-dropdown" T="EventCopyFormat">
+                    <label for="settings-copy-format">Keyboard Copy Behavior:</label>
+                    <ValueSelect @bind-Value="_copyFormat" CssClass="input filter-dropdown" Id="settings-copy-format" T="EventCopyFormat">
                         @foreach (EventCopyFormat item in Enum.GetValues(typeof(EventCopyFormat)))
                         {
                             <ValueSelectItem T="EventCopyFormat" Value="item" />
@@ -94,8 +53,8 @@
                 </div>
 
                 <div class="flex-center-aligned-row">
-                    <text>Logging Level:</text>
-                    <ValueSelect AriaLabel="Logging Level" @bind-Value="_logLevel" CssClass="input filter-dropdown" T="LogLevel">
+                    <label for="settings-log-level">Logging Level:</label>
+                    <ValueSelect @bind-Value="_logLevel" CssClass="input filter-dropdown" Id="settings-log-level" T="LogLevel">
                         @foreach (LogLevel item in Enum.GetValues(typeof(LogLevel)))
                         {
                             <ValueSelectItem T="LogLevel" Value="item" />
@@ -109,7 +68,7 @@
     <ExtraFooterContent>
         <div class="flex-center-aligned-row">
             <text>Pre-release Builds:</text>
-            <BooleanSelect AriaLabel="Pre-release Builds" @bind-Value="_isPreReleaseEnabled" />
+            <Toggle AriaLabel="Pre-release Builds" @bind-Value="_isPreReleaseEnabled" />
         </div>
     </ExtraFooterContent>
 </ModalChrome>
diff --git a/src/EventLogExpert.UI/Settings/SettingsModal.razor.cs b/src/EventLogExpert.UI/Settings/SettingsModal.razor.cs
index 263991fe..4617faf7 100644
--- a/src/EventLogExpert.UI/Settings/SettingsModal.razor.cs
+++ b/src/EventLogExpert.UI/Settings/SettingsModal.razor.cs
@@ -1,14 +1,9 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Logging.Abstractions;
-using EventLogExpert.Runtime.Alerts;
-using EventLogExpert.Runtime.Banner;
+using EventLogExpert.Runtime.Announcement;
 using EventLogExpert.Runtime.Common.Clipboard;
-using EventLogExpert.Runtime.Database;
 using EventLogExpert.Runtime.DetailsPane;
-using EventLogExpert.Runtime.EventLog;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Settings;
 using EventLogExpert.UI.Modal;
 using Microsoft.AspNetCore.Components;
@@ -18,155 +13,40 @@ namespace EventLogExpert.UI.Settings;
 
 public sealed partial class SettingsModal : ModalBase<bool>
 {
-    private readonly Dictionary<string, bool> _pendingToggles = new(StringComparer.OrdinalIgnoreCase);
-
-    private CancellationTokenSource? _classificationCts;
     private EventCopyFormat _copyFormat;
-    private bool _databaseStateChanged;
-    private volatile bool _disposed;
     private bool _isPreReleaseEnabled;
     private LogLevel _logLevel;
     private bool _showDisplayPaneOnSelectionChange;
     private Theme _theme;
     private string _timeZoneId = string.Empty;
 
-    [Inject] private IDatabaseOperationCoordinator Coordinator { get; init; } = null!;
-
-    [Inject] private IDatabaseService DatabaseService { get; init; } = null!;
+    [Inject] private IAnnouncementService AnnouncementService { get; init; } = null!;
 
     [Inject] private IDetailsPanePreferencesProvider DetailsPanePreferences { get; init; } = null!;
 
-    private bool IsAnyUpgradeInFlight =>
-        Coordinator.IsAnyUpgradeInFlight || ProgressBannerService.SettingsProgress is not null;
-
-    private bool IsClassificationPending => !DatabaseService.InitialClassificationTask.IsCompleted;
-
-    private bool IsCloseBlocked => IsAnyUpgradeInFlight;
-
-    [Inject] private ILogReloadCoordinator LogReloadCoordinator { get; init; } = null!;
-
-    [Inject] private IProgressBannerService ProgressBannerService { get; init; } = null!;
-
     [Inject] private ISettingsService Settings { get; init; } = null!;
 
-    [Inject] private ITraceLogger TraceLogger { get; init; } = null!;
-
-    protected override async ValueTask DisposeAsyncCore(bool disposing)
-    {
-        if (disposing)
-        {
-            _disposed = true;
-            _classificationCts?.CancelAsync();
-            _classificationCts?.Dispose();
-            _classificationCts = null;
-            DatabaseService.EntriesChanged -= OnDatabaseEntriesChanged;
-            ProgressBannerService.StateChanged -= OnBannerStateChanged;
-            Coordinator.UpgradeStateChanged -= OnCoordinatorStateChanged;
-        }
-
-        await base.DisposeAsyncCore(disposing);
-    }
-
-    protected override async Task OnClosingAsync()
-    {
-        if (_databaseStateChanged)
-        {
-            await PromptAndReloadOpenLogs();
-
-            _databaseStateChanged = false;
-        }
-    }
+    /// <summary>
+    ///     Test-only seam. <c>SettingsModalTests</c> invoke this instead of routing through the ModalChrome footer
+    ///     markup, which would couple tests to chrome button class names.
+    /// </summary>
+    internal Task InvokeOnSaveAsyncForTests() => OnSaveAsync();
 
     protected override void OnInitialized()
     {
         LoadFromSettings();
-
-        DatabaseService.EntriesChanged += OnDatabaseEntriesChanged;
-        ProgressBannerService.StateChanged += OnBannerStateChanged;
-        Coordinator.UpgradeStateChanged += OnCoordinatorStateChanged;
-
-        if (!DatabaseService.InitialClassificationTask.IsCompleted)
-        {
-            _classificationCts = new CancellationTokenSource();
-            _ = ObserveClassificationCompletionAsync(_classificationCts.Token);
-        }
-
         base.OnInitialized();
     }
 
-    protected override Task<bool> OnRequestCloseAsync(ModalCloseRequest request) =>
-        Task.FromResult(!IsCloseBlocked);
-
     protected override async Task OnSaveAsync()
     {
-        if (IsCloseBlocked) { return; }
-
-        var snapshot = _pendingToggles.Keys.ToArray();
-        _pendingToggles.Clear();
-
-        await Coordinator.ApplyPendingTogglesAsync(snapshot);
+        SaveSettings();
 
-        if (_disposed) { return; }
-
-        Settings.CopyFormat = _copyFormat;
-        Settings.IsPreReleaseEnabled = _isPreReleaseEnabled;
-        Settings.LogLevel = _logLevel;
-        DetailsPanePreferences.DisplayPaneSelectionPreference = _showDisplayPaneOnSelectionChange;
-        Settings.Theme = _theme;
-        Settings.TimeZoneId = _timeZoneId;
+        AnnouncementService.Announce("Settings saved");
 
         await CompleteAsync(true);
     }
 
-    private async Task<bool> AskOverwriteAsync(string fileName, CancellationToken cancellationToken)
-    {
-        if (_disposed) { return false; }
-
-        try
-        {
-            var result = await ShowInlineAlertAsync(
-                new InlineAlertRequest(
-                    Title: "Database already exists",
-                    Message: $"{fileName} already exists. Overwrite?",
-                    AcceptLabel: "Overwrite",
-                    CancelLabel: "Skip",
-                    IsPrompt: false,
-                    PromptInitialValue: null),
-                cancellationToken);
-
-            return result.Accepted;
-        }
-        catch (ObjectDisposedException) { return false; }
-    }
-
-    private bool GetEffectiveEnabled(DatabaseEntry entry) =>
-        _pendingToggles.TryGetValue(entry.FileName, out var pending) ? pending : entry.IsEnabled;
-
-    private async Task ImportDatabase()
-    {
-        var outcome = await Coordinator.ImportAsync(AskOverwriteAsync);
-
-        if (_disposed) { return; }
-
-        if (outcome.DatabaseStateChanged)
-        {
-            try { await InvokeAsync(OnSaveAsync); }
-            catch (ObjectDisposedException)
-            {
-                // Modal torn down between the _disposed check and the dispatcher call; safe to ignore.
-            }
-        }
-    }
-
-    private async Task InvokeAsyncSafe()
-    {
-        try { await InvokeAsync(StateHasChanged); }
-        catch (ObjectDisposedException)
-        {
-            // Renderer disposed concurrently with this dispatch; safe to ignore during teardown.
-        }
-    }
-
     private void LoadFromSettings()
     {
         _copyFormat = Settings.CopyFormat;
@@ -177,145 +57,13 @@ private void LoadFromSettings()
         _timeZoneId = Settings.TimeZoneId;
     }
 
-    private async Task ObserveClassificationCompletionAsync(CancellationToken cancellationToken)
+    private void SaveSettings()
     {
-        try
-        {
-            await DatabaseService.InitialClassificationTask.WaitAsync(cancellationToken).ConfigureAwait(false);
-        }
-        catch (OperationCanceledException)
-        {
-            return;
-        }
-        catch
-        {
-            // InitialClassificationTask is contractually never-faulting (DatabaseService.cs);
-            // defensive try/catch so a future contract drift cannot orphan this fire-and-forget task.
-        }
-
-        if (_disposed) { return; }
-
-        await InvokeAsyncSafe();
-    }
-
-    private void OnBannerStateChanged() => _ = InvokeAsyncSafe();
-
-    private void OnCoordinatorStateChanged() => _ = InvokeAsyncSafe();
-
-    private void OnDatabaseEntriesChanged(object? sender, EventArgs e)
-    {
-        _databaseStateChanged = true;
-        _ = InvokeAsyncSafe();
-    }
-
-    private async Task PromptAndReloadOpenLogs()
-    {
-        if (!LogReloadCoordinator.HasActiveLogs) { return; }
-
-        if (_disposed) { return; }
-
-        bool yes;
-
-        try
-        {
-            var result = await ShowInlineAlertAsync(
-                new InlineAlertRequest(
-                    Title: "Reload Open Logs Now?",
-                    Message: "In order for these changes to take effect, all currently open logs must be reloaded. " +
-                        "Would you like to reload all open logs now?",
-                    AcceptLabel: "Yes",
-                    CancelLabel: "No",
-                    IsPrompt: false,
-                    PromptInitialValue: null),
-                CancellationToken.None);
-
-            yes = result.Accepted;
-        }
-        catch (ObjectDisposedException) { return; }
-        catch (OperationCanceledException) { return; }
-
-        if (yes)
-        {
-            try { await LogReloadCoordinator.ReloadAllActiveLogsAsync(); }
-            catch (OperationCanceledException) { }
-            catch (TimeoutException ex)
-            {
-                TraceLogger.Warning(
-                    $"{nameof(SettingsModal)}.{nameof(PromptAndReloadOpenLogs)}: reload did not complete within timeout: {ex}");
-            }
-        }
-    }
-
-    private async Task RemoveDatabase(DatabaseEntry entry)
-    {
-        var fileName = entry.FileName;
-
-        var outcome = await Coordinator.RemoveDatabaseAsync(
-            fileName,
-            async (showCloseReopenWarning, cancellationToken) =>
-            {
-                if (_disposed) { return false; }
-
-                var message = showCloseReopenWarning
-                    ? $"{fileName} is currently enabled. Removing will close and reopen any affected log views. Are you sure?"
-                    : $"Are you sure you want to remove {fileName}?";
-
-                try
-                {
-                    var result = await ShowInlineAlertAsync(
-                        new InlineAlertRequest(
-                            Title: "Remove Database",
-                            Message: message,
-                            AcceptLabel: "Remove",
-                            CancelLabel: "Cancel",
-                            IsPrompt: false,
-                            PromptInitialValue: null),
-                        cancellationToken);
-
-                    return result.Accepted;
-                }
-                catch (ObjectDisposedException) { return false; }
-            });
-
-        if (_disposed) { return; }
-
-        if (outcome.Confirmed) { _pendingToggles.Remove(fileName); }
-
-        if (outcome.LogsReopened)
-        {
-            _databaseStateChanged = false;
-        }
-        else if (outcome.Removed)
-        {
-            _databaseStateChanged = true;
-        }
-    }
-
-    private void ToggleDatabase(string fileName)
-    {
-        var entry = DatabaseService.Entries.FirstOrDefault(e =>
-            string.Equals(e.FileName, fileName, StringComparison.OrdinalIgnoreCase));
-
-        if (entry is null) { return; }
-
-        var newValue = !GetEffectiveEnabled(entry);
-
-        if (newValue == entry.IsEnabled)
-        {
-            _pendingToggles.Remove(fileName);
-        }
-        else
-        {
-            _pendingToggles[fileName] = newValue;
-        }
-    }
-
-    private async Task UpgradeEntry(string fileName)
-    {
-        await Coordinator.UpgradeDatabaseAsync(fileName);
-
-        if (_disposed) { return; }
-
-        await InvokeAsyncSafe();
+        Settings.CopyFormat = _copyFormat;
+        Settings.IsPreReleaseEnabled = _isPreReleaseEnabled;
+        Settings.LogLevel = _logLevel;
+        DetailsPanePreferences.DisplayPaneSelectionPreference = _showDisplayPaneOnSelectionChange;
+        Settings.Theme = _theme;
+        Settings.TimeZoneId = _timeZoneId;
     }
 }
diff --git a/src/EventLogExpert.UI/Settings/SettingsModal.razor.css b/src/EventLogExpert.UI/Settings/SettingsModal.razor.css
index cd6e17fa..ee997f7e 100644
--- a/src/EventLogExpert.UI/Settings/SettingsModal.razor.css
+++ b/src/EventLogExpert.UI/Settings/SettingsModal.razor.css
@@ -6,26 +6,11 @@
     height: 100%;
 }
 
-.tz-row { margin-bottom: .5rem; }
-
-.fixed-width { width: 50px; }
-
-.classification-pending {
-    display: flex;
-    align-items: center;
-    gap: .5rem;
-    padding: .25rem .5rem;
-
-    color: var(--clr-lightblue);
-    font-style: italic;
+/* Padding so :focus-visible rings are not clipped by the ancestor overflow-hidden utility. */
+.settings-form > .flex-column-scroll {
+    padding: .5rem;
 }
 
-.classification-pending i {
-    flex: 0 0 auto;
-    animation: classification-spin 1.5s linear infinite;
-}
+.tz-row { margin-bottom: .5rem; }
 
-@keyframes classification-spin {
-    from { transform: rotate(0deg); }
-    to { transform: rotate(360deg); }
-}
+.fixed-width { width: 50px; }
\ No newline at end of file
diff --git a/src/EventLogExpert.UI/Settings/SettingsUpgradeProgressBanner.razor b/src/EventLogExpert.UI/Settings/SettingsUpgradeProgressBanner.razor
deleted file mode 100644
index 9ab5a885..00000000
--- a/src/EventLogExpert.UI/Settings/SettingsUpgradeProgressBanner.razor
+++ /dev/null
@@ -1,26 +0,0 @@
-@if (ProgressBannerService.SettingsProgress is { } progress)
-{
-    <aside class="settings-upgrade-banner" role="status">
-        <i aria-hidden="true" class="banner-spinner bi bi-arrow-repeat"></i>
-
-        @if (string.IsNullOrEmpty(progress.CurrentEntryName))
-        {
-            <span class="banner-message">Preparing upgrade of @progress.CurrentBatchSize @(progress.CurrentBatchSize == 1 ? "database" : "databases")&hellip;</span>
-        }
-        else
-        {
-            <span class="banner-message">Upgrading database @progress.CurrentBatchPosition of @progress.CurrentBatchSize: @progress.CurrentEntryName &mdash; @progress.CurrentPhase</span>
-        }
-
-        @if (progress.QueuedBatchesAfter > 0)
-        {
-            <span class="banner-subtitle">(+@progress.QueuedBatchesAfter @(progress.QueuedBatchesAfter == 1 ? "batch" : "batches") queued)</span>
-        }
-
-        <button class="banner-action button"
-            @onclick="() => OnCancelClickedAsync(progress)"
-            type="button">
-            Cancel
-        </button>
-    </aside>
-}
diff --git a/src/EventLogExpert.UI/Settings/SettingsUpgradeProgressBanner.razor.cs b/src/EventLogExpert.UI/Settings/SettingsUpgradeProgressBanner.razor.cs
deleted file mode 100644
index fe87a447..00000000
--- a/src/EventLogExpert.UI/Settings/SettingsUpgradeProgressBanner.razor.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Logging.Abstractions;
-using EventLogExpert.Runtime.Banner;
-using Microsoft.AspNetCore.Components;
-
-namespace EventLogExpert.UI.Settings;
-
-public sealed partial class SettingsUpgradeProgressBanner : ComponentBase, IDisposable
-{
-    private bool _disposed;
-
-    [Inject] private IProgressBannerService ProgressBannerService { get; init; } = null!;
-
-    [Inject] private ITraceLogger TraceLogger { get; init; } = null!;
-
-    public void Dispose()
-    {
-        if (_disposed) { return; }
-
-        _disposed = true;
-
-        ProgressBannerService.StateChanged -= OnStateChanged;
-    }
-
-    protected override void OnInitialized()
-    {
-        ProgressBannerService.StateChanged += OnStateChanged;
-
-        base.OnInitialized();
-    }
-
-    private async Task OnCancelClickedAsync(BannerProgressEntry entry)
-    {
-        try
-        {
-            entry.Cancel();
-        }
-        catch (Exception ex)
-        {
-            TraceLogger.Error($"{nameof(SettingsUpgradeProgressBanner)}.{nameof(OnCancelClickedAsync)}: cancel threw: {ex}");
-        }
-
-        await Task.CompletedTask;
-    }
-
-    private void OnStateChanged()
-    {
-        if (_disposed) { return; }
-
-        _ = InvokeAsync(StateHasChanged);
-    }
-}
diff --git a/src/EventLogExpert.UI/Settings/SettingsUpgradeProgressBanner.razor.css b/src/EventLogExpert.UI/Settings/SettingsUpgradeProgressBanner.razor.css
deleted file mode 100644
index 08146796..00000000
--- a/src/EventLogExpert.UI/Settings/SettingsUpgradeProgressBanner.razor.css
+++ /dev/null
@@ -1,53 +0,0 @@
-.settings-upgrade-banner {
-    position: sticky;
-    top: 0;
-    z-index: 1;
-
-    display: flex;
-    align-items: center;
-    gap: .75rem;
-    padding: .5rem 1rem;
-    margin-bottom: .5rem;
-
-    background-color: var(--clr-statusbar);
-    color: var(--text-on-statusbar);
-    box-shadow: var(--shadow-modal);
-}
-
-.banner-spinner {
-    flex: 0 0 auto;
-    animation: banner-spin 1.5s linear infinite;
-}
-
-@keyframes banner-spin {
-    from { transform: rotate(0deg); }
-    to { transform: rotate(360deg); }
-}
-
-.banner-message {
-    flex: 1 1 auto;
-    min-width: 0;
-
-    overflow: hidden;
-    white-space: nowrap;
-    text-overflow: ellipsis;
-}
-
-.banner-subtitle {
-    flex: 0 0 auto;
-
-    font-size: .85rem;
-    opacity: .9;
-}
-
-.banner-action {
-    flex: 0 0 auto;
-    padding: .15rem .75rem;
-
-    background: transparent;
-    color: inherit;
-    border: 1px solid currentColor;
-    border-radius: .25rem;
-
-    &:hover { background-color: rgba(255, 255, 255, 0.15); }
-}
diff --git a/src/EventLogExpert.UI/_Imports.razor b/src/EventLogExpert.UI/_Imports.razor
index cda07183..1887cf4b 100644
--- a/src/EventLogExpert.UI/_Imports.razor
+++ b/src/EventLogExpert.UI/_Imports.razor
@@ -23,6 +23,7 @@
 @using EventLogExpert.Runtime.Settings
 
 @* UI (Razor component types) *@
+@using EventLogExpert.UI.Banner
 @using EventLogExpert.UI.Database
 @using EventLogExpert.UI.FilterEditor
 @using EventLogExpert.UI.Inputs
diff --git a/src/EventLogExpert/Adapters/Menu/MauiMenuActionService.cs b/src/EventLogExpert/Adapters/Menu/MauiMenuActionService.cs
index 49ffa97b..92d7bffb 100644
--- a/src/EventLogExpert/Adapters/Menu/MauiMenuActionService.cs
+++ b/src/EventLogExpert/Adapters/Menu/MauiMenuActionService.cs
@@ -140,7 +140,7 @@ public async Task<IReadOnlyList<string>> GetOtherLogNamesAsync()
 
     public void LoadNewEvents() => _eventLogCommands.LoadNewEvents();
 
-    public Task OpenDatabaseToolsAsync() =>
+    public Task<bool> OpenDatabaseToolsAsync() =>
         TryOpenModalAsync(_modalCoordinator.OpenDatabaseToolsAsync, nameof(DatabaseToolsModal));
 
     public Task OpenDocsAsync() =>
diff --git a/src/EventLogExpert/Components/Layout/MainLayout.razor b/src/EventLogExpert/Components/Layout/MainLayout.razor
index 92d50e95..dcbf0500 100644
--- a/src/EventLogExpert/Components/Layout/MainLayout.razor
+++ b/src/EventLogExpert/Components/Layout/MainLayout.razor
@@ -17,4 +17,6 @@
     <footer>
         <StatusBar />
     </footer>
+
+    <AnnouncerHost />
 </div>
diff --git a/src/EventLogExpert/Main.razor b/src/EventLogExpert/Main.razor
index b10dc658..e4f97232 100644
--- a/src/EventLogExpert/Main.razor
+++ b/src/EventLogExpert/Main.razor
@@ -2,7 +2,9 @@
     Application root. The hybrid shell is intentionally non-routed: there are no @page directives anywhere.
     BannerHost lives outside UnhandledExceptionHandler so the error banner survives when child rendering faults.
 *@
-<BannerHost />
+<div class="banner-region">
+    <BannerHost Location="BannerHostLocation.MainLayout" />
+</div>
 
 <UnhandledExceptionHandler>
     <Fluxor.Blazor.Web.StoreInitializer />
diff --git a/src/EventLogExpert/MauiProgram.cs b/src/EventLogExpert/MauiProgram.cs
index 1d2a9f67..9f55d5a9 100644
--- a/src/EventLogExpert/MauiProgram.cs
+++ b/src/EventLogExpert/MauiProgram.cs
@@ -31,6 +31,7 @@
 using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Settings;
 using EventLogExpert.UI.Alerts;
+using EventLogExpert.UI.Banner;
 using EventLogExpert.UI.Database;
 using Fluxor;
 using Fluxor.DependencyInjection;
@@ -103,6 +104,8 @@ public static MauiApp CreateMauiApp()
         builder.Services.AddEventLogFiltering();
         builder.Services.AddEventLogRuntime();
 
+        builder.Services.AddSingleton<IBannerCycleStateService, BannerCycleStateService>();
+
         builder.Services.AddSingleton<IMainThreadService, MauiMainThreadService>();
         builder.Services.AddSingleton<ITitleProvider, TitleProvider>();
         builder.Services.AddSingleton<IClipboardService, ClipboardService>();
diff --git a/src/EventLogExpert/_Imports.razor b/src/EventLogExpert/_Imports.razor
index 6b4d55ad..8d1d77bf 100644
--- a/src/EventLogExpert/_Imports.razor
+++ b/src/EventLogExpert/_Imports.razor
@@ -43,6 +43,7 @@
 @* UI *@
 @using EventLogExpert.UI
 @using EventLogExpert.UI.Alerts
+@using EventLogExpert.UI.Announcement
 @using EventLogExpert.UI.Banner
 @using EventLogExpert.UI.Database
 @using EventLogExpert.UI.DatabaseTools
diff --git a/src/EventLogExpert/wwwroot/css/app.css b/src/EventLogExpert/wwwroot/css/app.css
index ca631737..0a79fe82 100644
--- a/src/EventLogExpert/wwwroot/css/app.css
+++ b/src/EventLogExpert/wwwroot/css/app.css
@@ -24,6 +24,11 @@
     --background-dark:     light-dark(#E0E0E0, #222222);
     --background-darkgray: light-dark(#CECECE, #353535);
 
+    /* Shared accent for Toggle + OptionSelect. Light is darkened from --clr-lightblue
+       so the on-state hits WCAG 1.4.3 AA against --background-darkgray (#14599D on
+       #CECECE = 4.53:1; dark #9CDCFE on #353535 = 8.23:1). */
+    --toggle-accent: light-dark(#14599D, var(--clr-lightblue));
+
     /* Recessed surface used for content wells (e.g. the trash strip exposed
        behind a database row when it slides aside). Always darker than
        --background-dark in both schemes so the well reads as cut into the
diff --git a/src/EventLogExpert/wwwroot/css/manage-status-banner.css b/src/EventLogExpert/wwwroot/css/manage-status-banner.css
new file mode 100644
index 00000000..d911adf1
--- /dev/null
+++ b/src/EventLogExpert/wwwroot/css/manage-status-banner.css
@@ -0,0 +1,26 @@
+.manage-status-banner {
+    display: flex;
+    align-items: center;
+    gap: .75rem;
+    padding: .5rem 1rem;
+    margin-bottom: .5rem;
+    border-left: 3px solid var(--clr-lightblue);
+}
+
+.manage-status-banner__spinner {
+    animation: manage-status-banner-spin 1.2s linear infinite;
+}
+
+.manage-status-banner__message {
+    flex: 1 1 auto;
+}
+
+@keyframes manage-status-banner-spin {
+    from { transform: rotate(0deg); }
+    to   { transform: rotate(360deg); }
+}
+
+.manage-status-banner--info {
+    color: var(--clr-lightblue);
+    font-style: italic;
+}
diff --git a/src/EventLogExpert/wwwroot/index.html b/src/EventLogExpert/wwwroot/index.html
index 09c1f6d6..ce7b22da 100644
--- a/src/EventLogExpert/wwwroot/index.html
+++ b/src/EventLogExpert/wwwroot/index.html
@@ -8,6 +8,7 @@
     <link href="css/bootstrap/bootstrap.min.css" rel="stylesheet" />
     <link href="css/app.css" rel="stylesheet" />
     <link href="css/banner.css" rel="stylesheet" />
+    <link href="css/manage-status-banner.css" rel="stylesheet" />
     <link href="EventLogExpert.styles.css" rel="stylesheet" />
 </head>
 
diff --git a/tests/Integration/EventLogExpert.Runtime.IntegrationTests/Database/DatabaseServiceTests.cs b/tests/Integration/EventLogExpert.Runtime.IntegrationTests/Database/DatabaseServiceTests.cs
index 86de598b..dde94267 100644
--- a/tests/Integration/EventLogExpert.Runtime.IntegrationTests/Database/DatabaseServiceTests.cs
+++ b/tests/Integration/EventLogExpert.Runtime.IntegrationTests/Database/DatabaseServiceTests.cs
@@ -12,6 +12,7 @@
 using Microsoft.Data.Sqlite;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
+using NSubstitute.ExceptionExtensions;
 using System.IO.Compression;
 
 namespace EventLogExpert.Runtime.IntegrationTests.Database;
@@ -272,51 +273,48 @@ public async Task
     }
 
     [Fact]
-    public async Task ClassifyEntriesAsync_WhenV3SchemaWithUpgradeBak_ShouldDetectAsUpgradeRequiredAndBackupExistsTrue()
+    public async Task ClassifyEntriesAsync_WhenV3Schema_ShouldDetectAsUpgradeRequired()
     {
         var databasePath = CreateDatabaseDirectory();
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
         DatabaseSeedUtils.SeedV3Schema(dbPath);
 
-        var bakPath = dbPath + DatabaseService.UpgradeBackupSuffix;
-        File.WriteAllText(bakPath, "interrupted-upgrade-backup");
-
         var service = CreateDatabaseService();
 
         await service.ClassifyEntriesAsync(TestContext.Current.CancellationToken);
 
         var entry = Assert.Single(service.Entries);
         Assert.Equal(DatabaseStatus.UpgradeRequired, entry.Status);
-        Assert.True(entry.BackupExists);
-        Assert.True(File.Exists(bakPath), ".upgrade.bak must be preserved for V3 entries so recovery can restore it.");
+        Assert.False(entry.BackupExists);
     }
 
     [Fact]
-    public async Task ClassifyEntriesAsync_WhenV3Schema_ShouldDetectAsUpgradeRequired()
+    public async Task ClassifyEntriesAsync_WhenV3SchemaWithUpgradeBak_ShouldDetectAsUpgradeRequiredAndBackupExistsTrue()
     {
         var databasePath = CreateDatabaseDirectory();
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
         DatabaseSeedUtils.SeedV3Schema(dbPath);
 
+        var bakPath = dbPath + DatabaseService.UpgradeBackupSuffix;
+        File.WriteAllText(bakPath, "interrupted-upgrade-backup");
+
         var service = CreateDatabaseService();
 
         await service.ClassifyEntriesAsync(TestContext.Current.CancellationToken);
 
         var entry = Assert.Single(service.Entries);
         Assert.Equal(DatabaseStatus.UpgradeRequired, entry.Status);
-        Assert.False(entry.BackupExists);
+        Assert.True(entry.BackupExists);
+        Assert.True(File.Exists(bakPath), ".upgrade.bak must be preserved for V3 entries so recovery can restore it.");
     }
 
     [Fact]
-    public async Task ClassifyEntriesAsync_WhenV4SchemaWithUpgradeBak_ShouldDeleteBakAndDetectAsReady()
+    public async Task ClassifyEntriesAsync_WhenV4Schema_ShouldDetectAsReady()
     {
         var databasePath = CreateDatabaseDirectory();
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
         DatabaseSeedUtils.SeedV4Schema(dbPath);
 
-        var bakPath = dbPath + DatabaseService.UpgradeBackupSuffix;
-        File.WriteAllText(bakPath, "stale-backup-from-successful-upgrade");
-
         var service = CreateDatabaseService();
 
         await service.ClassifyEntriesAsync(TestContext.Current.CancellationToken);
@@ -324,16 +322,18 @@ public async Task ClassifyEntriesAsync_WhenV4SchemaWithUpgradeBak_ShouldDeleteBa
         var entry = Assert.Single(service.Entries);
         Assert.Equal(DatabaseStatus.Ready, entry.Status);
         Assert.False(entry.BackupExists);
-        Assert.False(File.Exists(bakPath), "Stale .upgrade.bak must be cleaned up once the main file reaches V4.");
     }
 
     [Fact]
-    public async Task ClassifyEntriesAsync_WhenV4Schema_ShouldDetectAsReady()
+    public async Task ClassifyEntriesAsync_WhenV4SchemaWithUpgradeBak_ShouldDeleteBakAndDetectAsReady()
     {
         var databasePath = CreateDatabaseDirectory();
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
         DatabaseSeedUtils.SeedV4Schema(dbPath);
 
+        var bakPath = dbPath + DatabaseService.UpgradeBackupSuffix;
+        File.WriteAllText(bakPath, "stale-backup-from-successful-upgrade");
+
         var service = CreateDatabaseService();
 
         await service.ClassifyEntriesAsync(TestContext.Current.CancellationToken);
@@ -341,6 +341,7 @@ public async Task ClassifyEntriesAsync_WhenV4Schema_ShouldDetectAsReady()
         var entry = Assert.Single(service.Entries);
         Assert.Equal(DatabaseStatus.Ready, entry.Status);
         Assert.False(entry.BackupExists);
+        Assert.False(File.Exists(bakPath), "Stale .upgrade.bak must be cleaned up once the main file reaches V4.");
     }
 
     [Fact]
@@ -663,25 +664,6 @@ public async Task DisposeAsync_WithPendingBatches_ShouldCancelInFlightAndPending
         Assert.Equal(Constants.TestDb2, pendingResult.Cancelled[0]);
     }
 
-    [Fact]
-    public void EntriesChanged_MultipleSubscribers_FirstThrows_ShouldStillInvokeRest()
-    {
-        var databasePath = CreateDatabaseDirectory();
-        CreateDatabaseFile(databasePath, Constants.TestDb1);
-
-        var service = CreateDatabaseService();
-
-        var secondSubscriberInvocations = 0;
-
-        service.EntriesChanged += (_, _) => throw new InvalidOperationException("first subscriber throws");
-        service.EntriesChanged += (_, _) => Interlocked.Increment(ref secondSubscriberInvocations);
-
-        service.Toggle(Constants.TestDb1);
-
-        // If multicast invoke aborted on the first throwing subscriber, this would be 0.
-        Assert.Equal(1, secondSubscriberInvocations);
-    }
-
     [Fact]
     public void Entries_WhenMixedVersionedAndNonVersioned_ShouldSortCorrectly()
     {
@@ -742,6 +724,25 @@ public void Entries_WhenSimpleNames_ShouldSortByNameAscThenVersionDesc()
         Assert.Equal(Constants.DatabaseA + ".db", service.Entries[2].FileName);
     }
 
+    [Fact]
+    public void EntriesChanged_MultipleSubscribers_FirstThrows_ShouldStillInvokeRest()
+    {
+        var databasePath = CreateDatabaseDirectory();
+        CreateDatabaseFile(databasePath, Constants.TestDb1);
+
+        var service = CreateDatabaseService();
+
+        var secondSubscriberInvocations = 0;
+
+        service.EntriesChanged += (_, _) => throw new InvalidOperationException("first subscriber throws");
+        service.EntriesChanged += (_, _) => Interlocked.Increment(ref secondSubscriberInvocations);
+
+        service.Toggle(Constants.TestDb1);
+
+        // If multicast invoke aborted on the first throwing subscriber, this would be 0.
+        Assert.Equal(1, secondSubscriberInvocations);
+    }
+
     [Fact]
     public async Task EnumerateZipDbEntryNamesAsync_MalformedZip_ShouldReturnEmpty_NotThrow()
     {
@@ -1948,6 +1949,78 @@ public async Task RestoreFromBackupAsync_WhenSidecarDeleteFails_PreservesBackupA
         Assert.Equal(mainBytesBefore, File.ReadAllBytes(dbPath));
     }
 
+    [Fact]
+    public async Task RetryClassificationAsync_AlreadyCancelled_Throws()
+    {
+        var databasePath = CreateDatabaseDirectory();
+        DatabaseSeedUtils.SeedV4Schema(Path.Combine(databasePath, Constants.TestDb1));
+
+        var service = CreateDatabaseService();
+        Assert.Equal(DatabaseStatus.Ready, service.Entries[0].Status);
+
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+
+        await Assert.ThrowsAsync<OperationCanceledException>(
+            async () => await service.RetryClassificationAsync(Constants.TestDb1, cts.Token));
+
+        // Status unchanged since cancellation hits before MarkStatus.
+        Assert.Equal(DatabaseStatus.Ready, service.Entries[0].Status);
+    }
+
+    [Fact]
+    public async Task RetryClassificationAsync_MaintenanceThrows_SetsClassificationFailed()
+    {
+        var databasePath = CreateDatabaseDirectory();
+        var dbPath = Path.Combine(databasePath, Constants.TestDb1);
+        DatabaseSeedUtils.SeedV4Schema(dbPath);
+
+        var fileLocationOptions = new FileLocationOptions(_testDirectory);
+        var preferences = Substitute.For<IDatabasePreferencesProvider>();
+        preferences.DisabledDatabasesPreference.Returns([]);
+        var logger = Substitute.For<ITraceLogger>();
+        var failingMaintenance = Substitute.For<IProviderDatabaseMaintenance>();
+        failingMaintenance.CheckSchemaState(Arg.Any<string>()).Throws(new SqliteException("boom", 1));
+
+        var entryStore = new DatabaseRegistry(fileLocationOptions, preferences, logger);
+        entryStore.Refresh();
+        var classification = new DatabaseClassificationService(entryStore, fileLocationOptions, failingMaintenance, logger);
+
+        await classification.RetryClassificationAsync(Constants.TestDb1, TestContext.Current.CancellationToken);
+
+        var entry = entryStore.Entries.Single(e => e.FileName == Constants.TestDb1);
+        Assert.Equal(DatabaseStatus.ClassificationFailed, entry.Status);
+        Assert.False(entry.BackupExists);
+    }
+
+    [Fact]
+    public async Task RetryClassificationAsync_MissingEntry_NoOps()
+    {
+        CreateDatabaseDirectory();
+        var service = CreateDatabaseService();
+
+        // Should not throw; missing entry is treated as stale UI.
+        await service.RetryClassificationAsync("does-not-exist.db", TestContext.Current.CancellationToken);
+
+        Assert.Empty(service.Entries);
+    }
+
+    [Fact]
+    public async Task RetryClassificationAsync_Success_UpdatesEntryToReady()
+    {
+        var databasePath = CreateDatabaseDirectory();
+        DatabaseSeedUtils.SeedV4Schema(Path.Combine(databasePath, Constants.TestDb1));
+
+        var service = CreateDatabaseService();
+        // Reset to a stale status so we can observe the classification.
+        service.MarkStatus(Constants.TestDb1, DatabaseStatus.ClassificationFailed);
+        Assert.Equal(DatabaseStatus.ClassificationFailed, service.Entries[0].Status);
+
+        await service.RetryClassificationAsync(Constants.TestDb1, TestContext.Current.CancellationToken);
+
+        Assert.Equal(DatabaseStatus.Ready, service.Entries[0].Status);
+    }
+
     [Fact]
     public void Toggle_WhenCalled_ShouldFlipIsEnabledAndPersist()
     {
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Announcement/AnnouncementServiceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Announcement/AnnouncementServiceTests.cs
new file mode 100644
index 00000000..c25a034d
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Announcement/AnnouncementServiceTests.cs
@@ -0,0 +1,98 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Logging.Abstractions.Handlers;
+using EventLogExpert.Runtime.Announcement;
+using NSubstitute;
+
+namespace EventLogExpert.Runtime.Tests.Announcement;
+
+public sealed class AnnouncementServiceTests
+{
+    private readonly ITraceLogger _traceLogger = Substitute.For<ITraceLogger>();
+
+    [Fact]
+    public void Announce_CurrentAnnouncement_ReflectsLastMessage()
+    {
+        var svc = new AnnouncementService(_traceLogger);
+        svc.Announce("Settings saved");
+
+        Assert.StartsWith("Settings saved", svc.CurrentAnnouncement);
+    }
+
+    [Fact]
+    public void Announce_DifferentMessages_BothReflectedInOrder()
+    {
+        var svc = new AnnouncementService(_traceLogger);
+        var states = new List<string>();
+        svc.StateChanged += () => states.Add(svc.CurrentAnnouncement);
+
+        svc.Announce("Settings saved");
+        svc.Announce("Database imported");
+
+        Assert.Equal(2, states.Count);
+        Assert.StartsWith("Settings saved", states[0]);
+        Assert.StartsWith("Database imported", states[1]);
+    }
+
+    [Fact]
+    public void Announce_NullMessage_Throws()
+    {
+        var svc = new AnnouncementService(_traceLogger);
+        Assert.Throws<ArgumentNullException>(() => svc.Announce(null!));
+    }
+
+    [Fact]
+    public void Announce_RaisesStateChanged()
+    {
+        var svc = new AnnouncementService(_traceLogger);
+        int callCount = 0;
+        svc.StateChanged += () => callCount++;
+
+        svc.Announce("Settings saved");
+
+        Assert.Equal(1, callCount);
+    }
+
+    [Fact]
+    public void Announce_SubscriberThrows_LaterSubscribersStillInvoked_AndExceptionLogged()
+    {
+        // Mirrors BannerService.RaiseSafely contract: per-subscriber fault isolation prevents
+        // one throwing handler from blocking later ones or surfacing to the Announce caller.
+        var svc = new AnnouncementService(_traceLogger);
+        int secondCallCount = 0;
+        svc.StateChanged += static () => throw new InvalidOperationException("boom");
+        svc.StateChanged += () => secondCallCount++;
+
+        svc.Announce("Settings saved");
+
+        Assert.Equal(1, secondCallCount);
+        _traceLogger.Received(1).Warning(Arg.Any<WarningLogHandler>());
+    }
+
+    [Fact]
+    public void Announce_TwoIdenticalMessages_DomTextMutatesForReannouncement()
+    {
+        // SR live regions do not re-announce if the text node does not change. The seq-toggle
+        // appends \u200B (zero-width space) on odd-seq announcements so the DOM string differs even
+        // when the visible content matches the prior announcement. NVDA/JAWS/VoiceOver do not
+        // pronounce ZWS, so the difference is invisible to users.
+        var svc = new AnnouncementService(_traceLogger);
+        svc.Announce("Database imported");
+        var first = svc.CurrentAnnouncement;
+
+        svc.Announce("Database imported");
+        var second = svc.CurrentAnnouncement;
+
+        Assert.NotEqual(first, second);
+        Assert.StartsWith("Database imported", first);
+        Assert.StartsWith("Database imported", second);
+    }
+
+    [Fact]
+    public void Ctor_NullTraceLogger_Throws()
+    {
+        Assert.Throws<ArgumentNullException>(() => new AnnouncementService(null!));
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Banner/BannerServiceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Banner/BannerServiceTests.cs
index 7f4eeab9..efc117ec 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Banner/BannerServiceTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Banner/BannerServiceTests.cs
@@ -27,7 +27,7 @@ public void AttentionEntries_FilterIncludesEachAttentionStatus_AndExcludesReadyA
         // Arrange — single entry whose Status is the one under test.
         var databaseService = Substitute.For<IDatabaseService>();
         var entry = new DatabaseEntry("test.db", @"c:\dbs\test.db", true, status);
-        databaseService.Entries.Returns(new[] { entry });
+        databaseService.Entries.Returns([entry]);
 
         // Act
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
@@ -83,7 +83,7 @@ public void Ctor_PullsAttentionEntriesFromCurrentDatabaseEntries()
         var upgradeRequired = new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired);
         var ready = new DatabaseEntry("b.db", @"c:\dbs\b.db", true, DatabaseStatus.Ready);
         var unrecognized = new DatabaseEntry("c.db", @"c:\dbs\c.db", false, DatabaseStatus.UnrecognizedSchema);
-        databaseService.Entries.Returns(new[] { upgradeRequired, ready, unrecognized });
+        databaseService.Entries.Returns([upgradeRequired, ready, unrecognized]);
 
         // Act
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
@@ -104,15 +104,15 @@ public void DismissAttention_AfterReset_NewlyDismissedSnapshotReflectsCurrentEnt
         var entryA = new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired);
         var entryB = new DatabaseEntry("b.db", @"c:\dbs\b.db", true, DatabaseStatus.UpgradeRequired);
         var entryC = new DatabaseEntry("c.db", @"c:\dbs\c.db", true, DatabaseStatus.UpgradeRequired);
-        databaseService.Entries.Returns(new[] { entryA });
+        databaseService.Entries.Returns([entryA]);
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
         sut.DismissAttention();
-        databaseService.Entries.Returns(new[] { entryA, entryB });
+        databaseService.Entries.Returns([entryA, entryB]);
         databaseService.EntriesChanged += Raise.EventWith(databaseService, EventArgs.Empty);
         Assert.False(sut.AttentionDismissed);
         sut.DismissAttention();
         Assert.True(sut.AttentionDismissed);
-        databaseService.Entries.Returns(new[] { entryA, entryB, entryC });
+        databaseService.Entries.Returns([entryA, entryB, entryC]);
 
         // Act — c.db is the first file with a name not in the post-reset snapshot.
         databaseService.EntriesChanged += Raise.EventWith(databaseService, EventArgs.Empty);
@@ -128,7 +128,7 @@ public void DismissAttention_DoesNotMutateAttentionEntriesList()
         // Arrange
         var databaseService = Substitute.For<IDatabaseService>();
         var entry = new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired);
-        databaseService.Entries.Returns(new[] { entry });
+        databaseService.Entries.Returns([entry]);
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
         IReadOnlyList<DatabaseEntry> beforeDismiss = sut.AttentionEntries;
 
@@ -146,13 +146,13 @@ public void DismissAttention_FileLeavesAndReturns_DoesNotResetDismiss()
         // the dismissed snapshot, so the re-entry does NOT count as growth.
         var databaseService = Substitute.For<IDatabaseService>();
         var entryA = new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired);
-        databaseService.Entries.Returns(new[] { entryA });
+        databaseService.Entries.Returns([entryA]);
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
         sut.DismissAttention();
-        databaseService.Entries.Returns(new[] { entryA with { Status = DatabaseStatus.Ready } });
+        databaseService.Entries.Returns([entryA with { Status = DatabaseStatus.Ready }]);
         databaseService.EntriesChanged += Raise.EventWith(databaseService, EventArgs.Empty);
         Assert.Empty(sut.AttentionEntries);
-        databaseService.Entries.Returns(new[] { entryA with { Status = DatabaseStatus.UpgradeFailed } });
+        databaseService.Entries.Returns([entryA with { Status = DatabaseStatus.UpgradeFailed }]);
 
         // Act — a.db re-enters attention.
         databaseService.EntriesChanged += Raise.EventWith(databaseService, EventArgs.Empty);
@@ -170,10 +170,10 @@ public void DismissAttention_FileLeavesAttention_DoesNotResetDismiss()
         var databaseService = Substitute.For<IDatabaseService>();
         var entryA = new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired);
         var entryB = new DatabaseEntry("b.db", @"c:\dbs\b.db", true, DatabaseStatus.UpgradeRequired);
-        databaseService.Entries.Returns(new[] { entryA, entryB });
+        databaseService.Entries.Returns([entryA, entryB]);
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
         sut.DismissAttention();
-        databaseService.Entries.Returns(new[] { entryA with { Status = DatabaseStatus.Ready }, entryB });
+        databaseService.Entries.Returns([entryA with { Status = DatabaseStatus.Ready }, entryB]);
 
         // Act
         databaseService.EntriesChanged += Raise.EventWith(databaseService, EventArgs.Empty);
@@ -188,10 +188,9 @@ public void DismissAttention_FirstCall_RaisesStateChanged_AndSetsDismissedTrue()
     {
         // Arrange
         var databaseService = Substitute.For<IDatabaseService>();
-        databaseService.Entries.Returns(new[]
-        {
-            new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired),
-        });
+        databaseService.Entries.Returns([
+            new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired)
+        ]);
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
         int stateChangedCount = 0;
         ((IAttentionBannerService)sut).StateChanged += () => stateChangedCount++;
@@ -210,14 +209,14 @@ public void DismissAttention_NewFileEntersAttention_ResetsDismiss_RaisesStateCha
         // Arrange — dismiss with {a.db}, then EntriesChanged adds a NEW file b.db.
         var databaseService = Substitute.For<IDatabaseService>();
         var entryA = new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired);
-        databaseService.Entries.Returns(new[] { entryA });
+        databaseService.Entries.Returns([entryA]);
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
         sut.DismissAttention();
         Assert.True(sut.AttentionDismissed);
         int stateChangedCount = 0;
         ((IAttentionBannerService)sut).StateChanged += () => stateChangedCount++;
         var entryB = new DatabaseEntry("b.db", @"c:\dbs\b.db", true, DatabaseStatus.UpgradeRequired);
-        databaseService.Entries.Returns(new[] { entryA, entryB });
+        databaseService.Entries.Returns([entryA, entryB]);
 
         // Act — b.db's FileName is not in the dismissed-set snapshot, so dismissal must reset.
         databaseService.EntriesChanged += Raise.EventWith(databaseService, EventArgs.Empty);
@@ -235,11 +234,11 @@ public void DismissAttention_SameFileChangesStatus_DoesNotResetDismiss()
         // FileName, so the ratchet must NOT reset (user already dismissed knowledge of a.db).
         var databaseService = Substitute.For<IDatabaseService>();
         var initial = new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired);
-        databaseService.Entries.Returns(new[] { initial });
+        databaseService.Entries.Returns([initial]);
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
         sut.DismissAttention();
         var updated = initial with { Status = DatabaseStatus.UpgradeFailed };
-        databaseService.Entries.Returns(new[] { updated });
+        databaseService.Entries.Returns([updated]);
 
         // Act
         databaseService.EntriesChanged += Raise.EventWith(databaseService, EventArgs.Empty);
@@ -254,10 +253,9 @@ public void DismissAttention_SecondCall_NoOp_DoesNotRaiseStateChanged()
     {
         // Arrange — already dismissed.
         var databaseService = Substitute.For<IDatabaseService>();
-        databaseService.Entries.Returns(new[]
-        {
-            new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired),
-        });
+        databaseService.Entries.Returns([
+            new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired)
+        ]);
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
         sut.DismissAttention();
         int stateChangedCount = 0;
@@ -351,12 +349,12 @@ public void EntriesChanged_FileLeavesAttentionBucket_RaisesStateChanged()
         // Arrange — one attention entry initially, then it transitions to Ready.
         var databaseService = Substitute.For<IDatabaseService>();
         var initialEntry = new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired);
-        databaseService.Entries.Returns(new[] { initialEntry });
+        databaseService.Entries.Returns([initialEntry]);
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
         int stateChangedCount = 0;
         ((IAttentionBannerService)sut).StateChanged += () => stateChangedCount++;
         var readyEntry = initialEntry with { Status = DatabaseStatus.Ready };
-        databaseService.Entries.Returns(new[] { readyEntry });
+        databaseService.Entries.Returns([readyEntry]);
 
         // Act
         databaseService.EntriesChanged += Raise.EventWith(databaseService, EventArgs.Empty);
@@ -371,12 +369,12 @@ public void EntriesChanged_NewFileAppearsInAttention_RaisesStateChanged()
     {
         // Arrange — start with no attention entries, then add one via EntriesChanged.
         var databaseService = Substitute.For<IDatabaseService>();
-        databaseService.Entries.Returns(Array.Empty<DatabaseEntry>());
+        databaseService.Entries.Returns([]);
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
         int stateChangedCount = 0;
         ((IAttentionBannerService)sut).StateChanged += () => stateChangedCount++;
         var newEntry = new DatabaseEntry("new.db", @"c:\dbs\new.db", false, DatabaseStatus.UpgradeRequired);
-        databaseService.Entries.Returns(new[] { newEntry });
+        databaseService.Entries.Returns([newEntry]);
 
         // Act
         databaseService.EntriesChanged += Raise.EventWith(databaseService, EventArgs.Empty);
@@ -395,12 +393,12 @@ public void EntriesChanged_StatusChangesWithinAttentionBucket_AssignsFreshList_R
         // the latest record instance, not the stale one captured at construction.
         var databaseService = Substitute.For<IDatabaseService>();
         var initialEntry = new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired);
-        databaseService.Entries.Returns(new[] { initialEntry });
+        databaseService.Entries.Returns([initialEntry]);
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
         int stateChangedCount = 0;
         ((IAttentionBannerService)sut).StateChanged += () => stateChangedCount++;
         var updatedEntry = initialEntry with { Status = DatabaseStatus.UpgradeFailed };
-        databaseService.Entries.Returns(new[] { updatedEntry });
+        databaseService.Entries.Returns([updatedEntry]);
 
         // Act
         databaseService.EntriesChanged += Raise.EventWith(databaseService, EventArgs.Empty);
@@ -417,7 +415,7 @@ public void EntriesChanged_WithIdenticalAttentionSet_DoesNotRaiseStateChanged()
         // Arrange — same attention entries before and after; SequenceEqual must short-circuit the raise.
         var databaseService = Substitute.For<IDatabaseService>();
         var entry = new DatabaseEntry("a.db", @"c:\dbs\a.db", true, DatabaseStatus.UpgradeRequired);
-        databaseService.Entries.Returns(new[] { entry });
+        databaseService.Entries.Returns([entry]);
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
         int stateChangedCount = 0;
         ((IAttentionBannerService)sut).StateChanged += () => stateChangedCount++;
@@ -1017,7 +1015,7 @@ public void UpgradeBatchStarted_PopulatesBackgroundProgress_RaisesStateChanged()
         Assert.Equal(string.Empty, sut.BackgroundProgress.CurrentEntryName);
         Assert.Equal(UpgradePhase.BackingUp, sut.BackgroundProgress.CurrentPhase);
         Assert.Equal(2, sut.BackgroundProgress.QueuedBatchesAfter);
-        Assert.Null(sut.SettingsProgress);
+        Assert.Null(sut.ManageDatabasesProgress);
         Assert.Equal(1, stateChangedCount);
     }
 
@@ -1025,7 +1023,7 @@ public void UpgradeBatchStarted_PopulatesBackgroundProgress_RaisesStateChanged()
     public void UpgradeBatchStarted_TwoBatchesDifferentScopes_OnlyOneSlotPopulatedAtATime()
     {
         // Arrange — DatabaseService's FIFO consumer guarantees that at most one batch is in-flight at any
-        // time, so Background and Settings slots should never both be non-null. Verifies the runtime
+        // time, so Background and ManageDatabases slots should never both be non-null. Verifies the runtime
         // invariant: a Started must be paired with a Completed before the next Started fires.
         var databaseService = Substitute.For<IDatabaseService>();
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
@@ -1039,40 +1037,40 @@ public void UpgradeBatchStarted_TwoBatchesDifferentScopes_OnlyOneSlotPopulatedAt
             databaseService,
             new UpgradeBatchStartedEventArgs(firstId, UpgradeProgressScope.Background, 1, firstCts));
         Assert.NotNull(sut.BackgroundProgress);
-        Assert.Null(sut.SettingsProgress);
+        Assert.Null(sut.ManageDatabasesProgress);
 
-        // Background completed before Settings started.
+        // Background completed before ManageDatabases started.
         databaseService.UpgradeBatchCompleted += Raise.EventWith(
             databaseService,
             new UpgradeBatchCompletedEventArgs(firstId, new UpgradeBatchResult([], [], []), false));
         Assert.Null(sut.BackgroundProgress);
-        Assert.Null(sut.SettingsProgress);
+        Assert.Null(sut.ManageDatabasesProgress);
 
-        // Settings started.
+        // ManageDatabases started.
         databaseService.UpgradeBatchStarted += Raise.EventWith(
             databaseService,
-            new UpgradeBatchStartedEventArgs(secondId, UpgradeProgressScope.SettingsTriggered, 1, secondCts));
+            new UpgradeBatchStartedEventArgs(secondId, UpgradeProgressScope.ManageDatabasesTriggered, 1, secondCts));
         Assert.Null(sut.BackgroundProgress);
-        Assert.NotNull(sut.SettingsProgress);
+        Assert.NotNull(sut.ManageDatabasesProgress);
     }
 
     [Fact]
-    public void UpgradeBatchStarted_WithSettingsScope_PopulatesSettingsProgress_NotBackground()
+    public void UpgradeBatchStarted_WithManageDatabasesScope_PopulatesManageDatabasesProgress_NotBackground()
     {
         // Arrange
         var databaseService = Substitute.For<IDatabaseService>();
         var sut = new BannerService(databaseService, Substitute.For<ITraceLogger>());
         var batchId = UpgradeBatchId.Create();
         using var cts = new CancellationTokenSource();
-        var args = new UpgradeBatchStartedEventArgs(batchId, UpgradeProgressScope.SettingsTriggered, 1, cts);
+        var args = new UpgradeBatchStartedEventArgs(batchId, UpgradeProgressScope.ManageDatabasesTriggered, 1, cts);
 
         // Act
         databaseService.UpgradeBatchStarted += Raise.EventWith(databaseService, args);
 
         // Assert
         Assert.Null(sut.BackgroundProgress);
-        Assert.NotNull(sut.SettingsProgress);
-        Assert.Equal(batchId, sut.SettingsProgress.BatchId);
-        Assert.Equal(UpgradeProgressScope.SettingsTriggered, sut.SettingsProgress.Scope);
+        Assert.NotNull(sut.ManageDatabasesProgress);
+        Assert.Equal(batchId, sut.ManageDatabasesProgress.BatchId);
+        Assert.Equal(UpgradeProgressScope.ManageDatabasesTriggered, sut.ManageDatabasesProgress.Scope);
     }
 }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Banner/BannerViewSelectorTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Banner/BannerViewSelectorTests.cs
index 28e20c3b..1e54c3b2 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Banner/BannerViewSelectorTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Banner/BannerViewSelectorTests.cs
@@ -20,6 +20,7 @@ public void BuildCycle_AllEmpty_ReturnsEmpty()
                 errorBanners: [],
                 attentionEntries: [],
                 attentionDismissed: false,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: null,
                 infoBanners: []);
 
@@ -43,6 +44,7 @@ public void BuildCycle_AllSlicesActive_OrdersErrorsThenAttentionThenUpgradeProgr
                 errorBanners: [e0, e1],
                 attentionEntries: [BuildAttention("a.db"), BuildAttention("b.db")],
                 attentionDismissed: false,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: BuildProgress(),
                 infoBanners: [i0, i1, i2]);
 
@@ -66,6 +68,7 @@ public void BuildCycle_AttentionDismissed_AttentionExcluded()
                 errorBanners: [],
                 attentionEntries: [BuildAttention("a.db")],
                 attentionDismissed: true,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: null,
                 infoBanners: []);
 
@@ -73,6 +76,36 @@ public void BuildCycle_AttentionDismissed_AttentionExcluded()
         Assert.Empty(result);
     }
 
+    [Theory]
+    [InlineData(false, false, true)]
+    [InlineData(true, false, false)]
+    [InlineData(false, true, false)]
+    [InlineData(true, true, false)]
+    public void BuildCycle_AttentionDismissedOrSuppressed_OmitsAttention(
+        bool dismissed,
+        bool suppressedByModalContext,
+        bool expectAttention)
+    {
+        IReadOnlyList<BannerCycleItem> result = BannerViewSelector
+            .BuildCycle(currentCritical: null,
+                errorBanners: [],
+                attentionEntries: [BuildAttention("a.db")],
+                attentionDismissed: dismissed,
+                attentionSuppressedByModalContext: suppressedByModalContext,
+                backgroundProgress: null,
+                infoBanners: []);
+
+        if (expectAttention)
+        {
+            Assert.Single(result);
+            Assert.Equal(BannerView.Attention, result[0].View);
+        }
+        else
+        {
+            Assert.Empty(result);
+        }
+    }
+
     [Fact]
     public void BuildCycle_AttentionEntriesEmpty_AttentionExcluded_RegardlessOfDismissedFlag()
     {
@@ -82,6 +115,7 @@ public void BuildCycle_AttentionEntriesEmpty_AttentionExcluded_RegardlessOfDismi
                 errorBanners: [],
                 attentionEntries: [],
                 attentionDismissed: false,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: null,
                 infoBanners: []);
 
@@ -98,10 +132,47 @@ public void BuildCycle_AttentionEntriesNull_Throws()
                 errorBanners: [],
                 attentionEntries: null!,
                 attentionDismissed: false,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: null,
                 infoBanners: []));
     }
 
+    [Fact]
+    public void BuildCycle_AttentionSuppressedByModalContext_DoesNotAffectOtherSlices()
+    {
+        ErrorBannerEntry err = BuildError();
+        BannerInfoEntry info = BuildInfo();
+
+        IReadOnlyList<BannerCycleItem> result = BannerViewSelector
+            .BuildCycle(currentCritical: null,
+                errorBanners: [err],
+                attentionEntries: [BuildAttention("a.db")],
+                attentionDismissed: false,
+                attentionSuppressedByModalContext: true,
+                backgroundProgress: BuildProgress(),
+                infoBanners: [info]);
+
+        Assert.Equal(3, result.Count);
+        Assert.Equal(new BannerCycleItem(BannerView.Error, 0, err.Id), result[0]);
+        Assert.Equal(new BannerCycleItem(BannerView.UpgradeProgress, 0, null), result[1]);
+        Assert.Equal(new BannerCycleItem(BannerView.Info, 0, info.Id), result[2]);
+    }
+
+    [Fact]
+    public void BuildCycle_AttentionSuppressedByModalContext_OmitsAttentionSlice()
+    {
+        IReadOnlyList<BannerCycleItem> result = BannerViewSelector
+            .BuildCycle(currentCritical: null,
+                errorBanners: [],
+                attentionEntries: [BuildAttention("a.db"), BuildAttention("b.db")],
+                attentionDismissed: false,
+                attentionSuppressedByModalContext: true,
+                backgroundProgress: null,
+                infoBanners: []);
+
+        Assert.Empty(result);
+    }
+
     [Fact]
     public void BuildCycle_CriticalPresent_ReturnsSingleCriticalItem_RegardlessOfOtherSlices()
     {
@@ -111,6 +182,7 @@ public void BuildCycle_CriticalPresent_ReturnsSingleCriticalItem_RegardlessOfOth
                 errorBanners: [BuildError(), BuildError()],
                 attentionEntries: [BuildAttention("a.db")],
                 attentionDismissed: false,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: BuildProgress(),
                 infoBanners: [BuildInfo()]);
 
@@ -130,6 +202,7 @@ public void BuildCycle_ErrorBannersNull_Throws()
                 errorBanners: null!,
                 attentionEntries: [],
                 attentionDismissed: false,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: null,
                 infoBanners: []));
     }
@@ -143,6 +216,7 @@ public void BuildCycle_InfoBannersNull_Throws()
                 errorBanners: [],
                 attentionEntries: [],
                 attentionDismissed: false,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: null,
                 infoBanners: null!));
     }
@@ -156,6 +230,7 @@ public void BuildCycle_OnlyAttention_ReturnsSingleAttentionItem()
                 errorBanners: [],
                 attentionEntries: [BuildAttention("a.db"), BuildAttention("b.db")],
                 attentionDismissed: false,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: null,
                 infoBanners: []);
 
@@ -178,6 +253,7 @@ public void BuildCycle_OnlyErrors_OneItemPerError_StableOrder()
                 errorBanners: [e0, e1, e2],
                 attentionEntries: [],
                 attentionDismissed: false,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: null,
                 infoBanners: []);
 
@@ -201,6 +277,7 @@ public void BuildCycle_OnlyInfos_OneItemPerInfo_StableOrder()
                 errorBanners: [],
                 attentionEntries: [],
                 attentionDismissed: false,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: null,
                 infoBanners: [i0, i1]);
 
@@ -219,6 +296,7 @@ public void BuildCycle_OnlyUpgradeProgress_ReturnsSingleUpgradeProgressItem()
                 errorBanners: [],
                 attentionEntries: [],
                 attentionDismissed: false,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: BuildProgress(),
                 infoBanners: []);
 
@@ -241,6 +319,7 @@ public void BuildCycle_RebuildAfterErrorDismissed_PreservesEntryIdOnSurvivingErr
                 errorBanners: [e0, e1, e2],
                 attentionEntries: [],
                 attentionDismissed: false,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: null,
                 infoBanners: []);
 
@@ -249,6 +328,7 @@ public void BuildCycle_RebuildAfterErrorDismissed_PreservesEntryIdOnSurvivingErr
                 errorBanners: [e1, e2],
                 attentionEntries: [],
                 attentionDismissed: false,
+                attentionSuppressedByModalContext: false,
                 backgroundProgress: null,
                 infoBanners: []);
 
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Database/DatabaseOperationCoordinatorTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Database/DatabaseOperationCoordinatorTests.cs
index d80e8769..9f8b816e 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Database/DatabaseOperationCoordinatorTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Database/DatabaseOperationCoordinatorTests.cs
@@ -715,7 +715,7 @@ public async Task UpgradeDatabaseAsync_Success_TracksInFlightStateAndRaisesEnter
         Assert.False(sut.IsAnyUpgradeInFlight);
         await _databases.Received(1).UpgradeBatchAsync(
             Arg.Is<IReadOnlyList<string>>(l => l.Count == 1 && l[0] == "a.db"),
-            UpgradeProgressScope.SettingsTriggered,
+            UpgradeProgressScope.ManageDatabasesTriggered,
             Arg.Any<CancellationToken>());
     }
 
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/DependencyInjection/RuntimeServiceCollectionExtensionsTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/DependencyInjection/RuntimeServiceCollectionExtensionsTests.cs
index 4379cb3f..d7448f13 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/DependencyInjection/RuntimeServiceCollectionExtensionsTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/DependencyInjection/RuntimeServiceCollectionExtensionsTests.cs
@@ -4,6 +4,7 @@
 using EventLogExpert.Provider.Maintenance;
 using EventLogExpert.Provider.Resolution;
 using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.Runtime.Announcement;
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Common.AppTitle;
 using EventLogExpert.Runtime.Common.Files;
@@ -115,6 +116,7 @@ public async Task AddEventLogRuntime_Resolves5BannerFacetsToSameSingleton()
     [InlineData(typeof(ICriticalErrorService))]
     [InlineData(typeof(IErrorBannerService))]
     [InlineData(typeof(IInfoBannerService))]
+    [InlineData(typeof(IAnnouncementService))]
     [InlineData(typeof(IDatabaseService))]
     [InlineData(typeof(IActiveDatabases))]
     [InlineData(typeof(IDatabaseOperationCoordinator))]
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Announcement/AnnouncerHostTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Announcement/AnnouncerHostTests.cs
new file mode 100644
index 00000000..bbdd0704
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/Announcement/AnnouncerHostTests.cs
@@ -0,0 +1,70 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.Runtime.Announcement;
+using EventLogExpert.UI.Announcement;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+
+namespace EventLogExpert.UI.Tests.Announcement;
+
+public sealed class AnnouncerHostTests : BunitContext
+{
+    private readonly IAnnouncementService _announcementService = Substitute.For<IAnnouncementService>();
+
+    public AnnouncerHostTests()
+    {
+        _announcementService.CurrentAnnouncement.Returns(string.Empty);
+        Services.AddSingleton(_announcementService);
+    }
+
+    [Fact]
+    public void AnnouncerHost_Dispose_UnsubscribesFromStateChanged()
+    {
+        var component = Render<AnnouncerHost>();
+
+        component.Instance.Dispose();
+
+        // After Dispose, raising StateChanged would invoke any remaining subscribers; since the
+        // component's handler was unsubscribed, no exception is thrown and the test passes.
+        _announcementService.StateChanged += Raise.Event<Action>();
+        Assert.True(true);
+    }
+
+    [Fact]
+    public void AnnouncerHost_OnStateChanged_ReRendersWithLatestAnnouncement()
+    {
+        _announcementService.CurrentAnnouncement.Returns(string.Empty);
+        var component = Render<AnnouncerHost>();
+
+        Assert.Empty(component.Find("#app-announcer").TextContent.Trim());
+
+        _announcementService.CurrentAnnouncement.Returns("Database imported");
+        _announcementService.StateChanged += Raise.Event<Action>();
+
+        component.WaitForState(() => component.Find("#app-announcer").TextContent.Contains("Database imported"));
+        Assert.Contains("Database imported", component.Find("#app-announcer").TextContent);
+    }
+
+    [Fact]
+    public void AnnouncerHost_RendersCurrentAnnouncementText()
+    {
+        _announcementService.CurrentAnnouncement.Returns("Settings saved");
+
+        var component = Render<AnnouncerHost>();
+
+        Assert.Contains("Settings saved", component.Find("#app-announcer").TextContent);
+    }
+
+    [Fact]
+    public void AnnouncerHost_RendersLiveRegionWithPolitePoliteness()
+    {
+        var component = Render<AnnouncerHost>();
+
+        var region = component.Find("#app-announcer");
+        Assert.Equal("status", region.GetAttribute("role"));
+        Assert.Equal("polite", region.GetAttribute("aria-live"));
+        Assert.Equal("true", region.GetAttribute("aria-atomic"));
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Banner/AttentionBannerTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Banner/AttentionBannerTests.cs
index 03acd49e..e7e6d69f 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Banner/AttentionBannerTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Banner/AttentionBannerTests.cs
@@ -42,12 +42,9 @@ public async Task AttentionBanner_DismissClicked_CallsDismissAttention()
     }
 
     [Fact]
-    public async Task AttentionBanner_OpenSettingsClicked_DismissesAttention_BeforeAwaitingOpenSettings()
+    public async Task AttentionBanner_OpenDatabasesClicked_DismissesAttention_BeforeAwaitingOpenDatabases()
     {
-        // Clicking the action button is itself the user-acknowledgement that they're acting on the items;
-        // dismissing immediately means the banner doesn't linger while the modal opens (which can take a
-        // perceptible beat). On failure the error banner replaces the attention banner as the visible signal.
-        _menuActionService.OpenSettingsAsync().Returns(Task.FromResult(true));
+        _menuActionService.OpenDatabaseToolsAsync().Returns(Task.FromResult(true));
 
         var component = RenderAttentionBanner(1);
         await component.Find("aside.banner-attention button.banner-action").ClickAsync(new MouseEventArgs());
@@ -56,18 +53,15 @@ public async Task AttentionBanner_OpenSettingsClicked_DismissesAttention_BeforeA
             () =>
             {
                 _attentionBannerService.DismissAttention();
-                _ = _menuActionService.OpenSettingsAsync();
+                _ = _menuActionService.OpenDatabaseToolsAsync();
             });
         _errorBannerService.DidNotReceive().ReportError(Arg.Any<string>(), Arg.Any<string>());
     }
 
     [Fact]
-    public async Task AttentionBanner_OpenSettingsReturnsFalse_DismissesAttentionImmediately_AndReportsRecoverableError()
+    public async Task AttentionBanner_OpenDatabasesReturnsFalse_DismissesAttentionImmediately_AndReportsRecoverableError()
     {
-        // Dismiss-immediately semantics: the attention banner is gone the instant the user clicked, regardless
-        // of outcome. When OpenSettingsAsync returns false (caught internally), surface a recoverable Error so
-        // the user knows the click was received but the modal failed to open.
-        _menuActionService.OpenSettingsAsync().Returns(Task.FromResult(false));
+        _menuActionService.OpenDatabaseToolsAsync().Returns(Task.FromResult(false));
         BannerCycleItem? captured = null;
         Action<BannerCycleItem> handler = c => captured = c;
 
@@ -82,18 +76,15 @@ public async Task AttentionBanner_OpenSettingsReturnsFalse_DismissesAttentionImm
 
         _attentionBannerService.Received(1).DismissAttention();
         _errorBannerService.Received(1)
-            .ReportError("Settings", Arg.Is<string>(s => s.Contains("Failed to open settings")));
+            .ReportError("Databases", Arg.Is<string>(s => s.Contains("Failed to open databases")));
         Assert.NotNull(captured);
         Assert.Equal(BannerView.Error, captured.View);
     }
 
     [Fact]
-    public async Task AttentionBanner_OpenSettingsThrowsJSDisconnected_DismissesAttention_NoErrorReport()
+    public async Task AttentionBanner_OpenDatabasesThrowsJSDisconnected_DismissesAttention_NoErrorReport()
     {
-        // Per rule 3.9, JSDisconnectedException is expected during teardown and must be caught silently — it
-        // does not warrant ReportError surface (the user closed the circuit themselves). The dismiss happened
-        // before the await so the attention banner is already gone by the time the throw lands.
-        _menuActionService.OpenSettingsAsync()
+        _menuActionService.OpenDatabaseToolsAsync()
             .Returns(Task.FromException<bool>(new JSDisconnectedException("circuit gone")));
 
         var component = RenderAttentionBanner(1);
@@ -104,13 +95,10 @@ public async Task AttentionBanner_OpenSettingsThrowsJSDisconnected_DismissesAtte
     }
 
     [Fact]
-    public async Task AttentionBanner_OpenSettingsThrowsUnexpectedly_DismissesAttention_LogsAndReportsRecoverableError()
+    public async Task AttentionBanner_OpenDatabasesThrowsUnexpectedly_DismissesAttention_LogsAndReportsRecoverableError()
     {
-        // Defensive path: contract says OpenSettingsAsync catches internally, but a synchronous throw before the
-        // first await would still bubble. Must not propagate to ErrorBoundary (which would escalate the visible
-        // banner from Attention to Critical). Surface as Error; attention was already dismissed on click.
         var openException = new InvalidOperationException("modal boom");
-        _menuActionService.OpenSettingsAsync().Returns(Task.FromException<bool>(openException));
+        _menuActionService.OpenDatabaseToolsAsync().Returns(Task.FromException<bool>(openException));
         BannerCycleItem? captured = null;
         Action<BannerCycleItem> handler = c => captured = c;
 
@@ -125,7 +113,7 @@ public async Task AttentionBanner_OpenSettingsThrowsUnexpectedly_DismissesAttent
 
         _attentionBannerService.Received(1).DismissAttention();
         _errorBannerService.Received(1)
-            .ReportError("Settings", Arg.Is<string>(s => s.Contains("modal boom")));
+            .ReportError("Databases", Arg.Is<string>(s => s.Contains("modal boom")));
         _traceLogger.Received(1).Error(Arg.Is<ErrorLogHandler>(h =>
             h.ToString().Contains(nameof(AttentionBanner)) && h.ToString().Contains("modal boom")));
         Assert.NotNull(captured);
@@ -133,13 +121,13 @@ public async Task AttentionBanner_OpenSettingsThrowsUnexpectedly_DismissesAttent
     }
 
     [Fact]
-    public void AttentionBanner_RendersWithOpenSettingsAndDismiss()
+    public void AttentionBanner_RendersWithOpenDatabasesAndDismiss()
     {
         var component = RenderAttentionBanner(2);
 
         var banner = component.Find("aside.banner-attention");
         Assert.Contains("2 databases need attention", banner.TextContent);
-        Assert.Equal("Open Settings", component.Find("aside.banner-attention button.banner-action").TextContent.Trim());
+        Assert.Equal("Open Databases", component.Find("aside.banner-attention button.banner-action").TextContent.Trim());
         Assert.Single(component.FindAll("aside.banner-attention button.banner-dismiss"));
     }
 
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerCycleStateServiceTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerCycleStateServiceTests.cs
new file mode 100644
index 00000000..4229e407
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerCycleStateServiceTests.cs
@@ -0,0 +1,323 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Banner;
+using EventLogExpert.Runtime.Database;
+using EventLogExpert.Runtime.Modal;
+using EventLogExpert.UI.Banner;
+using EventLogExpert.UI.DatabaseTools;
+using NSubstitute;
+
+namespace EventLogExpert.UI.Tests.Banner;
+
+public sealed class BannerCycleStateServiceTests
+{
+    private readonly IAttentionBannerService _attention = Substitute.For<IAttentionBannerService>();
+    private readonly ICriticalErrorService _critical = Substitute.For<ICriticalErrorService>();
+    private readonly IErrorBannerService _errors = Substitute.For<IErrorBannerService>();
+    private readonly IInfoBannerService _infos = Substitute.For<IInfoBannerService>();
+    private readonly IModalCoordinator _modalCoordinator = Substitute.For<IModalCoordinator>();
+    private readonly IProgressBannerService _progress = Substitute.For<IProgressBannerService>();
+
+    public BannerCycleStateServiceTests()
+    {
+        _critical.CurrentCritical.Returns((Exception?)null);
+        _errors.ErrorBanners.Returns([]);
+        _infos.InfoBanners.Returns([]);
+        _attention.AttentionEntries.Returns([]);
+        _attention.AttentionDismissed.Returns(false);
+        _progress.BackgroundProgress.Returns((BannerProgressEntry?)null);
+        _modalCoordinator.ActiveSession.Returns((ModalSession?)null);
+    }
+
+    [Fact]
+    public void Constructor_ComputesInitialSnapshotFromCurrentFacetState()
+    {
+        var err = MakeError();
+        _errors.ErrorBanners.Returns([err]);
+
+        var service = CreateService();
+
+        Assert.Single(service.Items);
+        Assert.Equal(BannerView.Error, service.CurrentView);
+        Assert.Equal(err.Id, service.SelectedItem?.EntryId);
+    }
+
+    [Fact]
+    public void Constructor_WithNoBanners_HasEmptyItems_AndNoneView()
+    {
+        var service = CreateService();
+
+        Assert.Empty(service.Items);
+        Assert.Equal(BannerView.None, service.CurrentView);
+        Assert.Null(service.SelectedItem);
+    }
+
+    [Fact]
+    public void Dispose_UnsubscribesFromAllSources()
+    {
+        var service = CreateService();
+        int stateChangedFires = 0;
+        service.StateChanged += () => stateChangedFires++;
+
+        service.Dispose();
+
+        _errors.ErrorBanners.Returns([MakeError()]);
+        _errors.StateChanged += Raise.Event<Action>();
+        _attention.StateChanged += Raise.Event<Action>();
+        _infos.StateChanged += Raise.Event<Action>();
+        _progress.StateChanged += Raise.Event<Action>();
+        _critical.StateChanged += Raise.Event<Action>();
+        _modalCoordinator.StateChanged += Raise.Event<Action>();
+
+        Assert.Equal(0, stateChangedFires);
+    }
+
+    [Fact]
+    public void ModalContentDisplayed_DefaultsFalse_OnNewInstance()
+    {
+        var service = CreateService();
+
+        Assert.False(service.ModalContentDisplayed);
+    }
+
+    [Fact]
+    public void MoveNext_AtFirstIndex_AdvancesAndFiresStateChanged()
+    {
+        _errors.ErrorBanners.Returns([MakeError(), MakeError()]);
+        var service = CreateService();
+
+        int stateChangedFires = 0;
+        service.StateChanged += () => stateChangedFires++;
+
+        service.MoveNext();
+
+        Assert.Equal(1, service.DisplayedIndex);
+        Assert.Equal(1, stateChangedFires);
+    }
+
+    [Fact]
+    public void MoveNext_AtLastIndex_DoesNothing()
+    {
+        _errors.ErrorBanners.Returns([MakeError(), MakeError()]);
+        var service = CreateService();
+        service.MoveNext();
+
+        int stateChangedFires = 0;
+        service.StateChanged += () => stateChangedFires++;
+
+        service.MoveNext();
+
+        Assert.Equal(1, service.DisplayedIndex);
+        Assert.Equal(0, stateChangedFires);
+    }
+
+    [Fact]
+    public void MovePrev_AtFirstIndex_DoesNothing()
+    {
+        _errors.ErrorBanners.Returns([MakeError(), MakeError()]);
+        var service = CreateService();
+
+        int stateChangedFires = 0;
+        service.StateChanged += () => stateChangedFires++;
+
+        service.MovePrev();
+
+        Assert.Equal(0, service.DisplayedIndex);
+        Assert.Equal(0, stateChangedFires);
+    }
+
+    [Fact]
+    public void MovePrev_AtMiddleIndex_DecrementsAndFiresStateChanged()
+    {
+        _errors.ErrorBanners.Returns([MakeError(), MakeError(), MakeError()]);
+        var service = CreateService();
+        service.MoveNext();
+        service.MoveNext();
+
+        int stateChangedFires = 0;
+        service.StateChanged += () => stateChangedFires++;
+
+        service.MovePrev();
+
+        Assert.Equal(1, service.DisplayedIndex);
+        Assert.Equal(1, stateChangedFires);
+    }
+
+    [Fact]
+    public void OnFacetChanged_AfterDatabaseToolsModalActive_AttentionSuppressionApplied()
+    {
+        _attention.AttentionEntries.Returns([MakeAttention("a.db")]);
+        var service = CreateService();
+        Assert.Equal(BannerView.Attention, service.CurrentView);
+
+        _modalCoordinator.ActiveSession.Returns(
+            new ModalSession(new ModalId(1), typeof(DatabaseToolsModal), null));
+        _modalCoordinator.StateChanged += Raise.Event<Action>();
+
+        Assert.Empty(service.Items);
+        Assert.Equal(BannerView.None, service.CurrentView);
+    }
+
+    [Fact]
+    public void OnFacetChanged_AfterErrorAdded_RebuildsAndFiresStateChanged()
+    {
+        var service = CreateService();
+        int stateChangedFires = 0;
+        service.StateChanged += () => stateChangedFires++;
+
+        _errors.ErrorBanners.Returns([MakeError()]);
+        _errors.StateChanged += Raise.Event<Action>();
+
+        Assert.Single(service.Items);
+        Assert.Equal(BannerView.Error, service.CurrentView);
+        Assert.Equal(1, stateChangedFires);
+    }
+
+    [Fact]
+    public void RebuildAndReselect_AfterSelectedItemRemoved_ClampsIndex()
+    {
+        var e1 = MakeError();
+        var e2 = MakeError();
+        _errors.ErrorBanners.Returns([e1, e2]);
+        var service = CreateService();
+        service.MoveNext();
+        Assert.Equal(e2.Id, service.SelectedItem?.EntryId);
+
+        _errors.ErrorBanners.Returns([e1]);
+        _errors.StateChanged += Raise.Event<Action>();
+
+        Assert.Equal(0, service.DisplayedIndex);
+        Assert.Equal(e1.Id, service.SelectedItem?.EntryId);
+    }
+
+    [Fact]
+    public void RebuildAndReselect_PreservesSelectedItemWhenStillPresent()
+    {
+        var e1 = MakeError();
+        var e2 = MakeError();
+        _errors.ErrorBanners.Returns([e1, e2]);
+        var service = CreateService();
+        service.MoveNext();
+        Assert.Equal(e2.Id, service.SelectedItem?.EntryId);
+
+        _errors.ErrorBanners.Returns([e1, e2, MakeError()]);
+        _errors.StateChanged += Raise.Event<Action>();
+
+        Assert.Equal(e2.Id, service.SelectedItem?.EntryId);
+    }
+
+    [Fact]
+    public void RebuildAndReselect_WhenActiveSessionIsNotNull_PreservesModalContentDisplayedFlag()
+    {
+        var service = CreateService();
+        service.SetModalContentDisplayed(true);
+
+        _modalCoordinator.ActiveSession.Returns(
+            new ModalSession(new ModalId(7), typeof(BannerCycleStateServiceTests), null));
+        _errors.ErrorBanners.Returns([MakeError()]);
+        _errors.StateChanged += Raise.Event<Action>();
+
+        Assert.True(service.ModalContentDisplayed);
+    }
+
+    [Fact]
+    public void RebuildAndReselect_WhenActiveSessionIsNull_AutoClearsModalContentDisplayed()
+    {
+        var service = CreateService();
+        service.SetModalContentDisplayed(true);
+        Assert.True(service.ModalContentDisplayed);
+
+        _modalCoordinator.ActiveSession.Returns((ModalSession?)null);
+        _errors.ErrorBanners.Returns([MakeError()]);
+        _errors.StateChanged += Raise.Event<Action>();
+
+        Assert.False(service.ModalContentDisplayed);
+    }
+
+    [Fact]
+    public void RegisterFallbackError_AppliesOverrideImmediately_FiresStateChangedOnce()
+    {
+        var existing = MakeError();
+        var fallback = MakeError();
+        _errors.ErrorBanners.Returns([existing, fallback]);
+        var service = CreateService();
+
+        int stateChangedFires = 0;
+        service.StateChanged += () => stateChangedFires++;
+
+        service.RegisterFallbackError(new BannerCycleItem(BannerView.Error, 1, fallback.Id));
+
+        Assert.Equal(1, service.DisplayedIndex);
+        Assert.Equal(fallback.Id, service.SelectedItem?.EntryId);
+        Assert.Equal(1, stateChangedFires);
+    }
+
+    [Fact]
+    public void RegisterFallbackError_OverrideConsumedAfterApplication()
+    {
+        var first = MakeError();
+        var second = MakeError();
+        _errors.ErrorBanners.Returns([first, second]);
+        var service = CreateService();
+
+        service.RegisterFallbackError(new BannerCycleItem(BannerView.Error, 1, second.Id));
+        Assert.Equal(1, service.DisplayedIndex);
+
+        var third = MakeError();
+        _errors.ErrorBanners.Returns([first, second, third]);
+        _errors.StateChanged += Raise.Event<Action>();
+
+        Assert.Equal(1, service.DisplayedIndex);
+        Assert.Equal(second.Id, service.SelectedItem?.EntryId);
+    }
+
+    [Fact]
+    public void RegisterFallbackError_WhenOverrideItemNotInCurrentItems_FallsThroughToPriorSelection()
+    {
+        var existing = MakeError();
+        _errors.ErrorBanners.Returns([existing]);
+        var service = CreateService();
+
+        var notInList = new BannerCycleItem(BannerView.Error, 99, BannerId.Create());
+        service.RegisterFallbackError(notInList);
+
+        Assert.Equal(0, service.DisplayedIndex);
+        Assert.Equal(existing.Id, service.SelectedItem?.EntryId);
+    }
+
+    [Fact]
+    public void SetModalContentDisplayed_SameValue_IsNoOp_DoesNotFireStateChanged()
+    {
+        var service = CreateService();
+        int stateChangedFires = 0;
+        service.StateChanged += () => stateChangedFires++;
+
+        service.SetModalContentDisplayed(false);
+
+        Assert.False(service.ModalContentDisplayed);
+        Assert.Equal(0, stateChangedFires);
+    }
+
+    [Fact]
+    public void SetModalContentDisplayed_True_TogglesFlag_FiresStateChangedOnce()
+    {
+        var service = CreateService();
+        int stateChangedFires = 0;
+        service.StateChanged += () => stateChangedFires++;
+
+        service.SetModalContentDisplayed(true);
+
+        Assert.True(service.ModalContentDisplayed);
+        Assert.Equal(1, stateChangedFires);
+    }
+
+    private static DatabaseEntry MakeAttention(string fileName) =>
+        new(fileName, $@"C:\dbs\{fileName}", IsEnabled: false, DatabaseStatus.UpgradeRequired);
+
+    private static ErrorBannerEntry MakeError() =>
+        new(BannerId.Create(), "Title", "msg", null, null, DateTime.UtcNow);
+
+    private BannerCycleStateService CreateService() =>
+        new(_attention, _errors, _infos, _progress, _critical, _modalCoordinator);
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerHostTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerHostTests.cs
index e4e0c04f..fa356304 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerHostTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerHostTests.cs
@@ -8,7 +8,9 @@
 using EventLogExpert.Runtime.Common.Restart;
 using EventLogExpert.Runtime.Database;
 using EventLogExpert.Runtime.Menu;
+using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.Banner;
+using EventLogExpert.UI.DatabaseTools;
 using EventLogExpert.UI.Tests.TestUtils;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.Extensions.DependencyInjection;
@@ -26,12 +28,14 @@ public sealed class BannerHostTests : BunitContext
     private readonly IErrorBannerService _errorBannerService;
     private readonly IInfoBannerService _infoBannerService;
     private readonly IMenuActionService _menuActionService = Substitute.For<IMenuActionService>();
+    private readonly IModalCoordinator _modalCoordinator = Substitute.For<IModalCoordinator>();
     private readonly IProgressBannerService _progressBannerService;
     private readonly ITraceLogger _traceLogger = Substitute.For<ITraceLogger>();
 
     public BannerHostTests()
     {
         Services.AddBannerSubstitutes(out _attentionBannerService, out _progressBannerService, out _criticalErrorService, out _errorBannerService, out _infoBannerService);
+        Services.AddSingleton<IBannerCycleStateService, BannerCycleStateService>();
 
         _criticalErrorService.CurrentCritical.Returns((Exception?)null);
         _errorBannerService.ErrorBanners.Returns([]);
@@ -39,10 +43,12 @@ public BannerHostTests()
         _attentionBannerService.AttentionEntries.Returns([]);
         _attentionBannerService.AttentionDismissed.Returns(false);
         _progressBannerService.BackgroundProgress.Returns((BannerProgressEntry?)null);
+        _modalCoordinator.ActiveSession.Returns((ModalSession?)null);
 
         Services.AddSingleton(_applicationRestartService);
         Services.AddSingleton(_clipboardService);
         Services.AddSingleton(_menuActionService);
+        Services.AddSingleton(_modalCoordinator);
         Services.AddSingleton(_traceLogger);
 
         JSInterop.Mode = JSRuntimeMode.Loose;
@@ -110,6 +116,44 @@ public void BannerHost_CycleErrorAndAttention_RendersFirstErrorWithCyclePaginati
         Assert.Contains("Err: msg", banner.TextContent);
     }
 
+    [Fact]
+    public async Task BannerHost_CycleNextAndPrev_AcrossThreeInfoBanners_UpdatesDisplayedEntryAndPagination()
+    {
+        var i0 = new BannerInfoEntry(BannerId.Create(), "First", "first message", BannerSeverity.Info, DateTime.UtcNow);
+        var i1 = new BannerInfoEntry(BannerId.Create(), "Second", "second message", BannerSeverity.Info, DateTime.UtcNow);
+        var i2 = new BannerInfoEntry(BannerId.Create(), "Third", "third message", BannerSeverity.Info, DateTime.UtcNow);
+        _infoBannerService.InfoBanners.Returns([i0, i1, i2]);
+
+        var component = Render<BannerHost>();
+
+        Assert.Contains("First: first message", component.Find("aside.banner-info").TextContent);
+        Assert.Equal("1 of 3", component.Find(".banner-pagination").TextContent.Trim());
+
+        await component.Find("button.banner-cycle-next").ClickAsync(new MouseEventArgs());
+
+        Assert.Contains("Second: second message", component.Find("aside.banner-info").TextContent);
+        Assert.DoesNotContain("First", component.Find("aside.banner-info").TextContent);
+        Assert.Equal("2 of 3", component.Find(".banner-pagination").TextContent.Trim());
+
+        await component.Find("button.banner-cycle-next").ClickAsync(new MouseEventArgs());
+
+        Assert.Contains("Third: third message", component.Find("aside.banner-info").TextContent);
+        Assert.DoesNotContain("Second", component.Find("aside.banner-info").TextContent);
+        Assert.Equal("3 of 3", component.Find(".banner-pagination").TextContent.Trim());
+
+        await component.Find("button.banner-cycle-prev").ClickAsync(new MouseEventArgs());
+
+        Assert.Contains("Second: second message", component.Find("aside.banner-info").TextContent);
+        Assert.DoesNotContain("Third", component.Find("aside.banner-info").TextContent);
+        Assert.Equal("2 of 3", component.Find(".banner-pagination").TextContent.Trim());
+
+        await component.Find("button.banner-cycle-prev").ClickAsync(new MouseEventArgs());
+
+        Assert.Contains("First: first message", component.Find("aside.banner-info").TextContent);
+        Assert.DoesNotContain("Second", component.Find("aside.banner-info").TextContent);
+        Assert.Equal("1 of 3", component.Find(".banner-pagination").TextContent.Trim());
+    }
+
     [Fact]
     public async Task BannerHost_CycleNextAtLast_DisabledAndDoesNotAdvance()
     {
@@ -226,28 +270,23 @@ public void BannerHost_NoState_RendersNothing()
     }
 
     [Fact]
-    public async Task BannerHost_OpenSettingsReturnsFalse_RendersNewErrorBanner_NotStaleAttention()
+    public async Task BannerHost_OpenDatabasesReturnsFalse_RendersNewErrorBanner_NotStaleAttention()
     {
-        // Round-2 regression: without explicitly steering _selectedItem to the new error after ReportError,
-        // ItemMatches preserves the stale Attention selection by (View=Attention, EntryId=null) and the user
-        // never sees the failure message they need — the error banner would be one page back in the cycle.
         var attention = BuildDatabaseEntry("a.db");
         var newErrorId = BannerId.Create();
         var newError = new ErrorBannerEntry(
             newErrorId,
-            "Settings",
-            "Failed to open settings; try again from the menu.",
+            "Databases",
+            "Failed to open databases; try again from the menu.",
             null,
             null,
             DateTime.UtcNow);
 
         _attentionBannerService.AttentionEntries.Returns([attention]);
-        _menuActionService.OpenSettingsAsync().Returns(Task.FromResult(false));
-        _errorBannerService.ReportError("Settings", Arg.Any<string>())
+        _menuActionService.OpenDatabaseToolsAsync().Returns(Task.FromResult(false));
+        _errorBannerService.ReportError("Databases", Arg.Any<string>())
             .Returns(_ =>
             {
-                // Simulate the real BannerService side effect: the new error joins the ErrorBanners list so
-                // the next rebuild has both [Error, Attention] in the cycle.
                 _errorBannerService.ErrorBanners.Returns([newError]);
                 return newErrorId;
             });
@@ -256,15 +295,13 @@ public async Task BannerHost_OpenSettingsReturnsFalse_RendersNewErrorBanner_NotS
         Assert.Single(component.FindAll("aside.banner-attention"));
 
         await component.Find("aside.banner-attention button.banner-action").ClickAsync(new MouseEventArgs());
-        // Real BannerService raises StateChanged from inside ReportError; the mock does not, so raise it here
-        // to drive the re-render that proves _selectedItem was steered to the new error.
+        // Substitute does not raise StateChanged from ReportError; raise manually to trigger re-render.
         _errorBannerService.StateChanged += Raise.Event<Action>();
 
         component.WaitForState(() => component.FindAll("aside.banner-error").Count > 0);
 
         var errorBanner = component.Find("aside.banner-error");
-        Assert.Contains("Failed to open settings; try again from the menu.", errorBanner.TextContent);
-        // Bug being prevented: stale Attention selection would render Attention here instead of Error.
+        Assert.Contains("Failed to open databases; try again from the menu.", errorBanner.TextContent);
         Assert.Empty(component.FindAll("aside.banner-attention"));
     }
 
@@ -282,6 +319,131 @@ public void BannerHost_SingleErrorBanner_RendersWithoutPagination()
         Assert.Single(component.FindAll("aside.banner-error button.banner-dismiss"));
     }
 
+    [Fact]
+    public void Dispose_UnsubscribesFromCycleState()
+    {
+        _attentionBannerService.AttentionEntries.Returns([BuildDatabaseEntry("a.db")]);
+
+        var component = Render<BannerHost>();
+        Assert.Single(component.FindAll("aside.banner-attention"));
+
+        component.Instance.Dispose();
+
+        _attentionBannerService.AttentionEntries.Returns([]);
+        _attentionBannerService.StateChanged += Raise.Event<Action>();
+
+        Assert.Single(component.FindAll("aside.banner-attention"));
+    }
+
+    [Fact]
+    public void Render_AsInsideModal_WithDatabaseToolsModalActive_OmitsAttentionBanner_RendersOtherBanners()
+    {
+        var errorEntry = new ErrorBannerEntry(
+            BannerId.Create(), "Title", "msg", null, null, DateTime.UtcNow);
+        _attentionBannerService.AttentionEntries.Returns([BuildDatabaseEntry("a.db")]);
+        _errorBannerService.ErrorBanners.Returns([errorEntry]);
+        _modalCoordinator.ActiveSession.Returns(
+            new ModalSession(new ModalId(5), typeof(DatabaseToolsModal), null));
+        var cycleState = Services.GetRequiredService<IBannerCycleStateService>();
+        cycleState.SetModalContentDisplayed(true);
+
+        var component = Render<BannerHost>(parameters => parameters
+            .Add(p => p.Location, BannerHostLocation.InsideModal));
+
+        Assert.Empty(component.FindAll("aside.banner-attention"));
+        Assert.Single(component.FindAll("aside.banner-error"));
+    }
+
+    [Fact]
+    public void Render_AsInsideModal_WithDifferentModalActive_RendersAttentionBanner()
+    {
+        _attentionBannerService.AttentionEntries.Returns([BuildDatabaseEntry("a.db")]);
+        _modalCoordinator.ActiveSession.Returns(
+            new ModalSession(new ModalId(2), typeof(BannerHost), null));
+        var cycleState = Services.GetRequiredService<IBannerCycleStateService>();
+        cycleState.SetModalContentDisplayed(true);
+
+        var component = Render<BannerHost>(parameters => parameters
+            .Add(p => p.Location, BannerHostLocation.InsideModal));
+
+        Assert.Single(component.FindAll("aside.banner-attention"));
+    }
+
+    [Fact]
+    public void Render_AsInsideModalLocation_WithNoModalActive_RendersNothing()
+    {
+        _attentionBannerService.AttentionEntries.Returns([BuildDatabaseEntry("a.db")]);
+        _modalCoordinator.ActiveSession.Returns((ModalSession?)null);
+
+        var component = Render<BannerHost>(parameters => parameters
+            .Add(p => p.Location, BannerHostLocation.InsideModal));
+
+        Assert.Empty(component.FindAll("aside.banner-attention"));
+    }
+
+    [Fact]
+    public void Render_AsMainLayoutLocation_WithModalActive_RendersNothing()
+    {
+        _attentionBannerService.AttentionEntries.Returns([BuildDatabaseEntry("a.db")]);
+        _modalCoordinator.ActiveSession.Returns(
+            new ModalSession(new ModalId(6), typeof(BannerHost), null));
+        var cycleState = Services.GetRequiredService<IBannerCycleStateService>();
+        cycleState.SetModalContentDisplayed(true);
+
+        var component = Render<BannerHost>();
+
+        Assert.Empty(component.FindAll("aside.banner-attention"));
+    }
+
+    [Fact]
+    public async Task Render_ModalActivationTransition_TogglesAttentionVisibility()
+    {
+        _attentionBannerService.AttentionEntries.Returns([BuildDatabaseEntry("a.db")]);
+        var cycleState = Services.GetRequiredService<IBannerCycleStateService>();
+
+        var component = Render<BannerHost>();
+        Assert.Single(component.FindAll("aside.banner-attention"));
+
+        _modalCoordinator.ActiveSession.Returns(
+            new ModalSession(new ModalId(3), typeof(DatabaseToolsModal), null));
+        _modalCoordinator.StateChanged += Raise.Event<Action>();
+        cycleState.SetModalContentDisplayed(true);
+
+        await component.WaitForAssertionAsync(() =>
+            Assert.Empty(component.FindAll("aside.banner-attention")));
+
+        _modalCoordinator.ActiveSession.Returns((ModalSession?)null);
+        _modalCoordinator.StateChanged += Raise.Event<Action>();
+
+        await component.WaitForAssertionAsync(() =>
+            Assert.Single(component.FindAll("aside.banner-attention")));
+    }
+
+    [Fact]
+    public void Render_WithDatabaseToolsModalActive_OmitsAttentionBanner()
+    {
+        _attentionBannerService.AttentionEntries.Returns([BuildDatabaseEntry("a.db")]);
+        _modalCoordinator.ActiveSession.Returns(
+            new ModalSession(new ModalId(1), typeof(DatabaseToolsModal), null));
+        var cycleState = Services.GetRequiredService<IBannerCycleStateService>();
+        cycleState.SetModalContentDisplayed(true);
+
+        var component = Render<BannerHost>();
+
+        Assert.Empty(component.FindAll("aside.banner-attention"));
+    }
+
+    [Fact]
+    public void Render_WithNoModalActive_RendersAttentionBanner()
+    {
+        _attentionBannerService.AttentionEntries.Returns([BuildDatabaseEntry("a.db")]);
+        _modalCoordinator.ActiveSession.Returns((ModalSession?)null);
+
+        var component = Render<BannerHost>();
+
+        Assert.Single(component.FindAll("aside.banner-attention"));
+    }
+
     private static DatabaseEntry BuildDatabaseEntry(string fileName) =>
         new(fileName, $@"C:\dbs\{fileName}", false, DatabaseStatus.UpgradeRequired);
 }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseEntryRowTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseEntryRowTests.cs
index 7940660b..27db48f9 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseEntryRowTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseEntryRowTests.cs
@@ -2,10 +2,15 @@
 // // Licensed under the MIT License.
 
 using Bunit;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Database;
+using EventLogExpert.Runtime.Database.Upgrade;
 using EventLogExpert.UI.Database;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
 
 namespace EventLogExpert.UI.Tests.Database;
 
@@ -14,6 +19,81 @@ public sealed class DatabaseEntryRowTests : BunitContext
     public DatabaseEntryRowTests()
     {
         JSInterop.Mode = JSRuntimeMode.Loose;
+        Services.AddSingleton(Substitute.For<ITraceLogger>());
+    }
+
+    [Fact]
+    public async Task CancelButton_Click_InvokesProgressCancelDelegate()
+    {
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired);
+        int cancelCount = 0;
+        var progress = MakeProgress(currentEntryName: "a.db", cancel: () => cancelCount++);
+
+        var component = RenderRow(entry, upgradeProgress: progress);
+        await component.Find(".db-entry-cancel-btn").ClickAsync(new MouseEventArgs());
+
+        Assert.Equal(1, cancelCount);
+    }
+
+    [Fact]
+    public void Checkbox_RenderedWithAriaLabelInRow()
+    {
+        var entry = MakeEntry(DatabaseStatus.Ready, "MyDb.evtx");
+
+        var component = RenderRow(entry);
+
+        var checkbox = component.Find(".db-entry-row input[type='checkbox']");
+        Assert.Equal("Select MyDb.evtx", checkbox.GetAttribute("aria-label"));
+    }
+
+    [Fact]
+    public async Task CheckboxChange_InvokesOnSelectionToggle()
+    {
+        var entry = MakeEntry(DatabaseStatus.Ready);
+        int invocationCount = 0;
+        var component = Render<DatabaseEntryRow>(parameters => parameters
+            .Add(p => p.Entry, entry)
+            .Add(p => p.OnSelectionToggle, () => invocationCount++));
+
+        await component.Find(".db-entry-row input[type='checkbox']")
+            .ChangeAsync(new ChangeEventArgs { Value = true });
+
+        Assert.Equal(1, invocationCount);
+    }
+
+    [Fact]
+    public void RemoveButton_AlwaysVisible_RowDoesNotHaveSlideRevealClass()
+    {
+        var entry = MakeEntry(DatabaseStatus.Ready);
+
+        var component = RenderRow(entry);
+
+        var row = component.Find(".db-entry-row");
+        Assert.DoesNotContain("db-entry-row--revealed", row.GetAttribute("class") ?? string.Empty);
+        Assert.Single(component.FindAll(".db-entry-remove-btn"));
+    }
+
+    [Fact]
+    public void RemoveButton_DuringBackgroundUpgrade_NotAriaDisabled()
+    {
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired);
+        var progress = MakeProgress(currentEntryName: "a.db", scope: UpgradeProgressScope.Background);
+
+        var component = RenderRow(entry, upgradeProgress: progress);
+
+        var button = component.Find(".db-entry-remove-btn");
+        Assert.False(button.HasAttribute("aria-disabled"));
+    }
+
+    [Fact]
+    public void RemoveButton_DuringManageUpgrade_NotAriaDisabled()
+    {
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired);
+
+        var component = RenderRow(entry, isUpgrading: true);
+
+        var button = component.Find(".db-entry-remove-btn");
+        Assert.False(button.HasAttribute("aria-disabled"));
     }
 
     [Fact]
@@ -33,6 +113,31 @@ public async Task RemoveButtonClick_InvokesOnRemove()
         Assert.Equal(1, invocationCount);
     }
 
+    [Fact]
+    public void Render_BackgroundUpgrade_UpgradeFailed_NoDoubleRenderBadgeAndSpinner()
+    {
+        var entry = MakeEntry(DatabaseStatus.UpgradeFailed);
+        var progress = MakeProgress(currentEntryName: "a.db", scope: UpgradeProgressScope.Background);
+
+        var component = RenderRow(entry, upgradeProgress: progress);
+
+        Assert.Single(component.FindAll(".db-entry-spinner"));
+        Assert.Empty(component.FindAll(".db-entry-badge"));
+    }
+
+    [Fact]
+    public void Render_BackupExists_AND_BackgroundUpgrade_StillShowsBadge()
+    {
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired, backupExists: true);
+        var progress = MakeProgress(currentEntryName: "a.db", scope: UpgradeProgressScope.Background);
+
+        var component = RenderRow(entry, upgradeProgress: progress);
+
+        Assert.Single(component.FindAll(".db-entry-badge"));
+        Assert.Single(component.FindAll(".db-entry-restore-btn"));
+        Assert.Empty(component.FindAll(".db-entry-spinner"));
+    }
+
     [Fact]
     public void Render_BackupExistsAndIsUpgrading_StillShowsRecoveryBadge()
     {
@@ -49,7 +154,7 @@ public void Render_BackupExistsAndIsUpgrading_StillShowsRecoveryBadge()
 
         Assert.Empty(component.FindAll(".db-entry-upgrading"));
         Assert.Empty(component.FindAll(".db-entry-upgrade-btn"));
-        Assert.Empty(component.FindAll(".toggle"));
+        Assert.Empty(component.FindAll(".option-select"));
 
         // Trash is unconditionally rendered now; visibility is governed by the CSS
         // hover/focus reveal animation, not by markup.
@@ -68,10 +173,25 @@ public void Render_BackupExistsEntry_OverridesReadyStatus()
         // Assert
         var badge = component.Find(".db-entry-badge");
         Assert.Equal("Recovery required", badge.TextContent);
-        Assert.Empty(component.FindAll(".toggle"));
+        Assert.Empty(component.FindAll(".option-select"));
         Assert.Single(component.FindAll(".db-entry-remove-btn"));
     }
 
+    [Fact]
+    public void Render_BackupExistsEntry_RestoreButton_AriaDisabledWhenBlocked()
+    {
+        // Arrange
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired, backupExists: true);
+
+        // Act
+        var component = RenderRow(entry, isUpgradeBlocked: true);
+
+        // Assert
+        var restoreBtn = component.Find(".db-entry-restore-btn");
+        Assert.Equal("true", restoreBtn.GetAttribute("aria-disabled"));
+        Assert.False(restoreBtn.HasAttribute("disabled"));
+    }
+
     [Fact]
     public void Render_BackupExistsEntry_ShowsRecoveryRequiredBadge_AndShowsTrash()
     {
@@ -89,12 +209,53 @@ public void Render_BackupExistsEntry_ShowsRecoveryRequiredBadge_AndShowsTrash()
         Assert.Equal("Recovery", badge.GetAttribute("data-badge"));
 
         Assert.Empty(component.FindAll(".db-entry-upgrade-btn"));
-        Assert.Empty(component.FindAll(".toggle"));
+        Assert.Empty(component.FindAll(".option-select"));
         Assert.Empty(component.FindAll(".db-entry-upgrading"));
 
         Assert.Single(component.FindAll(".db-entry-remove-btn"));
     }
 
+    [Fact]
+    public void Render_BackupExistsEntry_ShowsRestoreButton()
+    {
+        // Arrange
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired, backupExists: true);
+
+        // Act
+        var component = RenderRow(entry);
+
+        // Assert
+        var restoreBtn = component.Find(".db-entry-restore-btn");
+        Assert.Equal("Restore database a.db from backup", restoreBtn.GetAttribute("aria-label"));
+        Assert.Contains("Restore", restoreBtn.TextContent);
+    }
+
+    [Fact]
+    public void Render_ClassificationFailedEntry_ShowsRetryClassificationButton()
+    {
+        // Arrange
+        var entry = MakeEntry(DatabaseStatus.ClassificationFailed);
+
+        // Act
+        var component = RenderRow(entry);
+
+        // Assert
+        var retryBtn = component.Find(".db-entry-retry-classification-btn");
+        Assert.Equal("Retry classification of database a.db", retryBtn.GetAttribute("aria-label"));
+        Assert.Contains("Retry classification", retryBtn.TextContent);
+    }
+
+    [Fact]
+    public void Render_DefaultIsSelectedFalse_CheckboxUnchecked()
+    {
+        var entry = MakeEntry(DatabaseStatus.Ready);
+
+        var component = RenderRow(entry);
+
+        var checkbox = component.Find(".db-entry-row input[type='checkbox']");
+        Assert.False(checkbox.HasAttribute("checked"));
+    }
+
     [Fact]
     public void Render_DisabledEntries_ShowTrashButton()
     {
@@ -126,7 +287,21 @@ public void Render_FileName_AppearsInRow()
     }
 
     [Fact]
-    public void Render_IsUpgradeBlocked_DisablesRetryButton()
+    public void Render_IsSelectedTrue_CheckboxCheckedAndRowHasSelectedClass()
+    {
+        var entry = MakeEntry(DatabaseStatus.Ready);
+
+        var component = RenderRow(entry, isSelected: true);
+
+        var checkbox = component.Find(".db-entry-row input[type='checkbox']");
+        Assert.True(checkbox.HasAttribute("checked"));
+
+        var row = component.Find(".db-entry-row");
+        Assert.Contains("db-entry-row--selected", row.GetAttribute("class") ?? string.Empty);
+    }
+
+    [Fact]
+    public void Render_IsUpgradeBlocked_AriaDisablesRetryUpgradeButton()
     {
         // Arrange
         var entry = MakeEntry(DatabaseStatus.UpgradeFailed);
@@ -136,11 +311,12 @@ public void Render_IsUpgradeBlocked_DisablesRetryButton()
 
         // Assert
         var button = component.Find(".db-entry-upgrade-btn");
-        Assert.True(button.HasAttribute("disabled"));
+        Assert.Equal("true", button.GetAttribute("aria-disabled"));
+        Assert.False(button.HasAttribute("disabled"));
     }
 
     [Fact]
-    public void Render_IsUpgradeBlocked_DisablesUpgradeButton()
+    public void Render_IsUpgradeBlocked_AriaDisablesUpgradeButton()
     {
         // Arrange
         var entry = MakeEntry(DatabaseStatus.UpgradeRequired);
@@ -150,7 +326,8 @@ public void Render_IsUpgradeBlocked_DisablesUpgradeButton()
 
         // Assert
         var button = component.Find(".db-entry-upgrade-btn");
-        Assert.True(button.HasAttribute("disabled"));
+        Assert.Equal("true", button.GetAttribute("aria-disabled"));
+        Assert.False(button.HasAttribute("disabled"));
     }
 
     [Fact]
@@ -170,11 +347,22 @@ public void Render_IsUpgrading_ShowsSpinner_AndHidesBadge()
         Assert.Empty(component.FindAll(".db-entry-upgrade-btn"));
         Assert.Empty(component.FindAll(".db-entry-badge"));
 
-        // Trash is rendered even during an in-flight upgrade; RemoveAsync coordinates
-        // with the per-file reservation so the user-initiated delete is safe to expose.
         Assert.Single(component.FindAll(".db-entry-remove-btn"));
     }
 
+    [Fact]
+    public void Render_ManageUpgrade_TransitionalWindow_RoleStatusPresent()
+    {
+        // IsUpgrading=true, UpgradeProgress=null: Manage path between batch start and first per-file progress event.
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired);
+
+        var component = RenderRow(entry, isUpgrading: true);
+
+        var upgrading = component.Find(".db-entry-upgrading");
+        Assert.Equal("status", upgrading.GetAttribute("role"));
+        Assert.Contains("Upgrading", upgrading.TextContent);
+    }
+
     [Fact]
     public void Render_NonReadyEnabledEntry_ShowsTrashButton()
     {
@@ -199,7 +387,7 @@ public void Render_NotClassifiedEntry_ShowsDisabledToggle_AndClassifyingBadge()
         var component = RenderRow(entry);
 
         // Assert
-        var radios = component.FindAll(".toggle input[type='radio']");
+        var radios = component.FindAll(".option-select input[type='radio']");
         Assert.NotEmpty(radios);
         Assert.All(radios, r => Assert.True(r.HasAttribute("disabled")));
 
@@ -208,6 +396,61 @@ public void Render_NotClassifiedEntry_ShowsDisabledToggle_AndClassifyingBadge()
         Assert.Equal("NotClassified", badge.GetAttribute("data-badge"));
     }
 
+    [Fact]
+    public void Render_PendingToggle_AnnouncesPendingViaAriaDescribedBy()
+    {
+        var entry = MakeEntry(DatabaseStatus.Ready, "provider-y.db");
+
+        // Act
+        var component = RenderRow(entry, effectiveEnabled: false, isTogglePending: true);
+
+        // Assert
+        var radiogroup = component.Find(".db-entry-actions [role='radiogroup']");
+        var describedById = radiogroup.GetAttribute("aria-describedby");
+        Assert.False(string.IsNullOrEmpty(describedById),
+            "Pending toggle must have aria-describedby pointing at the pending-status span.");
+
+        var pendingSpan = component.Find($"#{describedById}");
+        Assert.Equal("(pending toggle, unsaved)", pendingSpan.TextContent.Trim());
+        Assert.Contains("visually-hidden", pendingSpan.GetAttribute("class") ?? string.Empty);
+    }
+
+    [Fact]
+    public void Render_PendingToggle_AppliesIndicatorClass()
+    {
+        // Arrange
+        var entry = MakeEntry(DatabaseStatus.Ready);
+
+        // Act
+        var component = RenderRow(entry, effectiveEnabled: false, isTogglePending: true);
+
+        // Assert
+        var actions = component.Find(".db-entry-actions");
+        Assert.Contains("db-entry-actions--pending", actions.GetAttribute("class") ?? string.Empty);
+    }
+
+    [Fact]
+    public void Render_PendingToggleOnDisabledToggle_DoesNotShowIndicator()
+    {
+        // Arrange — NotClassified routes to ActionKind.DisabledToggle (the toggle renders
+        // but is disabled while classification is still in flight). Even if upstream marks
+        // the row as pending, the indicator (and SR pending-status description) should be
+        // suppressed so the announcement isn't misleading on a control the user can't flip.
+        var entry = MakeEntry(DatabaseStatus.NotClassified, "provider-z.db");
+
+        // Act
+        var component = RenderRow(entry, isTogglePending: true);
+
+        // Assert
+        var actions = component.Find(".db-entry-actions");
+        Assert.DoesNotContain("db-entry-actions--pending", actions.GetAttribute("class") ?? string.Empty);
+
+        var radiogroup = component.Find(".db-entry-actions [role='radiogroup']");
+        Assert.True(string.IsNullOrEmpty(radiogroup.GetAttribute("aria-describedby")),
+            "Disabled toggle should NOT carry the pending-status description.");
+        Assert.Empty(component.FindAll("span.visually-hidden"));
+    }
+
     [Fact]
     public void Render_ReadyEnabledEntry_OptimisticToggleOff_StillRendersTrashButton()
     {
@@ -247,7 +490,7 @@ public void Render_ReadyEntry_ShowsToggle_AndNoBadge()
         var component = RenderRow(entry);
 
         // Assert
-        Assert.Single(component.FindAll(".toggle"));
+        Assert.Single(component.FindAll(".option-select"));
         Assert.Empty(component.FindAll(".db-entry-badge"));
         Assert.Empty(component.FindAll(".db-entry-upgrade-btn"));
         Assert.Empty(component.FindAll(".db-entry-upgrading"));
@@ -263,7 +506,7 @@ public void Render_ReadyEntryWithClassificationPending_ShowsDisabledToggle()
         var component = RenderRow(entry, true);
 
         // Assert
-        var radios = component.FindAll(".toggle input[type='radio']");
+        var radios = component.FindAll(".option-select input[type='radio']");
         Assert.NotEmpty(radios);
         Assert.All(radios, r => Assert.True(r.HasAttribute("disabled")));
     }
@@ -285,10 +528,9 @@ public void Render_RemoveButton_HasAriaLabel()
     [Theory]
     [InlineData(DatabaseStatus.UnrecognizedSchema, "Unrecognized")]
     [InlineData(DatabaseStatus.ObsoleteSchema, "Obsolete")]
-    [InlineData(DatabaseStatus.ClassificationFailed, "Classification failed")]
     public void Render_TerminalStatus_ShowsBadge_AndOnlyTrash(DatabaseStatus status, string expectedLabel)
     {
-        // Arrange
+        // ClassificationFailed intentionally excluded: it now renders the Retry classification button.
         var entry = MakeEntry(status);
 
         // Act
@@ -300,10 +542,30 @@ public void Render_TerminalStatus_ShowsBadge_AndOnlyTrash(DatabaseStatus status,
         Assert.Equal(status.ToString(), badge.GetAttribute("data-badge"));
 
         Assert.Empty(component.FindAll(".db-entry-upgrade-btn"));
-        Assert.Empty(component.FindAll(".toggle"));
+        Assert.Empty(component.FindAll(".option-select"));
         Assert.Single(component.FindAll(".db-entry-remove-btn"));
     }
 
+    [Fact]
+    public void Render_Toggle_UsesAriaLabelledByPointingAtFilenameButton()
+    {
+        var entry = MakeEntry(DatabaseStatus.Ready, "provider-x.db");
+
+        var component = RenderRow(entry, effectiveEnabled: false);
+
+        var radiogroup = component.Find(".db-entry-actions [role='radiogroup']");
+        var labelledById = radiogroup.GetAttribute("aria-labelledby");
+        Assert.False(string.IsNullOrEmpty(labelledById),
+            "Toggle must have aria-labelledby referencing the filename button.");
+
+        var nameButton = component.Find($"#{labelledById}");
+        Assert.Equal("db-entry-name", nameButton.GetAttribute("class"));
+        Assert.Equal("provider-x.db", nameButton.TextContent.Trim());
+
+        Assert.True(string.IsNullOrEmpty(radiogroup.GetAttribute("aria-label")),
+            "Toggle must not fall back to a synthesized aria-label when aria-labelledby is set.");
+    }
+
     [Fact]
     public void Render_UpgradeFailedEntry_ShowsRetryButton_AndRedBadge()
     {
@@ -323,6 +585,106 @@ public void Render_UpgradeFailedEntry_ShowsRetryButton_AndRedBadge()
         Assert.Equal("UpgradeFailed", badge.GetAttribute("data-badge"));
     }
 
+    [Fact]
+    public void Render_UpgradeProgress_EmptyEntryName_DoesNotEmitFilenameSrSuffix()
+    {
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired);
+        var progress = MakeProgress(currentEntryName: string.Empty, currentBatchSize: 2);
+
+        var component = RenderRow(entry, upgradeProgress: progress);
+
+        Assert.Empty(component.FindAll(".db-entry-upgrading .visually-hidden"));
+    }
+
+    [Fact]
+    public void Render_UpgradeProgress_EmptyEntryName_RendersPreparingMessage()
+    {
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired);
+        var progress = MakeProgress(
+            currentEntryName: string.Empty,
+            currentBatchSize: 3);
+
+        var component = RenderRow(entry, upgradeProgress: progress);
+
+        var text = component.Find(".db-entry-upgrading-text");
+        Assert.Contains("Preparing upgrade of 3 databases", text.TextContent);
+    }
+
+    [Fact]
+    public void Render_UpgradeProgress_EmptyEntryName_SingleDb_UsesSingularLabel()
+    {
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired);
+        var progress = MakeProgress(currentEntryName: string.Empty, currentBatchSize: 1);
+
+        var component = RenderRow(entry, upgradeProgress: progress);
+
+        var text = component.Find(".db-entry-upgrading-text");
+        Assert.Contains("Preparing upgrade of 1 database", text.TextContent);
+        Assert.DoesNotContain("databases", text.TextContent);
+    }
+
+    [Fact]
+    public void Render_UpgradeProgress_RendersRichProgressMarkupWithVerbAndPosition()
+    {
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired);
+        var progress = MakeProgress(
+            currentEntryName: "a.db",
+            currentPhase: UpgradePhase.MigratingSchema,
+            currentBatchPosition: 2,
+            currentBatchSize: 5);
+
+        var component = RenderRow(entry, upgradeProgress: progress);
+
+        var text = component.Find(".db-entry-upgrading-text");
+        Assert.Equal("Migrating schema 2 of 5", text.TextContent);
+    }
+
+    [Fact]
+    public void Render_UpgradeProgress_RoleStatusOnInnerSpan_WithFilenameSrSuffix()
+    {
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired, "MyProvider.db");
+        var progress = MakeProgress(currentEntryName: "MyProvider.db");
+
+        var component = RenderRow(entry, upgradeProgress: progress);
+
+        var statusSpan = component.Find(".db-entry-upgrading-status");
+        Assert.Equal("status", statusSpan.GetAttribute("role"));
+
+        var srSuffix = component.Find(".db-entry-upgrading .visually-hidden");
+        Assert.Contains("MyProvider.db", srSuffix.TextContent);
+    }
+
+    [Fact]
+    public void Render_UpgradeProgress_SingleFileBatch_OmitsBatchPosition()
+    {
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired);
+        var progress = MakeProgress(
+            currentEntryName: "a.db",
+            currentPhase: UpgradePhase.Verifying,
+            currentBatchPosition: 1,
+            currentBatchSize: 1);
+
+        var component = RenderRow(entry, upgradeProgress: progress);
+
+        var text = component.Find(".db-entry-upgrading-text");
+        Assert.Equal("Verifying", text.TextContent);
+    }
+
+    [Theory]
+    [InlineData(UpgradePhase.BackingUp, "Backing up")]
+    [InlineData(UpgradePhase.MigratingSchema, "Migrating schema")]
+    [InlineData(UpgradePhase.Verifying, "Verifying")]
+    public void Render_UpgradeProgress_VerbPerPhase(UpgradePhase phase, string expectedVerb)
+    {
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired);
+        var progress = MakeProgress(currentEntryName: "a.db", currentPhase: phase);
+
+        var component = RenderRow(entry, upgradeProgress: progress);
+
+        var text = component.Find(".db-entry-upgrading-text");
+        Assert.Contains(expectedVerb, text.TextContent);
+    }
+
     [Fact]
     public void Render_UpgradeRequiredEntry_ShowsTrashButton()
     {
@@ -354,7 +716,73 @@ public void Render_UpgradeRequiredEntry_ShowsUpgradeButton_AndNoBadge()
         Assert.DoesNotContain("button-red", button.GetAttribute("class") ?? string.Empty);
 
         Assert.Empty(component.FindAll(".db-entry-badge"));
-        Assert.Empty(component.FindAll(".toggle"));
+        Assert.Empty(component.FindAll(".option-select"));
+    }
+
+    [Fact]
+    public async Task RestoreButtonClick_InvokesOnRestoreFromBackup()
+    {
+        // Arrange
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired, backupExists: true);
+        int invocationCount = 0;
+        var component = Render<DatabaseEntryRow>(parameters => parameters
+            .Add(p => p.Entry, entry)
+            .Add(p => p.OnRestoreFromBackup, () => invocationCount++));
+
+        // Act
+        await component.Find(".db-entry-restore-btn").ClickAsync(new MouseEventArgs());
+
+        // Assert
+        Assert.Equal(1, invocationCount);
+    }
+
+    [Fact]
+    public async Task RestoreButtonClick_WhenIsUpgradeBlocked_DoesNotInvokeOnRestoreFromBackup()
+    {
+        // Arrange
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired, backupExists: true);
+        int invocationCount = 0;
+        var component = Render<DatabaseEntryRow>(parameters => parameters
+            .Add(p => p.Entry, entry)
+            .Add(p => p.IsUpgradeBlocked, true)
+            .Add(p => p.OnRestoreFromBackup, () => invocationCount++));
+
+        // Act
+        await component.Find(".db-entry-restore-btn").ClickAsync(new MouseEventArgs());
+
+        // Assert
+        Assert.Equal(0, invocationCount);
+    }
+
+    [Fact]
+    public async Task RestoreButtonClick_WhenUpgradeProgressMatchesRow_DoesNotInvokeOnRestoreFromBackup()
+    {
+        // BackupExists routes to RestoreFromBackup over Spinner; the click guard must still
+        // honor per-row UpgradeProgress so a Background-scope upgrade in flight for the same
+        // database blocks restore.
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired, backupExists: true);
+        int invocationCount = 0;
+        var progress = new BannerProgressEntry(
+            UpgradeBatchId.Create(),
+            UpgradeProgressScope.Background,
+            CurrentBatchPosition: 1,
+            CurrentBatchSize: 1,
+            CurrentEntryName: entry.FileName,
+            CurrentPhase: UpgradePhase.MigratingSchema,
+            QueuedBatchesAfter: 0,
+            Cancel: () => { });
+        var component = Render<DatabaseEntryRow>(parameters => parameters
+            .Add(p => p.Entry, entry)
+            .Add(p => p.IsUpgradeBlocked, false)
+            .Add(p => p.UpgradeProgress, progress)
+            .Add(p => p.OnRestoreFromBackup, () => invocationCount++));
+
+        var restoreBtn = component.Find(".db-entry-restore-btn");
+        Assert.Equal("true", restoreBtn.GetAttribute("aria-disabled"));
+
+        await restoreBtn.ClickAsync(new MouseEventArgs());
+
+        Assert.Equal(0, invocationCount);
     }
 
     [Fact]
@@ -374,6 +802,34 @@ public async Task RetryButtonClick_InvokesOnUpgrade()
         Assert.Equal(1, invocationCount);
     }
 
+    [Fact]
+    public async Task RetryClassificationButtonClick_InvokesOnRetryClassification()
+    {
+        // Arrange
+        var entry = MakeEntry(DatabaseStatus.ClassificationFailed);
+        int invocationCount = 0;
+        var component = Render<DatabaseEntryRow>(parameters => parameters
+            .Add(p => p.Entry, entry)
+            .Add(p => p.OnRetryClassification, () => invocationCount++));
+
+        // Act
+        await component.Find(".db-entry-retry-classification-btn").ClickAsync(new MouseEventArgs());
+
+        // Assert
+        Assert.Equal(1, invocationCount);
+    }
+
+    [Fact]
+    public void Row_NoAriaSelectedAttribute()
+    {
+        var entry = MakeEntry(DatabaseStatus.Ready);
+
+        var component = RenderRow(entry, isSelected: true);
+
+        var row = component.Find(".db-entry-row");
+        Assert.False(row.HasAttribute("aria-selected"));
+    }
+
     [Fact]
     public async Task TogglingTrueRadio_InvokesOnToggle_OnReadyEntry()
     {
@@ -386,7 +842,7 @@ public async Task TogglingTrueRadio_InvokesOnToggle_OnReadyEntry()
             .Add(p => p.OnToggle, () => invocationCount++));
 
         // Act
-        var enableRadio = component.FindAll(".toggle input[type='radio']")[1];
+        var enableRadio = component.FindAll(".option-select input[type='radio']")[1];
         await enableRadio.ChangeAsync(new ChangeEventArgs { Value = "true" });
 
         // Assert
@@ -410,6 +866,24 @@ public async Task UpgradeButtonClick_InvokesOnUpgrade()
         Assert.Equal(1, invocationCount);
     }
 
+    [Fact]
+    public async Task UpgradeButtonClick_WhenAriaDisabled_DoesNotInvokeOnUpgrade()
+    {
+        // Arrange
+        var entry = MakeEntry(DatabaseStatus.UpgradeRequired);
+        int invocationCount = 0;
+        var component = Render<DatabaseEntryRow>(parameters => parameters
+            .Add(p => p.Entry, entry)
+            .Add(p => p.IsUpgradeBlocked, true)
+            .Add(p => p.OnUpgrade, () => invocationCount++));
+
+        // Act
+        await component.Find(".db-entry-upgrade-btn").ClickAsync(new MouseEventArgs());
+
+        // Assert
+        Assert.Equal(0, invocationCount);
+    }
+
     private static DatabaseEntry MakeEntry(
         DatabaseStatus status,
         string fileName = "a.db",
@@ -417,16 +891,40 @@ private static DatabaseEntry MakeEntry(
         bool backupExists = false) =>
         new(fileName, $@"C:\dbs\{fileName}", isEnabled, status, backupExists);
 
+    private static BannerProgressEntry MakeProgress(
+        string currentEntryName = "a.db",
+        UpgradePhase currentPhase = UpgradePhase.MigratingSchema,
+        int currentBatchPosition = 1,
+        int currentBatchSize = 1,
+        int queuedBatchesAfter = 0,
+        UpgradeProgressScope scope = UpgradeProgressScope.ManageDatabasesTriggered,
+        Action? cancel = null) =>
+        new(
+            UpgradeBatchId.Create(),
+            scope,
+            currentBatchPosition,
+            currentBatchSize,
+            currentEntryName,
+            currentPhase,
+            queuedBatchesAfter,
+            cancel ?? (() => { }));
+
     private IRenderedComponent<DatabaseEntryRow> RenderRow(
         DatabaseEntry entry,
         bool isClassificationPending = false,
         bool isUpgrading = false,
         bool isUpgradeBlocked = false,
-        bool effectiveEnabled = false) =>
+        bool effectiveEnabled = false,
+        bool isTogglePending = false,
+        bool isSelected = false,
+        BannerProgressEntry? upgradeProgress = null) =>
         Render<DatabaseEntryRow>(parameters => parameters
             .Add(p => p.Entry, entry)
             .Add(p => p.IsClassificationPending, isClassificationPending)
             .Add(p => p.IsUpgrading, isUpgrading)
             .Add(p => p.IsUpgradeBlocked, isUpgradeBlocked)
-            .Add(p => p.EffectiveEnabled, effectiveEnabled));
+            .Add(p => p.EffectiveEnabled, effectiveEnabled)
+            .Add(p => p.IsTogglePending, isTogglePending)
+            .Add(p => p.IsSelected, isSelected)
+            .Add(p => p.UpgradeProgress, upgradeProgress));
 }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseRecoveryDialogTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseRecoveryDialogTests.cs
index c9e4d7a7..5aff78aa 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseRecoveryDialogTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseRecoveryDialogTests.cs
@@ -9,6 +9,7 @@
 using EventLogExpert.Runtime.Database;
 using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.Database;
+using EventLogExpert.UI.Tests.TestUtils;
 using Fluxor;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
@@ -30,6 +31,8 @@ public sealed class DatabaseRecoveryDialogTests : BunitContext
 
     public DatabaseRecoveryDialogTests()
     {
+        Services.AddBannerHostDependencies();
+
         _databaseService.Entries.Returns([]);
         _modalService.ActiveModalId.Returns(_modalId);
 
diff --git a/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/FakeDatabaseService.cs b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/FakeDatabaseService.cs
new file mode 100644
index 00000000..a74812bc
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/FakeDatabaseService.cs
@@ -0,0 +1,101 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Database;
+using EventLogExpert.Runtime.Database.Upgrade;
+
+namespace EventLogExpert.UI.Tests.DatabaseTools.Tabs;
+
+/// <summary>
+///     Test-only fake of <see cref="IDatabaseService" /> that exposes real CLR field-like events and their
+///     invocation-list counts via <see cref="EntriesChangedHandlerCount" /> /
+///     <see cref="UpgradeBatchCompletedHandlerCount" />. NSubstitute proxies do not surface <c>GetInvocationList()</c> on
+///     intercepted events, so a hand-rolled fake is the cleanest way to assert unsubscribe coverage from the
+///     disposal-regression test.
+/// </summary>
+internal sealed class FakeDatabaseService : IDatabaseService
+{
+    public event EventHandler? EntriesChanged;
+
+    public event EventHandler<UpgradeBatchCompletedEventArgs>? UpgradeBatchCompleted;
+
+    public IReadOnlyList<DatabaseEntry> Entries { get; set; } = [];
+
+    public int EntriesChangedHandlerCount => EntriesChanged?.GetInvocationList().Length ?? 0;
+
+    public Task InitialClassificationTask { get; set; } = Task.CompletedTask;
+
+    public int QueuedBatchCount => 0;
+
+    public int RestoreFromBackupCalls { get; private set; }
+
+    public bool RestoreFromBackupReturnValue { get; set; } = true;
+
+    public int RetryClassificationCalls { get; private set; }
+
+    public int UpgradeBatchCompletedHandlerCount => UpgradeBatchCompleted?.GetInvocationList().Length ?? 0;
+
+    public Task ClassifyEntriesAsync(CancellationToken cancellationToken = default) => Task.CompletedTask;
+
+    public Task<bool> DeleteEntryWithBackupAsync(string fileName, CancellationToken cancellationToken = default) =>
+        Task.FromResult(true);
+
+    public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+
+    public Task<IReadOnlyList<string>> EnumerateZipDbEntryNamesAsync(
+        string sourceZipPath,
+        CancellationToken cancellationToken = default) =>
+        Task.FromResult<IReadOnlyList<string>>([]);
+
+    public Task<ImportResult> ImportAsync(
+        IEnumerable<string> sourceFilePaths,
+        CancellationToken cancellationToken = default) =>
+        Task.FromResult(new ImportResult(0, [], []));
+
+    public Task<ImportResult> ImportAsync(
+        IEnumerable<string> sourceFilePaths,
+        IReadOnlySet<string> skipFileNames,
+        CancellationToken cancellationToken = default) =>
+        Task.FromResult(new ImportResult(0, [], []));
+
+    public void MarkStatus(string fileName, DatabaseStatus status) { }
+
+    public void RaiseEntriesChanged() => EntriesChanged?.Invoke(this, EventArgs.Empty);
+
+    public void RaiseUpgradeBatchCompleted(UpgradeBatchCompletedEventArgs args) =>
+        UpgradeBatchCompleted?.Invoke(this, args);
+
+    public void Refresh() { }
+
+    public Task RemoveAsync(
+        string fileName,
+        Func<CancellationToken, Task>? prepareForDeletionAsync = null,
+        CancellationToken cancellationToken = default) =>
+        Task.CompletedTask;
+
+    public Task<bool> RestoreFromBackupAsync(string fileName, CancellationToken cancellationToken = default)
+    {
+        RestoreFromBackupCalls++;
+        return Task.FromResult(RestoreFromBackupReturnValue);
+    }
+
+    public Task RetryClassificationAsync(string fileName, CancellationToken cancellationToken = default)
+    {
+        RetryClassificationCalls++;
+        return Task.CompletedTask;
+    }
+
+    public void Toggle(string fileName) { }
+
+    public Task<UpgradeBatchResult> UpgradeBatchAsync(
+        IReadOnlyList<string> fileNames,
+        UpgradeProgressScope scope,
+        CancellationToken cancellationToken = default) =>
+        Task.FromResult(new UpgradeBatchResult([], [], []));
+
+#pragma warning disable CS0067 // Events not raised in test fakes; declared only to satisfy the interface.
+    public event EventHandler<UpgradeBatchProgressEventArgs>? UpgradeBatchProgress;
+
+    public event EventHandler<UpgradeBatchStartedEventArgs>? UpgradeBatchStarted;
+#pragma warning restore CS0067
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/FakeInlineAlertSurface.cs b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/FakeInlineAlertSurface.cs
new file mode 100644
index 00000000..8ba4bc3a
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/FakeInlineAlertSurface.cs
@@ -0,0 +1,22 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.UI.DatabaseTools;
+
+namespace EventLogExpert.UI.Tests.DatabaseTools.Tabs;
+
+internal sealed class FakeInlineAlertSurface : IInlineAlertSurface
+{
+    public List<InlineAlertRequest> Requests { get; } = [];
+
+    public InlineAlertResult Result { get; set; } = new(false, null);
+
+    public Task<InlineAlertResult> ShowInlineAlertAsync(
+        InlineAlertRequest request,
+        CancellationToken cancellationToken)
+    {
+        Requests.Add(request);
+        return Task.FromResult(Result);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/ManageDatabasesEmptyStateTests.cs b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/ManageDatabasesEmptyStateTests.cs
new file mode 100644
index 00000000..3076a33b
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/ManageDatabasesEmptyStateTests.cs
@@ -0,0 +1,40 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.UI.DatabaseTools.Tabs;
+
+namespace EventLogExpert.UI.Tests.DatabaseTools.Tabs;
+
+public sealed class ManageDatabasesEmptyStateTests : BunitContext
+{
+    [Fact]
+    public void ManageDatabasesEmptyState_BoldsImportButtonReferenceForVisualHierarchy()
+    {
+        var component = Render<ManageDatabasesEmptyState>();
+
+        var strong = component.Find(".manage-databases-empty strong");
+        Assert.Equal("Import database\u2026", strong.TextContent);
+    }
+
+    [Fact]
+    public void ManageDatabasesEmptyState_HasNoRoleAttribute_StaticContentNotLiveRegion()
+    {
+        var component = Render<ManageDatabasesEmptyState>();
+
+        var empty = component.Find(".manage-databases-empty");
+        Assert.False(
+            empty.HasAttribute("role"),
+            "static empty state should not declare role=status; live-region semantics are reserved for dynamic announcements");
+    }
+
+    [Fact]
+    public void ManageDatabasesEmptyState_RendersInstructionsReferencingImportButton()
+    {
+        var component = Render<ManageDatabasesEmptyState>();
+
+        var empty = component.Find(".manage-databases-empty");
+        Assert.Contains("Import a provider database", empty.TextContent);
+        Assert.Contains("Import database\u2026", empty.TextContent);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/ManageDatabasesTabTests.cs b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/ManageDatabasesTabTests.cs
new file mode 100644
index 00000000..25b8ecca
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/ManageDatabasesTabTests.cs
@@ -0,0 +1,751 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.Runtime.Announcement;
+using EventLogExpert.Runtime.Banner;
+using EventLogExpert.Runtime.Database;
+using EventLogExpert.Runtime.Database.Upgrade;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.UI.DatabaseTools;
+using EventLogExpert.UI.DatabaseTools.Tabs;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Web;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+using System.Reflection;
+using TestContext = Xunit.TestContext;
+
+namespace EventLogExpert.UI.Tests.DatabaseTools.Tabs;
+
+public sealed class ManageDatabasesTabTests : BunitContext
+{
+    private readonly IAnnouncementService _announcementService = Substitute.For<IAnnouncementService>();
+    private readonly IDatabaseOperationCoordinator _coordinator = Substitute.For<IDatabaseOperationCoordinator>();
+    private readonly FakeDatabaseService _databaseService = new();
+    private readonly ILogReloadCoordinator _logReloadCoordinator = Substitute.For<ILogReloadCoordinator>();
+    private readonly IProgressBannerService _progressBannerService = Substitute.For<IProgressBannerService>();
+    private readonly ITraceLogger _traceLogger = Substitute.For<ITraceLogger>();
+
+    public ManageDatabasesTabTests()
+    {
+        _progressBannerService.ManageDatabasesProgress.Returns((BannerProgressEntry?)null);
+        _logReloadCoordinator.HasActiveLogs.Returns(false);
+
+        Services.AddSingleton(_announcementService);
+        Services.AddSingleton(_coordinator);
+        Services.AddSingleton<IDatabaseService>(_databaseService);
+        Services.AddSingleton(_logReloadCoordinator);
+        Services.AddSingleton(_progressBannerService);
+        Services.AddSingleton(_traceLogger);
+
+        JSInterop.Mode = JSRuntimeMode.Loose;
+    }
+
+    [Fact]
+    public async Task ApplyPendingTogglesAsync_WhenIsUpgradeBlocked_ReturnsFalseAndDoesNotInvokeCoordinator()
+    {
+        _coordinator.IsAnyUpgradeInFlight.Returns(true);
+        var component = Render<ManageDatabasesTab>();
+
+        var saved = await component.InvokeAsync(component.Instance.ApplyPendingTogglesAsync);
+
+        Assert.False(saved);
+        await _coordinator.DidNotReceive().ApplyPendingTogglesAsync(Arg.Any<IReadOnlyCollection<string>>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task ApplyPendingTogglesAsync_WithNoPendingToggles_ReturnsTrue_NoAnnounce()
+    {
+        var component = Render<ManageDatabasesTab>();
+
+        var saved = await component.InvokeAsync(component.Instance.ApplyPendingTogglesAsync);
+
+        Assert.True(saved);
+        _announcementService.DidNotReceive().Announce(Arg.Any<string>());
+    }
+
+    [Fact]
+    public async Task BulkRemove_ConfirmationAccepted_InvokesCoordinatorPerFile()
+    {
+        _databaseService.Entries = [
+            Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready),
+            Entry("b.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        _coordinator.RemoveDatabaseAsync(
+                Arg.Any<string>(),
+                Arg.Any<Func<bool, CancellationToken, Task<bool>>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(new RemoveOutcome(RemoveOutcomeStatus.Confirmed, true, false));
+        var alertSurface = new FakeInlineAlertSurface { Result = new InlineAlertResult(true, null) };
+        var component = RenderWithAlertSurface(alertSurface);
+
+        var checkboxes = component.FindAll(".db-entry-row input[type='checkbox']");
+        await component.InvokeAsync(() => checkboxes[0].ChangeAsync(new ChangeEventArgs { Value = true }));
+        await component.InvokeAsync(() => checkboxes[1].ChangeAsync(new ChangeEventArgs { Value = true }));
+
+        var bulkRemove = component.FindAll(".manage-databases-bulk-strip button")[1];
+        await component.InvokeAsync(() => bulkRemove.Click());
+
+        await _coordinator.Received(1).RemoveDatabaseAsync(
+            "a.db",
+            Arg.Any<Func<bool, CancellationToken, Task<bool>>>(),
+            Arg.Any<CancellationToken>());
+        await _coordinator.Received(1).RemoveDatabaseAsync(
+            "b.db",
+            Arg.Any<Func<bool, CancellationToken, Task<bool>>>(),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task BulkRemove_ConfirmationDeclined_DoesNotInvokeCoordinator()
+    {
+        _databaseService.Entries = [
+            Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready),
+            Entry("b.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        var alertSurface = new FakeInlineAlertSurface { Result = new InlineAlertResult(false, null) };
+        var component = RenderWithAlertSurface(alertSurface);
+
+        var checkboxes = component.FindAll(".db-entry-row input[type='checkbox']");
+        await component.InvokeAsync(() => checkboxes[0].ChangeAsync(new ChangeEventArgs { Value = true }));
+        await component.InvokeAsync(() => checkboxes[1].ChangeAsync(new ChangeEventArgs { Value = true }));
+
+        var bulkRemove = component.FindAll(".manage-databases-bulk-strip button")[1];
+        await component.InvokeAsync(() => bulkRemove.Click());
+
+        await _coordinator.DidNotReceive().RemoveDatabaseAsync(
+            Arg.Any<string>(),
+            Arg.Any<Func<bool, CancellationToken, Task<bool>>>(),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task BulkRemove_DuringBackgroundUpgrade_DualSignal_AcceptanceLabelMentionsCancel()
+    {
+        var entry = Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready);
+        _databaseService.Entries = [entry];
+
+        _coordinator.IsUpgradeInFlight("a.db").Returns(false);
+        _progressBannerService.BackgroundProgress.Returns(MakeProgress(
+            currentEntryName: "a.db",
+            scope: UpgradeProgressScope.Background));
+
+        var alertSurface = new FakeInlineAlertSurface { Result = new InlineAlertResult(false, null) };
+        var component = RenderWithAlertSurface(alertSurface);
+
+        await component.InvokeAsync(() => component.Find(".db-entry-row input[type='checkbox']").ChangeAsync(new ChangeEventArgs { Value = true }));
+        var bulkRemove = component.FindAll(".manage-databases-bulk-strip button")[1];
+        await component.InvokeAsync(() => bulkRemove.Click());
+
+        var captured = Assert.Single(alertSurface.Requests);
+        Assert.Contains("Cancel", captured.AcceptLabel ?? string.Empty, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("upgrade", captured.AcceptLabel ?? string.Empty, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("a.db", captured.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task BulkRemove_LogsReopened_CallsConsumeReopenedAsBaseline()
+    {
+        _databaseService.Entries = [
+            Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready),
+            Entry("b.db", isEnabled: true, status: DatabaseStatus.Ready)];
+
+        _coordinator.RemoveDatabaseAsync(
+                Arg.Any<string>(),
+                Arg.Any<Func<bool, CancellationToken, Task<bool>>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(new RemoveOutcome(RemoveOutcomeStatus.Confirmed, true, true));
+        var alertSurface = new FakeInlineAlertSurface { Result = new InlineAlertResult(true, null) };
+        var component = RenderWithAlertSurface(alertSurface);
+
+        _databaseService.RaiseUpgradeBatchCompleted(
+            new UpgradeBatchCompletedEventArgs(
+                UpgradeBatchId.Create(),
+                new UpgradeBatchResult(["a.db"], [], []),
+                wasCancelled: false));
+        Assert.True(component.Instance.HasDatabaseStateChanged);
+
+        var checkboxes = component.FindAll(".db-entry-row input[type='checkbox']");
+        await component.InvokeAsync(() => checkboxes[0].ChangeAsync(new ChangeEventArgs { Value = true }));
+        await component.InvokeAsync(() => checkboxes[1].ChangeAsync(new ChangeEventArgs { Value = true }));
+
+        var bulkRemove = component.FindAll(".manage-databases-bulk-strip button")[1];
+        await component.InvokeAsync(() => bulkRemove.Click());
+
+        Assert.False(component.Instance.HasDatabaseStateChanged);
+    }
+
+    [Fact]
+    public async Task BulkRemove_PerFileFailure_AnnouncesFirstFailureDetail()
+    {
+        _databaseService.Entries = [
+            Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready),
+            Entry("b.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        _coordinator.RemoveDatabaseAsync("a.db", Arg.Any<Func<bool, CancellationToken, Task<bool>>>(), Arg.Any<CancellationToken>())
+            .Returns<RemoveOutcome>(_ => throw new InvalidOperationException("disk full"));
+        _coordinator.RemoveDatabaseAsync("b.db", Arg.Any<Func<bool, CancellationToken, Task<bool>>>(), Arg.Any<CancellationToken>())
+            .Returns(new RemoveOutcome(RemoveOutcomeStatus.Confirmed, true, false));
+        var alertSurface = new FakeInlineAlertSurface { Result = new InlineAlertResult(true, null) };
+        var component = RenderWithAlertSurface(alertSurface);
+
+        var checkboxes = component.FindAll(".db-entry-row input[type='checkbox']");
+        await component.InvokeAsync(() => checkboxes[0].ChangeAsync(new ChangeEventArgs { Value = true }));
+        await component.InvokeAsync(() => checkboxes[1].ChangeAsync(new ChangeEventArgs { Value = true }));
+
+        var bulkRemove = component.FindAll(".manage-databases-bulk-strip button")[1];
+        await component.InvokeAsync(() => bulkRemove.Click());
+
+        _announcementService.Received().Announce(Arg.Is<string>(s => s.Contains("a.db") && s.Contains("disk full")));
+    }
+
+    [Fact]
+    public async Task ClearSelection_EmptiesSet_HidesBulkStrip()
+    {
+        _databaseService.Entries = [
+            Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready),
+            Entry("b.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        var component = Render<ManageDatabasesTab>();
+
+        var checkboxes = component.FindAll(".db-entry-row input[type='checkbox']");
+        await component.InvokeAsync(() => checkboxes[0].ChangeAsync(new ChangeEventArgs { Value = true }));
+        await component.InvokeAsync(() => checkboxes[1].ChangeAsync(new ChangeEventArgs { Value = true }));
+        Assert.Contains("2 selected", component.Find(".manage-databases-bulk-count").TextContent);
+
+        var clearBtn = component.FindAll(".manage-databases-bulk-strip button")[0];
+        await component.InvokeAsync(() => clearBtn.Click());
+
+        Assert.False(component.Instance.HasSelectedForRemoval);
+        Assert.Empty(component.FindAll(".manage-databases-bulk-strip"));
+    }
+
+    [Fact]
+    public async Task ClearSelection_UpdatesAriaLiveAnnouncement()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        var component = Render<ManageDatabasesTab>();
+
+        await component.InvokeAsync(() => component.Find(".db-entry-row input[type='checkbox']").ChangeAsync(new ChangeEventArgs { Value = true }));
+        var liveRegion = component.Find(".manage-databases-tab > span[role='status'][aria-live='polite']");
+        Assert.NotEqual(string.Empty, liveRegion.TextContent.Trim());
+
+        var clearBtn = component.FindAll(".manage-databases-bulk-strip button")[0];
+        await component.InvokeAsync(() => clearBtn.Click());
+
+        liveRegion = component.Find(".manage-databases-tab > span[role='status'][aria-live='polite']");
+        Assert.DoesNotContain("selected", liveRegion.TextContent, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task ConfirmationMessage_WhenNoActiveLogs_DoesNotIncludeCloseReopenWarning()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready)];
+        _logReloadCoordinator.HasActiveLogs.Returns(false);
+
+        var alertSurface = new FakeInlineAlertSurface { Result = new InlineAlertResult(false, null) };
+        var component = RenderWithAlertSurface(alertSurface);
+
+        var removeBtn = component.Find(".db-entry-row .db-entry-remove-btn");
+        await component.InvokeAsync(() => removeBtn.Click());
+
+        var captured = Assert.Single(alertSurface.Requests);
+        Assert.DoesNotContain("close and reopen", captured.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task ConfirmationMessage_WhenRemovingActiveDbWithOpenLogs_IncludesCloseReopenWarning()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready)];
+        _logReloadCoordinator.HasActiveLogs.Returns(true);
+
+        var alertSurface = new FakeInlineAlertSurface { Result = new InlineAlertResult(false, null) };
+        var component = RenderWithAlertSurface(alertSurface);
+
+        var removeBtn = component.Find(".db-entry-row .db-entry-remove-btn");
+        await component.InvokeAsync(() => removeBtn.Click());
+
+        var captured = Assert.Single(alertSurface.Requests);
+        Assert.Contains("close and reopen", captured.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task ConfirmationMessage_WhenRemovingDisabledDb_DoesNotIncludeCloseReopenWarning()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        _logReloadCoordinator.HasActiveLogs.Returns(true);
+
+        var alertSurface = new FakeInlineAlertSurface { Result = new InlineAlertResult(false, null) };
+        var component = RenderWithAlertSurface(alertSurface);
+
+        var removeBtn = component.Find(".db-entry-row .db-entry-remove-btn");
+        await component.InvokeAsync(() => removeBtn.Click());
+
+        var captured = Assert.Single(alertSurface.Requests);
+        Assert.DoesNotContain("close and reopen", captured.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task DisposeAsync_UnsubscribesAllEvents()
+    {
+        var component = Render<ManageDatabasesTab>();
+
+        Assert.Equal(1, _databaseService.EntriesChangedHandlerCount);
+        Assert.Equal(1, _databaseService.UpgradeBatchCompletedHandlerCount);
+
+        await component.InvokeAsync(() => component.Instance.DisposeAsync().AsTask());
+
+        Assert.Equal(0, _databaseService.EntriesChangedHandlerCount);
+        Assert.Equal(0, _databaseService.UpgradeBatchCompletedHandlerCount);
+    }
+
+    [Fact]
+    public void HasDatabaseStateChanged_AfterEnabledEntryRemovedFromActiveSet_True()
+    {
+        // Active set was {a}; mutate underlying entries so set becomes {}; flag computed via diff.
+        var entry = Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready);
+        _databaseService.Entries = [entry];
+        var component = Render<ManageDatabasesTab>();
+
+        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
+
+        Assert.True(component.Instance.HasDatabaseStateChanged);
+    }
+
+    [Fact]
+    public async Task HasDatabaseStateChanged_AfterImportNoChanges_False()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready)];
+        _coordinator.ImportAsync(
+                Arg.Any<Func<string, CancellationToken, Task<bool>>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(ImportOutcome.None);
+        var component = Render<ManageDatabasesTab>();
+
+        var importBtn = component.Find("#manage-import-button");
+        await component.InvokeAsync(() => importBtn.ClickAsync(new MouseEventArgs()));
+
+        Assert.False(component.Instance.HasDatabaseStateChanged);
+    }
+
+    [Fact]
+    public async Task HasDatabaseStateChanged_AfterImportSuccess_True_ViaStickyFlag()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready)];
+        _coordinator.ImportAsync(
+                Arg.Any<Func<string, CancellationToken, Task<bool>>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(new ImportOutcome(ImportedCount: 1, Failures: [], UpgradeFailures: []));
+        var component = Render<ManageDatabasesTab>();
+
+        var importBtn = component.Find("#manage-import-button");
+        await component.InvokeAsync(() => importBtn.ClickAsync(new MouseEventArgs()));
+
+        Assert.True(component.Instance.HasDatabaseStateChanged);
+    }
+
+    [Fact]
+    public void HasDatabaseStateChanged_AfterUpgradeCancelledWithNoSucceeded_False()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready)];
+        var component = Render<ManageDatabasesTab>();
+
+        _databaseService.RaiseUpgradeBatchCompleted(
+            new UpgradeBatchCompletedEventArgs(UpgradeBatchId.Create(), new UpgradeBatchResult([], ["a.db"], []), wasCancelled: true));
+
+        Assert.False(component.Instance.HasDatabaseStateChanged);
+    }
+
+    [Fact]
+    public void HasDatabaseStateChanged_AfterUpgradeFailedWithNoSucceeded_False()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready)];
+        var component = Render<ManageDatabasesTab>();
+
+        _databaseService.RaiseUpgradeBatchCompleted(
+            new UpgradeBatchCompletedEventArgs(
+                UpgradeBatchId.Create(),
+                new UpgradeBatchResult([], [], [new UpgradeFailure("a.db", "boom")]),
+                wasCancelled: false));
+
+        Assert.False(component.Instance.HasDatabaseStateChanged);
+    }
+
+    [Fact]
+    public void HasDatabaseStateChanged_AfterUpgradeSuccess_True_ViaStickyFlag()
+    {
+        var entry = Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready);
+        _databaseService.Entries = [entry];
+        var component = Render<ManageDatabasesTab>();
+
+        // Schema migrated in place — entry stays in the active set, but the underlying data changed.
+        _databaseService.RaiseUpgradeBatchCompleted(
+            new UpgradeBatchCompletedEventArgs(UpgradeBatchId.Create(), new UpgradeBatchResult(["a.db"], [], []), wasCancelled: false));
+
+        Assert.True(component.Instance.HasDatabaseStateChanged);
+    }
+
+    [Fact]
+    public void HasDatabaseStateChanged_InitialState_False()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready)];
+
+        var component = Render<ManageDatabasesTab>();
+
+        Assert.False(component.Instance.HasDatabaseStateChanged);
+    }
+
+    [Fact]
+    public void HasDatabaseStateChanged_PartiallySucceededWasCancelled_True()
+    {
+        // Multi-file batch: A succeeds, B is cancelled mid-flight. A's schema is permanently migrated;
+        // flag must fire even though args.WasCancelled is true.
+        _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready)];
+        var component = Render<ManageDatabasesTab>();
+
+        _databaseService.RaiseUpgradeBatchCompleted(
+            new UpgradeBatchCompletedEventArgs(
+                UpgradeBatchId.Create(),
+                new UpgradeBatchResult(["a.db"], ["b.db"], []),
+                wasCancelled: true));
+
+        Assert.True(component.Instance.HasDatabaseStateChanged);
+    }
+
+    [Fact]
+    public void HasDatabaseStateChanged_UpgradeSucceededForDisabledEntry_False()
+    {
+        // Background-scope upgrades of disabled (non-active) DBs must not trigger the reload prompt:
+        // the file isn't in the active resolver set, so open logs aren't affected.
+        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        var component = Render<ManageDatabasesTab>();
+
+        _databaseService.RaiseUpgradeBatchCompleted(
+            new UpgradeBatchCompletedEventArgs(UpgradeBatchId.Create(), new UpgradeBatchResult(["a.db"], [], []), wasCancelled: false));
+
+        Assert.False(component.Instance.HasDatabaseStateChanged);
+    }
+
+    [Fact]
+    public void IsUpgradeInFlight_TracksCoordinator()
+    {
+        _coordinator.IsAnyUpgradeInFlight.Returns(true);
+        var component = Render<ManageDatabasesTab>();
+
+        Assert.True(component.Instance.IsUpgradeInFlight);
+    }
+
+    [Fact]
+    public async Task RebaselineActiveSnapshotOnly_PreservesStickyFlags()
+    {
+        // Modal opens mid-classification (empty snapshot), user-initiated upgrade succeeds during the
+        // wait (_schemaUpgradeOccurred=true), classification completes. The snapshot rebaselines but
+        // the sticky flag must survive so the close-time reload prompt still fires.
+        var tcs = new TaskCompletionSource();
+        _databaseService.InitialClassificationTask = tcs.Task;
+        _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready)];
+        var component = Render<ManageDatabasesTab>();
+
+        _databaseService.RaiseUpgradeBatchCompleted(
+            new UpgradeBatchCompletedEventArgs(UpgradeBatchId.Create(), new UpgradeBatchResult(["a.db"], [], []), wasCancelled: false));
+
+        Assert.True(component.Instance.HasDatabaseStateChanged);
+
+        tcs.SetResult();
+        await Task.Delay(50, TestContext.Current.CancellationToken);
+
+        Assert.True(component.Instance.HasDatabaseStateChanged);
+    }
+
+    [Fact]
+    public void Render_BulkStrip_HiddenWhenNoSelection()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
+
+        var component = Render<ManageDatabasesTab>();
+
+        Assert.Empty(component.FindAll(".manage-databases-bulk-strip"));
+        Assert.False(component.Instance.HasSelectedForRemoval);
+    }
+
+    [Fact]
+    public void Render_ClassificationPendingNotice_WhenClassificationInProgress()
+    {
+        _databaseService.Entries = [];
+        _databaseService.InitialClassificationTask = new TaskCompletionSource().Task;
+
+        var component = Render<ManageDatabasesTab>();
+
+        Assert.Single(component.FindAll(".manage-status-banner--info"));
+        Assert.Empty(component.FindAll(".manage-databases-empty"));
+    }
+
+    [Fact]
+    public void Render_DoesNotRenderRemovedSharedProgressBanner()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.UpgradeRequired)];
+        _progressBannerService.ManageDatabasesProgress.Returns(MakeProgress(currentEntryName: "a.db"));
+
+        var component = Render<ManageDatabasesTab>();
+
+        Assert.Empty(component.FindAll("aside.manage-databases-upgrade-banner"));
+    }
+
+    [Fact]
+    public void Render_EmptyState_WhenNoEntries_AndClassificationComplete()
+    {
+        _databaseService.Entries = [];
+        _databaseService.InitialClassificationTask = Task.CompletedTask;
+
+        var component = Render<ManageDatabasesTab>();
+
+        Assert.Single(component.FindAll(".manage-databases-empty"));
+    }
+
+    [Fact]
+    public void Render_HasPendingChanges_False_HidesSaveStrip()
+    {
+        var component = Render<ManageDatabasesTab>();
+
+        Assert.Empty(component.FindAll(".manage-databases-save-strip"));
+    }
+
+    [Fact]
+    public void Render_ImportButton_Present()
+    {
+        var component = Render<ManageDatabasesTab>();
+
+        Assert.Single(component.FindAll("#manage-import-button"));
+    }
+
+    [Fact]
+    public void Render_PersistentAriaLiveRegion_PresentRegardlessOfSelection()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
+
+        var component = Render<ManageDatabasesTab>();
+
+        var statusRegion = component.Find(".manage-databases-tab > span[role='status'][aria-live='polite']");
+        Assert.NotNull(statusRegion);
+        Assert.Equal("true", statusRegion.GetAttribute("aria-atomic"));
+    }
+
+    [Fact]
+    public async Task RestoreFromBackup_ServiceReturnsFalse_DoesNotSetRestorationFlag()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.UpgradeRequired, backupExists: true)];
+        _databaseService.RestoreFromBackupReturnValue = false;
+        var component = Render<ManageDatabasesTab>();
+
+        await component.InvokeAsync(() =>
+            ((Task)component.Instance.GetType()
+                .GetMethod("RestoreFromBackup", BindingFlags.NonPublic | BindingFlags.Instance)!
+                .Invoke(component.Instance, [_databaseService.Entries[0]])!));
+
+        Assert.Equal(1, _databaseService.RestoreFromBackupCalls);
+        Assert.False(component.Instance.HasDatabaseStateChanged);
+        _announcementService.Received(1).Announce(Arg.Is<string>(s => s.Contains("Could not restore")));
+        _announcementService.DidNotReceive().Announce(Arg.Is<string>(s => s.StartsWith("Restored ")));
+    }
+
+    [Fact]
+    public async Task RestoreFromBackup_ServiceReturnsTrue_SetsStickyFlag_AndAnnouncesSuccess()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.UpgradeRequired, backupExists: true)];
+        _databaseService.RestoreFromBackupReturnValue = true;
+        var component = Render<ManageDatabasesTab>();
+
+        await component.InvokeAsync(() =>
+            ((Task)component.Instance.GetType()
+                .GetMethod("RestoreFromBackup", BindingFlags.NonPublic | BindingFlags.Instance)!
+                .Invoke(component.Instance, [_databaseService.Entries[0]])!));
+
+        Assert.Equal(1, _databaseService.RestoreFromBackupCalls);
+        Assert.True(component.Instance.HasDatabaseStateChanged);
+        _announcementService.Received(1).Announce(Arg.Is<string>(s => s.StartsWith("Restored ")));
+    }
+
+    [Fact]
+    public async Task RestoreFromBackup_WhileUpgradeInFlight_DoesNotInvokeService()
+    {
+        // Prevents the race where DatabaseRecoveryService.RestoreFromBackupAsync triggers
+        // ClassifyEntriesAsync, deleting a .upgrade.bak that an in-flight upgrade still needs.
+        _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.UpgradeRequired, backupExists: true)];
+        _coordinator.IsAnyUpgradeInFlight.Returns(true);
+        var component = Render<ManageDatabasesTab>();
+
+        await component.InvokeAsync(() =>
+            ((Task)component.Instance.GetType()
+                .GetMethod("RestoreFromBackup", BindingFlags.NonPublic | BindingFlags.Instance)!
+                .Invoke(component.Instance, [_databaseService.Entries[0]])!));
+
+        Assert.Equal(0, _databaseService.RestoreFromBackupCalls);
+        _announcementService.Received(1).Announce(Arg.Is<string>(s => s.Contains("Cannot restore")));
+    }
+
+    [Fact]
+    public void RowReceivesNullUpgradeProgress_WhenNeitherSlotMatchesFileName()
+    {
+        var entry = Entry("a.db", isEnabled: false, status: DatabaseStatus.UpgradeRequired);
+        _databaseService.Entries = [entry];
+        _progressBannerService.ManageDatabasesProgress.Returns(MakeProgress(currentEntryName: "different.db"));
+        _progressBannerService.BackgroundProgress.Returns(MakeProgress(
+            currentEntryName: "another.db",
+            scope: UpgradeProgressScope.Background));
+
+        var component = Render<ManageDatabasesTab>();
+
+        Assert.Empty(component.FindAll(".db-entry-upgrading-text"));
+        Assert.Empty(component.FindAll(".db-entry-cancel-btn"));
+    }
+
+    [Fact]
+    public void RowReceivesUpgradeProgress_WhenBackgroundSlotMatches()
+    {
+        var entry = Entry("b.db", isEnabled: false, status: DatabaseStatus.UpgradeRequired);
+        _databaseService.Entries = [entry];
+        _progressBannerService.BackgroundProgress.Returns(MakeProgress(
+            currentEntryName: "b.db",
+            currentBatchSize: 3,
+            currentBatchPosition: 2,
+            scope: UpgradeProgressScope.Background));
+        _coordinator.IsUpgradeInFlight("b.db").Returns(false);
+
+        var component = Render<ManageDatabasesTab>();
+
+        var text = component.Find(".db-entry-upgrading-text");
+        Assert.Contains("Migrating schema 2 of 3", text.TextContent);
+    }
+
+    [Fact]
+    public void RowReceivesUpgradeProgress_WhenManageDatabasesSlotMatches()
+    {
+        var entry = Entry("a.db", isEnabled: false, status: DatabaseStatus.UpgradeRequired);
+        _databaseService.Entries = [entry];
+        _progressBannerService.ManageDatabasesProgress.Returns(MakeProgress(
+            currentEntryName: "a.db",
+            currentBatchSize: 2,
+            currentBatchPosition: 1));
+        _coordinator.IsUpgradeInFlight("a.db").Returns(true);
+
+        var component = Render<ManageDatabasesTab>();
+
+        var text = component.Find(".db-entry-upgrading-text");
+        Assert.Contains("Migrating schema 1 of 2", text.TextContent);
+    }
+
+    [Fact]
+    public async Task SingleRowRemove_DuringCoordinatorUpgrade_DualSignal_AcceptanceLabelMentionsCancel()
+    {
+        var entry = Entry("a.db", isEnabled: false, status: DatabaseStatus.UpgradeRequired);
+        _databaseService.Entries = [entry];
+
+        _coordinator.IsUpgradeInFlight("a.db").Returns(true);
+        _progressBannerService.ManageDatabasesProgress.Returns(MakeProgress(
+            currentEntryName: "a.db",
+            scope: UpgradeProgressScope.ManageDatabasesTriggered));
+
+        var alertSurface = new FakeInlineAlertSurface { Result = new InlineAlertResult(false, null) };
+        var component = RenderWithAlertSurface(alertSurface);
+
+        await component.InvokeAsync(() => component.Find(".db-entry-remove-btn").Click());
+
+        var captured = Assert.Single(alertSurface.Requests);
+        Assert.Contains("Cancel", captured.AcceptLabel ?? string.Empty, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("upgrade", captured.AcceptLabel ?? string.Empty, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task ToggleSelection_AddsToSelection_RevealsBulkStrip()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        var component = Render<ManageDatabasesTab>();
+
+        await component.InvokeAsync(() => component.Find(".db-entry-row input[type='checkbox']").ChangeAsync(new ChangeEventArgs { Value = true }));
+
+        Assert.True(component.Instance.HasSelectedForRemoval);
+        Assert.Single(component.FindAll(".manage-databases-bulk-strip"));
+        Assert.Contains("1 selected", component.Find(".manage-databases-bulk-count").TextContent);
+    }
+
+    [Fact]
+    public async Task ToggleSelection_OnRemovedEntry_PrunedFromSelection()
+    {
+        _databaseService.Entries = [
+            Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready),
+            Entry("b.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        var component = Render<ManageDatabasesTab>();
+
+        var checkboxes = component.FindAll(".db-entry-row input[type='checkbox']");
+        await component.InvokeAsync(() => checkboxes[0].ChangeAsync(new ChangeEventArgs { Value = true }));
+        await component.InvokeAsync(() => checkboxes[1].ChangeAsync(new ChangeEventArgs { Value = true }));
+        Assert.Contains("2 selected", component.Find(".manage-databases-bulk-count").TextContent);
+
+        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        _databaseService.RaiseEntriesChanged();
+        await component.InvokeAsync(() => { });
+
+        Assert.True(component.Instance.HasSelectedForRemoval);
+        Assert.Contains("1 selected", component.Find(".manage-databases-bulk-count").TextContent);
+    }
+
+    [Fact]
+    public async Task ToggleSelection_TwiceOnSameRow_RemovesFromSelection()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        var component = Render<ManageDatabasesTab>();
+
+        await component.InvokeAsync(() => component.Find(".db-entry-row input[type='checkbox']").ChangeAsync(new ChangeEventArgs { Value = true }));
+        Assert.True(component.Instance.HasSelectedForRemoval);
+
+        await component.InvokeAsync(() => component.Find(".db-entry-row input[type='checkbox']").ChangeAsync(new ChangeEventArgs { Value = true }));
+
+        Assert.False(component.Instance.HasSelectedForRemoval);
+        Assert.Empty(component.FindAll(".manage-databases-bulk-strip"));
+    }
+
+    [Fact]
+    public async Task ToggleSelection_UpdatesAriaLiveAnnouncement()
+    {
+        _databaseService.Entries = [
+            Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready),
+            Entry("b.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        var component = Render<ManageDatabasesTab>();
+
+        var liveRegion = component.Find(".manage-databases-tab > span[role='status'][aria-live='polite']");
+        Assert.Equal(string.Empty, liveRegion.TextContent.Trim());
+
+        var checkboxes = component.FindAll(".db-entry-row input[type='checkbox']");
+        await component.InvokeAsync(() => checkboxes[0].ChangeAsync(new ChangeEventArgs { Value = true }));
+        liveRegion = component.Find(".manage-databases-tab > span[role='status'][aria-live='polite']");
+        Assert.Contains("1", liveRegion.TextContent);
+        Assert.Contains("selected", liveRegion.TextContent, StringComparison.OrdinalIgnoreCase);
+
+        await component.InvokeAsync(() => checkboxes[1].ChangeAsync(new ChangeEventArgs { Value = true }));
+        liveRegion = component.Find(".manage-databases-tab > span[role='status'][aria-live='polite']");
+        Assert.Contains("2", liveRegion.TextContent);
+    }
+
+    private static DatabaseEntry Entry(string fileName, bool isEnabled, DatabaseStatus status, bool backupExists = false) =>
+        new(fileName, $@"C:\dbs\{fileName}", isEnabled, status, backupExists);
+
+    private static BannerProgressEntry MakeProgress(
+        string currentEntryName = "a.db",
+        UpgradePhase currentPhase = UpgradePhase.MigratingSchema,
+        int currentBatchPosition = 1,
+        int currentBatchSize = 1,
+        int queuedBatchesAfter = 0,
+        UpgradeProgressScope scope = UpgradeProgressScope.ManageDatabasesTriggered) =>
+        new(
+            UpgradeBatchId.Create(),
+            scope,
+            currentBatchPosition,
+            currentBatchSize,
+            currentEntryName,
+            currentPhase,
+            queuedBatchesAfter,
+            () => { });
+
+    private IRenderedComponent<ManageDatabasesTab> RenderWithAlertSurface(IInlineAlertSurface alertSurface) =>
+        Render<ManageDatabasesTab>(parameters => parameters
+            .AddCascadingValue(alertSurface));
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/DebugLog/DebugLogModalTests.cs b/tests/Unit/EventLogExpert.UI.Tests/DebugLog/DebugLogModalTests.cs
index 50e6ee63..bfa0230b 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/DebugLog/DebugLogModalTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/DebugLog/DebugLogModalTests.cs
@@ -34,6 +34,8 @@ public sealed class DebugLogModalTests : BunitContext
 
     public DebugLogModalTests()
     {
+        Services.AddBannerHostDependencies();
+
         _modalService.ActiveModalId.Returns(new ModalId(1L));
 
         Services.AddSingleton(_alertDialogService);
diff --git a/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowChromeTests.cs b/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowChromeTests.cs
new file mode 100644
index 00000000..e6012f84
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowChromeTests.cs
@@ -0,0 +1,118 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.UI.FilterEditor;
+using Microsoft.AspNetCore.Components;
+
+namespace EventLogExpert.UI.Tests.FilterEditor;
+
+public sealed class FilterRowChromeTests : BunitContext
+{
+    [Fact]
+    public void SavedFilter_AllButtons_HaveTypeButton()
+    {
+        var savedFilter = MakeSavedFilter(isEnabled: true);
+
+        var component = RenderChrome(value: savedFilter);
+
+        var buttons = component.FindAll("button");
+        Assert.NotEmpty(buttons);
+        foreach (var button in buttons)
+        {
+            Assert.Equal("button", button.GetAttribute("type"));
+        }
+    }
+
+    [Fact]
+    public void SavedFilter_Disabled_RendersToggleNotVerbButton()
+    {
+        var savedFilter = MakeSavedFilter(isEnabled: false);
+
+        var component = RenderChrome(value: savedFilter);
+
+        var enableButton = component.FindAll("button")
+            .FirstOrDefault(b => b.TextContent.Contains("Enable"));
+        Assert.Null(enableButton);
+
+        var toggle = component.Find("input[role='switch']");
+        Assert.False(toggle.HasAttribute("checked"));
+    }
+
+    [Fact]
+    public void SavedFilter_Enabled_RendersToggleNotVerbButton()
+    {
+        var savedFilter = MakeSavedFilter(isEnabled: true);
+
+        var component = RenderChrome(value: savedFilter);
+
+        var disableButton = component.FindAll("button")
+            .FirstOrDefault(b => b.TextContent.Contains("Disable"));
+        Assert.Null(disableButton);
+
+        var toggle = component.Find("input[role='switch']");
+        Assert.True(toggle.HasAttribute("checked"));
+
+        Assert.False(toggle.HasAttribute("aria-label"));
+        Assert.False(string.IsNullOrEmpty(toggle.GetAttribute("aria-labelledby")));
+    }
+
+    [Fact]
+    public void SavedFilter_ShowToggleEnabledFalse_DoesNotRenderToggle()
+    {
+        var savedFilter = MakeSavedFilter(isEnabled: true);
+
+        var component = RenderChrome(value: savedFilter, showToggleEnabled: false);
+
+        Assert.Empty(component.FindAll("input[role='switch']"));
+    }
+
+    [Fact]
+    public void SavedFilter_Toggle_AriaLabelledByTargetsVisibleComparisonText()
+    {
+        var savedFilter = MakeSavedFilter(isEnabled: true);
+
+        var component = RenderChrome(value: savedFilter);
+
+        var toggle = component.Find("input[role='switch']");
+        var labelId = toggle.GetAttribute("aria-labelledby");
+        Assert.False(string.IsNullOrWhiteSpace(labelId));
+
+        var labelEl = component.Find($"#{labelId}");
+        Assert.Contains(savedFilter.ComparisonText, labelEl.TextContent);
+    }
+
+    [Fact]
+    public async Task Toggle_Change_InvokesOnToggleEnabled()
+    {
+        var savedFilter = MakeSavedFilter(isEnabled: false);
+        int invocations = 0;
+
+        var component = Render<FilterRowChrome>(parameters => parameters
+            .Add(p => p.Value, savedFilter)
+            .Add(p => p.ShowToggleEnabled, true)
+            .Add(p => p.OnToggleEnabled,
+                EventCallback.Factory.Create(this, () => invocations++)));
+
+        var toggle = component.Find("input[role='switch']");
+        await toggle.ChangeAsync(new ChangeEventArgs { Value = true });
+
+        Assert.Equal(1, invocations);
+    }
+
+    private static SavedFilter MakeSavedFilter(bool isEnabled) =>
+        new()
+        {
+            ComparisonText = "Id == 1000",
+            Compiled = null,
+            IsEnabled = isEnabled,
+        };
+
+    private IRenderedComponent<FilterRowChrome> RenderChrome(
+        SavedFilter? value,
+        bool showToggleEnabled = true) =>
+        Render<FilterRowChrome>(parameters => parameters
+            .Add(p => p.Value, value)
+            .Add(p => p.ShowToggleEnabled, showToggleEnabled));
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Inputs/CheckboxTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Inputs/CheckboxTests.cs
new file mode 100644
index 00000000..67fdc6ea
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/Inputs/CheckboxTests.cs
@@ -0,0 +1,180 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.UI.Inputs;
+using Microsoft.AspNetCore.Components;
+
+namespace EventLogExpert.UI.Tests.Inputs;
+
+public sealed class CheckboxTests : BunitContext
+{
+    [Fact]
+    public async Task Change_InvokesValueChangedWithNewValue()
+    {
+        bool? observedValue = null;
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.ValueChanged, v =>
+            {
+                observedValue = v;
+                return Task.CompletedTask;
+            }));
+
+        var input = component.Find("input[type='checkbox']");
+        await input.ChangeAsync(new ChangeEventArgs { Value = true });
+
+        Assert.True(observedValue);
+    }
+
+    [Fact]
+    public async Task Change_WhenDisabled_DoesNotInvokeValueChanged()
+    {
+        bool invoked = false;
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.Disabled, true)
+            .Add(p => p.ValueChanged, _ =>
+            {
+                invoked = true;
+                return Task.CompletedTask;
+            }));
+
+        var input = component.Find("input[type='checkbox']");
+        await input.ChangeAsync(new ChangeEventArgs { Value = true });
+
+        Assert.False(invoked);
+    }
+
+    [Fact]
+    public void Render_AriaDescribedBy_AppliedToInput()
+    {
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.AriaDescribedBy, "help-text-id"));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.Equal("help-text-id", input.GetAttribute("aria-describedby"));
+    }
+
+    [Fact]
+    public void Render_AriaLabel_AppliedToInput()
+    {
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.AriaLabel, "Select database foo.db"));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.Equal("Select database foo.db", input.GetAttribute("aria-label"));
+    }
+
+    [Fact]
+    public void Render_AriaLabelledBy_AppliedToInput()
+    {
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.AriaLabelledBy, "external-label-id"));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.Equal("external-label-id", input.GetAttribute("aria-labelledby"));
+    }
+
+    [Fact]
+    public void Render_AriaLabelledByAndAriaLabel_SuppressesAriaLabelPerWaiAriaPrecedence()
+    {
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.AriaLabel, "Should be suppressed")
+            .Add(p => p.AriaLabelledBy, "external-label-id"));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.False(input.HasAttribute("aria-label"));
+        Assert.Equal("external-label-id", input.GetAttribute("aria-labelledby"));
+    }
+
+    [Fact]
+    public void Render_CssClass_AppendedToLabel()
+    {
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.CssClass, "extra-class"));
+
+        var label = component.Find("label");
+        Assert.Contains("checkbox", label.ClassList);
+        Assert.Contains("extra-class", label.ClassList);
+    }
+
+    [Fact]
+    public void Render_DisabledFalse_InputNotDisabled()
+    {
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.Disabled, false));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.False(input.HasAttribute("disabled"));
+    }
+
+    [Fact]
+    public void Render_DisabledTrue_InputDisabled()
+    {
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.Disabled, true));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.True(input.HasAttribute("disabled"));
+    }
+
+    [Fact]
+    public void Render_TitleOnLabel_AppliedFromAriaLabel()
+    {
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.AriaLabel, "Tooltip text"));
+
+        var label = component.Find("label.checkbox");
+        Assert.Equal("Tooltip text", label.GetAttribute("title"));
+    }
+
+    [Fact]
+    public void Render_ValueFalse_IconIsSquare()
+    {
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, false));
+
+        var icon = component.Find(".checkbox-icon i");
+        Assert.Contains("bi-square", icon.ClassList);
+        Assert.DoesNotContain("bi-check-square-fill", icon.ClassList);
+    }
+
+    [Fact]
+    public void Render_ValueFalse_InputDoesNotHaveCheckedAttribute()
+    {
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, false));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.False(input.HasAttribute("checked"));
+    }
+
+    [Fact]
+    public void Render_ValueTrue_IconIsCheckSquareFill()
+    {
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, true));
+
+        var icon = component.Find(".checkbox-icon i");
+        Assert.Contains("bi-check-square-fill", icon.ClassList);
+    }
+
+    [Fact]
+    public void Render_ValueTrue_InputHasCheckedAttribute()
+    {
+        var component = Render<Checkbox>(parameters => parameters
+            .Add(p => p.Value, true));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.True(input.HasAttribute("checked"));
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Inputs/OptionSelectTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Inputs/OptionSelectTests.cs
new file mode 100644
index 00000000..1751093a
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/Inputs/OptionSelectTests.cs
@@ -0,0 +1,200 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.UI.Inputs;
+using Microsoft.AspNetCore.Components;
+
+namespace EventLogExpert.UI.Tests.Inputs;
+
+public sealed class OptionSelectTests : BunitContext
+{
+    [Fact]
+    public void Render_AriaDescribedBy_AppliedToRadiogroup()
+    {
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.AriaDescribedBy, "pending-status-id"));
+
+        var group = component.Find(".option-select");
+        Assert.Equal("pending-status-id", group.GetAttribute("aria-describedby"));
+    }
+
+    [Fact]
+    public void Render_AriaLabelledBy_AppliedToRadiogroup()
+    {
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.AriaLabelledBy, "filename-button-id"));
+
+        var group = component.Find(".option-select");
+        Assert.Equal("filename-button-id", group.GetAttribute("aria-labelledby"));
+    }
+
+    [Fact]
+    public void Render_AriaLabelledByAndAriaLabel_SuppressesOuterAriaLabelAndRadioPrefix()
+    {
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.AriaLabel, "Should be suppressed")
+            .Add(p => p.AriaLabelledBy, "filename-button-id")
+            .Add(p => p.DisabledString, "AND")
+            .Add(p => p.EnabledString, "OR"));
+
+        var group = component.Find(".option-select");
+        Assert.False(group.HasAttribute("aria-label"));
+        Assert.Equal("filename-button-id", group.GetAttribute("aria-labelledby"));
+
+        var radios = component.FindAll(".option-select input[type='radio']");
+        Assert.Equal("AND", radios[0].GetAttribute("aria-label"));
+        Assert.Equal("OR", radios[1].GetAttribute("aria-label"));
+    }
+
+    [Fact]
+    public void Render_AriaLabelOnly_PrependsOuterLabelOnEachRadio()
+    {
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.AriaLabel, "Should Compare")
+            .Add(p => p.DisabledString, "AND")
+            .Add(p => p.EnabledString, "OR"));
+
+        var radios = component.FindAll(".option-select input[type='radio']");
+        Assert.Equal("Should Compare AND", radios[0].GetAttribute("aria-label"));
+        Assert.Equal("Should Compare OR", radios[1].GetAttribute("aria-label"));
+    }
+
+    [Fact]
+    public void Render_CustomLabels_AreApplied()
+    {
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.DisabledString, "AND")
+            .Add(p => p.EnabledString, "OR"));
+
+        var labels = component.FindAll(".option-select label");
+        Assert.Equal("AND", labels[0].TextContent);
+        Assert.Equal("OR", labels[1].TextContent);
+    }
+
+    [Fact]
+    public void Render_DefaultId_IsUnique()
+    {
+        var first = Render<OptionSelect>(parameters => parameters.Add(p => p.Value, false));
+        var second = Render<OptionSelect>(parameters => parameters.Add(p => p.Value, false));
+
+        var firstName = first.Find(".option-select input[type='radio']").GetAttribute("name");
+        var secondName = second.Find(".option-select input[type='radio']").GetAttribute("name");
+
+        Assert.False(string.IsNullOrEmpty(firstName));
+        Assert.False(string.IsNullOrEmpty(secondName));
+        Assert.NotEqual(firstName, secondName);
+    }
+
+    [Fact]
+    public void Render_DefaultLabels_AreDisabledAndEnabled()
+    {
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, false));
+
+        var labels = component.FindAll(".option-select label");
+        Assert.Equal("Disabled", labels[0].TextContent);
+        Assert.Equal("Enabled", labels[1].TextContent);
+    }
+
+    [Fact]
+    public void Render_DefaultState_HasRadiogroupRole()
+    {
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, false));
+
+        var group = component.Find(".option-select");
+        Assert.Equal("radiogroup", group.GetAttribute("role"));
+    }
+
+    [Fact]
+    public void Render_Disabled_RendersDisabledOnBothInputs()
+    {
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.Disabled, true));
+
+        var radios = component.FindAll(".option-select input[type='radio']");
+        Assert.True(radios[0].HasAttribute("disabled"));
+        Assert.True(radios[1].HasAttribute("disabled"));
+    }
+
+    [Fact]
+    public void Render_RendersTwoRadioInputs()
+    {
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, false));
+
+        var radios = component.FindAll(".option-select input[type='radio']");
+        Assert.Equal(2, radios.Count);
+    }
+
+    [Fact]
+    public void Render_UseStatusColorsFalse_HasFalseDataAttribute()
+    {
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.UseStatusColors, false));
+
+        var labels = component.FindAll(".option-select label");
+        Assert.Equal("false", labels[0].GetAttribute("data-use-status-colors"));
+        Assert.Equal("false", labels[1].GetAttribute("data-use-status-colors"));
+    }
+
+    [Fact]
+    public void Render_UseStatusColorsTrue_AppliesDataAttributeToLabels()
+    {
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, true)
+            .Add(p => p.UseStatusColors, true));
+
+        var labels = component.FindAll(".option-select label");
+        Assert.Equal("true", labels[0].GetAttribute("data-use-status-colors"));
+        Assert.Equal("true", labels[1].GetAttribute("data-use-status-colors"));
+    }
+
+    [Fact]
+    public void Render_ValueFalse_ChecksFalseRadio()
+    {
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, false));
+
+        var radios = component.FindAll(".option-select input[type='radio']");
+        Assert.True(radios[0].HasAttribute("checked"));
+        Assert.False(radios[1].HasAttribute("checked"));
+    }
+
+    [Fact]
+    public void Render_ValueTrue_ChecksTrueRadio()
+    {
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, true));
+
+        var radios = component.FindAll(".option-select input[type='radio']");
+        Assert.False(radios[0].HasAttribute("checked"));
+        Assert.True(radios[1].HasAttribute("checked"));
+    }
+
+    [Fact]
+    public async Task TogglingTrueRadio_InvokesValueChanged()
+    {
+        bool? observedValue = null;
+        var component = Render<OptionSelect>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.ValueChanged, v =>
+            {
+                observedValue = v;
+                return Task.CompletedTask;
+            }));
+
+        var radios = component.FindAll(".option-select input[type='radio']");
+        await radios[1].ChangeAsync(new ChangeEventArgs { Value = "true" });
+
+        Assert.True(observedValue);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Inputs/TextInputTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Inputs/TextInputTests.cs
new file mode 100644
index 00000000..4088bfc8
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/Inputs/TextInputTests.cs
@@ -0,0 +1,56 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.UI.Inputs;
+
+namespace EventLogExpert.UI.Tests.Inputs;
+
+public sealed class TextInputTests : BunitContext
+{
+    [Fact]
+    public void Render_AriaDescribedBy_AppliedToInput()
+    {
+        var component = Render<TextInput>(parameters => parameters
+            .Add(p => p.Value, string.Empty)
+            .Add(p => p.AriaDescribedBy, "help-text-id"));
+
+        var input = component.Find("input[type='text']");
+        Assert.Equal("help-text-id", input.GetAttribute("aria-describedby"));
+    }
+
+    [Fact]
+    public void Render_AriaLabel_AppliedToInput()
+    {
+        var component = Render<TextInput>(parameters => parameters
+            .Add(p => p.Value, string.Empty)
+            .Add(p => p.AriaLabel, "Filter value"));
+
+        var input = component.Find("input[type='text']");
+        Assert.Equal("Filter value", input.GetAttribute("aria-label"));
+    }
+
+    [Fact]
+    public void Render_AriaLabelledBy_AppliedToInput()
+    {
+        var component = Render<TextInput>(parameters => parameters
+            .Add(p => p.Value, string.Empty)
+            .Add(p => p.AriaLabelledBy, "external-label-id"));
+
+        var input = component.Find("input[type='text']");
+        Assert.Equal("external-label-id", input.GetAttribute("aria-labelledby"));
+    }
+
+    [Fact]
+    public void Render_AriaLabelledByAndAriaLabel_SuppressesAriaLabel()
+    {
+        var component = Render<TextInput>(parameters => parameters
+            .Add(p => p.Value, string.Empty)
+            .Add(p => p.AriaLabel, "Should be suppressed")
+            .Add(p => p.AriaLabelledBy, "external-label-id"));
+
+        var input = component.Find("input[type='text']");
+        Assert.False(input.HasAttribute("aria-label"));
+        Assert.Equal("external-label-id", input.GetAttribute("aria-labelledby"));
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Inputs/ToggleTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Inputs/ToggleTests.cs
new file mode 100644
index 00000000..415ad7b7
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/Inputs/ToggleTests.cs
@@ -0,0 +1,140 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.UI.Inputs;
+using Microsoft.AspNetCore.Components;
+
+namespace EventLogExpert.UI.Tests.Inputs;
+
+public sealed class ToggleTests : BunitContext
+{
+    [Fact]
+    public void Render_AriaDescribedBy_AppliedToInput()
+    {
+        var component = Render<Toggle>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.AriaDescribedBy, "help-text-id"));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.Equal("help-text-id", input.GetAttribute("aria-describedby"));
+    }
+
+    [Fact]
+    public void Render_AriaLabel_AppliedToInput()
+    {
+        var component = Render<Toggle>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.AriaLabel, "Auto-expand details on selection"));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.Equal("Auto-expand details on selection", input.GetAttribute("aria-label"));
+    }
+
+    [Fact]
+    public void Render_AriaLabelledBy_AppliedToInput()
+    {
+        var component = Render<Toggle>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.AriaLabelledBy, "external-label-id"));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.Equal("external-label-id", input.GetAttribute("aria-labelledby"));
+    }
+
+    [Fact]
+    public void Render_AriaLabelledByAndAriaLabel_SuppressesAriaLabelPerWaiAriaPrecedence()
+    {
+        var component = Render<Toggle>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.AriaLabel, "Should be suppressed")
+            .Add(p => p.AriaLabelledBy, "external-label-id"));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.False(input.HasAttribute("aria-label"));
+        Assert.Equal("external-label-id", input.GetAttribute("aria-labelledby"));
+    }
+
+    [Fact]
+    public void Render_DefaultId_IsUnique()
+    {
+        var first = Render<Toggle>(parameters => parameters.Add(p => p.Value, false));
+        var second = Render<Toggle>(parameters => parameters.Add(p => p.Value, false));
+
+        var firstId = first.Find("input[type='checkbox']").GetAttribute("id");
+        var secondId = second.Find("input[type='checkbox']").GetAttribute("id");
+
+        Assert.False(string.IsNullOrEmpty(firstId));
+        Assert.False(string.IsNullOrEmpty(secondId));
+        Assert.NotEqual(firstId, secondId);
+    }
+
+    [Fact]
+    public void Render_DefaultState_HasRoleSwitch()
+    {
+        var component = Render<Toggle>(parameters => parameters
+            .Add(p => p.Value, false));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.Equal("switch", input.GetAttribute("role"));
+    }
+
+    [Fact]
+    public void Render_Disabled_RendersDisabledAttribute()
+    {
+        var component = Render<Toggle>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.Disabled, true));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.True(input.HasAttribute("disabled"));
+    }
+
+    [Fact]
+    public void Render_HasToggleTrackAndKnob()
+    {
+        var component = Render<Toggle>(parameters => parameters
+            .Add(p => p.Value, false));
+
+        Assert.Single(component.FindAll(".toggle-track"));
+        Assert.Single(component.FindAll(".toggle-knob"));
+    }
+
+    [Fact]
+    public void Render_ValueFalse_RendersUncheckedInput()
+    {
+        var component = Render<Toggle>(parameters => parameters
+            .Add(p => p.Value, false));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.False(input.HasAttribute("checked"));
+    }
+
+    [Fact]
+    public void Render_ValueTrue_RendersCheckedInput()
+    {
+        var component = Render<Toggle>(parameters => parameters
+            .Add(p => p.Value, true));
+
+        var input = component.Find("input[type='checkbox']");
+        Assert.True(input.HasAttribute("checked"));
+    }
+
+    [Fact]
+    public async Task Toggle_Change_InvokesValueChanged()
+    {
+        bool? observedValue = null;
+        var component = Render<Toggle>(parameters => parameters
+            .Add(p => p.Value, false)
+            .Add(p => p.ValueChanged, v =>
+            {
+                observedValue = v;
+                return Task.CompletedTask;
+            }));
+
+        var input = component.Find("input[type='checkbox']");
+        await input.ChangeAsync(new ChangeEventArgs { Value = true });
+
+        Assert.True(observedValue);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Inputs/ValueSelectTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Inputs/ValueSelectTests.cs
new file mode 100644
index 00000000..68c9e5f9
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/Inputs/ValueSelectTests.cs
@@ -0,0 +1,57 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.UI.Inputs;
+
+namespace EventLogExpert.UI.Tests.Inputs;
+
+public sealed class ValueSelectTests : BunitContext
+{
+    public ValueSelectTests()
+    {
+        JSInterop.Mode = JSRuntimeMode.Loose;
+    }
+
+    [Fact]
+    public void Render_AriaDescribedBy_AppliedToCombobox()
+    {
+        var component = Render<ValueSelect<string>>(parameters => parameters
+            .Add(p => p.AriaDescribedBy, "help-text-id"));
+
+        var combobox = component.Find("input[role='combobox']");
+        Assert.Equal("help-text-id", combobox.GetAttribute("aria-describedby"));
+    }
+
+    [Fact]
+    public void Render_AriaLabel_AppliedToCombobox()
+    {
+        var component = Render<ValueSelect<string>>(parameters => parameters
+            .Add(p => p.AriaLabel, "Highlight Color"));
+
+        var combobox = component.Find("input[role='combobox']");
+        Assert.Equal("Highlight Color", combobox.GetAttribute("aria-label"));
+    }
+
+    [Fact]
+    public void Render_AriaLabelledBy_AppliedToCombobox()
+    {
+        var component = Render<ValueSelect<string>>(parameters => parameters
+            .Add(p => p.AriaLabelledBy, "external-label-id"));
+
+        var combobox = component.Find("input[role='combobox']");
+        Assert.Equal("external-label-id", combobox.GetAttribute("aria-labelledby"));
+    }
+
+    [Fact]
+    public void Render_AriaLabelledByAndAriaLabel_SuppressesAriaLabelPerWaiAriaPrecedence()
+    {
+        var component = Render<ValueSelect<string>>(parameters => parameters
+            .Add(p => p.AriaLabel, "Should be suppressed")
+            .Add(p => p.AriaLabelledBy, "external-label-id"));
+
+        var combobox = component.Find("input[role='combobox']");
+        Assert.False(combobox.HasAttribute("aria-label"));
+        Assert.Equal("external-label-id", combobox.GetAttribute("aria-labelledby"));
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalChromeTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalChromeTests.cs
new file mode 100644
index 00000000..a0efbb6e
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalChromeTests.cs
@@ -0,0 +1,111 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.UI.Banner;
+using EventLogExpert.UI.Modal;
+using EventLogExpert.UI.Tests.TestUtils;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.UI.Tests.Modal;
+
+public sealed class ModalChromeTests : BunitContext
+{
+    public ModalChromeTests()
+    {
+        Services.AddBannerHostDependencies();
+
+        JSInterop.Mode = JSRuntimeMode.Loose;
+    }
+
+    [Fact]
+    public async Task DisposeAsync_SetsModalContentDisplayedFalse()
+    {
+        var cycleState = Services.GetRequiredService<IBannerCycleStateService>();
+        var component = Render<ModalChrome>(parameters => parameters
+            .Add(p => p.Title, "Test")
+            .AddChildContent("<p>body</p>"));
+
+        await component.WaitForAssertionAsync(() => Assert.True(cycleState.ModalContentDisplayed));
+
+        await component.Instance.DisposeAsync();
+
+        Assert.False(cycleState.ModalContentDisplayed);
+    }
+
+    [Fact]
+    public void Render_BannerHostWrapper_DoesNotHaveInertAttributeWhenNoInlineAlert()
+    {
+        var component = Render<ModalChrome>(parameters => parameters
+            .Add(p => p.Title, "Test")
+            .AddChildContent("<p>body</p>"));
+
+        var dialogGroup = component.Find(".dialog-group");
+        var wrapper = dialogGroup.Children[0];
+        Assert.Contains("banner-region", wrapper.GetAttribute("class") ?? string.Empty);
+        Assert.False(wrapper.HasAttribute("inert"));
+    }
+
+    [Fact]
+    public void Render_BannerHostWrapper_HasInertAttributeWhenInlineAlertShown()
+    {
+        var alert = new InlineAlertRequest(
+            Title: "Confirm",
+            Message: "Are you sure?",
+            AcceptLabel: "Yes",
+            CancelLabel: "No",
+            IsPrompt: false,
+            PromptInitialValue: null);
+
+        var component = Render<ModalChrome>(parameters => parameters
+            .Add(p => p.Title, "Test")
+            .Add(p => p.InlineAlert, alert)
+            .AddChildContent("<p>body</p>"));
+
+        var dialogGroup = component.Find(".dialog-group");
+        var wrapper = dialogGroup.Children[0];
+        Assert.Contains("banner-region", wrapper.GetAttribute("class") ?? string.Empty);
+        Assert.True(wrapper.HasAttribute("inert"));
+    }
+
+    [Fact]
+    public void Render_BannerHostWrapper_PresentAtTopOfDialogGroup()
+    {
+        var component = Render<ModalChrome>(parameters => parameters
+            .Add(p => p.Title, "Test")
+            .AddChildContent("<p>body</p>"));
+
+        var dialogGroup = component.Find(".dialog-group");
+        Assert.NotNull(dialogGroup);
+
+        var firstChild = dialogGroup.Children[0];
+        Assert.Contains("banner-region", firstChild.GetAttribute("class") ?? string.Empty);
+    }
+
+    [Fact]
+    public void Render_BannerHostWrapper_RendersNothingWhenNoBannersAndNoModalActive()
+    {
+        var component = Render<ModalChrome>(parameters => parameters
+            .Add(p => p.Title, "Test")
+            .AddChildContent("<p>body</p>"));
+
+        var dialogGroup = component.Find(".dialog-group");
+        var wrapper = dialogGroup.Children[0];
+        Assert.Contains("banner-region", wrapper.GetAttribute("class") ?? string.Empty);
+        Assert.Empty(wrapper.Children);
+    }
+
+    [Fact]
+    public async Task Render_FirstRender_SetsModalContentDisplayedTrue_AfterShowModal()
+    {
+        var cycleState = Services.GetRequiredService<IBannerCycleStateService>();
+        Assert.False(cycleState.ModalContentDisplayed);
+
+        var component = Render<ModalChrome>(parameters => parameters
+            .Add(p => p.Title, "Test")
+            .AddChildContent("<p>body</p>"));
+
+        await component.WaitForAssertionAsync(() => Assert.True(cycleState.ModalContentDisplayed));
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Settings/SettingsModalTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Settings/SettingsModalTests.cs
new file mode 100644
index 00000000..65ca4937
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/Settings/SettingsModalTests.cs
@@ -0,0 +1,82 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.Runtime.Announcement;
+using EventLogExpert.Runtime.DetailsPane;
+using EventLogExpert.Runtime.Modal;
+using EventLogExpert.Runtime.Settings;
+using EventLogExpert.UI.Settings;
+using EventLogExpert.UI.Tests.TestUtils;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+
+namespace EventLogExpert.UI.Tests.Settings;
+
+public sealed class SettingsModalTests : BunitContext
+{
+    private readonly IAnnouncementService _announcementService = Substitute.For<IAnnouncementService>();
+    private readonly IDetailsPanePreferencesProvider _detailsPanePreferences = Substitute.For<IDetailsPanePreferencesProvider>();
+    private readonly IModalCoordinator _modalCoordinator = Substitute.For<IModalCoordinator>();
+    private readonly IModalService _modalService = Substitute.For<IModalService>();
+    private readonly ISettingsService _settings = Substitute.For<ISettingsService>();
+
+    public SettingsModalTests()
+    {
+        Services.AddBannerHostDependencies();
+
+        _modalService.ActiveModalId.Returns(new ModalId(1L));
+
+        _settings.TimeZoneId.Returns(string.Empty);
+
+        Services.AddSingleton(_announcementService);
+        Services.AddSingleton(_detailsPanePreferences);
+        Services.AddSingleton(_modalCoordinator);
+        Services.AddSingleton(_modalService);
+        Services.AddSingleton(_settings);
+        Services.AddFluxor(options => options.ScanAssemblies(typeof(SettingsModal).Assembly));
+
+        JSInterop.Mode = JSRuntimeMode.Loose;
+    }
+
+    [Fact]
+    public async Task SettingsModal_OnSaveSuccess_AnnouncesSettingsSaved()
+    {
+        var component = Render<SettingsModal>();
+        // Internal test-only forwarder bypasses ModalChrome footer markup coupling.
+        await component.InvokeAsync(() => component.Instance.InvokeOnSaveAsyncForTests());
+
+        _announcementService.Received(1).Announce("Settings saved");
+    }
+
+    [Fact]
+    public void SettingsModal_PreReleaseBuilds_LivesInFooterNotBody()
+    {
+        var component = Render<SettingsModal>();
+
+        var footerExtra = component.Find(".footer-extra");
+        Assert.Contains("Pre-release Builds", footerExtra.TextContent);
+    }
+
+    [Fact]
+    public void SettingsModal_TimeZoneInput_HasLabelForAssociation()
+    {
+        var component = Render<SettingsModal>();
+
+        var label = component.Find("label[for='settings-timezone']");
+        Assert.Equal("Time Zone:", label.TextContent.Trim());
+        var input = component.Find("#settings-timezone");
+        Assert.Equal("settings-timezone", input.Id);
+    }
+
+    [Fact]
+    public void SettingsModal_UsesAriaLabelNotTitleForUtilityModalConvention()
+    {
+        var component = Render<SettingsModal>();
+
+        var dialog = component.Find("dialog");
+        Assert.Equal("Settings", dialog.GetAttribute("aria-label"));
+        Assert.False(dialog.HasAttribute("aria-labelledby"));
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Settings/SettingsUpgradeProgressBannerTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Settings/SettingsUpgradeProgressBannerTests.cs
deleted file mode 100644
index 3ac49c1f..00000000
--- a/tests/Unit/EventLogExpert.UI.Tests/Settings/SettingsUpgradeProgressBannerTests.cs
+++ /dev/null
@@ -1,255 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using Bunit;
-using EventLogExpert.Logging.Abstractions;
-using EventLogExpert.Logging.Abstractions.Handlers;
-using EventLogExpert.Runtime.Banner;
-using EventLogExpert.Runtime.Database.Upgrade;
-using EventLogExpert.UI.Settings;
-using Microsoft.AspNetCore.Components.Web;
-using Microsoft.Extensions.DependencyInjection;
-using NSubstitute;
-
-namespace EventLogExpert.UI.Tests.Settings;
-
-public sealed class SettingsUpgradeProgressBannerTests : BunitContext
-{
-    private readonly IProgressBannerService _progressBannerService = Substitute.For<IProgressBannerService>();
-    private readonly ITraceLogger _traceLogger = Substitute.For<ITraceLogger>();
-
-    public SettingsUpgradeProgressBannerTests()
-    {
-        _progressBannerService.SettingsProgress.Returns((BannerProgressEntry?)null);
-        _progressBannerService.BackgroundProgress.Returns((BannerProgressEntry?)null);
-
-        Services.AddSingleton(_progressBannerService);
-        Services.AddSingleton(_traceLogger);
-
-        JSInterop.Mode = JSRuntimeMode.Loose;
-    }
-
-    [Fact]
-    public void SettingsUpgradeProgressBanner_BackgroundProgressOnly_RendersNothing()
-    {
-        // Arrange
-        _progressBannerService.BackgroundProgress.Returns(BuildProgress(UpgradeProgressScope.Background));
-
-        // Act
-        var component = Render<SettingsUpgradeProgressBanner>();
-
-        // Assert
-        Assert.Empty(component.FindAll("aside.settings-upgrade-banner"));
-    }
-
-    [Fact]
-    public async Task SettingsUpgradeProgressBanner_CancelClicked_InvokesProgressCancelDelegate()
-    {
-        // Arrange
-        int cancelInvocationCount = 0;
-        _progressBannerService.SettingsProgress.Returns(BuildProgress(cancel: () => cancelInvocationCount++));
-
-        // Act
-        var component = Render<SettingsUpgradeProgressBanner>();
-        await component.Find("aside.settings-upgrade-banner button.banner-action").ClickAsync(new MouseEventArgs());
-
-        // Assert
-        Assert.Equal(1, cancelInvocationCount);
-    }
-
-    [Fact]
-    public async Task SettingsUpgradeProgressBanner_CancelThrows_LogsViaTraceLoggerAndDoesNotPropagate()
-    {
-        // Arrange
-        _progressBannerService.SettingsProgress.Returns(
-            BuildProgress(cancel: () => throw new InvalidOperationException("cts disposed")));
-
-        // Act
-        var component = Render<SettingsUpgradeProgressBanner>();
-        await component.Find("aside.settings-upgrade-banner button.banner-action").ClickAsync(new MouseEventArgs());
-
-        // Assert
-        Assert.Single(component.FindAll("aside.settings-upgrade-banner"));
-
-        _traceLogger.Received(1).Error(Arg.Is<ErrorLogHandler>(h =>
-            h.ToString().Contains(nameof(SettingsUpgradeProgressBanner)) &&
-            h.ToString().Contains("cts disposed")));
-    }
-
-    [Fact]
-    public void SettingsUpgradeProgressBanner_DisposeIsIdempotent()
-    {
-        // Arrange
-        var component = Render<SettingsUpgradeProgressBanner>();
-        var instance = component.Instance;
-        instance.Dispose();
-
-        // Act + Assert - second Dispose must not throw
-        var exception = Record.Exception(() => instance.Dispose());
-        Assert.Null(exception);
-    }
-
-    [Fact]
-    public async Task SettingsUpgradeProgressBanner_DisposeUnsubscribesFromStateChanged()
-    {
-        // Arrange
-        _progressBannerService.SettingsProgress.Returns((BannerProgressEntry?)null);
-
-        var component = Render<SettingsUpgradeProgressBanner>();
-        component.Instance.Dispose();
-
-        // Act
-        _progressBannerService.SettingsProgress.Returns(BuildProgress());
-        _progressBannerService.StateChanged += Raise.Event<Action>();
-
-        await Task.Yield();
-
-        // Assert
-        Assert.Empty(component.FindAll("aside.settings-upgrade-banner"));
-    }
-
-    [Fact]
-    public void SettingsUpgradeProgressBanner_QueuedBatchesAfterOne_UsesSingularBatchLabel()
-    {
-        // Arrange
-        _progressBannerService.SettingsProgress.Returns(BuildProgress(queuedBatchesAfter: 1));
-
-        // Act
-        var component = Render<SettingsUpgradeProgressBanner>();
-
-        // Assert
-        var subtitle = component.Find("aside.settings-upgrade-banner .banner-subtitle");
-        Assert.Contains("+1 batch queued", subtitle.TextContent);
-        Assert.DoesNotContain("batches", subtitle.TextContent);
-    }
-
-    [Fact]
-    public void SettingsUpgradeProgressBanner_QueuedBatchesAfterTwo_UsesPluralBatchesLabel()
-    {
-        // Arrange
-        _progressBannerService.SettingsProgress.Returns(BuildProgress(queuedBatchesAfter: 2));
-
-        // Act
-        var component = Render<SettingsUpgradeProgressBanner>();
-
-        // Assert
-        var subtitle = component.Find("aside.settings-upgrade-banner .banner-subtitle");
-        Assert.Contains("+2 batches queued", subtitle.TextContent);
-    }
-
-    [Fact]
-    public void SettingsUpgradeProgressBanner_QueuedBatchesAfterZero_DoesNotRenderSubtitle()
-    {
-        // Arrange
-        _progressBannerService.SettingsProgress.Returns(BuildProgress(queuedBatchesAfter: 0));
-
-        // Act
-        var component = Render<SettingsUpgradeProgressBanner>();
-
-        // Assert
-        Assert.Empty(component.FindAll("aside.settings-upgrade-banner .banner-subtitle"));
-    }
-
-    [Fact]
-    public void SettingsUpgradeProgressBanner_SettingsProgressNull_RendersNothing()
-    {
-        // Arrange
-        _progressBannerService.SettingsProgress.Returns((BannerProgressEntry?)null);
-
-        // Act
-        var component = Render<SettingsUpgradeProgressBanner>();
-
-        // Assert
-        Assert.Empty(component.FindAll("aside.settings-upgrade-banner"));
-    }
-
-    [Fact]
-    public void SettingsUpgradeProgressBanner_SettingsProgressWithBatchSizeOne_UsesSingularDatabaseLabel()
-    {
-        // Arrange
-        _progressBannerService.SettingsProgress.Returns(
-            BuildProgress(currentBatchSize: 1, currentEntryName: string.Empty));
-
-        // Act
-        var component = Render<SettingsUpgradeProgressBanner>();
-
-        // Assert
-        var banner = component.Find("aside.settings-upgrade-banner");
-        Assert.Contains("Preparing upgrade of 1 database", banner.TextContent);
-        Assert.DoesNotContain("databases", banner.TextContent);
-    }
-
-    [Fact]
-    public void SettingsUpgradeProgressBanner_SettingsProgressWithEmptyEntryName_RendersPreparingMessage()
-    {
-        // Arrange
-        _progressBannerService.SettingsProgress.Returns(
-            BuildProgress(currentBatchSize: 3, currentEntryName: string.Empty));
-
-        // Act
-        var component = Render<SettingsUpgradeProgressBanner>();
-
-        // Assert
-        var banner = component.Find("aside.settings-upgrade-banner");
-        Assert.Contains("Preparing upgrade of 3 databases", banner.TextContent);
-        Assert.DoesNotContain("Upgrading database 0", banner.TextContent);
-    }
-
-    [Fact]
-    public void
-        SettingsUpgradeProgressBanner_SettingsProgressWithEntryName_RendersUpgradeProgressBannerWithCancelButton()
-    {
-        // Arrange
-        _progressBannerService.SettingsProgress.Returns(BuildProgress(
-            currentBatchPosition: 2,
-            currentBatchSize: 5,
-            currentEntryName: "MyDb.evtx",
-            currentPhase: UpgradePhase.MigratingSchema));
-
-        // Act
-        var component = Render<SettingsUpgradeProgressBanner>();
-
-        // Assert
-        var banner = component.Find("aside.settings-upgrade-banner");
-        Assert.Contains("Upgrading database 2 of 5", banner.TextContent);
-        Assert.Contains("MyDb.evtx", banner.TextContent);
-        Assert.Contains("MigratingSchema", banner.TextContent);
-        Assert.Equal("Cancel", component.Find("aside.settings-upgrade-banner button.banner-action").TextContent.Trim());
-        Assert.Single(component.FindAll("aside.settings-upgrade-banner .banner-spinner"));
-    }
-
-    [Fact]
-    public async Task SettingsUpgradeProgressBanner_StateChangedRaised_RerendersWithNewProgress()
-    {
-        // Arrange
-        _progressBannerService.SettingsProgress.Returns((BannerProgressEntry?)null);
-        var component = Render<SettingsUpgradeProgressBanner>();
-        Assert.Empty(component.FindAll("aside.settings-upgrade-banner"));
-
-        // Act
-        _progressBannerService.SettingsProgress.Returns(BuildProgress(currentEntryName: "x.evtx"));
-        _progressBannerService.StateChanged += Raise.Event<Action>();
-
-        // Assert
-        await component.WaitForAssertionAsync(() =>
-            Assert.Single(component.FindAll("aside.settings-upgrade-banner")));
-    }
-
-    private static BannerProgressEntry BuildProgress(
-        UpgradeProgressScope scope = UpgradeProgressScope.SettingsTriggered,
-        int currentBatchPosition = 1,
-        int currentBatchSize = 1,
-        string currentEntryName = "x.evtx",
-        UpgradePhase currentPhase = UpgradePhase.MigratingSchema,
-        int queuedBatchesAfter = 0,
-        Action? cancel = null) =>
-        new(
-            UpgradeBatchId.Create(),
-            scope,
-            currentBatchPosition,
-            currentBatchSize,
-            currentEntryName,
-            currentPhase,
-            queuedBatchesAfter,
-            cancel ?? (() => { }));
-}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/TestUtils/BannerHostDependenciesExtensions.cs b/tests/Unit/EventLogExpert.UI.Tests/TestUtils/BannerHostDependenciesExtensions.cs
new file mode 100644
index 00000000..fbf3b60b
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/TestUtils/BannerHostDependenciesExtensions.cs
@@ -0,0 +1,43 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Banner;
+using EventLogExpert.Runtime.Modal;
+using EventLogExpert.UI.Banner;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+
+namespace EventLogExpert.UI.Tests.TestUtils;
+
+internal static class BannerHostDependenciesExtensions
+{
+    public static void AddBannerHostDependencies(this IServiceCollection services)
+    {
+        var attention = Substitute.For<IAttentionBannerService>();
+        attention.AttentionEntries.Returns([]);
+        attention.AttentionDismissed.Returns(false);
+        services.AddSingleton(attention);
+
+        var critical = Substitute.For<ICriticalErrorService>();
+        critical.CurrentCritical.Returns((Exception?)null);
+        services.AddSingleton(critical);
+
+        var errors = Substitute.For<IErrorBannerService>();
+        errors.ErrorBanners.Returns([]);
+        services.AddSingleton(errors);
+
+        var infos = Substitute.For<IInfoBannerService>();
+        infos.InfoBanners.Returns([]);
+        services.AddSingleton(infos);
+
+        var progress = Substitute.For<IProgressBannerService>();
+        progress.BackgroundProgress.Returns((BannerProgressEntry?)null);
+        services.AddSingleton(progress);
+
+        var modalCoordinator = Substitute.For<IModalCoordinator>();
+        modalCoordinator.ActiveSession.Returns((ModalSession?)null);
+        services.AddSingleton(modalCoordinator);
+
+        services.AddSingleton<IBannerCycleStateService, BannerCycleStateService>();
+    }
+}