agentbridge-cli 0.1.12__tar.gz → 0.1.13__tar.gz

{agentbridge_cli-0.1.12 → agentbridge_cli-0.1.13}/.codex/skills/build-release/SKILL.md

@@ -9,8 +9,7 @@ Use the repository-owned GitHub Actions workflow and PyPI Trusted Publishing.
 Do not create a local tag or upload with local credentials: pushing a new
 `pyproject.toml` version to `main` triggers `.github/workflows/release.yml`,
 which tests, scans, builds, creates `v<version>`, creates the GitHub Release,
-publishes `agentbridge-cli`, and, when macOS publishing is enabled, attaches
-signed and notarized arm64 and x86_64 DMGs.
+publishes `agentbridge-cli`, and attaches ad-hoc-signed arm64 and x86_64 DMGs.
 
 Use the next unused patch version unless the user requests another valid,
 unused semantic version. Treat an untagged version absent from PyPI as pending.
@@ -29,12 +28,8 @@ git log --oneline HEAD..origin/main
 Stop on unrelated changes, unpublished commits, divergence, or another branch.
 Do not clean, pull, commit unrelated files, or switch branches.
 
-Require the repository variable `MACOS_RELEASE_ENABLED` to be `true` and verify
-that these Actions secrets are configured before a release expected to contain
-the macOS app: `APPLE_CERTIFICATE_BASE64`, `APPLE_CERTIFICATE_PASSWORD`,
-`APPLE_KEYCHAIN_PASSWORD`, `APPLE_NOTARY_APPLE_ID`, `APPLE_NOTARY_PASSWORD`, and
-`APPLE_TEAM_ID`. Secret names may be inspected with `gh secret list`; never read
-or print secret values.
+The macOS artifacts use an ad-hoc signature and are not notarized. They do not
+require Apple Developer credentials or repository secrets.
 
 2. Select the release version from the repository root:
 
@@ -59,8 +54,8 @@ The preflight requires macOS. It checks consistent project and lock metadata, an
 unused PyPI version and tag, clean patch formatting, a frozen lock, Python 3.12
 and 3.13 tests, Ruff, Swift tests, a self-contained app/DMG build for the current
 Mac architecture, app signature and embedded-runtime smoke tests, wheel and
-sdist audits, and a wheel installation smoke test. CI builds and notarizes both
-macOS architectures. Stop at the exact failed gate.
+sdist audits, and a wheel installation smoke test. CI builds both macOS
+architectures with ad-hoc signatures. Stop at the exact failed gate.
 
 4. Review and publish the release commit:
 
