Multi-account 1/4: verified account identity, cards, and naming

.github/workflows/ci.yml

@@ -5,7 +5,7 @@ on:
   push:
     branches: [main]
   pull_request:
-    branches: [main]
+    branches: [main, 'codex/account-*']
 
 permissions:
   contents: read

Sources/OpenUsage/App/AppContainer.swift

@@ -41,6 +41,9 @@ final class AppContainer {
     /// provider were ever removed from the registry. Injected into the view tree via
     /// `\.codexResetClaim`.
     let codexResetClaim: CodexResetClaimService?
+    /// The account registry the launch pass reconciled. The UI observes it live: a rename
+    /// (`customLabel`) re-titles the card everywhere without a relaunch.
+    let accounts: ProviderAccountsStore
     /// The provider runtimes, kept so on-demand credential detection (the Customize "Reset All" reseed)
     /// can re-probe `hasLocalCredentials()` the same way first-run seeding does.
     private let providers: [ProviderRuntime]
@@ -67,11 +70,23 @@ final class AppContainer {
         // Once the capture lands, persist its identity-relevant facts so the NEXT launch has them
         // even if that launch's own capture is slow (see `ShellEnvironmentSnapshot`).
         self.shellEnvironmentSnapshotTask = ShellEnvironmentSnapshotStore(defaults: .standard).startRefreshTask()
-        // The launch account pass: which account is signed in at each family's default home. Feeds
-        // the snapshot cache's account stamp and reconciles the account registry.
-        let accountAssembly = ProviderAccountAssembly.make(waitsForLoginShell: true)
+        // The launch account pass: which account is signed in at each family's default home, plus
+        // the config-dir scan for extra Claude logins. Feeds the snapshot cache's account stamp,
+        // reconciles the account registry, and hands the catalog its extra-card build plan.
+        let accounts = ProviderAccountsStore()
+        let accountAssembly = ProviderAccountAssembly.make(accountsStore: accounts, waitsForLoginShell: true)
+        self.accounts = accounts
 
-        let providers = ProviderCatalog.make()
+        let providers = ProviderCatalog.make(
+            claudeCards: accountAssembly.claudeCards,
+            defaultClaudeExtraLogRoots: accountAssembly.defaultClaudeExtraLogRoots,
+            defaultClaudeDisplayName: accountAssembly.defaultClaudeDisplayName,
+            defaultClaudeVerifiedIdentityAliases: accountAssembly.defaultClaudeVerifiedIdentityAliases,
+            defaultClaudeCardID: accountAssembly.defaultClaudeCardID,
+            claudeIdentityKeys: accountAssembly.identityKeysByCard,
+            isClaudeDiscoveryComplete: accountAssembly.isClaudeDiscoveryComplete,
+            allowsUnownedClaudeDesktopFallback: accountAssembly.allowsUnownedClaudeDesktopFallback
+        )
         let registry = WidgetRegistry.from(providers)
         let apiKeyProviders = providers.compactMap { $0 as? any APIKeyManaging }
         let enablement = ProviderEnablementStore()
@@ -86,7 +101,8 @@ final class AppContainer {
             isProviderEnabled: { [enablement] in enablement.isEnabled($0) },
             orderedDescriptors: { [layout] in layout.visiblePlaced.compactMap { layout.descriptor(for: $0) } },
             notificationSettings: { notificationSettings },
-            providerIdentityKeys: accountAssembly.identityKeysByCard
+            providerIdentityKeys: accountAssembly.identityKeysByCard,
+            resolveDisplayName: { [accounts] in accounts.resolvedDisplayName(cardID: $0) }
         )
         let iCloudSync = ICloudUsageSyncStore(dataStore: dataStore)
         // Re-enabling a provider should fetch it promptly, so clear any leftover failure backoff before
@@ -196,14 +212,17 @@ final class AppContainer {
         self.telemetry = telemetry
         self.transparency = PopoverTransparencyStore()
         self.privacy = MenuBarPrivacyStore()
-        self.localAPI = LocalUsageServer(state: { [layout, enablement, dataStore] in
+        self.localAPI = LocalUsageServer(state: { [layout, enablement, dataStore, accounts] in
             LocalUsageAPI.State(
                 enabledOrderedIDs: layout.orderedProviderIDs().filter { enablement.isEnabled($0) },
                 knownIDs: Set(registry.providers.map(\.id)),
                 snapshots: dataStore.snapshots,
                 limitDescriptors: registry.limitDescriptorsByProvider,
                 errors: dataStore.providerErrors
             )
+            // API output is human-read too: resolve card titles at respond time so renames show,
+            // exactly like every UI surface.
+            .resolvingDisplayNames(accounts.resolvedDisplayNamesByCardID)
         })
         self.refreshTask = Self.startPeriodicRefresh(dataStore: dataStore, telemetry: telemetry)
         localAPI.start()
@@ -220,6 +239,21 @@ final class AppContainer {
         shellEnvironmentSnapshotTask.cancel()
     }
 
+    /// The name a card renders under right now — the app-side face of the one resolver
+    /// (`ProviderAccountRecord.resolvedDisplayName`). Live: a rename in the account registry
+    /// re-titles the card everywhere without a relaunch. Non-account providers (no record) keep
+    /// their static display name; `Provider.displayName` itself only ever carries the derived
+    /// default, so the fallback can never be a stale rename.
+    func displayName(for provider: Provider) -> String {
+        accounts.resolvedDisplayName(cardID: provider.id) ?? provider.displayName
+    }
+
+    /// Whether the card has an account record a rename can attach to (accounts-model families only,
+    /// and only once the account's identity has been observed at least once).
+    func canRename(_ providerID: String) -> Bool {
+        accounts.runtimeRecord(for: providerID) != nil
+    }
+
     /// Re-runs first-launch credential detection on demand — the enablement half of the Customize
     /// "Reset All" action (`LayoutStore.resetToDefault` handles metrics, order, pins, and expansion).
     /// Delegates to `FirstRunSeeder.reseed`; returns its detection task so callers can await it.

Sources/OpenUsage/App/StatusItemImageUpdater.swift

@@ -68,7 +68,8 @@ final class StatusItemImageUpdater {
         }
         let content = MenuBarContentBuilder.build(
             groups: container.layout.pinnedGroups,
-            data: { container.dataStore.data(for: $0) }
+            data: { container.dataStore.data(for: $0) },
+            title: { container.displayName(for: $0) }
         )
         return MenuBarStripRenderer.image(for: content, style: container.layout.menuBarStyle)
             ?? MenuBarIcon.image

Sources/OpenUsage/Models/MenuBarContent.swift

@@ -58,13 +58,19 @@ enum MenuBarContentBuilder {
     /// The strip is dynamic: a pinned metric without data is dropped (one of two pins renders alone at
     /// full size), and a provider with no data-carrying pins contributes no icon at all. Pins are
     /// membership; the strip shows whatever subset is real right now.
-    static func build(groups: [ProviderMetrics], data: (WidgetDescriptor) -> WidgetData) -> MenuBarContent {
+    /// `title` resolves each provider's card title (the VoiceOver summary is a human-facing name, so
+    /// the caller passes the account-registry resolver); defaults to the baked derived name.
+    static func build(
+        groups: [ProviderMetrics],
+        data: (WidgetDescriptor) -> WidgetData,
+        title: (Provider) -> String = { $0.displayName }
+    ) -> MenuBarContent {
         let resolvedGroups = groups.compactMap { group -> MenuBarContent.Group? in
             let metrics = group.metrics.map { resolve($0, data($0)) }.filter(\.hasData)
             guard !metrics.isEmpty else { return nil }
             return MenuBarContent.Group(
                 providerID: group.provider.id,
-                displayName: group.provider.displayName,
+                displayName: title(group.provider),
                 icon: group.provider.icon,
                 metrics: metrics
             )

Sources/OpenUsage/Models/ProviderSnapshot.swift

@@ -3,7 +3,11 @@ import Foundation
 /// Latest normalized output for one provider refresh.
 struct ProviderSnapshot: Hashable, Sendable, Codable {
     let providerID: String
-    let displayName: String
+    /// The card title at refresh time — always the baked DERIVED name (renames never reach the
+    /// cache or iCloud). The CLI/API boundary re-resolves it against the account registry at
+    /// respond time (`LocalUsageAPI.State.resolvingDisplayNames`), so human-facing output carries
+    /// renames without persisting them.
+    var displayName: String
     var plan: String?
     var lines: [MetricLine]
     var refreshedAt: Date