sidebar: organize and drag workspaces (reorder, groups, glass look)

.gitignore

@@ -19,7 +19,6 @@ ios/Config/AppStoreConnect.local.plist
 .swiftpm/
 .ci-source-packages/
 .ci-reload-derived-data/
-.glaeda/
 
 # GhosttyKit binary (built from ghostty submodule via scripts/setup.sh)
 GhosttyKit.xcframework
@@ -79,6 +78,3 @@ tmux-*.log
 # Remote-only Blacksmith cmux-tui benchmark output
 /testbox-benchmark/
 /.cmux-scratch/
-
-# Locally downloaded prebuilt client for Packages/Shared/CmuxTerminalClient
-Packages/Shared/CmuxTerminalClient/CmuxTerminalClient.xcframework/

Packages/macOS/CmuxAppKitSupportUI/Sources/CmuxAppKitSupportUI/WindowChrome/Appearance/WindowAppearanceResolver.swift

@@ -32,8 +32,10 @@ public struct WindowAppearanceResolver {
                 cornerRadius: settings.sidebarCornerRadius,
                 blurOpacity: settings.sidebarBlurOpacity,
                 // The snapshot initializer replaces this compatibility value
-                // with the resolved sidebar scheme.
-                colorScheme: settings.colorScheme
+                // with the terminal authority below.
+                colorScheme: settings.colorScheme,
+                compositorGlass: settings.sidebarCompositorGlass,
+                compositorBlurRadius: settings.sidebarGlassBlurRadius
             ),
             windowGlassSettings: WindowGlassSettingsSnapshot(
                 sidebarBlendModeRawValue: settings.sidebarBlendMode,
@@ -77,18 +79,21 @@ public struct WindowAppearanceResolver {
             unifySurfaceBackdrops: defaults.object(forKey: "sidebarMatchTerminalBackground") as? Bool
                 ?? WindowChromeSidebarTintDefaults.matchesTerminalBackground,
             colorScheme: ambientScheme,
-            sidebarMaterial: defaults.string(forKey: "sidebarMaterial") ?? WindowChromeSidebarMaterialOption.sidebar.rawValue,
-            sidebarBlendMode: defaults.string(forKey: "sidebarBlendMode") ?? WindowChromeSidebarBlendModeOption.withinWindow.rawValue,
-            sidebarState: defaults.string(forKey: "sidebarState") ?? WindowChromeSidebarStateOption.followWindow.rawValue,
+            sidebarMaterial: defaults.string(forKey: "sidebarMaterial") ?? WindowChromeSidebarMaterialOption.hudWindow.rawValue,
+            sidebarBlendMode: defaults.string(forKey: "sidebarBlendMode") ?? WindowChromeSidebarBlendModeOption.behindWindow.rawValue,
+            sidebarState: defaults.string(forKey: "sidebarState") ?? WindowChromeSidebarStateOption.active.rawValue,
             sidebarTintHex: defaults.string(forKey: "sidebarTintHex") ?? tintDefaults.hex,
             sidebarTintHexLight: defaults.string(forKey: "sidebarTintHexLight"),
             sidebarTintHexDark: defaults.string(forKey: "sidebarTintHexDark"),
             sidebarTintOpacity: defaults.object(forKey: "sidebarTintOpacity") as? Double ?? tintDefaults.opacity,
             sidebarCornerRadius: defaults.object(forKey: "sidebarCornerRadius") as? Double ?? 0.0,
             sidebarBlurOpacity: defaults.object(forKey: "sidebarBlurOpacity") as? Double ?? 1.0,
-            bgGlassEnabled: defaults.object(forKey: "bgGlassEnabled") as? Bool ?? false,
+            bgGlassEnabled: defaults.object(forKey: "bgGlassEnabled") as? Bool ?? true,
             bgGlassTintHex: defaults.string(forKey: "bgGlassTintHex") ?? "#000000",
             bgGlassTintOpacity: defaults.object(forKey: "bgGlassTintOpacity") as? Double ?? 0.03,
+            sidebarCompositorGlass: defaults.object(forKey: "sidebarCompositorGlass") as? Bool ?? true,
+            sidebarGlassBlurRadius: defaults.object(forKey: "sidebarGlassBlurRadius") as? Double
+                ?? SidebarBackdropSettingsSnapshot.compositorBlurRadiusRange.lowerBound,
             reduceTransparency: reduceTransparency
         ))
     }