@@ -97,7 +92,7 @@ python3 .codex/skills/build-release/scripts/release_build.py wait-pypi --version
 gh release view v<version> --json url,tagName,assets
 ```
 
-When macOS publishing is enabled, require both
+Require both
 `AgentBridge-<version>-macos-arm64.dmg` and
 `AgentBridge-<version>-macos-x86_64.dmg` plus their `.sha256` files in the
 release assets. Do not report success until PyPI returns exact-version files and
@@ -105,6 +100,13 @@ all required GitHub assets exist. If the workflow fails, inspect
 `gh run view <run-id> --log-failed` and report the failed gate before considering
 recovery.
 
+If an existing release is missing only its macOS assets, attach them without
+republishing Python distributions:
+
+```bash
+gh workflow run release.yml --ref main -f attach_macos=true
+```
+
 ## Final Response
 
 Lead with the exact PyPI version URL. Report the tag, release workflow URL and

{agentbridge_cli-0.1.12 → agentbridge_cli-0.1.13}/.github/workflows/release.yml

@@ -8,6 +8,11 @@ on:
         required: false
         default: false
         type: boolean
+      attach_macos:
+        description: Build and attach macOS DMGs to the current version's existing release
+        required: false
+        default: false
+        type: boolean
   push:
     branches: [main]
     paths:
@@ -200,8 +205,9 @@ jobs:
   macos-app:
     needs: [build]
     if: >-
-      needs.build.outputs.publish == 'true' &&
-      vars.MACOS_RELEASE_ENABLED == 'true'
+      always() &&
+      (needs.build.outputs.publish == 'true' ||
+      (github.event_name == 'workflow_dispatch' && inputs.attach_macos == true))
     strategy:
       fail-fast: false
       matrix:
@@ -225,57 +231,10 @@ jobs:
           cache-dependency-glob: "uv.lock"
       - name: Install Python 3.12
         run: uv python install 3.12
-      - name: Import Developer ID certificate
-        env:
-          APPLE_CERTIFICATE_BASE64: ${{ secrets.APPLE_CERTIFICATE_BASE64 }}
-          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-          KEYCHAIN_PASSWORD: ${{ secrets.APPLE_KEYCHAIN_PASSWORD }}
-        shell: bash
-        run: |
-          certificate_path="$RUNNER_TEMP/developer-id.p12"
-          keychain_path="$RUNNER_TEMP/agentbridge-signing.keychain-db"
-          echo "$APPLE_CERTIFICATE_BASE64" | base64 -D > "$certificate_path"
-          security create-keychain -p "$KEYCHAIN_PASSWORD" "$keychain_path"
-          security set-keychain-settings -lut 21600 "$keychain_path"
-          security unlock-keychain -p "$KEYCHAIN_PASSWORD" "$keychain_path"
-          security import "$certificate_path" \
-            -P "$APPLE_CERTIFICATE_PASSWORD" \
-            -A \
-            -t cert \
-            -f pkcs12 \
-            -k "$keychain_path"
-          security list-keychain -d user -s "$keychain_path"
-          security set-key-partition-list \
-            -S apple-tool:,apple: \
-            -s \
-            -k "$KEYCHAIN_PASSWORD" \
-            "$keychain_path"
-          identity="$(security find-identity -v -p codesigning "$keychain_path" \
-            | sed -n 's/.*"\(Developer ID Application:.*\)"/\1/p' \
-            | head -1)"
-          test -n "$identity"
-          echo "CODE_SIGN_IDENTITY=$identity" >> "$GITHUB_ENV"
-      - name: Build signed application
+      - name: Build ad-hoc-signed application
         run: scripts/build_macos_app.sh
       - name: Verify embedded application
         run: scripts/verify_macos_app.sh "build/macos/${{ matrix.architecture }}/AgentBridge.app"
-      - name: Notarize and staple disk image
-        env:
-          APPLE_ID: ${{ secrets.APPLE_NOTARY_APPLE_ID }}
-          APPLE_APP_PASSWORD: ${{ secrets.APPLE_NOTARY_PASSWORD }}
-          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-        shell: bash
-        run: |
-          dmg="$(find "build/macos/${{ matrix.architecture }}" -maxdepth 1 -name '*.dmg' -print -quit)"
-          test -n "$dmg"
-          xcrun notarytool submit "$dmg" \
-            --apple-id "$APPLE_ID" \
-            --password "$APPLE_APP_PASSWORD" \
-            --team-id "$APPLE_TEAM_ID" \
-            --wait
-          xcrun stapler staple "$dmg"
-          xcrun stapler validate "$dmg"
-          shasum -a 256 "$dmg" > "$dmg.sha256"
       - name: Store macOS artifacts
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
@@ -292,7 +251,7 @@ jobs:
       always() &&
       needs.build.outputs.publish == 'true' &&
       needs.publish.result == 'success' &&
-      (needs.macos-app.result == 'success' || needs.macos-app.result == 'skipped')
+      needs.macos-app.result == 'success'
     runs-on: ubuntu-latest
     timeout-minutes: 10
     permissions:
@@ -304,7 +263,6 @@ jobs:
           name: python-package-${{ github.sha }}
           path: dist/
       - name: Download macOS artifacts
-        if: needs.macos-app.result == 'success'
         uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           pattern: macos-app-*-${{ github.sha }}
@@ -317,6 +275,44 @@ jobs:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           TAG: ${{ needs.build.outputs.tag }}
 
+  attach-macos:
+    needs: [macos-app]
+    if: >-
+      always() &&
+      github.event_name == 'workflow_dispatch' &&
+      inputs.attach_macos == true &&
+      needs.macos-app.result == 'success'
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - name: Download macOS artifacts
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          pattern: macos-app-*-${{ github.sha }}
+          path: dist/
+          merge-multiple: true
+      - name: Attach DMGs to the existing release
+        shell: bash
+        run: |
+          version="$(python - <<'PY'
+          import tomllib
+
+          with open("pyproject.toml", "rb") as pyproject_file:
+              print(tomllib.load(pyproject_file)["project"]["version"])
+          PY
+          )"
+          tag="v${version}"
+          gh release view "$tag" >/dev/null
+          gh release upload "$tag" dist/* --clobber
+        env:
+          GH_REPO: ${{ github.repository }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
   publish:
     needs: [build]
     if: needs.build.outputs.publish == 'true'

{agentbridge_cli-0.1.12 → agentbridge_cli-0.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentbridge-cli
-Version: 0.1.12
+Version: 0.1.13
 Summary: Bridge OpenAI tools to Claude Code SDK, Codex CLI, and OpenRouter
 Project-URL: Homepage, https://github.com/tsilva/agentbridge
 Project-URL: Repository, https://github.com/tsilva/agentbridge
@@ -46,9 +46,14 @@ It supports streaming and non-streaming responses, image and PDF inputs where th
 
 ### macOS menu-bar app
 
-Build the app locally on macOS 13 or later. This requires
-[uv](https://docs.astral.sh/uv/) and the Xcode Command Line Tools, but it does
-not require an Apple Developer account:
+Download the DMG for your Mac architecture from the GitHub Release, drag
+`AgentBridge.app` to Applications, and open it. The app is ad-hoc signed rather
+than Apple-notarized, so on first launch macOS may require you to Control-click
+the app, choose **Open**, and confirm.
+
+You can also build the app locally on macOS 13 or later. This requires
+[uv](https://docs.astral.sh/uv/) and the Xcode Command Line Tools, but not an
+Apple Developer account:
 
 ```bash
 git clone https://github.com/tsilva/agentbridge.git
