Make the menu bar icon visible on a full menu bar

New status items land leftmost, which on a notched Mac lands under the
notch and is invisible, so the app appeared broken. Replace MenuBarExtra
with a managed status item that carries an autosave name and a persisted
preferred position, and add a diagnostic dump to verify placement.

💘 Generated with Crush

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

AGENTS.md

@@ -5,21 +5,42 @@ executable SwiftPM package, no external dependencies (all Apple frameworks).
 
 ## Architecture
 
-- `Sources/SimpleTopBar/App.swift` — `@main` entry. `MenuBarExtra` with
+- `Sources/SimpleTopBar/App.swift` — `@main` entry using a bare
-  `.menuBarExtraStyle(.window)` hosting `TopBarView`. `AppDelegate` handles the
+  `Settings { EmptyView() }` scene, because the app owns its status item
-  `--self-test` flag and the single-instance guard. `LoginItem` wraps
+  manually instead of using `MenuBarExtra`. `AppDelegate.setupStatusItem()`
-  `SMAppService`.
+  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`
   (both sorted by name). Subscribes to the `NSWorkspace` launch/terminate/
   activate/hide/unhide notifications to refresh automatically.
-- `Sources/SimpleTopBar/TopBarView.swift` — the panel. `section(...)` renders
+- `Sources/SimpleTopBar/TopBarView.swift` — the panel. `menuBarSection` is the
-  the regular apps; `backgroundSection` is the collapsible dropdown for
+  hamburger tray of other apps' menu bar items; `section(...)` renders the
+  regular apps; `backgroundSection` is the collapsible dropdown for
   background apps. `AppRow` shows icon + name + active dot with a right-click
   Activate/Hide/Quit menu.
+- `Sources/SimpleTopBar/MenuBarItems.swift` — `MenuBarItemManager` enumerates
+  other apps' status items via the Accessibility API (`kAXExtrasMenuBarAttribute`
+  → `kAXChildrenAttribute`) and presses them (`kAXPressAction`, falling back to
+  `kAXShowMenuAction`). `MenuBarHider` owns the zero-width spacer `NSStatusItem`
+  used to push items off the menu bar. `AccessibilityPermission` wraps
+  `AXIsProcessTrusted` / `AXIsProcessTrustedWithOptions`.
 - `Sources/SimpleTopBar/SelfTest.swift` — `runSelfTest()` powers `--self-test`.
 
+## The menu bar tray (Accessibility)
+
+- Requires Accessibility permission. `MenuBarItemManager.refresh()` short-circuits
+  to an empty list when `AXIsProcessTrusted()` is false, and `TopBarView` shows a
+  "Grant Accessibility…" button in that state. Never assume permission.
+- Enumeration must be resilient: `AXUIElementCopyAttributeValue` can fail per-app
+  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.
+- Reading another app's UI is the only TCC permission needed; there is no Screen
+  Recording or Apple Events usage.
+
 ## The background dropdown
 
 This is the core feature. Requirements:
@@ -60,6 +81,37 @@ 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).
+
 ## Gotchas
 
 - `AppListModel` is `@MainActor`; the `NSWorkspace` observers hop back with
@@ -68,7 +120,8 @@ version argument and pass the same version to `release.sh`.
   the single-instance guard terminates stale copies with the same bundle id.
 - Reading `activationPolicy` is reliable but must happen on the main thread;
   keep all `NSWorkspace` access inside the model.
-- Don't add Accessibility/Screen Recording permission code: this app only reads
+- The menu bar tray needs Accessibility permission; do not add Screen Recording
-  the running-app list, which needs no TCC grants.
+  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.
 - `.gitignore` covers `.build/`, `SimpleTopBar.app/`, `dist/` — build artifacts
   should never be committed.

README.md

@@ -1,8 +1,13 @@
 # SimpleTopBar
 
-A native macOS menu bar app that shows a compact top bar with every app that is
+A native macOS menu bar app: a **hamburger menu** in the menu bar whose panel
-running on your Mac, split into two sections:
+collects every other app's menu bar (tray) icons, plus every app running on your
+Mac, into three sections:
 
+- **Menu Bar** — a tray of all other apps' menu bar items, discovered through
+  the Accessibility API. Click one to open its real menu. Optionally **hide the
+  items from the menu bar** so they only live inside this panel (best-effort;
+  see below).
 - **Apps** — regular apps that live in the Dock.
 - **Background Apps** — accessory/agent apps without a Dock icon. This section
   is a **dropdown**: it stays collapsed to a single header, and when you expand
@@ -11,6 +16,23 @@ running on your Mac, split into two sections:
 
 Click any row to activate the app, or right-click for Activate / Hide / Quit.
 
+## Accessibility permission
+
+Collecting and opening other apps' menu bar items needs **Accessibility**
+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)
+
+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.
+
 ## Install with Homebrew
 
 ```bash
