@sriinnu/runic 1.0.0

package/Sources/Runic/Views/Preferences/PreferencesProvidersPane.swift

@@ -0,0 +1,3435 @@
+import AppKit
+import RunicCore
+import SwiftUI
+
+private struct ProviderUsageStatus {
+    let text: String
+    let style: Style
+
+    enum Style {
+        case success
+        case error
+        case neutral
+    }
+}
+
+private enum ProviderListMetrics {
+    static let contentInset: CGFloat = 16
+    static let listHeaderCornerRadius: CGFloat = RunicCornerRadius.md
+    static let listHeaderPadding: EdgeInsets = .init(
+        top: RunicSpacing.xs,
+        leading: RunicSpacing.md,
+        bottom: RunicSpacing.xs,
+        trailing: RunicSpacing.md)
+    static let listHeaderBackgroundOpacity: Double = 0.26
+    static let listHeaderBorderOpacity: Double = 0.2
+    static let rowSpacing: CGFloat = RunicSpacing.sm
+    static let reorderHandleSize: CGFloat = 12
+    static let reorderDotSize: CGFloat = 4
+    static let reorderDotSpacing: CGFloat = 4
+    static let rowInsets = EdgeInsets(
+        top: RunicSpacing.xxs,
+        leading: contentInset,
+        bottom: RunicSpacing.xxs,
+        trailing: contentInset)
+    static let sectionEdgeInset: CGFloat = RunicSpacing.md
+    static let dividerBottomInset: CGFloat = RunicSpacing.xxs
+    static let checkboxSize: CGFloat = 20
+    static let iconSize: CGFloat = 30
+    static let dividerLeadingInset: CGFloat = contentInset
+    static let dividerTrailingInset: CGFloat = contentInset
+    static let providerCardPadding = EdgeInsets(
+        top: RunicSpacing.sm,
+        leading: RunicSpacing.sm,
+        bottom: RunicSpacing.sm,
+        trailing: RunicSpacing.sm)
+    static let providerCardBackgroundOpacity: Double = 0.55
+    static let providerCardBorderOpacity: Double = 0.25
+    static let providerCardCornerRadius: CGFloat = RunicCornerRadius.md
+    static let providerInsightsCardCornerRadius: CGFloat = RunicCornerRadius.sm
+    static let providerInsightsGridItemMinWidth: CGFloat = 210
+    static let providerInsightsChipCornerRadius: CGFloat = RunicCornerRadius.sm
+    static let providerInsightsChipSpacing: CGFloat = RunicSpacing.xxs
+    static let providerInsightsChipPadding: CGFloat = RunicSpacing.xs
+
+    static let supplementalCardPadding = EdgeInsets(
+        top: RunicSpacing.sm,
+        leading: RunicSpacing.sm,
+        bottom: RunicSpacing.sm,
+        trailing: RunicSpacing.sm)
+    static let supplementalCardBackgroundOpacity: Double = 0.28
+    static let supplementalCardBorderOpacity: Double = 0.18
+    static let fieldMaxWidth: CGFloat = 420
+    static let errorCardPadding: CGFloat = RunicSpacing.sm
+    static let statusBadgePaddingH: CGFloat = RunicSpacing.xs
+    static let statusBadgePaddingV: CGFloat = RunicSpacing.xxxs
+    static let errorCardCornerRadius: CGFloat = RunicCornerRadius.sm
+    static let insightsCardPadding: CGFloat = RunicSpacing.xs
+    static let insightsLineSpacing: CGFloat = RunicSpacing.xxxs
+    static let insightsLabelWidth: CGFloat = 84
+    static let sidebarStatusLabelWidth: CGFloat = 62
+    static let sidebarCardCornerRadius: CGFloat = RunicCornerRadius.md
+    static let sidebarCardPadding: CGFloat = RunicSpacing.md
+    static let sidebarCardBackgroundOpacity: Double = 0.36
+    static let sidebarCardBorderOpacity: Double = 0.22
+    static let sidebarMicroCardCornerRadius: CGFloat = RunicCornerRadius.sm
+    static let sidebarMicroCardBackgroundOpacity: Double = 0.52
+    static let sidebarMicroCardBorderOpacity: Double = 0.2
+    static let sidebarSectionSpacing: CGFloat = RunicSpacing.md
+    static let sidebarContentGap: CGFloat = RunicSpacing.sm
+}
+
+private struct ProviderInsightLine: Identifiable, Equatable {
+    let id: String
+    let label: String
+    let value: String
+    let help: String?
+
+    init(id: String, label: String, value: String, help: String? = nil) {
+        self.id = id
+        self.label = label
+        self.value = value
+        self.help = help
+    }
+}
+
+@MainActor
+private enum ProviderInsightsComposer {
+    static func lines(
+        for provider: UsageProvider,
+        store: UsageStore,
+        maxRows: Int? = nil) -> [ProviderInsightLine]
+    {
+        var rows: [ProviderInsightLine] = []
+        let snapshot = store.snapshot(for: provider)
+        let identity = snapshot?.identity(for: provider) ?? snapshot?.identity
+        let tokenSnapshot = store.tokenSnapshot(for: provider)
+        let attempts = store.fetchAttempts(for: provider)
+        let reliability = store.ledgerReliabilityScore(for: provider)
+        let anomaly = store.ledgerAnomalySummary(for: provider)
+        let spendForecast = store.ledgerSpendForecast(for: provider)
+        let topProjectSpendForecast = store.ledgerTopProjectSpendForecast(for: provider)
+        let topModel = store.ledgerTopModel(for: provider)
+        let topProject = store.ledgerTopProject(for: provider)
+        let modelBreakdown = store.ledgerModelBreakdown(for: provider)
+        let projectBreakdown = store.ledgerProjectBreakdown(for: provider)
+        let coverage = Self.effectiveCoverage(
+            provider: provider,
+            metadataCoverage: store.metadata(for: provider).usageCoverage,
+            topModel: topModel,
+            topProject: topProject,
+            modelBreakdown: modelBreakdown,
+            projectBreakdown: projectBreakdown,
+            snapshot: snapshot,
+            tokenSnapshot: tokenSnapshot)
+        let hasModelBreakdown = coverage.supportsModelBreakdown
+        let hasProjectAttribution = coverage.supportsProjectAttribution
+
+        if let who = self.actorValue(identity: identity) {
+            rows.append(ProviderInsightLine(id: "actor", label: "Who", value: who))
+        }
+        if let planAuth = self.planAuthValue(identity: identity) {
+            rows.append(ProviderInsightLine(id: "plan-auth", label: "Plan/Auth", value: planAuth))
+        }
+        if let fetch = self.fetchHealthValue(attempts) {
+            rows.append(ProviderInsightLine(
+                id: "fetch",
+                label: "Fetch",
+                value: fetch,
+                help: self.fetchAttemptsHelp(attempts)))
+        }
+        if store.isStale(provider: provider), let fetchError = self.fetchErrorValue(attempts) {
+            rows.append(ProviderInsightLine(
+                id: "fetch-error",
+                label: "Fetch err",
+                value: fetchError,
+                help: self.fetchAttemptsHelp(attempts)))
+        }
+        if let reliabilityValue = self.reliabilityValue(reliability) {
+            rows.append(ProviderInsightLine(
+                id: "reliability",
+                label: "Reliability",
+                value: reliabilityValue,
+                help: self.reliabilityHelpText(reliability)))
+        }
+        if let costAlertValue = self.costAnomalyValue(anomaly) {
+            rows.append(ProviderInsightLine(
+                id: "cost-alert",
+                label: "Cost alert",
+                value: costAlertValue,
+                help: self.costAnomalyHelpText(anomaly)))
+        }
+
+        if hasModelBreakdown, let topModel, topModel.provider == provider {
+            rows.append(ProviderInsightLine(
+                id: "top-model",
+                label: "Top model",
+                value: self.topModelValue(topModel)))
+        } else if !hasModelBreakdown, let windowModels = self.windowModelsValue(snapshot) {
+            rows.append(ProviderInsightLine(
+                id: "models",
+                label: "Quota windows",
+                value: windowModels,
+                help: "Live quota windows grouped by provider response window IDs."))
+        }
+
+        if hasProjectAttribution,
+           let topProject,
+           topProject.provider == provider
+        {
+            rows.append(ProviderInsightLine(
+                id: "top-project",
+                label: "Top project",
+                value: self.topProjectValue(topProject),
+                help: self.projectIdentityHelpText(topProject)))
+        }
+
+        if hasModelBreakdown, let modelMix = self.modelMixValue(modelBreakdown) {
+            rows.append(ProviderInsightLine(id: "model-mix", label: "Model mix", value: modelMix))
+        }
+
+        if hasProjectAttribution, let projectMix = self.projectMixValue(projectBreakdown) {
+            rows.append(ProviderInsightLine(
+                id: "project-mix",
+                label: "Project mix",
+                value: projectMix,
+                help: self.projectMixHelpText(projectBreakdown)))
+        }
+
+        if let usage = self.usageValue(snapshot?.primary) {
+            rows.append(ProviderInsightLine(id: "usage", label: "Usage", value: usage))
+        }
+
+        if let spend = self.spendValue(snapshot?.providerCost) {
+            rows.append(ProviderInsightLine(id: "spend", label: "Spend", value: spend))
+        }
+        if let forecast = self.forecastValue(spendForecast) {
+            rows.append(ProviderInsightLine(
+                id: "forecast",
+                label: "Forecast",
+                value: forecast,
+                help: self.forecastHelpText(spendForecast)))
+        }
+        if let budget = self.budgetValue(spendForecast) {
+            rows.append(ProviderInsightLine(
+                id: "budget",
+                label: "Budget",
+                value: budget,
+                help: self.budgetHelpText(spendForecast)))
+        }
+        if hasProjectAttribution, let projectBudget = self.projectBudgetValue(topProjectSpendForecast) {
+            rows.append(ProviderInsightLine(
+                id: "project-budget",
+                label: "Prj budget",
+                value: projectBudget,
+                help: self.budgetHelpText(topProjectSpendForecast)))
+        }
+
+        if let today = self.tokenWindowValue(tokens: tokenSnapshot?.sessionTokens, cost: tokenSnapshot?.sessionCostUSD) {
+            rows.append(ProviderInsightLine(id: "today", label: "Today", value: today))
+        }
+
+        if let last30 = self.tokenWindowValue(
+            tokens: tokenSnapshot?.last30DaysTokens,
+            cost: tokenSnapshot?.last30DaysCostUSD)
+        {
+            rows.append(ProviderInsightLine(id: "last30", label: "30d", value: last30))
+        }
+
+        if let reset = self.resetValue(snapshot?.primary) {
+            rows.append(ProviderInsightLine(id: "reset", label: "Reset", value: reset))
+        }
+
+        guard let maxRows, maxRows > 0, rows.count > maxRows else {
+            return rows
+        }
+        return Array(rows.prefix(maxRows))
+    }
+
+    static func coverageSummaryLabel(for provider: UsageProvider, store: UsageStore) -> String? {
+        Self.effectiveCoverage(for: provider, store: store).summaryLabel
+    }
+
+    static func effectiveCoverage(
+        for provider: UsageProvider,
+        store: UsageStore) -> ProviderUsageCoverage
+    {
+        Self.effectiveCoverage(
+            provider: provider,
+            metadataCoverage: store.metadata(for: provider).usageCoverage,
+            topModel: store.ledgerTopModel(for: provider),
+            topProject: store.ledgerTopProject(for: provider),
+            modelBreakdown: store.ledgerModelBreakdown(for: provider),
+            projectBreakdown: store.ledgerProjectBreakdown(for: provider),
+            snapshot: store.snapshot(for: provider),
+            tokenSnapshot: store.tokenSnapshot(for: provider))
+    }
+
+    private static func effectiveCoverage(
+        provider: UsageProvider,
+        metadataCoverage: ProviderUsageCoverage,
+        topModel: UsageLedgerModelSummary?,
+        topProject: UsageLedgerProjectSummary?,
+        modelBreakdown: [UsageLedgerModelSummary],
+        projectBreakdown: [UsageLedgerProjectSummary],
+        snapshot: UsageSnapshot?,
+        tokenSnapshot: CostUsageTokenSnapshot?) -> ProviderUsageCoverage
+    {
+        let hasModelBreakdown =
+            metadataCoverage.supportsModelBreakdown
+            || (topModel?.provider == provider)
+            || !modelBreakdown.isEmpty
+
+        let hasProjectAttribution =
+            metadataCoverage.supportsProjectAttribution
+            || (topProject?.provider == provider)
+            || !projectBreakdown.isEmpty
+
+        let hasTokenMetrics = metadataCoverage.supportsTokenMetrics
+            || snapshot?.providerCost != nil
+            || tokenSnapshot?.sessionTokens != nil
+            || tokenSnapshot?.sessionCostUSD != nil
+            || tokenSnapshot?.last30DaysTokens != nil
+            || tokenSnapshot?.last30DaysCostUSD != nil
+
+        return ProviderUsageCoverage(
+            supportsModelBreakdown: hasModelBreakdown,
+            supportsTokenMetrics: hasTokenMetrics,
+            supportsProjectAttribution: hasProjectAttribution)
+    }
+
+    private static func actorValue(identity: ProviderIdentitySnapshot?) -> String? {
+        let email = self.trimmed(identity?.accountEmail)
+        let organization = self.trimmed(identity?.accountOrganization)
+        if let email, let organization {
+            if email.caseInsensitiveCompare(organization) == .orderedSame {
+                return email
+            }
+            return "\(email) · \(organization)"
+        }
+        return email ?? organization
+    }
+
+    private static func planAuthValue(identity: ProviderIdentitySnapshot?) -> String? {
+        guard let raw = self.trimmed(identity?.loginMethod) else { return nil }
+        let cleaned = UsageFormatter.cleanPlanName(raw)
+        return cleaned.isEmpty ? raw : cleaned
+    }
+
+    private static func topModelValue(_ summary: UsageLedgerModelSummary) -> String {
+        let model = UsageFormatter.modelDisplayName(summary.model)
+        let tokens = UsageFormatter.tokenCountString(summary.totals.totalTokens)
+        var parts = [model, "\(tokens) tok", "\(summary.entryCount) req"]
+        if let context = UsageFormatter.modelContextLabel(for: summary.model) {
+            parts.append(context)
+        }
+        if let cost = summary.totals.costUSD {
+            parts.append(UsageFormatter.usdString(cost))
+            if let per1K = UsageFormatter.usdPer1KTokensString(costUSD: cost, tokenCount: summary.totals.totalTokens) {
+                parts.append("~\(per1K)")
+            }
+            if let perReq = UsageFormatter.usdPerRequestString(costUSD: cost, requestCount: summary.entryCount) {
+                parts.append("~\(perReq)")
+            }
+        }
+        return parts.joined(separator: " · ")
+    }
+
+    private static func topProjectValue(_ summary: UsageLedgerProjectSummary) -> String {
+        let project = self.shortProjectName(summary.displayProjectName)
+        let tokens = UsageFormatter.tokenCountString(summary.totals.totalTokens)
+        var parts = [project, "\(tokens) tok", "\(summary.entryCount) req"]
+        if let cost = summary.totals.costUSD {
+            parts.append(UsageFormatter.usdString(cost))
+            if let per1K = UsageFormatter.usdPer1KTokensString(costUSD: cost, tokenCount: summary.totals.totalTokens) {
+                parts.append("~\(per1K)")
+            }
+            if let perReq = UsageFormatter.usdPerRequestString(costUSD: cost, requestCount: summary.entryCount) {
+                parts.append("~\(perReq)")
+            }
+        }
+        return parts.joined(separator: " · ")
+    }
+
+    private static func modelMixValue(_ summaries: [UsageLedgerModelSummary]) -> String? {
+        guard !summaries.isEmpty else { return nil }
+        var tokensByModel: [String: Int] = [:]
+        for summary in summaries {
+            tokensByModel[summary.model, default: 0] += summary.totals.totalTokens
+        }
+        let ranked = tokensByModel.map { (model: $0.key, tokens: $0.value) }.sorted { lhs, rhs in
+            if lhs.tokens == rhs.tokens {
+                return UsageFormatter.modelDisplayName(lhs.model) < UsageFormatter.modelDisplayName(rhs.model)
+            }
+            return lhs.tokens > rhs.tokens
+        }
+        guard ranked.count > 1 else { return nil }
+        let rendered = ranked.prefix(2).map { item in
+            let name = UsageFormatter.modelDisplayName(item.model)
+            let tokens = UsageFormatter.tokenCountString(item.tokens)
+            if let context = UsageFormatter.modelContextLabel(for: item.model) {
+                return "\(name) \(context) \(tokens)"
+            }
+            return "\(name) \(tokens)"
+        }
+        var value = rendered.joined(separator: " · ")
+        if ranked.count > 2 {
+            value += " +\(ranked.count - 2) more"
+        }
+        return value
+    }
+
+    private static func projectMixValue(_ summaries: [UsageLedgerProjectSummary]) -> String? {
+        guard summaries.count > 1 else { return nil }
+        let ranked = summaries.sorted { lhs, rhs in
+            if lhs.totals.totalTokens == rhs.totals.totalTokens {
+                return lhs.displayProjectName < rhs.displayProjectName
+            }
+            return lhs.totals.totalTokens > rhs.totals.totalTokens
+        }
+        let rendered = ranked.prefix(2).map { summary in
+            let project = self.shortProjectName(summary.displayProjectName)
+            let tokens = UsageFormatter.tokenCountString(summary.totals.totalTokens)
+            return "\(project) \(tokens)"
+        }
+        var value = rendered.joined(separator: " · ")
+        if ranked.count > 2 {
+            value += " +\(ranked.count - 2) more"
+        }
+        return value
+    }
+
+    private static func shortProjectName(_ text: String) -> String {
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        let maxLength = 44
+        guard trimmed.count > maxLength else { return trimmed }
+        let prefixLength = 28
+        let suffixLength = 12
+        guard trimmed.count > (prefixLength + suffixLength + 1) else {
+            let index = trimmed.index(trimmed.startIndex, offsetBy: maxLength)
+            return "\(trimmed[..<index])…"
+        }
+        let prefixEnd = trimmed.index(trimmed.startIndex, offsetBy: prefixLength)
+        let suffixStart = trimmed.index(trimmed.endIndex, offsetBy: -suffixLength)
+        return "\(trimmed[..<prefixEnd])…\(trimmed[suffixStart...])"
+    }
+
+    private static func projectMixHelpText(_ summaries: [UsageLedgerProjectSummary]) -> String? {
+        guard summaries.count > 1 else { return nil }
+        let ranked = summaries.sorted { lhs, rhs in
+            if lhs.totals.totalTokens == rhs.totals.totalTokens {
+                return lhs.displayProjectName < rhs.displayProjectName
+            }
+            return lhs.totals.totalTokens > rhs.totals.totalTokens
+        }
+        let details = ranked.prefix(3).map { summary in
+            let tokens = UsageFormatter.tokenCountString(summary.totals.totalTokens)
+            let project = summary.displayProjectName
+            return "\(project): \(tokens) tok"
+        }
+        return details.isEmpty ? nil : details.joined(separator: "\n")
+    }
+
+    private static func projectIdentityHelpText(_ summary: UsageLedgerProjectSummary) -> String? {
+        let displayName = summary.displayProjectName
+        let source = summary.projectNameSource ?? .unknown
+        let confidence = summary.projectNameConfidence ?? .none
+        let shouldAnnotateSource = source != .projectName && source != .budgetOverride
+        let shouldAnnotateConfidence = confidence != .high
+        let isUnknown = displayName == "Unknown project"
+
+        var details: [String] = []
+        if shouldAnnotateSource {
+            details.append("source: \(self.projectSourceLabel(source))")
+        }
+        if shouldAnnotateConfidence {
+            details.append("confidence: \(self.projectConfidenceLabel(confidence))")
+        }
+        if isUnknown, let fingerprint = self.projectIDFingerprint(summary.projectID) {
+            details.append("id: \(fingerprint)")
+        }
+        if let provenance = self.trimmed(summary.projectNameProvenance) {
+            details.append("via: \(provenance)")
+        }
+        guard !details.isEmpty else { return nil }
+        return ([displayName] + details).joined(separator: "\n")
+    }
+
+    private static func projectSourceLabel(_ source: UsageLedgerProjectNameSource) -> String {
+        switch source {
+        case .projectName: return "project name"
+        case .projectID: return "project id"
+        case .inferredFromPath: return "path-derived"
+        case .inferredFromName: return "name-derived"
+        case .budgetOverride: return "budget override"
+        case .unknown: return "unknown"
+        }
+    }
+
+    private static func projectConfidenceLabel(_ confidence: UsageLedgerProjectNameConfidence) -> String {
+        switch confidence {
+        case .high: return "high"
+        case .medium: return "medium"
+        case .low: return "low"
+        case .none: return "none"
+        }
+    }
+
+    private static func projectIDFingerprint(_ projectID: String?) -> String? {
+        guard let projectID = projectID?.trimmingCharacters(in: .whitespacesAndNewlines), !projectID.isEmpty else {
+            return nil
+        }
+
+        var hash: UInt64 = 0xcbf29ce484222325
+        for byte in projectID.lowercased().utf8 {
+            hash ^= UInt64(byte)
+            hash = hash &* 0x100000001b3
+        }
+        return String(format: "%08llx", hash)
+    }
+
+    private static func trimmed(_ value: String?) -> String? {
+        guard let value else { return nil }
+        let cleaned = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return cleaned.isEmpty ? nil : cleaned
+    }
+
+    private static func usageValue(_ window: RateWindow?) -> String? {
+        guard let window else { return nil }
+        var parts = ["\(Int(window.usedPercent.rounded()))% used"]
+        if let minutes = window.windowMinutes, minutes > 0 {
+            parts.append("\(minutes)m window")
+        }
+        return parts.joined(separator: " · ")
+    }
+
+    private static func spendValue(_ providerCost: ProviderCostSnapshot?) -> String? {
+        guard let providerCost else { return nil }
+        let used = UsageFormatter.currencyString(providerCost.used, currencyCode: providerCost.currencyCode)
+        var value: String
+        if providerCost.limit > 0 {
+            let limitText = UsageFormatter.currencyString(providerCost.limit, currencyCode: providerCost.currencyCode)
+            value = "\(used) / \(limitText)"
+        } else {
+            value = used
+        }
+        if let period = self.trimmed(providerCost.period) {
+            value += " · \(period)"
+        }
+        return value
+    }
+
+    private static func forecastValue(_ forecast: UsageLedgerSpendForecast?) -> String? {
+        guard let forecast else { return nil }
+        var parts = [UsageFormatter.usdString(forecast.projected30DayCostUSD), "/ 30d"]
+        if forecast.averageDailyCostUSD.isFinite, forecast.averageDailyCostUSD >= 0 {
+            parts.append("· \(UsageFormatter.usdString(forecast.averageDailyCostUSD))/day")
+        }
+        return parts.joined(separator: " ")
+    }
+
+    private static func budgetValue(_ forecast: UsageLedgerSpendForecast?) -> String? {
+        guard let forecast, let limit = forecast.budgetLimitUSD, limit > 0 else { return nil }
+        let limitText = UsageFormatter.usdString(limit)
+        if let eta = forecast.budgetETAInDays {
+            return "\(limitText) · \(self.budgetBreachETAText(days: eta))"
+        }
+        if forecast.budgetWillBreach {
+            return "\(limitText) · Breach risk"
+        }
+        return "\(limitText) · On track"
+    }
+
+    private static func projectBudgetValue(_ forecast: UsageLedgerSpendForecast?) -> String? {
+        guard let forecast, let limit = forecast.budgetLimitUSD, limit > 0 else { return nil }
+        let name = self.shortProjectName(forecast.projectName?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "Top project")
+        if let eta = forecast.budgetETAInDays {
+            return "\(name) · \(self.budgetBreachETAText(days: eta))"
+        }
+        if forecast.budgetWillBreach {
+            return "\(name) · Breach risk"
+        }
+        return "\(name) · On track"
+    }
+
+    private static func forecastHelpText(_ forecast: UsageLedgerSpendForecast?) -> String? {
+        guard let forecast else { return nil }
+        var lines: [String] = []
+        let observedLabel = forecast.observedDays == 1 ? "day" : "days"
+        lines.append("Observed: \(forecast.observedDays) \(observedLabel)")
+        lines.append("Projected 30d: \(UsageFormatter.usdString(forecast.projected30DayCostUSD))")
+        if let p50 = forecast.projectedCostP50USD {
+            lines.append("p50: \(UsageFormatter.usdString(p50))")
+        }
+        if let p80 = forecast.projectedCostP80USD {
+            lines.append("p80: \(UsageFormatter.usdString(p80))")
+        }
+        if let p95 = forecast.projectedCostP95USD {
+            lines.append("p95: \(UsageFormatter.usdString(p95))")
+        }
+        return lines.joined(separator: "\n")
+    }
+
+    private static func budgetHelpText(_ forecast: UsageLedgerSpendForecast?) -> String? {
+        guard let forecast, let limit = forecast.budgetLimitUSD, limit > 0 else { return nil }
+        var lines = [
+            "Budget limit: \(UsageFormatter.usdString(limit))",
+            "Projected 30d: \(UsageFormatter.usdString(forecast.projected30DayCostUSD))"
+        ]
+        if let eta = forecast.budgetETAInDays {
+            lines.append(self.budgetBreachETAText(days: eta))
+        } else if forecast.budgetWillBreach {
+            lines.append("Breach risk at current pace")
+        } else {
+            lines.append("No breach at current pace")
+        }
+        return lines.joined(separator: "\n")
+    }
+
+    private static func budgetBreachETAText(days: Double) -> String {
+        guard days.isFinite else { return "Breach ETA unavailable" }
+        if days <= 0 { return "Breach now" }
+        let now = Date()
+        let etaDate = now.addingTimeInterval(days * 24 * 60 * 60)
+        let countdown = UsageFormatter.resetCountdownDescription(from: etaDate, now: now)
+        if countdown == "now" { return "Breach now" }
+        return "Breach \(countdown)"
+    }
+
+    private static func resetValue(_ window: RateWindow?) -> String? {
+        guard let window else { return nil }
+        if let resetsAt = window.resetsAt {
+            return UsageFormatter.resetCountdownDescription(from: resetsAt)
+        }
+        return self.trimmed(window.resetDescription)
+    }
+
+    private static func tokenWindowValue(tokens: Int?, cost: Double?) -> String? {
+        var parts: [String] = []
+        if let cost, cost.isFinite, cost >= 0 {
+            parts.append(UsageFormatter.usdString(cost))
+        }
+        if let tokens, tokens >= 0 {
+            parts.append("\(UsageFormatter.tokenCountString(tokens)) tok")
+        }
+        return parts.isEmpty ? nil : parts.joined(separator: " · ")
+    }
+
+    private static func reliabilityValue(_ reliability: UsageLedgerReliabilityScore?) -> String? {
+        guard let reliability else { return nil }
+        return "\(reliability.grade) · \(reliability.score)/100"
+    }
+
+    private static func reliabilityHelpText(_ reliability: UsageLedgerReliabilityScore?) -> String? {
+        guard let reliability else { return nil }
+        var lines = [reliability.summary]
+        if let primary = self.trimmed(reliability.primarySignal), !primary.isEmpty {
+            lines.append(primary)
+        }
+        for signal in reliability.signals {
+            let trimmed = self.trimmed(signal) ?? ""
+            guard !trimmed.isEmpty else { continue }
+            if lines.contains(trimmed) { continue }
+            lines.append(trimmed)
+            if lines.count >= 5 { break }
+        }
+        return lines.joined(separator: "\n")
+    }
+
+    private static func costAnomalyValue(_ anomaly: UsageLedgerAnomalySummary?) -> String? {
+        guard let spend = anomaly?.spendAnomaly else { return nil }
+        let percent = Int((spend.percentIncrease * 100).rounded())
+        return "\(spend.severity.label) spend +\(percent)%"
+    }
+
+    private static func costAnomalyHelpText(_ anomaly: UsageLedgerAnomalySummary?) -> String? {
+        guard let anomaly, let spend = anomaly.spendAnomaly else { return nil }
+        let percent = Int((spend.percentIncrease * 100).rounded())
+        var lines = [
+            "Spend today: \(UsageFormatter.usdString(spend.todayValue))",
+            "Baseline (\(anomaly.baselineDays)d avg): \(UsageFormatter.usdString(spend.baselineAverage))",
+            "Increase: +\(percent)%",
+            "Severity: \(spend.severity.label)"
+        ]
+        if let explanation = anomaly.explanation {
+            lines.append(contentsOf: explanation.details.prefix(2))
+        }
+        return lines.joined(separator: "\n")
+    }
+
+    private static func fetchHealthValue(_ attempts: [ProviderFetchAttempt]) -> String? {
+        guard !attempts.isEmpty else { return nil }
+        let rendered = attempts.prefix(3).map { attempt in
+            let status: String
+            if !attempt.wasAvailable {
+                status = "unavailable"
+            } else if self.trimmed(attempt.errorDescription) != nil {
+                status = "failed"
+            } else {
+                status = "ok"
+            }
+            return "\(self.fetchStrategyLabel(attempt)) \(status)"
+        }
+        var value = rendered.joined(separator: " · ")
+        if attempts.count > 3 {
+            value += " +\(attempts.count - 3) more"
+        }
+        return value
+    }
+
+    private static func fetchErrorValue(_ attempts: [ProviderFetchAttempt]) -> String? {
+        guard let latestError = attempts.reversed().compactMap({ self.trimmed($0.errorDescription) }).first else {
+            return nil
+        }
+        return self.truncated(latestError, maxLength: 88)
+    }
+
+    private static func fetchAttemptsHelp(_ attempts: [ProviderFetchAttempt]) -> String? {
+        guard !attempts.isEmpty else { return nil }
+        return attempts.map { attempt in
+            let status: String
+            if !attempt.wasAvailable {
+                status = "unavailable"
+            } else if let error = self.trimmed(attempt.errorDescription) {
+                return "\(attempt.strategyID) (\(self.fetchKindLabel(attempt.kind))) failed: \(error)"
+            } else {
+                status = "ok"
+            }
+            return "\(attempt.strategyID) (\(self.fetchKindLabel(attempt.kind))) \(status)"
+        }.joined(separator: "\n")
+    }
+
+    private static func fetchStrategyLabel(_ attempt: ProviderFetchAttempt) -> String {
+        let raw = attempt.strategyID
+            .replacingOccurrences(of: "_", with: " ")
+            .replacingOccurrences(of: "-", with: " ")
+        let cleaned = UsageFormatter.cleanPlanName(raw).trimmingCharacters(in: .whitespacesAndNewlines)
+        if !cleaned.isEmpty {
+            return cleaned
+        }
+        return self.fetchKindLabel(attempt.kind)
+    }
+
+    private static func fetchKindLabel(_ kind: ProviderFetchKind) -> String {
+        switch kind {
+        case .cli: return "cli"
+        case .web: return "web"
+        case .oauth: return "oauth"
+        case .apiToken: return "api"
+        case .api: return "api"
+        case .localProbe: return "local"
+        case .webDashboard: return "web"
+        }
+    }
+
+    private static func truncated(_ text: String, maxLength: Int) -> String {
+        guard text.count > maxLength else { return text }
+        let index = text.index(text.startIndex, offsetBy: maxLength)
+        return "\(text[..<index])…"
+    }
+
+    private static func windowModelsValue(_ snapshot: UsageSnapshot?) -> String? {
+        guard let snapshot else { return nil }
+        let windows = [snapshot.primary, snapshot.secondary, snapshot.tertiary].compactMap { $0 }
+        guard !windows.isEmpty else { return nil }
+
+        var seen: Set<String> = []
+        var items: [String] = []
+        for window in windows {
+            guard let rawLabel = self.trimmed(window.label) else { continue }
+            let normalized = rawLabel.lowercased()
+            guard !seen.contains(normalized) else { continue }
+            seen.insert(normalized)
+
+            let label = UsageFormatter.modelDisplayName(rawLabel)
+            let used = Int(window.usedPercent.rounded())
+            items.append("\(label) \(used)%")
+        }
+        guard !items.isEmpty else { return nil }
+        if items.count > 3 {
+            let visible = items.prefix(3).joined(separator: " · ")
+            return "\(visible) +\(items.count - 3) more"
+        }
+        return items.joined(separator: " · ")
+    }
+}
+
+@MainActor
+struct ProvidersPane: View {
+    @Bindable var settings: SettingsStore
+    @Bindable var store: UsageStore
+    @State private var expandedErrors: Set<UsageProvider> = []
+    @State private var settingsStatusTextByID: [String: String] = [:]
+    @State private var settingsLastAppActiveRunAtByID: [String: Date] = [:]
+    @State private var activeConfirmation: ProviderSettingsConfirmationState?
+    @State private var sidebarSelection: UsageProvider?
+
+    private var providers: [UsageProvider] { self.settings.orderedProviders() }
+
+    var body: some View {
+        Group {
+            if self.settings.providersPaneSidebar {
+                self.sidebarLayout
+            } else {
+                self.listLayout
+            }
+        }
+        .onReceive(NotificationCenter.default.publisher(for: NSApplication.didBecomeActiveNotification)) { _ in
+            self.runSettingsDidBecomeActiveHooks()
+        }
+        .alert(
+            self.activeConfirmation?.title ?? "",
+            isPresented: Binding(
+                get: { self.activeConfirmation != nil },
+                set: { isPresented in
+                    if !isPresented { self.activeConfirmation = nil }
+                }),
+            actions: {
+                if let active = self.activeConfirmation {
+                    Button(active.confirmTitle) {
+                        active.onConfirm()
+                        self.activeConfirmation = nil
+                    }
+                    Button("Cancel", role: .cancel) { self.activeConfirmation = nil }
+                }
+            },
+            message: {
+                if let active = self.activeConfirmation {
+                    Text(active.message)
+                }
+            })
+    }
+
+    // MARK: - List layout (default)
+
+    private var listLayout: some View {
+        PreferencesListPane(horizontalPadding: 0, verticalPadding: 0) {
+            VStack(spacing: ProviderListMetrics.sidebarSectionSpacing) {
+                self.listLayoutHeader
+
+                ProviderListView(
+                    providers: self.providers,
+                    store: self.store,
+                    isEnabled: { provider in self.binding(for: provider) },
+                    subtitle: { provider in self.providerSubtitle(provider) },
+                    usageStatus: { provider in self.providerUsageStatus(provider) },
+                    sourceLabel: { provider in self.providerSourceLabel(provider) },
+                    statusLabel: { provider in self.providerStatusLabel(provider) },
+                    settingsToggles: { provider in self.extraSettingsToggles(for: provider) },
+                    settingsFields: { provider in self.extraSettingsFields(for: provider) },
+                    errorDisplay: { provider in self.providerErrorDisplay(provider) },
+                    isErrorExpanded: { provider in self.expandedBinding(for: provider) },
+                    onCopyError: { text in self.copyToPasteboard(text) },
+                    moveProviders: { fromOffsets, toOffset in
+                        self.settings.moveProvider(fromOffsets: fromOffsets, toOffset: toOffset)
+                    })
+            }
+        }
+    }
+
+    private var listLayoutHeader: some View {
+        HStack(alignment: .top, spacing: RunicSpacing.sm) {
+            Image(systemName: "square.grid.2x2")
+                .font(.system(size: 15, weight: .medium))
+                .foregroundStyle(.secondary)
+
+            VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                Text("Built-in providers")
+                    .font(.subheadline.weight(.semibold))
+                    .foregroundStyle(.primary)
+                Text("Switch to sidebar layout for per-day history cards and model or project drill-down details.")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+
+            Spacer(minLength: 0)
+        }
+        .padding(ProviderListMetrics.listHeaderPadding)
+        .background(
+            RoundedRectangle(cornerRadius: ProviderListMetrics.listHeaderCornerRadius, style: .continuous)
+                .fill(Color(nsColor: .controlBackgroundColor).opacity(ProviderListMetrics.listHeaderBackgroundOpacity))
+        )
+        .overlay(
+            RoundedRectangle(cornerRadius: ProviderListMetrics.listHeaderCornerRadius, style: .continuous)
+                .strokeBorder(
+                    Color(nsColor: .separatorColor).opacity(ProviderListMetrics.listHeaderBorderOpacity),
+                    lineWidth: 1)
+        )
+        .padding(.horizontal, ProviderListMetrics.contentInset)
+    }
+
+    // MARK: - Sidebar layout
+
+    private var sidebarLayout: some View {
+        NavigationSplitView {
+            List(selection: self.$sidebarSelection) {
+                ForEach(self.providers, id: \.self) { provider in
+                    ProviderSidebarRow(
+                        provider: provider,
+                        store: self.store,
+                        isEnabled: self.binding(for: provider).wrappedValue,
+                        isSelected: self.sidebarSelection == provider)
+                        .tag(provider)
+                }
+                .onMove { fromOffsets, toOffset in
+                    self.settings.moveProvider(fromOffsets: fromOffsets, toOffset: toOffset)
+                }
+            }
+            .listStyle(.sidebar)
+            .frame(minWidth: 160, idealWidth: 180)
+            .scrollContentBackground(.hidden)
+            .background(Color(nsColor: .controlBackgroundColor).opacity(0.15))
+            .onAppear {
+                self.normalizeSidebarSelection()
+            }
+            .onChange(of: self.providers) { _, _ in
+                self.normalizeSidebarSelection()
+            }
+        } detail: {
+            if let selected = self.sidebarSelection {
+                ProviderSidebarDetailView(
+                    provider: selected,
+                    store: self.store,
+                    isEnabled: self.binding(for: selected),
+                    subtitle: self.providerSubtitle(selected),
+                    usageStatus: self.providerUsageStatus(selected),
+                    sourceLabel: self.providerSourceLabel(selected),
+                    statusLabel: self.providerStatusLabel(selected),
+                    settingsToggles: self.extraSettingsToggles(for: selected),
+                    settingsFields: self.extraSettingsFields(for: selected),
+                    errorDisplay: self.providerErrorDisplay(selected),
+                    isErrorExpanded: self.expandedBinding(for: selected),
+                    onCopyError: { text in self.copyToPasteboard(text) })
+            } else {
+                Text("Select a provider")
+                    .font(.title3)
+                    .foregroundStyle(.secondary)
+                    .frame(maxWidth: .infinity, maxHeight: .infinity)
+            }
+        }
+    }
+
+    private func normalizeSidebarSelection() {
+        guard !self.providers.isEmpty else {
+            self.sidebarSelection = nil
+            return
+        }
+
+        if let selected = self.sidebarSelection, self.providers.contains(selected) {
+            return
+        }
+
+        self.sidebarSelection = self.providers.first
+    }
+
+    private func binding(for provider: UsageProvider) -> Binding<Bool> {
+        let meta = self.store.metadata(for: provider)
+        return Binding(
+            get: { self.settings.isProviderEnabled(provider: provider, metadata: meta) },
+            set: { self.settings.setProviderEnabled(provider: provider, metadata: meta, enabled: $0) })
+    }
+
+    private func providerSubtitle(_ provider: UsageProvider) -> String {
+        let meta = self.store.metadata(for: provider)
+        let cliName = meta.cliName
+        let coverageSuffix = ProviderInsightsComposer.coverageSummaryLabel(
+            for: provider,
+            store: self.store).map { " • \($0)" } ?? ""
+        let version = self.store.version(for: provider)
+        var versionText = version ?? "not detected"
+        if provider == .claude, let parenRange = versionText.range(of: "(") {
+            versionText = versionText[..<parenRange.lowerBound].trimmingCharacters(in: .whitespaces)
+        }
+
+        if cliName == "codex" {
+            return "\(versionText)\(coverageSuffix)"
+        }
+
+        // Cursor is web-based, no CLI version to detect
+        if provider == .cursor || provider == .minimax {
+            return "web\(coverageSuffix)"
+        }
+        let apiBackedProviders: Set<UsageProvider> = [
+            .zai,
+            .openrouter,
+            .groq,
+            .deepseek,
+            .fireworks,
+            .mistral,
+            .perplexity,
+            .kimi,
+            .auggie,
+            .together,
+            .cohere,
+            .xai,
+            .cerebras,
+            .sambanova,
+            .azure,
+            .bedrock,
+        ]
+        if apiBackedProviders.contains(provider) {
+            return "api\(coverageSuffix)"
+        }
+
+        var detail = "\(cliName) \(versionText)"
+        if provider == .antigravity {
+            detail += " • experimental"
+        }
+        return "\(detail)\(coverageSuffix)"
+    }
+
+    private func providerUsageStatus(_ provider: UsageProvider) -> ProviderUsageStatus {
+        if let snapshot = self.store.snapshot(for: provider) {
+            let relative = snapshot.updatedAt.relativeDescription()
+            return ProviderUsageStatus(text: "usage fetched \(relative)", style: .success)
+        } else if self.store.isStale(provider: provider) {
+            return ProviderUsageStatus(text: "last fetch failed", style: .error)
+        } else {
+            return ProviderUsageStatus(text: "usage not fetched yet", style: .neutral)
+        }
+    }
+
+    private func providerSourceLabel(_ provider: UsageProvider) -> String {
+        self.store.sourceLabel(for: provider)
+    }
+
+    private func providerStatusLabel(_ provider: UsageProvider) -> String {
+        if let snapshot = self.store.snapshot(for: provider) {
+            return snapshot.updatedAt.formatted(date: .abbreviated, time: .shortened)
+        }
+        if self.store.isStale(provider: provider) {
+            return "failed"
+        }
+        return "not yet"
+    }
+
+    private func providerErrorDisplay(_ provider: UsageProvider) -> ProviderErrorDisplay? {
+        guard self.store.isStale(provider: provider), let raw = self.store.error(for: provider) else { return nil }
+        return ProviderErrorDisplay(
+            preview: self.truncated(raw, prefix: ""),
+            full: raw)
+    }
+
+    private func extraSettingsToggles(for provider: UsageProvider) -> [ProviderSettingsToggleDescriptor] {
+        guard let impl = ProviderCatalog.implementation(for: provider) else { return [] }
+        let context = self.makeSettingsContext(provider: provider)
+        return impl.settingsToggles(context: context)
+            .filter { $0.isVisible?() ?? true }
+    }
+
+    private func extraSettingsFields(for provider: UsageProvider) -> [ProviderSettingsFieldDescriptor] {
+        guard let impl = ProviderCatalog.implementation(for: provider) else { return [] }
+        let context = self.makeSettingsContext(provider: provider)
+        return impl.settingsFields(context: context)
+            .filter { $0.isVisible?() ?? true }
+    }
+
+    private func makeSettingsContext(provider: UsageProvider) -> ProviderSettingsContext {
+        ProviderSettingsContext(
+            provider: provider,
+            settings: self.settings,
+            store: self.store,
+            boolBinding: { keyPath in
+                Binding(
+                    get: { self.settings[keyPath: keyPath] },
+                    set: { self.settings[keyPath: keyPath] = $0 })
+            },
+            stringBinding: { keyPath in
+                Binding(
+                    get: { self.settings[keyPath: keyPath] },
+                    set: { self.settings[keyPath: keyPath] = $0 })
+            },
+            statusText: { id in
+                self.settingsStatusTextByID[id]
+            },
+            setStatusText: { id, text in
+                if let text {
+                    self.settingsStatusTextByID[id] = text
+                } else {
+                    self.settingsStatusTextByID.removeValue(forKey: id)
+                }
+            },
+            lastAppActiveRunAt: { id in
+                self.settingsLastAppActiveRunAtByID[id]
+            },
+            setLastAppActiveRunAt: { id, date in
+                if let date {
+                    self.settingsLastAppActiveRunAtByID[id] = date
+                } else {
+                    self.settingsLastAppActiveRunAtByID.removeValue(forKey: id)
+                }
+            },
+            requestConfirmation: { confirmation in
+                self.activeConfirmation = ProviderSettingsConfirmationState(confirmation: confirmation)
+            })
+    }
+
+    private func runSettingsDidBecomeActiveHooks() {
+        for provider in UsageProvider.allCases {
+            for toggle in self.extraSettingsToggles(for: provider) {
+                guard let hook = toggle.onAppDidBecomeActive else { continue }
+                Task { @MainActor in
+                    await hook()
+                }
+            }
+        }
+    }
+
+    private func truncated(_ text: String, prefix: String, maxLength: Int = 160) -> String {
+        var message = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        if message.count > maxLength {
+            let idx = message.index(message.startIndex, offsetBy: maxLength)
+            message = "\(message[..<idx])…"
+        }
+        return prefix + message
+    }
+
+    private func expandedBinding(for provider: UsageProvider) -> Binding<Bool> {
+        Binding(
+            get: { self.expandedErrors.contains(provider) },
+            set: { expanded in
+                if expanded {
+                    self.expandedErrors.insert(provider)
+                } else {
+                    self.expandedErrors.remove(provider)
+                }
+            })
+    }
+
+    private func copyToPasteboard(_ text: String) {
+        let pb = NSPasteboard.general
+        pb.clearContents()
+        pb.setString(text, forType: .string)
+    }
+}
+
+@MainActor
+private struct ProviderListView: View {
+    let providers: [UsageProvider]
+    @Bindable var store: UsageStore
+    let isEnabled: (UsageProvider) -> Binding<Bool>
+    let subtitle: (UsageProvider) -> String
+    let usageStatus: (UsageProvider) -> ProviderUsageStatus
+    let sourceLabel: (UsageProvider) -> String
+    let statusLabel: (UsageProvider) -> String
+    let settingsToggles: (UsageProvider) -> [ProviderSettingsToggleDescriptor]
+    let settingsFields: (UsageProvider) -> [ProviderSettingsFieldDescriptor]
+    let errorDisplay: (UsageProvider) -> ProviderErrorDisplay?
+    let isErrorExpanded: (UsageProvider) -> Binding<Bool>
+    let onCopyError: (String) -> Void
+    let moveProviders: (IndexSet, Int) -> Void
+
+    var body: some View {
+        List {
+            ForEach(self.providers, id: \.self) { provider in
+                let fields = self.settingsFields(provider)
+                let toggles = self.settingsToggles(provider)
+                let isEnabled = self.isEnabled(provider).wrappedValue
+                let isFirstProvider = provider == self.providers.first
+                let isLastProvider = provider == self.providers.last
+                let shouldShowDivider = provider != self.providers.last
+                let showDividerOnProviderRow = shouldShowDivider &&
+                    (!isEnabled || (fields.isEmpty && toggles.isEmpty))
+                let providerAddsBottomPadding = isLastProvider && (!isEnabled || (fields.isEmpty && toggles.isEmpty))
+
+                ProviderListProviderRowView(
+                    provider: provider,
+                    store: self.store,
+                    isEnabled: self.isEnabled(provider),
+                    subtitle: self.subtitle(provider),
+                    usageStatus: self.usageStatus(provider),
+                    sourceLabel: self.sourceLabel(provider),
+                    statusLabel: self.statusLabel(provider),
+                    errorDisplay: self.isEnabled(provider).wrappedValue ? self.errorDisplay(provider) : nil,
+                    isErrorExpanded: self.isErrorExpanded(provider),
+                    onCopyError: self.onCopyError)
+                    .padding(.bottom, showDividerOnProviderRow ? ProviderListMetrics.dividerBottomInset : 0)
+                    .listRowInsets(self.rowInsets(
+                        withDivider: showDividerOnProviderRow,
+                        addTopPadding: isFirstProvider,
+                        addBottomPadding: providerAddsBottomPadding))
+                    .listRowSeparator(.hidden)
+                    .providerSectionDivider(isVisible: showDividerOnProviderRow)
+
+                if isEnabled {
+                    let lastFieldID = fields.last?.id
+                    ForEach(fields) { field in
+                        let isLastField = field.id == lastFieldID
+                        let showDivider = shouldShowDivider && toggles.isEmpty && isLastField
+                        let fieldAddsBottomPadding = isLastProvider && toggles.isEmpty && isLastField
+
+                        ProviderListFieldRowView(provider: provider, field: field)
+                            .id(self.rowID(provider: provider, suffix: field.id))
+                            .padding(.bottom, showDivider ? ProviderListMetrics.dividerBottomInset : 0)
+                            .listRowInsets(self.rowInsets(
+                                withDivider: showDivider,
+                                addTopPadding: false,
+                                addBottomPadding: fieldAddsBottomPadding))
+                            .listRowSeparator(.hidden)
+                            .providerSectionDivider(isVisible: showDivider)
+                    }
+                    let lastToggleID = toggles.last?.id
+                    ForEach(toggles) { toggle in
+                        let isLastToggle = toggle.id == lastToggleID
+                        let showDivider = shouldShowDivider && isLastToggle
+                        let toggleAddsBottomPadding = isLastProvider && isLastToggle
+
+                        ProviderListToggleRowView(provider: provider, toggle: toggle)
+                            .id(self.rowID(provider: provider, suffix: toggle.id))
+                            .padding(.bottom, showDivider ? ProviderListMetrics.dividerBottomInset : 0)
+                            .listRowInsets(self.rowInsets(
+                                withDivider: showDivider,
+                                addTopPadding: false,
+                                addBottomPadding: toggleAddsBottomPadding))
+                            .listRowSeparator(.hidden)
+                            .providerSectionDivider(isVisible: showDivider)
+                    }
+                }
+            }
+            .onMove { fromOffsets, toOffset in
+                self.moveProviders(fromOffsets, toOffset)
+            }
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .leading)
+        .listStyle(.plain)
+        .scrollContentBackground(.hidden)
+        .background(ProviderListScrollInsetFixer())
+    }
+
+    private func rowInsets(withDivider: Bool, addTopPadding: Bool, addBottomPadding: Bool) -> EdgeInsets {
+        let base = ProviderListMetrics.rowInsets
+        let topInset = addTopPadding ? ProviderListMetrics.sectionEdgeInset : base.top
+        let bottomInset = addBottomPadding
+            ? ProviderListMetrics.sectionEdgeInset
+            : (withDivider ? ProviderListMetrics.dividerBottomInset : base.bottom)
+        return EdgeInsets(
+            top: topInset,
+            leading: base.leading,
+            bottom: bottomInset,
+            trailing: base.trailing)
+    }
+
+    private func rowID(provider: UsageProvider, suffix: String) -> String {
+        "\(provider.rawValue)-\(suffix)"
+    }
+}
+
+@MainActor
+private struct ProviderListBrandIcon: View {
+    let provider: UsageProvider
+
+    var body: some View {
+        Group {
+            if let brand = ProviderBrandIcon.image(for: self.provider, size: ProviderListMetrics.iconSize) {
+                Image(nsImage: brand)
+                    .resizable()
+                    .scaledToFit()
+                    .frame(width: ProviderListMetrics.iconSize, height: ProviderListMetrics.iconSize)
+            } else {
+                let descriptor = ProviderDescriptorRegistry.descriptor(for: self.provider)
+                let initial = String(descriptor.metadata.displayName.prefix(1)).uppercased()
+                let brandColor = Color(
+                    red: Double(descriptor.branding.color.red),
+                    green: Double(descriptor.branding.color.green),
+                    blue: Double(descriptor.branding.color.blue))
+                ZStack {
+                    RoundedRectangle(cornerRadius: RunicCornerRadius.sm, style: .continuous)
+                        .fill(brandColor.opacity(0.18))
+                    Text(initial)
+                        .font(.system(size: ProviderListMetrics.iconSize * 0.5, weight: .bold, design: .rounded))
+                        .foregroundStyle(brandColor)
+                }
+                .frame(width: ProviderListMetrics.iconSize, height: ProviderListMetrics.iconSize)
+            }
+        }
+        .shadow(color: .black.opacity(0.1), radius: 2, y: 1)
+        .accessibilityHidden(true)
+    }
+}
+
+@MainActor
+private struct ProviderInsightsView: View {
+    let lines: [ProviderInsightLine]
+
+    var body: some View {
+        LazyVGrid(
+            columns: [
+                GridItem(
+                    .adaptive(minimum: ProviderListMetrics.providerInsightsGridItemMinWidth),
+                    spacing: ProviderListMetrics.providerInsightsChipSpacing)
+            ],
+            alignment: .leading,
+            spacing: ProviderListMetrics.providerInsightsChipSpacing)
+        {
+            ForEach(self.lines) { line in
+                ProviderInsightChip(line: line)
+            }
+        }
+        .padding(ProviderListMetrics.insightsCardPadding)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .background(
+            RoundedRectangle(
+                cornerRadius: ProviderListMetrics.providerInsightsCardCornerRadius,
+                style: .continuous)
+                .fill(Color(nsColor: .controlBackgroundColor).opacity(0.42))
+        )
+        .overlay {
+            RoundedRectangle(
+                cornerRadius: ProviderListMetrics.providerInsightsCardCornerRadius,
+                style: .continuous)
+                .strokeBorder(Color(nsColor: .separatorColor).opacity(0.22), lineWidth: 1)
+        }
+    }
+}
+
+private struct ProviderInsightChip: View {
+    let line: ProviderInsightLine
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
+            Text(line.label.uppercased())
+                .font(.caption2.weight(.semibold))
+                .tracking(0.2)
+                .foregroundStyle(.tertiary)
+            Text(line.value)
+                .font(.caption)
+                .foregroundStyle(.secondary)
+                .lineLimit(2)
+                .fixedSize(horizontal: false, vertical: true)
+                .textSelection(.enabled)
+                .help(line.help ?? "")
+        }
+        .padding(ProviderListMetrics.providerInsightsChipPadding)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .background(
+            RoundedRectangle(cornerRadius: ProviderListMetrics.providerInsightsChipCornerRadius, style: .continuous)
+                .fill(Color(nsColor: .textBackgroundColor).opacity(0.45))
+        )
+        .overlay(
+            RoundedRectangle(cornerRadius: ProviderListMetrics.providerInsightsChipCornerRadius, style: .continuous)
+                .strokeBorder(Color(nsColor: .separatorColor).opacity(0.2), lineWidth: 1)
+        )
+        .help(line.help ?? "")
+        .accessibilityLabel("\(line.label): \(line.value)")
+        .accessibilityHint(line.help ?? "")
+    }
+}
+
+@MainActor
+private struct ProviderListProviderRowView: View {
+    let provider: UsageProvider
+    @Bindable var store: UsageStore
+    @Binding var isEnabled: Bool
+    let subtitle: String
+    let usageStatus: ProviderUsageStatus
+    let sourceLabel: String
+    let statusLabel: String
+    let errorDisplay: ProviderErrorDisplay?
+    @Binding var isErrorExpanded: Bool
+    let onCopyError: (String) -> Void
+    @State private var isHovering = false
+    @FocusState private var isToggleFocused: Bool
+
+    var body: some View {
+        let isRefreshing = self.store.refreshingProviders.contains(self.provider)
+        let showReorderHandle = self.isHovering || self.isToggleFocused
+        let metadata = self.store.metadata(for: self.provider)
+        let insightLines = ProviderInsightsComposer.lines(for: self.provider, store: self.store, maxRows: 4)
+
+        HStack(alignment: .top, spacing: ProviderListMetrics.rowSpacing) {
+            Toggle("", isOn: self.$isEnabled)
+                .labelsHidden()
+                .toggleStyle(.checkbox)
+                .alignmentGuide(.top) { d in d[VerticalAlignment.center] }
+                .focused(self.$isToggleFocused)
+
+            VStack(alignment: .leading, spacing: RunicSpacing.sm) {
+                VStack(alignment: .leading, spacing: RunicSpacing.sm) {
+                    HStack(alignment: .top, spacing: RunicSpacing.sm) {
+                        ProviderListBrandIcon(provider: self.provider)
+                        VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                            Text(metadata.displayName)
+                                .font(.headline.weight(.semibold))
+                                .foregroundStyle(.primary)
+                            Text(self.subtitle)
+                                .font(.footnote)
+                                .foregroundStyle(.secondary)
+                                .fixedSize(horizontal: false, vertical: true)
+                        }
+                        Spacer(minLength: RunicSpacing.xs)
+                    }
+
+                    HStack(alignment: .center, spacing: RunicSpacing.xs) {
+                        self.sourceBadge
+                        Text(self.statusLabel)
+                            .font(.caption2)
+                            .foregroundStyle(.tertiary)
+                            .lineLimit(1)
+
+                        if isRefreshing {
+                            ProgressView()
+                                .controlSize(.small)
+                                .alignmentGuide(.firstTextBaseline) { d in d[VerticalAlignment.center] }
+                            Text("Refreshing…")
+                                .font(.caption2)
+                                .foregroundStyle(.secondary)
+                        } else {
+                            self.usageStatusBadge
+                                .alignmentGuide(.firstTextBaseline) { d in d[VerticalAlignment.center] }
+                        }
+                    }
+                }
+                .contentShape(Rectangle())
+                .onTapGesture { self.isEnabled.toggle() }
+
+                if !insightLines.isEmpty {
+                    ProviderInsightsView(lines: insightLines)
+                        .padding(.top, RunicSpacing.xxs)
+                }
+
+                if let errorDisplay {
+                    ProviderErrorView(
+                        title: "Last \(metadata.displayName) fetch failed:",
+                        display: errorDisplay,
+                        isExpanded: self.$isErrorExpanded,
+                        onCopy: { self.onCopyError(errorDisplay.full) })
+                        .padding(.top, RunicSpacing.xxs)
+                }
+            }
+            .frame(maxWidth: .infinity, alignment: .leading)
+        }
+        .padding(ProviderListMetrics.providerCardPadding)
+        .background(self.cardBackground)
+        .overlay {
+            RoundedRectangle(cornerRadius: ProviderListMetrics.providerCardCornerRadius, style: .continuous)
+                .strokeBorder(self.cardBorderColor, lineWidth: 1)
+        }
+        .overlay(alignment: .topLeading) {
+            ProviderListReorderHandle(isVisible: showReorderHandle)
+                .offset(
+                    x: -(ProviderListMetrics.reorderHandleSize + RunicSpacing.xs),
+                    y: RunicSpacing.sm)
+        }
+        .onHover { isHovering in
+            self.isHovering = isHovering
+        }
+    }
+
+    private var usageStatusBadge: some View {
+        let (color, backgroundColor) = self.usageStatusColors
+
+        return Text(self.usageStatus.text)
+            .font(.caption2.weight(.medium))
+            .padding(.horizontal, ProviderListMetrics.statusBadgePaddingH)
+            .padding(.vertical, ProviderListMetrics.statusBadgePaddingV)
+            .background(Capsule(style: .continuous).fill(backgroundColor))
+            .foregroundStyle(color)
+    }
+
+    private var sourceBadge: some View {
+        Text(self.sourceLabel)
+            .font(.caption2.weight(.medium))
+            .foregroundStyle(.secondary)
+            .padding(.horizontal, RunicSpacing.xs)
+            .padding(.vertical, RunicSpacing.xxxs)
+            .background(
+                Capsule(style: .continuous)
+                    .fill(Color(nsColor: .controlBackgroundColor).opacity(0.7))
+            )
+    }
+
+    private var usageStatusColors: (Color, Color) {
+        switch self.usageStatus.style {
+        case .success:
+            return (.green, Color.green.opacity(0.15))
+        case .error:
+            return (.red, Color.red.opacity(0.15))
+        case .neutral:
+            return (.secondary, Color(nsColor: .controlBackgroundColor))
+        }
+    }
+
+    private var rowBackgroundColor: Color {
+        if self.isHovering {
+            return Color(nsColor: .controlBackgroundColor).opacity(0.72)
+        } else if self.isEnabled {
+            return Color(nsColor: .controlBackgroundColor).opacity(ProviderListMetrics.providerCardBackgroundOpacity)
+        }
+        return Color(nsColor: .controlBackgroundColor).opacity(0.35)
+    }
+
+    private var cardBorderColor: Color {
+        if self.isHovering {
+            return Color.accentColor.opacity(0.35)
+        }
+        if self.isEnabled {
+            return Color(nsColor: .separatorColor).opacity(ProviderListMetrics.providerCardBorderOpacity)
+        }
+        return Color(nsColor: .separatorColor).opacity(0.18)
+    }
+
+    private var cardBackground: some View {
+        RoundedRectangle(cornerRadius: ProviderListMetrics.providerCardCornerRadius, style: .continuous)
+            .fill(self.rowBackgroundColor)
+    }
+}
+
+@MainActor
+private struct ProviderListReorderHandle: View {
+    let isVisible: Bool
+
+    var body: some View {
+        VStack(spacing: ProviderListMetrics.reorderDotSpacing) {
+            ForEach(0..<3, id: \.self) { _ in
+                HStack(spacing: ProviderListMetrics.reorderDotSpacing) {
+                    Circle()
+                        .frame(
+                            width: ProviderListMetrics.reorderDotSize,
+                            height: ProviderListMetrics.reorderDotSize)
+                    Circle()
+                        .frame(
+                            width: ProviderListMetrics.reorderDotSize,
+                            height: ProviderListMetrics.reorderDotSize)
+                }
+            }
+        }
+        .frame(width: ProviderListMetrics.reorderHandleSize, height: ProviderListMetrics.reorderHandleSize)
+        .foregroundStyle(.tertiary)
+        .opacity(self.isVisible ? 1 : 0)
+        .animation(.easeInOut(duration: 0.15), value: self.isVisible)
+        .help("Drag to reorder")
+        .accessibilityHidden(true)
+        .allowsHitTesting(false)
+    }
+}
+
+@MainActor
+private struct ProviderListSectionDividerView: View {
+    var body: some View {
+        Rectangle()
+            .fill(Color(nsColor: .separatorColor).opacity(0.5))
+            .frame(height: 1)
+            .padding(.leading, ProviderListMetrics.dividerLeadingInset)
+            .padding(.trailing, ProviderListMetrics.dividerTrailingInset)
+    }
+}
+
+extension View {
+    @ViewBuilder
+    fileprivate func providerSectionDivider(isVisible: Bool) -> some View {
+        overlay(alignment: .bottom) {
+            if isVisible {
+                ProviderListSectionDividerView()
+            }
+        }
+    }
+}
+
+@MainActor
+private struct ProviderListToggleRowView: View {
+    let provider: UsageProvider
+    let toggle: ProviderSettingsToggleDescriptor
+
+    var body: some View {
+        HStack(alignment: .top, spacing: ProviderListMetrics.rowSpacing) {
+            Toggle("", isOn: self.toggle.binding)
+                .labelsHidden()
+                .toggleStyle(.checkbox)
+                .alignmentGuide(.top) { d in d[VerticalAlignment.center] }
+
+            VStack(alignment: .leading, spacing: RunicSpacing.sm) {
+                VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                    Text(self.toggle.title)
+                        .font(.callout.weight(.semibold))
+                    Text(self.toggle.subtitle)
+                        .font(.footnote)
+                        .foregroundStyle(.secondary)
+                        .fixedSize(horizontal: false, vertical: true)
+                }
+
+                if self.toggle.binding.wrappedValue {
+                    if let status = self.toggle.statusText?(), !status.isEmpty {
+                        Text(status)
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                            .lineLimit(4)
+                            .fixedSize(horizontal: false, vertical: true)
+                            .padding(RunicSpacing.xs)
+                            .frame(maxWidth: .infinity, alignment: .leading)
+                            .background(
+                                RoundedRectangle(cornerRadius: RunicCornerRadius.sm, style: .continuous)
+                                    .fill(Color(nsColor: .controlBackgroundColor).opacity(0.55))
+                            )
+                            .overlay {
+                                RoundedRectangle(cornerRadius: RunicCornerRadius.sm, style: .continuous)
+                                    .strokeBorder(Color(nsColor: .separatorColor).opacity(0.2), lineWidth: 1)
+                            }
+                    }
+
+                    let actions = self.toggle.actions.filter { $0.isVisible?() ?? true }
+                    if !actions.isEmpty {
+                        HStack(spacing: RunicSpacing.xs) {
+                            ForEach(actions) { action in
+                                Button(action.title) {
+                                    Task { @MainActor in
+                                        await action.perform()
+                                    }
+                                }
+                                .applyProviderSettingsButtonStyle(action.style)
+                                .controlSize(.small)
+                            }
+                        }
+                    }
+                }
+            }
+            .padding(.leading, ProviderListMetrics.iconSize + RunicSpacing.sm)
+            .frame(maxWidth: .infinity, alignment: .leading)
+        }
+        .padding(ProviderListMetrics.supplementalCardPadding)
+        .background(self.supplementalCardBackground)
+        .overlay {
+            RoundedRectangle(cornerRadius: ProviderListMetrics.providerCardCornerRadius, style: .continuous)
+                .strokeBorder(self.supplementalCardBorderColor, lineWidth: 1)
+        }
+        .onChange(of: self.toggle.binding.wrappedValue) { _, enabled in
+            guard let onChange = self.toggle.onChange else { return }
+            Task { @MainActor in
+                await onChange(enabled)
+            }
+        }
+        .task(id: self.toggle.binding.wrappedValue) {
+            guard self.toggle.binding.wrappedValue else { return }
+            guard let onAppear = self.toggle.onAppearWhenEnabled else { return }
+            await onAppear()
+        }
+    }
+
+    private var supplementalCardBackground: some View {
+        RoundedRectangle(cornerRadius: ProviderListMetrics.providerCardCornerRadius, style: .continuous)
+            .fill(Color(nsColor: .controlBackgroundColor).opacity(ProviderListMetrics.supplementalCardBackgroundOpacity))
+    }
+
+    private var supplementalCardBorderColor: Color {
+        Color(nsColor: .separatorColor).opacity(ProviderListMetrics.supplementalCardBorderOpacity)
+    }
+}
+
+@MainActor
+private struct ProviderListFieldRowView: View {
+    let provider: UsageProvider
+    let field: ProviderSettingsFieldDescriptor
+
+    var body: some View {
+        HStack(alignment: .top, spacing: ProviderListMetrics.rowSpacing) {
+            Color.clear
+                .frame(width: ProviderListMetrics.checkboxSize, height: ProviderListMetrics.checkboxSize)
+                .alignmentGuide(.top) { d in d[VerticalAlignment.center] }
+
+            VStack(alignment: .leading, spacing: RunicSpacing.sm) {
+                VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                    Text(self.field.title)
+                        .font(.callout.weight(.semibold))
+                    Text(self.field.subtitle)
+                        .font(.footnote)
+                        .foregroundStyle(.secondary)
+                        .fixedSize(horizontal: false, vertical: true)
+                }
+
+                switch self.field.kind {
+                case .plain:
+                    TextField(self.field.placeholder ?? "", text: self.field.binding)
+                        .textFieldStyle(.roundedBorder)
+                        .font(.callout)
+                        .frame(maxWidth: ProviderListMetrics.fieldMaxWidth, alignment: .leading)
+                case .secure:
+                    SecureField(self.field.placeholder ?? "", text: self.field.binding)
+                        .textFieldStyle(.roundedBorder)
+                        .font(.callout)
+                        .frame(maxWidth: ProviderListMetrics.fieldMaxWidth, alignment: .leading)
+                }
+
+                let actions = self.field.actions.filter { $0.isVisible?() ?? true }
+                if !actions.isEmpty {
+                    HStack(spacing: RunicSpacing.xs) {
+                        ForEach(actions) { action in
+                            Button(action.title) {
+                                Task { @MainActor in
+                                    await action.perform()
+                                }
+                            }
+                            .applyProviderSettingsButtonStyle(action.style)
+                            .controlSize(.small)
+                        }
+                    }
+                }
+            }
+            .padding(.leading, ProviderListMetrics.iconSize + RunicSpacing.sm)
+            .frame(maxWidth: .infinity, alignment: .leading)
+        }
+        .padding(ProviderListMetrics.supplementalCardPadding)
+        .background(self.supplementalCardBackground)
+        .overlay {
+            RoundedRectangle(cornerRadius: ProviderListMetrics.providerCardCornerRadius, style: .continuous)
+                .strokeBorder(self.supplementalCardBorderColor, lineWidth: 1)
+        }
+    }
+
+    private var supplementalCardBackground: some View {
+        RoundedRectangle(cornerRadius: ProviderListMetrics.providerCardCornerRadius, style: .continuous)
+            .fill(Color(nsColor: .controlBackgroundColor).opacity(ProviderListMetrics.supplementalCardBackgroundOpacity))
+    }
+
+    private var supplementalCardBorderColor: Color {
+        Color(nsColor: .separatorColor).opacity(0.18)
+    }
+}
+
+extension View {
+    @ViewBuilder
+    fileprivate func applyProviderSettingsButtonStyle(_ style: ProviderSettingsActionDescriptor.Style) -> some View {
+        switch style {
+        case .bordered:
+            self.buttonStyle(.bordered)
+        case .link:
+            self.buttonStyle(.link)
+        }
+    }
+}
+
+private struct ProviderErrorDisplay: Sendable {
+    let preview: String
+    let full: String
+}
+
+@MainActor
+private struct ProviderListScrollInsetFixer: NSViewRepresentable {
+    private final class HitTestIgnoringView: NSView {
+        override func hitTest(_ point: NSPoint) -> NSView? { nil }
+    }
+
+    func makeNSView(context: Context) -> NSView {
+        HitTestIgnoringView()
+    }
+
+    func updateNSView(_ nsView: NSView, context: Context) {
+        Task { @MainActor in
+            guard let scrollView = Self.findScrollView(from: nsView) else { return }
+            if scrollView.automaticallyAdjustsContentInsets {
+                scrollView.automaticallyAdjustsContentInsets = false
+            }
+            let zeroInsets = NSEdgeInsets(top: 0, left: 0, bottom: 0, right: 0)
+            let currentContentInsets = scrollView.contentInsets
+            if currentContentInsets.top != 0 || currentContentInsets.left != 0 ||
+               currentContentInsets.bottom != 0 || currentContentInsets.right != 0 {
+                scrollView.contentInsets = zeroInsets
+            }
+            let currentScrollerInsets = scrollView.scrollerInsets
+            if currentScrollerInsets.top != 0 || currentScrollerInsets.left != 0 ||
+               currentScrollerInsets.bottom != 0 || currentScrollerInsets.right != 0 {
+                scrollView.scrollerInsets = zeroInsets
+            }
+        }
+    }
+
+    private static func findScrollView(from view: NSView) -> NSScrollView? {
+        var current: NSView? = view
+        while let candidate = current {
+            if let scroll = candidate as? NSScrollView { return scroll }
+            if let found = candidate.subviews.compactMap({ $0 as? NSScrollView }).first {
+                return found
+            }
+            current = candidate.superview
+        }
+        return nil
+    }
+}
+
+@MainActor
+private struct ProviderErrorView: View {
+    let title: String
+    let display: ProviderErrorDisplay
+    @Binding var isExpanded: Bool
+    let onCopy: () -> Void
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+            HStack(alignment: .center, spacing: RunicSpacing.xs) {
+                Image(systemName: "exclamationmark.triangle.fill")
+                    .font(.caption)
+                    .foregroundStyle(.orange)
+                    .alignmentGuide(.firstTextBaseline) { d in d[VerticalAlignment.center] }
+                Text(self.title)
+                    .font(.callout.weight(.semibold))
+                    .foregroundStyle(.orange)
+                Spacer()
+                Button {
+                    self.onCopy()
+                } label: {
+                    HStack(alignment: .center, spacing: RunicSpacing.xxs) {
+                        Image(systemName: "doc.on.doc")
+                            .font(.caption)
+                        Text("Copy")
+                            .font(.caption)
+                    }
+                }
+                .buttonStyle(.bordered)
+                .controlSize(.small)
+                .help("Copy error to clipboard")
+                .alignmentGuide(.firstTextBaseline) { d in d[VerticalAlignment.center] }
+            }
+
+            Text(self.display.preview)
+                .font(.callout)
+                .foregroundStyle(.secondary)
+                .lineLimit(3)
+                .fixedSize(horizontal: false, vertical: true)
+                .padding(RunicSpacing.xs)
+                .frame(maxWidth: .infinity, alignment: .leading)
+                .background(
+                    RoundedRectangle(cornerRadius: ProviderListMetrics.errorCardCornerRadius, style: .continuous)
+                        .fill(Color.orange.opacity(0.08))
+                )
+
+            if self.display.preview != self.display.full {
+                Button(self.isExpanded ? "Hide details" : "Show details") { self.isExpanded.toggle() }
+                    .buttonStyle(.link)
+                    .font(.callout)
+            }
+
+            if self.isExpanded {
+                ScrollView(.horizontal, showsIndicators: true) {
+                    Text(self.display.full)
+                        .font(.system(.caption, design: .monospaced))
+                        .foregroundStyle(.primary)
+                        .textSelection(.enabled)
+                        .fixedSize(horizontal: false, vertical: true)
+                        .padding(ProviderListMetrics.errorCardPadding)
+                }
+                .frame(maxHeight: 200)
+                .background(
+                    RoundedRectangle(cornerRadius: ProviderListMetrics.errorCardCornerRadius, style: .continuous)
+                        .fill(Color(nsColor: .textBackgroundColor))
+                )
+                .overlay(
+                    RoundedRectangle(cornerRadius: ProviderListMetrics.errorCardCornerRadius, style: .continuous)
+                        .stroke(Color.orange.opacity(0.3), lineWidth: 1)
+                )
+            }
+        }
+        .padding(ProviderListMetrics.errorCardPadding)
+        .background(
+            RoundedRectangle(cornerRadius: ProviderListMetrics.errorCardCornerRadius, style: .continuous)
+                .fill(Color.orange.opacity(0.03))
+        )
+    }
+}
+
+@MainActor
+private struct ProviderSettingsConfirmationState: Identifiable {
+    let id = UUID()
+    let title: String
+    let message: String
+    let confirmTitle: String
+    let onConfirm: () -> Void
+
+    init(confirmation: ProviderSettingsConfirmation) {
+        self.title = confirmation.title
+        self.message = confirmation.message
+        self.confirmTitle = confirmation.confirmTitle
+        self.onConfirm = confirmation.onConfirm
+    }
+}
+
+// MARK: - Sidebar layout views
+
+@MainActor
+private struct ProviderSidebarRow: View {
+    let provider: UsageProvider
+    @Bindable var store: UsageStore
+    let isEnabled: Bool
+    let isSelected: Bool
+
+    var body: some View {
+        HStack(spacing: RunicSpacing.xs) {
+            if let brand = ProviderBrandIcon.image(for: self.provider, size: 20) {
+                Image(nsImage: brand)
+                    .resizable()
+                    .scaledToFit()
+                    .frame(width: 20, height: 20)
+                    .foregroundStyle(self.isEnabled ? .primary : .tertiary)
+            } else {
+                Image(systemName: "circle.dotted")
+                    .font(.system(size: 16))
+                    .foregroundStyle(.tertiary)
+                    .frame(width: 20, height: 20)
+            }
+            Text(self.store.metadata(for: self.provider).displayName)
+                .font(.body)
+                .foregroundStyle(self.isEnabled ? .primary : .secondary)
+                .lineLimit(1)
+                .layoutPriority(1)
+        }
+        .padding(.horizontal, RunicSpacing.xs)
+        .padding(.vertical, RunicSpacing.sm)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .background(
+            RoundedRectangle(cornerRadius: RunicCornerRadius.sm, style: .continuous)
+                .fill(self.isSelected ? Color.accentColor.opacity(0.14) : .clear))
+        .overlay(
+            RoundedRectangle(cornerRadius: RunicCornerRadius.sm, style: .continuous)
+                .stroke(
+                    self.isSelected ? Color.accentColor.opacity(0.45) : Color.clear,
+                    lineWidth: 1))
+        .contentShape(Rectangle())
+        .opacity(self.isEnabled ? 1 : 0.6)
+    }
+}
+
+private struct ProviderSidebarSectionCard<Content: View>: View {
+    private let content: Content
+
+    init(@ViewBuilder content: () -> Content) {
+        self.content = content()
+    }
+
+    var body: some View {
+        self.content
+            .padding(ProviderListMetrics.sidebarCardPadding)
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .background(
+                RoundedRectangle(
+                    cornerRadius: ProviderListMetrics.sidebarCardCornerRadius,
+                    style: .continuous)
+                    .fill(Color(nsColor: .controlBackgroundColor).opacity(ProviderListMetrics.sidebarCardBackgroundOpacity))
+            )
+            .overlay(
+                RoundedRectangle(
+                    cornerRadius: ProviderListMetrics.sidebarCardCornerRadius,
+                    style: .continuous)
+                    .strokeBorder(Color(nsColor: .separatorColor).opacity(ProviderListMetrics.sidebarCardBorderOpacity), lineWidth: 1)
+            )
+    }
+}
+
+private struct ProviderHistoryNavigationButton: View {
+    let systemName: String
+    let enabled: Bool
+    let help: String
+    let action: () -> Void
+
+    var body: some View {
+        Button(action: self.action) {
+            Image(systemName: self.systemName)
+                .font(.caption.weight(.semibold))
+                .foregroundStyle(self.enabled ? .secondary : .tertiary)
+                .frame(width: 26, height: 26)
+        }
+        .buttonStyle(.plain)
+        .disabled(!self.enabled)
+        .background(
+            Circle()
+                .fill(Color(nsColor: .controlBackgroundColor).opacity(self.enabled ? 0.48 : 0.2))
+                .overlay(
+                    Circle()
+                        .strokeBorder(
+                            Color(
+                                nsColor: .separatorColor).opacity(self.enabled ? 0.28 : 0.1),
+                            lineWidth: 1))
+        )
+        .help(self.help)
+        .accessibilityLabel(help)
+    }
+}
+
+private struct ProviderSidebarSectionHeader: View {
+    let title: String
+
+    var body: some View {
+        Text(self.title)
+            .font(.subheadline.weight(.semibold))
+            .foregroundStyle(.secondary)
+    }
+}
+
+@MainActor
+private struct ProviderSidebarKeyValueRow: View {
+    let label: String
+    let value: String
+    let helpText: String?
+
+    var body: some View {
+        HStack(alignment: .firstTextBaseline, spacing: RunicSpacing.xs) {
+            Text("\(self.label):")
+                .font(.caption)
+                .foregroundStyle(.tertiary)
+                .frame(width: ProviderListMetrics.sidebarStatusLabelWidth, alignment: .leading)
+            if let helpText = self.helpText {
+                Text(self.value)
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .lineLimit(2)
+                    .fixedSize(horizontal: false, vertical: true)
+                    .textSelection(.enabled)
+                    .help(helpText)
+            } else {
+                Text(self.value)
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .lineLimit(2)
+                    .fixedSize(horizontal: false, vertical: true)
+                    .textSelection(.enabled)
+            }
+        }
+    }
+}
+
+@MainActor
+private struct ProviderSidebarMetricChip: View {
+    let title: String
+    let value: String
+    let helpText: String?
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
+            Text(self.title)
+                .font(.caption2.weight(.semibold))
+                .foregroundStyle(.tertiary)
+                .textCase(.uppercase)
+            Text(self.value)
+                .font(.caption.weight(.medium))
+                .foregroundStyle(.secondary)
+                .lineLimit(2)
+                .fixedSize(horizontal: false, vertical: true)
+                .textSelection(.enabled)
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .padding(.horizontal, RunicSpacing.xs)
+        .padding(.vertical, RunicSpacing.xs)
+        .background(
+            RoundedRectangle(
+                cornerRadius: ProviderListMetrics.sidebarMicroCardCornerRadius,
+                style: .continuous)
+                .fill(Color(nsColor: .textBackgroundColor).opacity(ProviderListMetrics.sidebarMicroCardBackgroundOpacity))
+        )
+        .overlay(
+            RoundedRectangle(
+                cornerRadius: ProviderListMetrics.sidebarMicroCardCornerRadius,
+                style: .continuous)
+                .strokeBorder(Color(
+                    nsColor: .separatorColor).opacity(ProviderListMetrics.sidebarMicroCardBorderOpacity), lineWidth: 1)
+        )
+        .help(self.helpText ?? "")
+    }
+}
+
+private enum ProviderDetailSubview: String, CaseIterable, Identifiable {
+    case overview = "Overview"
+    case history = "History"
+
+    var id: String { self.rawValue }
+}
+
+private enum ProviderHistoryMetricMode: String, CaseIterable, Identifiable {
+    case tokens = "Tokens"
+    case cost = "Cost"
+    case requests = "Requests"
+
+    var id: String { self.rawValue }
+}
+
+private enum ProviderHistoryDayDetailMode: String, CaseIterable, Identifiable {
+    case summary = "Summary"
+    case models = "Models"
+    case projects = "Projects"
+
+    var id: String { self.rawValue }
+}
+
+@MainActor
+private struct ProviderHistoryCalendarDayCell: View {
+    let dayNumber: Int
+    let isInMonth: Bool
+    let isSelected: Bool
+    let hasActivity: Bool
+    let intensity: Double
+    let action: () -> Void
+
+    var body: some View {
+        Button(action: self.action) {
+            VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
+                Text("\(self.dayNumber)")
+                    .font(.caption.weight(self.isSelected ? .semibold : .regular))
+                    .foregroundStyle(self.isInMonth ? .primary : .tertiary)
+                Spacer(minLength: 0)
+                if self.hasActivity {
+                    Capsule(style: .continuous)
+                        .fill(Color.accentColor.opacity(0.35 + (0.45 * self.intensity)))
+                        .frame(height: 4)
+                } else {
+                    Capsule(style: .continuous)
+                        .fill(Color(nsColor: .separatorColor).opacity(self.isInMonth ? 0.14 : 0.08))
+                        .frame(height: 2)
+                }
+            }
+            .padding(RunicSpacing.xs)
+            .frame(maxWidth: .infinity, minHeight: 46, alignment: .topLeading)
+            .background(
+                RoundedRectangle(cornerRadius: RunicCornerRadius.sm, style: .continuous)
+                    .fill(self.backgroundColor)
+            )
+            .overlay(
+                RoundedRectangle(cornerRadius: RunicCornerRadius.sm, style: .continuous)
+                    .strokeBorder(self.borderColor, lineWidth: self.isSelected ? 1.5 : 1)
+            )
+            .opacity(self.isInMonth ? 1 : 0.52)
+        }
+        .buttonStyle(.plain)
+    }
+
+    private var backgroundColor: Color {
+        if self.isSelected {
+            return Color.accentColor.opacity(0.18)
+        }
+        if self.hasActivity {
+            return Color.accentColor.opacity(0.06 + (0.18 * self.intensity))
+        }
+        return Color(nsColor: .textBackgroundColor).opacity(self.isInMonth ? 0.55 : 0.32)
+    }
+
+    private var borderColor: Color {
+        if self.isSelected {
+            return Color.accentColor.opacity(0.75)
+        }
+        return Color(nsColor: .separatorColor).opacity(self.isInMonth ? 0.22 : 0.12)
+    }
+}
+
+@MainActor
+private struct ProviderSidebarDetailView: View {
+    let provider: UsageProvider
+    @Bindable var store: UsageStore
+    @Binding var isEnabled: Bool
+    let subtitle: String
+    let usageStatus: ProviderUsageStatus
+    let sourceLabel: String
+    let statusLabel: String
+    let settingsToggles: [ProviderSettingsToggleDescriptor]
+    let settingsFields: [ProviderSettingsFieldDescriptor]
+    let errorDisplay: ProviderErrorDisplay?
+    @Binding var isErrorExpanded: Bool
+    let onCopyError: (String) -> Void
+    @State private var diagnosticsCopyStatus: String?
+    @State private var selectedSubview: ProviderDetailSubview = .overview
+    @State private var historyMetricMode: ProviderHistoryMetricMode = .tokens
+    @State private var historyMonthStart: Date = Self.monthStart(for: Date())
+    @State private var historySnapshot: ProviderHistoryMonthSnapshot?
+    @State private var historySelectedDay: Date?
+    @State private var historyDayDetailMode: ProviderHistoryDayDetailMode = .summary
+    @State private var historyIsLoading = false
+    @State private var historyError: String?
+
+    var body: some View {
+        let insightLines = ProviderInsightsComposer.lines(for: self.provider, store: self.store)
+        let topModelLines = self.topModelLines
+        let topProjectLines = self.topProjectLines
+
+        ScrollView {
+            VStack(alignment: .leading, spacing: ProviderListMetrics.sidebarSectionSpacing) {
+                ProviderSidebarSectionCard {
+                    VStack(alignment: .leading, spacing: RunicSpacing.md) {
+                        HStack(alignment: .top, spacing: RunicSpacing.sm) {
+                            ProviderListBrandIcon(provider: self.provider)
+                            VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                                Text(self.store.metadata(for: self.provider).displayName)
+                                    .font(.title2.weight(.semibold))
+                                Text(self.subtitle)
+                                    .font(.caption)
+                                    .foregroundStyle(.secondary)
+                            }
+                            Spacer()
+                            Toggle("Enabled", isOn: self.$isEnabled)
+                                .toggleStyle(.switch)
+                                .labelsHidden()
+                        }
+                        Divider()
+
+                        Picker("View", selection: self.$selectedSubview) {
+                            ForEach(ProviderDetailSubview.allCases) { view in
+                                Text(view.rawValue).tag(view)
+                            }
+                        }
+                        .pickerStyle(.segmented)
+                    }
+                }
+
+                if self.selectedSubview == .overview {
+                    ProviderSidebarSectionCard {
+                        VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+                            VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                                ProviderSidebarSectionHeader(title: "Overview")
+                                ProviderSidebarKeyValueRow(label: "Source", value: self.sourceLabel, helpText: nil)
+                                ProviderSidebarKeyValueRow(label: "Updated", value: self.statusLabel, helpText: nil)
+                                if let runtimeMetrics = self.runtimeMetrics {
+                                    ProviderSidebarKeyValueRow(
+                                        label: "Runtime",
+                                        value: runtimeMetrics.lineText,
+                                        helpText: runtimeMetrics.hoverText)
+                                }
+                                self.statusBadge
+                            }
+
+                            if !self.quickMetrics.isEmpty {
+                                LazyVGrid(
+                                    columns: [
+                                        GridItem(.flexible(minimum: 120), spacing: RunicSpacing.xs),
+                                        GridItem(.flexible(minimum: 120), spacing: RunicSpacing.xs),
+                                    ],
+                                    alignment: .leading,
+                                    spacing: RunicSpacing.xs)
+                                {
+                                    ForEach(self.quickMetrics) { metric in
+                                        ProviderSidebarMetricChip(
+                                            title: metric.title,
+                                            value: metric.value,
+                                            helpText: metric.helpText)
+                                    }
+                                }
+                            }
+
+                            HStack(spacing: RunicSpacing.xs) {
+                                Button("Copy diagnostics") {
+                                    self.copyDiagnostics()
+                                }
+                                .buttonStyle(.bordered)
+                                .controlSize(.small)
+                                .help("Copy fetch path, reliability, anomaly, and budget/forecast details.")
+
+                                if let diagnosticsCopyStatus {
+                                    Text(diagnosticsCopyStatus)
+                                        .font(.caption2)
+                                        .foregroundStyle(.tertiary)
+                                }
+                            }
+                        }
+                    }
+
+                    if !insightLines.isEmpty {
+                        ProviderSidebarSectionCard {
+                            VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                                ProviderSidebarSectionHeader(title: "Insights")
+                                ProviderInsightsView(lines: insightLines)
+                            }
+                        }
+                    }
+
+                    if !topModelLines.isEmpty || !topProjectLines.isEmpty {
+                        ProviderSidebarSectionCard {
+                            VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                                ProviderSidebarSectionHeader(title: "Activity leaders")
+                                HStack(alignment: .top, spacing: RunicSpacing.md) {
+                                    if !topModelLines.isEmpty {
+                                        VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                                            Text(self.modelSectionTitle)
+                                                .font(.caption2.weight(.semibold))
+                                                .foregroundStyle(.secondary)
+                                            ForEach(Array(topModelLines.enumerated()), id: \.offset) { index, line in
+                                                Text("\(index + 1). \(line)")
+                                                    .font(.caption)
+                                                    .foregroundStyle(.secondary)
+                                                    .textSelection(.enabled)
+                                            }
+                                        }
+                                        .frame(maxWidth: .infinity, alignment: .leading)
+                                    }
+
+                                    if !topProjectLines.isEmpty {
+                                        VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                                            Text("Projects")
+                                                .font(.caption2.weight(.semibold))
+                                                .foregroundStyle(.secondary)
+                                            ForEach(Array(topProjectLines.enumerated()), id: \.offset) { index, line in
+                                                Text("\(index + 1). \(line)")
+                                                    .font(.caption)
+                                                    .foregroundStyle(.secondary)
+                                                    .textSelection(.enabled)
+                                            }
+                                        }
+                                        .frame(maxWidth: .infinity, alignment: .leading)
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    self.historyContent
+                }
+
+                if let errorDisplay, self.isEnabled {
+                    ProviderErrorView(
+                        title: "Last fetch failed:",
+                        display: errorDisplay,
+                        isExpanded: self.$isErrorExpanded,
+                        onCopy: { self.onCopyError(errorDisplay.full) })
+                }
+
+                if self.isEnabled, !self.settingsFields.isEmpty {
+                    ProviderSidebarSectionCard {
+                        VStack(alignment: .leading, spacing: RunicSpacing.sm) {
+                            ProviderSidebarSectionHeader(title: "Settings fields")
+                            ForEach(self.settingsFields) { field in
+                                VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                                    Text(field.title)
+                                        .font(.body.weight(.medium))
+                                    Text(field.subtitle)
+                                        .font(.caption)
+                                        .foregroundStyle(.secondary)
+                                    switch field.kind {
+                                    case .plain:
+                                        TextField(field.placeholder ?? "", text: field.binding)
+                                            .textFieldStyle(.roundedBorder)
+                                            .font(.callout)
+                                    case .secure:
+                                        SecureField(field.placeholder ?? "", text: field.binding)
+                                            .textFieldStyle(.roundedBorder)
+                                            .font(.callout)
+                                    }
+                                    self.fieldActions(field.actions)
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if self.isEnabled, !self.settingsToggles.isEmpty {
+                    ProviderSidebarSectionCard {
+                        VStack(alignment: .leading, spacing: RunicSpacing.sm) {
+                            ProviderSidebarSectionHeader(title: "Settings toggles")
+                            ForEach(self.settingsToggles) { toggle in
+                                VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                                    Toggle(isOn: toggle.binding) {
+                                        VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                                            Text(toggle.title)
+                                                .font(.body.weight(.medium))
+                                            Text(toggle.subtitle)
+                                                .font(.caption)
+                                                .foregroundStyle(.secondary)
+                                        }
+                                    }
+                                    .toggleStyle(.checkbox)
+
+                                    if toggle.binding.wrappedValue {
+                                        if let status = toggle.statusText?(), !status.isEmpty {
+                                            Text(status)
+                                                .font(.caption)
+                                                .foregroundStyle(.secondary)
+                                                .padding(RunicSpacing.xs)
+                                                .frame(maxWidth: .infinity, alignment: .leading)
+                                                .background(
+                                                    RoundedRectangle(
+                                                        cornerRadius: ProviderListMetrics.sidebarMicroCardCornerRadius,
+                                                        style: .continuous)
+                                                        .fill(Color(
+                                                            nsColor: .controlBackgroundColor).opacity(
+                                                                ProviderListMetrics.sidebarMicroCardBackgroundOpacity)))
+                                        }
+                                        self.toggleActions(toggle.actions)
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            .padding(RunicSpacing.lg)
+        }
+        .frame(maxWidth: .infinity, minHeight: 0, alignment: .topLeading)
+        .clipped()
+        .task(id: self.historyTaskID) {
+            guard self.selectedSubview == .history else { return }
+            await self.loadHistoryMonth()
+        }
+        .onChange(of: self.provider) { _, _ in
+            self.selectedSubview = .overview
+            self.historyMetricMode = .tokens
+            self.historyMonthStart = Self.monthStart(for: Date())
+            self.historySnapshot = nil
+            self.historySelectedDay = nil
+            self.historyDayDetailMode = .summary
+            self.historyError = nil
+            self.historyIsLoading = false
+        }
+    }
+
+    private var statusBadge: some View {
+        let (color, bg) = self.statusColors
+        return Text(self.usageStatus.text)
+            .font(.caption2.weight(.medium))
+            .padding(.horizontal, RunicSpacing.xs)
+            .padding(.vertical, RunicSpacing.xxs)
+            .background(bg)
+            .foregroundStyle(color)
+            .clipShape(.capsule)
+    }
+
+    private var statusColors: (Color, Color) {
+        switch self.usageStatus.style {
+        case .success: return (.green, Color.green.opacity(0.15))
+        case .error: return (.red, Color.red.opacity(0.15))
+        case .neutral: return (.secondary, Color(nsColor: .controlBackgroundColor))
+        }
+    }
+
+    private var historyTaskID: String {
+        let monthKey = Int(self.historyMonthStart.timeIntervalSince1970)
+        return "\(self.provider.rawValue)-\(self.selectedSubview.rawValue)-\(monthKey)"
+    }
+
+    private var historyContent: some View {
+        ProviderSidebarSectionCard {
+            VStack(alignment: .leading, spacing: RunicSpacing.sm) {
+                HStack(alignment: .center, spacing: RunicSpacing.xs) {
+                    ProviderHistoryNavigationButton(
+                        systemName: "chevron.left",
+                        enabled: true,
+                        help: "Previous month") {
+                        self.shiftHistoryMonth(by: -1)
+                    }
+
+                    Text(self.historyMonthTitle)
+                        .font(.caption.weight(.semibold))
+                        .foregroundStyle(.secondary)
+                        .frame(minWidth: 130, alignment: .leading)
+
+                    ProviderHistoryNavigationButton(
+                        systemName: "chevron.right",
+                        enabled: self.canShiftHistoryForward,
+                        help: "Next month") {
+                        self.shiftHistoryMonth(by: 1)
+                    }
+
+                    Spacer()
+
+                    Picker("Metric", selection: self.$historyMetricMode) {
+                        ForEach(ProviderHistoryMetricMode.allCases) { mode in
+                            Text(mode.rawValue).tag(mode)
+                        }
+                    }
+                    .pickerStyle(.segmented)
+                    .frame(width: 220)
+                }
+
+                if self.historyIsLoading, self.historySnapshot == nil {
+                    HStack(spacing: RunicSpacing.xs) {
+                        ProgressView()
+                            .controlSize(.small)
+                        Text("Loading history…")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                    }
+                    .padding(.vertical, RunicSpacing.xs)
+                } else if let snapshot = self.historySnapshot {
+                    if !snapshot.isSupported {
+                        Text(snapshot.note ?? "History is not available for this provider yet.")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                            .padding(.vertical, RunicSpacing.xs)
+                            .frame(maxWidth: .infinity, alignment: .leading)
+                            .background(
+                                RoundedRectangle(
+                                    cornerRadius: ProviderListMetrics.sidebarMicroCardCornerRadius,
+                                    style: .continuous)
+                                    .fill(Color(nsColor: .controlBackgroundColor).opacity(ProviderListMetrics.sidebarCardBackgroundOpacity))
+                            )
+                    } else {
+                        if let note = snapshot.note, !note.isEmpty {
+                            Text(note)
+                                .font(.caption2)
+                                .foregroundStyle(.tertiary)
+                        }
+                        Text(snapshot.days.count == 1 ? "1 active day in \(self.historyMonthTitle)." : "\(snapshot.days.count) active days in \(self.historyMonthTitle).")
+                            .font(.caption2)
+                            .foregroundStyle(.secondary)
+                            .padding(.bottom, RunicSpacing.xxs)
+
+                        self.historyCalendarGrid
+                        self.historyDayDetailCard
+                    }
+                } else {
+                    Text("History is empty for this period.")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                        .padding(.vertical, RunicSpacing.xs)
+                }
+
+                if let historyError = self.historyError {
+                    VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
+                        Text("History load failed")
+                            .font(.caption.weight(.semibold))
+                            .foregroundStyle(.red)
+                        Text(historyError)
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                            .textSelection(.enabled)
+                        Button("Retry") {
+                            Task { await self.loadHistoryMonth(forceRefresh: true) }
+                        }
+                        .buttonStyle(.bordered)
+                        .controlSize(.small)
+                    }
+                    .padding(RunicSpacing.sm)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .background(
+                        RoundedRectangle(
+                            cornerRadius: ProviderListMetrics.sidebarMicroCardCornerRadius,
+                            style: .continuous)
+                            .fill(Color.red.opacity(0.06))
+                    )
+                    .overlay(
+                        RoundedRectangle(
+                            cornerRadius: ProviderListMetrics.sidebarMicroCardCornerRadius,
+                            style: .continuous)
+                            .strokeBorder(Color.red.opacity(0.28), lineWidth: 1)
+                    )
+                }
+
+                Text("Local aggregated history only. Prompts, cookies, API keys, and raw payloads are never shown here.")
+                    .font(.caption2)
+                    .foregroundStyle(.tertiary)
+            }
+        }
+    }
+
+    private var historyCalendarGrid: some View {
+        VStack(alignment: .leading, spacing: RunicSpacing.xs) {
+            let weekdays = self.weekdaySymbols
+            LazyVGrid(columns: Array(repeating: GridItem(.flexible(), spacing: RunicSpacing.xxs), count: 7), spacing: RunicSpacing.xxs) {
+                ForEach(weekdays, id: \.self) { symbol in
+                    Text(symbol)
+                        .font(.caption2.weight(.semibold))
+                        .foregroundStyle(.tertiary)
+                        .frame(maxWidth: .infinity)
+                }
+            }
+
+            LazyVGrid(columns: Array(repeating: GridItem(.flexible(), spacing: RunicSpacing.xxs), count: 7), spacing: RunicSpacing.xxs) {
+                ForEach(self.calendarDaysForMonth, id: \.self) { day in
+                    let inMonth = self.historyCalendar.isDate(day, equalTo: self.historyMonthStart, toGranularity: .month)
+                    let normalizedDay = self.historyCalendar.startOfDay(for: day)
+                    let summary = self.historySummaryByDay[normalizedDay]
+                    let dayNumber = self.historyCalendar.component(.day, from: day)
+                    let isSelected = self.historySelectedDay.map { self.historyCalendar.isDate($0, inSameDayAs: day) } ?? false
+                    ProviderHistoryCalendarDayCell(
+                        dayNumber: dayNumber,
+                        isInMonth: inMonth,
+                        isSelected: isSelected,
+                        hasActivity: summary != nil,
+                        intensity: self.historyIntensity(for: summary),
+                        action: { self.historySelectedDay = normalizedDay })
+                    .help(self.historyDayHelp(for: day, summary: summary))
+                }
+            }
+        }
+    }
+
+    private var historyDayDetailCard: some View {
+        ProviderSidebarSectionCard {
+            VStack(alignment: .leading, spacing: RunicSpacing.sm) {
+                HStack(alignment: .firstTextBaseline, spacing: RunicSpacing.xs) {
+                    Text("Day details")
+                        .font(.caption.weight(.semibold))
+                        .foregroundStyle(.tertiary)
+                        .textCase(.uppercase)
+                        .tracking(0.25)
+                    Spacer()
+                    if self.selectedHistoryDaySummary != nil {
+                        Picker("History detail", selection: self.$historyDayDetailMode) {
+                            ForEach(ProviderHistoryDayDetailMode.allCases) { mode in
+                                Text(mode.rawValue).tag(mode)
+                            }
+                        }
+                        .pickerStyle(.segmented)
+                        .controlSize(.mini)
+                        .frame(maxWidth: 240)
+                    }
+                }
+
+                if let selected = self.selectedHistoryDaySummary {
+                    Text(selected.dayStart.formatted(.dateTime.weekday(.wide).month(.abbreviated).day().year()))
+                        .font(.caption.weight(.semibold))
+                        .foregroundStyle(.secondary)
+
+                    if self.historyDayDetailMode == .summary {
+                        LazyVGrid(
+                            columns: [
+                                GridItem(.flexible(minimum: 90), spacing: RunicSpacing.xs),
+                                GridItem(.flexible(minimum: 90), spacing: RunicSpacing.xs),
+                                GridItem(.flexible(minimum: 90), spacing: RunicSpacing.xs),
+                            ],
+                            alignment: .leading,
+                            spacing: RunicSpacing.xs)
+                        {
+                            ProviderSidebarMetricChip(
+                                title: "Requests",
+                                value: self.decimalString(selected.requestCount),
+                                helpText: "Count of requests recorded in local ledger logs.")
+                            ProviderSidebarMetricChip(
+                                title: "Tokens",
+                                value: UsageFormatter.tokenSummaryString(selected.totals),
+                                helpText: "Input, output, and cache token composition.")
+                            if let spend = selected.totals.costUSD {
+                                ProviderSidebarMetricChip(
+                                    title: "Spend",
+                                    value: UsageFormatter.usdString(spend),
+                                    helpText: "Estimated day spend from ledger pricing.")
+                            }
+                        }
+
+                        if self.hasModelBreakdown, let topModel = selected.topModel {
+                            Text("Top model: \(self.usageLine(title: UsageFormatter.modelDisplayName(topModel.model), totals: topModel.totals, requests: topModel.entryCount, model: topModel.model))")
+                                .font(.caption)
+                                .foregroundStyle(.secondary)
+                                .textSelection(.enabled)
+                        }
+
+                        if self.hasProjectAttribution, let topProject = selected.topProject {
+                            let project = self.projectDisplay(topProject)
+                            Text("Top project: \(project.title)")
+                                .font(.caption)
+                                .foregroundStyle(.secondary)
+                                .textSelection(.enabled)
+                                .help(project.helpText ?? "")
+                        }
+                    }
+
+                    if self.historyDayDetailMode == .models {
+                        if self.hasModelBreakdown, !selected.modelSummaries.isEmpty {
+                            Text("Models used")
+                                .font(.caption2.weight(.medium))
+                                .foregroundStyle(.secondary)
+                            ForEach(Array(selected.modelSummaries.prefix(12).enumerated()), id: \.offset) { _, summary in
+                                Text("• \(self.historyModelLine(summary))")
+                                    .font(.caption2)
+                                    .foregroundStyle(.tertiary)
+                                    .textSelection(.enabled)
+                                    .help(self.historyModelLine(summary))
+                            }
+                        } else if self.hasModelBreakdown, !selected.modelsUsed.isEmpty {
+                            Text("Models used: \(self.renderedModelsList(selected.modelsUsed).joined(separator: ", "))")
+                                .font(.caption2)
+                                .foregroundStyle(.tertiary)
+                                .textSelection(.enabled)
+                        } else {
+                            Text(self.hasModelBreakdown ? "No models recorded for this day." : "Model attribution is not available for this provider.")
+                                .font(.caption)
+                                .foregroundStyle(.tertiary)
+                        }
+                    }
+
+                    if self.historyDayDetailMode == .projects {
+                        if self.hasProjectAttribution, !selected.projectSummaries.isEmpty {
+                            Text("Top projects")
+                                .font(.caption2.weight(.medium))
+                                .foregroundStyle(.secondary)
+                            ForEach(Array(selected.projectSummaries.prefix(12).enumerated()), id: \.offset) { _, summary in
+                                let project = self.projectDisplay(summary)
+                                Text("• \(self.historyProjectLine(summary))")
+                                    .font(.caption2)
+                                    .foregroundStyle(.tertiary)
+                                    .textSelection(.enabled)
+                                    .help(project.helpText ?? "")
+                            }
+                        } else {
+                            Text(self.hasProjectAttribution ? "No projects recorded for this day." : "Project attribution is not available for this provider.")
+                                .font(.caption)
+                                .foregroundStyle(.tertiary)
+                        }
+                    }
+                } else {
+                    Text(self.historySelectedDay?.formatted(.dateTime.weekday(.wide).month(.abbreviated).day().year()) ?? "No day selected")
+                        .font(.caption.weight(.semibold))
+                        .foregroundStyle(.secondary)
+                    Text("No recorded activity for this day.")
+                        .font(.caption)
+                        .foregroundStyle(.tertiary)
+                }
+            }
+        }
+    }
+
+    private var historyMonthTitle: String {
+        self.historyMonthStart.formatted(.dateTime.month(.wide).year())
+    }
+
+    private var canShiftHistoryForward: Bool {
+        self.historyMonthStart < Self.monthStart(for: Date())
+    }
+
+    private var historyCalendar: Calendar {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone.current
+        return calendar
+    }
+
+    private var weekdaySymbols: [String] {
+        let symbols = self.historyCalendar.veryShortStandaloneWeekdaySymbols
+        guard !symbols.isEmpty else { return [] }
+        let start = max(0, min(symbols.count - 1, self.historyCalendar.firstWeekday - 1))
+        return Array(symbols[start...]) + Array(symbols[..<start])
+    }
+
+    private var calendarDaysForMonth: [Date] {
+        guard let monthInterval = self.historyCalendar.dateInterval(of: .month, for: self.historyMonthStart),
+              let firstWeek = self.historyCalendar.dateInterval(of: .weekOfMonth, for: monthInterval.start),
+              let lastDayOfMonth = self.historyCalendar.date(byAdding: .day, value: -1, to: monthInterval.end),
+              let lastWeek = self.historyCalendar.dateInterval(of: .weekOfMonth, for: lastDayOfMonth)
+        else {
+            return []
+        }
+
+        var days: [Date] = []
+        var cursor = firstWeek.start
+        while cursor < lastWeek.end {
+            days.append(cursor)
+            guard let next = self.historyCalendar.date(byAdding: .day, value: 1, to: cursor) else { break }
+            cursor = next
+        }
+        return days
+    }
+
+    private var historySummaryByDay: [Date: ProviderHistoryDaySnapshot] {
+        guard let snapshot = self.historySnapshot else { return [:] }
+        var map: [Date: ProviderHistoryDaySnapshot] = [:]
+        for day in snapshot.days {
+            map[self.historyCalendar.startOfDay(for: day.dayStart)] = day
+        }
+        return map
+    }
+
+    private var selectedHistoryDaySummary: ProviderHistoryDaySnapshot? {
+        guard let snapshot = self.historySnapshot else { return nil }
+        guard let selectedDay = self.historySelectedDay else { return snapshot.days.last }
+        return snapshot.days.first { self.historyCalendar.isDate($0.dayStart, inSameDayAs: selectedDay) }
+    }
+
+    private var historyMaxMetricValue: Double {
+        guard let snapshot = self.historySnapshot, !snapshot.days.isEmpty else { return 0 }
+        return snapshot.days.reduce(0) { max($0, self.historyMetricValue(for: $1)) }
+    }
+
+    private func historyMetricValue(for day: ProviderHistoryDaySnapshot) -> Double {
+        switch self.historyMetricMode {
+        case .tokens:
+            return Double(day.totals.totalTokens)
+        case .cost:
+            return max(0, day.totals.costUSD ?? 0)
+        case .requests:
+            return Double(day.requestCount)
+        }
+    }
+
+    private func historyIntensity(for day: ProviderHistoryDaySnapshot?) -> Double {
+        guard let day else { return 0 }
+        let maxValue = self.historyMaxMetricValue
+        guard maxValue > 0 else { return 0.15 }
+        return min(1, max(0.15, self.historyMetricValue(for: day) / maxValue))
+    }
+
+    private func historyDayHelp(for day: Date, summary: ProviderHistoryDaySnapshot?) -> String {
+        var lines: [String] = [day.formatted(.dateTime.weekday(.wide).month(.abbreviated).day().year())]
+        guard let summary else {
+            lines.append("No recorded activity")
+            return lines.joined(separator: "\n")
+        }
+        lines.append("Requests: \(self.decimalString(summary.requestCount))")
+        lines.append("Tokens: \(UsageFormatter.tokenSummaryString(summary.totals))")
+        if let spend = summary.totals.costUSD {
+            lines.append("Spend: \(UsageFormatter.usdString(spend))")
+        }
+        if self.hasModelBreakdown, let topModel = summary.topModel {
+            var modelLine = "Top model: \(UsageFormatter.modelDisplayName(topModel.model))"
+            if let context = UsageFormatter.modelContextLabel(for: topModel.model) {
+                modelLine += " · \(context)"
+            }
+            lines.append(modelLine)
+        }
+        if self.hasModelBreakdown, !summary.modelSummaries.isEmpty {
+            let modelCount = min(3, summary.modelSummaries.count)
+            for summary in summary.modelSummaries.prefix(modelCount) {
+                var line = "Model: \(UsageFormatter.modelDisplayName(summary.model)) · \(UsageFormatter.tokenCountString(summary.totals.totalTokens)) tok"
+                if let context = UsageFormatter.modelContextLabel(for: summary.model) {
+                    line += " · \(context)"
+                }
+                lines.append(line)
+            }
+        }
+        if self.hasProjectAttribution, let topProject = summary.topProject {
+            var projectLine = "Top project: \(self.projectDisplay(topProject).title)"
+            if let cost = topProject.totals.costUSD {
+                projectLine += " · \(UsageFormatter.usdString(cost))"
+            }
+            lines.append(projectLine)
+        }
+        return lines.joined(separator: "\n")
+    }
+
+    private func renderedModelsList(_ modelsUsed: [String]) -> [String] {
+        var seen: Set<String> = []
+        var rendered: [String] = []
+        for model in modelsUsed {
+            let trimmed = model.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !trimmed.isEmpty, seen.insert(trimmed).inserted else { continue }
+            var text = UsageFormatter.modelDisplayName(trimmed)
+            if let context = UsageFormatter.modelContextLabel(for: trimmed) {
+                text += " \(context)"
+            }
+            rendered.append(text)
+        }
+        return rendered
+    }
+
+    private func historyModelLine(_ summary: UsageLedgerModelSummary) -> String {
+        self.usageLine(
+            title: UsageFormatter.modelDisplayName(summary.model),
+            totals: summary.totals,
+            requests: summary.entryCount,
+            model: summary.model)
+    }
+
+    private func historyProjectLine(_ summary: UsageLedgerProjectSummary) -> String {
+        let project = self.projectDisplay(summary)
+        return self.usageLine(
+            title: project.title,
+            totals: summary.totals,
+            requests: summary.entryCount)
+    }
+
+    private func shiftHistoryMonth(by delta: Int) {
+        guard delta != 0 else { return }
+        guard let shifted = self.historyCalendar.date(byAdding: .month, value: delta, to: self.historyMonthStart) else {
+            return
+        }
+        let candidate = Self.monthStart(for: shifted)
+        if delta > 0, candidate > Self.monthStart(for: Date()) {
+            return
+        }
+        self.historyMonthStart = candidate
+        self.historySnapshot = nil
+        self.historySelectedDay = nil
+        self.historyError = nil
+    }
+
+    private static func monthStart(for date: Date) -> Date {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone.current
+        let components = calendar.dateComponents([.year, .month], from: date)
+        return calendar.date(from: components) ?? calendar.startOfDay(for: date)
+    }
+
+    private func loadHistoryMonth(forceRefresh: Bool = false) async {
+        guard !self.historyIsLoading else { return }
+        self.historyIsLoading = true
+        self.historyError = nil
+        let snapshot = await self.store.providerHistoryMonth(
+            provider: self.provider,
+            monthStart: self.historyMonthStart,
+            forceRefresh: forceRefresh)
+        self.historySnapshot = snapshot
+        self.historyError = snapshot.error
+        self.historyIsLoading = false
+        self.selectDefaultHistoryDay(from: snapshot)
+    }
+
+    private func selectDefaultHistoryDay(from snapshot: ProviderHistoryMonthSnapshot) {
+        guard !snapshot.days.isEmpty else {
+            self.historySelectedDay = self.historyCalendar.startOfDay(for: self.historyMonthStart)
+            return
+        }
+        if let selected = self.historySelectedDay,
+           snapshot.days.contains(where: { self.historyCalendar.isDate($0.dayStart, inSameDayAs: selected) })
+        {
+            self.historySelectedDay = self.historyCalendar.startOfDay(for: selected)
+            return
+        }
+        self.historySelectedDay = snapshot.days.map(\.dayStart).max()
+    }
+
+    private struct ProjectDisplay {
+        let title: String
+        let helpText: String?
+    }
+
+    private func projectDisplay(_ summary: UsageLedgerProjectSummary) -> ProjectDisplay {
+        let displayName = summary.displayProjectName
+        let source = summary.projectNameSource ?? .unknown
+        let confidence = summary.projectNameConfidence ?? .none
+        let shouldAnnotateSource = source != .projectName && source != .budgetOverride
+        let shouldAnnotateConfidence = confidence != .high
+        let isUnknown = displayName == "Unknown project"
+
+        var details: [String] = []
+        if shouldAnnotateSource {
+            details.append("source: \(self.projectSourceLabel(source))")
+        }
+        if shouldAnnotateConfidence {
+            details.append("confidence: \(self.projectConfidenceLabel(confidence))")
+        }
+        if isUnknown, let fingerprint = self.projectIDFingerprint(summary.projectID) {
+            details.append("id: \(fingerprint)")
+        }
+        if let provenance = self.trimmed(summary.projectNameProvenance) {
+            details.append("via: \(provenance)")
+        }
+        return ProjectDisplay(
+            title: displayName,
+            helpText: details.isEmpty ? nil : details.joined(separator: "\n"))
+    }
+
+    private func projectSourceLabel(_ source: UsageLedgerProjectNameSource) -> String {
+        switch source {
+        case .projectName: return "project name"
+        case .projectID: return "project id"
+        case .inferredFromPath: return "path-derived"
+        case .inferredFromName: return "name-derived"
+        case .budgetOverride: return "budget override"
+        case .unknown: return "unknown"
+        }
+    }
+
+    private func projectConfidenceLabel(_ confidence: UsageLedgerProjectNameConfidence) -> String {
+        switch confidence {
+        case .high: return "high"
+        case .medium: return "medium"
+        case .low: return "low"
+        case .none: return "none"
+        }
+    }
+
+    private func projectIDFingerprint(_ projectID: String?) -> String? {
+        guard let projectID = projectID?.trimmingCharacters(in: .whitespacesAndNewlines), !projectID.isEmpty else {
+            return nil
+        }
+        var hash: UInt64 = 0xcbf29ce484222325
+        for byte in projectID.lowercased().utf8 {
+            hash ^= UInt64(byte)
+            hash = hash &* 0x100000001b3
+        }
+        return String(format: "%08llx", hash)
+    }
+
+    @ViewBuilder
+    private func fieldActions(_ actions: [ProviderSettingsActionDescriptor]) -> some View {
+        let visible = actions.filter { $0.isVisible?() ?? true }
+        if !visible.isEmpty {
+            HStack(spacing: RunicSpacing.xs) {
+                ForEach(visible) { action in
+                    Button(action.title) {
+                        Task { @MainActor in await action.perform() }
+                    }
+                    .applyProviderSettingsButtonStyle(action.style)
+                    .controlSize(.small)
+                }
+            }
+        }
+    }
+
+    @ViewBuilder
+    private func toggleActions(_ actions: [ProviderSettingsActionDescriptor]) -> some View {
+        let visible = actions.filter { $0.isVisible?() ?? true }
+        if !visible.isEmpty {
+            HStack(spacing: RunicSpacing.xs) {
+                ForEach(visible) { action in
+                    Button(action.title) {
+                        Task { @MainActor in await action.perform() }
+                    }
+                    .applyProviderSettingsButtonStyle(action.style)
+                    .controlSize(.small)
+                }
+            }
+        }
+    }
+
+    private struct QuickMetricItem: Identifiable {
+        let id: String
+        let title: String
+        let value: String
+        let helpText: String?
+    }
+
+    private var quickMetrics: [QuickMetricItem] {
+        var items: [QuickMetricItem] = []
+        let snapshot = self.store.snapshot(for: self.provider)
+        let tokenSnapshot = self.store.tokenSnapshot(for: self.provider)
+        let hasModelBreakdown = self.hasModelBreakdown
+        let hasProjectAttribution = self.hasProjectAttribution
+
+        if let today = self.tokenWindowValue(tokens: tokenSnapshot?.sessionTokens, cost: tokenSnapshot?.sessionCostUSD) {
+            items.append(QuickMetricItem(id: "today", title: "Today", value: today, helpText: "Session cost and tokens."))
+        }
+        if let last30 = self.tokenWindowValue(
+            tokens: tokenSnapshot?.last30DaysTokens,
+            cost: tokenSnapshot?.last30DaysCostUSD)
+        {
+            items.append(QuickMetricItem(id: "30d", title: "30d", value: last30, helpText: "Last 30 days cost and tokens."))
+        }
+        if let spend = self.providerSpendValue(snapshot?.providerCost) {
+            items.append(QuickMetricItem(id: "spend", title: "Spend", value: spend, helpText: "Provider billing usage."))
+        }
+        if hasModelBreakdown, let topModel = self.store.ledgerTopModel(for: self.provider) {
+            let modelName = UsageFormatter.modelDisplayName(topModel.model)
+            var value = self.modelLineValue(
+                title: modelName,
+                totals: topModel.totals,
+                requests: topModel.entryCount)
+            if let context = UsageFormatter.modelContextLabel(for: topModel.model) {
+                value += " · \(context)"
+            }
+            items.append(QuickMetricItem(
+                id: "top-model",
+                title: "Top model",
+                value: value,
+                helpText: "Highest token usage model in the active insights window."))
+        } else if !hasModelBreakdown, let windowModel = self.topWindowModel {
+            let modelName = UsageFormatter.modelDisplayName(windowModel.label)
+            let used = Int(windowModel.window.usedPercent.rounded())
+            items.append(QuickMetricItem(
+                id: "top-model-window",
+                title: hasModelBreakdown ? "Top model" : "Top window",
+                value: "\(modelName) · \(used)% used",
+                helpText: hasModelBreakdown ?
+                    "Most constrained model/category from live quota windows."
+                    : "Top quota window from live fetch response."))
+        }
+        if hasProjectAttribution, let topProject = self.store.ledgerTopProject(for: self.provider) {
+            let project = self.projectDisplay(topProject)
+            let value = self.topProjectSummaryValue(topProject)
+            items.append(QuickMetricItem(
+                id: "top-project",
+                title: "Top project",
+                value: "\(project.title) · \(value)",
+                helpText: "Highest token usage project in the active insights window."))
+        }
+        if let coverage = ProviderInsightsComposer.coverageSummaryLabel(for: self.provider, store: self.store) {
+            let value = coverage.replacingOccurrences(of: "usage: ", with: "")
+            items.append(QuickMetricItem(
+                id: "coverage",
+                title: "Data",
+                value: value,
+                helpText: "Provider coverage for model-level usage, token metrics, and project attribution."))
+        }
+        return items
+    }
+
+    private func tokenWindowValue(tokens: Int?, cost: Double?) -> String? {
+        var parts: [String] = []
+        if let cost, cost.isFinite, cost >= 0 {
+            parts.append(UsageFormatter.usdString(cost))
+        }
+        if let tokens, tokens >= 0 {
+            parts.append("\(UsageFormatter.tokenCountString(tokens)) tok")
+        }
+        guard !parts.isEmpty else { return nil }
+        return parts.joined(separator: " · ")
+    }
+
+    private func providerSpendValue(_ providerCost: ProviderCostSnapshot?) -> String? {
+        guard let providerCost else { return nil }
+        let used = UsageFormatter.currencyString(providerCost.used, currencyCode: providerCost.currencyCode)
+        if providerCost.limit > 0 {
+            let limitText = UsageFormatter.currencyString(providerCost.limit, currencyCode: providerCost.currencyCode)
+            return "\(used) / \(limitText)"
+        }
+        return used
+    }
+
+    private var topModelLines: [String] {
+        let ranked = self.store.ledgerModelBreakdown(for: self.provider).sorted { lhs, rhs in
+            if lhs.totals.totalTokens == rhs.totals.totalTokens {
+                return UsageFormatter.modelDisplayName(lhs.model) < UsageFormatter.modelDisplayName(rhs.model)
+            }
+            return lhs.totals.totalTokens > rhs.totals.totalTokens
+        }
+        if !ranked.isEmpty {
+            guard self.hasModelBreakdown else {
+                return []
+            }
+            return ranked.prefix(3).map { summary in
+                let name = UsageFormatter.modelDisplayName(summary.model)
+                return self.usageLine(
+                    title: name,
+                    totals: summary.totals,
+                    requests: summary.entryCount,
+                    model: summary.model)
+            }
+        }
+        guard !self.hasModelBreakdown else {
+            return []
+        }
+        return self.windowModelLines
+    }
+
+    private var modelSectionTitle: String {
+        self.hasModelBreakdown ? "Models" : "Quota windows"
+    }
+
+    private var effectiveUsageCoverage: ProviderUsageCoverage {
+        ProviderInsightsComposer.effectiveCoverage(for: self.provider, store: self.store)
+    }
+
+    private var hasModelBreakdown: Bool {
+        self.effectiveUsageCoverage.supportsModelBreakdown
+    }
+
+    private var hasProjectAttribution: Bool {
+        self.effectiveUsageCoverage.supportsProjectAttribution
+    }
+
+    private var topProjectLines: [String] {
+        guard self.hasProjectAttribution else {
+            return []
+        }
+        let ranked = self.store.ledgerProjectBreakdown(for: self.provider).sorted { lhs, rhs in
+            if lhs.totals.totalTokens == rhs.totals.totalTokens {
+                return lhs.displayProjectName < rhs.displayProjectName
+            }
+            return lhs.totals.totalTokens > rhs.totals.totalTokens
+        }
+        return ranked.prefix(3).map { summary in
+            let project = summary.displayProjectName
+            return self.usageLine(title: project, totals: summary.totals, requests: summary.entryCount)
+        }
+    }
+
+    private func usageLine(
+        title: String,
+        totals: UsageLedgerTotals,
+        requests: Int,
+        model: String? = nil) -> String
+    {
+        let tokens = UsageFormatter.tokenSummaryString(totals)
+        var parts = ["\(title)", "\(tokens)", "\(requests) req"]
+        if let cost = totals.costUSD {
+            parts.append(UsageFormatter.usdString(cost))
+            if let per1K = UsageFormatter.usdPer1KTokensString(costUSD: cost, tokenCount: totals.totalTokens) {
+                parts.append("~\(per1K)")
+            }
+            if let perReq = UsageFormatter.usdPerRequestString(costUSD: cost, requestCount: requests) {
+                parts.append("~\(perReq)")
+            }
+        }
+        if let model, let context = UsageFormatter.modelContextLabel(for: model) {
+            parts.append(context)
+        }
+        return parts.joined(separator: " · ")
+    }
+
+    private func topProjectSummaryValue(_ summary: UsageLedgerProjectSummary) -> String {
+        var parts: [String] = []
+        parts.append(UsageFormatter.tokenSummaryString(summary.totals))
+        parts.append("\(summary.entryCount) req")
+        if let cost = summary.totals.costUSD {
+            parts.append(UsageFormatter.usdString(cost))
+            if let perReq = UsageFormatter.usdPerRequestString(costUSD: cost, requestCount: summary.entryCount) {
+                parts.append("~\(perReq)")
+            }
+        }
+        return parts.joined(separator: " · ")
+    }
+
+    private func modelLineValue(title: String, totals: UsageLedgerTotals, requests: Int) -> String {
+        var parts: [String] = [title]
+        parts.append(UsageFormatter.tokenSummaryString(totals))
+        parts.append("\(requests) req")
+        if let cost = totals.costUSD {
+            parts.append(UsageFormatter.usdString(cost))
+            if let per1K = UsageFormatter.usdPer1KTokensString(costUSD: cost, tokenCount: totals.totalTokens) {
+                parts.append("~\(per1K)")
+            }
+            if let perReq = UsageFormatter.usdPerRequestString(costUSD: cost, requestCount: requests) {
+                parts.append("~\(perReq)")
+            }
+        }
+        return parts.joined(separator: " · ")
+    }
+
+    private var windowModelLines: [String] {
+        self.labeledQuotaWindows(from: self.store.snapshot(for: self.provider)).prefix(3).map { item in
+            let modelName = UsageFormatter.modelDisplayName(item.label)
+            let used = Int(item.window.usedPercent.rounded())
+            let remaining = Int(item.window.remainingPercent.rounded())
+            var parts = [modelName, "\(used)% used", "\(remaining)% left"]
+            if let resetsAt = item.window.resetsAt {
+                parts.append("reset \(UsageFormatter.resetCountdownDescription(from: resetsAt))")
+            } else if let resetDescription = item.window.resetDescription?
+                .trimmingCharacters(in: .whitespacesAndNewlines),
+                !resetDescription.isEmpty
+            {
+                parts.append(resetDescription)
+            }
+            return parts.joined(separator: " · ")
+        }
+    }
+
+    private var topWindowModel: (label: String, window: RateWindow)? {
+        self.labeledQuotaWindows(from: self.store.snapshot(for: self.provider)).first
+    }
+
+    private func labeledQuotaWindows(from snapshot: UsageSnapshot?) -> [(label: String, window: RateWindow)] {
+        guard let snapshot else { return [] }
+        let windows = [snapshot.primary, snapshot.secondary, snapshot.tertiary].compactMap { $0 }
+        var seen: Set<String> = []
+        var labeled: [(label: String, window: RateWindow)] = []
+
+        for window in windows {
+            guard let label = window.label?.trimmingCharacters(in: .whitespacesAndNewlines),
+                  !label.isEmpty
+            else {
+                continue
+            }
+            let normalized = label.lowercased()
+            guard seen.insert(normalized).inserted else { continue }
+            labeled.append((label, window))
+        }
+
+        return labeled.sorted { lhs, rhs in
+            if lhs.window.usedPercent == rhs.window.usedPercent {
+                return lhs.label.localizedCaseInsensitiveCompare(rhs.label) == .orderedAscending
+            }
+            return lhs.window.usedPercent > rhs.window.usedPercent
+        }
+    }
+
+    private func decimalString(_ value: Int) -> String {
+        let formatter = NumberFormatter()
+        formatter.numberStyle = .decimal
+        formatter.usesGroupingSeparator = true
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        return formatter.string(from: NSNumber(value: value)) ?? "\(value)"
+    }
+
+    private struct RuntimeMetricsData {
+        let lineText: String
+        let hoverText: String?
+    }
+
+    private var runtimeMetrics: RuntimeMetricsData? {
+        let attempts = self.store.fetchAttempts(for: self.provider)
+        guard !attempts.isEmpty || self.store.snapshot(for: self.provider) != nil else {
+            return nil
+        }
+
+        var parts: [String] = []
+        if let updatedAt = self.store.snapshot(for: self.provider)?.updatedAt {
+            parts.append("success \(updatedAt.relativeDescription())")
+        } else {
+            parts.append("no success yet")
+        }
+
+        var hoverText: String?
+        if !attempts.isEmpty {
+            let retryCount = self.retryCount(from: attempts)
+            if retryCount > 0 {
+                parts.append("retry \(retryCount)")
+            }
+            if let activeAttempt = self.activeAttempt(from: attempts) {
+                parts.append(Self.fetchKindLabel(activeAttempt.kind))
+                if let strategyID = self.trimmed(activeAttempt.strategyID) {
+                    hoverText = "Strategy: \(strategyID)"
+                }
+            }
+        }
+
+        return RuntimeMetricsData(
+            lineText: parts.joined(separator: " · "),
+            hoverText: hoverText)
+    }
+
+    private func retryCount(from attempts: [ProviderFetchAttempt]) -> Int {
+        guard !attempts.isEmpty else { return 0 }
+        if let successIndex = attempts.firstIndex(where: { $0.wasAvailable && self.trimmed($0.errorDescription) == nil }) {
+            return max(0, successIndex)
+        }
+        return max(0, attempts.count - 1)
+    }
+
+    private func activeAttempt(from attempts: [ProviderFetchAttempt]) -> ProviderFetchAttempt? {
+        guard !attempts.isEmpty else { return nil }
+        return attempts.first(where: { $0.wasAvailable && self.trimmed($0.errorDescription) == nil }) ??
+            attempts.last(where: { $0.wasAvailable }) ??
+            attempts.last
+    }
+
+    private func trimmed(_ value: String?) -> String? {
+        guard let value else { return nil }
+        let cleaned = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return cleaned.isEmpty ? nil : cleaned
+    }
+
+    private static func fetchKindLabel(_ kind: ProviderFetchKind) -> String {
+        switch kind {
+        case .cli: return "cli"
+        case .web: return "web"
+        case .oauth: return "oauth"
+        case .apiToken: return "api"
+        case .api: return "api"
+        case .localProbe: return "local"
+        case .webDashboard: return "web"
+        }
+    }
+
+    private func copyDiagnostics() {
+        let pb = NSPasteboard.general
+        pb.clearContents()
+        pb.setString(self.diagnosticsReport, forType: .string)
+        self.diagnosticsCopyStatus = "Copied"
+        Task { @MainActor in
+            try? await Task.sleep(nanoseconds: 1_500_000_000)
+            self.diagnosticsCopyStatus = nil
+        }
+    }
+
+    private var diagnosticsReport: String {
+        let metadata = self.store.metadata(for: self.provider)
+        let attempts = self.store.fetchAttempts(for: self.provider)
+        let snapshot = self.store.snapshot(for: self.provider)
+        let forecast = self.store.ledgerSpendForecast(for: self.provider)
+        let topProjectForecast = self.store.ledgerTopProjectSpendForecast(for: self.provider)
+        let reliability = self.store.ledgerReliabilityScore(for: self.provider)
+        let anomaly = self.store.ledgerAnomalySummary(for: self.provider)
+        let iso = ISO8601DateFormatter()
+
+        var lines: [String] = []
+        lines.append("# \(metadata.displayName) Diagnostics")
+        lines.append("provider: \(self.provider.rawValue)")
+        lines.append("generated_at: \(iso.string(from: Date()))")
+        lines.append("enabled: \(self.isEnabled ? "true" : "false")")
+        lines.append("source: \(self.sourceLabel)")
+        lines.append("updated: \(self.statusLabel)")
+        if let runtime = self.runtimeMetrics?.lineText {
+            lines.append("runtime: \(runtime)")
+        }
+
+        if let snapshot {
+            lines.append("")
+            lines.append("usage_snapshot:")
+            lines.append("- updated_at: \(iso.string(from: snapshot.updatedAt))")
+            lines.append("- primary_used_percent: \(Int(snapshot.primary.usedPercent.rounded()))")
+            if let minutes = snapshot.primary.windowMinutes, minutes > 0 {
+                lines.append("- primary_window_minutes: \(minutes)")
+            }
+            if let reset = snapshot.primary.resetsAt {
+                lines.append("- primary_resets_at: \(iso.string(from: reset))")
+            }
+            if let cost = snapshot.providerCost {
+                lines.append("- provider_spend_used: \(UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode))")
+                if cost.limit > 0 {
+                    lines.append("- provider_spend_limit: \(UsageFormatter.currencyString(cost.limit, currencyCode: cost.currencyCode))")
+                }
+                if let period = self.trimmed(cost.period) {
+                    lines.append("- provider_spend_period: \(period)")
+                }
+            }
+        }
+
+        lines.append("")
+        lines.append("fetch_path:")
+        if attempts.isEmpty {
+            lines.append("- none")
+        } else {
+            for attempt in attempts {
+                let state: String
+                if !attempt.wasAvailable {
+                    state = "unavailable"
+                } else if let error = self.trimmed(attempt.errorDescription) {
+                    state = "failed: \(error)"
+                } else {
+                    state = "ok"
+                }
+                lines.append("- \(attempt.strategyID) [\(Self.fetchKindLabel(attempt.kind))] \(state)")
+            }
+        }
+
+        if let forecast {
+            lines.append("")
+            lines.append("provider_forecast:")
+            lines.append("- projected_30d: \(UsageFormatter.usdString(forecast.projected30DayCostUSD))")
+            lines.append("- average_daily: \(UsageFormatter.usdString(forecast.averageDailyCostUSD))")
+            if let p50 = forecast.projectedCostP50USD {
+                lines.append("- p50: \(UsageFormatter.usdString(p50))")
+            }
+            if let p80 = forecast.projectedCostP80USD {
+                lines.append("- p80: \(UsageFormatter.usdString(p80))")
+            }
+            if let p95 = forecast.projectedCostP95USD {
+                lines.append("- p95: \(UsageFormatter.usdString(p95))")
+            }
+            if let limit = forecast.budgetLimitUSD, limit > 0 {
+                lines.append("- budget_limit: \(UsageFormatter.usdString(limit))")
+                lines.append("- budget_status: \(self.budgetStatusText(forecast))")
+            }
+        }
+
+        if let topProjectForecast {
+            lines.append("")
+            lines.append("top_project_forecast:")
+            if let name = self.trimmed(topProjectForecast.projectName) {
+                lines.append("- project: \(name)")
+            }
+            lines.append("- projected_30d: \(UsageFormatter.usdString(topProjectForecast.projected30DayCostUSD))")
+            if let limit = topProjectForecast.budgetLimitUSD, limit > 0 {
+                lines.append("- budget_limit: \(UsageFormatter.usdString(limit))")
+                lines.append("- budget_status: \(self.budgetStatusText(topProjectForecast))")
+            }
+        }
+
+        if let reliability {
+            lines.append("")
+            lines.append("reliability:")
+            lines.append("- score: \(reliability.score)/100")
+            lines.append("- grade: \(reliability.grade)")
+            lines.append("- summary: \(reliability.summary)")
+            if let signal = self.trimmed(reliability.primarySignal) {
+                lines.append("- signal: \(signal)")
+            }
+        }
+
+        if let anomaly {
+            lines.append("")
+            lines.append("anomaly:")
+            if let spend = anomaly.spendAnomaly {
+                lines.append("- spend: \(spend.severity.label) +\(Int((spend.percentIncrease * 100).rounded()))%")
+            }
+            if let token = anomaly.tokenAnomaly {
+                lines.append("- tokens: \(token.severity.label) +\(Int((token.percentIncrease * 100).rounded()))%")
+            }
+            if let explanation = anomaly.explanation {
+                lines.append("- headline: \(explanation.headline)")
+                for detail in explanation.details {
+                    lines.append("- detail: \(detail)")
+                }
+            }
+        }
+
+        return lines.joined(separator: "\n")
+    }
+
+    private func budgetStatusText(_ forecast: UsageLedgerSpendForecast) -> String {
+        if let eta = forecast.budgetETAInDays {
+            return self.budgetBreachETAText(days: eta)
+        }
+        if forecast.budgetWillBreach {
+            return "Breach risk"
+        }
+        return "On track"
+    }
+
+    private func budgetBreachETAText(days: Double) -> String {
+        guard days.isFinite else { return "Breach ETA unavailable" }
+        if days <= 0 { return "Breach now" }
+        let now = Date()
+        let etaDate = now.addingTimeInterval(days * 24 * 60 * 60)
+        let countdown = UsageFormatter.resetCountdownDescription(from: etaDate, now: now)
+        if countdown == "now" { return "Breach now" }
+        return "Breach \(countdown)"
+    }
+}