From 9fbe88b5854d2dce9bcd7725c120d64237df134d Mon Sep 17 00:00:00 2001
From: Ariver <shanghai3168@gmail.com>
Date: Tue, 02 Jun 2026 19:53:57 +0800
Subject: [PATCH] Add 7.8.9 rollback test package manifest

---
 Apptag/ContentView.swift | 1556 ++++++++++++++++++++++-------------------------------------
 1 files changed, 589 insertions(+), 967 deletions(-)

diff --git a/Apptag/ContentView.swift b/Apptag/ContentView.swift
index 02731e4..f29d986 100644
--- a/Apptag/ContentView.swift
+++ b/Apptag/ContentView.swift
@@ -1,6 +1,5 @@
 import SwiftUI
 import AppKit
-import UniformTypeIdentifiers
 
 // MARK: - Notification for manual re-index
 
@@ -201,7 +200,6 @@
     let colorIndex: Int
     var dragModeActive: Bool = false
     var isDragging: Bool = false
-    var dragResetToken: Int = 0
     let action: () -> Void
 
     private var bgColor: Color {
@@ -227,7 +225,6 @@
             .opacity(dragModeActive ? (isDragging ? 1.0 : 0.62) : 1.0)
             .animation(.easeOut(duration: 0.08), value: isDragging)
             .animation(.easeOut(duration: 0.08), value: dragModeActive)
-            .id("\(name)|reset-\(dragResetToken)")
             .contentShape(RoundedRectangle(cornerRadius: 7))
             .onTapGesture {
                 action()
@@ -242,7 +239,6 @@
     let colorIndex: Int
     var dragModeActive: Bool = false
     var isDragging: Bool = false
-    var dragResetToken: Int = 0
     let action: () -> Void
 
     private var bgColor: Color {
@@ -264,7 +260,6 @@
             .opacity(dragModeActive ? (isDragging ? 1.0 : 0.62) : 1.0)
             .animation(.easeOut(duration: 0.08), value: isDragging)
             .animation(.easeOut(duration: 0.08), value: dragModeActive)
-            .id("\(name)|reset-\(dragResetToken)")
             .contentShape(RoundedRectangle(cornerRadius: 6))
             .onTapGesture {
                 action()
@@ -309,6 +304,25 @@
     let arrowOffset: CGFloat
 }
 
+private struct AppGridInteractionState {
+    var appDragModeActive = false
+    var dropWarningToast: String? = nil
+    var dropRefreshVisible = false
+    var dropRefreshStartedAt: Date? = nil
+    var hoveredBubble: AppBubbleContext? = nil
+    var editingBubble: AppBubbleContext? = nil
+    var pendingUncategorizedDrop: PendingUncategorizedDrop? = nil
+    var pendingTagRemovalDrop: PendingTagRemovalDrop? = nil
+    var uncategorizedDropSuppressFuturePrompt = false
+    var tagRemovalDropSuppressFuturePrompt = false
+    var appDragResetToken = 0
+    var bubbleDraftNote = ""
+    var tagNavigationHoveredGroupName: String? = nil
+    var tagNavigationAppDropTargetName: String? = nil
+    var tagNavigationLastHoverScrollID: String? = nil
+    var tagNavigationLastHoverScrollAt: Date? = nil
+}
+
 private struct EditActionFeedback: Identifiable {
     let id = UUID()
     let title: String
@@ -319,34 +333,26 @@
     let id = UUID()
     let app: AppInfo
     let assignedTags: [String]
+    let removableTags: [String]
 }
 
-private enum SmartStartNoticeMode {
-    case autoApplied
-    case suggestionOnly
-    case manuallyApplied
-}
-
-private struct SmartStartNotice: Identifiable {
+private struct PendingTagRemovalDrop: Identifiable {
     let id = UUID()
-    let mode: SmartStartNoticeMode
-    let title: String
-    let message: String
-    let summary: SmartStartSummary
+    let app: AppInfo
+    let tagName: String
 }
 
 struct ContentView: View {
     let hideOverlay: () -> Void
     private let initialQuickSearchSource: String?
 
+    @Environment(\.colorScheme) private var colorScheme
     @State private var allApps: [AppInfo] = []
     @State private var displayGroups: [TagGroup] = []
     @State private var tagColors: [String: Int] = [:]
-    @State private var scrollProxy: ScrollViewProxy? = nil
-    @StateObject private var scrollInteractionState = AppGridScrollInteractionState()
     @State private var groupLayoutVersion = 0
-    @State private var cachedGridContainerRowsKey: GridContainerRowsKey? = nil
-    @State private var cachedGridContainerRows: [GridContainerLayoutRow] = []
+    @State private var appGridScrollTargetID: String? = nil
+    @State private var appGridScrollRequestToken = 0
 
     // Edit mode
     @State private var editPhase: EditPhase = .none
@@ -360,27 +366,16 @@
     @State private var tagReorderFrames: [String: CGRect] = [:]
     @State private var tagNavDragModeActive = false
     @State private var tagNavDragItem: String? = nil
-    @State private var tagNavDragResetToken = 0
     @State private var tagNavReorderFrames: [String: CGRect] = [:]
     @State private var tagNavReorderDidMove = false
-    @State private var hoveredContainer: String? = nil  // colored container lift
     // Fixed interaction for "Colorless Container": hover fills persistently; click clears.
     @State private var filledColorlessContainer: String? = nil
-    @State private var appDragModeActive = false
-    @State private var dropWarningToast: String? = nil
+    @State private var appGridInteraction = AppGridInteractionState()
     @State private var smartStartNotice: SmartStartNotice? = nil
     @State private var pendingSmartStartDraft: SmartCategorizationDraft? = nil
-    @State private var dropRefreshVisible = false
-    @State private var dropRefreshStartedAt: Date? = nil
     @State private var refreshInProgress = false
     @State private var refreshAgainAfterCurrent = false
     @State private var refreshAgainForceLayout = false
-    @State private var hoveredAppItemID: String? = nil
-    @State private var hoveredBubble: AppBubbleContext? = nil
-    @State private var editingBubble: AppBubbleContext? = nil
-    @State private var pendingUncategorizedDrop: PendingUncategorizedDrop? = nil
-    @State private var appDragResetToken = 0
-    @State private var bubbleDraftNote = ""
     @FocusState private var bubbleNoteFocused: Bool
 
     // Quick Search
@@ -391,7 +386,9 @@
     @State private var quickSearchSelectedID: URL? = nil
     @State private var quickSearchManualSelection = false
     @State private var quickSearchFocusToken = 0
+    @State private var quickSearchSelectionScrollToken = 0
     @State private var quickSearchCloseHidesOverlay = false
+    @State private var quickSearchOnlySession = false
     @State private var quickSearchErrorMessage: String? = nil
     @State private var initialQuickSearchConsumed = false
 
@@ -399,8 +396,10 @@
         self.hideOverlay = hideOverlay
         self.initialQuickSearchSource = initialQuickSearchSource
         let startsInQuickSearch = initialQuickSearchSource != nil
+        let startsInQuickSearchOnlySession = initialQuickSearchSource == QuickSearchOpenSource.globalHidden
         _quickSearchVisible = State(initialValue: startsInQuickSearch)
-        _quickSearchCloseHidesOverlay = State(initialValue: initialQuickSearchSource == QuickSearchOpenSource.globalHidden)
+        _quickSearchCloseHidesOverlay = State(initialValue: startsInQuickSearchOnlySession)
+        _quickSearchOnlySession = State(initialValue: startsInQuickSearchOnlySession)
         _quickSearchFocusToken = State(initialValue: startsInQuickSearch ? 1 : 0)
     }
 
@@ -412,15 +411,32 @@
     @State private var notchHeight: CGFloat = 0
     @AppStorage("displayMode") private var displayMode = AppDefaults.displayMode
     @AppStorage("hideAppNames") private var hideAppNames = AppDefaults.hideAppNames
+    @AppStorage("showUncommonAppBubbles") private var showUncommonAppBubbles = AppDefaults.showUncommonAppBubbles
+    @AppStorage("useAppKitTagNavigation") private var useAppKitTagNavigation = AppDefaults.useAppKitTagNavigation
+    @AppStorage("skipTagRemovalDropConfirm") private var skipTagRemovalDropConfirm = false
+    @AppStorage("skipUncategorizedDropConfirm") private var skipUncategorizedDropConfirm = false
 
     private let editSidebarWidth: CGFloat = 188
     private let editSidebarHorizontalInset: CGFloat = 12
     private let floatingControlsTrailingInset: CGFloat = 20
     private let floatingControlsReservedWidth: CGFloat = 120
     private var appBubbleDisabled: Bool {
-        appDragModeActive || pendingUncategorizedDrop != nil || scrollInteractionState.isFrozen
+        appGridInteraction.appDragModeActive
+            || appGridInteraction.pendingUncategorizedDrop != nil
+            || appGridInteraction.pendingTagRemovalDrop != nil
+    }
+    private var appGridHighlightedGroupName: String? {
+        appGridInteraction.tagNavigationHoveredGroupName
+            ?? (isColorlessContainerMode ? filledColorlessContainer : nil)
     }
     private let rightSidebarFloatingClearance: CGFloat = 44
+    private let tagNavigationHoverScrollInterval: TimeInterval = 0.22
+
+    private var floatingButtonSurfaceColor: Color {
+        colorScheme == .dark
+            ? Color.white.opacity(0.10)
+            : Color.white.opacity(0.78)
+    }
 
     private var isSideLayout: Bool {
         tagPosition == "left" || tagPosition == "right"
@@ -434,23 +450,22 @@
         displayMode == "container" || displayMode == "gridContainer"
     }
 
-    private var isColoredContainerMode: Bool {
-        displayMode == "coloredContainer" || displayMode == "coloredGridContainer"
-    }
-
-    private var quickSearchOnlyMode: Bool {
-        quickSearchVisible && quickSearchCloseHidesOverlay
+    private var shouldRenderAppGridBehindQuickSearch: Bool {
+        if quickSearchOnlySession {
+            return false
+        }
+        return !quickSearchVisible || !quickSearchCloseHidesOverlay
     }
 
     var body: some View {
         ZStack {
-            if !quickSearchOnlyMode {
+            if shouldRenderAppGridBehindQuickSearch {
                 VisualEffectView(material: .hudWindow, blendingMode: .behindWindow)
                     .ignoresSafeArea()
                     .allowsHitTesting(false)
             }
 
-            if !quickSearchOnlyMode {
+            if shouldRenderAppGridBehindQuickSearch {
                 if notchHeight > 0 {
                     VStack {
                         Rectangle().fill(.black)
@@ -474,11 +489,12 @@
                 smartStartNoticeOverlay
                 editActionFeedbackOverlay
                 uncategorizedDropConfirmOverlay
+                tagRemovalDropConfirmOverlay
             }
 
             quickSearchOverlay
 
-            if !quickSearchOnlyMode, let message = dropWarningToast {
+            if shouldRenderAppGridBehindQuickSearch, let message = appGridInteraction.dropWarningToast {
                 Text(message)
                     .font(.system(size: 16, weight: .semibold))
                     .foregroundStyle(.primary)
@@ -493,7 +509,7 @@
                     .allowsHitTesting(false)
             }
 
-            if !quickSearchOnlyMode && dropRefreshVisible {
+            if shouldRenderAppGridBehindQuickSearch && appGridInteraction.dropRefreshVisible {
                 Color.black.opacity(0.08)
                     .ignoresSafeArea()
                     .transition(.opacity)
@@ -518,28 +534,35 @@
             refreshAppsIfNeeded()
             if let initialQuickSearchSource, !initialQuickSearchConsumed {
                 initialQuickSearchConsumed = true
-                quickSearchCloseHidesOverlay = initialQuickSearchSource == QuickSearchOpenSource.globalHidden
-                quickSearchVisible = true
-                quickSearchFocusToken &+= 1
+                if initialQuickSearchSource == QuickSearchOpenSource.globalHidden {
+                    quickSearchCloseHidesOverlay = true
+                    quickSearchOnlySession = true
+                }
+                if !quickSearchVisible {
+                    quickSearchVisible = true
+                    quickSearchFocusToken &+= 1
+                }
+                refreshQuickSearchResults()
                 NotificationCenter.default.post(
                     name: .tagLauncherQuickSearchVisibilityChanged,
                     object: nil,
-                    userInfo: ["active": true]
+                    userInfo: [
+                        "active": true,
+                        "hideOverlayOnClose": quickSearchCloseHidesOverlay
+                    ]
                 )
             }
         }
         .onReceive(NotificationCenter.default.publisher(for: .tagLauncherOverlayDidShow)) { _ in
             resetTransientDragState()
             refreshNotchHeight()
-            if quickSearchVisible {
-                refreshAppsIfNeeded()
-            } else {
-                refreshApps()
-            }
+            refreshAppsIfNeeded()
         }
         .onReceive(NotificationCenter.default.publisher(for: .tagLauncherOverlayDidHide)) { _ in
             resetTransientDragState()
             closeQuickSearch(notify: true, hideOverlayIfNeeded: false)
+            quickSearchOnlySession = false
+            quickSearchCloseHidesOverlay = false
         }
         .onReceive(NotificationCenter.default.publisher(for: .tagLauncherQuickSearchRequested)) { notification in
             let source = notification.userInfo?["source"] as? String ?? QuickSearchOpenSource.mainOverlay
@@ -574,7 +597,7 @@
             )
         }
         .onChange(of: bubbleNoteFocused) { _, focused in
-            if editingBubble != nil && !focused {
+            if appGridInteraction.editingBubble != nil && !focused {
                 commitBubbleNote()
             }
         }
@@ -588,12 +611,11 @@
             quickSearchErrorMessage = nil
             refreshQuickSearchResults()
         }
-        .onChange(of: pendingUncategorizedDrop != nil) { _, active in
-            NotificationCenter.default.post(
-                name: .tagLauncherModalInteractionChanged,
-                object: nil,
-                userInfo: ["active": active]
-            )
+        .onChange(of: appGridInteraction.pendingUncategorizedDrop != nil) { _, _ in
+            publishModalInteractionState()
+        }
+        .onChange(of: appGridInteraction.pendingTagRemovalDrop != nil) { _, _ in
+            publishModalInteractionState()
         }
         .onDisappear {
             NotificationCenter.default.post(
@@ -602,6 +624,14 @@
                 userInfo: ["active": false]
             )
         }
+    }
+
+    private func publishModalInteractionState() {
+        NotificationCenter.default.post(
+            name: .tagLauncherModalInteractionChanged,
+            object: nil,
+            userInfo: ["active": appGridInteraction.pendingUncategorizedDrop != nil || appGridInteraction.pendingTagRemovalDrop != nil]
+        )
     }
 
     /// Set edit phase with synchronous notification BEFORE state change.
@@ -637,23 +667,23 @@
                     }
                     .zIndex(899)
 
-                QuickSearchOverlayView(
+                QuickSearchPanelPresentationView(
                     query: $quickSearchQuery,
                     results: quickSearchResults,
                     selectedID: quickSearchSelectedID,
                     focusToken: quickSearchFocusToken,
+                    selectionScrollToken: quickSearchSelectionScrollToken,
                     isLoading: quickSearchDocuments.isEmpty && refreshInProgress,
                     maxVisibleRows: quickSearchMaxVisibleRows(in: proxy.size),
+                    panelTopY: quickSearchPanelTopY(in: proxy.size),
+                    panelHeight: quickSearchPanelContentHeight(in: proxy.size),
                     errorMessage: quickSearchErrorMessage,
                     onCommand: handleQuickSearchCommand,
                     onHover: selectQuickSearchResult,
                     onLaunch: launchQuickSearchResult
                 )
-                .position(
-                    x: proxy.size.width / 2,
-                    y: quickSearchPanelCenterY(in: proxy.size)
-                )
-                .transition(.scale(scale: 0.98).combined(with: .opacity))
+                .frame(width: 0, height: 0)
+                .allowsHitTesting(false)
                 .zIndex(900)
             }
         }
@@ -661,10 +691,15 @@
         .animation(.easeOut(duration: 0.12), value: quickSearchVisible)
     }
 
-    private func quickSearchPanelCenterY(in size: CGSize) -> CGFloat {
-        let visibleRows = max(1, min(quickSearchResults.isEmpty ? 1 : quickSearchResults.count, quickSearchMaxVisibleRows(in: size)))
-        let estimatedPanelHeight = CGFloat(visibleRows) * 76 + 122
-        return quickSearchPanelTopY(in: size) + estimatedPanelHeight / 2
+    private func quickSearchPanelContentHeight(in size: CGSize) -> CGFloat {
+        let hasResultList = !(quickSearchDocuments.isEmpty && refreshInProgress)
+            && quickSearchErrorMessage == nil
+            && !quickSearchResults.isEmpty
+        let visibleRows = min(max(1, quickSearchResults.count), quickSearchMaxVisibleRows(in: size))
+        return QuickSearchPanelMetrics.contentHeight(
+            hasResultList: hasResultList,
+            visibleRows: visibleRows
+        )
     }
 
     private func quickSearchPanelTopY(in size: CGSize) -> CGFloat {
@@ -673,8 +708,11 @@
 
     private func quickSearchMaxVisibleRows(in size: CGSize) -> Int {
         let bottomClearance: CGFloat = 84
-        let chromeHeight: CGFloat = 122
-        let rowHeightWithSpacing: CGFloat = 76
+        let chromeHeight = QuickSearchPanelMetrics.headerHeight
+            + QuickSearchPanelMetrics.dividerHeight
+            + QuickSearchPanelMetrics.resultListVerticalInset * 2
+        let rowHeightWithSpacing = QuickSearchPanelMetrics.rowHeight
+            + QuickSearchPanelMetrics.rowSpacing
         let availableHeight = max(0, size.height - quickSearchPanelTopY(in: size) - bottomClearance - chromeHeight)
         return max(1, min(8, Int(floor(availableHeight / rowHeightWithSpacing))))
     }
@@ -682,7 +720,11 @@
     private func openQuickSearch(source: String) {
         guard canOpenQuickSearch else { return }
         dismissAppBubble()
-        quickSearchCloseHidesOverlay = source == QuickSearchOpenSource.globalHidden
+        if source == QuickSearchOpenSource.globalHidden {
+            quickSearchOnlySession = true
+        }
+        quickSearchCloseHidesOverlay = quickSearchCloseHidesOverlay
+            || source == QuickSearchOpenSource.globalHidden
         quickSearchVisible = true
         quickSearchQuery = ""
         quickSearchManualSelection = false
@@ -692,15 +734,18 @@
         NotificationCenter.default.post(
             name: .tagLauncherQuickSearchVisibilityChanged,
             object: nil,
-            userInfo: ["active": true]
+            userInfo: [
+                "active": true,
+                "hideOverlayOnClose": quickSearchCloseHidesOverlay
+            ]
         )
     }
 
     private var canOpenQuickSearch: Bool {
         editPhase == .none
-            && pendingUncategorizedDrop == nil
+            && appGridInteraction.pendingUncategorizedDrop == nil
             && smartStartNotice == nil
-            && !dropRefreshVisible
+            && !appGridInteraction.dropRefreshVisible
             && !quickSearchVisible
     }
 
@@ -713,16 +758,20 @@
         quickSearchSelectedID = nil
         quickSearchManualSelection = false
         quickSearchErrorMessage = nil
-        quickSearchCloseHidesOverlay = false
         if notify {
             NotificationCenter.default.post(
                 name: .tagLauncherQuickSearchVisibilityChanged,
                 object: nil,
-                userInfo: ["active": false]
+                userInfo: [
+                    "active": false,
+                    "hideOverlayOnClose": shouldHideOverlay
+                ]
             )
         }
         if shouldHideOverlay {
             hideOverlay()
+        } else {
+            quickSearchCloseHidesOverlay = false
         }
     }
 
@@ -773,9 +822,11 @@
         let nextIndex = min(max(currentIndex + delta, 0), quickSearchResults.count - 1)
         quickSearchSelectedID = quickSearchResults[nextIndex].id
         quickSearchManualSelection = true
+        quickSearchSelectionScrollToken &+= 1
     }
 
     private func selectQuickSearchResult(_ result: QuickSearchResult) {
+        guard quickSearchSelectedID != result.id || !quickSearchManualSelection else { return }
         quickSearchSelectedID = result.id
         quickSearchManualSelection = true
     }
@@ -836,7 +887,7 @@
     ) -> some View {
         NativeFloatingIconButton(systemImage: systemImage, action: action)
             .frame(width: 36, height: 36)
-            .background(Circle().fill(.ultraThinMaterial))
+            .background(Circle().fill(floatingButtonSurfaceColor))
     }
 
     // MARK: - Top / Side Layouts
@@ -844,7 +895,7 @@
     private var topLayout: some View {
         VStack(spacing: 0) {
             Spacer().frame(height: notchHeight > 0 ? notchHeight + 14 : 28)
-            if !tagLabels.isEmpty { tagBar.padding(.bottom, 8) }
+            if !tagLabels.isEmpty { topTagNavigation.padding(.bottom, 8) }
             Divider().opacity(0.3)
             appGridContent
         }
@@ -855,21 +906,97 @@
             Spacer().frame(height: notchHeight > 0 ? notchHeight + 14 : 28)
             Divider().opacity(0.3)
             HStack(spacing: 0) {
-                if tagPosition == "left" { tagSidebar; sideDivider }
+                if tagPosition == "left" { leftTagSidebar; sideDivider }
                 appGridContent
                 if tagPosition == "right" { sideDivider; rightTagSidebar }
             }
         }
     }
 
-    private var tagBar: some View {
+    private var topTagNavigation: some View {
+        Group {
+            if useAppKitTagNavigation {
+                appKitTagNavigation(orientation: .horizontal)
+                    .frame(height: 34)
+            } else {
+                swiftUITopTagBar
+            }
+        }
+    }
+
+    private var leftTagSidebar: some View {
+        Group {
+            if useAppKitTagNavigation {
+                appKitTagNavigation(orientation: .vertical)
+            } else {
+                swiftUITagSidebarList
+            }
+        }
+        .frame(width: 135)
+    }
+
+    private var rightTagSidebar: some View {
+        Group {
+            if useAppKitTagNavigation {
+                appKitTagNavigation(orientation: .vertical)
+            } else {
+                swiftUITagSidebarList
+            }
+        }
+        .padding(.top, rightSidebarFloatingClearance)
+        .frame(width: 135)
+    }
+
+    private func appKitTagNavigation(orientation: TagNavigationView.Orientation) -> some View {
+        let isHorizontal = orientation == .horizontal
+        let appDropTargetID = appGridInteraction.tagNavigationAppDropTargetName
+        return TagNavigationView(
+            items: tagLabels,
+            orientation: orientation,
+            contentInsets: isHorizontal
+                ? NSEdgeInsets(top: 3, left: 24, bottom: 3, right: tagPosition == "top" ? floatingControlsReservedWidth : 24)
+                : NSEdgeInsets(top: 12, left: 12, bottom: 12, right: 12),
+            dragModeActive: tagNavDragModeActive,
+            draggingItemID: tagNavDragItem,
+            appDragModeActive: appGridInteraction.appDragModeActive,
+            appDropTargetID: appDropTargetID,
+            onActivate: { tagID in
+                activateTagNavigation(tagID)
+            },
+            onHoverChange: { tagID, active in
+                handleTagNavigationHover(tagID, active: active)
+            },
+            canReorder: { tagID in
+                canReorderTag(tagID)
+            },
+            canAcceptAppDrop: { tagID in
+                canAssignDroppedAppToTag(tagID)
+            },
+            onReorderBegan: { tagID in
+                beginTagNavReorder(tagID)
+            },
+            onReorderMoved: { tagID, targetID in
+                reorderTagNavItem(fromName: tagID, to: targetID)
+            },
+            onReorderEnded: {
+                endTagNavReorder()
+            },
+            onAppDropHoverChange: { tagID, active in
+                handleTagNavigationAppDropHover(tagID, active: active)
+            },
+            onAppDrop: { path, source, targetTag, copy in
+                dropAppOnTagNavigation(path: path, sourceTag: source, targetTag: targetTag, copy: copy)
+            }
+        )
+    }
+
+    private var swiftUITopTagBar: some View {
         ScrollView(.horizontal, showsIndicators: false) {
             HStack(spacing: 8) {
                 ForEach(tagLabels) { tag in
                     TagPill(name: tag.name, colorIndex: tag.colorIndex,
                             dragModeActive: tagNavDragModeActive && canReorderTag(tag.name),
                             isDragging: tagNavDragItem == tag.name,
-                            dragResetToken: tagNavDragResetToken,
                             action: {
                         activateTagNavigation(tag.id)
                     })
@@ -877,10 +1004,7 @@
                     .zIndex(tagNavDragItem == tag.name ? 1 : 0)
                     .highPriorityGesture(tagNavReorderGesture(for: tag.name))
                     .onHover { hovering in
-                        if hovering {
-                            fillColorlessContainer(tag.id)
-                            scrollTo(tag.id)
-                        }
+                        handleTagNavigationHover(tag.id, active: hovering)
                     }
                 }
             }
@@ -893,25 +1017,13 @@
         }
     }
 
-    private var tagSidebar: some View {
-        tagSidebarList
-            .frame(width: 135)
-    }
-
-    private var rightTagSidebar: some View {
-        tagSidebarList
-            .padding(.top, rightSidebarFloatingClearance)
-            .frame(width: 135)
-    }
-
-    private var tagSidebarList: some View {
+    private var swiftUITagSidebarList: some View {
         ScrollView(.vertical, showsIndicators: false) {
             VStack(spacing: 6) {
                 ForEach(tagLabels) { tag in
                     SideTagPill(name: tag.name, colorIndex: tag.colorIndex,
                                 dragModeActive: tagNavDragModeActive && canReorderTag(tag.name),
                                 isDragging: tagNavDragItem == tag.name,
-                                dragResetToken: tagNavDragResetToken,
                                 action: {
                         activateTagNavigation(tag.id)
                     })
@@ -919,10 +1031,7 @@
                     .zIndex(tagNavDragItem == tag.name ? 1 : 0)
                     .highPriorityGesture(tagNavReorderGesture(for: tag.name))
                     .onHover { hovering in
-                        if hovering {
-                            fillColorlessContainer(tag.id)
-                            scrollTo(tag.id)
-                        }
+                        handleTagNavigationHover(tag.id, active: hovering)
                     }
                 }
             }
@@ -944,21 +1053,45 @@
                 Spacer()
                 ProgressView().scaleEffect(0.8)
                 Spacer()
-            } else if displayMode == "gridContainer" || displayMode == "coloredGridContainer" {
-                gridContainerGrid
-            } else if displayMode == "container" || displayMode == "coloredContainer" {
-                containerGrid
             } else {
-                flatGrid
+                AppGridCollectionView(
+                    groups: displayGroups,
+                    tagColors: tagColors,
+                    displayMode: displayMode,
+                    iconSize: iconSize,
+                    showNames: !hideAppNames,
+                    bubbleDisabled: appBubbleDisabled,
+                    showUncommonAppBubbles: showUncommonAppBubbles,
+                    highlightedGroupName: appGridHighlightedGroupName,
+                    contentRevision: groupLayoutVersion,
+                    scrollTargetID: appGridScrollTargetID,
+                    scrollRequestToken: appGridScrollRequestToken,
+                    onSelectApp: { app in openApp(app) },
+                    onBubbleHover: handleBubbleHover,
+                    onEditNote: beginEditingBubbleNote,
+                    onDropApp: { path, source, target, copy in
+                        dropApp(path: path, sourceTag: source, targetTag: target, copy: copy)
+                    },
+                    onDropOutsideGroup: { path, source, copy in
+                        dropAppOutsideGroup(path: path, sourceTag: source, copy: copy)
+                    },
+                    onGroupActivate: { groupName in
+                        if isColorlessContainerMode {
+                            toggleColorlessFill(groupName)
+                        }
+                    },
+                    onScrollActivity: handleAppGridScrollActivity,
+                    onDragModeChange: { setAppDragMode($0) }
+                )
             }
         }
     }
 
     private var uncommonAppBubbleOverlay: some View {
         GeometryReader { proxy in
-            if let context = editingBubble ?? hoveredBubble {
+            if let context = appGridInteraction.editingBubble ?? appGridInteraction.hoveredBubble {
                 let rootFrame = proxy.frame(in: .global)
-                let editing = editingBubble != nil
+                let editing = appGridInteraction.editingBubble != nil
                 let width = min(editing ? 440 : 520, max(260, proxy.size.width - 48))
                 let placement = bubblePlacement(for: context.frame, rootFrame: rootFrame)
                 let metrics = bubbleMetrics(
@@ -971,12 +1104,12 @@
                 )
 
                 AppNameBubble(
-                    appName: context.app.name,
+                    appName: context.app.displayName,
                     note: currentNote(for: context.app),
                     isEditing: editing,
                     placement: placement,
                     arrowOffset: metrics.arrowOffset,
-                    draftNote: $bubbleDraftNote,
+                    draftNote: $appGridInteraction.bubbleDraftNote,
                     noteFocused: $bubbleNoteFocused,
                     onCommit: commitBubbleNote,
                     onCancel: dismissAppBubble
@@ -989,621 +1122,17 @@
             }
         }
         .ignoresSafeArea()
-        .allowsHitTesting(editingBubble != nil)
+        .allowsHitTesting(appGridInteraction.editingBubble != nil)
     }
 
     private var smartStartNoticeOverlay: some View {
-        GeometryReader { proxy in
-            if let notice = smartStartNotice {
-                let panelWidth = min(560, max(320, proxy.size.width - 64))
-
-                ZStack {
-                    Color.black.opacity(0.10)
-                        .ignoresSafeArea()
-
-                    VStack(spacing: 18) {
-                        Image(systemName: notice.mode == .suggestionOnly ? "sparkles" : "checkmark.seal.fill")
-                            .font(.system(size: 30, weight: .semibold))
-                            .foregroundStyle(Color.accentColor)
-                            .frame(width: 58, height: 58)
-                            .background(
-                                Circle()
-                                    .fill(Color.accentColor.opacity(0.12))
-                            )
-
-                        VStack(spacing: 8) {
-                            Text(notice.title)
-                                .font(.system(size: 21, weight: .semibold))
-                                .foregroundStyle(.primary)
-                                .multilineTextAlignment(.center)
-
-                            Text(notice.message)
-                                .font(.system(size: 15, weight: .regular))
-                                .foregroundStyle(.secondary)
-                                .multilineTextAlignment(.center)
-                                .lineLimit(4)
-                                .fixedSize(horizontal: false, vertical: true)
-                        }
-
-                        HStack(spacing: 12) {
-                            switch notice.mode {
-                            case .suggestionOnly:
-                                Button(tr("smartstart.later")) {
-                                    dismissSmartStartNotice()
-                                }
-                                .buttonStyle(.bordered)
-                                .controlSize(.large)
-
-                                Button(tr("smartstart.apply")) {
-                                    applySmartStartSuggestion()
-                                }
-                                .buttonStyle(.borderedProminent)
-                                .controlSize(.large)
-                            case .autoApplied, .manuallyApplied:
-                                if notice.summary.backupPath != nil {
-                                    Button(tr("smartstart.undo")) {
-                                        undoSmartStart()
-                                    }
-                                    .buttonStyle(.bordered)
-                                    .controlSize(.large)
-                                }
-                                Button(tr("smartstart.ok")) {
-                                    dismissSmartStartNotice()
-                                }
-                                .buttonStyle(.borderedProminent)
-                                .controlSize(.large)
-                            }
-                        }
-                    }
-                    .padding(.horizontal, 30)
-                    .padding(.vertical, 26)
-                    .frame(width: panelWidth)
-                    .background(
-                        RoundedRectangle(cornerRadius: 16)
-                            .fill(.ultraThickMaterial)
-                            .shadow(color: .black.opacity(0.26), radius: 28, y: 16)
-                    )
-                    .overlay(
-                        RoundedRectangle(cornerRadius: 16)
-                            .stroke(.white.opacity(0.16), lineWidth: 1)
-                    )
-                }
-                .frame(width: proxy.size.width, height: proxy.size.height)
-                .transition(.scale(scale: 0.96).combined(with: .opacity))
-                .zIndex(650)
-            }
-        }
-        .ignoresSafeArea()
-        .allowsHitTesting(smartStartNotice != nil)
-    }
-    private var flatGrid: some View {
-        ScrollViewReader { proxy in
-            ScrollView {
-                LazyVStack(alignment: .leading, spacing: 24) {
-                    ForEach(displayGroups) { group in
-                        TagGroupView(
-                            group: group,
-                            onSelectApp: { app in openApp(app) },
-                            tagFontSize: tagFontSize,
-                            iconSize: iconSize,
-                            showNames: !hideAppNames,
-                            dragModeActive: appDragModeActive,
-                            onDragModeChange: { setAppDragMode($0) },
-                            onBubbleHover: handleBubbleHover,
-                            onEditNote: beginEditingBubbleNote,
-                            bubbleDisabled: appBubbleDisabled,
-                            dragResetToken: appDragResetToken,
-                            hoveredAppItemID: $hoveredAppItemID,
-                            onDropApp: { path, source, copy in
-                                dropApp(path: path, sourceTag: source, targetTag: group.name, copy: copy)
-                            }
-                        ).id(group.id)
-                    }
-                }
-                .padding(20)
-                .background(AppGridScrollActivityObserver(onScroll: handleAppGridScrollActivity))
-            }
-            .id(displayMode)  // force rebuild on mode switch
-            .onAppear { scrollProxy = proxy }
-        }
-    }
-
-    private var containerGrid: some View {
-        GeometryReader { geo in
-            let outerPad: CGFloat = 20
-            let gap: CGFloat = 16
-            let available = geo.size.width - outerPad * 2
-            let colW: CGFloat = 280
-            let colCount = max(1, Int((available + gap) / (colW + gap)))
-            let actualColW = (available - gap * CGFloat(colCount - 1)) / CGFloat(colCount)
-
-            let columns = distributeToColumns(groups: displayGroups, colCount: colCount, colWidth: actualColW)
-
-            ScrollViewReader { proxy in
-                ScrollView {
-                    HStack(alignment: .top, spacing: gap) {
-                        ForEach(0..<colCount, id: \.self) { ci in
-                            LazyVStack(spacing: gap) {
-                                ForEach(columns[ci]) { group in
-                                    masonryCard(group, width: actualColW)
-                                        .id(group.id)
-                                }
-                            }
-                        }
-                    }
-                    .padding(outerPad)
-                    .background(AppGridScrollActivityObserver(onScroll: handleAppGridScrollActivity))
-                }
-                .id(displayMode)  // force rebuild on mode switch
-                .onAppear { scrollProxy = proxy }
-            }
-        }
-    }
-
-    /// Distribute groups to the shortest column.
-    private func distributeToColumns(groups: [TagGroup], colCount: Int, colWidth: CGFloat) -> [[TagGroup]] {
-        var cols = Array(repeating: [TagGroup](), count: colCount)
-        var h = Array(repeating: CGFloat(0), count: colCount)
-        for g in groups {
-            let est = estimatedCardHeight(g, width: colWidth)
-            let ci = h.firstIndex(of: h.min()!)!
-            cols[ci].append(g)
-            h[ci] += est + 16
-        }
-        return cols
-    }
-
-    private func estimatedCardHeight(_ group: TagGroup, width: CGFloat) -> CGFloat {
-        let inner = width - 32
-        let itemW = AppGridItem.stableWidth(iconSize: iconSize) + 6
-        let perRow = max(1, Int(inner / itemW))
-        let rows = (group.apps.count + perRow - 1) / perRow
-        return 32
-            + CGFloat(rows) * AppGridItem.stableHeight(iconSize: iconSize)
-            + CGFloat(max(0, rows - 1)) * 2
-    }
-
-    private func masonryCard(_ group: TagGroup, width: CGFloat) -> some View {
-        let isColored = displayMode == "coloredContainer"
-        let isColorless = isColorlessContainerMode
-        let isColorlessFilled = isColorless && filledColorlessContainer == group.name
-        let isHovered = hoveredContainer == group.name
-        let isColorlessActive = isColorless && (isColorlessFilled || isHovered)
-        let tagColor = Color(nsColor: TagColor.nsColor(for: tagColors[group.name] ?? 0))
-        return VStack(alignment: .leading, spacing: 6) {
-            HStack(spacing: 0) {
-                Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
-                    .layoutPriority(0)
-                Text(group.name)
-                    .font(.system(size: tagFontSize, weight: .semibold))
-                    .foregroundStyle(.secondary)
-                    .lineLimit(1)
-                    .truncationMode(.middle)
-                    .padding(.horizontal, 10)
-                    .layoutPriority(1)
-                Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
-                    .layoutPriority(0)
-            }
-            let itemSize = AppGridItem.stableWidth(iconSize: iconSize)
-            LazyVGrid(
-                columns: [GridItem(.adaptive(minimum: itemSize, maximum: itemSize + 36), spacing: 6)],
-                spacing: 2
-            ) {
-                ForEach(group.apps) { app in
-                    AppGridItem(
-                        app: app,
-                        iconSize: iconSize,
-                        showName: !hideAppNames,
-                        sourceTag: group.name,
-                        dragModeActive: appDragModeActive,
-                        onDragModeChange: { setAppDragMode($0) },
-                        onBubbleHover: handleBubbleHover,
-                        onEditNote: beginEditingBubbleNote,
-                        bubbleDisabled: appBubbleDisabled,
-                        itemID: "\(group.name)|\(app.path.path)",
-                        dragResetToken: appDragResetToken,
-                        hoveredAppItemID: $hoveredAppItemID,
-                        onSelect: { openApp(app) }
-                    )
-                }
-            }
-        }
-        .frame(maxWidth: width)
-        .padding(16)
-        .background(
-            RoundedRectangle(cornerRadius: 14)
-                .fill((isColored || isColorlessActive) ? tagColor.opacity(0.30) : Color.clear)
-                .background(
-                    RoundedRectangle(cornerRadius: 14)
-                        .fill(.ultraThinMaterial)
-                )
-        )
-        .overlay(
-            RoundedRectangle(cornerRadius: 14)
-                .stroke(Color.primary.opacity(0.08), lineWidth: 1)
-        )
-        .overlay {
-            AppDropTargetView(targetTag: group.name) { path, source, copy in
-                dropApp(path: path, sourceTag: source, targetTag: group.name, copy: copy)
-            }
-            .allowsHitTesting(false)
-        }
-        .shadow(color: .black.opacity((isColored && isHovered) || isColorlessActive ? 0.22 : 0),
-                radius: (isColored && isHovered) || isColorlessActive ? 8 : 0,
-                y: (isColored && isHovered) || isColorlessActive ? 3 : 0)
-        .zIndex(isHovered ? 50 : 0)
-        .animation(.easeOut(duration: 0.045), value: isHovered)
-        .animation(.easeOut(duration: 0.08), value: isColorlessFilled)
-        .onHover { hovering in
-            guard !scrollInteractionState.isFrozen else {
-                if !hovering && hoveredContainer == group.name {
-                    hoveredContainer = nil
-                }
-                return
-            }
-            if isColored || isColorless {
-                hoveredContainer = hovering ? group.name : nil
-            }
-        }
-        .contentShape(RoundedRectangle(cornerRadius: 14))
-        .onTapGesture {
-            if isColorless {
-                toggleColorlessFill(group.name)
-            }
-        }
-        .onDrop(of: [UTType.plainText], isTargeted: nil) { providers in
-            handleAppDrop(providers, targetTag: group.name)
-        }
-    }
-
-    private var gridContainerGrid: some View {
-        GeometryReader { geo in
-            let outerPad: CGFloat = 20
-            let gap: CGFloat = 16
-            let available = geo.size.width - outerPad * 2
-            let preferredCount = preferredGridContainersPerRow(availableWidth: available)
-            let rowsKey = GridContainerRowsKey(
-                groupLayoutVersion: groupLayoutVersion,
-                trackCount: preferredCount,
-                availableWidth: Int(available.rounded()),
-                iconSize: Int(iconSize.rounded())
-            )
-            let rows = gridContainerRowsForRender(
-                key: rowsKey,
-                groups: displayGroups,
-                trackCount: preferredCount,
-                availableWidth: available,
-                gap: gap
-            )
-
-            ScrollViewReader { proxy in
-                ScrollView {
-                    LazyVStack(alignment: .leading, spacing: gap) {
-                        ForEach(Array(rows.indices), id: \.self) { rowIndex in
-                            let row = rows[rowIndex]
-
-                            HStack(alignment: .top, spacing: gap) {
-                                ForEach(Array(row.items.indices), id: \.self) { itemIndex in
-                                    let item = row.items[itemIndex]
-                                    gridContainerCard(item.group, width: item.width, fixedRows: row.fixedRows)
-                                        .id(item.group.id)
-                                }
-                            }
-                        }
-                    }
-                    .padding(outerPad)
-                    .frame(maxWidth: .infinity, alignment: .topLeading)
-                    .background(AppGridScrollActivityObserver(onScroll: handleAppGridScrollActivity))
-                }
-                .id(displayMode)
-                .onAppear { scrollProxy = proxy }
-                .onAppear {
-                    updateCachedGridContainerRows(
-                        key: rowsKey,
-                        groups: displayGroups,
-                        trackCount: preferredCount,
-                        availableWidth: available,
-                        gap: gap
-                    )
-                }
-                .onChange(of: rowsKey) { _, newKey in
-                    updateCachedGridContainerRows(
-                        key: newKey,
-                        groups: displayGroups,
-                        trackCount: preferredCount,
-                        availableWidth: available,
-                        gap: gap
-                    )
-                }
-            }
-        }
-    }
-
-    private func preferredGridContainersPerRow(availableWidth: CGFloat) -> Int {
-        let minCardWidth = max(260, AppGridItem.stableWidth(iconSize: iconSize) * 3 + 64)
-        if availableWidth >= minCardWidth * 3 + 32 { return 3 }
-        if availableWidth >= minCardWidth * 2 + 16 { return 2 }
-        return 1
-    }
-
-    private struct GridContainerLayoutItem {
-        let group: TagGroup
-        let width: CGFloat
-    }
-
-    private struct GridContainerLayoutRow {
-        let items: [GridContainerLayoutItem]
-        let fixedRows: Int
-    }
-
-    private struct GridContainerRowsKey: Equatable {
-        let groupLayoutVersion: Int
-        let trackCount: Int
-        let availableWidth: Int
-        let iconSize: Int
-    }
-
-    private struct GridContainerCandidate {
-        let spans: [Int]
-        let rows: Int
-        let cost: CGFloat
-    }
-
-    private func gridContainerRowsForRender(
-        key: GridContainerRowsKey,
-        groups: [TagGroup],
-        trackCount: Int,
-        availableWidth: CGFloat,
-        gap: CGFloat
-    ) -> [GridContainerLayoutRow] {
-        if cachedGridContainerRowsKey == key {
-            return cachedGridContainerRows
-        }
-        return gridContainerRows(
-            groups: groups,
-            trackCount: trackCount,
-            availableWidth: availableWidth,
-            gap: gap
+        SmartStartNoticeOverlay(
+            notice: smartStartNotice,
+            onDismiss: dismissSmartStartNotice,
+            onApply: applySmartStartSuggestion,
+            onUndo: undoSmartStart
         )
     }
-
-    private func updateCachedGridContainerRows(
-        key: GridContainerRowsKey,
-        groups: [TagGroup],
-        trackCount: Int,
-        availableWidth: CGFloat,
-        gap: CGFloat
-    ) {
-        guard cachedGridContainerRowsKey != key else { return }
-        cachedGridContainerRows = gridContainerRows(
-            groups: groups,
-            trackCount: trackCount,
-            availableWidth: availableWidth,
-            gap: gap
-        )
-        cachedGridContainerRowsKey = key
-    }
-
-    private func gridContainerRows(groups: [TagGroup], trackCount: Int, availableWidth: CGFloat, gap: CGFloat) -> [GridContainerLayoutRow] {
-        let trackCount = max(1, trackCount)
-        let trackWidth = (availableWidth - gap * CGFloat(trackCount - 1)) / CGFloat(trackCount)
-        let patterns = gridContainerSpanPatterns(trackCount: trackCount)
-        let n = groups.count
-        guard n > 0 else { return [] }
-
-        var bestCost = Array(repeating: CGFloat.greatestFiniteMagnitude, count: n + 1)
-        var bestPattern = Array(repeating: [Int](), count: n)
-        bestCost[n] = 0
-
-        for index in stride(from: n - 1, through: 0, by: -1) {
-            for pattern in patterns where index + pattern.count <= n {
-                let candidate = gridContainerCandidate(
-                    groups: groups,
-                    startIndex: index,
-                    spans: pattern,
-                    trackWidth: trackWidth,
-                    availableWidth: availableWidth,
-                    gap: gap
-                )
-                let totalCost = candidate.cost + bestCost[index + pattern.count]
-                if totalCost < bestCost[index] {
-                    bestCost[index] = totalCost
-                    bestPattern[index] = candidate.spans
-                }
-            }
-        }
-
-        var rows: [GridContainerLayoutRow] = []
-        var index = 0
-        while index < n {
-            let spans = bestPattern[index].isEmpty ? [trackCount] : bestPattern[index]
-            let widths = spans.map { gridContainerWidth(trackWidth: trackWidth, span: $0, gap: gap) }
-            let fixedRows = widths.indices.map {
-                iconRows(appCount: groups[index + $0].apps.count, width: widths[$0])
-            }.max() ?? 1
-            let items = widths.indices.map {
-                GridContainerLayoutItem(group: groups[index + $0], width: widths[$0])
-            }
-            rows.append(GridContainerLayoutRow(items: items, fixedRows: fixedRows))
-            index += spans.count
-        }
-        return rows
-    }
-
-    private func gridContainerSpanPatterns(trackCount: Int) -> [[Int]] {
-        switch trackCount {
-        case 3:
-            return [[1, 1, 1], [1, 2], [2, 1], [3]]
-        case 2:
-            return [[1, 1], [2]]
-        default:
-            return [[1]]
-        }
-    }
-
-    private func gridContainerCandidate(
-        groups: [TagGroup],
-        startIndex: Int,
-        spans: [Int],
-        trackWidth: CGFloat,
-        availableWidth: CGFloat,
-        gap: CGFloat
-    ) -> GridContainerCandidate {
-        let widths = spans.map { gridContainerWidth(trackWidth: trackWidth, span: $0, gap: gap) }
-        let rowCounts = widths.indices.map {
-            iconRows(appCount: groups[startIndex + $0].apps.count, width: widths[$0])
-        }
-        let fixedRows = rowCounts.max() ?? 1
-        let rowArea = CGFloat(fixedRows) * iconCellHeight() * availableWidth
-        let paddingCost = CGFloat(spans.count) * 0.001
-        return GridContainerCandidate(spans: spans, rows: fixedRows, cost: rowArea + paddingCost)
-    }
-
-    private func gridContainerWidth(trackWidth: CGFloat, span: Int, gap: CGFloat) -> CGFloat {
-        let span = max(1, span)
-        return trackWidth * CGFloat(span) + gap * CGFloat(span - 1)
-    }
-
-    private func iconColumns(width: CGFloat) -> Int {
-        let inner = width - 32
-        let itemW = AppGridItem.stableWidth(iconSize: iconSize) + 6
-        return max(1, Int((inner + 6) / itemW))
-    }
-
-    private func iconRows(appCount: Int, width: CGFloat) -> Int {
-        let cols = iconColumns(width: width)
-        return max(1, (appCount + cols - 1) / cols)
-    }
-
-    private func gridContainerCard(_ group: TagGroup, width: CGFloat, fixedRows: Int) -> some View {
-        let isColored = displayMode == "coloredGridContainer"
-        let isColorlessGrid = displayMode == "gridContainer"
-        let isColorless = isColorlessContainerMode
-        let isColorlessFilled = isColorless && filledColorlessContainer == group.name
-        let isHovered = hoveredContainer == group.name
-        let isColorlessGridActive = isColorlessGrid && (isColorlessFilled || isHovered)
-        let cols = iconColumns(width: width)
-        let contentWidth = max(1, width - 32)
-        let cellWidth = max(1, (contentWidth - 6 * CGFloat(cols - 1)) / CGFloat(cols))
-        let cellHeight = iconCellHeight()
-        let gridHeight = CGFloat(fixedRows) * cellHeight + CGFloat(max(0, fixedRows - 1)) * 2
-        let rows = appRows(group.apps, columns: cols, fixedRows: fixedRows)
-        let tagColor = Color(nsColor: TagColor.nsColor(for: tagColors[group.name] ?? 0))
-
-        return VStack(alignment: .leading, spacing: 6) {
-            HStack(spacing: 0) {
-                Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
-                    .layoutPriority(0)
-                Text(group.name)
-                    .font(.system(size: tagFontSize, weight: .semibold))
-                    .foregroundStyle(.secondary)
-                    .lineLimit(1)
-                    .truncationMode(.middle)
-                    .padding(.horizontal, 10)
-                    .layoutPriority(1)
-                Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
-                    .layoutPriority(0)
-            }
-
-            VStack(alignment: .leading, spacing: 2) {
-                ForEach(rows.indices, id: \.self) { rowIndex in
-                    HStack(alignment: .top, spacing: 6) {
-                        ForEach(rows[rowIndex]) { app in
-                            AppGridItem(
-                                app: app,
-                                iconSize: iconSize,
-                                showName: !hideAppNames,
-                                sourceTag: group.name,
-                                dragModeActive: appDragModeActive,
-                                onDragModeChange: { setAppDragMode($0) },
-                                onBubbleHover: handleBubbleHover,
-                                onEditNote: beginEditingBubbleNote,
-                                bubbleDisabled: appBubbleDisabled,
-                                itemID: "\(group.name)|\(app.path.path)",
-                                dragResetToken: appDragResetToken,
-                                hoveredAppItemID: $hoveredAppItemID,
-                                onSelect: { openApp(app) }
-                            )
-                                .frame(width: cellWidth)
-                                .frame(height: cellHeight)
-                        }
-
-                        let emptyCells = max(0, cols - rows[rowIndex].count)
-                        ForEach(0..<emptyCells, id: \.self) { _ in
-                            Color.clear
-                                .frame(width: cellWidth, height: cellHeight)
-                        }
-                    }
-                    .frame(height: cellHeight)
-                }
-            }
-            .frame(height: gridHeight, alignment: .topLeading)
-        }
-        .frame(width: contentWidth)
-        .padding(16)
-        .background(
-            RoundedRectangle(cornerRadius: 14)
-                .fill((isColored || isColorlessGridActive) ? tagColor.opacity(0.30) : Color.clear)
-                .background(
-                    RoundedRectangle(cornerRadius: 14)
-                        .fill(.ultraThinMaterial)
-                )
-        )
-        .overlay(
-            RoundedRectangle(cornerRadius: 14)
-                .stroke(Color.primary.opacity(0.08), lineWidth: 1)
-        )
-        .overlay {
-            AppDropTargetView(targetTag: group.name) { path, source, copy in
-                dropApp(path: path, sourceTag: source, targetTag: group.name, copy: copy)
-            }
-            .allowsHitTesting(false)
-        }
-        .shadow(color: .black.opacity((isColored && isHovered) || isColorlessGridActive ? 0.22 : 0),
-                radius: (isColored && isHovered) || isColorlessGridActive ? 8 : 0,
-                y: (isColored && isHovered) || isColorlessGridActive ? 3 : 0)
-        .zIndex(isHovered ? 50 : 0)
-        .animation(.easeOut(duration: 0.045), value: isHovered)
-        .animation(.easeOut(duration: 0.08), value: isColorlessFilled)
-        .onHover { hovering in
-            guard !scrollInteractionState.isFrozen else {
-                if !hovering && hoveredContainer == group.name {
-                    hoveredContainer = nil
-                }
-                return
-            }
-            if isColored || isColorlessGrid {
-                hoveredContainer = hovering ? group.name : nil
-            } else if hovering {
-                fillColorlessContainer(group.name)
-            }
-        }
-        .contentShape(RoundedRectangle(cornerRadius: 14))
-        .onTapGesture {
-            if isColorlessGrid {
-                toggleColorlessFill(group.name)
-            }
-        }
-        .onDrop(of: [UTType.plainText], isTargeted: nil) { providers in
-            handleAppDrop(providers, targetTag: group.name)
-        }
-    }
-
-    private func iconCellHeight() -> CGFloat {
-        AppGridItem.stableHeight(iconSize: iconSize)
-    }
-
-    private func appRows(_ apps: [AppInfo], columns: Int, fixedRows: Int) -> [[AppInfo]] {
-        let columns = max(1, columns)
-        let rowCount = max(1, fixedRows)
-        return (0..<rowCount).map { rowIndex in
-            let start = rowIndex * columns
-            guard start < apps.count else { return [] }
-            let end = min(start + columns, apps.count)
-            return Array(apps[start..<end])
-        }
-    }
-
     // MARK: - Edit Tags View
 
     private var editTagsView: some View {
@@ -1728,8 +1257,8 @@
                 columns: [
                     GridItem(
                         .adaptive(
-                            minimum: AppGridItem.stableWidth(iconSize: iconSize),
-                            maximum: AppGridItem.stableWidth(iconSize: iconSize) + 36
+                            minimum: AppGridItemMetrics.stableWidth(iconSize: iconSize),
+                            maximum: AppGridItemMetrics.stableWidth(iconSize: iconSize) + 36
                         ),
                         spacing: 6
                     )
@@ -1923,7 +1452,7 @@
 
     private var uncategorizedDropConfirmOverlay: some View {
         GeometryReader { proxy in
-            if let pendingDrop = pendingUncategorizedDrop {
+            if let pendingDrop = appGridInteraction.pendingUncategorizedDrop {
                 ZStack {
                     Color.black.opacity(0.14)
                         .ignoresSafeArea()
@@ -1931,6 +1460,8 @@
                     UncategorizedDropConfirmBubble(
                         title: tr("drop.uncategorizedConfirmTitle"),
                         message: uncategorizedConfirmMessage(for: pendingDrop),
+                        doNotRemindTitle: tr("drop.removeTagDoNotAskAgain"),
+                        doNotRemind: $appGridInteraction.uncategorizedDropSuppressFuturePrompt,
                         cancelTitle: tr("tag.cancel"),
                         confirmTitle: tr("edit.confirm"),
                         onCancel: dismissUncategorizedDropConfirm,
@@ -1944,7 +1475,35 @@
             }
         }
         .ignoresSafeArea()
-        .allowsHitTesting(pendingUncategorizedDrop != nil)
+        .allowsHitTesting(appGridInteraction.pendingUncategorizedDrop != nil)
+    }
+
+    private var tagRemovalDropConfirmOverlay: some View {
+        GeometryReader { proxy in
+            if let pendingDrop = appGridInteraction.pendingTagRemovalDrop {
+                ZStack {
+                    Color.black.opacity(0.14)
+                        .ignoresSafeArea()
+
+                    TagRemovalDropConfirmBubble(
+                        title: tr("drop.removeTagConfirmTitle"),
+                        message: tagRemovalConfirmMessage(for: pendingDrop),
+                        doNotRemindTitle: tr("drop.removeTagDoNotAskAgain"),
+                        doNotRemind: $appGridInteraction.tagRemovalDropSuppressFuturePrompt,
+                        cancelTitle: tr("drop.removeTagConfirmNo"),
+                        confirmTitle: tr("drop.removeTagConfirmYes"),
+                        onCancel: dismissTagRemovalDropConfirm,
+                        onConfirm: confirmPendingTagRemovalDrop
+                    )
+                    .frame(width: min(560, max(350, proxy.size.width - 120)))
+                    .position(x: proxy.size.width / 2, y: proxy.size.height / 2)
+                    .transition(.scale(scale: 0.94).combined(with: .opacity))
+                }
+                .zIndex(711)
+            }
+        }
+        .ignoresSafeArea()
+        .allowsHitTesting(appGridInteraction.pendingTagRemovalDrop != nil)
     }
 
     private func buildEditActionFeedback(for selectedApps: [AppInfo], tags: [String]) -> EditActionFeedback {
@@ -2095,23 +1654,14 @@
 
         let scannedApps = allApps
         DispatchQueue.global(qos: .userInitiated).async {
-            let result = SmartStartService.applySuggestion(draft)
-            let store = result.store
-            let apps = TagEditor.annotate(apps: scannedApps, store: store)
-            let quickSearchDocs = QuickSearchEngine.makeDocuments(apps: apps, store: store)
-            let colors = store.tags.mapValues { $0.color }
-            let order = TagEditor.orderedTagNames()
+            let result = AppLibraryController.applySmartStartSuggestion(
+                draft,
+                scannedApps: scannedApps
+            )
 
             DispatchQueue.main.async {
                 pendingSmartStartDraft = nil
-                allApps = apps
-                quickSearchDocuments = quickSearchDocs
-                tagColors = colors
-                draggedTagNames = order
-                rebuildDisplayGroups(apps: apps, tagOrder: order)
-                if quickSearchVisible {
-                    refreshQuickSearchResults()
-                }
+                applyAppLibrarySnapshot(result.snapshot)
                 if let summary = result.summary {
                     showSmartStartNotice(mode: .manuallyApplied, summary: summary)
                 } else {
@@ -2187,11 +1737,10 @@
     private func rebuildDisplayGroups(apps: [AppInfo], tagOrder: [String]) {
         displayGroups = makeDisplayGroups(apps: apps, tagOrder: tagOrder)
         groupLayoutVersion &+= 1
-        cachedGridContainerRowsKey = nil
     }
 
-    private var tagLabels: [TagLabel] {
-        displayGroups.map { TagLabel(name: $0.name, colorIndex: tagColors[$0.name] ?? 0) }
+    private var tagLabels: [TagNavigationItem] {
+        displayGroups.map { TagNavigationItem(name: $0.name, colorIndex: tagColors[$0.name] ?? 0) }
     }
 
     private var editGroups: [TagGroup] {
@@ -2221,12 +1770,9 @@
     }
 
     private func handleAppGridScrollActivity() {
-        if !scrollInteractionState.isFrozen {
-            hoveredAppItemID = nil
-            hoveredBubble = nil
-            hoveredContainer = nil
+        if appGridInteraction.hoveredBubble != nil {
+            appGridInteraction.hoveredBubble = nil
         }
-        scrollInteractionState.noteScroll()
     }
 
     private func handleBubbleHover(app: AppInfo, frame: CGRect, event: AppBubbleHoverEvent) {
@@ -2234,17 +1780,17 @@
             clearAppBubbleState()
             return
         }
-        guard editingBubble == nil else { return }
+        guard appGridInteraction.editingBubble == nil else { return }
         switch event {
         case .entered(let canShowBubble):
             if canShowBubble {
-                hoveredBubble = AppBubbleContext(app: app, frame: frame)
+                appGridInteraction.hoveredBubble = AppBubbleContext(app: app, frame: frame)
             } else {
-                hoveredBubble = nil
+                appGridInteraction.hoveredBubble = nil
             }
         case .exited:
-            guard hoveredBubble?.app.path == app.path else { return }
-            hoveredBubble = nil
+            guard appGridInteraction.hoveredBubble?.app.path == app.path else { return }
+            appGridInteraction.hoveredBubble = nil
         }
     }
 
@@ -2253,9 +1799,9 @@
             clearAppBubbleState()
             return
         }
-        bubbleDraftNote = currentNote(for: app)
-        hoveredBubble = nil
-        editingBubble = AppBubbleContext(app: app, frame: frame)
+        appGridInteraction.bubbleDraftNote = currentNote(for: app)
+        appGridInteraction.hoveredBubble = nil
+        appGridInteraction.editingBubble = AppBubbleContext(app: app, frame: frame)
         notifyAppNoteEditing(active: true)
         DispatchQueue.main.async {
             bubbleNoteFocused = true
@@ -2263,34 +1809,37 @@
     }
 
     private func commitBubbleNote() {
-        guard let context = editingBubble else { return }
-        let limited = String(bubbleDraftNote.prefix(TagDatabase.maxAppNoteLength))
+        guard let context = appGridInteraction.editingBubble else { return }
+        let limited = String(appGridInteraction.bubbleDraftNote.prefix(TagDatabase.maxAppNoteLength))
             .trimmingCharacters(in: .whitespacesAndNewlines)
         TagEditor.setAppNote(limited, for: context.app.path.path)
-        bubbleDraftNote = limited
-        editingBubble = nil
+        appGridInteraction.bubbleDraftNote = limited
+        appGridInteraction.editingBubble = nil
         bubbleNoteFocused = false
         notifyAppNoteEditing(active: false)
         refreshApps()
     }
 
     private func dismissAppBubble() {
-        hoveredBubble = nil
-        if editingBubble != nil {
+        appGridInteraction.hoveredBubble = nil
+        if appGridInteraction.editingBubble != nil {
             notifyAppNoteEditing(active: false)
         }
-        editingBubble = nil
+        appGridInteraction.editingBubble = nil
         bubbleNoteFocused = false
     }
 
     private func clearAppBubbleState() {
-        hoveredAppItemID = nil
-        hoveredBubble = nil
-        if editingBubble != nil {
-            notifyAppNoteEditing(active: false)
+        if appGridInteraction.hoveredBubble != nil {
+            appGridInteraction.hoveredBubble = nil
         }
-        editingBubble = nil
-        bubbleNoteFocused = false
+        if appGridInteraction.editingBubble != nil {
+            notifyAppNoteEditing(active: false)
+            appGridInteraction.editingBubble = nil
+        }
+        if bubbleNoteFocused {
+            bubbleNoteFocused = false
+        }
     }
 
     private func notifyAppNoteEditing(active: Bool) {
@@ -2354,7 +1903,8 @@
     }
 
     func scrollTo(_ id: String) {
-        withAnimation(.easeInOut(duration: 0.25)) { scrollProxy?.scrollTo(id, anchor: .top) }
+        appGridScrollTargetID = id
+        appGridScrollRequestToken &+= 1
     }
 
     private func activateTagNavigation(_ id: String) {
@@ -2362,6 +1912,56 @@
         if isColorlessContainerMode {
             toggleColorlessFill(id)
         }
+        scrollTo(id)
+    }
+
+    private func handleTagNavigationHover(_ id: String, active: Bool) {
+        if appGridInteraction.appDragModeActive {
+            if !active, appGridInteraction.tagNavigationHoveredGroupName == id {
+                appGridInteraction.tagNavigationHoveredGroupName = nil
+            }
+            return
+        }
+
+        guard active else {
+            if appGridInteraction.tagNavigationHoveredGroupName == id {
+                appGridInteraction.tagNavigationHoveredGroupName = nil
+            }
+            return
+        }
+
+        appGridInteraction.tagNavigationHoveredGroupName = id
+        fillColorlessContainer(id)
+        scrollToTagFromHover(id)
+    }
+
+    private func handleTagNavigationAppDropHover(_ id: String, active: Bool) {
+        guard appGridInteraction.appDragModeActive else {
+            if appGridInteraction.tagNavigationAppDropTargetName == id {
+                appGridInteraction.tagNavigationAppDropTargetName = nil
+            }
+            return
+        }
+
+        guard active, canAssignDroppedAppToTag(id) else {
+            if appGridInteraction.tagNavigationAppDropTargetName == id {
+                appGridInteraction.tagNavigationAppDropTargetName = nil
+            }
+            return
+        }
+
+        appGridInteraction.tagNavigationAppDropTargetName = id
+    }
+
+    private func scrollToTagFromHover(_ id: String) {
+        let now = Date()
+        if appGridInteraction.tagNavigationLastHoverScrollID == id,
+           let lastScrollAt = appGridInteraction.tagNavigationLastHoverScrollAt,
+           now.timeIntervalSince(lastScrollAt) < tagNavigationHoverScrollInterval {
+            return
+        }
+        appGridInteraction.tagNavigationLastHoverScrollID = id
+        appGridInteraction.tagNavigationLastHoverScrollAt = now
         scrollTo(id)
     }
 
@@ -2425,13 +2025,14 @@
     }
 
     private func endTagNavReorder() {
+        let hadDragState = tagNavDragModeActive || tagNavDragItem != nil
+        guard hadDragState else { return }
         if tagNavDragModeActive && tagNavReorderDidMove {
             TagEditor.reorderTags(draggedTagNames)
         }
         tagNavDragModeActive = false
         tagNavDragItem = nil
         tagNavReorderDidMove = false
-        tagNavDragResetToken &+= 1
     }
 
     private func cancelTagNavReorderVisualState() {
@@ -2439,49 +2040,28 @@
         tagNavDragModeActive = false
         tagNavDragItem = nil
         tagNavReorderDidMove = false
-        tagNavDragResetToken &+= 1
     }
 
     private func reorderTagNavItem(at location: CGPoint) {
         guard let fromName = tagNavDragItem,
               let targetName = tagNavReorderFrames.first(where: { $0.value.contains(location) })?.key,
-              fromName != targetName,
+              fromName != targetName
+        else { return }
+        reorderTagNavItem(fromName: fromName, to: targetName)
+    }
+
+    private func reorderTagNavItem(fromName: String, to targetName: String) {
+        guard fromName != targetName,
+              canReorderTag(fromName),
+              canReorderTag(targetName),
               let fromIndex = draggedTagNames.firstIndex(of: fromName),
               let toIndex = draggedTagNames.firstIndex(of: targetName)
         else { return }
-
         tagNavReorderDidMove = true
         withAnimation(.spring(response: 0.22, dampingFraction: 0.82)) {
             let destination = toIndex > fromIndex ? toIndex + 1 : toIndex
             draggedTagNames.move(fromOffsets: IndexSet(integer: fromIndex), toOffset: destination)
         }
-    }
-
-    private func handleAppDrop(_ providers: [NSItemProvider], targetTag: String) -> Bool {
-        guard let provider = providers.first(where: { $0.hasItemConformingToTypeIdentifier(UTType.plainText.identifier) }) else {
-            return false
-        }
-        provider.loadItem(forTypeIdentifier: UTType.plainText.identifier, options: nil) { item, _ in
-            let text: String?
-            if let data = item as? Data {
-                text = String(data: data, encoding: .utf8)
-            } else if let string = item as? String {
-                text = string
-            } else if let string = item as? NSString {
-                text = string as String
-            } else {
-                text = nil
-            }
-            guard let text else { return }
-            let parts = text.components(separatedBy: "\n")
-            guard let path = parts.first, !path.isEmpty else { return }
-            let source = parts.dropFirst().first ?? ""
-            let copy = NSEvent.modifierFlags.contains(.option)
-            DispatchQueue.main.async {
-                dropApp(path: path, sourceTag: source, targetTag: targetTag, copy: copy)
-            }
-        }
-        return true
     }
 
     private func dropApp(path: String, sourceTag: String, targetTag: String, copy: Bool) {
@@ -2510,20 +2090,77 @@
         refreshApps(forceLayoutRefresh: true)
     }
 
-    private func confirmAndMoveAppToUncategorized(path: String) {
+    private func dropAppOnTagNavigation(path: String, sourceTag: String, targetTag: String, copy: Bool) {
+        resetTransientDragState()
+        guard canAssignDroppedAppToTag(targetTag) else { return }
         guard let app = allApps.first(where: { $0.path.path == path }) else { return }
-        let assignedTags = assignedRegularDisplayTags(for: app)
-        guard !assignedTags.isEmpty else { return }
+        guard !appHasTag(app, tagName: targetTag) else { return }
+        TagEditor.appendTags([targetTag], to: [path])
+        showDropRefresh()
+        refreshApps(forceLayoutRefresh: true)
+    }
+
+    private func canAssignDroppedAppToTag(_ tagName: String) -> Bool {
+        tagColors[tagName] != nil
+            && !isAppleBuiltInDropTarget(tagName)
+            && !isUncategorizedDropTarget(tagName)
+    }
+
+    private func dropAppOutsideGroup(path: String, sourceTag: String, copy: Bool) {
+        resetTransientDragState(keepingPendingTagRemovalDrop: true)
+        guard isRemovableRegularTag(sourceTag) else { return }
+        guard let app = allApps.first(where: { $0.path.path == path }),
+              appHasTag(app, tagName: sourceTag)
+        else { return }
+
+        if skipTagRemovalDropConfirm {
+            removeTagFromDroppedApp(app: app, tagName: sourceTag)
+            return
+        }
 
         clearAppBubbleState()
+        appGridInteraction.tagRemovalDropSuppressFuturePrompt = false
         withAnimation(.spring(response: 0.24, dampingFraction: 0.84)) {
-            pendingUncategorizedDrop = PendingUncategorizedDrop(app: app, assignedTags: assignedTags)
+            appGridInteraction.pendingTagRemovalDrop = PendingTagRemovalDrop(app: app, tagName: sourceTag)
         }
     }
 
-    private func assignedRegularDisplayTags(for app: AppInfo) -> [String] {
+    private func confirmAndMoveAppToUncategorized(path: String) {
+        guard let app = allApps.first(where: { $0.path.path == path }) else { return }
+        let removableTags = removableRegularTags(for: app)
+        guard !removableTags.isEmpty else { return }
+        let assignedTags = assignedRegularDisplayTags(for: removableTags)
+
+        if skipUncategorizedDropConfirm {
+            moveDroppedAppToUncategorized(path: app.path.path, tags: removableTags)
+            return
+        }
+
+        clearAppBubbleState()
+        appGridInteraction.uncategorizedDropSuppressFuturePrompt = false
+        withAnimation(.spring(response: 0.24, dampingFraction: 0.84)) {
+            appGridInteraction.pendingUncategorizedDrop = PendingUncategorizedDrop(
+                app: app,
+                assignedTags: assignedTags,
+                removableTags: removableTags
+            )
+        }
+    }
+
+    private func removableRegularTags(for app: AppInfo) -> [String] {
         var result: [String] = []
         for tag in app.tags {
+            guard isRemovableRegularTag(tag) else { continue }
+            if !result.contains(tag) {
+                result.append(tag)
+            }
+        }
+        return result
+    }
+
+    private func assignedRegularDisplayTags(for tags: [String]) -> [String] {
+        var result: [String] = []
+        for tag in tags {
             let name = displayTagName(tag)
             if !result.contains(name) {
                 result.append(name)
@@ -2536,29 +2173,83 @@
         formattedFeedbackMessage(
             forKey: "drop.uncategorizedConfirmMessage",
             replacements: [
-                "%appName%": pendingDrop.app.name,
+                "%appName%": pendingDrop.app.displayName,
                 "%tagCount%": "\(pendingDrop.assignedTags.count)",
                 "%tagNames%": pendingDrop.assignedTags.joined(separator: localizedListSeparator)
             ]
         )
     }
 
+    private func tagRemovalConfirmMessage(for pendingDrop: PendingTagRemovalDrop) -> String {
+        formattedFeedbackMessage(
+            forKey: "drop.removeTagConfirmMessage",
+            replacements: [
+                "%appName%": pendingDrop.app.displayName,
+                "%tagName%": displayTagName(pendingDrop.tagName)
+            ]
+        )
+    }
+
     private func dismissUncategorizedDropConfirm() {
+        appGridInteraction.uncategorizedDropSuppressFuturePrompt = false
         resetTransientDragState(keepingPendingUncategorizedDrop: true)
         withAnimation(.easeOut(duration: 0.18)) {
-            pendingUncategorizedDrop = nil
+            appGridInteraction.pendingUncategorizedDrop = nil
         }
     }
 
     private func confirmPendingUncategorizedDrop() {
-        guard let pendingDrop = pendingUncategorizedDrop else { return }
+        guard let pendingDrop = appGridInteraction.pendingUncategorizedDrop else { return }
         let path = pendingDrop.app.path.path
-        let tags = pendingDrop.app.tags
+        let tags = pendingDrop.removableTags
+        let shouldSuppressFuturePrompt = appGridInteraction.uncategorizedDropSuppressFuturePrompt
+        if shouldSuppressFuturePrompt {
+            skipUncategorizedDropConfirm = true
+        }
+        appGridInteraction.uncategorizedDropSuppressFuturePrompt = false
         resetTransientDragState(keepingPendingUncategorizedDrop: true)
         withAnimation(.easeOut(duration: 0.16)) {
-            pendingUncategorizedDrop = nil
+            appGridInteraction.pendingUncategorizedDrop = nil
         }
+        moveDroppedAppToUncategorized(path: path, tags: tags)
+    }
+
+    private func moveDroppedAppToUncategorized(path: String, tags: [String]) {
+        guard !tags.isEmpty else { return }
         TagEditor.removeTags(tags, from: [path])
+        showDropRefresh()
+        refreshApps(forceLayoutRefresh: true)
+    }
+
+    private func dismissTagRemovalDropConfirm() {
+        appGridInteraction.tagRemovalDropSuppressFuturePrompt = false
+        withAnimation(.easeOut(duration: 0.18)) {
+            appGridInteraction.pendingTagRemovalDrop = nil
+        }
+    }
+
+    private func confirmPendingTagRemovalDrop() {
+        guard let pendingDrop = appGridInteraction.pendingTagRemovalDrop else { return }
+        let app = pendingDrop.app
+        let tagName = pendingDrop.tagName
+        let shouldSuppressFuturePrompt = appGridInteraction.tagRemovalDropSuppressFuturePrompt
+        if shouldSuppressFuturePrompt {
+            skipTagRemovalDropConfirm = true
+        }
+        appGridInteraction.tagRemovalDropSuppressFuturePrompt = false
+        withAnimation(.easeOut(duration: 0.16)) {
+            appGridInteraction.pendingTagRemovalDrop = nil
+        }
+        DispatchQueue.main.async {
+            removeTagFromDroppedApp(app: app, tagName: tagName)
+        }
+    }
+
+    private func removeTagFromDroppedApp(app: AppInfo, tagName: String) {
+        guard isRemovableRegularTag(tagName),
+              appHasTag(app, tagName: tagName)
+        else { return }
+        TagEditor.removeTags([tagName], from: [app.path.path])
         showDropRefresh()
         refreshApps(forceLayoutRefresh: true)
     }
@@ -2579,66 +2270,102 @@
         return defaultNames.contains(targetTag)
     }
 
+    private func isRemovableRegularTag(_ tag: String) -> Bool {
+        let protectedNames = [
+            "Mac自带",
+            tr("group.appleBuiltIn"),
+            defaultGroupName,
+            tr("group.uncategorized"),
+            TagDatabase.uncommonTagKey,
+            tr("group.uncommon")
+        ]
+        return !protectedNames.contains(tag) && tagColors[tag] != nil
+    }
+
     private func showDropWarning() {
         withAnimation(.spring(response: 0.24, dampingFraction: 0.82)) {
-            dropWarningToast = tr("drop.systemDefaultWarning")
+            appGridInteraction.dropWarningToast = tr("drop.systemDefaultWarning")
         }
         DispatchQueue.main.asyncAfter(deadline: .now() + 1.6) {
             withAnimation(.easeOut(duration: 0.18)) {
-                dropWarningToast = nil
+                appGridInteraction.dropWarningToast = nil
             }
         }
     }
 
     private func showDropRefresh() {
-        dropRefreshStartedAt = Date()
+        appGridInteraction.dropRefreshStartedAt = Date()
         withAnimation(.spring(response: 0.22, dampingFraction: 0.82)) {
-            dropRefreshVisible = true
+            appGridInteraction.dropRefreshVisible = true
         }
     }
 
     private func finishDropRefreshAfterMinimumDuration() {
         let minimumDuration: TimeInterval = 0.85
-        let elapsed = dropRefreshStartedAt.map { Date().timeIntervalSince($0) } ?? minimumDuration
+        let elapsed = appGridInteraction.dropRefreshStartedAt.map { Date().timeIntervalSince($0) } ?? minimumDuration
         let delay = max(0, minimumDuration - elapsed)
         DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
             withAnimation(.easeOut(duration: 0.18)) {
-                dropRefreshVisible = false
+                appGridInteraction.dropRefreshVisible = false
             }
-            dropRefreshStartedAt = nil
+            appGridInteraction.dropRefreshStartedAt = nil
         }
     }
 
     private func setAppDragMode(_ active: Bool) {
+        guard appGridInteraction.appDragModeActive != active else { return }
         if active {
             endTagNavReorder()
             clearAppBubbleState()
+            appGridInteraction.tagNavigationAppDropTargetName = nil
         }
-        appDragModeActive = active
+        appGridInteraction.appDragModeActive = active
+        if !active {
+            appGridInteraction.tagNavigationAppDropTargetName = nil
+        }
         if active {
             DispatchQueue.main.asyncAfter(deadline: .now() + 8) {
-                if appDragModeActive {
-                    appDragModeActive = false
+                if appGridInteraction.appDragModeActive && !AppDragCoordinator.shared.hasActiveDrag {
+                    appGridInteraction.appDragModeActive = false
+                    appGridInteraction.tagNavigationAppDropTargetName = nil
                 }
             }
         }
     }
 
-    private func resetTransientDragState(keepingPendingUncategorizedDrop: Bool = false) {
+    private func resetTransientDragState(
+        keepingPendingUncategorizedDrop: Bool = false,
+        keepingPendingTagRemovalDrop: Bool = false
+    ) {
+        let hadAppDragState = appGridInteraction.appDragModeActive
         AppDragCoordinator.shared.cancelDrag()
-        scrollInteractionState.reset()
-        appDragModeActive = false
-        appDragResetToken &+= 1
-        tagNavDragModeActive = false
-        tagNavDragItem = nil
-        tagNavReorderDidMove = false
-        tagNavDragResetToken &+= 1
-        dragItem = nil
-        hoveredAppItemID = nil
-        hoveredContainer = nil
+        if appGridInteraction.appDragModeActive {
+            appGridInteraction.appDragModeActive = false
+        }
+        if appGridInteraction.tagNavigationAppDropTargetName != nil {
+            appGridInteraction.tagNavigationAppDropTargetName = nil
+        }
+        if hadAppDragState {
+            appGridInteraction.appDragResetToken &+= 1
+        }
+        if tagNavDragModeActive {
+            tagNavDragModeActive = false
+        }
+        if tagNavDragItem != nil {
+            tagNavDragItem = nil
+        }
+        if tagNavReorderDidMove {
+            tagNavReorderDidMove = false
+        }
+        if dragItem != nil {
+            dragItem = nil
+        }
         clearAppBubbleState()
-        if !keepingPendingUncategorizedDrop {
-            pendingUncategorizedDrop = nil
+        if !keepingPendingUncategorizedDrop, appGridInteraction.pendingUncategorizedDrop != nil {
+            appGridInteraction.pendingUncategorizedDrop = nil
+        }
+        if !keepingPendingTagRemovalDrop, appGridInteraction.pendingTagRemovalDrop != nil {
+            appGridInteraction.pendingTagRemovalDrop = nil
         }
     }
 
@@ -2653,27 +2380,10 @@
 
         refreshInProgress = true
         DispatchQueue.global(qos: .userInitiated).async {
-            let scannedApps = AppIndexer.scan()
-            let reconciledStore = TagEditor.reconcileScannedApps(scannedApps)
-            let smartStartResult = SmartStartService.runIfNeeded(
-                apps: scannedApps,
-                store: reconciledStore
-            )
-            let store = smartStartResult.store
-            let apps = TagEditor.annotate(apps: scannedApps, store: store)
-            let quickSearchDocs = QuickSearchEngine.makeDocuments(apps: apps, store: store)
-            let colors = store.tags.mapValues { $0.color }
-            let order = TagEditor.orderedTagNames()
+            let result = AppLibraryController.refresh()
             DispatchQueue.main.async {
-                allApps = apps
-                quickSearchDocuments = quickSearchDocs
-                tagColors = colors
-                draggedTagNames = order
-                rebuildDisplayGroups(apps: apps, tagOrder: order)
-                if quickSearchVisible {
-                    refreshQuickSearchResults()
-                }
-                handleSmartStartRunResult(smartStartResult)
+                applyAppLibrarySnapshot(result.snapshot)
+                handleSmartStartRunResult(result.smartStartResult)
                 if forceLayoutRefresh {
                     finishDropRefreshAfterMinimumDuration()
                 }
@@ -2688,14 +2398,32 @@
         }
     }
 
+    private func applyAppLibrarySnapshot(_ snapshot: AppLibrarySnapshot) {
+        allApps = snapshot.apps
+        quickSearchDocuments = snapshot.quickSearchDocuments
+        tagColors = snapshot.tagColors
+        draggedTagNames = snapshot.tagOrder
+        rebuildDisplayGroups(apps: snapshot.apps, tagOrder: snapshot.tagOrder)
+        if quickSearchVisible {
+            refreshQuickSearchResults()
+        }
+    }
+
     private func launchApp(
         _ app: AppInfo,
         closeQuickSearchOnSuccess: Bool = false,
         closeOverlayOnSuccess: Bool = true,
         onFailure: (() -> Void)? = nil
     ) {
-        appDragModeActive = false
+        appGridInteraction.appDragModeActive = false
         endTagNavReorder()
+        let closeQuickSearchAndOverlayBeforeOpening = closeQuickSearchOnSuccess
+            && closeOverlayOnSuccess
+            && (quickSearchCloseHidesOverlay || quickSearchOnlySession)
+        if closeQuickSearchAndOverlayBeforeOpening {
+            closeQuickSearch(hideOverlayIfNeeded: true)
+            hideOverlay()
+        }
         let configuration = NSWorkspace.OpenConfiguration()
         NSWorkspace.shared.openApplication(at: app.path, configuration: configuration) { _, error in
             DispatchQueue.main.async {
@@ -2707,10 +2435,10 @@
                 DispatchQueue.global(qos: .utility).async {
                     TagEditor.recordLauncherOpen(for: app.path.path)
                 }
-                if closeQuickSearchOnSuccess {
-                    closeQuickSearch(hideOverlayIfNeeded: false)
+                if closeQuickSearchOnSuccess && !closeQuickSearchAndOverlayBeforeOpening {
+                    closeQuickSearch(hideOverlayIfNeeded: closeOverlayOnSuccess)
                 }
-                if closeOverlayOnSuccess {
+                if closeOverlayOnSuccess && !closeQuickSearchAndOverlayBeforeOpening {
                     hideOverlay()
                 }
             }
@@ -2718,108 +2446,8 @@
     }
 
     func openApp(_ app: AppInfo) {
-        launchApp(app)
-    }
-}
-
-private final class AppGridScrollInteractionState: ObservableObject {
-    @Published var isFrozen = false
-    private var unfreezeWorkItem: DispatchWorkItem?
-
-    func noteScroll() {
-        if !isFrozen {
-            isFrozen = true
-        }
-        unfreezeWorkItem?.cancel()
-        let workItem = DispatchWorkItem { [weak self] in
-            self?.isFrozen = false
-        }
-        unfreezeWorkItem = workItem
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.18, execute: workItem)
-    }
-
-    func reset() {
-        unfreezeWorkItem?.cancel()
-        unfreezeWorkItem = nil
-        isFrozen = false
-    }
-}
-
-private struct AppGridScrollActivityObserver: NSViewRepresentable {
-    let onScroll: () -> Void
-
-    func makeCoordinator() -> Coordinator {
-        Coordinator(onScroll: onScroll)
-    }
-
-    func makeNSView(context: Context) -> ScrollActivityNSView {
-        let view = ScrollActivityNSView()
-        view.coordinator = context.coordinator
-        return view
-    }
-
-    func updateNSView(_ view: ScrollActivityNSView, context: Context) {
-        context.coordinator.onScroll = onScroll
-        view.coordinator = context.coordinator
-        view.installObserverIfPossible()
-    }
-
-    final class Coordinator {
-        var onScroll: () -> Void
-        private weak var observedClipView: NSClipView?
-        private var observer: NSObjectProtocol?
-
-        init(onScroll: @escaping () -> Void) {
-            self.onScroll = onScroll
-        }
-
-        func install(from view: NSView) {
-            guard let clipView = view.enclosingScrollView?.contentView else { return }
-            guard observedClipView !== clipView else { return }
-            removeObserver()
-            observedClipView = clipView
-            clipView.postsBoundsChangedNotifications = true
-            observer = NotificationCenter.default.addObserver(
-                forName: NSView.boundsDidChangeNotification,
-                object: clipView,
-                queue: .main
-            ) { [weak self] _ in
-                self?.onScroll()
-            }
-        }
-
-        private func removeObserver() {
-            if let observer {
-                NotificationCenter.default.removeObserver(observer)
-            }
-            observer = nil
-            observedClipView = nil
-        }
-
-        deinit {
-            removeObserver()
-        }
-    }
-
-    final class ScrollActivityNSView: NSView {
-        weak var coordinator: Coordinator?
-
-        override func viewDidMoveToWindow() {
-            super.viewDidMoveToWindow()
-            installObserverIfPossible()
-        }
-
-        override func viewDidMoveToSuperview() {
-            super.viewDidMoveToSuperview()
-            installObserverIfPossible()
-        }
-
-        func installObserverIfPossible() {
-            DispatchQueue.main.async { [weak self] in
-                guard let self else { return }
-                coordinator?.install(from: self)
-            }
-        }
+        hideOverlay()
+        launchApp(app, closeOverlayOnSuccess: false)
     }
 }
 
@@ -2839,12 +2467,6 @@
     static func reduce(value: inout [String: CGRect], nextValue: () -> [String: CGRect]) {
         value.merge(nextValue(), uniquingKeysWith: { _, new in new })
     }
-}
-
-private struct TagLabel: Identifiable {
-    var id: String { name }
-    let name: String
-    let colorIndex: Int
 }
 
 // MARK: - NSVisualEffectView bridge

--
Gitblit v1.9.3