Packages/macOS/CmuxAppKitSupportUI/Sources/CmuxAppKitSupportUI/WindowChrome/Appearance/WindowAppearanceSnapshot.swift

@@ -81,14 +81,31 @@ public struct WindowAppearanceSnapshot {
             tintOpacity: sidebarSettings.tintOpacity,
             cornerRadius: sidebarSettings.cornerRadius,
             blurOpacity: sidebarSettings.blurOpacity,
-            colorScheme: sidebarScheme
+            colorScheme: sidebarScheme,
+            compositorGlass: sidebarSettings.compositorGlass,
+            compositorBlurRadius: sidebarSettings.compositorBlurRadius
         )
         self.windowGlassSettings = windowGlassSettings
         self.resolvedColorScheme = resolvedScheme
         self.reducesTransparency = reducesTransparency
         self.sidebarColorScheme = sidebarScheme
     }
 
+    /// Whether the window ground is clear glass blurred by the compositor.
+    ///
+    /// The workspace card paints its own opaque terminal colour, so the ground
+    /// can go clear under it. A translucent terminal already has Ghostty's own
+    /// blur path and keeps the legacy plan, and Reduce Transparency keeps the
+    /// opaque plan. This one answer drives the ground, the sidebar layer, and
+    /// the window plan, so they can never disagree.
+    public var usesCompositorGlass: Bool {
+        sidebarSettings.compositorGlass
+            && !reducesTransparency
+            && !unifySurfaceBackdrops
+            && terminalBackgroundOpacity >= 0.999
+            && !terminalBackgroundBlur.isMacOSGlassStyle
+    }
+
     /// Clamps opacity into the visible `0...1` range.
     public static func clampedOpacity(_ opacity: Double) -> CGFloat {
         CGFloat(max(0.0, min(1.0, opacity)))
@@ -249,14 +266,23 @@ public struct WindowAppearanceSnapshot {
     public func policy(for role: WindowBackdropRole) -> WindowBackdropPolicy {
         switch role {
         case .windowRoot:
+            // Clear glass ground: the compositor blurs the desktop behind the
+            // transparent window and the sidebar layer paints the tint over
+            // it; the workspace card stays the one opaque surface.
+            if usesCompositorGlass {
+                return .clear
+            }
             return terminalBackdropPolicy()
         case .terminalCanvas, .bonsplitChrome, .titlebar, .browserSurface:
             return .clear
-        case .leftSidebar, .rightSidebar:
+        case .leftSidebar:
             if unifySurfaceBackdrops {
                 return .clear
             }
             let materialPolicy = sidebarSettings.materialPolicy
+            if usesCompositorGlass {
+                return .sidebarMaterial(sidebarSettings.tintOnlyMaterialPolicy)
+            }
             guard reducesTransparency else {
                 return .sidebarMaterial(materialPolicy)
             }
@@ -266,6 +292,18 @@ public struct WindowAppearanceSnapshot {
                 ? compositedTerminalBackgroundColor
                 : Self.resolvedColor(.windowBackgroundColor, for: resolvedColorScheme)
             return .sidebarMaterial(materialPolicy.opaque(over: baseColor))
+        case .rightSidebar:
+            if unifySurfaceBackdrops {
+                return .clear
+            }
+            // The tools sidebar (files, find, vault) is a work surface, not
+            // chrome: it always sits on a solid terminal-coloured ground and
+            // never follows the workspace sidebar's glass.
+            return .ghosttyTerminalBackdrop(
+                color: terminalBackgroundColor,
+                opacity: 1.0,
+                renderingMode: terminalRenderingMode
+            )
         }
     }
 
@@ -312,6 +350,17 @@ public struct WindowAppearanceSnapshot {
         if reducesTransparency {
             return opaqueWindowFillPlan(rootPolicy: rootPolicy)
         }
+        if usesCompositorGlass {
+            return WindowBackdropPlan(
+                hostingPhase: .transparentRootBackdrop,
+                windowBackgroundColor: windowBackgroundPolicy.transparentWindowBaseColor,
+                windowIsOpaque: false,
+                rootPolicy: .clear,
+                glass: nil,
+                shouldApplyGhosttyCompositorBlur: false,
+                compositorBlurRadius: sidebarSettings.effectiveCompositorBlurRadius
+            )
+        }
         if windowGlassSettings.shouldApply(
             glassEffectAvailable: glassEffectAvailable,
             windowBackgroundPolicy: windowBackgroundPolicy

Packages/macOS/CmuxAppKitSupportUI/Sources/CmuxAppKitSupportUI/WindowChrome/Appearance/WindowAppearanceUserSettingsSnapshot.swift

@@ -46,6 +46,11 @@ public struct WindowAppearanceUserSettingsSnapshot {
     /// Background glass tint opacity.
     public let bgGlassTintOpacity: Double
 
+    /// Whether the sidebar glass uses the compositor blur path.
+    public let sidebarCompositorGlass: Bool
+
+    /// Sidebar compositor blur radius in points.
+    public let sidebarGlassBlurRadius: Double
     /// The macOS Reduce Transparency setting.
     public let reduceTransparency: Bool
 
@@ -65,8 +70,12 @@ public struct WindowAppearanceUserSettingsSnapshot {
         bgGlassEnabled: Bool,
         bgGlassTintHex: String,
         bgGlassTintOpacity: Double,
+        sidebarCompositorGlass: Bool = false,
+        sidebarGlassBlurRadius: Double = SidebarBackdropSettingsSnapshot.compositorBlurRadiusRange.lowerBound,
         reduceTransparency: Bool = false
     ) {
+        self.sidebarCompositorGlass = sidebarCompositorGlass
+        self.sidebarGlassBlurRadius = sidebarGlassBlurRadius
         self.unifySurfaceBackdrops = unifySurfaceBackdrops
         self.colorScheme = colorScheme
         self.sidebarMaterial = sidebarMaterial

Packages/macOS/CmuxAppKitSupportUI/Sources/CmuxAppKitSupportUI/WindowChrome/Backdrop/WindowBackdropController.swift

@@ -43,7 +43,9 @@ public final class WindowBackdropController {
             didChangeGlassRoot = dependencies.glassEffect.remove(from: window)
             window.backgroundColor = plan.windowBackgroundColor
             window.isOpaque = false
-            if plan.shouldApplyGhosttyCompositorBlur {
+            if let radius = plan.compositorBlurRadius {
+                dependencies.setCompositorBackgroundBlur(windowNumber: window.windowNumber, radius: radius)
+            } else if plan.shouldApplyGhosttyCompositorBlur {
                 dependencies.applyGhosttyCompositorBlurIfNeeded(to: window)
             } else {
                 dependencies.resetCompositorBackgroundBlur(windowNumber: window.windowNumber)

Packages/macOS/CmuxAppKitSupportUI/Sources/CmuxAppKitSupportUI/WindowChrome/Backdrop/WindowBackdropControllerDependencies.swift

@@ -9,6 +9,9 @@ public protocol WindowBackdropControllerDependencies: AnyObject {
     /// Resets compositor blur for a window number.
     func resetCompositorBackgroundBlur(windowNumber: Int)
 
+    /// Sets the compositor blur radius, in points, for a window number.
+    func setCompositorBackgroundBlur(windowNumber: Int, radius: Int)
+
     /// Applies Ghostty's compositor blur to a transparent window when needed.
     func applyGhosttyCompositorBlurIfNeeded(to window: NSWindow)
 }

Packages/macOS/CmuxAppKitSupportUI/Sources/CmuxAppKitSupportUI/WindowChrome/Backdrop/WindowBackdropPlan.swift

@@ -21,21 +21,28 @@ public struct WindowBackdropPlan {
     /// Whether Ghostty compositor blur should be applied.
     public let shouldApplyGhosttyCompositorBlur: Bool
 
+    /// Explicit compositor blur radius (points) for the sidebar glass ground,
+    /// when `hostingPhase` is `.transparentRootBackdrop` and the sidebar owns
+    /// the blur instead of Ghostty's config.
+    public let compositorBlurRadius: Int?
+
     /// Creates a window backdrop plan.
     public init(
         hostingPhase: WindowBackdropHostingPhase,
         windowBackgroundColor: NSColor,
         windowIsOpaque: Bool,
         rootPolicy: WindowBackdropPolicy,
         glass: WindowBackdropGlassPlan?,
-        shouldApplyGhosttyCompositorBlur: Bool
+        shouldApplyGhosttyCompositorBlur: Bool,
+        compositorBlurRadius: Int? = nil
     ) {
         self.hostingPhase = hostingPhase
         self.windowBackgroundColor = windowBackgroundColor
         self.windowIsOpaque = windowIsOpaque
         self.rootPolicy = rootPolicy
         self.glass = glass
         self.shouldApplyGhosttyCompositorBlur = shouldApplyGhosttyCompositorBlur
+        self.compositorBlurRadius = compositorBlurRadius
     }
 
     /// Whether the window should be transparent.
@@ -58,6 +65,7 @@ public struct WindowBackdropPlan {
             glass?.tintColor.hexString(includeAlpha: true) ?? "nil",
             glass.map { String(describing: $0.style) } ?? "nil",
             String(shouldApplyGhosttyCompositorBlur),
+            compositorBlurRadius.map(String.init) ?? "nil",
         ].joined(separator: "|")
     }
 }

Packages/macOS/CmuxAppKitSupportUI/Sources/CmuxAppKitSupportUI/WindowChrome/Sidebar/SidebarBackdropSettingsSnapshot.swift

@@ -34,6 +34,26 @@ public struct SidebarBackdropSettingsSnapshot {
     /// Color scheme used to pick light/dark tint overrides.
     public let colorScheme: ColorScheme
 
+    /// Whether the sidebar glass is a clear window ground with a compositor
+    /// blur behind it (tint painted on top) instead of an AppKit material.
+    /// This is the only path with an adjustable blur radius.
+    public let compositorGlass: Bool
+
+    /// Compositor blur radius in points, used when `compositorGlass` is on.
+    /// Read through `effectiveCompositorBlurRadius`, which clamps it.
+    public let compositorBlurRadius: Double
+
+    /// Blur radius bounds in points. Mirrors the settings catalog's range
+    /// (this module cannot import it): a floor so the sidebar always reads
+    /// as glass, a ceiling before blur turns to smear.
+    public static let compositorBlurRadiusRange: ClosedRange<Double> = 12...60
+
+    /// The blur radius the window actually receives, clamped to the range.
+    public var effectiveCompositorBlurRadius: Int {
+        let range = Self.compositorBlurRadiusRange
+        return Int(min(range.upperBound, max(range.lowerBound, compositorBlurRadius)).rounded())
+    }
+
     /// Creates a sidebar backdrop settings snapshot.
     public init(
         materialRawValue: String,
@@ -45,7 +65,9 @@ public struct SidebarBackdropSettingsSnapshot {
         tintOpacity: Double,
         cornerRadius: Double,
         blurOpacity: Double,
-        colorScheme: ColorScheme
+        colorScheme: ColorScheme,
+        compositorGlass: Bool = false,
+        compositorBlurRadius: Double = Self.compositorBlurRadiusRange.lowerBound
     ) {
         self.materialRawValue = materialRawValue
         self.blendModeRawValue = blendModeRawValue
@@ -57,23 +79,34 @@ public struct SidebarBackdropSettingsSnapshot {
         self.cornerRadius = cornerRadius
         self.blurOpacity = blurOpacity
         self.colorScheme = colorScheme
+        self.compositorGlass = compositorGlass
+        self.compositorBlurRadius = compositorBlurRadius
+    }
+
+    /// Tint-only policy for the compositor-glass path: the window ground is
+    /// clear and the compositor blurs behind it, so the sidebar layer paints
+    /// just the tint. No effect view is created for a nil material.
+    ///
+    /// Chosen by `WindowAppearanceSnapshot`, which owns the decision, so the
+    /// layer can never go tint-only over a ground that stayed opaque.
+    public var tintOnlyMaterialPolicy: SidebarBackdropMaterialPolicy {
+        SidebarBackdropMaterialPolicy(
+            material: nil,
+            blendingMode: .behindWindow,
+            state: .active,
+            opacity: 1.0,
+            tintColor: resolvedTintColor,
+            cornerRadius: CGFloat(max(0, cornerRadius)),
+            preferLiquidGlass: false,
+            usesWindowLevelGlass: false
+        )
     }
 
     /// Resolved AppKit material policy for these settings.
     public var materialPolicy: SidebarBackdropMaterialPolicy {
         let materialOption = WindowChromeSidebarMaterialOption(rawValue: materialRawValue)
         let blendingMode = WindowChromeSidebarBlendModeOption(rawValue: blendModeRawValue)?.mode ?? .behindWindow
         let state = WindowChromeSidebarStateOption(rawValue: stateRawValue)?.state ?? .active
-        let resolvedHex: String
-        if colorScheme == .dark, let tintHexDark {
-            resolvedHex = tintHexDark
-        } else if colorScheme == .light, let tintHexLight {
-            resolvedHex = tintHexLight
-        } else {
-            resolvedHex = tintHex
-        }
-        let tintColor = (NSColor(hex: resolvedHex) ?? NSColor(hex: tintHex) ?? .black)
-            .withAlphaComponent(tintOpacity)
         let preferLiquidGlass = materialOption?.usesLiquidGlass ?? false
         let usesWindowLevelGlass = preferLiquidGlass && blendingMode == .behindWindow
 
@@ -82,13 +115,34 @@ public struct SidebarBackdropSettingsSnapshot {
             blendingMode: blendingMode,
             state: state,
             opacity: blurOpacity,
-            tintColor: tintColor,
+            tintColor: resolvedTintColor,
             cornerRadius: CGFloat(max(0, cornerRadius)),
             preferLiquidGlass: preferLiquidGlass,
             usesWindowLevelGlass: usesWindowLevelGlass
         )
     }
 
+    /// The tint colour with its opacity baked in, honouring the per-scheme
+    /// overrides. Light mode swaps the stock dark tint for the light default;
+    /// a chosen colour, or a chosen opacity, still wins.
+    var resolvedTintColor: NSColor {
+        var resolvedHex = tintHex
+        var opacity = tintOpacity
+        if colorScheme == .dark, let tintHexDark {
+            resolvedHex = tintHexDark
+        } else if colorScheme == .light, let tintHexLight {
+            resolvedHex = tintHexLight
+        } else if colorScheme == .light {
+            let stock = WindowChromeSidebarTintDefaults()
+            if tintHex.caseInsensitiveCompare(stock.hex) == .orderedSame {
+                resolvedHex = WindowChromeSidebarTintDefaults.light.hex
+                if tintOpacity == stock.opacity { opacity = WindowChromeSidebarTintDefaults.light.opacity }
+            }
+        }
+        return (NSColor(hex: resolvedHex) ?? NSColor(hex: tintHex) ?? .black)
+            .withAlphaComponent(opacity)
+    }
+
     /// Stable identity for AppKit mutations.
     public var appKitMutationID: String {
         [
@@ -102,6 +156,8 @@ public struct SidebarBackdropSettingsSnapshot {
             identityComponent(cornerRadius),
             identityComponent(blurOpacity),
             String(describing: colorScheme),
+            String(compositorGlass),
+            identityComponent(compositorBlurRadius),
         ].joined(separator: "|")
     }
 

Packages/macOS/CmuxAppKitSupportUI/Sources/CmuxAppKitSupportUI/WindowChrome/Sidebar/WindowChromeSidebarTintDefaults.swift

@@ -9,12 +9,19 @@ public struct WindowChromeSidebarTintDefaults: Sendable {
     /// Whether the sidebar uses the terminal background instead of the tint
     /// when the user has not chosen. Mirrors the
     /// `sidebarAppearance.matchTerminalBackground` catalog default.
-    public static let matchesTerminalBackground = true
+    public static let matchesTerminalBackground = false
+
+    /// What light mode uses while the stock tint is in place. The stock
+    /// #393939 is a dark glass and light mode turns the sidebar text dark,
+    /// so it gets a light glass: Aside's cool mid-light gray ground (~#CACDCE
+    /// over a typical wallpaper). Main's light #000000 at 18% assumed a light
+    /// material under it; the compositor ground is the raw desktop blur.
+    public static let light = WindowChromeSidebarTintDefaults(hex: "#D1D4D5", opacity: 0.88)
 
     /// Creates sidebar tint defaults.
     public init(
-        hex: String = "#000000",
-        opacity: Double = 0.18
+        hex: String = "#393939",
+        opacity: Double = 0.72
     ) {
         self.hex = hex
         self.opacity = opacity