@@ -57,10 +62,10 @@ scripts/build_macos_app.sh
 open "build/macos/$(uname -m)/AgentBridge-"*.dmg
 ```
 
-Drag `AgentBridge.app` to Applications and open it. The menu-bar window shows
-live server health and activity, starts and stops the local server, opens the
-dashboard, and provides settings for the port, worker count, and launch at
-login. See [`macos/README.md`](macos/README.md) for development instructions.
+The menu-bar window shows live server health and activity, starts and stops the
+local server, opens the dashboard, and provides settings for the port, worker
+count, and launch at login. See [`macos/README.md`](macos/README.md) for
+development instructions.
 
 The app contains its own Python 3.12 runtime and AgentBridge dependencies. It
 does not bundle the Claude Code or Codex executables: installed provider tools
@@ -179,9 +184,11 @@ uv build                                              # build wheel and source d
 Releases use the `Release` GitHub Actions workflow and PyPI Trusted Publishing
 for the `agentbridge-cli` project. The publisher is scoped to owner `tsilva`,
 repository `agentbridge`, workflow `release.yml`, and environment `pypi`; no
-PyPI API token is required. GitHub Releases contain the Python distributions;
-the macOS app is tested in CI and built locally from source. Releases through
-`0.1.10` remain available under the previous `agentbridge-py` distribution name.
+PyPI API token is required. GitHub Releases contain the Python distributions
+plus ad-hoc-signed arm64 and x86_64 macOS DMGs and SHA-256 checksums. These DMGs
+are not Apple-notarized and require no Apple Developer credentials. Releases
+through `0.1.10` remain available under the previous `agentbridge-py`
+distribution name.
 
 ## Architecture
 

{agentbridge_cli-0.1.12 → agentbridge_cli-0.1.13}/README.md

@@ -14,9 +14,14 @@ It supports streaming and non-streaming responses, image and PDF inputs where th
 
 ### macOS menu-bar app
 
-Build the app locally on macOS 13 or later. This requires
-[uv](https://docs.astral.sh/uv/) and the Xcode Command Line Tools, but it does
-not require an Apple Developer account:
+Download the DMG for your Mac architecture from the GitHub Release, drag
+`AgentBridge.app` to Applications, and open it. The app is ad-hoc signed rather
+than Apple-notarized, so on first launch macOS may require you to Control-click
+the app, choose **Open**, and confirm.
+
+You can also build the app locally on macOS 13 or later. This requires
+[uv](https://docs.astral.sh/uv/) and the Xcode Command Line Tools, but not an
+Apple Developer account:
 
 ```bash
 git clone https://github.com/tsilva/agentbridge.git