@@ -22,14 +44,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
+./build-app.sh 0.2.0        # release build + SimpleTopBar.app bundle + icon + codesign
-./release.sh 0.1.0          # build-app.sh + dist/SimpleTopBar.zip + sha256
+./release.sh 0.2.0          # build-app.sh + dist/SimpleTopBar.zip + sha256
 ```
 
 ## Around the Background dropdown

Sources/SimpleTopBar/App.swift

@@ -7,20 +7,31 @@ struct SimpleTopBarApp: App {
     @NSApplicationDelegateAdaptor(AppDelegate.self) private var appDelegate
 
     var body: some Scene {
-        MenuBarExtra("SimpleTopBar", systemImage: "menubar.rectangle") {
+        // The app is a menu bar extra, so it has no real windows.
-            TopBarView(model: AppListModel.shared)
+        Settings { EmptyView() }
-        }
-        .menuBarExtraStyle(.window)
     }
 }
 
+/// 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
@@ -31,6 +42,76 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         }
 
         AppListModel.shared.start()
+        MenuBarItemManager.shared.start()
+        MenuBarHider.shared.prepare()
+        setupStatusItem()
+
+        if CommandLine.arguments.contains("--diag") {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 2.5) {
+                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()
+        }
     }
 }
 

Sources/SimpleTopBar/MenuBarItems.swift

@@ -0,0 +1,194 @@
+import AppKit
+import ApplicationServices
+import Combine
+
+/// One live menu bar (status/tray) item discovered via the Accessibility API.
+struct MenuBarItem: Identifiable, Equatable {
+    let id: String
+    let pid: pid_t
+    let appName: String
+    let title: String
+    let appIcon: NSImage
+    let element: AXUIElement
+
+    static func == (lhs: MenuBarItem, rhs: MenuBarItem) -> Bool {
+        lhs.id == rhs.id && lhs.title == rhs.title
+    }
+}
+
+/// Enumerates every other app's menu bar items so they can be shown (and
+/// pressed) from SimpleTopBar's hamburger panel. Requires Accessibility
+/// permission; without it the list is empty.
+@MainActor
+final class MenuBarItemManager: ObservableObject {
+    static let shared = MenuBarItemManager()
+
+    @Published private(set) var items: [MenuBarItem] = []
+    @Published private(set) var authorized = AXIsProcessTrusted()
+
+    private var observers: [NSObjectProtocol] = []
+
+    private init() {}
+
+    func start() {
+        authorized = AXIsProcessTrusted()
+        refresh()
+        let center = NSWorkspace.shared.notificationCenter
+        let names: [Notification.Name] = [
+            NSWorkspace.didLaunchApplicationNotification,
+            NSWorkspace.didTerminateApplicationNotification,
+            NSWorkspace.didActivateApplicationNotification,
+            NSWorkspace.didHideApplicationNotification,
+            NSWorkspace.didUnhideApplicationNotification,
+        ]
+        for name in names {
+            observers.append(center.addObserver(forName: name, object: nil, queue: .main) { [weak self] _ in
+                Task { @MainActor in self?.refresh() }
+            })
+        }
+    }
+
+    func refresh() {
+        authorized = AXIsProcessTrusted()
+        guard authorized else {
+            items = []
+            return
+        }
+        items = Self.enumerate()
+    }
+
+    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 !includeOwn && pid == ownPID { continue }
+            let axApp = AXUIElementCreateApplication(pid)
+            guard let bar = extrasMenuBar(of: axApp),
+                  let children = children(of: bar) else { continue }
+
+            for (index, child) in children.enumerated() {
+                let title = stringAttribute(child, kAXDescriptionAttribute)
+                    ?? stringAttribute(child, kAXTitleAttribute)
+                    ?? app.localizedName
+                    ?? "Item"
+                found.append(MenuBarItem(
+                    id: "\(pid)-\(index)",
+                    pid: pid,
+                    appName: app.localizedName ?? app.bundleIdentifier ?? "Unknown",
+                    title: title,
+                    appIcon: app.icon ?? NSImage(named: NSImage.applicationIconName) ?? NSImage(),
+                    element: child
+                ))
+            }
+        }
+
+        return found.sorted { a, b in
+            let byApp = a.appName.localizedCaseInsensitiveCompare(b.appName)
+            if byApp == .orderedSame { return a.title.localizedCaseInsensitiveCompare(b.title) == .orderedAscending }
+            return byApp == .orderedAscending
+        }
+    }
+
+    /// 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 {
+        if AXUIElementPerformAction(item.element, kAXPressAction as CFString) == .success {
+            return true
+        }
+        return AXUIElementPerformAction(item.element, kAXShowMenuAction as CFString) == .success
+    }
+
+    // MARK: - AX helpers
+
+    nonisolated static func extrasMenuBar(of app: AXUIElement) -> AXUIElement? {
+        var value: CFTypeRef?
+        guard AXUIElementCopyAttributeValue(app, kAXExtrasMenuBarAttribute as CFString, &value) == .success,
+              let value,
+              CFGetTypeID(value) == AXUIElementGetTypeID() else { return nil }
+        return (value as! AXUIElement)
+    }
+
+    nonisolated static func children(of element: AXUIElement) -> [AXUIElement]? {
+        var value: CFTypeRef?
+        guard AXUIElementCopyAttributeValue(element, kAXChildrenAttribute as CFString, &value) == .success else {
+            return nil
+        }
+        return value as? [AXUIElement]
+    }
+
+    nonisolated static func stringAttribute(_ element: AXUIElement, _ attribute: String) -> String? {
+        var value: CFTypeRef?
+        guard AXUIElementCopyAttributeValue(element, attribute as CFString, &value) == .success,
+              let string = value as? String,
+              !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
+    }
+}
+
+/// 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.
+@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
+
+    @Published private(set) var isHiding = false
+    @Published var enabled = false {
+        didSet {
+            guard enabled != oldValue else { return }
+            apply(enabled)
+        }
+    }
+
+    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 func apply(_ hiding: Bool) {
+        prepare()
+        spacer?.length = hiding ? Self.hiddenLength : 0
+        isHiding = hiding
+    }
+
+    /// Put the menu bar back the way we found it. Called on quit.
+    func restore() {
+        spacer?.length = 0
+        isHiding = false
+        enabled = false
+    }
+}
+
+enum AccessibilityPermission {
+    static var isGranted: Bool { AXIsProcessTrusted() }
+
+    static func request() {
+        let options = [kAXTrustedCheckOptionPrompt.takeUnretainedValue() as String: true] as CFDictionary
+        _ = AXIsProcessTrustedWithOptions(options)
+    }
+}

Sources/SimpleTopBar/SelfTest.swift

@@ -1,4 +1,32 @@
 import AppKit
+import ApplicationServices
+
+/// 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
@@ -45,6 +73,25 @@ func runSelfTest() {
     print("running=\(running.count) regular=\(regular) background=\(background)")
     check(regular + background == running.count, "every running app is classified")
 
+    // Menu bar item discovery degrades gracefully when it cannot read another
+    // app's UI (accessibility not granted, or the element has no extras bar).
+    let systemWide = AXUIElementCreateSystemWide()
+    check(MenuBarItemManager.extrasMenuBar(of: systemWide) == nil, "no extras bar on a non-app element")
+    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)
+    check(first == same, "menu bar items compare by id and title")
+    check(first != different, "different ids are not equal")
+
+    let authorized = AXIsProcessTrusted()
+    print("accessibility authorized=\(authorized)")
+    if authorized {
+        print("menu bar items discovered=\(MenuBarItemManager.enumerate().count)")
+    }
+
     print(failures == 0 ? "ALL PASS" : "\(failures) FAILURE(S)")
     exit(failures == 0 ? 0 : 1)
 }

Sources/SimpleTopBar/TopBarView.swift

@@ -1,9 +1,11 @@
 import SwiftUI
 import AppKit
 
-/// The top bar panel shown from the menu bar icon.
+/// The top bar panel shown from the menu bar hamburger icon.
 struct TopBarView: View {
     @ObservedObject var model: AppListModel
+    @ObservedObject var menuBar: MenuBarItemManager
+    @ObservedObject var hider: MenuBarHider
 
     var body: some View {
         VStack(spacing: 0) {
@@ -11,6 +13,10 @@ struct TopBarView: View {
             Divider()
             ScrollView {
                 VStack(alignment: .leading, spacing: 0) {
+                    menuBarSection
+
+                    Divider().padding(.vertical, 4)
+
                     section(title: "Apps", apps: model.regularApps, emptyText: "No apps running")
 
                     Divider().padding(.vertical, 4)
@@ -19,23 +25,28 @@ struct TopBarView: View {
                 }
                 .padding(.vertical, 4)
             }
-            .frame(maxHeight: 360)
+            .frame(maxHeight: 420)
 
             Divider()
             footer
         }
         .frame(width: 320)
+        .onAppear {
+            model.refresh()
+            menuBar.refresh()
+        }
     }
 
     private var header: some View {
         HStack(spacing: 8) {
-            Image(systemName: "menubar.rectangle")
+            Image(systemName: "line.3.horizontal")
                 .foregroundStyle(.secondary)
             Text("SimpleTopBar")
                 .font(.headline)
             Spacer()
             Button {
                 model.refresh()
+                menuBar.refresh()
             } label: {
                 Image(systemName: "arrow.clockwise")
             }
@@ -46,6 +57,69 @@ struct TopBarView: View {
         .padding(.vertical, 8)
     }
 
+    /// The hamburger tray: every other app's menu bar item lives here.
+    private var menuBarSection: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            HStack(spacing: 6) {
+                Text("MENU BAR")
+                    .font(.caption2)
+                    .fontWeight(.semibold)
+                    .foregroundStyle(.secondary)
+                Spacer()
+                Text("\(menuBar.items.count)")
+                    .font(.caption2)
+                    .foregroundStyle(.tertiary)
+                    .padding(.horizontal, 6)
+                    .padding(.vertical, 1)
+                    .background(Capsule().fill(Color.secondary.opacity(0.15)))
+            }
+            .padding(.horizontal, 12)
+            .padding(.top, 4)
+            .padding(.bottom, 4)
+
+            if !menuBar.authorized {
+                VStack(alignment: .leading, spacing: 4) {
+                    Text("Grant Accessibility to collect and open menu bar items.")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                    Button("Grant Accessibility…") {
+                        AccessibilityPermission.request()
+                        menuBar.refresh()
+                    }
+                    .buttonStyle(.borderedProminent)
+                    .controlSize(.small)
+                }
+                .padding(.horizontal, 12)
+                .padding(.vertical, 4)
+            } else if menuBar.items.isEmpty {
+                Text("No menu bar items found")
+                    .font(.caption)
+                    .foregroundStyle(.tertiary)
+                    .padding(.horizontal, 12)
+                    .padding(.vertical, 4)
+            } else {
+                LazyVGrid(columns: [GridItem(.adaptive(minimum: 34), spacing: 6)], spacing: 6) {
+                    ForEach(menuBar.items) { item in
+                        MenuBarTile(item: item, menuBar: menuBar)
+                    }
+                }
+                .padding(.horizontal, 12)
+            }
+
+            if menuBar.authorized {
+                Toggle(isOn: $hider.enabled) {
+                    Text("Hide items from the menu bar")
+                        .font(.caption)
+                }
+                .toggleStyle(.switch)
+                .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.")
+            }
+        }
+    }
+
     private func section(title: String, apps: [RunningApp], emptyText: String) -> some View {
         VStack(alignment: .leading, spacing: 0) {
             Text(title.uppercased())
@@ -163,6 +237,28 @@ struct TopBarView: View {
     }
 }
 
+private struct MenuBarTile: View {
+    let item: MenuBarItem
+    @ObservedObject var menuBar: MenuBarItemManager
+
+    var body: some View {
+        Button {
+            menuBar.press(item)
+        } label: {
+            Image(nsImage: item.appIcon)
+                .resizable()
+                .frame(width: 20, height: 20)
+                .padding(6)
+                .background(
+                    RoundedRectangle(cornerRadius: 6)
+                        .fill(Color.secondary.opacity(0.12))
+                )
+        }
+        .buttonStyle(.plain)
+        .help("\(item.appName) — \(item.title)")
+    }
+}
+
 private struct AppRow: View {
     let app: RunningApp
     @ObservedObject var model: AppListModel

build-app.sh

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