crazy-macs/tag-launcher.git

			@@ -4,8 +4,7 @@
			// MARK: - Notification for manual re-index

			extension Notification.Name {
			static let apptagReindex = Notification.Name("ApptagReindex")
			static let apptagEditModeChanged = Notification.Name("ApptagEditModeChanged")
			static let tagLauncherEditModeChanged = Notification.Name("TagLauncherEditModeChanged")
			}

			// MARK: - Edit Phase
			@@ -204,6 +203,9 @@
			@State private var successToast: String? = nil
			@State private var draggedTagNames: [String] = [] // live drag order
			@State private var dragItem: String? = nil // currently dragged tag
			@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

			// Configurable defaults
			@AppStorage("defaultGroupName") private var defaultGroupName = "Other"
			@@ -212,9 +214,18 @@
			@AppStorage("tagPosition") private var tagPosition = "left"
			@State private var notchHeight: CGFloat = 0
			@AppStorage("displayMode") private var displayMode = "flat"
			@AppStorage("hideAppNames") private var hideAppNames = false

			private var isSideLayout: Bool {
			tagPosition == "left" \|\| tagPosition == "right"
			}

			private var isColorlessContainerMode: Bool {
			displayMode == "container" \|\| displayMode == "gridContainer"
			}

			private var isColoredContainerMode: Bool {
			displayMode == "coloredContainer" \|\| displayMode == "coloredGridContainer"
			}

			var body: some View {
			@@ -253,13 +264,10 @@
			.onReceive(NotificationCenter.default.publisher(for: NSApplication.didBecomeActiveNotification)) { _ in
			refreshApps()
			}
			.onReceive(NotificationCenter.default.publisher(for: .apptagReindex)) { _ in
			refreshApps()
			}
			.onChange(of: editPhase) { _, newPhase in
			let active = newPhase != .none
			NotificationCenter.default.post(
			name: .apptagEditModeChanged,
			name: .tagLauncherEditModeChanged,
			object: nil,
			userInfo: ["active": active]
			)
			@@ -269,17 +277,17 @@
			/// Set edit phase with synchronous notification BEFORE state change.
			func setEditPhase(_ phase: EditPhase) {
			if phase != .none {
			NotificationCenter.default.post(name: .apptagEditModeChanged, object: nil, userInfo: ["active": true])
			NotificationCenter.default.post(name: .tagLauncherEditModeChanged, object: nil, userInfo: ["active": true])
			NSApp.activate(ignoringOtherApps: true)
			// Sync drag order from database when entering edit mode
			if draggedTagNames.isEmpty {
			draggedTagNames = TagEditor.orderedTagNames()
			}
			// Always sync tag list from database when entering edit mode
			let store = TagDatabase.load()
			tagColors = store.tags.mapValues { $0.color }
			draggedTagNames = TagEditor.orderedTagNames()
			}
			editPhase = phase
			if phase == .none {
			DispatchQueue.main.async {
			NotificationCenter.default.post(name: .apptagEditModeChanged, object: nil, userInfo: ["active": false])
			NotificationCenter.default.post(name: .tagLauncherEditModeChanged, object: nil, userInfo: ["active": false])
			}
			}
			}
			@@ -338,7 +346,18 @@
			HStack(spacing: 8) {
			ForEach(tagLabels) { tag in
			TagPill(name: tag.name, colorIndex: tag.colorIndex,
			action: { scrollTo(tag.id) })
			action: {
			if isColorlessContainerMode {
			toggleColorlessFill(tag.id)
			}
			scrollTo(tag.id)
			})
			.onHover { hovering in
			if hovering {
			fillColorlessContainer(tag.id)
			scrollTo(tag.id)
			}
			}
			}
			}.padding(.horizontal, 24)
			}
			@@ -349,7 +368,18 @@
			VStack(spacing: 6) {
			ForEach(tagLabels) { tag in
			SideTagPill(name: tag.name, colorIndex: tag.colorIndex,
			action: { scrollTo(tag.id) })
			action: {
			if isColorlessContainerMode {
			toggleColorlessFill(tag.id)
			}
			scrollTo(tag.id)
			})
			.onHover { hovering in
			if hovering {
			fillColorlessContainer(tag.id)
			scrollTo(tag.id)
			}
			}
			}
			}.padding(12)
			}.frame(width: 135)
			@@ -365,7 +395,9 @@
			Spacer()
			ProgressView().scaleEffect(0.8)
			Spacer()
			} else if displayMode == "container" {
			} else if displayMode == "gridContainer" \|\| displayMode == "coloredGridContainer" {
			gridContainerGrid
			} else if displayMode == "container" \|\| displayMode == "coloredContainer" {
			containerGrid
			} else {
			flatGrid
			@@ -382,59 +414,376 @@
			group: group,
			onSelectApp: { app in openApp(app) },
			tagFontSize: tagFontSize,
			iconSize: iconSize
			iconSize: iconSize,
			showNames: !hideAppNames
			).id(group.id)
			}
			}.padding(20)
			}.onAppear { scrollProxy = proxy }
			}
			.id(displayMode) // force rebuild on mode switch
			.onAppear { scrollProxy = proxy }
			}
			}

			private var containerGrid: some View {
			GeometryReader { geo in
			let availableWidth = geo.size.width - 40 // padding
			let spacing: CGFloat = 16
			let containerMin: CGFloat = 320
			let colCount = max(1, Int((availableWidth + spacing) / (containerMin + spacing)))
			let cols = Array(repeating: GridItem(.flexible(), spacing: spacing), count: colCount)
			ScrollView {
			LazyVGrid(columns: cols, alignment: .leading, spacing: spacing) {
			ForEach(groups) { group in
			VStack(alignment: .leading, spacing: 6) {
			// Group header
			HStack(spacing: 0) {
			Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
			Text(group.name)
			.font(.system(size: tagFontSize, weight: .semibold))
			.foregroundStyle(.secondary)
			.padding(.horizontal, 10)
			Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
			}
			// App grid — adaptive inside the container
			let itemSize = iconSize + 28
			LazyVGrid(
			columns: [GridItem(.adaptive(minimum: itemSize, maximum: itemSize + 36), spacing: 6)],
			spacing: 2
			) {
			ForEach(group.apps) { app in
			AppGridItem(app: app, iconSize: iconSize, onSelect: { openApp(app) })
			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: groups, 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)
			}
			}
			}
			.id(group.id)
			.padding(16)
			.background(
			RoundedRectangle(cornerRadius: 14)
			.fill(.ultraThinMaterial)
			)
			.overlay(
			RoundedRectangle(cornerRadius: 14)
			.stroke(Color.primary.opacity(0.08), lineWidth: 1)
			)
			}
			.padding(outerPad)
			}
			.padding(20)
			.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 = iconSize + 28 + 6
			let perRow = max(1, Int(inner / itemW))
			let rows = (group.apps.count + perRow - 1) / perRow
			return 32 + CGFloat(rows) * (iconSize + 30)
			}

			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 = iconSize + 28
			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, 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)
			)
			.shadow(color: .black.opacity((isColored && isHovered) \|\| isColorlessActive ? 0.22 : 0),
			radius: (isColored && isHovered) \|\| isColorlessActive ? 18 : 0,
			y: (isColored && isHovered) \|\| isColorlessActive ? 10 : 0)
			.scaleEffect(isColored && isHovered ? 1.015 : 1.0)
			.animation(.spring(response: 0.25, dampingFraction: 0.82), value: isHovered)
			.animation(.spring(response: 0.25, dampingFraction: 0.82), value: isColorlessFilled)
			.onHover { hovering in
			if isColored \|\| isColorless {
			hoveredContainer = hovering ? group.name : nil
			}
			}
			.contentShape(RoundedRectangle(cornerRadius: 14))
			.onTapGesture {
			if isColorless {
			toggleColorlessFill(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 rows = gridContainerRows(groups: groups, trackCount: preferredCount, availableWidth: available, gap: gap)

			ScrollViewReader { proxy in
			ScrollView {
			VStack(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)
			}
			.id(displayMode)
			.onAppear { scrollProxy = proxy }
			}
			}
			}

			private func preferredGridContainersPerRow(availableWidth: CGFloat) -> Int {
			let minCardWidth = max(260, iconSize * 3 + 88)
			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 GridContainerCandidate {
			let spans: [Int]
			let rows: Int
			let cost: CGFloat
			}

			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 = iconSize + 34
			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, 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)
			)
			.shadow(color: .black.opacity((isColored && isHovered) \|\| isColorlessGridActive ? 0.22 : 0),
			radius: (isColored && isHovered) \|\| isColorlessGridActive ? 18 : 0,
			y: (isColored && isHovered) \|\| isColorlessGridActive ? 10 : 0)
			.scaleEffect(isColored && isHovered ? 1.015 : 1.0)
			.animation(.spring(response: 0.25, dampingFraction: 0.82), value: isHovered)
			.animation(.spring(response: 0.25, dampingFraction: 0.82), value: isColorlessFilled)
			.onHover { hovering in
			if isColored \|\| isColorlessGrid {
			hoveredContainer = hovering ? group.name : nil
			} else if hovering {
			fillColorlessContainer(group.name)
			}
			}
			.contentShape(RoundedRectangle(cornerRadius: 14))
			.onTapGesture {
			if isColorlessGrid {
			toggleColorlessFill(group.name)
			}
			}
			}

			private func iconCellHeight() -> CGFloat {
			iconSize + (hideAppNames ? 16 : 42)
			}

			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])
			}
			}

			@@ -446,12 +795,12 @@
			Button {
			setEditPhase(.none)
			} label: {
			Label("Exit editing", systemImage: "rectangle.portrait.and.arrow.right")
			Label(tr("edit.exit"), systemImage: "rectangle.portrait.and.arrow.right")
			.font(.system(size: 12))
			}
			.buttonStyle(.bordered)
			Spacer()
			Text("Edit Tags").font(.headline)
			Text(tr("edit.tags")).font(.headline)
			Spacer()
			}
			.padding(.horizontal, 24)
			@@ -474,14 +823,14 @@
			VStack(spacing: 0) {
			HStack {
			Button { cancelEditApps(); setEditPhase(.none) } label: {
			Label("Exit editing", systemImage: "rectangle.portrait.and.arrow.right")
			Label(tr("edit.exit"), systemImage: "rectangle.portrait.and.arrow.right")
			.font(.system(size: 12))
			}
			.buttonStyle(.bordered)
			Spacer()
			Text("Edit App Categories").font(.headline)
			Text(tr("edit.title")).font(.headline)
			Spacer()
			Button("Confirm") { confirmAssign() }
			Button(tr("edit.confirm")) { confirmAssign() }
			.buttonStyle(.borderedProminent)
			.disabled(selectedAppPaths.isEmpty \|\| selectedTagNames.isEmpty)
			}
			@@ -493,8 +842,8 @@

			HStack(spacing: 0) {
			VStack(alignment: .leading, spacing: 4) {
			Text("Select tags:").font(.caption).foregroundStyle(.secondary).padding(.bottom, 4)
			Text("Drag to reorder").font(.caption2).foregroundStyle(.tertiary).padding(.bottom, 2)
			Text(tr("edit.selectTags")).font(.caption).foregroundStyle(.secondary).padding(.bottom, 4)
			Text(tr("edit.dragHint")).font(.caption2).foregroundStyle(.tertiary).padding(.bottom, 2)
			ScrollView(.vertical, showsIndicators: false) {
			VStack(spacing: 4) {
			ForEach(sortedTagNames, id: \.self) { tagName in
			@@ -526,23 +875,7 @@
			if allApps.isEmpty {
			Spacer(); ProgressView().scaleEffect(0.8); Spacer()
			} else {
			ScrollView {
			LazyVStack(alignment: .leading, spacing: 24) {
			ForEach(groups) { group in
			VStack(alignment: .leading, spacing: 6) {
			HStack(spacing: 0) {
			Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
			Text(group.name).font(.system(size: tagFontSize, weight: .semibold))
			.foregroundStyle(.secondary).padding(.horizontal, 10)
			Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
			}
			LazyVGrid(columns: [GridItem(.adaptive(minimum: iconSize + 28, maximum: iconSize + 64), spacing: 6)], spacing: 2) {
			ForEach(group.apps) { app in editableAppItem(app) }
			}
			}
			}
			}.padding(20)
			}
			editAppsGrid
			}
			}

			@@ -556,6 +889,38 @@
			withAnimation { successToast = nil }
			}
			}
			}
			}
			}

			private var editAppsGrid: some View {
			ScrollView {
			LazyVStack(alignment: .leading, spacing: 24) {
			ForEach(groups) { group in
			editFlatGroup(group)
			}
			}
			.padding(20)
			}
			}

			private func editFlatGroup(_ group: TagGroup) -> some View {
			VStack(alignment: .leading, spacing: 0) {
			HStack(spacing: 0) {
			Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
			Text(group.name)
			.font(.system(size: tagFontSize, weight: .semibold))
			.foregroundStyle(.secondary)
			.padding(.horizontal, 10)
			Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
			}
			.padding(.bottom, 6)

			LazyVGrid(
			columns: [GridItem(.adaptive(minimum: iconSize + 28, maximum: iconSize + 64), spacing: 6)],
			spacing: 2
			) {
			ForEach(group.apps) { app in editableAppItem(app) }
			}
			}
			}
			@@ -587,7 +952,7 @@
			}
			selectedAppPaths = []; selectedTagNames = []
			refreshApps()
			withAnimation { successToast = "分类成功" }
			withAnimation { successToast = tr("edit.success") }
			}

			private func cancelEditApps() {
			@@ -637,7 +1002,17 @@
			let order = draggedTagNames.isEmpty
			? TagEditor.orderedTagNames()
			: draggedTagNames
			return AppIndexer.group(apps: allApps, defaultGroupName: defaultGroupName, tagOrder: order)
			let raw = AppIndexer.group(apps: allApps, defaultGroupName: defaultGroupName, tagOrder: order)
			// Translate stable keys for display
			return raw.map { group in
			if group.name == defaultGroupName {
			return TagGroup(name: tr("group.uncategorized"), apps: group.apps)
			}
			if group.name == "Mac自带" {
			return TagGroup(name: tr("group.appleBuiltIn"), apps: group.apps)
			}
			return group
			}
			}

			// MARK: - Actions
			@@ -646,11 +1021,20 @@
			withAnimation(.easeInOut(duration: 0.25)) { scrollProxy?.scrollTo(id, anchor: .top) }
			}

			private func fillColorlessContainer(_ id: String) {
			guard isColorlessContainerMode else { return }
			filledColorlessContainer = id
			}

			private func toggleColorlessFill(_ id: String) {
			guard isColorlessContainerMode else { return }
			filledColorlessContainer = (filledColorlessContainer == id) ? nil : id
			}

			func refreshApps() {
			DispatchQueue.global(qos: .userInitiated).async {
			var apps = AppIndexer.scan()
			// Ensure migration ran at least once
			let store = TagDatabase.migrateFromFinderIfNeeded(apps: apps)
			let store = TagDatabase.load()
			apps = TagEditor.annotate(apps: apps)
			let colors = store.tags.mapValues { $0.color }
			let order = TagEditor.orderedTagNames()
			@@ -664,7 +1048,18 @@

			func openApp(_ app: AppInfo) {
			hideOverlay()
			NSWorkspace.shared.open(app.path)
			if let bundleIdentifier = app.bundleIdentifier {
			NSWorkspace.shared.launchApplication(
			withBundleIdentifier: bundleIdentifier,
			options: [],
			additionalEventParamDescriptor: nil,
			launchIdentifier: nil
			)
			return
			}

			let configuration = NSWorkspace.OpenConfiguration()
			NSWorkspace.shared.openApplication(at: app.path, configuration: configuration)
			}
			}