Fix partial model history aggregation

Sources/CodexBar/PreferencesSpendDashboardPane.swift

@@ -27,6 +27,22 @@ func spendDashboardCoverageText(covered: Int, requested: Int) -> String {
     "\(L("Coverage")): \(codexBarLocalizedInteger(covered)) / \(codexBarLocalizedInteger(requested))"
 }
 
+enum SpendDashboardModelHistoryPresentation: Equatable {
+    case unavailable
+    case empty
+    case partial
+    case complete
+}
+
+func spendDashboardModelHistoryPresentation(
+    _ group: SpendDashboardModel.CurrencyGroup) -> SpendDashboardModelHistoryPresentation
+{
+    if group.models.isEmpty {
+        return group.modelHistoryCompleteness == .incomplete ? .unavailable : .empty
+    }
+    return group.modelHistoryCompleteness == .incomplete ? .partial : .complete
+}
+
 @MainActor
 struct SpendDashboardPane: View {
     @Bindable var settings: SettingsStore
@@ -314,24 +330,39 @@ private struct SpendModelPanel: View {
         SpendDashboardPanel {
             VStack(alignment: .leading, spacing: 0) {
                 Text(L("Models")).font(.headline).padding(.bottom, 8)
-                if self.group.modelHistoryCompleteness == .incomplete {
+                let presentation = spendDashboardModelHistoryPresentation(self.group)
+                switch presentation {
+                case .unavailable:
                     Text(L("Model breakdown unavailable"))
                         .foregroundStyle(.secondary)
                         .padding(.vertical, 10)
-                } else if self.group.models.isEmpty {
+                case .empty:
                     Text(L("No model-level history"))
                         .foregroundStyle(.secondary)
                         .padding(.vertical, 10)
-                } else {
+                case .partial, .complete:
+                    if presentation == .partial {
+                        Label(L("Model breakdown unavailable"), systemImage: "exclamationmark.triangle")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                            .padding(.bottom, 6)
+                    }
                     ForEach(self.group.models.prefix(8)) { row in
                         if row.rank > 1 {
                             Divider()
                         }
                         HStack(spacing: 10) {
-                            Text(spendDashboardRankText(row.rank))
-                                .font(.caption.monospacedDigit())
-                                .foregroundStyle(.tertiary)
-                                .frame(width: 26, alignment: .leading)
+                            if presentation == .complete {
+                                Text(spendDashboardRankText(row.rank))
+                                    .font(.caption.monospacedDigit())
+                                    .foregroundStyle(.tertiary)
+                                    .frame(width: 26, alignment: .leading)
+                            } else {
+                                Image(systemName: "circle.dashed")
+                                    .font(.caption)
+                                    .foregroundStyle(.tertiary)
+                                    .frame(width: 26, alignment: .leading)
+                            }
                             SpendProviderIcon(provider: row.provider)
                             VStack(alignment: .leading, spacing: 2) {
                                 Text(row.modelName).lineLimit(1)

Sources/CodexBar/ShareStatsPayload.swift

@@ -329,7 +329,9 @@ enum ShareStatsBuilder {
                     coveredDayCount: row.coveredDayCount)
             }
         }
-        let sanitizedModels = model.groups.flatMap { group in
+        let sanitizedModels = model.groups.filter {
+            $0.modelHistoryCompleteness == .complete
+        }.flatMap { group in
             group.models.compactMap { row -> ShareStatsModelPayload? in
                 let estimatedCost = self.finiteCost(row.totalCost)
                 guard let modelName = ShareStatsSanitizer.modelName(row.modelName),

Sources/CodexBar/SpendDashboardModel.swift

@@ -172,15 +172,19 @@ struct SpendDashboardModel: Equatable, Sendable {
             Self.inputSummary(input: input, bounds: bounds, calendar: calendar)
         }
         let providers = Self.providerRows(summaries)
-        let modelSummary = Self.modelSummary(summaries: summaries)
-        let modelHistoryCompleteness = summaries.contains(where: { $0.totalCost == nil })
-            ? ModelHistoryCompleteness.incomplete
-            : modelSummary.completeness
+        let completeModelSummaries = summaries.filter { summary in
+            guard summary.totalCost != nil else { return false }
+            return Self.modelSummary(summaries: [summary]).completeness == .complete
+        }
+        let modelSummary = Self.modelSummary(summaries: completeModelSummaries)
+        let modelHistoryCompleteness = completeModelSummaries.count == summaries.count
+            ? ModelHistoryCompleteness.complete
+            : ModelHistoryCompleteness.incomplete
         let dailyPoints = Self.dailyPoints(summaries: summaries)
         return CurrencyGroup(
             currencyCode: currencyCode,
             providers: providers,
-            models: modelHistoryCompleteness == .complete ? modelSummary.rows : [],
+            models: modelSummary.rows,
             dailyPoints: dailyPoints,
             totalTokens: Self.completeIntSum(providers.map(\.totalTokens)),
             totalCost: Self.completeCostSum(providers.map(\.totalCost)),

Tests/CodexBarTests/ShareStatsTests.swift

@@ -224,6 +224,42 @@ struct ShareStatsTests {
         #expect(!ShareStatsFormatting.text(payload).lowercased().contains("inf"))
     }
 
+    @Test
+    func `partial model history does not enter shared rankings`() throws {
+        let group = SpendDashboardModel.CurrencyGroup(
+            currencyCode: "USD",
+            providers: [
+                SpendDashboardModel.ProviderRow(
+                    id: "codex",
+                    rank: 1,
+                    provider: .codex,
+                    displayName: "Codex",
+                    totalTokens: 10,
+                    totalCost: 2,
+                    coveredDayCount: 7),
+            ],
+            models: [
+                SpendDashboardModel.ModelRow(
+                    rank: 1,
+                    provider: .codex,
+                    providerName: "Codex",
+                    modelName: "gpt-5.4",
+                    totalTokens: 10,
+                    totalCost: 2),
+            ],
+            dailyPoints: [],
+            totalTokens: nil,
+            totalCost: nil,
+            coveredDayCount: 7,
+            chartDomain: Self.date...Self.date,
+            modelHistoryCompleteness: .incomplete)
+        let payload = try #require(ShareStatsBuilder.make(
+            model: SpendDashboardModel(requestedDays: 7, groups: [group])))
+
+        #expect(payload.providers.count == 1)
+        #expect(payload.topModels.isEmpty)
+    }
+
     @Test @MainActor
     func `renderer creates social card PNG`() throws {
         let payload = try #require(ShareStatsBuilder.make(model: Self.dashboard))

Tests/CodexBarTests/SpendDashboardDateTruthTests.swift

@@ -323,7 +323,8 @@ struct SpendDashboardDateTruthTests {
             #expect(cad.totalCost == nil)
             #expect(cad.totalTokens == 30)
             #expect(cad.modelHistoryCompleteness == .incomplete)
-            #expect(cad.models.isEmpty)
+            #expect(cad.models.map(\.provider) == [.mistral])
+            #expect(cad.models.map(\.totalCost) == [5])
             #expect(cad.dailyPoints.map(\.sourceID) == ["healthy-cad"])
             #expect(SpendDailyChartPresentation(
                 dailyPoints: cad.dailyPoints,
@@ -428,7 +429,8 @@ struct SpendDashboardDateTruthTests {
         #expect(usd.totalCost == nil)
         #expect(usd.totalTokens == nil)
         #expect(usd.modelHistoryCompleteness == .incomplete)
-        #expect(usd.models.isEmpty)
+        #expect(usd.models.map(\.provider) == [.codex])
+        #expect(usd.models.map(\.totalCost) == [4])
         #expect(usd.dailyPoints.map(\.sourceID) == ["healthy-usd"])
         #expect(usd.dailyPoints.map(\.cost) == [4])
         #expect(eur.totalCost == 5)
@@ -602,7 +604,8 @@ struct SpendDashboardDateTruthTests {
 
         #expect(usd.totalCost == nil)
         #expect(usd.modelHistoryCompleteness == .incomplete)
-        #expect(usd.models.isEmpty)
+        #expect(usd.models.map(\.provider) == [.codex])
+        #expect(usd.models.map(\.totalCost) == [4])
         #expect(usd.dailyPoints.map(\.sourceID) == ["healthy-usd"])
         #expect(usd.dailyPoints.map(\.cost) == [4])
         #expect(eur.totalCost == 5)

Tests/CodexBarTests/SpendDashboardModelTests.swift

@@ -243,7 +243,7 @@ struct SpendDashboardModelTests {
     }
 
     @Test
-    func `uncovered same currency source hides partial model ranking`() throws {
+    func `uncovered same currency source keeps complete model rows without ranking them as complete`() throws {
         let covered = Self.input(id: "covered", provider: .claude, currency: "USD", cost: 4)
         let uncovered = SpendDashboardModel.ProviderInput(
             id: "uncovered",
@@ -263,7 +263,10 @@ struct SpendDashboardModelTests {
         #expect(group.totalCost == nil)
         #expect(group.totalTokens == nil)
         #expect(group.modelHistoryCompleteness == .incomplete)
-        #expect(group.models.isEmpty)
+        #expect(group.models.map(\.provider) == [.claude])
+        #expect(group.models.map(\.modelName) == ["test-model"])
+        #expect(group.models.map(\.totalCost) == [4])
+        #expect(spendDashboardModelHistoryPresentation(group) == .partial)
     }
 
     @Test
@@ -287,6 +290,7 @@ struct SpendDashboardModelTests {
         #expect(group.totalTokens == nil)
         #expect(group.modelHistoryCompleteness == .incomplete)
         #expect(group.models.isEmpty)
+        #expect(spendDashboardModelHistoryPresentation(group) == .unavailable)
     }
 
     @Test