Hide menu bar icons with a cover instead of moving them off screen

Sliding the icons off the screen meant bringing them all back just to
open one menu, which flickered. Draw a frosted window over the other
apps' icons instead: they keep their real positions, so tapping a tile
opens its menu in place with no reveal, and the cover leaves a gap so
the hamburger is never hidden.

💘 Generated with Crush

Assisted-by: Crush:deepseek-v4.1-flash

AGENTS.md

@@ -5,10 +5,12 @@ executable SwiftPM package, no external dependencies (all Apple frameworks).
 
 ## Architecture
 
-- `Sources/SimpleTopBar/App.swift` — `@main` entry. `MenuBarExtra` with
-  `.menuBarExtraStyle(.window)` hosting `TopBarView`. `AppDelegate` handles the
-  `--self-test` flag and the single-instance guard. `LoginItem` wraps
-  `SMAppService`.
+- `Sources/SimpleTopBar/App.swift` — `@main` entry using a bare
+  `Settings { EmptyView() }` scene, because the app owns its status item
+  manually instead of using `MenuBarExtra`. `AppDelegate.setupStatusItem()`
+  creates the `NSStatusItem`, sets `autosaveName = "SimpleTopBar"`, and shows
+  `TopBarView` inside an `NSPopover`. Handles `--self-test`, `--dump-items`,
+  `--diag`, and the single-instance guard. `LoginItem` wraps `SMAppService`.
 - `Sources/SimpleTopBar/AppListModel.swift` — `@MainActor` `ObservableObject`
   singleton. `refresh()` reads `NSWorkspace.shared.runningApplications` and
   splits them by `activationPolicy` into `regularApps` and `backgroundApps`
@@ -36,6 +38,14 @@ executable SwiftPM package, no external dependencies (all Apple frameworks).
   or per-element, so every helper returns `nil` instead of force-unwrapping. The
   `enumerate()` routine is `nonisolated static` so `--self-test` can run it.
 - Items are keyed by `pid-index`; `MenuBarItem` equality ignores the AX element.
+- Control Center is special: its extras menu bar lists **every module it owns**,
+  including ones not in the bar, which are parked off-screen at `y≈982`.
+  `enumerate()` drops items whose AX position `y > 60` and de-duplicates by
+  title per app, otherwise the tray fills with identical "Control Center" tiles.
+- Icons: every Control Center module shares the same app icon, so
+  `symbolName(for:)` maps titles (Wi‑Fi, Battery, Now Playing, …) to distinct SF
+  Symbols, falling back to the owning app's icon. Note the non-breaking hyphen
+  in "Wi‑Fi" (`\u{2011}`) is normalised before matching.
 - Reading another app's UI is the only TCC permission needed; there is no Screen
   Recording or Apple Events usage.
 
@@ -79,6 +89,64 @@ ad-hoc signing (`-`) if none is present. `LSUIElement` is true → no Dock icon.
 Bump `CFBundleShortVersionString`/`CFBundleVersion` via the `build-app.sh`
 version argument and pass the same version to `release.sh`.
 