@@ -25,10 +30,10 @@ scripts/build_macos_app.sh
 open "build/macos/$(uname -m)/AgentBridge-"*.dmg
 ```
 
-Drag `AgentBridge.app` to Applications and open it. The menu-bar window shows
-live server health and activity, starts and stops the local server, opens the
-dashboard, and provides settings for the port, worker count, and launch at
-login. See [`macos/README.md`](macos/README.md) for development instructions.
+The menu-bar window shows live server health and activity, starts and stops the
+local server, opens the dashboard, and provides settings for the port, worker
+count, and launch at login. See [`macos/README.md`](macos/README.md) for
+development instructions.
 
 The app contains its own Python 3.12 runtime and AgentBridge dependencies. It
 does not bundle the Claude Code or Codex executables: installed provider tools
@@ -147,9 +152,11 @@ uv build                                              # build wheel and source d
 Releases use the `Release` GitHub Actions workflow and PyPI Trusted Publishing
 for the `agentbridge-cli` project. The publisher is scoped to owner `tsilva`,
 repository `agentbridge`, workflow `release.yml`, and environment `pypi`; no
-PyPI API token is required. GitHub Releases contain the Python distributions;
-the macOS app is tested in CI and built locally from source. Releases through
-`0.1.10` remain available under the previous `agentbridge-py` distribution name.
+PyPI API token is required. GitHub Releases contain the Python distributions
+plus ad-hoc-signed arm64 and x86_64 macOS DMGs and SHA-256 checksums. These DMGs
+are not Apple-notarized and require no Apple Developer credentials. Releases
+through `0.1.10` remain available under the previous `agentbridge-py`
+distribution name.
 
 ## Architecture
 

agentbridge_cli-0.1.13/agentbridge/_build_info.py

@@ -0,0 +1 @@
+GIT_HASH = "6918a70"

agentbridge_cli-0.1.13/design-qa.md

@@ -0,0 +1,58 @@
+# Active-worker menu-bar badge and inactive brightness design QA
+
+## Evidence
+
+- Source visual truths:
+  - Badge proportions: `/var/folders/wz/x29jb7_x5rdc_5dcjr4qnhg00000gn/T/codex-clipboard-a88e73a8-8b49-415b-b2ef-9f289e13c5ea.png`
+  - Unfocused menu-bar brightness: `/var/folders/wz/x29jb7_x5rdc_5dcjr4qnhg00000gn/T/codex-clipboard-6c362e7b-d087-493b-8d8f-683607e7a420.png`
+  - Inner-arrow contrast: `/var/folders/wz/x29jb7_x5rdc_5dcjr4qnhg00000gn/T/codex-clipboard-7fb76339-7c5e-4568-98cf-3c91d8ad0f48.png`
+- Source pixels: 208 × 62 for the badge reference, 3232 × 76 for the unfocused menu-bar reference, and 260 × 58 for the inner-arrow reference, all at Retina density. Focused item crops retain their original 2× scale.
+- Implementation screenshots:
+  - Active state: `/Users/tsilva/repos/tsilva/agentbridge/design-qa/status-item-active-workers.png`
+  - Zero state: `/Users/tsilva/repos/tsilva/agentbridge/design-qa/status-item-no-workers.png`
+- Implementation pixels: 96 × 62 for a 48 × 31-point native AppKit fixture at 2× density.
+- Viewport: native macOS status-item button, 32 × 22 points inside a 48 × 31-point menu-bar crop.
+- Density normalization: the 64 × 62 source crop was centered on a 96 × 62 canvas without scaling so both sides retain 2× density.
+- State: dark, unfocused-style menu bar with 48 active workers for visual fidelity; running server with zero active workers for empty-state verification.
+- Combined comparisons:
+  - Badge proportions: `/Users/tsilva/repos/tsilva/agentbridge/design-qa/status-item-badge-comparison.png`
+  - Unfocused brightness: `/Users/tsilva/repos/tsilva/agentbridge/design-qa/status-item-inactive-comparison.png`
+  - Inner-arrow contrast before/after: `/Users/tsilva/repos/tsilva/agentbridge/design-qa/status-item-arrow-contrast-comparison.png`
+
+## Findings
+
+- No actionable P0/P1/P2 differences remain.
+- Fonts and typography: the badge uses a 7.5-point semibold native system font; the two-digit weight and density match the compact Telegram reference without crowding.
+- Spacing and layout rhythm: the 11-point capsule sits at the lower trailing edge of the existing icon, with the source-like overlap and enough of AgentBridge's mark remaining visible.
+- Colors and visual tokens: the badge uses the current semantic label color at 48% opacity and automatically reverses its number color for light and dark appearances. The main mark uses an appearance-aware label-color palette without template dimming, keeping it bright on an unfocused display like Telegram. Filled status symbols now use a contrasting secondary palette layer: translucent black arrows in dark appearance and translucent white detail in light appearance.
+- Image quality and asset fidelity: the existing SF Symbol remains native but is rendered as a non-template, appearance-aware image so AppKit does not mute it with inactive template tinting. The badge is rendered natively at Retina density with no raster replacement or custom icon asset.
+- Copy and content: the visible badge is the exact live active-worker number. The button tooltip and accessibility label include the same count with correct singular/plural wording.
+- Empty state: the zero-state rendering shows only the AgentBridge icon; no empty capsule or numeric badge remains.
+
+The full menu-bar reference establishes the inactive-display context and Telegram's brighter mark. The component capture is the complete implementation viewport for this isolated status item. Focused comparisons confirm capsule size, opacity, number weight, overlap, the brighter main-icon treatment, and clear separation between the outer circle and inner arrows.
+
+## Comparison History
+
+1. The first active-state rendering used a 14-point badge with wider padding. It obscured most of the circular AgentBridge symbol and was visibly larger and lighter than the Telegram badge.
+2. The badge was reduced to 11 points, its type and horizontal padding were tightened, and label opacity was lowered from 68% to 48%. The revised combined comparison shows matching compact proportions and tone, while the zero-state capture confirms complete badge removal.
+3. The inactive-display reference showed AppKit's template tint making AgentBridge materially dimmer than Telegram. The symbol now uses an appearance-aware palette and is explicitly non-template; the revised dark-appearance capture shows the bright main mark while retaining the subdued badge.
+4. The first bright non-template render gave the circle and arrows nearly identical light values, making the arrows hard to perceive. Filled symbols now use a two-color palette with 68%-opaque black inner detail in dark appearance; the before/after comparison shows clear arrow contrast. Outline-only stopped and transitional symbols retain a single semantic label color so they remain visible.
+
+## Implementation Checklist
+
+- [x] Observe live health-count changes in addition to server-phase changes.
+- [x] Show the exact active-worker count in a compact native badge.
+- [x] Hide the badge at zero.
+- [x] Keep the main icon bright instead of accepting inactive template dimming.
+- [x] Preserve appearance-aware light/dark coloring.
+- [x] Give filled symbols contrasting inner detail without darkening outline-only states.
+- [x] Preserve status-item click behavior.
+- [x] Include the count in tooltip and accessibility text.
+- [x] Verify active and zero states with Retina component captures.
+- [x] Pass Swift unit tests and a release build.
+
+## Follow-up Polish
+
+- None.
+
+final result: passed

{agentbridge_cli-0.1.12 → agentbridge_cli-0.1.13}/macos/README.md

@@ -38,6 +38,10 @@ require an Apple Developer account.
 
 Open the generated DMG and drag `AgentBridge.app` to Applications.
 
+GitHub Releases provide the same ad-hoc-signed DMG for arm64 and x86_64 Macs.
+They are not Apple-notarized, so macOS may require you to Control-click the app,
+choose **Open**, and confirm on first launch.
+
 Mutable data stays outside the application bundle:
 
 ```text

