Use descriptor pace rules in CLI

Author: kiranmagic7

Sources/CodexBar/MenuCardView+ModelHelpers.swift

@@ -560,27 +560,7 @@ extension UsageMenuCardView.Model {
 
     private static func resetWindowForPace(provider: UsageProvider, window: RateWindow) -> RateWindow {
         // Provider snapshots use 30 days as a monthly sentinel; use the reset date for the real calendar-cycle length.
-        let pace = ProviderDescriptorRegistry.descriptor(for: provider).pace
-        guard pace.usesInferredMonthlyDuration(window: window),
-              let resetsAt = window.resetsAt,
-              let minutes = self.inferredMonthlyWindowMinutes(endingAt: resetsAt)
-        else { return window }
-        return RateWindow(
-            usedPercent: window.usedPercent,
-            windowMinutes: minutes,
-            resetsAt: window.resetsAt,
-            resetDescription: window.resetDescription,
-            nextRegenPercent: window.nextRegenPercent,
-            isSyntheticPlaceholder: window.isSyntheticPlaceholder)
-    }
-
-    private static func inferredMonthlyWindowMinutes(endingAt resetsAt: Date) -> Int? {
-        var calendar = Calendar(identifier: .gregorian)
-        calendar.timeZone = TimeZone(secondsFromGMT: 0) ?? calendar.timeZone
-        guard let startsAt = calendar.date(byAdding: .month, value: -1, to: resetsAt) else { return nil }
-        let minutes = resetsAt.timeIntervalSince(startsAt) / 60
-        guard minutes.isFinite, minutes > 0 else { return nil }
-        return Int(minutes.rounded())
+        ProviderDescriptorRegistry.descriptor(for: provider).pace.resolvedResetWindowForPace(window)
     }
 
     static func antigravityMetrics(input: Input, snapshot: UsageSnapshot) -> [Metric] {

Sources/CodexBarCLI/CLIPayloads.swift

@@ -98,6 +98,7 @@ struct ProviderPayload: Encodable {
 struct ProviderPacePayload: Encodable {
     let primary: PacePayload?
     let secondary: PacePayload?
+    let tertiary: PacePayload?
 }
 
 struct PacePayload: Encodable {

Sources/CodexBarCLI/CLIRenderer.swift

@@ -34,7 +34,13 @@ enum CLIRenderer {
             context: context,
             now: now,
             lines: &lines)
-        self.appendTertiaryLines(snapshot: snapshot, labels: labels, context: context, now: now, lines: &lines)
+        self.appendTertiaryLines(
+            provider: provider,
+            snapshot: snapshot,
+            labels: labels,
+            context: context,
+            now: now,
+            lines: &lines)
         self.appendMiMoBalanceLine(snapshot: snapshot, useColor: context.useColor, lines: &lines)
         self.appendClawRouterUsageLines(snapshot: snapshot, useColor: context.useColor, lines: &lines)
         self.appendSub2APIUsageLines(snapshot: snapshot, useColor: context.useColor, lines: &lines)
@@ -102,7 +108,13 @@ enum CLIRenderer {
             context: context,
             now: now,
             lines: &lines)
-        self.appendTertiaryLines(snapshot: snapshot, labels: labels, context: context, now: now, lines: &lines)
+        self.appendTertiaryLines(
+            provider: provider,
+            snapshot: snapshot,
+            labels: labels,
+            context: context,
+            now: now,
+            lines: &lines)
         self.appendMiMoBalanceLine(snapshot: snapshot, useColor: context.useColor, lines: &lines)
         self.appendClawRouterUsageLines(snapshot: snapshot, useColor: context.useColor, lines: &lines)
         self.appendSub2APIUsageLines(snapshot: snapshot, useColor: context.useColor, lines: &lines)
@@ -574,8 +586,16 @@ enum CLIRenderer {
                 weeklyWorkDays: weeklyWorkDays,
                 now: now)
         }
-        guard primary != nil || secondary != nil else { return nil }
-        return ProviderPacePayload(primary: primary, secondary: secondary)
+        let tertiary = snapshot.tertiary.flatMap {
+            self.pacePayload(
+                provider: provider,
+                window: $0,
+                kind: self.paceKind(provider: provider, fallback: .weekly),
+                weeklyWorkDays: weeklyWorkDays,
+                now: now)
+        }
+        guard primary != nil || secondary != nil || tertiary != nil else { return nil }
+        return ProviderPacePayload(primary: primary, secondary: secondary, tertiary: tertiary)
     }
 
     static func rateLine(title: String, window: RateWindow, useColor: Bool) -> String {
@@ -765,16 +785,28 @@ enum CLIRenderer {
         }
     }
 
+    // swiftlint:disable:next function_parameter_count
     private static func appendTertiaryLines(
+        provider: UsageProvider,
         snapshot: UsageSnapshot,
         labels: RateWindowLabels,
         context: RenderContext,
         now: Date,
         lines: inout [String])
     {
-        guard labels.showsTertiary, let opus = snapshot.tertiary else { return }
-        lines.append(self.rateLine(title: labels.tertiary, window: opus, useColor: context.useColor))
-        if let reset = self.resetLine(for: opus, style: context.resetStyle, now: now) {
+        guard labels.showsTertiary, let tertiary = snapshot.tertiary else { return }
+        lines.append(self.rateLine(title: labels.tertiary, window: tertiary, useColor: context.useColor))
+        if let pace = self.paceLine(
+            provider: provider,
+            window: tertiary,
+            kind: self.paceKind(provider: provider, fallback: .weekly),
+            weeklyWorkDays: context.weeklyWorkDays,
+            useColor: context.useColor,
+            now: now)
+        {
+            lines.append(pace)
+        }
+        if let reset = self.resetLine(for: tertiary, style: context.resetStyle, now: now) {
             lines.append(self.subtleLine(reset, useColor: context.useColor))
         }
     }
@@ -1098,8 +1130,9 @@ enum CLIRenderer {
 
     /// .session mirrors the GUI's session pace (5h window, real session windows only); .weekly reads
     /// weeklyProgressWorkDays from the GUI's UserDefaults (same key) and passes it to UsagePace.weekly,
-    /// so the baseline matches the menu bar when the setting is configured. Codex historical refinement
-    /// is not applied (fixed allowlist only), so it can still differ from the menu for Codex accounts.
+    /// so the baseline matches the menu bar when the setting is configured. Descriptor-backed reset windows
+    /// also use .weekly wording. Codex historical refinement is not applied, so it can still differ from the
+    /// menu for Codex accounts.
     private enum PaceKind {
         case session
         case weekly
@@ -1111,7 +1144,7 @@ enum CLIRenderer {
             }
         }
 
-        func supports(provider: UsageProvider) -> Bool {
+        func supportsStandardPace(provider: UsageProvider) -> Bool {
             switch self {
             case .session:
                 provider == .codex || provider == .claude || provider == .ollama || provider == .kimi
@@ -1122,6 +1155,11 @@ enum CLIRenderer {
         }
     }
 
+    private struct PaceComputation {
+        let pace: UsagePace
+        let kind: PaceKind
+    }
+
     private static func paceKind(provider: UsageProvider, fallback: PaceKind) -> PaceKind {
         guard provider == .kimi else { return fallback }
         // Kimi stores weekly in primary and its rate limit in secondary, opposite the legacy CLI slot convention.
@@ -1138,36 +1176,45 @@ enum CLIRenderer {
         window: RateWindow,
         kind: PaceKind,
         weeklyWorkDays: Int? = nil,
-        now: Date) -> UsagePace?
+        now: Date) -> PaceComputation?
     {
-        guard kind.supports(provider: provider) else { return nil }
+        let capability = ProviderDescriptorRegistry.descriptor(for: provider).pace
+        let paceWindow: RateWindow
+        let resolvedKind: PaceKind
+        if capability.supportsResetWindowPace(window: window, now: now) {
+            paceWindow = capability.resolvedResetWindowForPace(window)
+            resolvedKind = .weekly
+        } else {
+            guard kind.supportsStandardPace(provider: provider) else { return nil }
+            paceWindow = window
+            resolvedKind = kind
+        }
         if provider == .kimi {
-            let supportsWindow = switch kind {
+            let supportsWindow = switch resolvedKind {
             case .session:
-                window.windowMinutes == KimiProviderDescriptor.sessionWindowMinutes
+                paceWindow.windowMinutes == KimiProviderDescriptor.sessionWindowMinutes
             case .weekly:
-                ProviderDescriptorRegistry.descriptor(for: provider).pace
-                    .supportsResetWindowPace(window: window, now: now)
+                capability.supportsResetWindowPace(window: paceWindow, now: now)
             }
             guard supportsWindow else { return nil }
         }
         // Only pace a real session window here; Claude w/o 5-hour data falls a 7-day window into primary.
-        if case .session = kind, let minutes = window.windowMinutes, minutes > 300 {
+        if case .session = resolvedKind, let minutes = paceWindow.windowMinutes, minutes > 300 {
             return nil
         }
-        if provider == .ollama, window.windowMinutes == nil {
+        if provider == .ollama, paceWindow.windowMinutes == nil {
             return nil
         }
-        guard window.remainingPercent > 0 else { return nil }
+        guard paceWindow.remainingPercent > 0 else { return nil }
         // workDays applies only to the weekly (10 080-min) window; UsagePace.weekly ignores it for other durations.
-        let workDays = kind == .weekly ? weeklyWorkDays : nil
+        let workDays = resolvedKind == .weekly ? weeklyWorkDays : nil
         guard let pace = UsagePace.weekly(
-            window: window,
+            window: paceWindow,
             now: now,
-            defaultWindowMinutes: kind.defaultWindowMinutes,
+            defaultWindowMinutes: resolvedKind.defaultWindowMinutes,
             workDays: workDays) else { return nil }
         guard pace.expectedUsedPercent >= Self.paceMinimumExpectedPercent else { return nil }
-        return pace
+        return PaceComputation(pace: pace, kind: resolvedKind)
     }
 
     private static func paceSummary(
@@ -1194,14 +1241,19 @@ enum CLIRenderer {
         useColor: Bool,
         now: Date) -> String?
     {
-        guard let pace = self.computePace(
+        guard let computation = self.computePace(
             provider: provider,
             window: window,
             kind: kind,
             weeklyWorkDays: weeklyWorkDays,
             now: now) else { return nil }
         let label = self.label("Pace", useColor: useColor)
-        return "\(label): \(self.paceSummary(provider: provider, for: pace, kind: kind, now: now))"
+        let summary = self.paceSummary(
+            provider: provider,
+            for: computation.pace,
+            kind: computation.kind,
+            now: now)
+        return "\(label): \(summary)"
     }
 
     private static func pacePayload(
@@ -1211,20 +1263,24 @@ enum CLIRenderer {
         weeklyWorkDays: Int? = nil,
         now: Date) -> PacePayload?
     {
-        guard let pace = self.computePace(
+        guard let computation = self.computePace(
             provider: provider,
             window: window,
             kind: kind,
             weeklyWorkDays: weeklyWorkDays,
             now: now) else { return nil }
         return PacePayload(
-            stage: Self.stageString(pace.stage),
-            deltaPercent: pace.deltaPercent.rounded(),
-            expectedUsedPercent: pace.expectedUsedPercent.rounded(),
-            willLastToReset: pace.willLastToReset,
-            etaSeconds: pace.etaSeconds.map { $0.rounded() },
-            runOutProbability: pace.runOutProbability,
-            summary: self.paceSummary(provider: provider, for: pace, kind: kind, now: now))
+            stage: Self.stageString(computation.pace.stage),
+            deltaPercent: computation.pace.deltaPercent.rounded(),
+            expectedUsedPercent: computation.pace.expectedUsedPercent.rounded(),
+            willLastToReset: computation.pace.willLastToReset,
+            etaSeconds: computation.pace.etaSeconds.map { $0.rounded() },
+            runOutProbability: computation.pace.runOutProbability,
+            summary: self.paceSummary(
+                provider: provider,
+                for: computation.pace,
+                kind: computation.kind,
+                now: now))
     }
 
     private static func stageString(_ stage: UsagePace.Stage) -> String {

Sources/CodexBarCore/Providers/ProviderDescriptor.swift

@@ -75,6 +75,29 @@ public struct ProviderPaceCapability: Sendable {
     public func usesInferredMonthlyDuration(window: RateWindow) -> Bool {
         self.inferredMonthlyDuration.matches(window: window)
     }
+
+    public func resolvedResetWindowForPace(_ window: RateWindow) -> RateWindow {
+        guard self.usesInferredMonthlyDuration(window: window),
+              let resetsAt = window.resetsAt,
+              let minutes = Self.inferredMonthlyWindowMinutes(endingAt: resetsAt)
+        else { return window }
+        return RateWindow(
+            usedPercent: window.usedPercent,
+            windowMinutes: minutes,
+            resetsAt: window.resetsAt,
+            resetDescription: window.resetDescription,
+            nextRegenPercent: window.nextRegenPercent,
+            isSyntheticPlaceholder: window.isSyntheticPlaceholder)
+    }
+
+    private static func inferredMonthlyWindowMinutes(endingAt resetsAt: Date) -> Int? {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone(secondsFromGMT: 0) ?? calendar.timeZone
+        guard let startsAt = calendar.date(byAdding: .month, value: -1, to: resetsAt) else { return nil }
+        let minutes = resetsAt.timeIntervalSince(startsAt) / 60
+        guard minutes.isFinite, minutes > 0 else { return nil }
+        return Int(minutes.rounded())
+    }
 }
 
 public struct ProviderDescriptor: Sendable {