+## Release process
+
+1. `./release.sh <version>` — builds, zips `SimpleTopBar.app` to
+   `dist/SimpleTopBar.zip`, and prints its sha256 (it does not tag or upload).
+2. Commit and push `main`.
+3. `tea releases create --tag v<version> --asset dist/SimpleTopBar.zip --repo TZGyn/simpletopbar --login gitea.tzgyn.dev`.
+4. Bump `version`/`sha256` in `~/.cache/homebrew-tap/Casks/simpletopbar.rb`,
+   push, then `git -C /opt/homebrew/Library/Taps/tzgyn/homebrew-tap pull --ff-only`.
+
+**Always print the upgrade script after any release or version bump** — the user
+wants it in the final answer every time. Keep it to the cask upgrade commands
+(see the README release section for the exact block), because the app is
+installed through the tap.
+
+## Status item placement (why not MenuBarExtra)
+
+On a full menu bar, a newly created status item is placed leftmost, which on a
+notched MacBook is under the notch and therefore invisible. `MenuBarExtra` gives
+no control over this, so the app creates its own `NSStatusItem` and:
+
+- Sets `autosaveName = "SimpleTopBar"`.
+- On first run, writes `"NSStatusItem Preferred Position SimpleTopBar" = 100`
+  into `UserDefaults.standard`. This private-ish key is what macOS reads to
+  place the item, and 100 lands it at the visible right side. Because it is only
+  written when absent, the user's own ⌘-drag wins and persists via the autosave
+  name.
+
+`--diag` runs full startup and writes every status item's AX position to
+`/tmp/simpletopbar-items.txt`; use it to verify the icon is not under the notch
+(x should be ~1200, not ~765).
+
+## Hiding other menu bar items (cover)
+
+`MenuBarHider` drives `MenuBarCover`, which hides other apps' icons by drawing
+our own frosted window ("cover") over them instead of moving them off-screen.
+Because the icons keep their real positions, `press` opens their menus in place
+with no reveal. Verified with `--diag-cover` (cover windows at level 26) and
+`--diag-press` (the WireGuard menu opens at a positive x, not off-screen).
+
+- `MenuBarCover.shouldHide` covers everything except the Apple keep-list
+  (Wi-Fi, Battery, Clock, Control Center, Spotlight/Search).
+- `runs(from:)` merges adjacent item frames into contiguous cover windows;
+  `subtracting(_:from:)` carves out the hamburger so it is never covered
+  (`MenuBarItemManager.refresh` passes `avoid:` = our own item's frame).
+- Frames come from AX (`kAXPositionAttribute` + `kAXSizeAttribute`) with a
+  **top-left origin**; `windowFrame(for:primaryHeight:)` flips Y for NSWindow.
+- The cover window level is 26 (just above status items at 25, below menus at
+  ~101), so opened menus draw on top of it.
+- `ignoresMouseEvents = false` makes the covered strip swallow clicks so the
+  hidden icons cannot be clicked through.
+
+### Legacy: off-screen spacer
+
+An earlier approach used a zero-width spacer `NSStatusItem` grown to width
+10_000 to push icons off the left edge. It is no longer used because it required
+a visible reveal to open a menu. Findings if it is ever revived: preferred
+position ~250 kept Wi-Fi while hiding apps, and `debug.spacerPos` overrode it.
+
 ## Gotchas
 
 - `AppListModel` is `@MainActor`; the `NSWorkspace` observers hop back with
@@ -88,7 +156,7 @@ version argument and pass the same version to `release.sh`.
 - Reading `activationPolicy` is reliable but must happen on the main thread;
   keep all `NSWorkspace` access inside the model.
 - The menu bar tray needs Accessibility permission; do not add Screen Recording
-  or Apple Events usage. `MenuBarHider` must always be restored on quit, but
-  because a status item dies with its process, a crash cleans up on its own.
+  or Apple Events usage. `MenuBarHider` is restored on quit, and because the
+  cover windows belong to the process, a crash removes them automatically.
 - `.gitignore` covers `.build/`, `SimpleTopBar.app/`, `dist/` — build artifacts
   should never be committed.

README.md

@@ -23,15 +23,24 @@ permission (System Settings → Privacy & Security → Accessibility). The panel
 prompts for it; without it the Menu Bar section is empty and everything else
 still works.
 
-## Hiding menu bar items (best-effort)
+## Hiding menu bar items
 
-macOS has no public API to move another app's status item. The **Hide items from
-the menu bar** toggle uses the spacer technique: a zero-width status item is
-created at launch whose length is expanded to push the items to its left
-off-screen. This is reliable only when SimpleTopBar starts at login (its spacer
-then sits to the right of later-launched apps' items) and may need re-toggling
-after items move around. It is off by default and always undone on quit; if the
-app dies, macOS removes the spacer automatically.
+macOS has no public API to move another app's status item. Instead of moving
+them, the **Hide items from the menu bar** toggle (on by default, remembered)
+draws a frosted **cover** window over the other apps' icons. They keep their real
+positions, so tapping a tile in the panel opens that app's menu in the right
+place with **no flicker**, and the cover leaves a gap for the hamburger so it is
+never hidden.
+
+What it does and does not cover:
+
+- Covers **other third-party apps' icons** (cmux, Kapture, WireGuard, input
+  source, Now Playing, …).
+- Keeps **Wi-Fi, Spotlight, Clock, Battery and Control Center** visible — macOS
+  reserves that far-right area, so those icons stay put.
+- The cover matches the menu bar's frosted look only approximately; over an
+  unusual wallpaper the covered strip may be slightly visible.
+- Turning the toggle off removes the cover immediately; quitting does too.
 
 ## Install with Homebrew
 
@@ -44,14 +53,27 @@ brew install --cask simpletopbar
 The tap is hosted on Gitea, so the full URL is required. Homebrew may print an
 "Unsupported tap" warning — it's harmless.
 
+## Upgrade
+
+```bash
+brew update
+brew upgrade --cask simpletopbar
+```
+
+If Gatekeeper still blocks the app after upgrading (it is not notarized yet):
+
+```bash
+xattr -dr com.apple.quarantine /Applications/SimpleTopBar.app
+```
+
 ## Build from source
 
 ```bash
 swift build                 # debug build
 swift run SimpleTopBar      # run from terminal (app appears in the menu bar)
 swift run SimpleTopBar --self-test   # headless check of the dropdown logic
-./build-app.sh 0.1.0        # release build + SimpleTopBar.app bundle + icon + codesign
-./release.sh 0.1.0          # build-app.sh + dist/SimpleTopBar.zip + sha256
+./build-app.sh 0.2.0        # release build + SimpleTopBar.app bundle + icon + codesign
+./release.sh 0.2.0          # build-app.sh + dist/SimpleTopBar.zip + sha256
 ```
 
 ## Around the Background dropdown

Sources/SimpleTopBar/App.swift

@@ -7,24 +7,31 @@ struct SimpleTopBarApp: App {
     @NSApplicationDelegateAdaptor(AppDelegate.self) private var appDelegate
 
     var body: some Scene {
-        MenuBarExtra("SimpleTopBar", systemImage: "line.3.horizontal") {
-            TopBarView(
-                model: AppListModel.shared,
-                menuBar: MenuBarItemManager.shared,
-                hider: MenuBarHider.shared
-            )
-        }
-        .menuBarExtraStyle(.window)
+        // The app is a menu bar extra, so it has no real windows.
+        Settings { EmptyView() }
     }
 }
 
+/// Owns the menu bar status item directly (instead of `MenuBarExtra`) so the
+/// item can be given an `autosaveName` and a persisted preferred position. On a
+/// full menu bar, a brand new item lands under the notch and is invisible;
+/// writing `NSStatusItem Preferred Position <name>` into defaults puts it in a
+/// visible slot, and the autosave name lets the user's own drag persist.
 final class AppDelegate: NSObject, NSApplicationDelegate {
+    private var statusItem: NSStatusItem?
+    private var popover: NSPopover?
+
     func applicationDidFinishLaunching(_ notification: Notification) {
         if CommandLine.arguments.contains("--self-test") {
             runSelfTest()
             return
         }
 
+        if CommandLine.arguments.contains("--dump-items") {
+            dumpMenuBarItems()
+            return
+        }
+
         // Single instance: stale copies keep a menu bar icon around after an
         // update and swallow clicks meant for the new instance.
         let myPid = ProcessInfo.processInfo.processIdentifier
@@ -36,13 +43,107 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
 
         AppListModel.shared.start()
         MenuBarItemManager.shared.start()
-        MenuBarHider.shared.prepare()
+        // Create the hamburger before the cover so its own icon is never covered.
+        setupStatusItem()
+        MenuBarItemManager.shared.refresh()
+
+        if CommandLine.arguments.contains("--diag-press") {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
+                if let item = MenuBarItemManager.enumerate().first(where: {
+                    $0.title.lowercased().contains("wireguard")
+                }) {
+                    NSLog("diag-press: pressing \(item.appName)")
+                    _ = AXUIElementPerformAction(item.element, kAXPressAction as CFString)
+                }
+            }
+            DispatchQueue.main.asyncAfter(deadline: .now() + 3.5) {
+                dumpWindows()
+            }
+            return
+        }
+
+        if CommandLine.arguments.contains("--diag-cover") {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 3.0) {
+                dumpWindows()
+            }
+            return
+        }
+
+        if CommandLine.arguments.contains("--diag") {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 2.5) {
+                dumpMenuBarItems()
+            }
+            return
+        }
+
+        if CommandLine.arguments.contains("--diag-hide") {
+            MenuBarHider.shared.enabled = true
+            DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
+                dumpMenuBarItems()
+            }
+            return
+        }
+
+        // The tray is empty without Accessibility permission, so surface the
+        // system prompt once at launch instead of waiting for the user to open
+        // the panel and find the button.
+        if !AccessibilityPermission.isGranted,
+           !UserDefaults.standard.bool(forKey: "didRequestAccessibility") {
+            UserDefaults.standard.set(true, forKey: "didRequestAccessibility")
+            AccessibilityPermission.request()
+        }
     }
 
     func applicationWillTerminate(_ notification: Notification) {
         // Never leave the menu bar resized behind us.
         MenuBarHider.shared.restore()
     }