{agentbridge_cli-0.1.12 → agentbridge_cli-0.1.13}/macos/Sources/AgentBridgeMenuBar/AgentBridgeMenuBarApp.swift

@@ -26,8 +26,9 @@ struct AgentBridgeMenuBarApp: App {
 final class AgentBridgeAppDelegate: NSObject, NSApplicationDelegate {
     private let controller = ServerController()
     private let popover = NSPopover()
+    private let statusPresenter = MenuBarStatusPresenter()
     private var statusItem: NSStatusItem?
-    private var phaseObservation: AnyCancellable?
+    private var statusObservation: AnyCancellable?
     #if DEBUG
     private var debugAnchorWindow: NSWindow?
     #endif
@@ -39,18 +40,26 @@ final class AgentBridgeAppDelegate: NSObject, NSApplicationDelegate {
         if let button = item.button {
             button.target = self
             button.action = #selector(togglePopover(_:))
+            statusPresenter.install(on: button)
+            statusPresenter.update(
+                button: button,
+                phase: controller.phase,
+                activeWorkers: controller.activeRequests
+            )
         }
-        updateStatusItem(for: controller.phase)
 
         let host = NSHostingController(rootView: StatusPopover(controller: controller))
         popover.contentViewController = host
         popover.behavior = .transient
         popover.animates = true
 
-        phaseObservation = controller.$phase
+        statusObservation = Publishers.CombineLatest(controller.$phase, controller.$health)
             .receive(on: RunLoop.main)
-            .sink { [weak self] phase in
-                self?.updateStatusItem(for: phase)
+            .sink { [weak self] phase, health in
+                self?.updateStatusItem(
+                    for: phase,
+                    activeWorkers: health?.activeRequests ?? 0
+                )
             }
 
         controller.begin()
@@ -84,17 +93,13 @@ final class AgentBridgeAppDelegate: NSObject, NSApplicationDelegate {
         }
     }
 
-    private func updateStatusItem(for phase: ServerPhase) {
+    private func updateStatusItem(for phase: ServerPhase, activeWorkers: Int) {
         guard let button = statusItem?.button else { return }
-        let label = "AgentBridge: \(phase.label)"
-        let image = NSImage(
-            systemSymbolName: phase.menuBarSymbol,
-            accessibilityDescription: label
+        statusPresenter.update(
+            button: button,
+            phase: phase,
+            activeWorkers: activeWorkers
         )
-        image?.isTemplate = true
-        button.image = image
-        button.toolTip = label
-        button.setAccessibilityLabel(label)
     }
 
     #if DEBUG

agentbridge_cli-0.1.13/macos/Sources/AgentBridgeMenuBar/MenuBarStatusPresenter.swift

@@ -0,0 +1,135 @@
+import AppKit
+
+@MainActor
+final class MenuBarStatusPresenter {
+    let badgeView = MenuBarActivityBadgeView()
+
+    func install(on button: NSStatusBarButton) {
+        guard badgeView.superview !== button else { return }
+
+        badgeView.translatesAutoresizingMaskIntoConstraints = false
+        button.addSubview(badgeView)
+        NSLayoutConstraint.activate([
+            badgeView.trailingAnchor.constraint(equalTo: button.trailingAnchor),
+            badgeView.bottomAnchor.constraint(equalTo: button.bottomAnchor, constant: 2),
+            badgeView.heightAnchor.constraint(equalToConstant: 11),
+        ])
+    }
+
+    func update(
+        button: NSStatusBarButton,
+        phase: ServerPhase,
+        activeWorkers: Int
+    ) {
+        let count = max(activeWorkers, 0)
+        let label = Self.accessibilityLabel(for: phase, activeWorkers: count)
+        let baseImage = NSImage(
+            systemSymbolName: phase.menuBarSymbol,
+            accessibilityDescription: label
+        )
+        let appearance = button.effectiveAppearance.bestMatch(from: [.darkAqua, .aqua])
+        let symbolDetailColor = appearance == .darkAqua
+            ? NSColor.black.withAlphaComponent(0.68)
+            : NSColor.white.withAlphaComponent(0.88)
+        let paletteColors: [NSColor]
+        switch phase {
+        case .runningManaged, .runningExternal, .conflict, .failed:
+            paletteColors = [symbolDetailColor, .labelColor]
+        case .starting, .stopping, .stopped:
+            paletteColors = [.labelColor]
+        }
+        let colorConfiguration = NSImage.SymbolConfiguration(
+            paletteColors: paletteColors
+        )
+        let image = baseImage?.withSymbolConfiguration(colorConfiguration) ?? baseImage
+        image?.isTemplate = false
+        button.image = image
+        button.toolTip = label
+        button.setAccessibilityLabel(label)
+        badgeView.update(count: count)
+    }
+
+    static func accessibilityLabel(for phase: ServerPhase, activeWorkers: Int) -> String {
+        guard activeWorkers > 0 else { return "AgentBridge: \(phase.label)" }
+        let noun = activeWorkers == 1 ? "worker" : "workers"
+        return "AgentBridge: \(phase.label), \(activeWorkers) active \(noun)"
+    }
+}
+
+@MainActor
+final class MenuBarActivityBadgeView: NSView {
+    private let countLabel = NSTextField(labelWithString: "")
+
+    private(set) var displayedCount: Int?
+
+    override init(frame frameRect: NSRect) {
+        super.init(frame: frameRect)
+        configureView()
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        configureView()
+    }
+
+    override var intrinsicContentSize: NSSize {
+        let labelWidth = ceil(countLabel.intrinsicContentSize.width)
+        return NSSize(width: max(11, labelWidth + 1.5), height: 11)
+    }
+
+    override func hitTest(_ point: NSPoint) -> NSView? {
+        nil
+    }
+
+    override func viewDidChangeEffectiveAppearance() {
+        super.viewDidChangeEffectiveAppearance()
+        updateColors()
+    }
+
+    func update(count: Int) {
+        guard count > 0 else {
+            displayedCount = nil
+            countLabel.stringValue = ""
+            isHidden = true
+            invalidateIntrinsicContentSize()
+            return
+        }
+
+        displayedCount = count
+        countLabel.stringValue = String(count)
+        isHidden = false
+        invalidateIntrinsicContentSize()
+    }
+
+    private func configureView() {
+        wantsLayer = true
+        layer?.cornerRadius = 5.5
+        layer?.cornerCurve = .continuous
+
+        countLabel.translatesAutoresizingMaskIntoConstraints = false
+        countLabel.font = .systemFont(ofSize: 7.5, weight: .semibold)
+        countLabel.alignment = .center
+        countLabel.lineBreakMode = .byClipping
+        countLabel.maximumNumberOfLines = 1
+        addSubview(countLabel)
+
+        NSLayoutConstraint.activate([
+            countLabel.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 0.75),
+            countLabel.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -0.75),
+            countLabel.centerYAnchor.constraint(equalTo: centerYAnchor),
+        ])
+
+        setAccessibilityElement(false)
+        isHidden = true
+        updateColors()
+    }
+
+    private func updateColors() {
+        let match = effectiveAppearance.bestMatch(from: [.darkAqua, .aqua])
+        let usesDarkMenuBar = match == .darkAqua
+        layer?.backgroundColor = NSColor.labelColor.withAlphaComponent(0.48).cgColor
+        countLabel.textColor = usesDarkMenuBar
+            ? NSColor.black.withAlphaComponent(0.78)
+            : NSColor.white.withAlphaComponent(0.94)
+    }
+}

{agentbridge_cli-0.1.12 → agentbridge_cli-0.1.13}/macos/Tests/AgentBridgeMenuBarTests/StatusModelsTests.swift

@@ -1,3 +1,4 @@
+import AppKit
 import Foundation
 import XCTest
 @testable import AgentBridgeMenuBar
@@ -71,4 +72,77 @@ final class StatusModelsTests: XCTestCase {
         XCTAssertTrue(paths.contains("/Users/example/.local/bin"))
         XCTAssertTrue(paths.contains("/Users/example/.npm-global/bin"))
     }
+
+    @MainActor
+    func testMenuBarBadgeIsHiddenWithoutActiveWorkers() throws {
+        let (canvas, button, presenter) = makeMenuBarFixture(activeWorkers: 0)
+
+        XCTAssertTrue(presenter.badgeView.isHidden)
+        XCTAssertNil(presenter.badgeView.displayedCount)
+        XCTAssertEqual(button.toolTip, "AgentBridge: Running")
+
+        try writeSnapshot(
+            of: canvas,
+            requestedBy: "AGENTBRIDGE_STATUS_ITEM_ZERO_SNAPSHOT_PATH"
+        )
+    }
+
+    @MainActor
+    func testMenuBarBadgeShowsActiveWorkerCount() throws {
+        let (canvas, button, presenter) = makeMenuBarFixture(activeWorkers: 48)
+
+        XCTAssertFalse(presenter.badgeView.isHidden)
+        XCTAssertEqual(presenter.badgeView.displayedCount, 48)
+        XCTAssertEqual(button.toolTip, "AgentBridge: Running, 48 active workers")
+        XCTAssertEqual(button.image?.isTemplate, false)
+
+        try writeSnapshot(
+            of: canvas,
+            requestedBy: "AGENTBRIDGE_STATUS_ITEM_SNAPSHOT_PATH"
+        )
+    }
+
+    @MainActor
+    private func makeMenuBarFixture(
+        activeWorkers: Int
+    ) -> (NSView, NSStatusBarButton, MenuBarStatusPresenter) {
+        let canvas = NSView(frame: NSRect(x: 0, y: 0, width: 48, height: 31))
+        canvas.appearance = NSAppearance(named: .darkAqua)
+        canvas.wantsLayer = true
+        canvas.layer?.backgroundColor = NSColor(
+            calibratedRed: 0.01,
+            green: 0.22,
+            blue: 0.19,
+            alpha: 1
+        ).cgColor
+
+        let button = NSStatusBarButton(frame: NSRect(x: 8, y: 4, width: 32, height: 22))
+        button.isBordered = false
+        canvas.addSubview(button)
+        let presenter = MenuBarStatusPresenter()
+        presenter.install(on: button)
+        presenter.update(
+            button: button,
+            phase: .runningManaged,
+            activeWorkers: activeWorkers
+        )
+        return (canvas, button, presenter)
+    }
+
+    @MainActor
+    private func writeSnapshot(of view: NSView, requestedBy environmentKey: String) throws {
+        guard let snapshotPath = ProcessInfo.processInfo.environment[environmentKey] else {
+            return
+        }
+
+        view.layoutSubtreeIfNeeded()
+        let representation = try XCTUnwrap(
+            view.bitmapImageRepForCachingDisplay(in: view.bounds)
+        )
+        view.cacheDisplay(in: view.bounds, to: representation)
+        let data = try XCTUnwrap(
+            representation.representation(using: .png, properties: [:])
+        )
+        try data.write(to: URL(fileURLWithPath: snapshotPath), options: .atomic)
+    }
 }

{agentbridge_cli-0.1.12 → agentbridge_cli-0.1.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentbridge-cli"
-version = "0.1.12"
+version = "0.1.13"
 description = "Bridge OpenAI tools to Claude Code SDK, Codex CLI, and OpenRouter"
 readme = "README.md"
 license = {text = "MIT"}

{agentbridge_cli-0.1.12 → agentbridge_cli-0.1.13}/scripts/build_macos_app.sh

@@ -150,7 +150,10 @@ hdiutil create \
     -ov \
     "${dmg_path}" >/dev/null
 
-shasum -a 256 "${dmg_path}" > "${dmg_path}.sha256"
+(
+    cd "$(dirname "${dmg_path}")"
+    shasum -a 256 "$(basename "${dmg_path}")" > "$(basename "${dmg_path}").sha256"
+)
 
 echo "Application: ${app_path}"
 echo "Disk image:  ${dmg_path}"

{agentbridge_cli-0.1.12 → agentbridge_cli-0.1.13}/uv.lock

@@ -37,7 +37,7 @@ constraints = [
 
 [[package]]
 name = "agentbridge-cli"
-version = "0.1.12"
+version = "0.1.13"
 source = { editable = "." }
 dependencies = [
     { name = "claude-agent-sdk" },

agentbridge_cli-0.1.12/agentbridge/_build_info.py

@@ -1 +0,0 @@
-GIT_HASH = "738d069"

agentbridge_cli-0.1.12/design-qa.md

@@ -1,43 +0,0 @@
-# AgentBridge refresh-footer design QA
-
-## Evidence
-
-- Source visual truth: right-hand footer in `/var/folders/wz/x29jb7_x5rdc_5dcjr4qnhg00000gn/T/codex-clipboard-7372d7c5-9ea8-42d9-9f84-41b99c9c9e24.png`
-- Source pixels: 1540 × 388 at Retina density
-- Implementation: `/Applications/AgentBridge.app`
-- Implementation screenshot: pending user-provided capture
-- Viewport: native macOS status popover, 350-point content width, Retina display
-- State to capture: running server with footer showing `Updated now`
-
-## Findings
-
-- [Blocked] The revised app is built, installed, and running, but post-fix visual evidence is pending because the user requested that Computer Use not be used and will provide screenshots directly.
-- Functional structure: the icon and update label are now one plain clickable refresh control with an accessible combined label.
-- Fonts and typography: the update label now uses 13-point medium system text to match the reference's optical weight.
-- Spacing and layout rhythm: icon-to-label spacing is reduced from 12 to 9 points and the symbol is constrained to a 16-point slot, matching the compact reference grouping.
-- Colors and visual tokens: icon and label share the same semantic secondary-label color.
-- Image quality and assets: the refresh mark uses the native `arrow.clockwise` SF Symbol at 15-point regular weight; no custom-drawn asset is used.
-- Copy and content: relative update copy is unchanged and continues to show `Updated now` immediately after refresh.
-
-## Implementation Checklist
-
-- [x] Match the reference refresh symbol family.
-- [x] Match icon size and regular stroke weight.
-- [x] Tighten icon-to-label spacing.
-- [x] Increase label optical weight to medium.
-- [x] Apply one muted semantic color to the icon and copy.
-- [x] Preserve refresh interaction and improve its accessibility label.
-- [x] Run Swift tests and patch-format validation.
-- [x] Build, sign, verify, install, and launch the updated app.
-- [ ] Compare a user-provided post-fix screenshot against the right-hand reference.
-
-## Comparison History
-
-1. Source evidence showed the implementation label lighter than the target and the icon-to-label gap materially wider; the refresh icon also read smaller and less balanced.
-2. The implementation now uses a 15-point regular symbol in a 16-point slot, 9-point spacing, and 13-point medium text in one aligned control. Automated tests and bundle verification pass; visual comparison awaits the user capture.
-
-## Follow-up Polish
-
-- None classified until the post-fix screenshot is available.
-
-final result: blocked