@@ -326,7 +326,12 @@ impl ProviderUsageSnapshot {
             provider_id: id.cli_name().to_string(),
             display_name: id.display_name().to_string(),
             primary: primary_snap,
-            primary_label: Some(metadata.session_label.to_string()),
+            primary_label: Some(
+                usage
+                    .primary_label
+                    .clone()
+                    .unwrap_or_else(|| metadata.session_label.to_string()),
+            ),
             secondary: secondary_snap,
             secondary_label: usage
                 .secondary
 
@@ -554,11 +554,18 @@ fn append_usage_window_lines(
     metadata: &crate::core::ProviderMetadata,
     use_color: bool,
 ) {
-    append_window_line(lines, metadata.session_label, &usage.primary, use_color);
-    // Upstream 0.50.1 #2957: pace for the 5-hour session window.
-    if usage.primary.window_minutes == Some(crate::core::SESSION_WINDOW_MINUTES)
-        && let Some(pace) =
-            UsagePace::weekly(&usage.primary, None, crate::core::SESSION_WINDOW_MINUTES)
+    let primary_label = usage
+        .primary_label
+        .as_deref()
+        .unwrap_or(metadata.session_label);
+    append_window_line(lines, primary_label, &usage.primary, use_color);
+    // Pace for primary windows whose provider published a common cadence.
+    let pace_minutes = usage.primary.window_minutes.filter(|minutes| {
+        *minutes == crate::core::SESSION_WINDOW_MINUTES
+            || *minutes >= crate::core::WEEKLY_WINDOW_MINUTES
+    });
+    if let Some(minutes) = pace_minutes
+        && let Some(pace) = UsagePace::weekly(&usage.primary, None, minutes)
     {
         lines.push(format!(
             "  Pace:    {} {}",
@@ -643,14 +650,18 @@ fn append_model_specific_line(
 pub fn render_brief_text(provider: ProviderId, result: &ProviderFetchResult) -> String {
     let metadata = instantiate_provider(provider).metadata().clone();
     let usage = &result.usage;
+    let primary_label = usage
+        .primary_label
+        .as_deref()
+        .unwrap_or(metadata.session_label);
     let mut parts = Vec::new();
     let reset = if usage.primary.is_informational {
-        parts.push(format!("{} unavailable", metadata.session_label));
+        parts.push(format!("{primary_label} unavailable"));
         usage.secondary.as_ref().unwrap_or(&usage.primary)
     } else {
         parts.push(format!(
             "{} {}",
-            metadata.session_label,
+            primary_label,
             format_percent(usage.primary.used_percent)
         ));
         &usage.primary
@@ -799,6 +810,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn primary_label_override_is_shared_by_full_and_brief_renderers() {
+        let result =
+            fetch_result(UsageSnapshot::new(RateWindow::new(42.0)).with_primary_label("Monthly"));
+
+        let full = render_text_with_status(ProviderId::Grok, &result, None, false);
+        let brief = render_brief_text(ProviderId::Grok, &result);
+
+        assert!(full.contains("Monthly:"));
+        assert!(brief.contains("Grok: Monthly 42%"));
+        assert!(!brief.contains("Credits 42%"));
+    }
+
     #[test]
     fn gemini_plan_preserves_acronym_casing() {
         let result = fetch_result(
 
@@ -76,6 +76,11 @@ pub struct UsageSnapshot {
     /// Primary rate window (usually session-based, e.g., 5-hour for Claude)
     pub primary: RateWindow,
 
+    /// Provider-resolved label for the primary rate window when the stable
+    /// provider metadata label is not specific enough for this snapshot.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub primary_label: Option<String>,
+
     /// Secondary rate window (usually weekly/monthly)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub secondary: Option<RateWindow>,
@@ -113,6 +118,7 @@ impl UsageSnapshot {
     pub fn new(primary: RateWindow) -> Self {
         Self {
             primary,
+            primary_label: None,
             secondary: None,
             model_specific: None,
             tertiary: None,
@@ -124,6 +130,12 @@ impl UsageSnapshot {
         }
     }
 
+    /// Builder pattern: override the primary window label for this snapshot.
+    pub fn with_primary_label(mut self, label: impl Into<String>) -> Self {
+        self.primary_label = Some(label.into());
+        self
+    }
+
     /// Builder pattern: set secondary window
     pub fn with_secondary(mut self, secondary: RateWindow) -> Self {
         self.secondary = Some(secondary);
 
@@ -33,7 +33,7 @@ impl GrokProvider {
             metadata: ProviderMetadata {
                 id: ProviderId::Grok,
                 display_name: "Grok",
-                session_label: "Monthly",
+                session_label: "Credits",
                 weekly_label: "On-demand",
                 supports_opus: false,
                 supports_credits: false,
@@ -434,6 +434,25 @@ fn text_field(value: &Value, key: &str) -> Option<String> {
 struct GrokBillingSnapshot {
     used_percent: Option<f64>,
     resets_at: Option<DateTime<Utc>>,
+    window_minutes: Option<u32>,
+}
+
+/// Classify Grok from the full billing-cycle duration, not time remaining.
+/// This preserves the upstream #2431/#2566 invariant that a monthly plan near
+/// its reset must not become a weekly plan.
+fn primary_label_for_cycle_minutes(minutes: u32) -> Option<&'static str> {
+    const DAY_MINUTES: u32 = 24 * 60;
+    if minutes <= 60 {
+        return None;
+    }
+    let days = (minutes + DAY_MINUTES / 2) / DAY_MINUTES;
+    if (4..=12).contains(&days) {
+        Some("Weekly")
+    } else if (20..=45).contains(&days) {
+        Some("Monthly")
+    } else {
+        None
+    }
 }
 
 fn result_from_billing(
@@ -443,17 +462,30 @@ fn result_from_billing(
     team_id: Option<String>,
     login_method: Option<String>,
 ) -> ProviderFetchResult {
-    // Upstream #2431 / #2566: do not infer windowMinutes from time-until-reset.
-    // A monthly quota near its reset would otherwise be misclassified as weekly.
+    // Dynamic cadence is provider-owned and comes only from a complete billing
+    // cycle. A reset timestamp alone is insufficient because monthly quotas can
+    // have only a few days remaining.
+    let primary_label = billing
+        .window_minutes
+        .and_then(primary_label_for_cycle_minutes);
     let primary = match billing.used_percent {
-        Some(used_percent) => RateWindow::with_details(used_percent, None, billing.resets_at, None),
+        Some(used_percent) => RateWindow::with_details(
+            used_percent,
+            billing.window_minutes,
+            billing.resets_at,
+            None,
+        ),
         None => {
             let mut window = RateWindow::informational("Usage unavailable");
             window.resets_at = billing.resets_at;
+            window.window_minutes = billing.window_minutes;
             window
         }
     };
     let mut usage = UsageSnapshot::new(primary);
+    if let Some(label) = primary_label {
+        usage = usage.with_primary_label(label);
+    }
     usage.account_email = email;
     usage.account_organization = team_id;
     usage.login_method = login_method;
@@ -532,29 +564,50 @@ fn parse_grpc_web_response(data: &[u8]) -> Result<GrokBillingSnapshot, ProviderE
         })
         .map(|field| field.value as f64);
 
+    let now = Utc::now();
     let resets_at = scan
         .varints
         .iter()
-        .filter_map(|field| {
-            // Varint timestamps are Unix seconds inside the range checked below.
-            #[allow(
-                clippy::cast_possible_wrap,
-                reason = "varint timestamps are bounded to the Unix-seconds range checked below"
-            )]
-            let seconds = field.value as i64;
-            (1_700_000_000..=2_100_000_000)
-                .contains(&field.value)
-                .then(|| Utc.timestamp_opt(seconds, 0).single())
-                .flatten()
-        })
-        .filter(|dt| *dt > Utc::now())
+        .filter_map(varint_timestamp)
+        .filter(|dt| *dt > now)
         .min();
     Ok(GrokBillingSnapshot {
         used_percent,
         resets_at,
+        window_minutes: current_period_window_minutes(&scan, now),
     })
 }
 
+fn varint_timestamp(field: &VarintField) -> Option<DateTime<Utc>> {
+    // Varint timestamps are Unix seconds inside the range checked below.
+    #[allow(
+        clippy::cast_possible_wrap,
+        reason = "varint timestamps are bounded to the Unix-seconds range checked below"
+    )]
+    let seconds = field.value as i64;
+    (1_700_000_000..=2_100_000_000)
+        .contains(&field.value)
+        .then(|| Utc.timestamp_opt(seconds, 0).single())
+        .flatten()
+}
+
+fn current_period_window_minutes(scan: &ProtoScan, now: DateTime<Utc>) -> Option<u32> {
+    let timestamp_at = |path: &[u64]| {
+        scan.varints
+            .iter()
+            .find(|field| field.path.as_slice() == path)
+            .and_then(varint_timestamp)
+    };
+    let start = timestamp_at(&[1, 8, 2, 1])?;
+    let end = timestamp_at(&[1, 8, 3, 1])?;
+    if start > now || end <= now || end <= start {
+        return None;
+    }
+    u32::try_from((end - start).num_minutes())
+        .ok()
+        .filter(|minutes| *minutes > 0)
+}
+
 fn grpc_web_data_frames(data: &[u8]) -> Vec<Vec<u8>> {
     let mut frames = Vec::new();
     let mut index = 0;
@@ -591,6 +644,7 @@ struct Fixed32Field {
 }
 
 struct VarintField {
+    path: Vec<u64>,
     value: u64,
 }
 
@@ -624,17 +678,20 @@ impl ProtoScan {
         wire: u64,
     ) -> Option<usize> {
         match wire {
-            0 => self.scan_varint(data, i),
+            0 => self.scan_varint(data, i, path),
             2 => self.scan_length_delimited(data, i, path, depth),
             5 => self.scan_fixed32(data, i, path),
             1 => Some(i.saturating_add(8)),
             _ => None,
         }
     }
 
-    fn scan_varint(&mut self, data: &[u8], i: usize) -> Option<usize> {
+    fn scan_varint(&mut self, data: &[u8], i: usize, path: &[u64]) -> Option<usize> {
         let (value, next) = read_varint(data, i)?;
-        self.varints.push(VarintField { value });
+        self.varints.push(VarintField {
+            path: path.to_vec(),
+            value,
+        });
         Some(next)
     }
 
@@ -794,22 +851,99 @@ mod tests {
     }
 
     #[test]
-    fn billing_snapshot_leaves_window_minutes_unset() {
-        // A monthly quota with six days left must not be reported as weekly.
-        let resets = Utc::now() + chrono::Duration::days(6);
+    fn billing_snapshot_uses_full_weekly_cycle_for_pace() {
+        let now = Utc::now();
+        let resets = now + chrono::Duration::days(2);
         let result = result_from_billing(
             GrokBillingSnapshot {
                 used_percent: Some(12.0),
                 resets_at: Some(resets),
+                window_minutes: Some(crate::core::WEEKLY_WINDOW_MINUTES),
+            },
+            "web",
+            None,
+            None,
+            Some("SuperGrok".into()),
+        );
+        assert_eq!(
+            result.usage.primary.window_minutes,
+            Some(crate::core::WEEKLY_WINDOW_MINUTES)
+        );
+        assert_eq!(result.usage.primary_label.as_deref(), Some("Weekly"));
+        let pace = crate::core::UsagePace::weekly(
+            &result.usage.primary,
+            Some(now),
+            crate::core::WEEKLY_WINDOW_MINUTES,
+        );
+        assert!(pace.is_some(), "weekly window + reset must yield pace");
+    }
+
+    #[test]
+    fn monthly_cycle_stays_monthly_with_six_days_remaining() {
+        let now = Utc::now();
+        let resets = now + chrono::Duration::days(6);
+        let monthly_minutes = 31 * 24 * 60;
+        let result = result_from_billing(
+            GrokBillingSnapshot {
+                used_percent: Some(40.0),
+                resets_at: Some(resets),
+                window_minutes: Some(monthly_minutes),
+            },
+            "cli",
+            None,
+            None,
+            Some("SuperGrok Heavy".into()),
+        );
+        assert_eq!(result.usage.primary_label.as_deref(), Some("Monthly"));
+        assert_eq!(result.usage.primary.window_minutes, Some(monthly_minutes));
+    }
+
+    #[test]
+    fn reset_distance_alone_does_not_invent_a_cadence() {
+        let resets = Utc::now() + chrono::Duration::days(6);
+        let result = result_from_billing(
+            GrokBillingSnapshot {
+                used_percent: Some(80.0),
+                resets_at: Some(resets),
+                window_minutes: None,
             },
             "web",
             None,
             None,
             Some("SuperGrok".into()),
         );
         assert_eq!(result.usage.primary.window_minutes, None);
-        assert_eq!(result.usage.primary.resets_at, Some(resets));
-        assert_eq!(result.usage.login_method.as_deref(), Some("SuperGrok"));
+        assert_eq!(result.usage.primary_label, None);
+    }
+
+    #[test]
+    fn current_period_paths_define_the_full_cycle() {
+        let now = Utc.timestamp_opt(1_800_000_000, 0).single().unwrap();
+        let start = now - chrono::Duration::days(25);
+        let end = now + chrono::Duration::days(6);
+        let scan = ProtoScan {
+            fixed32: Vec::new(),
+            varints: vec![
+                VarintField {
+                    path: vec![1, 8, 2, 1],
+                    value: u64::try_from(start.timestamp()).unwrap(),
+                },
+                VarintField {
+                    path: vec![1, 8, 3, 1],
+                    value: u64::try_from(end.timestamp()).unwrap(),
+                },
+            ],
+            order: 0,
+        };
+
+        assert_eq!(
+            current_period_window_minutes(&scan, now),
+            Some(31 * 24 * 60)
+        );
+        assert_eq!(
+            primary_label_for_cycle_minutes(current_period_window_minutes(&scan, now).unwrap()),
+            Some("Monthly")
+        );
     }
 
     #[test]
@@ -819,6 +953,7 @@ mod tests {
             GrokBillingSnapshot {
                 used_percent: None,
                 resets_at: Some(resets),
+                window_minutes: None,
             },
             "cli",
             Some("user@example.com".into()),