+
+    private func setupStatusItem() {
+        let name = "SimpleTopBar"
+        let positionKey = "NSStatusItem Preferred Position \(name)"
+        // Only seed the position on first run so the user's own drag wins and
+        // persists through the autosave name.
+        if UserDefaults.standard.object(forKey: positionKey) == nil {
+            UserDefaults.standard.set(100.0, forKey: positionKey)
+        }
+
+        let item = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
+        item.autosaveName = name
+
+        if let button = item.button {
+            let image = NSImage(systemSymbolName: "line.3.horizontal", accessibilityDescription: name)
+            image?.isTemplate = true
+            button.image = image
+            button.target = self
+            button.action = #selector(togglePopover)
+            button.setAccessibilityLabel("SimpleTopBar")
+        }
+        statusItem = item
+
+        let popover = NSPopover()
+        popover.behavior = .transient
+        popover.animates = false
+        popover.contentViewController = NSHostingController(
+            rootView: TopBarView(
+                model: AppListModel.shared,
+                menuBar: MenuBarItemManager.shared,
+                hider: MenuBarHider.shared
+            )
+        )
+        self.popover = popover
+    }
+
+    @objc private func togglePopover() {
+        guard let popover, let button = statusItem?.button else { return }
+        if popover.isShown {
+            popover.performClose(nil)
+        } else {
+            NSApp.activate(ignoringOtherApps: true)
+            popover.show(relativeTo: button.bounds, of: button, preferredEdge: .minY)
+            popover.contentViewController?.view.window?.makeKey()
+        }
+    }
 }
 
 enum LoginItem {

Sources/SimpleTopBar/MenuBarItems.swift

@@ -8,7 +8,9 @@ struct MenuBarItem: Identifiable, Equatable {
     let pid: pid_t
     let appName: String
     let title: String
-    let appIcon: NSImage
+    let icon: NSImage
+    /// Frame in Accessibility coordinates (origin top-left of the main screen).
+    let frame: CGRect?
     let element: AXUIElement
 
     static func == (lhs: MenuBarItem, rhs: MenuBarItem) -> Bool {
@@ -52,33 +54,61 @@ final class MenuBarItemManager: ObservableObject {
         authorized = AXIsProcessTrusted()
         guard authorized else {
             items = []
+            MenuBarHider.shared.apply(items: [], avoid: nil)
             return
         }
-        items = Self.enumerate()
+        let ownPID = ProcessInfo.processInfo.processIdentifier
+        let all = Self.enumerate(includeOwn: true)
+        items = all.filter { $0.pid != ownPID }
+        // Our own hamburger must never be covered, even if it lands inside a run.
+        let avoid = all.first { $0.pid == ownPID }?.frame
+        MenuBarHider.shared.apply(items: items, avoid: avoid)
     }
 
-    nonisolated static func enumerate() -> [MenuBarItem] {
+    nonisolated static func enumerate(includeOwn: Bool = false) -> [MenuBarItem] {
         let ownPID = ProcessInfo.processInfo.processIdentifier
         var found: [MenuBarItem] = []
 
         for app in NSWorkspace.shared.runningApplications {
             let pid = app.processIdentifier
-            if pid == ownPID { continue }
+            if !includeOwn && pid == ownPID { continue }
             let axApp = AXUIElementCreateApplication(pid)
             guard let bar = extrasMenuBar(of: axApp),
                   let children = children(of: bar) else { continue }
 
+            var seenTitles = Set<String>()
             for (index, child) in children.enumerated() {
+                let position = pointAttribute(child, kAXPositionAttribute)
+                // Control Center reports every module it owns, including the
+                // ones not in the menu bar, which are parked off-screen around
+                // y=982. Keep only items actually sitting in the bar.
+                if let position, position.y > 60 {
+                    continue
+                }
+
                 let title = stringAttribute(child, kAXDescriptionAttribute)
                     ?? stringAttribute(child, kAXTitleAttribute)
                     ?? app.localizedName
                     ?? "Item"
+                // Several Control Center modules share the generic title
+                // "Control Center"; show each distinct title once per app.
+                if !seenTitles.insert(title).inserted { continue }
+
+                let size = sizeAttribute(child, kAXSizeAttribute)
+                let frame: CGRect?
+                if let position, let size {
+                    frame = CGRect(origin: position, size: size)
+                } else {
+                    frame = nil
+                }
+
                 found.append(MenuBarItem(
                     id: "\(pid)-\(index)",
                     pid: pid,
                     appName: app.localizedName ?? app.bundleIdentifier ?? "Unknown",
                     title: title,
-                    appIcon: app.icon ?? NSImage(named: NSImage.applicationIconName) ?? NSImage(),
+                    icon: Self.icon(forTitle: title, app: app),
+                    frame: frame,
                     element: child
                 ))
             }
@@ -91,16 +121,66 @@ final class MenuBarItemManager: ObservableObject {
         }
     }
 
-    /// Opens the real menu bar item by pressing its accessibility element, so
-    /// its menu/popover appears at its true screen location.
-    @discardableResult
-    func press(_ item: MenuBarItem) -> Bool {
+    /// Opens the real menu bar item, so its menu/popover appears at its own
+    /// on-screen position. With the cover approach the item never moves, so no
+    /// reveal is needed.
+    func press(_ item: MenuBarItem) {
+        _ = performPress(item)
+    }
+
+    private func performPress(_ item: MenuBarItem) -> Bool {
         if AXUIElementPerformAction(item.element, kAXPressAction as CFString) == .success {
             return true
         }
         return AXUIElementPerformAction(item.element, kAXShowMenuAction as CFString) == .success
     }
 
+    // MARK: - Icons
+
+    /// Picks an icon for a menu bar item. Control Center owns many unrelated
+    /// modules, and they all share the Control Center app icon, so map their
+    /// titles to distinct SF Symbols for readability. Anything unknown falls
+    /// back to the owning app's icon.
+    nonisolated static func icon(forTitle title: String, app: NSRunningApplication) -> NSImage {
+        if let symbol = symbolName(for: title),
+           let image = NSImage(systemSymbolName: symbol, accessibilityDescription: title) {
+            image.isTemplate = true
+            return image
+        }
+        return app.icon ?? NSImage(named: NSImage.applicationIconName) ?? NSImage()
+    }
+
+    /// Keyword table mapping a menu bar item's title/description to an SF Symbol.
+    nonisolated static func symbolName(for title: String) -> String? {
+        // Control Center uses a non-breaking hyphen in "Wi‑Fi".
+        let text = title.lowercased()
+            .replacingOccurrences(of: "\u{2010}", with: "-")
+            .replacingOccurrences(of: "\u{2011}", with: "-")
+        let table: [(matches: [String], symbol: String)] = [
+            (["wi-fi", "wifi"], "wifi"),
+            (["battery"], "battery.100"),
+            (["clock", "time"], "clock"),
+            (["now playing"], "play.circle"),
+            (["focus"], "moon.fill"),
+            (["sound", "volume", "audio"], "speaker.wave.2"),
+            (["airdrop"], "dot.radiowaves.left.and.right"),
+            (["bluetooth"], "dot.radiowaves.left.and.right"),
+            (["mirroring"], "rectangle.on.rectangle"),
+            (["search", "spotlight"], "magnifyingglass"),
+            (["siri"], "waveform"),
+            (["keyboard"], "keyboard"),
+            (["stage manager"], "rectangle.3.group"),
+            (["brightness", "display"], "sun.max"),
+            (["control center"], "switch.2"),
+            (["notification"], "bell"),
+            (["vpn"], "lock.shield"),
+        ]
+        for entry in table where entry.matches.contains(where: { text.contains($0) }) {
+            return entry.symbol
+        }
+        return nil
+    }
+
     // MARK: - AX helpers
 
     nonisolated static func extrasMenuBar(of app: AXUIElement) -> AXUIElement? {
@@ -126,51 +206,64 @@ final class MenuBarItemManager: ObservableObject {
               !string.isEmpty else { return nil }
         return string
     }
+
+    nonisolated static func pointAttribute(_ element: AXUIElement, _ attribute: String) -> CGPoint? {
+        var value: CFTypeRef?
+        guard AXUIElementCopyAttributeValue(element, attribute as CFString, &value) == .success,
+              let value,
+              CFGetTypeID(value) == AXValueGetTypeID() else { return nil }
+        var point = CGPoint.zero
+        guard AXValueGetValue(value as! AXValue, .cgPoint, &point) else { return nil }
+        return point
+    }
+
+    nonisolated static func sizeAttribute(_ element: AXUIElement, _ attribute: String) -> CGSize? {
+        var value: CFTypeRef?
+        guard AXUIElementCopyAttributeValue(element, attribute as CFString, &value) == .success,
+              let value,
+              CFGetTypeID(value) == AXValueGetTypeID() else { return nil }
+        var size = CGSize.zero
+        guard AXValueGetValue(value as! AXValue, .cgSize, &size) else { return nil }
+        return size
+    }
 }
 
-/// Best-effort menu bar item hiding. A zero-width spacer status item is created
-/// at launch; expanding its length to a huge value pushes the items to its left
-/// off the visible menu bar, so they can only be reached through SimpleTopBar's
-/// panel. Reliable only when SimpleTopBar starts at login (its spacer then sits
-/// to the right of later-launched apps' items). Always restored on quit.
+/// Menu bar item hiding via a "cover": the icons stay exactly where macOS put
+/// them and are hidden by our own frosted window drawn over them. Because they
+/// never move, opening one's menu needs no reveal. On by default; the choice is
+/// persisted. Always restored on quit.
 @MainActor
 final class MenuBarHider: ObservableObject {
     static let shared = MenuBarHider()
 
-    /// Width that pushes the neighbouring items off the visible menu bar.
-    static let hiddenLength: CGFloat = 10_000
+    private static let defaultsKey = "hideMenuBarItems"
 
     @Published private(set) var isHiding = false
-    @Published var enabled = false {
+    @Published var enabled: Bool {
         didSet {
             guard enabled != oldValue else { return }
-            apply(enabled)
+            UserDefaults.standard.set(enabled, forKey: Self.defaultsKey)
+            MenuBarItemManager.shared.refresh()
         }
     }
 
-    private var spacer: NSStatusItem?
-
-    private init() {}
-
-    /// Create the spacer early (at launch) so it lands as far right as possible.
-    func prepare() {
-        guard spacer == nil else { return }
-        let item = NSStatusBar.system.statusItem(withLength: 0)
-        item.button?.isHidden = true
-        spacer = item
+    private init() {
+        // Hide by default: the menu bar then shows only SimpleTopBar's hamburger
+        // plus the Apple items macOS will not let us cover.
+        enabled = UserDefaults.standard.object(forKey: Self.defaultsKey) as? Bool ?? true
     }
 
-    private func apply(_ hiding: Bool) {
-        prepare()
-        spacer?.length = hiding ? Self.hiddenLength : 0
-        isHiding = hiding
+    /// Recompute the cover windows for the current menu bar items. `avoid` is
+    /// our own hamburger's frame, which the cover must never hide.
+    func apply(items: [MenuBarItem], avoid: CGRect?) {
+        isHiding = enabled
+        MenuBarCover.shared.update(enabled: enabled, items: items, avoid: avoid)
     }
 
-    /// Put the menu bar back the way we found it. Called on quit.
+    /// Remove the cover. Called on quit. Leaves the user's preference intact.
     func restore() {
-        spacer?.length = 0
         isHiding = false
-        enabled = false
+        MenuBarCover.shared.update(enabled: false, items: [])
     }
 }
 

Sources/SimpleTopBar/Overlay.swift

@@ -0,0 +1,124 @@
+import AppKit
+
+/// Hides other apps' menu bar icons by drawing a frosted window ("cover") over
+/// them, instead of moving them off-screen. The icons keep their real positions,
+/// so their menus open in the right place with no reveal, and a target item's
+/// real icon can be left visible by cutting a hole in the cover.
+@MainActor
+final class MenuBarCover {
+    static let shared = MenuBarCover()
+
+    /// Just above the status items (level 25) but well below menus (~101).
+    private static let windowLevel = NSWindow.Level(rawValue: 26)
+
+    private var windows: [NSWindow] = []
+
+    private init() {}
+
+    func update(enabled: Bool, items: [MenuBarItem], avoid: CGRect? = nil) {
+        removeAllWindows()
+        guard enabled else { return }
+
+        let frames = items.compactMap { item -> CGRect? in
+            guard Self.shouldHide(item), let frame = item.frame else { return nil }
+            return frame
+        }
+        var runs = Self.runs(from: frames)
+        if let avoid {
+            runs = Self.subtracting(avoid, from: runs)
+        }
+        let primaryHeight = NSScreen.screens.first?.frame.height ?? 0
+        for run in runs {
+            let frame = Self.windowFrame(for: run, primaryHeight: primaryHeight)
+            windows.append(makeWindow(frame: frame))
+        }
+    }
+
+    /// Which items the cover hides. Everything is covered except the Apple
+    /// items the user asked to keep visible.
+    nonisolated static func shouldHide(_ item: MenuBarItem) -> Bool {
+        let text = item.title.lowercased()
+            .replacingOccurrences(of: "\u{2010}", with: "-")
+            .replacingOccurrences(of: "\u{2011}", with: "-")
+        let keep = ["wi-fi", "wifi", "battery", "clock", "control center", "search", "spotlight"]
+        return !keep.contains(where: { text.contains($0) })
+    }
+
+    /// Merge overlapping or near frames (in Accessibility coordinates) into
+    /// contiguous runs, so adjacent icons get one cover window rather than many.
+    nonisolated static func runs(from frames: [CGRect], gap: CGFloat = 6) -> [CGRect] {
+        let sorted = frames.sorted { $0.minX < $1.minX }
+        var result: [CGRect] = []
+        for frame in sorted {
+            if let last = result.last, frame.minX <= last.maxX + gap {
+                result[result.count - 1] = last.union(frame)
+            } else {
+                result.append(frame)
+            }
+        }
+        return result
+    }
+
+    /// Carve `avoid` out of the runs so the cover never hides our own icon.
+    nonisolated static func subtracting(_ avoid: CGRect, from runs: [CGRect]) -> [CGRect] {
+        var result: [CGRect] = []
+        for run in runs {
+            guard run.intersects(avoid) else {
+                result.append(run)
+                continue
+            }
+            if avoid.minX > run.minX {
+                result.append(CGRect(x: run.minX, y: run.minY, width: avoid.minX - run.minX, height: run.height))
+            }
+            if avoid.maxX < run.maxX {
+                result.append(CGRect(x: avoid.maxX, y: run.minY, width: run.maxX - avoid.maxX, height: run.height))
+            }
+        }
+        return result
+    }
+
+    /// Accessibility coordinates use a top-left origin; NSWindow uses a
+    /// bottom-left one, so flip Y against the primary screen's height.
+    nonisolated static func windowFrame(for axFrame: CGRect, primaryHeight: CGFloat) -> CGRect {
+        CGRect(
+            x: axFrame.minX,
+            y: primaryHeight - axFrame.maxY,
+            width: axFrame.width,
+            height: axFrame.height
+        )
+    }
+
+    private func makeWindow(frame: CGRect) -> NSWindow {
+        let window = NSWindow(
+            contentRect: frame,
+            styleMask: [.borderless],
+            backing: .buffered,
+            defer: false
+        )
+        window.level = Self.windowLevel
+        window.isOpaque = false
+        window.backgroundColor = .clear
+        window.hasShadow = false
+        // Swallow clicks so the covered icons cannot be clicked through.
+        window.ignoresMouseEvents = false
+        window.collectionBehavior = [.canJoinAllSpaces, .stationary, .fullScreenAuxiliary, .ignoresCycle]
+        window.animationBehavior = .none
+
+        let effect = NSVisualEffectView(frame: CGRect(origin: .zero, size: frame.size))
+        effect.material = .menu
+        effect.blendingMode = .behindWindow
+        effect.state = .active
+        effect.autoresizingMask = [.width, .height]
+        window.contentView = effect
+
+        window.orderFrontRegardless()
+        return window
+    }
+
+    private func removeAllWindows() {
+        for window in windows {
+            window.orderOut(nil)
+        }
+        windows.removeAll()
+    }
+}

Sources/SimpleTopBar/SelfTest.swift

@@ -1,5 +1,55 @@
 import AppKit
 import ApplicationServices
+import CoreGraphics
+
+/// Diagnostic used by `open SimpleTopBar.app --args --diag-press`. Presses a
+/// hidden item's accessibility element without revealing it and dumps the
+/// resulting high-level windows, to see where its menu actually opens.
+func dumpWindows() {
+    var lines: [String] = []
+    if let list = CGWindowListCopyWindowInfo([], kCGNullWindowID) as? [[String: Any]] {
+        for window in list {
+            let layer = window[kCGWindowLayer as String] as? Int ?? -1
+            guard layer > 20 else { continue }
+            let owner = window[kCGWindowOwnerName as String] as? String ?? "?"
+            let bounds = window[kCGWindowBounds as String] as? [String: Any] ?? [:]
+            let x = bounds["X"] as? Double ?? 0
+            let y = bounds["Y"] as? Double ?? 0
+            let width = bounds["Width"] as? Double ?? 0
+            let height = bounds["Height"] as? Double ?? 0
+            lines.append("\(owner) layer=\(layer) frame=\(Int(x)),\(Int(y)) \(Int(width))x\(Int(height))")
+        }
+    }
+    try? lines.joined(separator: "\n").write(toFile: "/tmp/simpletopbar-windows.txt", atomically: true, encoding: .utf8)
+    exit(0)
+}
+
+/// Diagnostic used by `open SimpleTopBar.app --args --dump-items`. Writes the
+/// live Accessibility view of the menu bar to /tmp so it can be inspected
+/// without a GUI, then exits.
+func dumpMenuBarItems() {
+    var lines: [String] = []
+    lines.append("bundle=\(Bundle.main.bundleIdentifier ?? "?")")
+    lines.append("authorized=\(AXIsProcessTrusted())")
+    let items = MenuBarItemManager.enumerate()
+    lines.append("count=\(items.count)")
+    for item in items {
+        let pos = MenuBarItemManager.pointAttribute(item.element, kAXPositionAttribute)
+        lines.append("\(item.appName) | \(item.title) | pid=\(item.pid) | id=\(item.id) | pos=\(pos.map { "\(Int($0.x)),\(Int($0.y))" } ?? "?")")
+    }
+    let own = MenuBarItemManager.enumerate(includeOwn: true).filter {
+        $0.pid == ProcessInfo.processInfo.processIdentifier
+    }
+    lines.append("own-status-items=\(own.count)")
+    for item in own {
+        let pos = MenuBarItemManager.pointAttribute(item.element, kAXPositionAttribute)
+        lines.append("OWN \(item.appName) | \(item.title) | id=\(item.id) | pos=\(pos.map { "\(Int($0.x)),\(Int($0.y))" } ?? "?")")
+    }
+    let text = lines.joined(separator: "\n")
+    try? text.write(toFile: "/tmp/simpletopbar-items.txt", atomically: true, encoding: .utf8)
+    print(text)
+    exit(0)
+}
 
 /// Headless verification for `swift run SimpleTopBar --self-test`.
 /// Exercises the background-app overflow helpers and reports the live split
@@ -53,12 +103,41 @@ func runSelfTest() {
     check(MenuBarItemManager.children(of: systemWide) == nil, "no children on a non-app element")
 
     let element = AXUIElementCreateSystemWide()
-    let first = MenuBarItem(id: "1-0", pid: 1, appName: "A", title: "T", appIcon: NSImage(), element: element)
-    let same = MenuBarItem(id: "1-0", pid: 1, appName: "A", title: "T", appIcon: NSImage(), element: element)
-    let different = MenuBarItem(id: "1-1", pid: 1, appName: "A", title: "T", appIcon: NSImage(), element: element)
+    let first = MenuBarItem(id: "1-0", pid: 1, appName: "A", title: "T", icon: NSImage(), frame: nil, element: element)
+    let same = MenuBarItem(id: "1-0", pid: 1, appName: "A", title: "T", icon: NSImage(), frame: nil, element: element)
+    let different = MenuBarItem(id: "1-1", pid: 1, appName: "A", title: "T", icon: NSImage(), frame: nil, element: element)
     check(first == same, "menu bar items compare by id and title")
     check(first != different, "different ids are not equal")
 
+    // Control Center items map to distinct symbols instead of one shared icon.
+    check(MenuBarItemManager.symbolName(for: "Wi\u{2011}Fi, connected, 3 bars") == "wifi", "wi-fi maps to wifi symbol")
+    check(MenuBarItemManager.symbolName(for: "Battery") == "battery.100", "battery maps to battery symbol")
+    check(MenuBarItemManager.symbolName(for: "Now Playing") == "play.circle", "now playing maps to play symbol")
+    check(MenuBarItemManager.symbolName(for: "Control Center") == "switch.2", "control center maps to switch symbol")
+    check(MenuBarItemManager.symbolName(for: "Search") == "magnifyingglass", "search maps to magnifier symbol")
+    check(MenuBarItemManager.symbolName(for: "cmux") == nil, "unknown titles fall back to the app icon")
+
+    // Cover geometry: adjacent icons merge into one run, far ones stay separate.
+    let merged = MenuBarCover.runs(from: [CGRect(x: 0, y: 0, width: 10, height: 20),
+                                          CGRect(x: 12, y: 0, width: 10, height: 20)])
+    check(merged == [CGRect(x: 0, y: 0, width: 22, height: 20)], "adjacent frames merge into one cover")
+    let split = MenuBarCover.runs(from: [CGRect(x: 0, y: 0, width: 10, height: 20),
+                                         CGRect(x: 100, y: 0, width: 10, height: 20)])
+    check(split.count == 2, "distant frames stay separate covers")
+
+    // Cover hides third-party apps but keeps the Apple items.
+    let hiddenApp = MenuBarItem(id: "1-0", pid: 1, appName: "cmux", title: "cmux", icon: NSImage(), frame: nil, element: element)
+    let keptWiFi = MenuBarItem(id: "2-0", pid: 2, appName: "Control Center", title: "Wi\u{2011}Fi, connected", icon: NSImage(), frame: nil, element: element)
+    let keptBattery = MenuBarItem(id: "2-1", pid: 2, appName: "Control Center", title: "Battery", icon: NSImage(), frame: nil, element: element)
+    let hiddenPlaying = MenuBarItem(id: "2-2", pid: 2, appName: "Control Center", title: "Now Playing", icon: NSImage(), frame: nil, element: element)
+    check(MenuBarCover.shouldHide(hiddenApp), "third-party apps are covered")
+    check(!MenuBarCover.shouldHide(keptWiFi), "wi-fi stays visible")
+    check(!MenuBarCover.shouldHide(keptBattery), "battery stays visible")
+    check(MenuBarCover.shouldHide(hiddenPlaying), "now playing is covered")
+
+    let converted = MenuBarCover.windowFrame(for: CGRect(x: 10, y: 0, width: 30, height: 24), primaryHeight: 1000)
+    check(converted == CGRect(x: 10, y: 976, width: 30, height: 24), "AX frame flips Y for NSWindow")
+
     let authorized = AXIsProcessTrusted()
     print("accessibility authorized=\(authorized)")
     if authorized {

Sources/SimpleTopBar/TopBarView.swift

@@ -115,7 +115,7 @@ struct TopBarView: View {
                 .controlSize(.mini)
                 .padding(.horizontal, 12)
                 .padding(.top, 6)
-                .help("Best-effort: pushes the real items off the menu bar so they only live here. Reliable when SimpleTopBar starts at login.")
+                .help("Best-effort: pushes other apps' icons off the menu bar so they only live here. Apple's Wi-Fi, Spotlight, Clock, Battery and Control Center stay visible; macOS won't let any third-party app move them.")
             }
         }
     }
@@ -245,8 +245,11 @@ private struct MenuBarTile: View {
         Button {
             menuBar.press(item)
         } label: {
-            Image(nsImage: item.appIcon)
+            // Preserve the symbol's aspect ratio: forcing wide symbols like the
+            // battery into a square stretches them into a blocky shape.
+            Image(nsImage: item.icon)
                 .resizable()
+                .scaledToFit()
                 .frame(width: 20, height: 20)
                 .padding(6)
                 .background(

build-app.sh

@@ -2,7 +2,7 @@
 set -euo pipefail
 cd "$(dirname "$0")"
 
-VERSION="${1:-0.2.0}"
+VERSION="${1:-0.2.3}"
 
 swift build -c release