ai_usagebar/tui/

panels.rs

//! Native ratatui panels.
//!
//! Each vendor projects its snapshot into a sequence of [`Section`]s — either
//! a metric (gauge + footnote) or a free-form text block. The renderer lays
//! them out vertically with consistent spacing so every panel has the same
//! visual rhythm regardless of vendor.
//!
//! Progress bars use Bubble Tea-style block glyphs that scale to the available
//! width, so on a wide monitor you get long, readable bars instead of the
//! 20-char Pango ones the Waybar tooltip is stuck with.

use chrono::{DateTime, Utc};
use ratatui::Frame;
use ratatui::layout::{Constraint, Layout, Rect};
use ratatui::style::{Modifier, Style};
use ratatui::text::{Line, Span};
use ratatui::widgets::Paragraph;
use ratatui_bubbletea_components::{Progress, Spinner, SpinnerFrames};
use ratatui_bubbletea_theme::BubbleTheme;

use crate::balance::{self, DisplayPrefs, MetricHeadline};
use crate::countdown;
use crate::format::{
    clamp_pct, cursor_credit_label, cursor_credit_meter, local_time_hms, money, reset_credit_lines,
    usd,
};
use crate::pacing::{self, PaceSeverity};
use crate::pango::severity_for;
use crate::theme::Theme;
use crate::tui::app::TabState;
use crate::tui::style::{bubble_theme, color, progress_theme, severity_color};
use crate::usage::VendorSnapshot;

/// One row of the panel body. Vendors emit a `Vec<Section>`; the renderer
/// turns them into ratatui widgets.
pub enum Section {
    /// Title row at the top. `left` is the plan/vendor label (accent-colored,
    /// bold); `right` is an optional right-aligned annotation, used for the
    /// "Updated HH:MM:SS" timestamp so it shares the title row instead of
    /// taking a separate body row + duplicating the global footer's clock.
    Title { left: String, right: Option<String> },
    /// A metric: label + gauge + value annotation + dim footnote.
    Metric {
        label: String,
        pct: u16,
        severity: PaceSeverity,
        value_label: String,
        footnote: String,
    },
    /// Free-form key/value text line.
    Text { label: String, value: String },
    /// A label followed by a multi-line dim block (no gauge).
    Block { label: String, body: Vec<String> },
    /// Visual spacer (one blank row).
    Spacer,
}

/// Internal metadata carried alongside a public [`Section`]. Keeping this
/// wrapper private to the crate lets machine-readable frontends receive
/// absolute reset timestamps without adding a source-breaking field to the
/// public `Section::Metric` variant.
pub(crate) struct SectionProjection {
    pub section: Section,
    pub reset_at: Option<DateTime<Utc>>,
    /// Full length of the metric's reset window, when it is known exactly
    /// (a rolling 5h/7d window). `None` for calendar periods and for quotas
    /// whose window length the vendor never states — a frontend can pace a
    /// metric only when this is `Some`.
    pub window: Option<chrono::Duration>,
    /// Named sub-group the metric belongs under (e.g. SuperGrok's product
    /// slices under `"Breakdown"`), so a frontend can draw it as a compact
    /// row beneath a heading instead of a peer of the overall meter. The TUI
    /// renders grouped metrics like any other; only the report carries this.
    pub group: Option<&'static str>,
    /// A per-model quota pool (Antigravity's "Gemini 4 Argon"): the limit of
    /// one model, not one of the windows every model of the provider shares.
    /// A frontend that sums the provider up in one figure ranks it below
    /// those, so an exhausted model does not read as an exhausted provider.
    pub model_pool: bool,
    /// Which of the metric's two numbers a report-driven frontend puts on the
    /// bar. Every metric is a percentage unless its vendor says otherwise, so
    /// this is [`MetricHeadline::Percent`] by default — the bar draws it and
    /// leaves the money figure in the detail. A prepaid-balance vendor flips
    /// it, and that declaration is what the frontend reads instead of guessing
    /// from the label.
    pub headline: MetricHeadline,
    /// USD cents of spend behind a text row's formatted value. Set only for
    /// Cursor's On-Demand line. The report copies the cents onto that text
    /// section so a frontend can meter the prepaid cap without parsing the
    /// `$spent / $cap` string `fmt_minor` produced.
    pub used_cents: Option<i64>,
    /// Positive prepaid cap in USD cents. `None` when Cursor reported spend
    /// without a cap — the row stays a plain amount.
    pub limit_cents: Option<i64>,
    /// Amount the metric's window refills by when it reopens (Synthetic's
    /// weekly credit tick, e.g. `"2%"`). Present only for refill-style
    /// windows, so a frontend's countdown reads "Regenerates X in …"
    /// instead of "Resets in …".
    pub regen: Option<String>,
    /// The metric's percentage with its decimal precision preserved, for
    /// frontends that print a figure ("70.5%"). Only vendors whose API
    /// reports a fraction set this; the integer `Section::Metric::pct`
    /// remains what meters and severity colours use.
    pub percent_precise: Option<f64>,
    /// How a frontend should read the percentage. Refill-style windows
    /// (Synthetic's weekly credits) read as a fuel gauge — `"left"`, what
    /// remains — while fixed windows keep the default "used" reading and
    /// omit the field.
    pub reading: Option<&'static str>,
}

struct SectionBuilder(Vec<SectionProjection>);

impl SectionBuilder {
    fn projection(section: Section) -> SectionProjection {
        SectionProjection {
            section,
            reset_at: None,
            window: None,
            group: None,
            model_pool: false,
            headline: MetricHeadline::Percent,
            used_cents: None,
            limit_cents: None,
            regen: None,
            percent_precise: None,
            reading: None,
        }
    }

    fn new(sections: Vec<Section>) -> Self {
        Self(
            sections
                .into_iter()
                .map(|section| {
                    assert!(
                        !matches!(section, Section::Metric { .. }),
                        "metric sections must declare reset metadata with push_metric"
                    );
                    Self::projection(section)
                })
                .collect(),
        )
    }

    fn push(&mut self, section: Section) {
        assert!(
            !matches!(section, Section::Metric { .. }),
            "metric sections must declare reset metadata with push_metric"
        );
        self.0.push(Self::projection(section));
    }

    /// A metric whose window length is not known exactly (a calendar month,
    /// a vendor-defined billing period, or no stated window at all).
    fn push_metric(&mut self, section: Section, reset_at: Option<DateTime<Utc>>) {
        assert!(matches!(section, Section::Metric { .. }));
        let mut row = Self::projection(section);
        row.reset_at = reset_at;
        self.0.push(row);
    }

    /// Mark the most recently pushed metric as a refilling window: `amount`
    /// is what the vendor restores when it reopens (Synthetic's weekly
    /// credit tick), so the footnote and every report-driven countdown read
    /// "Regenerates {amount} in …" instead of "Resets in …". The report
    /// also tags the metric `reading: "left"`: a budget that regenerates
    /// reads as a fuel gauge — what remains — whatever the global reading.
    fn regen_last_metric(&mut self, amount: String) {
        let Some(last) = self.0.last_mut() else {
            return;
        };
        last.regen = Some(amount.clone());
        last.reading = Some("left");
        if let Section::Metric { footnote, .. } = &mut last.section
            && let Some(rest) = footnote.strip_prefix("Resets in ")
        {
            *footnote = format!("Regenerates {amount} in {rest}");
        }
    }

    /// Give the most recently pushed metric a decimal-precise percentage
    /// (Synthetic's weekly budget), so report-driven frontends can print
    /// "70.5%" instead of the meter's rounded integer. The printed value
    /// label gains the same precision; the meter keeps the integer.
    fn precise_last_metric(&mut self, pct: f64) {
        let Some(last) = self.0.last_mut() else {
            return;
        };
        last.percent_precise = Some(pct);
        if let Section::Metric { value_label, .. } = &mut last.section {
            *value_label = format_precise_pct(pct);
        }
    }

    /// A metric whose vendor chose which of its two numbers goes on the bar.
    /// Only a prepaid-balance vendor (and Nous Research, whose credits are a
    /// balance too) needs this; everything else is a percentage and uses
    /// [`SectionBuilder::push_metric`].
    fn push_metric_with_headline(
        &mut self,
        section: Section,
        reset_at: Option<DateTime<Utc>>,
        headline: MetricHeadline,
    ) {
        assert!(matches!(section, Section::Metric { .. }));
        let mut row = Self::projection(section);
        row.reset_at = reset_at;
        row.headline = headline;
        self.0.push(row);
    }

    /// A metric on a window of exactly `window` length, so a frontend can
    /// compute how far through the window `reset_at` sits.
    fn push_metric_in_window(
        &mut self,
        section: Section,
        reset_at: Option<DateTime<Utc>>,
        window: chrono::Duration,
    ) {
        assert!(matches!(section, Section::Metric { .. }));
        let mut row = Self::projection(section);
        row.reset_at = reset_at;
        row.window = Some(window);
        self.0.push(row);
    }

    /// A metric that belongs to a named sub-group of the panel (SuperGrok's
    /// product slices under `"Breakdown"`). Grouped slices share the overall
    /// pool's window, so they carry no reset of their own; the group label is
    /// the only extra thing they assert.
    fn push_metric_in_group(&mut self, section: Section, group: &'static str) {
        assert!(matches!(section, Section::Metric { .. }));
        let mut row = Self::projection(section);
        row.group = Some(group);
        self.0.push(row);
    }
    /// Mark the metric just pushed as a per-model quota pool; see
    /// [`SectionProjection::model_pool`].
    fn mark_model_pool(&mut self) {
        let row = self.0.last_mut().expect("a metric was just pushed");
        assert!(matches!(row.section, Section::Metric { .. }));
        row.model_pool = true;
    }

    /// Cursor's prepaid on-demand row. `value` stays the formatted pair the
    /// TUI and every other frontend print. The cents travel beside it so a
    /// frontend can meter the cap without parsing that string. A non-positive
    /// cap is spend with nothing to meter against, so it is not recorded.
    fn push_on_demand(&mut self, used_cents: i64, limit_cents: Option<i64>) {
        let value = match limit_cents {
            Some(limit) => format!(
                "{} / {}",
                crate::usage::fmt_minor(used_cents, 2, Some("USD")),
                crate::usage::fmt_minor(limit, 2, Some("USD"))
            ),
            None => crate::usage::fmt_minor(used_cents, 2, Some("USD")),
        };
        let mut row = Self::projection(Section::Text {
            label: "On-Demand".into(),
            value,
        });
        row.used_cents = Some(used_cents);
        row.limit_cents = limit_cents.filter(|limit| *limit > 0);
        self.0.push(row);
    }
}

/// The headline row of a prepaid-balance vendor: money remaining, drawn as a
/// consumed meter when something supplies a tank size and as a plain text row
/// when nothing does.
///
/// Every balance-only vendor gets the same shape from here, so the tank, the
/// severity floor and the detail line cannot drift apart between them.
///
/// `api_limit` is the denominator the vendor's own API states, if any; it wins
/// over the user's `display_limit`. `money_severity` is the vendor's existing
/// money-based tier, which stays the floor: a nearly empty wallet is still
/// critical however large the tank, and a mostly-spent tank is still high
/// however much money is nominally left.
fn push_balance_headline(
    v: &mut SectionBuilder,
    label: &str,
    remaining: f64,
    currency: &str,
    money_severity: PaceSeverity,
    api_limit: Option<f64>,
    prefs: DisplayPrefs,
) {
    let amount = money(remaining, currency);
    let Some(limit) = balance::denominator(api_limit, prefs.display_limit) else {
        // No denominator from either source: nothing to meter against, so the
        // row stays free text rather than becoming a fabricated 0% gauge.
        v.push(Section::Text {
            label: label.into(),
            value: amount,
        });
        return;
    };

    let pct = balance::consumed_pct(limit, remaining);
    let headline = balance::resolve_headline(prefs.headline, Some(limit));
    let of_limit = money(limit, currency);
    let (value_label, footnote) = match headline {
        MetricHeadline::Percent => (
            format!("{pct}%"),
            format!("{amount} of {of_limit} left ({pct}% used)"),
        ),
        MetricHeadline::Value => (
            amount.clone(),
            format!("{pct}% of {of_limit} used ({amount} left)"),
        ),
    };
    v.push_metric_with_headline(
        Section::Metric {
            label: label.into(),
            pct,
            severity: money_severity.max(severity_for(i32::from(pct))),
            value_label,
            footnote,
        },
        None,
        headline,
    );
}

/// Compact one-line projection of a vendor snapshot for the Overview: a short
/// plan/tier sub-label (may be empty) plus a few key metric cells — a percent
/// or a balance — each carrying a severity for coloring. Same numbers as
/// [`sections_for`], flattened for a dense multi-vendor list. The vendor's name
/// is supplied by the caller, so it is not repeated here.
pub fn compact_cells(snapshot: &VendorSnapshot) -> (String, Vec<(String, PaceSeverity)>) {
    let pct = |label: &str, p: i32| (format!("{label} {p}%"), severity_for(p));
    // Named `*_cell` so neither shadows `format::{usd, money}`, which they
    // wrap — the cell is the string plus the severity the Overview colours it with.
    let usd_cell = |v: f64| (usd(v), PaceSeverity::Low);
    let money_cell = |v: f64, c: &str| (money(v, c), PaceSeverity::Low);
    let (plan, mut cells) = match snapshot {
        VendorSnapshot::Anthropic(s) => {
            let mut cells = vec![
                pct("S", s.session.utilization_pct),
                pct("W", s.weekly.utilization_pct),
            ];
            if let Some(sonnet) = &s.sonnet {
                cells.push(pct("Son", sonnet.utilization_pct));
            }
            (s.plan.clone(), cells)
        }
        VendorSnapshot::AnthropicApi(s) => {
            let cell = match s.pct() {
                Some(p) => pct("spend", p),
                None => (format!("{}/mo", usd(s.spent)), PaceSeverity::Low),
            };
            (String::new(), vec![cell])
        }
        VendorSnapshot::Openai(s) => {
            let mut cells = Vec::new();
            if let Some(w) = &s.session {
                cells.push(pct("5h", w.utilization_pct));
            }
            if let Some(w) = &s.weekly {
                cells.push(pct("7d", w.utilization_pct));
            }
            if cells.is_empty() {
                cells.push(("—".into(), PaceSeverity::Low));
            }
            (s.plan.clone(), cells)
        }
        VendorSnapshot::MuseCode(s) => {
            let mut cells = Vec::new();
            if let Some(window) = &s.session {
                cells.push(pct("S", window.utilization_pct));
            }
            if let Some(window) = &s.weekly {
                cells.push(pct("W", window.utilization_pct));
            }
            (s.plan.clone(), cells)
        }
        VendorSnapshot::Copilot(s) => (
            s.plan.clone(),
            s.quotas()
                .map(|(label, quota)| pct(label, quota.used_pct()))
                .collect(),
        ),
        VendorSnapshot::Zai(s) => {
            let mut cells = Vec::new();
            if let Some(w) = &s.session {
                cells.push(pct("S", w.utilization_pct));
            }
            if let Some(w) = &s.weekly {
                cells.push(pct("W", w.utilization_pct));
            }
            if cells.is_empty() {
                cells.push(("—".into(), PaceSeverity::Low));
            }
            (s.plan.clone(), cells)
        }
        VendorSnapshot::Openrouter(s) => (String::new(), vec![usd_cell(s.balance())]),
        VendorSnapshot::OrcaRouter(s) => (
            String::new(),
            vec![match s.remaining_usd() {
                Some(remaining) => usd_cell(remaining),
                None => usd_cell(s.spent_usd()),
            }],
        ),
        VendorSnapshot::Deepseek(s) => (String::new(), vec![money_cell(s.balance, &s.currency)]),
        VendorSnapshot::Deepinfra(s) => (
            String::new(),
            vec![(usd(s.balance), crate::deepinfra::vendor::severity(s))],
        ),
        VendorSnapshot::Kimi(s) => {
            let mut cells = vec![pct("5h", s.window_pct())];
            if s.has_weekly {
                cells.push(pct("wk", s.weekly_pct()));
            }
            if let Some(monthly) = s.monthly_pct {
                cells.push(pct("mo", monthly));
            }
            (s.plan.clone().unwrap_or_default(), cells)
        }
        VendorSnapshot::Kilo(s) => (String::new(), vec![usd_cell(s.balance)]),
        VendorSnapshot::Novita(s) => (String::new(), vec![usd_cell(s.available)]),
        VendorSnapshot::Synthetic(s) => {
            (String::new(), vec![pct("week", s.weekly.utilization_pct)])
        }
        VendorSnapshot::Lyceum(s) => (
            String::new(),
            vec![(usd(s.available_credits), PaceSeverity::Low)],
        ),
        VendorSnapshot::Moonshot(s) => (String::new(), vec![money_cell(s.available, &s.currency)]),
        VendorSnapshot::Grok(s) => (String::new(), vec![usd_cell(s.balance)]),
        VendorSnapshot::SuperGrok(s) => (s.plan.clone(), vec![pct(s.period.short(), s.weekly_pct)]),
        VendorSnapshot::Grokbot(s) => {
            // No included allowance is a state, not a 0% — no meter cell.
            let cells = if s.has_included_allowance {
                vec![pct("wk", s.weekly_pct)]
            } else {
                vec![("—".into(), PaceSeverity::Low)]
            };
            (s.display_plan().to_string(), cells)
        }
        VendorSnapshot::ModelStudio(s) => {
            // Absent windows drop their cell — no-data is not 0%.
            let cells = [
                ("5h", s.session.as_ref()),
                ("wk", s.weekly.as_ref()),
                ("mo", s.monthly.as_ref()),
            ]
            .into_iter()
            .filter_map(|(label, window)| window.map(|w| pct(label, w.utilization_pct)))
            .collect::<Vec<_>>();
            (
                crate::vendor::VendorId::ModelStudio
                    .display_name()
                    .to_string(),
                cells,
            )
        }
        VendorSnapshot::Devin(s) => {
            let mut cells = [("D", s.daily.as_ref()), ("W", s.weekly.as_ref())]
                .into_iter()
                .filter_map(|(label, window)| window.map(|w| pct(label, w.utilization_pct)))
                .collect::<Vec<_>>();
            if let Some(balance) = s.overage_balance_micros {
                cells.push((
                    crate::usage::fmt_minor(balance, crate::devin::vendor::BALANCE_DECIMALS, None),
                    PaceSeverity::Low,
                ));
            }
            // The caller prints the vendor name; an empty plan label keeps it
            // from appearing twice (Lyceum does the same).
            (String::new(), cells)
        }
        VendorSnapshot::Droid(s) => {
            let mut cells = [
                ("5h", s.session.as_ref()),
                ("wk", s.weekly.as_ref()),
                ("mo", s.monthly.as_ref()),
            ]
            .into_iter()
            .filter_map(|(label, window)| window.map(|w| pct(label, w.utilization_pct)))
            .collect::<Vec<_>>();
            if let Some(balance) = s.extra_balance_cents {
                cells.push((
                    crate::droid::vendor::extra_balance(balance),
                    PaceSeverity::Low,
                ));
            }
            // The caller prints the vendor name; an empty plan label keeps it
            // from appearing twice (Devin and Lyceum do the same).
            (String::new(), cells)
        }
        VendorSnapshot::Antigravity(s) => (
            s.plan.clone(),
            [
                s.session.as_ref().map(|w| pct("S", w.utilization_pct)),
                s.weekly.as_ref().map(|w| pct("W", w.utilization_pct)),
            ]
            .into_iter()
            .flatten()
            .collect(),
        ),
        VendorSnapshot::Cursor(s) => (
            s.plan.clone(),
            vec![pct("auto", s.auto_pct), pct("premium", s.api_pct)],
        ),
        VendorSnapshot::Minimax(s) => (
            s.plan.clone(),
            vec![
                pct("S", s.session.utilization_pct),
                pct("W", s.weekly.utilization_pct),
            ],
        ),
        VendorSnapshot::Kiro(s) => (s.plan.clone(), vec![pct("credits", s.pct())]),
        VendorSnapshot::NousResearch(s) => {
            let cell = s
                .usage_percent()
                .map(|value| pct("usage", i32::from(clamp_pct(value))))
                .unwrap_or_else(|| ("—".into(), PaceSeverity::Low));
            (s.plan.clone().unwrap_or_default(), vec![cell])
        }
        VendorSnapshot::CommandCode(s) => {
            let cells = [
                ("session", s.five_hour.as_ref()),
                ("weekly", s.weekly.as_ref()),
                ("monthly", s.monthly_window().as_ref()),
            ]
            .into_iter()
            .filter_map(|(label, window)| window.map(|window| pct(label, window.pct())))
            .collect();
            (s.plan.clone().unwrap_or_default(), cells)
        }
        VendorSnapshot::Cline(s) => {
            let cells = s
                .windows()
                .into_iter()
                .filter_map(|(label, window)| window.map(|window| pct(label, window.pct())))
                .collect();
            (s.plan.clone().unwrap_or_else(|| "Cline".into()), cells)
        }
        VendorSnapshot::OpenCodeGo(s) => {
            let cells = [
                ("rolling", s.rolling.as_ref()),
                ("weekly", s.weekly.as_ref()),
                ("monthly", s.monthly.as_ref()),
            ]
            .into_iter()
            .filter_map(|(label, window)| {
                window.map(|window| pct(label, i32::from(clamp_pct(window.percent))))
            })
            .collect();
            ("OpenCode Go".into(), cells)
        }
        VendorSnapshot::Ollama(s) => {
            let cells = [
                ("5h", s.session.as_ref()),
                ("wk", s.weekly.as_ref()),
                ("mo", s.monthly.as_ref()),
            ]
            .into_iter()
            .filter_map(|(label, window)| {
                window.map(|window| pct(label, window.utilization_pct.clamp(0, 100)))
            })
            .collect();
            (s.plan.clone(), cells)
        }
        VendorSnapshot::Custom(s) => (
            s.plan.clone().unwrap_or_default(),
            s.metrics
                .iter()
                .take(3)
                .map(|metric| pct(&metric.label, i32::from(metric.pct)))
                .collect(),
        ),
    };

    for (text, _) in &mut cells {
        *text = crate::display::sanitize_untrusted_field(text);
    }
    (crate::display::sanitize_untrusted_field(&plan), cells)
}

/// The single most-relevant percentage for a vendor in the Overview — what its
/// per-row mini bar shows. Mirrors the macOS menu bar's headline: Cursor is the
/// combined included-total, quota vendors the most-exhausted window; balance
/// vendors have no meaningful percentage (`None` → no bar).
pub fn headline_pct(snapshot: &VendorSnapshot) -> Option<i32> {
    match snapshot {
        VendorSnapshot::Anthropic(s) => [
            Some(s.session.utilization_pct),
            Some(s.weekly.utilization_pct),
            s.sonnet.as_ref().map(|w| w.utilization_pct),
        ]
        .into_iter()
        .flatten()
        .max(),
        VendorSnapshot::AnthropicApi(s) => s.pct(),
        VendorSnapshot::Openai(s) => [
            s.session.as_ref().map(|w| w.utilization_pct),
            s.weekly.as_ref().map(|w| w.utilization_pct),
        ]
        .into_iter()
        .flatten()
        .max(),
        VendorSnapshot::Copilot(s) => s.quotas().map(|(_, quota)| quota.used_pct()).max(),
        VendorSnapshot::Zai(s) => [
            s.session.as_ref().map(|w| w.utilization_pct),
            s.weekly.as_ref().map(|w| w.utilization_pct),
        ]
        .into_iter()
        .flatten()
        .max(),
        VendorSnapshot::Kimi(s) => Some(s.worst_pct()),
        VendorSnapshot::Antigravity(s) => [
            s.session.as_ref().map(|w| w.utilization_pct),
            s.weekly.as_ref().map(|w| w.utilization_pct),
            s.third_party_session.as_ref().map(|w| w.utilization_pct),
            s.third_party_weekly.as_ref().map(|w| w.utilization_pct),
        ]
        .into_iter()
        .flatten()
        .chain(s.model_pools.iter().map(|p| p.window.utilization_pct))
        .max(),
        VendorSnapshot::Cursor(s) => (!s.unlimited).then_some(s.total_pct),
        VendorSnapshot::Minimax(s) => Some(s.session.utilization_pct.max(s.weekly.utilization_pct)),
        VendorSnapshot::Kiro(s) => Some(s.pct()),
        VendorSnapshot::NousResearch(s) => {
            s.usage_percent().map(|value| i32::from(clamp_pct(value)))
        }
        VendorSnapshot::CommandCode(s) => {
            let worst = s.worst_pct();
            (s.five_hour.is_some() || s.weekly.is_some()).then_some(worst)
        }
        VendorSnapshot::Cline(s) => s.worst_pct(),
        VendorSnapshot::MuseCode(s) => [s.session.as_ref(), s.weekly.as_ref()]
            .into_iter()
            .flatten()
            .map(|window| window.utilization_pct)
            .max(),
        VendorSnapshot::Synthetic(s) => Some(s.weekly.utilization_pct),
        VendorSnapshot::OpenCodeGo(s) => [
            s.rolling
                .as_ref()
                .map(|window| window.percent.round() as i32),
            s.weekly
                .as_ref()
                .map(|window| window.percent.round() as i32),
            s.monthly
                .as_ref()
                .map(|window| window.percent.round() as i32),
        ]
        .into_iter()
        .flatten()
        .max(),
        VendorSnapshot::SuperGrok(s) => Some(s.weekly_pct),
        VendorSnapshot::Grokbot(s) => s.has_included_allowance.then_some(s.weekly_pct),
        VendorSnapshot::ModelStudio(s) => {
            [s.session.as_ref(), s.weekly.as_ref(), s.monthly.as_ref()]
                .into_iter()
                .flatten()
                .map(|w| w.utilization_pct)
                .max()
        }
        VendorSnapshot::Devin(s) => [
            s.daily.as_ref().map(|window| window.utilization_pct),
            s.weekly.as_ref().map(|window| window.utilization_pct),
        ]
        .into_iter()
        .flatten()
        .max(),
        VendorSnapshot::Droid(s) => crate::droid::vendor::headline_utilization(s),
        VendorSnapshot::Ollama(s) => [
            s.session.as_ref().map(|w| w.utilization_pct),
            s.weekly.as_ref().map(|w| w.utilization_pct),
            s.monthly.as_ref().map(|w| w.utilization_pct),
        ]
        .into_iter()
        .flatten()
        .max(),
        VendorSnapshot::Custom(s) => s.metrics.first().map(|metric| i32::from(metric.pct)),
        VendorSnapshot::Openrouter(_)
        | VendorSnapshot::OrcaRouter(_)
        | VendorSnapshot::Deepseek(_)
        | VendorSnapshot::Deepinfra(_)
        | VendorSnapshot::Kilo(_)
        | VendorSnapshot::Novita(_)
        | VendorSnapshot::Lyceum(_)
        | VendorSnapshot::Moonshot(_)
        | VendorSnapshot::Grok(_) => None,
    }
}

/// Build the section list for the currently-active vendor's snapshot.
pub fn sections_for(tab: &TabState, now: DateTime<Utc>, pace_tolerance: u32) -> Vec<Section> {
    sections_with_metadata_for(tab, now, pace_tolerance)
        .into_iter()
        .map(|projected| projected.section)
        .collect()
}

/// Rich projection used by machine-readable frontends. The TUI continues to
/// expose the source-compatible [`sections_for`] result above.
pub(crate) fn sections_with_metadata_for(
    tab: &TabState,
    now: DateTime<Utc>,
    pace_tolerance: u32,
) -> Vec<SectionProjection> {
    let mut sections = match tab {
        TabState::Loading => SectionBuilder::new(vec![
            Section::Spacer,
            Section::Text {
                label: "".into(),
                value: "  Loading…".into(),
            },
        ]),
        TabState::Error { message: e, plan } => {
            let mut rows = Vec::new();
            if let Some(plan) = plan {
                rows.push(Section::Title {
                    left: plan.clone(),
                    right: None,
                });
            }
            rows.extend([
                Section::Spacer,
                Section::Text {
                    label: "Error".into(),
                    value: e.clone(),
                },
                Section::Spacer,
                Section::Text {
                    label: "".into(),
                    value: "Press `r` to retry, `q` to quit.".into(),
                },
            ]);
            SectionBuilder::new(rows)
        }
        TabState::Ready(r) => {
            let snapshot = &r.snapshot;
            let last_error = &r.last_error;
            let prefs = r.display;
            let mut sections = match snapshot {
                VendorSnapshot::Anthropic(s) => anthropic_sections(s, now, pace_tolerance),
                VendorSnapshot::AnthropicApi(s) => anthropic_api_sections(s),
                VendorSnapshot::Openai(s) => openai_sections(s, now, pace_tolerance),
                VendorSnapshot::Copilot(s) => copilot_sections(s, now),
                VendorSnapshot::Zai(s) => zai_sections(s, now, pace_tolerance),
                VendorSnapshot::Openrouter(s) => openrouter_sections(s, prefs),
                VendorSnapshot::OrcaRouter(s) => orcarouter_sections(s, now),
                VendorSnapshot::Deepseek(s) => deepseek_sections(s, prefs),
                VendorSnapshot::Deepinfra(s) => deepinfra_sections(s, prefs),
                VendorSnapshot::Kimi(s) => kimi_sections(s, now, pace_tolerance),
                VendorSnapshot::Kilo(s) => kilo_sections(s, prefs),
                VendorSnapshot::Novita(s) => novita_sections(s, prefs),
                VendorSnapshot::Synthetic(s) => synthetic_sections(s, now, pace_tolerance),
                VendorSnapshot::Lyceum(s) => lyceum_sections(s),
                VendorSnapshot::Moonshot(s) => moonshot_sections(s, prefs),
                VendorSnapshot::Grok(s) => grok_sections(s, prefs),
                VendorSnapshot::SuperGrok(s) => supergrok_sections(s, now, pace_tolerance),
                VendorSnapshot::Grokbot(s) => grokbot_sections(s, now, pace_tolerance),
                VendorSnapshot::ModelStudio(s) => modelstudio_sections(s, now, pace_tolerance),
                VendorSnapshot::Devin(s) => devin_sections(s, now, pace_tolerance),
                VendorSnapshot::Droid(s) => droid_sections(s, now, pace_tolerance),
                VendorSnapshot::MuseCode(s) => muse_sections(s, now, pace_tolerance),
                VendorSnapshot::Antigravity(s) => antigravity_sections(s, now),
                VendorSnapshot::Cursor(s) => cursor_sections(s, now, pace_tolerance),
                VendorSnapshot::Minimax(s) => minimax_sections(s, now, pace_tolerance),
                VendorSnapshot::Kiro(s) => kiro_sections(s, now),
                VendorSnapshot::NousResearch(s) => nous_sections(s, now, prefs),
                VendorSnapshot::OpenCodeGo(s) => opencode_go_sections(s, now, pace_tolerance),
                VendorSnapshot::CommandCode(s) => commandcode_sections(s, now),
                VendorSnapshot::Ollama(s) => ollama_sections(s, now, pace_tolerance),
                VendorSnapshot::Custom(s) => custom_sections(s),
                VendorSnapshot::Cline(s) => cline_sections(s, now),
            };
            // Inject the (already-absolute) fetched-at instant into the title
            // row, right-aligned. Pre-snapshotted in app::refresh_one so it
            // doesn't drift between redraws.
            let updated = match r.fetched_at {
                Some(at) => format!("Updated {}", local_time_hms(at)),
                None => "Updated —".to_string(),
            };
            if let Some(SectionProjection {
                section: Section::Title { right, .. },
                ..
            }) = sections.0.first_mut()
            {
                *right = Some(updated);
            }
            // Error footer (when present) still lives in the body.
            if let Some((label, msg)) = warning_label(snapshot, last_error) {
                sections.push(Section::Spacer);
                sections.push(Section::Text { label, value: msg });
            }
            sections
        }
    };
    for projected in &mut sections.0 {
        sanitize_section(&mut projected.section);
    }
    sections.0
}

/// Sanitize at the final projection boundary so every vendor field, cached
/// diagnostic, and fetch error is inert before ratatui writes it to a terminal.
fn sanitize_section(section: &mut Section) {
    let clean = |value: &mut String| {
        *value = crate::display::sanitize_untrusted_field(value);
    };
    match section {
        Section::Title { left, right } => {
            clean(left);
            if let Some(right) = right {
                clean(right);
            }
        }
        Section::Metric {
            label,
            value_label,
            footnote,
            ..
        } => {
            clean(label);
            clean(value_label);
            clean(footnote);
        }
        Section::Text { label, value } => {
            clean(label);
            clean(value);
        }
        Section::Block { label, body } => {
            clean(label);
            for line in body {
                clean(line);
            }
        }
        Section::Spacer => {}
    }
}

/// Translate cache diagnostics at the presentation boundary. Cache files keep
/// their established `(u16, String)` form: only non-zero codes are HTTP, while
/// Kimi's stable schema marker identifies its code-zero schema warning.
fn warning_label(
    snapshot: &VendorSnapshot,
    last_error: &Option<(u16, String)>,
) -> Option<(String, String)> {
    let (code, message) = last_error.as_ref()?;
    if *code != 0 {
        return Some((format!("HTTP {code}"), message.clone()));
    }
    if message.is_empty() {
        return None;
    }
    let label = if matches!(snapshot, VendorSnapshot::Kimi(_))
        && matches!(
            crate::kimi::vendor::warning_kind(*code, message),
            crate::kimi::vendor::WarningKind::SchemaDrift
        ) {
        "Kimi API schema drift"
    } else {
        "Warning"
    };
    // The stable marker is already the schema-warning label. Keep the label
    // visible but do not repeat that sentinel as a redundant body value.
    let value = if label == message {
        String::new()
    } else {
        message.clone()
    };
    Some((label.into(), value))
}

fn anthropic_api_sections(s: &crate::usage::AnthropicApiSnapshot) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![Section::Title {
        left: "Anthropic API".into(),
        right: None,
    }]);
    // The label is the row's name to everything that reads it: the
    // notification dedupe key, the popover's stars and hidden rows, Omarchy's
    // pick of a balance row. The covered day changes daily, so it gets a row of
    // its own instead (#470).
    match (s.limit.filter(|l| *l > 0.0), s.pct()) {
        (Some(limit), Some(pct)) => {
            let p = pct.clamp(0, 100) as u16;
            v.push_metric(
                Section::Metric {
                    label: "Spend (mo)".into(),
                    pct: p,
                    severity: severity_for(pct),
                    value_label: format!("{} of ${:.0}", usd(s.spent), limit),
                    footnote: format!("{pct}% of monthly limit"),
                },
                None,
            );
        }
        _ => {
            v.push(Section::Text {
                label: "Spend (mo)".into(),
                value: usd(s.spent),
            });
        }
    }
    if let Some(day) = s.covered_through_day() {
        v.push(Section::Text {
            label: "Through".into(),
            value: day,
        });
    }
    v.push(Section::Spacer);
    v.push(Section::Text {
        label: "".into(),
        value: "Only completed daily buckets from the Admin usage API.".into(),
    });
    v.push(Section::Text {
        label: "".into(),
        value: "Prepaid credit balance is Console-only (no API).".into(),
    });
    v.push(Section::Text {
        label: "".into(),
        value: "Excludes Priority Tier cost (not reported by this API).".into(),
    });
    v
}

fn anthropic_sections(
    s: &crate::usage::AnthropicSnapshot,
    now: DateTime<Utc>,
    tol: u32,
) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![Section::Title {
        left: format!("Claude {}", s.plan),
        right: None,
    }]);

    push_window(&mut v, "Session (5h)", &s.session, now, tol, true);
    push_window(&mut v, "Weekly (7d)", &s.weekly, now, tol, true);
    if let Some(w) = &s.sonnet {
        push_window(&mut v, "Sonnet only", w, now, tol, false);
    }
    for sw in &s.scoped {
        push_window(
            &mut v,
            &format!("{} (7d)", sw.label),
            &sw.window,
            now,
            tol,
            false,
        );
    }
    if let Some(e) = &s.extra {
        v.push(Section::Spacer);
        let pct = e.percent().clamp(0, 100) as u16;
        // An uncapped plan (`monthly_limit: null`) has spend but no
        // denominator: show the amount alone rather than "of $0.00" or a
        // percentage nobody can vouch for (#30).
        let (value_label, mut footnote) = match e.fmt_limit() {
            Some(l) => (
                format!("{} of {}", e.fmt_spent(), l),
                format!("{pct}% of monthly limit consumed"),
            ),
            None => (e.fmt_spent(), "no monthly limit reported".to_string()),
        };
        if let Some(note) = e.status_note() {
            footnote.push_str(" · ");
            footnote.push_str(note);
        }
        v.push_metric(
            Section::Metric {
                label: "Extra usage".into(),
                pct,
                severity: severity_for(pct as i32),
                value_label,
                footnote,
            },
            None,
        );
    }
    if let Some(c) = &s.cloud_credits {
        v.push(Section::Spacer);
        // Same shape as Cursor's included credits: the remaining dollars are
        // the headline the tray, GNOME and KDE draw (a prepaid balance, not
        // a quota), the bar meters the used share, and the caption carries
        // the spend and the expiry. The parse gate guarantees a positive
        // limit, so `cursor_credit_meter` has no zero denominator to guard.
        // The meter clamps the remaining to the limit for its bar and its
        // spend; the headline is the balance the response reported, so a
        // remaining above the limit is shown as it is, not cut down to it.
        let (pct, _, mut footnote) =
            crate::format::cursor_credit_meter(c.remaining.0, c.limit.0, c.expires_at, now);
        let value = crate::usage::fmt_minor(c.remaining.0, 2, Some("USD"));
        if c.locked {
            // Appended to the caption the meter already built — it never
            // comes back empty, so the separator never dangles.
            footnote.push_str(" · locked");
        }
        // The second argument of push_metric stays None: this is an expiry,
        // not a reset instant the account can bank.
        v.push_metric_with_headline(
            Section::Metric {
                label: "Cloud session credits".into(),
                pct,
                severity: severity_for(i32::from(pct)),
                value_label: value,
                footnote,
            },
            None,
            MetricHeadline::Value,
        );
    }
    if let Some(u) = &s.usage_credits {
        v.push(Section::Spacer);
        let mut body = vec![format!(
            "balance: {}",
            crate::usage::fmt_minor(u.balance.0, u.decimal_places, u.currency.as_deref())
        )];
        // `None` means "not reported": the row is absent, never an invented
        // "off".
        if let Some(auto_reload) = u.auto_reload {
            body.push(if auto_reload {
                "auto-reload: on".into()
            } else {
                "auto-reload: off".into()
            });
        }
        v.push(Section::Block {
            label: "Usage credits".into(),
            body,
        });
    }
    push_reset_credits(&mut v, &s.reset_credits, now);
    v
}

fn openai_sections(
    s: &crate::usage::OpenAiSnapshot,
    now: DateTime<Utc>,
    tol: u32,
) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![Section::Title {
        left: s.plan.clone(),
        right: None,
    }]);
    if let Some(session) = &s.session {
        push_window(&mut v, "Codex 5h", session, now, tol, true);
    } else if s.weekly.is_some() {
        push_unreported_window(&mut v, "Codex 5h");
    }
    if let Some(weekly) = &s.weekly {
        push_window(&mut v, "Codex weekly", weekly, now, tol, true);
    } else if s.session.is_some() {
        push_unreported_window(&mut v, "Codex weekly");
    }
    if s.session.is_none() && s.weekly.is_none() {
        v.push(Section::Spacer);
        v.push(Section::Text {
            label: "".into(),
            value: "  no usage windows reported".into(),
        });
    }
    if let Some(cr) = &s.code_review {
        push_window(&mut v, "Code review", cr, now, tol, false);
    }
    // A named limit can be the binding one while the headline window reads
    // low, so it gets a real row rather than a footnote.
    for limit in &s.additional_limits {
        if let Some(w) = &limit.session {
            push_window(&mut v, &format!("{} (5h)", limit.name), w, now, tol, false);
        }
        if let Some(w) = &limit.weekly {
            push_window(&mut v, &format!("{} (7d)", limit.name), w, now, tol, false);
        }
    }
    // No percentage reflects a model the account cannot dispatch to, so say it
    // outright rather than leaving the user to infer it from healthy bars.
    if !s.unavailable_models.is_empty() {
        v.push(Section::Spacer);
        v.push(Section::Block {
            label: "Unavailable".into(),
            body: s
                .unavailable_models
                .iter()
                .map(|m| match m.available_at {
                    Some(at) => format!("{} — back {}", m.model, countdown::format(Some(at), now)),
                    None => format!("{} — at capacity", m.model),
                })
                .collect(),
        });
    }
    if let Some(c) = &s.credits {
        v.push(Section::Spacer);
        let body = vec![crate::openai::vendor::credit_balance_label(c)];
        v.push(Section::Block {
            label: "Credits".into(),
            body,
        });
    }
    if let Some(credits) = &s.reset_credits {
        push_reset_block(&mut v, credits, now);
    }
    v
}

fn push_unreported_window(sections: &mut SectionBuilder, label: &str) {
    sections.push(Section::Spacer);
    sections.push(Section::Text {
        label: label.into(),
        value: "Not reported".into(),
    });
}

fn copilot_sections(s: &crate::copilot::types::Snapshot, now: DateTime<Utc>) -> SectionBuilder {
    let mut sections = SectionBuilder::new(vec![Section::Title {
        left: format!("GitHub Copilot {}", s.plan),
        right: None,
    }]);
    for (label, quota) in s.quotas() {
        let pct = quota.used_pct();
        let detail = if quota.unlimited {
            "Unlimited".to_string()
        } else {
            quota
                .used_and_entitlement()
                .map(|(used, entitlement)| format!("{used} of {entitlement} used"))
                .unwrap_or_else(|| format!("{}% remaining", quota.percent_remaining))
        };
        sections.push(Section::Spacer);
        sections.push_metric(
            Section::Metric {
                label: label.to_string(),
                pct: pct.clamp(0, 100) as u16,
                severity: severity_for(pct),
                value_label: if quota.unlimited {
                    "Unlimited".to_string()
                } else {
                    format!("{pct}%")
                },
                footnote: detail,
            },
            s.reset_at,
        );
    }
    sections.push(Section::Spacer);
    sections.push(Section::Text {
        label: "Resets".into(),
        value: countdown::format(s.reset_at, now),
    });
    sections
}

fn zai_sections(s: &crate::usage::ZaiSnapshot, now: DateTime<Utc>, tol: u32) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![Section::Title {
        left: s.plan.clone(),
        right: None,
    }]);
    if let Some(w) = &s.session {
        push_window(&mut v, "Session (5h)", w, now, tol, true);
    }
    if let Some(w) = &s.weekly {
        push_window(&mut v, "Weekly", w, now, tol, true);
    }
    if let Some(w) = &s.mcp {
        push_window(&mut v, "MCP tools (monthly)", w, now, tol, true);
    }
    if s.session.is_none() && s.weekly.is_none() && s.mcp.is_none() {
        v.push(Section::Spacer);
        v.push(Section::Text {
            label: "".into(),
            value: "  no usage windows reported".into(),
        });
    }
    v
}

fn openrouter_sections(
    s: &crate::usage::OpenRouterSnapshot,
    prefs: DisplayPrefs,
) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![Section::Title {
        left: s.label.clone(),
        right: None,
    }]);
    let pct = s.consumed_pct().clamp(0, 100) as u16;
    // OpenRouter states its own denominator — credits purchased — so there is
    // no user tank to fall back to and `None` is passed literally rather than
    // `prefs.display_limit`. A free-tier-only account buys nothing, so
    // `total_credits` is 0, `denominator` is `None`, and the money stays on the
    // bar. Routing `prefs.display_limit` in here instead would let a tank take
    // over in exactly that case and name the headline `percent` — while `pct`
    // below still came from `consumed_pct()`, which is 0 without credits. The
    // bar would read "0%" for an account with money in it.
    let denominator = balance::denominator(Some(s.total_credits), None);
    v.push(Section::Spacer);
    v.push_metric_with_headline(
        Section::Metric {
            label: "Credit balance".into(),
            pct,
            // One severity policy for every frontend: this value is what the
            // Omarchy, GNOME and KDE panels colour their row with, so it has to
            // agree with the Waybar tooltip about what "in debt" looks like.
            severity: crate::openrouter::vendor::severity(s),
            value_label: usd(s.balance()),
            footnote: format!(
                "{} of {} used ({pct}%)",
                usd(s.total_usage),
                usd(s.total_credits)
            ),
        },
        None,
        balance::resolve_headline(prefs.headline, denominator),
    );
    v.push(Section::Spacer);
    v.push(Section::Block {
        label: "Usage by period".into(),
        body: vec![format!(
            "today ${:.2} · week ${:.2} · month ${:.2}",
            s.usage_daily, s.usage_weekly, s.usage_monthly
        )],
    });
    if let (Some(limit), Some(rem)) = (s.limit, s.limit_remaining) {
        v.push(Section::Spacer);
        v.push(Section::Block {
            label: "Per-key limit".into(),
            body: vec![format!("{} of {} remaining", usd(rem), usd(limit))],
        });
    }
    v.push(Section::Spacer);
    v.push(Section::Block {
        label: "Tier".into(),
        body: vec![if s.is_free_tier {
            "free tier".into()
        } else {
            "paid tier".into()
        }],
    });
    if !s.recent_models.is_empty() {
        v.push(Section::Spacer);
        v.push(Section::Block {
            label: "Recent models".into(),
            body: s.recent_models.clone(),
        });
    }
    v
}

/// OrcaRouter is a balance card: spend of a total credit limit, remaining,
/// and an optional key expiry. An unlimited key (the `100000000` sentinel)
/// has no denominator, so its panel is spend-only — the same treatment a
/// missing monthly limit gets, never a $100M wallet.
fn orcarouter_sections(s: &crate::usage::OrcaRouterSnapshot, now: DateTime<Utc>) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![
        Section::Title {
            left: "OrcaRouter".into(),
            right: None,
        },
        Section::Spacer,
    ]);
    match (s.limit_usd().filter(|l| *l > 0.0), s.consumed_pct()) {
        (Some(_), Some(pct)) => {
            let p = pct.clamp(0, 100) as u16;
            v.push_metric(
                Section::Metric {
                    label: "Credit".into(),
                    pct: p,
                    severity: crate::orcarouter::vendor::severity(s),
                    value_label: usd(s.remaining_usd().unwrap_or_default()),
                    footnote: format!(
                        "{} of {} used ({pct}%)",
                        usd(s.spent_usd()),
                        usd(s.limit_usd().unwrap_or_default())
                    ),
                },
                // The key's own expiry is the one absolute timestamp this
                // vendor reports; it travels with the row for frontends.
                s.access_until,
            );
        }
        _ => {
            v.push(Section::Text {
                label: "Spent".into(),
                value: usd(s.spent_usd()),
            });
            v.push(Section::Spacer);
            v.push(Section::Text {
                label: "".into(),
                value: "no credit limit on this key".into(),
            });
        }
    }
    if let Some(access_until) = s.access_until {
        v.push(Section::Spacer);
        v.push(Section::Text {
            label: "Key expires".into(),
            value: format!(
                "{} ({})",
                countdown::format(Some(access_until), now),
                crate::format::local_date_hm(access_until)
            ),
        });
    }
    v
}

/// Antigravity holds two independent pools (Gemini, Claude & GPT OSS), each
/// with a 5-hour and a weekly window. Grouped by window type so the two pools
/// sit side by side, matching the GNOME dropdown. A per-model pool (Pro's
/// "Gemini 4 Argon") joins them under the heading of its cadence, in the order
/// `antigravity::vendor::rows` sets.
fn antigravity_sections(
    s: &crate::usage::AntigravitySnapshot,
    now: DateTime<Utc>,
) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![Section::Title {
        left: s.plan.clone(),
        right: None,
    }]);
    for (heading, weekly) in [("Session", false), ("Weekly", true)] {
        let rows = crate::antigravity::vendor::rows(s, weekly);
        // A cadence no bucket reported gets no heading either — an empty
        // "Session" with nothing under it reads as a failed fetch.
        if rows.is_empty() {
            continue;
        }
        v.push(Section::Spacer);
        v.push(Section::Text {
            label: heading.into(),
            value: String::new(),
        });
        for row in rows {
            push_window(&mut v, row.label, row.window, now, 5, false);
            if row.model_pool {
                v.mark_model_pool();
            }
        }
    }
    // Figures read from the Cloud Code API fallback can lag what the local
    // product would show; say where they came from.
    if s.source == crate::usage::AntigravitySource::Remote {
        v.push(Section::Spacer);
        v.push(Section::Text {
            label: "Source".into(),
            value: "Google API".into(),
        });
    }
    v
}

/// A Cursor pool row. The billing cycle carries an exact window only when the
/// API stated both ends; when it did not, the row goes out with its reset time
/// and no window rather than a guessed month a frontend would pace as exact.
fn push_cursor_pool(v: &mut SectionBuilder, section: Section, s: &crate::usage::CursorSnapshot) {
    match s.cycle_window() {
        Some(window) => v.push_metric_in_window(section, s.reset_at, window),
        None => v.push_metric(section, s.reset_at),
    }
}

/// A pool's footnote, with how far through the billing cycle we are and the
/// point delta when the cycle's length is exact. Both pools share the cycle,
/// so only the delta differs between them. An unstated cycle adds nothing: no
/// estimate is better than one paced against a guessed month.
fn cursor_pool_footnote(
    base: String,
    pct: i32,
    s: &crate::usage::CursorSnapshot,
    now: DateTime<Utc>,
    tol: u32,
) -> String {
    let Some(window) = s.cycle_window() else {
        return base;
    };
    let pace = pacing::calc(pct, s.reset_at, now, window, tol);
    format!(
        "{base} · {}% elapsed · {}",
        pace.elapsed_pct, pace.point_label
    )
}

fn cursor_sections(
    s: &crate::usage::CursorSnapshot,
    now: DateTime<Utc>,
    tol: u32,
) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![Section::Title {
        left: format!("Cursor {}", s.plan),
        right: None,
    }]);
    if s.unlimited {
        v.push(Section::Spacer);
        v.push(Section::Text {
            label: "Plan".into(),
            value: "Unlimited — pools don't cap".into(),
        });
    } else {
        // Two included-usage pools, mirroring the dashboard's two bars.
        v.push(Section::Spacer);
        push_cursor_pool(
            &mut v,
            Section::Metric {
                label: "Cursor Models".into(),
                pct: s.auto_pct.clamp(0, 100) as u16,
                severity: severity_for(s.auto_pct),
                value_label: format!("{}%", s.auto_pct),
                footnote: cursor_pool_footnote("Auto + Composer".into(), s.auto_pct, s, now, tol),
            },
            s,
        );
        v.push(Section::Spacer);
        push_cursor_pool(
            &mut v,
            Section::Metric {
                label: "Other Models".into(),
                pct: s.api_pct.clamp(0, 100) as u16,
                severity: severity_for(s.api_pct),
                value_label: format!("{}%", s.api_pct),
                footnote: cursor_pool_footnote(
                    format!(
                        "Named / API models · on-demand {}",
                        if s.on_demand_enabled { "on" } else { "off" }
                    ),
                    s.api_pct,
                    s,
                    now,
                    tol,
                ),
            },
            s,
        );
        if let Some(used) = s.on_demand_used_cents {
            v.push(Section::Spacer);
            v.push_on_demand(used, s.on_demand_limit_cents);
        }
    }
    for grant in &s.credits {
        let name = cursor_credit_label(&crate::display::sanitize_untrusted_line(
            grant.display_name.trim(),
        ));
        let (pct, value, footnote) = cursor_credit_meter(
            grant.remaining_cents,
            grant.total_cents,
            grant.expires_at,
            now,
        );
        v.push(Section::Spacer);
        // Same shape as On-Demand: remaining dollars on the row, a bar for
        // how much of the grant is already spent, expiry in the caption.
        v.push_metric_with_headline(
            Section::Metric {
                label: name,
                pct,
                severity: severity_for(i32::from(pct)),
                value_label: value,
                footnote,
            },
            None,
            MetricHeadline::Value,
        );
    }
    v.push(Section::Spacer);
    v.push(Section::Text {
        label: "Resets".into(),
        value: countdown::format(s.reset_at, now),
    });
    v
}

fn nous_sections(
    s: &crate::nous::types::AccountSnapshot,
    now: DateTime<Utc>,
    prefs: DisplayPrefs,
) -> SectionBuilder {
    let mut sections = SectionBuilder::new(vec![Section::Title {
        left: "Nous Research".into(),
        right: None,
    }]);
    if let Some(value) = s.usage_percent() {
        let pct = clamp_pct(value);
        // `[nous] headline = "amount"` puts the credits still usable on the
        // bar, the way the prepaid-balance vendors do. The consumed percentage
        // keeps the meter, the severity and the detail line, so a spent
        // allocation still reads critical while the balance stays visible.
        let balance = s
            .total_usable_credits
            .or(s.purchased_credits_remaining)
            .or(s.credits_remaining);
        let headline = match (prefs.headline, balance) {
            (crate::balance::Headline::Amount, Some(_)) => MetricHeadline::Value,
            _ => MetricHeadline::Percent,
        };
        let (label, value_label, footnote) = match headline {
            MetricHeadline::Value => (
                "Credits remaining".into(),
                usd(balance.unwrap_or_default()),
                "usable now".into(),
            ),
            MetricHeadline::Percent => ("Usage".into(), format!("{pct}%"), "current period".into()),
        };
        sections.push_metric_with_headline(
            Section::Metric {
                label,
                pct,
                severity: severity_for(i32::from(pct)),
                value_label,
                footnote,
            },
            s.current_period_end,
            headline,
        );
    }
    sections.push(Section::Spacer);
    if let Some(remaining) = s.credits_remaining {
        sections.push(Section::Text {
            label: "Subscription credits".into(),
            value: format!("{} remaining", usd(remaining)),
        });
    }
    if let Some(purchased) = s.purchased_credits_remaining {
        sections.push(Section::Text {
            label: "Top-up credits".into(),
            value: format!("{} remaining", usd(purchased)),
        });
    }
    if let Some(total_usable) = s.total_usable_credits {
        sections.push(Section::Text {
            label: "Total usable credits".into(),
            value: usd(total_usable),
        });
    }
    if let Some(period_end) = s.current_period_end {
        sections.push(Section::Text {
            label: "Renews".into(),
            value: countdown::format(Some(period_end), now),
        });
    }
    sections
}

fn commandcode_sections(
    s: &crate::commandcode::types::Snapshot,
    now: DateTime<Utc>,
) -> SectionBuilder {
    let title = match s.plan.as_deref() {
        Some(plan) if !plan.is_empty() => format!("Command Code {plan}"),
        _ => "Command Code".to_string(),
    };
    let mut sections = SectionBuilder::new(vec![Section::Title {
        left: title,
        right: None,
    }]);
    for (label, window) in [
        ("Session (5h)", s.five_hour.as_ref()),
        ("Weekly", s.weekly.as_ref()),
        ("Monthly", s.monthly_window().as_ref()),
    ] {
        if let Some(window) = window {
            let pct = window.pct();
            sections.push_metric(
                Section::Metric {
                    label: label.into(),
                    pct: pct.clamp(0, 100) as u16,
                    severity: severity_for(pct),
                    value_label: format!("{pct}%"),
                    footnote: format!("{} of {}", usd(window.used), usd(window.cap)),
                },
                window.resets_at,
            );
            sections.push(Section::Text {
                label: "Resets".into(),
                value: countdown::format(window.resets_at, now),
            });
        }
    }
    if let Some(credits) = s.credits.as_ref() {
        sections.push(Section::Spacer);
        sections.push(Section::Text {
            label: "Credits".into(),
            value: usd(credits.remaining()),
        });
    }
    sections
}

/// Cline shows one bar per ClinePass limit. The reset row counts down to the
/// reset time Cline reports; a limit with no open window has none ("—").
fn cline_sections(s: &crate::cline::types::Snapshot, now: DateTime<Utc>) -> SectionBuilder {
    let mut sections = SectionBuilder::new(vec![Section::Title {
        left: s.plan.clone().unwrap_or_else(|| "Cline".into()),
        right: None,
    }]);
    let mut any = false;
    for (label, window) in [
        ("5 hours", s.five_hour.as_ref()),
        ("Weekly", s.seven_day.as_ref()),
        ("Monthly", s.thirty_day.as_ref()),
    ] {
        let Some(window) = window else {
            continue;
        };
        any = true;
        let pct = window.pct();
        sections.push_metric(
            Section::Metric {
                label: label.into(),
                pct: pct.clamp(0, 100) as u16,
                severity: severity_for(pct),
                value_label: format!("{pct}%"),
                footnote: String::new(),
            },
            window.resets_at(),
        );
        sections.push(Section::Text {
            label: "Resets in".into(),
            value: window
                .resets_at()
                .map(|at| countdown::format(Some(at), now))
                .unwrap_or_else(|| "—".into()),
        });
    }
    if !any {
        sections.push(Section::Text {
            label: "Quota".into(),
            value: "this plan has no ClinePass quota".into(),
        });
    }
    if let Some(period_end) = s.period_end {
        sections.push(Section::Spacer);
        sections.push(Section::Text {
            label: "Renews".into(),
            value: period_end.format("%Y-%m-%d").to_string(),
        });
    }
    sections
}

fn opencode_go_sections(
    s: &crate::opencode_go::types::Usage,
    now: DateTime<Utc>,
    tol: u32,
) -> SectionBuilder {
    use crate::opencode_go::vendor::{ROLLING_WINDOW, WEEKLY_WINDOW};

    let mut sections = SectionBuilder::new(vec![Section::Title {
        left: "OpenCode Go".into(),
        right: None,
    }]);
    let mut any = false;
    for (label, window, duration) in [
        ("Rolling (5h)", s.rolling.as_ref(), ROLLING_WINDOW),
        ("Weekly (7d)", s.weekly.as_ref(), WEEKLY_WINDOW),
    ] {
        let Some(window) = window else {
            continue;
        };
        any = true;
        let pct = i32::from(clamp_pct(window.percent));
        let projected = crate::usage::UsageWindow {
            utilization_pct: pct,
            resets_at: Some(window.resets_at),
            window_duration: duration,
        };
        push_window(&mut sections, label, &projected, now, tol, true);
    }
    // Monthly keeps its reset countdown but no pacing and no `window_secs`:
    // the cycle follows the subscription date (28/29/31-day months), so no
    // fixed denominator is exact. `push_metric` (not `push_metric_in_window`)
    // is what withholds the window from machine-readable frontends.
    if let Some(window) = s.monthly.as_ref() {
        any = true;
        let pct = clamp_pct(window.percent);
        sections.push_metric(
            Section::Metric {
                label: "Monthly".into(),
                pct,
                severity: severity_for(i32::from(pct)),
                value_label: format!("{pct}%"),
                footnote: format!(
                    "Resets in {}",
                    countdown::format(Some(window.resets_at), now)
                ),
            },
            Some(window.resets_at),
        );
    }
    if !any {
        sections.push(Section::Spacer);
        sections.push(Section::Text {
            label: "".into(),
            value: "  no usage windows reported".into(),
        });
    }
    sections
}

/// Kiro has a single credit pool, so the panel is a single metric bar plus
/// the reset row — the same shape as `anthropic_api_sections` but with a
/// real percentage (Kiro always reports both used and limit) instead of an
/// optional configured one.
fn kiro_sections(s: &crate::usage::KiroSnapshot, now: DateTime<Utc>) -> SectionBuilder {
    let pct = s.pct();
    let mut v = SectionBuilder::new(vec![
        Section::Title {
            left: format!("Kiro {}", s.plan),
            right: None,
        },
        Section::Spacer,
    ]);
    v.push_metric(
        Section::Metric {
            label: "Credits".into(),
            pct: pct.clamp(0, 100) as u16,
            severity: severity_for(pct),
            value_label: format!("{pct}%"),
            footnote: format!("{:.2} of {:.0}", s.used, s.limit),
        },
        s.reset_at,
    );
    v.push(Section::Spacer);
    v.push(Section::Text {
        label: "Resets".into(),
        value: countdown::format(s.reset_at, now),
    });
    v
}

/// MiniMax groups quota by model bucket, so the panel is laid out by window
/// (Session, Weekly) with one row per pool — the same shape as Antigravity's
/// two-group panel. Pacing is shown: both windows report a real duration, so
/// the marker is meaningful.
fn minimax_sections(
    s: &crate::usage::MinimaxSnapshot,
    now: DateTime<Utc>,
    tol: u32,
) -> SectionBuilder {
    use crate::minimax::vendor::{POOL_GENERAL, POOL_VIDEO};

    let mut v = SectionBuilder::new(vec![Section::Title {
        left: s.plan.clone(),
        right: None,
    }]);
    for (heading, general, video) in [
        ("Session", &s.session, s.video_session.as_ref()),
        ("Weekly", &s.weekly, s.video_weekly.as_ref()),
    ] {
        v.push(Section::Spacer);
        v.push(Section::Text {
            label: heading.into(),
            value: String::new(),
        });
        push_window(&mut v, POOL_GENERAL, general, now, tol, true);
        if let Some(w) = video {
            push_window(&mut v, POOL_VIDEO, w, now, tol, true);
        }
    }
    v
}

fn kilo_sections(s: &crate::usage::KiloSnapshot, prefs: DisplayPrefs) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![
        Section::Title {
            left: s.label.clone(),
            right: None,
        },
        Section::Spacer,
    ]);
    push_balance_headline(
        &mut v,
        "Balance",
        s.balance,
        "USD",
        crate::kilo::vendor::severity(s),
        None,
        prefs,
    );
    v
}

fn novita_sections(s: &crate::usage::NovitaSnapshot, prefs: DisplayPrefs) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![
        Section::Title {
            left: "Novita".into(),
            right: None,
        },
        Section::Spacer,
    ]);
    // `credit_limit` is a credit line Novita extends, not a cap on spend, so it
    // is not a denominator — it stays in the breakdown.
    push_balance_headline(
        &mut v,
        "Balance",
        s.available,
        "USD",
        crate::novita::vendor::severity(s),
        None,
        prefs,
    );
    v.push(Section::Block {
        label: "Breakdown".into(),
        body: vec![format!(
            "top-up ${:.2} · credit limit ${:.2}",
            s.cash, s.credit_limit
        )],
    });
    if s.outstanding > 0.0 {
        v.push(Section::Spacer);
        v.push(Section::Block {
            label: "Owed".into(),
            body: vec![usd(s.outstanding)],
        });
    }
    v
}

fn synthetic_sections(
    s: &crate::usage::SyntheticSnapshot,
    now: DateTime<Utc>,
    tolerance: u32,
) -> SectionBuilder {
    let mut sections = SectionBuilder::new(vec![Section::Title {
        left: s.plan.clone().unwrap_or_else(|| "Synthetic".to_string()),
        right: None,
    }]);
    push_window(
        &mut sections,
        "Weekly credits",
        &s.weekly,
        now,
        tolerance,
        false,
    );
    // The weekly budget refills by this much at the countdown moment rather
    // than resetting wholesale, so the countdown line carries the amount.
    let regen_amount = match &s.credits {
        Some(credits) if credits.next_regen > 0.0 => {
            Some(format!("{} credits", credits_number(credits.next_regen)))
        }
        _ => s
            .next_regen_percent
            .filter(|p| *p > 0.0)
            .map(|p| format!("{}%", credits_number(p))),
    };
    if let Some(amount) = regen_amount {
        sections.regen_last_metric(amount);
    }
    // Keep the API's decimal precision for printed figures ("70.5%"); the
    // meter itself stays on the rounded integer.
    sections.precise_last_metric(s.utilization_precise);
    if let Some(credits) = &s.credits {
        sections.push(Section::Text {
            label: "Credits".into(),
            value: format!(
                "{} / {}",
                credits_number(credits.used),
                credits_number(credits.max)
            ),
        });
    }
    sections
}

fn lyceum_sections(s: &crate::usage::LyceumSnapshot) -> SectionBuilder {
    SectionBuilder::new(vec![
        Section::Title {
            left: crate::vendor::VendorId::Lyceum.display_name().into(),
            right: None,
        },
        Section::Spacer,
        Section::Text {
            label: "Available balance".into(),
            value: usd(s.available_credits),
        },
        Section::Text {
            label: "Amount used".into(),
            value: usd(s.used_credits),
        },
    ])
}

fn moonshot_sections(s: &crate::usage::MoonshotSnapshot, prefs: DisplayPrefs) -> SectionBuilder {
    let cur = &s.currency;
    let fmt = |v: f64| money(v, cur);
    let mut v = SectionBuilder::new(vec![
        Section::Title {
            left: "Kimi (Moonshot)".into(),
            right: None,
        },
        Section::Spacer,
    ]);
    push_balance_headline(
        &mut v,
        "Balance",
        s.available,
        cur,
        crate::moonshot::vendor::severity(s),
        None,
        prefs,
    );
    v.push(Section::Block {
        label: "Breakdown".into(),
        body: vec![format!("cash {} · voucher {}", fmt(s.cash), fmt(s.voucher))],
    });
    v
}

fn grok_sections(s: &crate::usage::GrokSnapshot, prefs: DisplayPrefs) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![
        Section::Title {
            left: "Grok (xAI)".into(),
            right: None,
        },
        Section::Spacer,
    ]);
    push_balance_headline(
        &mut v,
        "Prepaid balance",
        s.balance,
        "USD",
        crate::grok::vendor::severity(s),
        None,
        prefs,
    );
    v
}

/// A user-declared `[[custom]]` provider: the plan (if the response carried
/// one), one gauge per configured metric, then the free-form text rows. The
/// vendor never states a reset countdown of its own; a metric's `resets_at`
/// and optional exact `window_secs` ride along as reset metadata so every
/// frontend paces it exactly like a built-in.
fn custom_sections(s: &crate::custom::types::CustomSnapshot) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![
        Section::Title {
            left: s.plan.clone().unwrap_or_default(),
            right: None,
        },
        Section::Spacer,
    ]);
    for metric in &s.metrics {
        let pct = metric.pct.min(100);
        let section = Section::Metric {
            label: metric.label.clone(),
            pct,
            severity: severity_for(i32::from(pct)),
            value_label: format!("{pct}%"),
            footnote: metric.footnote.clone(),
        };
        match metric.window_secs {
            Some(secs) => v.push_metric_in_window(
                section,
                metric.resets_at,
                chrono::Duration::seconds(i64::try_from(secs).unwrap_or(i64::MAX)),
            ),
            None => v.push_metric(section, metric.resets_at),
        }
    }
    if !s.texts.is_empty() {
        v.push(Section::Spacer);
        for text in &s.texts {
            v.push(Section::Text {
                label: text.label.clone(),
                value: text.value.clone(),
            });
        }
    }
    v
}

fn supergrok_sections(
    s: &crate::usage::SuperGrokSnapshot,
    now: DateTime<Utc>,
    tol: u32,
) -> SectionBuilder {
    let pct = s.weekly_pct;
    let mut v = SectionBuilder::new(vec![
        Section::Title {
            left: s.plan.clone(),
            right: None,
        },
        Section::Spacer,
    ]);
    // The reset line `push_window` and Grok Bot print under their meters. Pace
    // needs the exact window length, which only the weekly period has (see
    // below).
    let footnote = match (s.period, s.reset_at) {
        (crate::usage::SuperGrokPeriod::Weekly, Some(_)) => {
            let pace = pacing::calc(pct, s.reset_at, now, chrono::Duration::days(7), tol);
            format!(
                "Resets in {} · {}% elapsed · {}",
                countdown::format(s.reset_at, now),
                pace.elapsed_pct,
                pace.point_label
            )
        }
        (_, Some(_)) => format!("Resets in {}", countdown::format(s.reset_at, now)),
        (_, None) => String::new(),
    };
    let metric = Section::Metric {
        label: format!("{} usage", s.period.label()),
        pct: pct.clamp(0, 100) as u16,
        severity: severity_for(pct),
        value_label: format!("{pct}%"),
        footnote,
    };
    // Only the weekly period has an exact length; a month varies and an
    // unknown period says nothing, so neither can be paced.
    if s.period == crate::usage::SuperGrokPeriod::Weekly {
        v.push_metric_in_window(metric, s.reset_at, chrono::Duration::days(7));
    } else {
        v.push_metric(metric, s.reset_at);
    }
    for product in &s.products {
        // Product slices share the overall pool. They must not carry the
        // window reset or a severity colour — only the overall usage meter
        // is the binding constraint. The "Breakdown" group lets frontends
        // draw them compactly under a heading instead of as peers of it.
        v.push_metric_in_group(
            Section::Metric {
                label: product.label.clone(),
                pct: product.percent.clamp(0, 100) as u16,
                severity: PaceSeverity::Low,
                value_label: format!("{}%", product.percent),
                footnote: String::new(),
            },
            "Breakdown",
        );
    }
    // A $0.00 prepaid row reads as "you have no money" when the field merely
    // says no credit was purchased on top of the subscription — and a unified
    // billing account keeps its real dollars in the Management API wallet
    // (`[grok]`), not here. Show the row only when there is credit to show.
    if let Some(extra) = s.additional_usage_text() {
        v.push(Section::Spacer);
        v.push(Section::Text {
            label: "Additional usage".into(),
            value: extra,
        });
    }
    if let Some(bal) = s.prepaid_balance.filter(|bal| *bal > 0.0) {
        v.push(Section::Spacer);
        v.push(Section::Text {
            label: "Prepaid API".into(),
            value: usd(bal),
        });
    }
    push_reset_credits(&mut v, &s.reset_credits, now);
    v
}

fn ollama_sections(
    s: &crate::usage::OllamaSnapshot,
    now: DateTime<Utc>,
    pace_tolerance: u32,
) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![Section::Title {
        left: format!("Ollama Cloud {}", s.plan),
        right: None,
    }]);
    if let Some(w) = &s.session {
        push_window(&mut v, "Session (5h)", w, now, pace_tolerance, true);
    }
    if let Some(w) = &s.weekly {
        push_window(&mut v, "Weekly", w, now, pace_tolerance, true);
    }
    if let Some(w) = &s.monthly {
        push_window(&mut v, "Monthly", w, now, pace_tolerance, true);
    }
    push_top_models(&mut v, &s.session_models, "Top models (5h)");
    push_top_models(&mut v, &s.weekly_models, "Top models (weekly)");
    push_top_models(&mut v, &s.monthly_models, "Top models (monthly)");
    if let Some(credits) = &s.credits {
        let mut body = vec![format!(
            "{} remaining of {}",
            credits.balance, credits.allowance
        )];
        if let Some(purchased) = &credits.purchased {
            body.push(format!("Purchased credits: {purchased}"));
        }
        v.push(Section::Block {
            label: "Credits".into(),
            body,
        });
    }
    if let Some(cost) = &s.activity_cost {
        v.push(Section::Spacer);
        v.push(Section::Block {
            label: "Activity".into(),
            body: vec![format!(
                "{} · {}",
                usd_str(cost),
                s.activity_period.as_deref().unwrap_or("last 4 weeks")
            )],
        });
    }
    v
}

fn push_top_models(
    sections: &mut SectionBuilder,
    models: &[crate::usage::OllamaModelUsage],
    label: &str,
) {
    if models.is_empty() {
        return;
    }
    let mut sorted: Vec<&crate::usage::OllamaModelUsage> = models.iter().collect();
    sorted.sort_by_key(|m| std::cmp::Reverse(m.request_count));
    let body: Vec<String> = sorted
        .into_iter()
        .take(5)
        .map(|m| format!("{}: {} requests", m.name, m.request_count))
        .collect();
    sections.push(Section::Spacer);
    sections.push(Section::Block {
        label: label.into(),
        body,
    });
}

fn usd_str(cost: &str) -> String {
    cost.parse::<f64>()
        .map(usd)
        .unwrap_or_else(|_| cost.to_string())
}

/// Whole numbers print bare; fractions keep two decimals (Synthetic credits).
fn credits_number(value: f64) -> String {
    if value.fract() == 0.0 {
        format!("{value:.0}")
    } else {
        format!("{value:.2}")
    }
}

fn push_reset_credits(
    v: &mut SectionBuilder,
    credits: &crate::usage::ResetCredits,
    now: DateTime<Utc>,
) {
    if credits.is_empty() {
        return;
    }
    push_reset_block(v, credits, now);
}

/// The "Reset credits" block itself. Codex calls it directly whenever its
/// usage response states a count, so a zero reads "None available" instead
/// of dropping the block.
fn push_reset_block(
    v: &mut SectionBuilder,
    credits: &crate::usage::ResetCredits,
    now: DateTime<Utc>,
) {
    v.push(Section::Spacer);
    v.push(Section::Block {
        label: "Reset credits".into(),
        body: reset_credit_lines(credits, now),
    });
}

fn deepseek_sections(s: &crate::usage::DeepseekSnapshot, prefs: DisplayPrefs) -> SectionBuilder {
    let currency = &s.currency;
    let fmt = |v: f64| money(v, currency);
    let avail = if s.is_available {
        "available"
    } else {
        "unavailable"
    };
    let mut v = SectionBuilder::new(vec![Section::Title {
        left: "DeepSeek".into(),
        right: None,
    }]);
    v.push(Section::Spacer);
    // `/user/balance` reports money remaining and no denominator at all, so
    // `api_limit` is unconditionally `None` here.
    push_balance_headline(
        &mut v,
        "Balance",
        s.balance,
        currency,
        crate::deepseek::vendor::severity(s),
        None,
        prefs,
    );
    v.push(Section::Block {
        label: "Breakdown".into(),
        body: vec![format!(
            "granted {} · topped-up {}",
            fmt(s.granted),
            fmt(s.topped_up)
        )],
    });
    v.push(Section::Spacer);
    v.push(Section::Block {
        label: "API".into(),
        body: vec![avail.into()],
    });
    v
}

fn deepinfra_sections(
    snapshot: &crate::usage::DeepInfraSnapshot,
    prefs: DisplayPrefs,
) -> SectionBuilder {
    let mut sections = SectionBuilder::new(vec![Section::Title {
        left: "DeepInfra".into(),
        right: None,
    }]);
    sections.push(Section::Spacer);
    push_balance_headline(
        &mut sections,
        "Balance",
        snapshot.balance,
        "USD",
        crate::deepinfra::vendor::severity(snapshot),
        None,
        prefs,
    );
    sections.push(Section::Spacer);
    match snapshot.monthly_limit {
        Some(limit) if limit > 0.0 => {
            let percent = snapshot.monthly_consumed_pct().unwrap_or_default();
            // A vendor-defined billing period with no reset instant — exactly
            // the case push_metric exists for (a bare push would trip the
            // reset-metadata assert the moment a limit is set).
            sections.push_metric(
                Section::Metric {
                    label: "Monthly usage".into(),
                    pct: percent.clamp(0, 100) as u16,
                    severity: severity_for(percent),
                    value_label: format!("{} / {}", usd(snapshot.monthly_spend), usd(limit)),
                    footnote: format!("{percent}% used in {}", snapshot.period),
                },
                None,
            );
        }
        Some(limit) => sections.push(Section::Text {
            label: "Monthly usage".into(),
            value: format!("{} / {}", usd(snapshot.monthly_spend), usd(limit)),
        }),
        None => sections.push(Section::Text {
            label: "Monthly usage".into(),
            value: format!("{} / no limit", usd(snapshot.monthly_spend)),
        }),
    }
    sections.push(Section::Text {
        label: "Period".into(),
        value: snapshot.period.clone(),
    });
    sections
}

/// Kimi reports each quota as used/limit against a limit of 100, so the pair
/// is the percentage in longhand. Projecting both onto a `UsageWindow` lets
/// the shared `push_window` draw them, which is what keeps the row identical
/// to every other vendor's instead of a hand-rolled near-copy.
fn kimi_sections(s: &crate::usage::KimiSnapshot, now: DateTime<Utc>, tol: u32) -> SectionBuilder {
    use crate::kimi::vendor::{ROLLING_WINDOW, WEEKLY_WINDOW};

    let plan = s.plan.as_deref().unwrap_or("Kimi");
    let mut v = SectionBuilder::new(vec![Section::Title {
        left: plan.into(),
        right: None,
    }]);
    let window = |pct, resets_at, window_duration| crate::usage::UsageWindow {
        utilization_pct: pct,
        resets_at,
        window_duration,
    };

    if s.window_limit > 0 {
        let w = window(s.window_pct(), s.window_reset_at, ROLLING_WINDOW);
        push_window(&mut v, "Rolling window (5h)", &w, now, tol, false);
    }
    if s.has_weekly {
        let w = window(s.weekly_pct(), s.weekly_reset_at, WEEKLY_WINDOW);
        push_window(&mut v, "Weekly quota", &w, now, tol, false);
    }
    if let Some(monthly_pct) = s.monthly_pct {
        // The monthly pool resets from the order date, so there is no fixed
        // window length: the metric carries its reset but no window metadata,
        // and nothing paces it.
        v.push(Section::Spacer);
        v.push_metric(
            Section::Metric {
                label: "Monthly".into(),
                pct: monthly_pct.clamp(0, 100) as u16,
                severity: severity_for(monthly_pct),
                value_label: format!("{monthly_pct}%"),
                footnote: format!("Resets in {}", countdown::format(s.monthly_reset_at, now)),
            },
            s.monthly_reset_at,
        );
    }

    v
}

/// Grok Bot: one weekly meter for the included pool — plus the honest
/// window length when both period instants were reported, so the report
/// carries exact `window_secs` — or the no-included-allowance state, which is
/// a text row, never a 0% meter.
fn grokbot_sections(
    s: &crate::usage::GrokbotSnapshot,
    now: DateTime<Utc>,
    tol: u32,
) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![Section::Title {
        left: s.display_plan().to_string(),
        right: None,
    }]);
    v.push(Section::Spacer);
    if !s.has_included_allowance {
        v.push(Section::Text {
            label: "Included usage".into(),
            value: "no included allowance on this account".into(),
        });
        return v;
    }
    let footnote = match s.window {
        Some(window) if window.num_seconds() > 0 && s.reset_at.is_some() => {
            let pace = pacing::calc(s.weekly_pct, s.reset_at, now, window, tol);
            format!(
                "Resets in {} · {}% elapsed · {}",
                countdown::format(s.reset_at, now),
                pace.elapsed_pct,
                pace.point_label
            )
        }
        _ => format!("Resets in {}", countdown::format(s.reset_at, now)),
    };
    let metric = Section::Metric {
        label: "Weekly".into(),
        pct: s.weekly_pct.clamp(0, 100) as u16,
        severity: severity_for(s.weekly_pct),
        value_label: format!("{}%", s.weekly_pct),
        footnote,
    };
    match s.window {
        Some(window) => v.push_metric_in_window(metric, s.reset_at, window),
        None => v.push_metric(metric, s.reset_at),
    }
    // At 100% with the account still serving, on-demand may be picking up the
    // rest — a footnote row, not its own meter.
    if let Some(note) = s.on_demand_note() {
        v.push(Section::Spacer);
        v.push(Section::Text {
            label: "On-demand".into(),
            value: note.into(),
        });
    }
    v
}

/// Model Studio Token Plan: a 5h, a weekly and a monthly window, each of
/// which the console account may not report. Present windows ride the shared
/// `push_window`; an absent one is no-data (possibly unlimited), drawn as a
/// text row — never a 0% meter. The monthly window rides `push_metric`,
/// without a declared window length: the cycle is plan-dependent (28–31
/// days), so a frontend must not pace against a guessed denominator.
fn modelstudio_sections(
    s: &crate::usage::ModelStudioSnapshot,
    now: DateTime<Utc>,
    tol: u32,
) -> SectionBuilder {
    let mut v = SectionBuilder::new(vec![Section::Title {
        left: crate::modelstudio::vendor::PLAN_LABEL.into(),
        right: None,
    }]);
    v.push(Section::Spacer);
    if let Some(session) = s.session.as_ref() {
        push_window(&mut v, "Token Plan 5h", session, now, tol, true);
    }
    if let Some(weekly) = s.weekly.as_ref() {
        push_window(&mut v, "Token Plan 7d", weekly, now, tol, true);
    }
    if let Some(monthly) = s.monthly.as_ref() {
        if s.session.is_some() || s.weekly.is_some() {
            v.push(Section::Spacer);
        }
        let reset_text = countdown::format(monthly.resets_at, now);
        v.push_metric(
            Section::Metric {
                label: "Token Plan 30d".into(),
                pct: monthly.utilization_pct.clamp(0, 100) as u16,
                severity: severity_for(monthly.utilization_pct),
                value_label: format!("{}%", monthly.utilization_pct),
                footnote: format!("Resets in {reset_text}"),
            },
            monthly.resets_at,
        );
    }
    if s.session.is_none() && s.weekly.is_none() && s.monthly.is_none() {
        v.push(Section::Text {
            label: "Usage".into(),
            value: "no usage windows reported".into(),
        });
    }
    v
}

fn muse_sections(
    s: &crate::usage::MuseSnapshot,
    now: DateTime<Utc>,
    tolerance: u32,
) -> SectionBuilder {
    let mut sections = SectionBuilder::new(vec![Section::Title {
        left: s.plan.clone(),
        right: None,
    }]);
    if let Some(window) = &s.session {
        push_window(&mut sections, "Session quota", window, now, tolerance, true);
    }
    if let Some(window) = &s.weekly {
        push_window(&mut sections, "Weekly quota", window, now, tolerance, true);
    }
    sections
}

fn devin_sections(
    snapshot: &crate::usage::DevinSnapshot,
    now: DateTime<Utc>,
    tol: u32,
) -> SectionBuilder {
    let mut sections = SectionBuilder::new(vec![Section::Title {
        left: crate::vendor::VendorId::Devin.display_name().into(),
        right: None,
    }]);
    if let Some(daily) = snapshot.daily.as_ref() {
        push_window(&mut sections, "Daily quota", daily, now, tol, true);
    }
    if let Some(weekly) = snapshot.weekly.as_ref() {
        push_window(&mut sections, "Weekly quota", weekly, now, tol, true);
    }
    if snapshot.daily.is_none()
        && snapshot.weekly.is_none()
        && snapshot.overage_balance_micros.is_none()
    {
        sections.push(Section::Text {
            label: "Usage".into(),
            value: "no quota fields reported".into(),
        });
    }
    if let Some(balance) = snapshot.overage_balance_micros {
        sections.push(Section::Spacer);
        sections.push(Section::Text {
            label: "Overage balance".into(),
            value: crate::usage::fmt_minor(balance, crate::devin::vendor::BALANCE_DECIMALS, None),
        });
        sections.push(Section::Text {
            label: "Balance note".into(),
            value: "Microunit-to-USD display matches the tested account; currency contract is unverified.".into(),
        });
    }
    sections
}

fn droid_sections(
    snapshot: &crate::usage::DroidSnapshot,
    now: DateTime<Utc>,
    tol: u32,
) -> SectionBuilder {
    let mut sections = SectionBuilder::new(vec![Section::Title {
        left: crate::vendor::VendorId::Droid.display_name().into(),
        right: None,
    }]);
    let standard = [
        ("5-hour quota", snapshot.session.as_ref()),
        ("Weekly quota", snapshot.weekly.as_ref()),
        ("Monthly quota", snapshot.monthly.as_ref()),
    ];
    if standard.iter().any(|(_, w)| w.is_some()) {
        sections.push(Section::Spacer);
        sections.push(Section::Text {
            label: "Standard".into(),
            value: String::new(),
        });
        for (label, window) in standard {
            if let Some(window) = window {
                push_droid_window(&mut sections, label, window, now, tol);
            }
        }
    }
    let core = [
        ("5-hour quota", snapshot.core_session.as_ref()),
        ("Weekly quota", snapshot.core_weekly.as_ref()),
        ("Monthly quota", snapshot.core_monthly.as_ref()),
    ];
    let core_idle = core
        .iter()
        .flat_map(|(_, w)| w)
        .all(|w| w.resets_at.is_none() && w.utilization_pct == 0);
    if core.iter().any(|(_, w)| w.is_some()) && core_idle {
        // Three empty bars say nothing a single line does not: an account
        // that never touched Droid Core reads as one row.
        sections.push(Section::Spacer);
        sections.push(Section::Text {
            label: "Droid Core".into(),
            value: "not used yet".into(),
        });
    } else if core.iter().any(|(_, w)| w.is_some()) {
        sections.push(Section::Spacer);
        sections.push(Section::Text {
            label: "Droid Core".into(),
            value: String::new(),
        });
        for (label, window) in core {
            if let Some(window) = window {
                push_droid_window(&mut sections, label, window, now, tol);
            }
        }
    }
    if standard.iter().all(|(_, w)| w.is_none())
        && core.iter().all(|(_, w)| w.is_none())
        && snapshot.extra_balance_cents.is_none()
    {
        sections.push(Section::Text {
            label: "Usage".into(),
            value: "no quota fields reported".into(),
        });
    }
    if let Some(balance) = snapshot.extra_balance_cents {
        sections.push(Section::Spacer);
        sections.push(Section::Text {
            label: "Extra usage balance".into(),
            value: crate::droid::vendor::extra_balance(balance),
        });
    }
    sections
}

/// Droid reports `windowEnd: null` for a window the account has not started:
/// there is no reset and no elapsed time to pace against, so the footnote
/// says so instead of "Resets in — · 0% elapsed · on track".
fn push_droid_window(
    sections: &mut SectionBuilder,
    label: &str,
    w: &crate::usage::UsageWindow,
    now: DateTime<Utc>,
    tol: u32,
) {
    if w.resets_at.is_some() {
        return push_window(sections, label, w, now, tol, true);
    }
    let pct = w.utilization_pct.clamp(0, 100) as u16;
    sections.push(Section::Spacer);
    sections.push_metric_in_window(
        Section::Metric {
            label: label.into(),
            pct,
            severity: severity_for(pct as i32),
            value_label: format!("{pct}%"),
            footnote: "Not started".into(),
        },
        None,
        w.window_duration,
    );
}

/// One decimal when it matters ("70.5%"), none when it does not ("70%").
fn format_precise_pct(pct: f64) -> String {
    let rounded = (pct * 10.0).round() / 10.0;
    if rounded == rounded.trunc() {
        format!("{rounded:.0}%")
    } else {
        format!("{rounded}%")
    }
}

fn push_window(
    sections: &mut SectionBuilder,
    label: &str,
    w: &crate::usage::UsageWindow,
    now: DateTime<Utc>,
    tol: u32,
    show_pacing: bool,
) {
    let pct = w.utilization_pct.clamp(0, 100) as u16;
    let reset_text = countdown::format(w.resets_at, now);
    let footnote = if show_pacing {
        let p = pacing::calc(w.utilization_pct, w.resets_at, now, w.window_duration, tol);
        format!(
            "Resets in {} · {}% elapsed · {}",
            reset_text, p.elapsed_pct, p.point_label
        )
    } else {
        format!("Resets in {}", reset_text)
    };
    sections.push(Section::Spacer);
    sections.push_metric_in_window(
        Section::Metric {
            label: label.into(),
            pct,
            severity: severity_for(pct as i32),
            value_label: format!("{pct}%"),
            footnote,
        },
        w.resets_at,
        w.window_duration,
    );
}

/// Render the given sections into `area`. Lays them out vertically; metric
/// rows take 2 lines (label+gauge / footnote), text and spacer rows take 1.
///
/// The trailing "Updated …" footer is detected (the last `Text` section)
/// and pinned to the bottom of the area, with the slack absorbed *between*
/// content and footer. This way shorter vendor panels (OpenRouter, Z.AI)
/// don't leave a giant gap below the footer.
pub fn render(f: &mut Frame, area: Rect, theme: &Theme, sections: &[Section]) {
    if sections.is_empty() {
        return;
    }
    let bubble = bubble_theme(theme);
    // Heuristic: if the last section is a Text starting with "  Updated",
    // pin it to the bottom. Otherwise just lay everything out top-down.
    let pin_last =
        matches!(sections.last(), Some(Section::Text { value, .. }) if value.contains("Updated"));

    let body_end = if pin_last {
        sections.len() - 1
    } else {
        sections.len()
    };
    let mut constraints: Vec<Constraint> =
        sections[..body_end].iter().map(section_height).collect();

    if pin_last {
        constraints.push(Constraint::Min(0)); // slack between body and footer
        constraints.push(section_height(sections.last().unwrap()));
    } else {
        constraints.push(Constraint::Min(0));
    }

    let chunks = Layout::default()
        .direction(ratatui::layout::Direction::Vertical)
        .constraints(constraints)
        .split(area);

    for (i, s) in sections[..body_end].iter().enumerate() {
        render_section(f, chunks[i], theme, &bubble, s);
    }
    if pin_last {
        render_section(
            f,
            chunks[chunks.len() - 1],
            theme,
            &bubble,
            sections.last().unwrap(),
        );
    }
}

fn section_height(s: &Section) -> Constraint {
    match s {
        Section::Title { .. } => Constraint::Length(2),
        Section::Metric { .. } => Constraint::Length(3),
        Section::Text { .. } => Constraint::Length(1),
        Section::Block { body, .. } => Constraint::Length(1 + body.len() as u16),
        Section::Spacer => Constraint::Length(1),
    }
}

fn render_section(f: &mut Frame, area: Rect, theme: &Theme, bubble: &BubbleTheme, s: &Section) {
    match s {
        Section::Title { left, right } => {
            // Left: bold accent-colored plan/vendor label. Right: dim-styled
            // "Updated HH:MM:SS" pinned to the right edge of the title row.
            let left_line = Line::from(Span::styled(
                format!("  {} {left}", bubble.symbols.selected),
                bubble.title,
            ));
            f.render_widget(Paragraph::new(left_line), area);
            if let Some(rt) = right {
                let right_line =
                    Line::from(Span::styled(format!("{rt}  "), bubble.muted)).right_aligned();
                f.render_widget(Paragraph::new(right_line), area);
            }
        }
        Section::Metric {
            label,
            pct,
            severity,
            value_label,
            footnote,
        } => render_metric(
            f,
            area,
            theme,
            bubble,
            label,
            *pct,
            *severity,
            value_label,
            footnote,
        ),
        Section::Text { label, value } => {
            if label.is_empty() && value.contains("Loading") {
                render_loading(f, area, bubble);
                return;
            }
            if label == "Error" {
                let line = Line::from(vec![
                    bubble.error(format!("  {} ", bubble.symbols.cross)),
                    Span::styled(value.clone(), bubble.error.add_modifier(Modifier::BOLD)),
                ]);
                f.render_widget(Paragraph::new(line), area);
                return;
            }
            let mut spans = Vec::new();
            if !label.is_empty() {
                spans.push(Span::styled(
                    format!("  {label}  "),
                    bubble.text.add_modifier(Modifier::BOLD),
                ));
            }
            spans.push(Span::styled(value.clone(), bubble.muted));
            f.render_widget(Paragraph::new(Line::from(spans)), area);
        }
        Section::Block { label, body } => render_block(f, area, bubble, label, body),
        Section::Spacer => {}
    }
}

fn render_loading(f: &mut Frame, area: Rect, bubble: &BubbleTheme) {
    let frames = SpinnerFrames::DOTS;
    let frame_count = frames.frames().len().max(1);
    let frame = chrono::Utc::now().timestamp_millis().unsigned_abs() as usize / 120;
    let mut spinner = Spinner::new()
        .frames(frames)
        .label("Fetching usage data")
        .theme(*bubble);
    for _ in 0..(frame % frame_count) {
        spinner.tick();
    }
    f.render_widget(&spinner, area);
}

#[allow(clippy::too_many_arguments)]
fn render_metric(
    f: &mut Frame,
    area: Rect,
    theme: &Theme,
    bubble: &BubbleTheme,
    label: &str,
    pct: u16,
    severity: PaceSeverity,
    value_label: &str,
    footnote: &str,
) {
    let bar_color = severity_color(theme, bubble, severity);
    let bar_empty = color(&theme.bar_empty).unwrap_or(bubble.palette.selected_background);

    let inner = Layout::default()
        .direction(ratatui::layout::Direction::Vertical)
        .constraints([
            Constraint::Length(1),
            Constraint::Length(1),
            Constraint::Length(1),
        ])
        .split(area);

    // Row 1: label
    let label_line = Line::from(Span::styled(
        format!("  {label}"),
        bubble.text.add_modifier(Modifier::BOLD),
    ));
    f.render_widget(Paragraph::new(label_line), inner[0]);

    // Row 2: gauge spanning most of the width + value annotation on the right
    let row = inner[1];
    let value_w = crate::display::text_width(value_label) as u16 + 2;
    let gauge_area = Rect {
        x: row.x + 2,
        y: row.y,
        width: row.width.saturating_sub(value_w + 4),
        height: 1,
    };
    let value_area = Rect {
        x: gauge_area.x + gauge_area.width + 1,
        y: row.y,
        width: value_w,
        height: 1,
    };
    let progress_theme = progress_theme(*bubble, bar_color, bar_empty);
    let progress = Progress::from_percent(pct)
        .theme(progress_theme)
        .show_percentage(false);
    f.render_widget(&progress, gauge_area);
    let value = Paragraph::new(Line::from(Span::styled(
        value_label.to_string(),
        Style::default().fg(bar_color).add_modifier(Modifier::BOLD),
    )));
    f.render_widget(value, value_area);

    // Row 3: footnote (dim)
    let foot = Line::from(Span::styled(format!("    {footnote}"), bubble.muted));
    f.render_widget(Paragraph::new(foot), inner[2]);
}

fn render_block(f: &mut Frame, area: Rect, bubble: &BubbleTheme, label: &str, body: &[String]) {
    let mut lines = vec![Line::from(Span::styled(
        format!("  {label}"),
        bubble.text.add_modifier(Modifier::BOLD),
    ))];
    for b in body {
        lines.push(Line::from(Span::styled(format!("    {b}"), bubble.muted)));
    }
    f.render_widget(Paragraph::new(lines), area);
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::usage::{
        AnthropicSnapshot, Cents, CloudCredits, ExtraUsage, KimiSnapshot, OpenAiCredits,
        OpenAiSnapshot, OpenAiSource, OpenRouterSnapshot, ResetCredit, ResetCredits, UsageCredits,
        UsageWindow, ZaiSnapshot,
    };
    use chrono::TimeZone;

    fn now() -> DateTime<Utc> {
        Utc.with_ymd_and_hms(2026, 5, 23, 12, 0, 0).unwrap()
    }

    #[test]
    fn lyceum_panel_shows_usd_balance_without_a_quota_percentage() {
        let snapshot = VendorSnapshot::Lyceum(crate::usage::LyceumSnapshot {
            available_credits: 42.5,
            used_credits: 7.5,
            total_credits_used: 7.5,
            remaining_credits: 42.5,
            monthly_free_credits: 0.0,
            purchased_credits: 50.0,
        });
        let sections = sections_for(&ready(snapshot.clone()), now(), 5);
        assert!(sections.iter().any(|section| matches!(section, Section::Text { label, value } if label == "Available balance" && value == "$42.50")));
        assert!(
            !sections
                .iter()
                .any(|section| matches!(section, Section::Metric { .. }))
        );
        assert_eq!(headline_pct(&snapshot), None);
        let (_, cells) = compact_cells(&snapshot);
        assert_eq!(cells[0].0, "$42.50");
    }

    /// The spend row's label is its name to the notification dedupe key, the
    /// popover's stars and hidden rows and Omarchy's pick of a balance row, so
    /// it stays put while the covered day moves on a row of its own (#470).
    #[test]
    fn anthropic_api_spend_row_keeps_its_label_as_the_covered_day_moves() {
        fn rows(limit: Option<f64>, covered_through: Option<chrono::NaiveDate>) -> Vec<String> {
            let snapshot = VendorSnapshot::AnthropicApi(crate::usage::AnthropicApiSnapshot {
                spent: 1.34,
                limit,
                covered_through,
            });
            sections_for(&ready(snapshot), now(), 5)
                .into_iter()
                .filter_map(|section| match section {
                    Section::Metric { label, .. } => Some(label),
                    Section::Text { label, value } if !label.is_empty() => {
                        Some(format!("{label} {value}"))
                    }
                    _ => None,
                })
                .collect()
        }
        let oct = |day| chrono::NaiveDate::from_ymd_opt(2026, 10, day);
        assert_eq!(
            rows(Some(1000.0), oct(17)),
            ["Spend (mo)", "Through Oct 17"]
        );
        assert_eq!(
            rows(Some(1000.0), oct(18)),
            ["Spend (mo)", "Through Oct 18"]
        );
        assert_eq!(rows(None, oct(18)), ["Spend (mo) $1.34", "Through Oct 18"]);
        // A report with no dated bucket names no day.
        assert_eq!(rows(None, None), ["Spend (mo) $1.34"]);
    }

    fn ready(snapshot: VendorSnapshot) -> TabState {
        ready_with(snapshot, DisplayPrefs::default())
    }

    fn ready_with(snapshot: VendorSnapshot, display: DisplayPrefs) -> TabState {
        TabState::Ready(Box::new(crate::tui::app::ReadyTab {
            snapshot,
            stale: false,
            last_error: None,
            fetched_at: Some(now() - chrono::Duration::seconds(15)),
            display,
        }))
    }

    fn supergrok(period: crate::usage::SuperGrokPeriod) -> VendorSnapshot {
        VendorSnapshot::SuperGrok(crate::usage::SuperGrokSnapshot {
            plan: "SuperGrok".into(),
            account: "digest".into(),
            weekly_pct: 40,
            period,
            reset_at: Some(now() + chrono::Duration::days(2)),
            prepaid_balance: None,
            on_demand_used_cents: None,
            on_demand_cap_cents: None,
            reset_credits: crate::usage::ResetCredits::default(),
            products: Vec::new(),
        })
    }

    fn only_metric(sections: &[SectionProjection]) -> &SectionProjection {
        let mut metrics = sections
            .iter()
            .filter(|projection| matches!(projection.section, Section::Metric { .. }));
        let metric = metrics.next().expect("one metric row");
        assert!(metrics.next().is_none(), "expected exactly one metric row");
        metric
    }

    fn nous_snapshot() -> crate::nous::types::AccountSnapshot {
        crate::nous::types::AccountSnapshot {
            plan: Some("Ultra".into()),
            tier: Some(9),
            monthly_credits: Some(220.0),
            credits_remaining: Some(0.0),
            purchased_credits_remaining: Some(12.93),
            total_usable_credits: Some(12.93),
            rollover_credits: Some(10.0),
            current_period_end: None,
        }
    }

    /// `[nous] headline = "amount"` moves the credits still usable onto the
    /// bar; the plan-usage percentage keeps the meter and the detail line.
    #[test]
    fn nous_bar_headline_can_be_the_credits_balance() {
        let percent = sections_with_metadata_for(
            &ready(VendorSnapshot::NousResearch(nous_snapshot())),
            now(),
            5,
        );
        let metric = only_metric(&percent);
        assert_eq!(metric.headline, MetricHeadline::Percent);
        match &metric.section {
            Section::Metric { value_label, .. } => assert_eq!(value_label, "100%"),
            _ => unreachable!(),
        }

        let prefs = DisplayPrefs::balance(None, crate::balance::Headline::Amount);
        let balance = sections_with_metadata_for(
            &ready_with(VendorSnapshot::NousResearch(nous_snapshot()), prefs),
            now(),
            5,
        );
        let metric = only_metric(&balance);
        assert_eq!(metric.headline, MetricHeadline::Value);
        match &metric.section {
            Section::Metric {
                pct, value_label, ..
            } => {
                assert_eq!(*pct, 100);
                assert_eq!(value_label, "$12.93");
            }
            _ => unreachable!(),
        }
    }

    #[test]
    fn nous_sections_render_credit_rows_as_usd() {
        let sections = sections_with_metadata_for(
            &ready(VendorSnapshot::NousResearch(nous_snapshot())),
            now(),
            5,
        );
        assert!(sections.iter().any(|s| matches!(
            &s.section,
            Section::Text { label, value } if label == "Subscription credits" && value == "$0.00 remaining"
        )));
        assert!(sections.iter().any(|s| matches!(
            &s.section,
            Section::Text { label, value } if label == "Top-up credits" && value == "$12.93 remaining"
        )));
        assert!(sections.iter().any(|s| matches!(
            &s.section,
            Section::Text { label, value } if label == "Total usable credits" && value == "$12.93"
        )));
    }

    /// Only a rolling window has a length a frontend can pace against. The
    /// shared `UsageWindow` helper always knows it; SuperGrok knows it for a
    /// week and not for a month, whose length varies.
    #[test]
    fn window_length_is_reported_only_when_exact() {
        use crate::usage::SuperGrokPeriod;

        let weekly =
            sections_with_metadata_for(&ready(supergrok(SuperGrokPeriod::Weekly)), now(), 5);
        assert_eq!(only_metric(&weekly).window, Some(chrono::Duration::days(7)));

        let monthly =
            sections_with_metadata_for(&ready(supergrok(SuperGrokPeriod::Monthly)), now(), 5);
        assert_eq!(only_metric(&monthly).window, None);

        let unknown =
            sections_with_metadata_for(&ready(supergrok(SuperGrokPeriod::Unknown)), now(), 5);
        assert_eq!(only_metric(&unknown).window, None);

        let kimi = sections_with_metadata_for(
            &ready(VendorSnapshot::Kimi(KimiSnapshot {
                plan: None,
                weekly_limit: 100,
                weekly_used: 10,
                weekly_remaining: 90,
                weekly_reset_at: Some(now() + chrono::Duration::days(3)),
                has_weekly: true,
                monthly_pct: None,
                monthly_reset_at: None,
                window_limit: 0,
                window_used: 0,
                window_remaining: 0,
                window_reset_at: None,
            })),
            now(),
            5,
        );
        assert_eq!(
            only_metric(&kimi).window,
            Some(crate::kimi::vendor::WEEKLY_WINDOW)
        );
    }

    #[test]
    fn cursor_pools_carry_the_billing_cycle_window_only_when_it_is_exact() {
        let mut snap = cursor_snap();
        snap.cycle_start = Some(now() - chrono::Duration::days(22));
        let exact =
            sections_with_metadata_for(&ready(VendorSnapshot::Cursor(snap.clone())), now(), 5);
        let windows: Vec<_> = exact
            .iter()
            .filter(|p| matches!(p.section, Section::Metric { .. }))
            .map(|p| p.window)
            .collect();
        assert_eq!(
            windows,
            vec![
                Some(chrono::Duration::days(31)),
                Some(chrono::Duration::days(31))
            ]
        );

        // Without `billingCycleStart` the cycle length is unknown. Reporting a
        // guessed month here would reach a frontend as an exact window and be
        // paced as one; every pool goes out with no window instead. The reset
        // time is unaffected.
        snap.cycle_start = None;
        let unknown = sections_with_metadata_for(&ready(VendorSnapshot::Cursor(snap)), now(), 5);
        let pools: Vec<_> = unknown
            .iter()
            .filter(|p| matches!(p.section, Section::Metric { .. }))
            .collect();
        assert_eq!(pools.len(), 2);
        assert!(
            pools.iter().all(|p| p.window.is_none()),
            "an unstated billing cycle must not report a window length"
        );
        assert!(
            pools.iter().all(|p| p.reset_at.is_some()),
            "the reset time still travels with the row"
        );
    }

    #[test]
    fn cursor_pool_footnotes_pace_each_pool_against_an_exact_billing_cycle() {
        let snap = crate::usage::CursorSnapshot {
            auto_pct: 70,
            api_pct: 30,
            reset_at: Some(now() + chrono::Duration::days(5)),
            cycle_start: Some(now() - chrono::Duration::days(5)),
            ..cursor_snap()
        };
        let sections = sections_for(&ready(VendorSnapshot::Cursor(snap)), now(), 5);
        let footnotes: Vec<&str> = sections
            .iter()
            .filter_map(|section| match section {
                Section::Metric { footnote, .. } => Some(footnote.as_str()),
                _ => None,
            })
            .collect();
        assert_eq!(
            footnotes,
            [
                "Auto + Composer · 50% elapsed · 20pts ahead",
                "Named / API models · on-demand off · 50% elapsed · 20pts under",
            ]
        );
    }

    #[test]
    fn cursor_pool_footnotes_skip_the_pace_when_the_cycle_is_not_exact() {
        // No `billingCycleStart`: the footnotes stay what they were, as the
        // window stays absent from the report.
        let sections = sections_for(&ready(VendorSnapshot::Cursor(cursor_snap())), now(), 5);
        for section in &sections {
            if let Section::Metric { footnote, .. } = section {
                assert!(!footnote.contains("elapsed"), "{footnote}");
            }
        }
    }

    #[test]
    fn deepinfra_monthly_usage_carries_no_reset_when_a_limit_is_set() {
        // A vendor-defined billing period has no reset instant; the row must
        // still travel through push_metric (reset_at None) — a bare push
        // trips the reset-metadata assert the moment a limit is set.
        let snapshot = VendorSnapshot::Deepinfra(crate::usage::DeepInfraSnapshot {
            balance: 12.5,
            monthly_spend: 10.0,
            monthly_limit: Some(50.0),
            period: "2026.09".into(),
        });
        let rows = sections_with_metadata_for(&ready(snapshot), now(), 5);
        let metrics: Vec<_> = rows
            .iter()
            .filter(|p| matches!(p.section, Section::Metric { .. }))
            .collect();
        assert_eq!(metrics.len(), 1);
        assert!(
            metrics[0].reset_at.is_none(),
            "a vendor billing period has no reset instant"
        );
    }

    #[test]
    fn copilot_sections_carry_quota_reset_metadata() {
        let reset_at = now() + chrono::Duration::days(4);
        let snapshot = VendorSnapshot::Copilot(crate::copilot::types::Snapshot {
            plan: "Pro".into(),
            premium: Some(crate::copilot::types::Quota {
                percent_remaining: 25,
                entitlement: Some(300),
                remaining: Some(75),
                unlimited: false,
            }),
            chat: None,
            completions: None,
            reset_at: Some(reset_at),
        });
        let sections = sections_with_metadata_for(&ready(snapshot), now(), 5);
        assert!(matches!(
            &sections[0].section,
            Section::Title { left, .. } if left == "GitHub Copilot Pro"
        ));
        let metric = sections
            .iter()
            .find(|projection| matches!(&projection.section, Section::Metric { .. }))
            .expect("premium metric");
        assert_eq!(metric.reset_at, Some(reset_at));
        assert!(matches!(
            &metric.section,
            Section::Metric { label, pct, value_label, footnote, .. }
                if label == "Premium requests"
                    && *pct == 75
                    && value_label == "75%"
                    && footnote == "225 of 300 used"
        ));
    }

    #[test]
    fn anthropic_sections_include_all_three_windows_when_present() {
        let snap = AnthropicSnapshot {
            plan: "Max 20x".into(),
            session: UsageWindow {
                utilization_pct: 60,
                resets_at: Some(now() + chrono::Duration::hours(1)),
                window_duration: chrono::Duration::hours(5),
            },
            weekly: UsageWindow {
                utilization_pct: 30,
                resets_at: Some(now() + chrono::Duration::days(3)),
                window_duration: chrono::Duration::days(7),
            },
            sonnet: Some(UsageWindow {
                utilization_pct: 5,
                resets_at: Some(now() + chrono::Duration::hours(2)),
                window_duration: chrono::Duration::days(7),
            }),
            scoped: vec![],
            extra: Some(ExtraUsage {
                limit: Some(Cents(5000)),
                spent: Cents(250),
                currency: None,
                decimal_places: Some(2),
                status: crate::usage::ExtraUsageStatus::Active,
            }),
            reset_credits: Default::default(),
            cloud_credits: None,
            usage_credits: None,
        };
        let sections = sections_for(&ready(VendorSnapshot::Anthropic(snap)), now(), 5);
        // Title (carries "Updated …" inline now) + 4 metrics (3 windows +
        // extra) each preceded by a Spacer. 1 + 4*2 = 9 sections.
        assert_eq!(sections.len(), 9);
        assert!(matches!(sections[0], Section::Title { .. }));
        // Title's right-aligned slot should carry the timestamp.
        if let Section::Title { right, .. } = &sections[0] {
            assert!(right.as_deref().is_some_and(|r| r.starts_with("Updated ")));
        } else {
            panic!("expected first section to be Title");
        }
        let metric_count = sections
            .iter()
            .filter(|s| matches!(s, Section::Metric { .. }))
            .count();
        assert_eq!(metric_count, 4);
    }

    #[test]
    fn anthropic_uncapped_extra_shows_spend_without_a_denominator() {
        // The #30 shape: `monthly_limit: null` (Pro). The panel must show the
        // spend alone — not "of $0.00", not an invented percentage.
        let snap = AnthropicSnapshot {
            plan: "Pro".into(),
            session: UsageWindow {
                utilization_pct: 10,
                resets_at: None,
                window_duration: chrono::Duration::hours(5),
            },
            weekly: UsageWindow {
                utilization_pct: 20,
                resets_at: None,
                window_duration: chrono::Duration::days(7),
            },
            sonnet: None,
            scoped: vec![],
            extra: Some(ExtraUsage {
                limit: None,
                spent: Cents(14157),
                currency: Some("BRL".into()),
                decimal_places: Some(2),
                status: crate::usage::ExtraUsageStatus::OutOfCredits,
            }),
            reset_credits: Default::default(),
            cloud_credits: None,
            usage_credits: None,
        };
        let sections = sections_for(&ready(VendorSnapshot::Anthropic(snap)), now(), 5);
        let extra = sections
            .iter()
            .find_map(|s| match s {
                Section::Metric {
                    label,
                    pct,
                    value_label,
                    footnote,
                    ..
                } if label == "Extra usage" => Some((*pct, value_label.clone(), footnote.clone())),
                _ => None,
            })
            .expect("uncapped extra usage must still render a section");
        assert_eq!(extra.0, 0);
        // Non-vacuous currency pin: a bare `$` formatter would say "$141.57" here.
        assert_eq!(extra.1, "R$141.57");
        assert!(
            !extra.1.contains(" of "),
            "no denominator to show: {}",
            extra.1
        );
        assert_eq!(extra.2, "no monthly limit reported · out of credits");
    }

    #[test]
    fn anthropic_omits_sonnet_and_extra_when_absent() {
        let snap = AnthropicSnapshot {
            plan: "Pro".into(),
            session: UsageWindow {
                utilization_pct: 10,
                resets_at: None,
                window_duration: chrono::Duration::hours(5),
            },
            weekly: UsageWindow {
                utilization_pct: 5,
                resets_at: None,
                window_duration: chrono::Duration::days(7),
            },
            sonnet: None,
            scoped: vec![],
            extra: None,
            reset_credits: Default::default(),
            cloud_credits: None,
            usage_credits: None,
        };
        let sections = sections_for(&ready(VendorSnapshot::Anthropic(snap)), now(), 5);
        let metric_count = sections
            .iter()
            .filter(|s| matches!(s, Section::Metric { .. }))
            .count();
        assert_eq!(metric_count, 2);
    }

    fn claude_snapshot_with_credits(
        cloud: Option<CloudCredits>,
        usage: Option<UsageCredits>,
    ) -> VendorSnapshot {
        VendorSnapshot::Anthropic(AnthropicSnapshot {
            plan: "Max 5x".into(),
            session: UsageWindow {
                utilization_pct: 12,
                resets_at: Some(now() + chrono::Duration::hours(2)),
                window_duration: chrono::Duration::hours(5),
            },
            weekly: UsageWindow {
                utilization_pct: 34,
                resets_at: None,
                window_duration: chrono::Duration::days(7),
            },
            sonnet: None,
            scoped: vec![],
            extra: None,
            reset_credits: Default::default(),
            cloud_credits: cloud,
            usage_credits: usage,
        })
    }

    #[test]
    fn anthropic_cloud_session_credits_render_as_a_metric() {
        // The real 2026-10-26 payload shape: $250 of $250 left — 0% used.
        // Built exactly like Cursor's included credits: the remaining dollars
        // are the headline the tray, GNOME and KDE draw, the bar meters the
        // used share, and the caption carries the spend and the expiry.
        let snap = claude_snapshot_with_credits(
            Some(CloudCredits {
                limit: Cents(25000),
                remaining: Cents(25000),
                expires_at: Some("2026-11-05T07:59:00Z".parse().unwrap()),
                locked: false,
            }),
            None,
        );
        let tab = ready(snap);
        let sections = sections_for(&tab, now(), 5);
        let metric = sections
            .iter()
            .find_map(|s| match s {
                Section::Metric {
                    label,
                    pct,
                    severity,
                    value_label,
                    footnote,
                    ..
                } if label == "Cloud session credits" => {
                    Some((*pct, *severity, value_label.clone(), footnote.clone()))
                }
                _ => None,
            })
            .expect("a cloud session credits metric under the Claude account");
        assert_eq!(metric.0, 0);
        assert_eq!(metric.1, severity_for(0));
        // The value is the money figure itself, not a percentage readout.
        assert_eq!(metric.2, "$250.00");
        // The caption reads like the included credits: spend first, then the
        // expiry. The date is local-timezone output, so the shape is pinned,
        // not the zone.
        assert!(
            metric
                .3
                .starts_with("$0.00 of $250.00 used (0%) · expires "),
            "{:?}",
            metric.3
        );
        assert!(!metric.3.contains("locked"), "{:?}", metric.3);
        // The report projection names the value as the headline — that is
        // what the popover model keys its headlineLabel on — and there is
        // no reset instant behind the expiry.
        let with_meta = sections_with_metadata_for(&tab, now(), 5);
        let projected = with_meta
            .iter()
            .find(|p| {
                matches!(&p.section, Section::Metric { label, .. } if label == "Cloud session credits")
            })
            .expect("the metric in the projection");
        assert_eq!(projected.headline, MetricHeadline::Value);
        assert!(projected.reset_at.is_none());
    }

    #[test]
    fn anthropic_cloud_credits_headline_the_reported_balance_above_the_limit() {
        // The bar clamps to nothing used; the money stays what was reported.
        let snap = claude_snapshot_with_credits(
            Some(CloudCredits {
                limit: Cents(100),
                remaining: Cents(200),
                expires_at: None,
                locked: false,
            }),
            None,
        );
        let sections = sections_for(&ready(snap), now(), 5);
        let (pct, value) = sections
            .iter()
            .find_map(|s| match s {
                Section::Metric {
                    label,
                    pct,
                    value_label,
                    ..
                } if label == "Cloud session credits" => Some((*pct, value_label.clone())),
                _ => None,
            })
            .expect("a cloud session credits metric");
        assert_eq!(pct, 0);
        assert_eq!(value, "$2.00");
    }

    #[test]
    fn anthropic_cloud_credits_meter_the_used_share() {
        // 100 of 250 spent: the meter shows the used share, 40%.
        let snap = claude_snapshot_with_credits(
            Some(CloudCredits {
                limit: Cents(25000),
                remaining: Cents(15000),
                expires_at: None,
                locked: false,
            }),
            None,
        );
        let sections = sections_for(&ready(snap), now(), 5);
        let metric = sections
            .iter()
            .find_map(|s| match s {
                Section::Metric {
                    label,
                    pct,
                    severity,
                    value_label,
                    ..
                } if label == "Cloud session credits" => {
                    Some((*pct, *severity, value_label.clone()))
                }
                _ => None,
            })
            .expect("a cloud session credits metric");
        assert_eq!(metric.0, 40);
        assert_eq!(metric.1, severity_for(40));
        // Remaining dollars on the row; the used share and spend in the bar
        // and caption, exactly as the included credits read.
        assert_eq!(metric.2, "$150.00");
        let footnote = sections
            .iter()
            .find_map(|s| match s {
                Section::Metric {
                    label, footnote, ..
                } if label == "Cloud session credits" => Some(footnote.clone()),
                _ => None,
            })
            .expect("the footnote");
        // No expiry was reported, so the caption stops at the spend.
        assert_eq!(footnote, "$100.00 of $250.00 used (40%)");
    }

    #[test]
    fn anthropic_locked_cloud_credits_without_an_expiry_says_locked() {
        // No expires_at → the lock stands alone, with no leading separator.
        let snap = claude_snapshot_with_credits(
            Some(CloudCredits {
                limit: Cents(25000),
                remaining: Cents(25000),
                expires_at: None,
                locked: true,
            }),
            None,
        );
        let sections = sections_for(&ready(snap), now(), 5);
        let footnote = sections
            .iter()
            .find_map(|s| match s {
                Section::Metric {
                    label, footnote, ..
                } if label == "Cloud session credits" => Some(footnote.clone()),
                _ => None,
            })
            .expect("a cloud session credits metric");
        // No expiry clause, so the lock appends straight onto the spend
        // caption with its own separator — never an empty or dangling one.
        assert_eq!(footnote, "$0.00 of $250.00 used (0%) · locked");
    }

    #[test]
    fn anthropic_cloud_and_usage_credits_sit_between_extra_usage_and_resets() {
        let credits = ResetCredits {
            available: 1,
            credits: vec![ResetCredit {
                title: Some("Opus launch reset".into()),
                expires_at: Some(now() + chrono::Duration::days(20)),
            }],
        };
        let mut snap = claude_snapshot_with_credits(
            Some(CloudCredits {
                limit: Cents(25000),
                remaining: Cents(25000),
                expires_at: Some(now() + chrono::Duration::days(10)),
                locked: false,
            }),
            Some(UsageCredits {
                balance: Cents(1500),
                decimal_places: 2,
                currency: Some("USD".into()),
                auto_reload: Some(true),
            }),
        );
        if let VendorSnapshot::Anthropic(a) = &mut snap {
            a.extra = Some(ExtraUsage {
                limit: Some(Cents(5000)),
                spent: Cents(250),
                currency: None,
                decimal_places: Some(2),
                status: crate::usage::ExtraUsageStatus::Active,
            });
            a.reset_credits = credits;
        }
        let sections = sections_for(&ready(snap), now(), 5);
        let index_of = |probe: &str| {
            sections
                .iter()
                .position(|s| {
                    matches!(
                        s,
                        Section::Metric { label, .. }
                            | Section::Block { label, .. } if label == probe
                    )
                })
                .unwrap_or_else(|| panic!("missing section {probe}"))
        };
        let extra = index_of("Extra usage");
        let cloud = index_of("Cloud session credits");
        let usage = index_of("Usage credits");
        let resets = index_of("Reset credits");
        assert!(
            extra < cloud && cloud < usage && usage < resets,
            "order must be Extra usage < Cloud < Usage credits < Reset credits: {extra} < {cloud} < {usage} < {resets}"
        );
    }

    #[test]
    fn anthropic_usage_credits_render_as_a_block_with_the_balance_and_flag() {
        for (auto_reload, expected) in [
            (Some(true), vec!["balance: $15.00", "auto-reload: on"]),
            (Some(false), vec!["balance: $15.00", "auto-reload: off"]),
            (None, vec!["balance: $15.00"]),
        ] {
            let snap = claude_snapshot_with_credits(
                None,
                Some(UsageCredits {
                    balance: Cents(1500),
                    decimal_places: 2,
                    currency: Some("USD".into()),
                    auto_reload,
                }),
            );
            let sections = sections_for(&ready(snap), now(), 5);
            let body = sections
                .iter()
                .find_map(|s| match s {
                    Section::Block { label, body } if label == "Usage credits" => {
                        Some(body.clone())
                    }
                    _ => None,
                })
                .unwrap_or_else(|| panic!("usage credits block, auto_reload {auto_reload:?}"));
            assert_eq!(body, expected, "auto_reload {auto_reload:?}");
        }

        // A reported zero balance renders at the currency's own scale —
        // not as a $0.00 claim for a zero-exponent currency.
        let snap = claude_snapshot_with_credits(
            None,
            Some(UsageCredits {
                balance: Cents(0),
                decimal_places: 0,
                currency: Some("KRW".into()),
                auto_reload: None,
            }),
        );
        let sections = sections_for(&ready(snap), now(), 5);
        let body = sections
            .iter()
            .find_map(|s| match s {
                Section::Block { label, body } if label == "Usage credits" => Some(body.clone()),
                _ => None,
            })
            .expect("a reported balance renders even at zero");
        assert_eq!(body, vec!["balance: 0 KRW"]);
    }

    #[test]
    fn anthropic_omits_credit_sections_when_the_response_brought_none() {
        let snap = claude_snapshot_with_credits(None, None);
        let sections = sections_for(&ready(snap), now(), 5);
        assert!(!sections.iter().any(|s| matches!(
            s,
            Section::Metric { label, .. }
                if label == "Cloud session credits"
        )));
        assert!(!sections.iter().any(|s| matches!(
            s,
            Section::Block { label, .. } if label == "Usage credits"
        )));
    }

    #[test]
    fn openrouter_always_has_balance_metric_and_period_block() {
        let snap = OpenRouterSnapshot {
            label: "OR".into(),
            total_credits: 100.0,
            total_usage: 25.0,
            usage_daily: 1.0,
            usage_weekly: 5.0,
            usage_monthly: 25.0,
            is_free_tier: false,
            limit: None,
            limit_remaining: None,
            recent_models: Vec::new(),
        };
        let sections = sections_for(&ready(VendorSnapshot::Openrouter(snap)), now(), 5);
        assert!(matches!(sections[0], Section::Title { .. }));
        assert!(
            sections
                .iter()
                .any(|s| matches!(s, Section::Metric { label, .. } if label == "Credit balance"))
        );
        assert!(
            sections
                .iter()
                .any(|s| matches!(s, Section::Block { label, .. } if label == "Usage by period"))
        );
    }

    #[test]
    fn openrouter_recent_models_block_renders_only_when_present() {
        let snap = |recent_models: Vec<String>| OpenRouterSnapshot {
            label: "OR".into(),
            total_credits: 100.0,
            total_usage: 25.0,
            usage_daily: 1.0,
            usage_weekly: 5.0,
            usage_monthly: 25.0,
            is_free_tier: false,
            limit: None,
            limit_remaining: None,
            recent_models,
        };
        let models = vec!["gpt-5-codex ($1.25 · 42 reqs)".to_string()];
        let sections = sections_for(
            &ready(VendorSnapshot::Openrouter(snap(models.clone()))),
            now(),
            5,
        );
        let block = sections.iter().find_map(|s| match s {
            Section::Block { label, body } if label == "Recent models" => Some(body),
            _ => None,
        });
        assert_eq!(block, Some(&models));

        let sections = sections_for(
            &ready(VendorSnapshot::Openrouter(snap(Vec::new()))),
            now(),
            5,
        );
        assert!(
            !sections
                .iter()
                .any(|s| matches!(s, Section::Block { label, .. } if label == "Recent models"))
        );
    }

    /// #118 reached every frontend, not just Waybar: the panel row is what the
    /// Omarchy, GNOME and KDE plugins colour and label from, so the debt has to
    /// survive the projection with its sign and its severity intact.
    #[test]
    fn openrouter_debt_reaches_the_panel_row_red_and_signed() {
        let snap = OpenRouterSnapshot {
            label: "OR".into(),
            total_credits: 0.0,
            total_usage: 5.71,
            usage_daily: 1.0,
            usage_weekly: 5.0,
            usage_monthly: 5.71,
            is_free_tier: false,
            limit: None,
            limit_remaining: None,
            recent_models: Vec::new(),
        };
        let sections = sections_for(&ready(VendorSnapshot::Openrouter(snap.clone())), now(), 5);
        let metric = sections
            .iter()
            .find_map(|s| match s {
                Section::Metric {
                    label,
                    value_label,
                    severity,
                    footnote,
                    ..
                } if label == "Credit balance" => Some((value_label, severity, footnote)),
                _ => None,
            })
            .expect("no credit balance metric");
        assert_eq!(metric.0, "-$5.71");
        assert_eq!(*metric.1, PaceSeverity::Critical);
        assert_eq!(metric.2, "$5.71 of $0.00 used (0%)");

        // ...and the same number in the dense Overview list.
        let (_, cells) = compact_cells(&VendorSnapshot::Openrouter(snap));
        assert_eq!(cells[0].0, "-$5.71");
    }

    /// The panels express pace as a footnote on the row; the arrow is the
    /// widget's idiom and the bar tick the menu bar's. All three Z.AI windows
    /// report a duration and a reset, so all three carry one.
    #[test]
    fn zai_windows_are_paced_like_every_other_percentage_vendor() {
        let window = |pct: i32, hours: i64, span: chrono::Duration| crate::usage::UsageWindow {
            utilization_pct: pct,
            resets_at: Some(now() + chrono::Duration::hours(hours)),
            window_duration: span,
        };
        let snap = ZaiSnapshot {
            plan: "GLM Coding Pro".into(),
            session: Some(window(40, 2, chrono::Duration::hours(5))),
            weekly: Some(window(60, 48, chrono::Duration::days(7))),
            mcp: Some(window(10, 200, chrono::Duration::days(30))),
        };

        let footnotes: Vec<String> = sections_for(&ready(VendorSnapshot::Zai(snap)), now(), 5)
            .into_iter()
            .filter_map(|section| match section {
                Section::Metric { footnote, .. } => Some(footnote),
                _ => None,
            })
            .collect();

        assert_eq!(footnotes.len(), 3, "{footnotes:?}");
        for footnote in &footnotes {
            assert!(footnote.contains("% elapsed"), "{footnote}");
        }
        // 40% used with 60% of a 5h window gone: behind pace, not ahead.
        assert_eq!(
            footnotes[0], "Resets in 2h 00m · 60% elapsed · 20pts under",
            "{footnotes:?}"
        );
    }

    #[test]
    fn zai_no_windows_renders_message() {
        let snap = ZaiSnapshot {
            plan: "GLM".into(),
            session: None,
            weekly: None,
            mcp: None,
        };
        let sections = sections_for(&ready(VendorSnapshot::Zai(snap)), now(), 5);
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Text { value, .. } if value.contains("no usage windows reported")
        )));
    }

    #[test]
    fn openai_no_windows_renders_message() {
        let snap = OpenAiSnapshot {
            plan: "ChatGPT Plus".into(),
            session: None,
            weekly: None,
            code_review: None,
            additional_limits: Vec::new(),
            unavailable_models: Vec::new(),
            credits: None,
            reset_credits: None,
            source: OpenAiSource::CodexOauth,
        };
        let sections = sections_for(&ready(VendorSnapshot::Openai(snap)), now(), 5);
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Text { value, .. } if value.contains("no usage windows reported")
        )));
    }

    #[test]
    fn loading_state_yields_loading_section() {
        let sections = sections_for(&TabState::Loading, now(), 5);
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Text { value, .. } if value.contains("Loading")
        )));
    }

    #[test]
    fn error_state_includes_retry_hint() {
        let sections = sections_for(&TabState::error("token expired"), now(), 5);
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Text { value, .. } if value.contains("token expired")
        )));
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Text { value, .. } if value.contains("`r` to retry")
        )));
    }

    #[test]
    fn error_state_keeps_oauth_plan_as_title() {
        let sections = sections_for(
            &TabState::error_with_plan("HTTP 401", Some("Claude Max 5x".into())),
            now(),
            5,
        );
        assert!(matches!(
            &sections[0],
            Section::Title { left, .. } if left == "Claude Max 5x"
        ));
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Text { value, .. } if value.contains("HTTP 401")
        )));
        assert!(!sections.iter().any(|s| matches!(s, Section::Metric { .. })));
    }

    #[test]
    fn openai_with_credits_renders_block() {
        let snap = OpenAiSnapshot {
            plan: "ChatGPT Plus".into(),
            session: Some(UsageWindow {
                utilization_pct: 1,
                resets_at: None,
                window_duration: chrono::Duration::hours(5),
            }),
            weekly: Some(UsageWindow {
                utilization_pct: 0,
                resets_at: None,
                window_duration: chrono::Duration::days(7),
            }),
            code_review: None,
            additional_limits: Vec::new(),
            unavailable_models: Vec::new(),
            credits: Some(OpenAiCredits {
                balance: "62500".into(),
                has_credits: true,
                unlimited: false,
                approx_local_messages: Some((100, 200)),
                approx_cloud_messages: Some((30, 50)),
            }),
            reset_credits: None,
            source: OpenAiSource::CodexOauth,
        };
        let sections = sections_for(&ready(VendorSnapshot::Openai(snap)), now(), 5);
        let body = sections.iter().find_map(|s| match s {
            Section::Block { label, body } if label == "Credits" => Some(body.clone()),
            _ => None,
        });
        // The balance is a count of Codex credits, not dollars: a bare number
        // followed by `credits`, the same line the Waybar tooltip renders. The
        // block holds only that line — the estimated message counts (reported
        // by both ranges here) are no longer listed under it.
        assert_eq!(body, Some(vec!["62,500".to_string()]));
    }

    #[test]
    fn openai_credits_block_omits_message_estimate_lines_when_both_ranges_are_reported() {
        let snap = OpenAiSnapshot {
            plan: "ChatGPT Plus".into(),
            session: None,
            weekly: None,
            code_review: None,
            additional_limits: Vec::new(),
            unavailable_models: Vec::new(),
            credits: Some(OpenAiCredits {
                balance: "62500".into(),
                has_credits: true,
                unlimited: false,
                approx_local_messages: Some((100, 200)),
                approx_cloud_messages: Some((30, 50)),
            }),
            reset_credits: None,
            source: OpenAiSource::CodexOauth,
        };
        let sections = sections_for(&ready(VendorSnapshot::Openai(snap)), now(), 5);
        let body = sections
            .iter()
            .find_map(|s| match s {
                Section::Block { label, body } if label == "Credits" => Some(body.clone()),
                _ => None,
            })
            .expect("the Credits block is rendered");
        // With both ranges reported, no line of the block may carry a message
        // estimate; the balance line still does.
        assert!(body.iter().any(|line| line.contains("62,500")));
        assert!(
            !body
                .iter()
                .any(|line| line.contains("local messages") || line.contains("cloud messages"))
        );
    }

    #[test]
    fn openai_non_numeric_balance_is_shown_without_a_unit() {
        let snap = OpenAiSnapshot {
            plan: "ChatGPT Plus".into(),
            session: None,
            weekly: None,
            code_review: None,
            additional_limits: Vec::new(),
            unavailable_models: Vec::new(),
            credits: Some(OpenAiCredits {
                balance: "$5.00".into(),
                has_credits: true,
                unlimited: false,
                approx_local_messages: None,
                approx_cloud_messages: None,
            }),
            reset_credits: None,
            source: OpenAiSource::CodexOauth,
        };
        let sections = sections_for(&ready(VendorSnapshot::Openai(snap)), now(), 5);
        let body = sections.iter().find_map(|s| match s {
            Section::Block { label, body } if label == "Credits" => Some(body.clone()),
            _ => None,
        });
        // Vendor text that is not a number keeps its own text: no `credits`.
        assert_eq!(
            body.as_ref().and_then(|b| b.first()),
            Some(&"$5.00".to_string())
        );
    }

    #[test]
    fn openai_weekly_only_marks_the_session_window_as_not_reported() {
        let snap = OpenAiSnapshot {
            plan: "ChatGPT Prolite".into(),
            session: None,
            weekly: Some(UsageWindow {
                utilization_pct: 66,
                resets_at: None,
                window_duration: chrono::Duration::days(7),
            }),
            code_review: None,
            additional_limits: Vec::new(),
            unavailable_models: Vec::new(),
            credits: None,
            reset_credits: None,
            source: OpenAiSource::CodexOauth,
        };
        let sections = sections_for(&ready(VendorSnapshot::Openai(snap)), now(), 5);
        assert!(sections.iter().any(|section| matches!(
            section,
            Section::Metric { label, .. } if label == "Codex weekly"
        )));
        assert!(!sections.iter().any(|section| matches!(
            section,
            Section::Metric { label, .. } if label == "Codex 5h"
        )));
        assert!(sections.iter().any(|section| matches!(
            section,
            Section::Text { label, value }
                if label == "Codex 5h" && value == "Not reported"
        )));
    }

    #[test]
    fn openai_session_only_marks_the_weekly_window_as_not_reported() {
        let snap = OpenAiSnapshot {
            plan: "ChatGPT Plus".into(),
            session: Some(UsageWindow {
                utilization_pct: 12,
                resets_at: None,
                window_duration: chrono::Duration::hours(5),
            }),
            weekly: None,
            code_review: None,
            additional_limits: Vec::new(),
            unavailable_models: Vec::new(),
            credits: None,
            reset_credits: None,
            source: OpenAiSource::CodexOauth,
        };
        let sections = sections_for(&ready(VendorSnapshot::Openai(snap)), now(), 5);
        assert!(sections.iter().any(|section| matches!(
            section,
            Section::Metric { label, .. } if label == "Codex 5h"
        )));
        assert!(sections.iter().any(|section| matches!(
            section,
            Section::Text { label, value }
                if label == "Codex weekly" && value == "Not reported"
        )));
    }

    /// Every vendor that banks resets reaches every frontend through these
    /// sections — the TUI panel, `usage --json`, and from there the Omarchy,
    /// GNOME and KDE surfaces. One row, one wording, whichever provider
    /// banked the reset.
    #[test]
    fn banked_resets_reach_the_panel_for_every_provider() {
        let now = now();
        let credits = ResetCredits {
            available: 2,
            credits: vec![
                ResetCredit {
                    title: Some("Full reset (Weekly + 5 hr)".into()),
                    expires_at: Some(now + chrono::Duration::days(13)),
                },
                ResetCredit {
                    title: Some("Full reset (Weekly + 5 hr)".into()),
                    expires_at: Some(now + chrono::Duration::days(13) + chrono::Duration::hours(6)),
                },
            ],
        };
        let codex = OpenAiSnapshot {
            plan: "ChatGPT Plus".into(),
            session: None,
            weekly: None,
            code_review: None,
            additional_limits: Vec::new(),
            unavailable_models: Vec::new(),
            credits: None,
            reset_credits: Some(credits.clone()),
            source: OpenAiSource::CodexOauth,
        };
        let supergrok = crate::usage::SuperGrokSnapshot {
            plan: "SuperGrok".into(),
            account: "scope".into(),
            weekly_pct: 30,
            period: crate::usage::SuperGrokPeriod::Weekly,
            reset_at: Some(now + chrono::Duration::days(3)),
            prepaid_balance: None,
            on_demand_used_cents: None,
            on_demand_cap_cents: None,
            reset_credits: credits.clone(),
            products: Vec::new(),
        };
        let claude = AnthropicSnapshot {
            plan: "Max 20x".into(),
            session: UsageWindow {
                utilization_pct: 2,
                resets_at: Some(now + chrono::Duration::hours(1)),
                window_duration: chrono::Duration::hours(5),
            },
            weekly: UsageWindow {
                utilization_pct: 63,
                resets_at: Some(now + chrono::Duration::days(1)),
                window_duration: chrono::Duration::days(7),
            },
            sonnet: None,
            scoped: Vec::new(),
            extra: None,
            reset_credits: credits,
            cloud_credits: None,
            usage_credits: None,
        };

        for snapshot in [
            VendorSnapshot::Openai(codex),
            VendorSnapshot::SuperGrok(supergrok),
            VendorSnapshot::Anthropic(claude),
        ] {
            let sections = sections_for(&ready(snapshot), now, 5);
            let body = sections.iter().find_map(|section| match section {
                Section::Block { label, body } if label == "Reset credits" => Some(body.clone()),
                _ => None,
            });
            let body = body.expect("reset credits block");
            assert_eq!(body.len(), 2, "{body:?}");
            assert!(
                body.iter()
                    .all(|line| line.contains("Full reset (Weekly + 5 hr)")),
                "{body:?}"
            );
        }
    }

    /// The row is absent, not zeroed: an account that has never earned a reset
    /// should not carry a permanent "0 resets available" line.
    #[test]
    fn a_provider_with_no_banked_resets_shows_no_reset_row() {
        let snap = OpenAiSnapshot {
            plan: "ChatGPT Plus".into(),
            session: None,
            weekly: None,
            code_review: None,
            additional_limits: Vec::new(),
            unavailable_models: Vec::new(),
            credits: None,
            reset_credits: None,
            source: OpenAiSource::CodexOauth,
        };
        let sections = sections_for(&ready(VendorSnapshot::Openai(snap)), now(), 5);
        assert!(!sections.iter().any(|section| matches!(
            section,
            Section::Block { label, .. } if label == "Reset credits"
        )));
    }

    #[test]
    fn a_codex_account_that_states_zero_resets_shows_none_available() {
        let snap = OpenAiSnapshot {
            plan: "ChatGPT Pro".into(),
            session: None,
            weekly: None,
            code_review: None,
            additional_limits: Vec::new(),
            unavailable_models: Vec::new(),
            credits: None,
            reset_credits: Some(ResetCredits::default()),
            source: OpenAiSource::CodexOauth,
        };
        let sections = sections_for(&ready(VendorSnapshot::Openai(snap)), now(), 5);
        assert!(sections.iter().any(|section| matches!(
            section,
            Section::Block { label, body }
                if label == "Reset credits" && body == &vec!["None available".to_string()]
        )));
    }

    #[test]
    fn supergrok_does_not_repeat_the_window_reset_as_its_own_section() {
        let now = now();
        let snap = crate::usage::SuperGrokSnapshot {
            plan: "SuperGrok".into(),
            account: "scope".into(),
            weekly_pct: 0,
            period: crate::usage::SuperGrokPeriod::Weekly,
            reset_at: Some(now + chrono::Duration::days(6)),
            prepaid_balance: Some(0.0),
            on_demand_used_cents: None,
            on_demand_cap_cents: None,
            reset_credits: ResetCredits::default(),
            products: Vec::new(),
        };
        let sections = sections_for(&ready(VendorSnapshot::SuperGrok(snap)), now, 5);
        assert!(!sections.iter().any(|section| matches!(
            section,
            Section::Text { label, .. } if label == "Resets"
        )));
        // Zero prepaid is noise (see `supergrok_hides_a_zero_prepaid_balance`),
        // so even a present-but-zero field draws no row.
        assert!(!sections.iter().any(|section| matches!(
            section,
            Section::Text { label, .. } if label == "Prepaid API"
        )));
    }

    /// A $0.00 prepaid line reads as "no money" when the billing document
    /// merely reports that nothing was purchased on top of the subscription.
    /// The row appears only when there is credit to show.
    #[test]
    fn supergrok_hides_a_zero_prepaid_balance_but_keeps_a_real_one() {
        let now = now();
        let base = |prepaid: Option<f64>| crate::usage::SuperGrokSnapshot {
            plan: "SuperGrok".into(),
            account: "scope".into(),
            weekly_pct: 40,
            period: crate::usage::SuperGrokPeriod::Weekly,
            reset_at: Some(now + chrono::Duration::days(6)),
            prepaid_balance: prepaid,
            on_demand_used_cents: None,
            on_demand_cap_cents: None,
            reset_credits: ResetCredits::default(),
            products: Vec::new(),
        };
        let labels = |snap| {
            sections_for(&ready(VendorSnapshot::SuperGrok(snap)), now, 5)
                .into_iter()
                .filter_map(|section| match section {
                    Section::Text { label, value, .. } => Some((label, value)),
                    _ => None,
                })
                .collect::<Vec<_>>()
        };
        assert!(
            !labels(base(Some(0.0)))
                .iter()
                .any(|(label, _)| label == "Prepaid API")
        );
        assert_eq!(
            labels(base(Some(4.22))).last(),
            Some(&("Prepaid API".to_string(), "$4.22".to_string()))
        );
    }

    /// Additional usage is the on-demand pair from the same billing document.
    /// A zero pair draws no row; a cap is shown as dollars used of dollars allowed.
    #[test]
    fn supergrok_lists_additional_usage_when_the_billing_document_has_it() {
        let now = now();
        let mut snap = crate::usage::SuperGrokSnapshot {
            plan: "SuperGrok".into(),
            account: "scope".into(),
            weekly_pct: 40,
            period: crate::usage::SuperGrokPeriod::Weekly,
            reset_at: Some(now + chrono::Duration::days(6)),
            prepaid_balance: None,
            reset_credits: ResetCredits::default(),
            products: Vec::new(),
            on_demand_used_cents: Some(0),
            on_demand_cap_cents: Some(0),
        };
        let labels = |snap: crate::usage::SuperGrokSnapshot| {
            sections_for(&ready(VendorSnapshot::SuperGrok(snap)), now, 5)
                .into_iter()
                .filter_map(|section| match section {
                    Section::Text { label, value, .. } => Some((label, value)),
                    _ => None,
                })
                .collect::<Vec<_>>()
        };
        assert!(labels(snap.clone()).is_empty());
        snap.on_demand_used_cents = Some(150);
        snap.on_demand_cap_cents = Some(2000);
        assert_eq!(
            labels(snap),
            vec![("Additional usage".to_string(), "$1.50 / $20.00".to_string())]
        );
    }

    #[test]
    fn supergrok_lists_product_slices_beside_the_overall_meter() {
        let now = now();
        let snap = crate::usage::SuperGrokSnapshot {
            plan: "SuperGrok".into(),
            account: "scope".into(),
            weekly_pct: 90,
            period: crate::usage::SuperGrokPeriod::Weekly,
            reset_at: Some(now + chrono::Duration::days(3)),
            prepaid_balance: None,
            on_demand_used_cents: None,
            on_demand_cap_cents: None,
            reset_credits: ResetCredits::default(),
            products: vec![
                crate::usage::SuperGrokProduct {
                    label: "Grok Build".into(),
                    percent: 87,
                },
                crate::usage::SuperGrokProduct {
                    label: "Grok Chat".into(),
                    percent: 3,
                },
            ],
        };
        let labels: Vec<_> = sections_for(&ready(VendorSnapshot::SuperGrok(snap)), now, 5)
            .into_iter()
            .filter_map(|section| match section {
                Section::Metric { label, pct, .. } => Some((label, pct)),
                _ => None,
            })
            .collect();
        assert_eq!(
            labels,
            vec![
                ("Weekly usage".into(), 90),
                ("Grok Build".into(), 87),
                ("Grok Chat".into(), 3),
            ]
        );
    }

    /// Product slices report the "Breakdown" group so frontends can draw them
    /// under a heading; the overall meter stays ungrouped, and neither gains
    /// reset metadata it must not have.
    #[test]
    fn supergrok_product_slices_carry_the_breakdown_group() {
        let now = now();
        let snap = crate::usage::SuperGrokSnapshot {
            plan: "SuperGrok".into(),
            account: "scope".into(),
            weekly_pct: 90,
            period: crate::usage::SuperGrokPeriod::Weekly,
            reset_at: Some(now + chrono::Duration::days(3)),
            prepaid_balance: None,
            on_demand_used_cents: None,
            on_demand_cap_cents: None,
            reset_credits: ResetCredits::default(),
            products: vec![crate::usage::SuperGrokProduct {
                label: "Grok Build".into(),
                percent: 87,
            }],
        };
        let projected = sections_with_metadata_for(&ready(VendorSnapshot::SuperGrok(snap)), now, 5);
        let mut metrics = projected
            .iter()
            .filter(|p| matches!(p.section, Section::Metric { .. }));
        let overall = metrics.next().expect("overall usage metric");
        let build = metrics.next().expect("one product slice metric");
        assert!(metrics.next().is_none(), "expected exactly two metric rows");
        assert_eq!(overall.group, None);
        assert!(overall.reset_at.is_some());
        assert_eq!(build.group, Some("Breakdown"));
        assert_eq!(build.reset_at, None);
        assert_eq!(build.window, None);
    }

    /// The overall meter names its reset the way Grok Bot's does, so the TUI,
    /// `usage --json` and the Omarchy panel, which all read this footnote, do
    /// not show a bare percentage.
    #[test]
    fn supergrok_weekly_usage_row_carries_the_countdown_and_pace() {
        use crate::usage::SuperGrokPeriod;

        let sections =
            sections_with_metadata_for(&ready(supergrok(SuperGrokPeriod::Weekly)), now(), 5);
        let Section::Metric { footnote, .. } = &only_metric(&sections).section else {
            unreachable!()
        };
        // Two of seven days left is 71% elapsed; 40% used is 31 points under.
        assert_eq!(footnote, "Resets in 2d 0h · 71% elapsed · 31pts under");
    }

    /// A month varies and an unknown period says nothing, so neither can be
    /// paced: the countdown stands alone.
    #[test]
    fn supergrok_monthly_and_unknown_usage_rows_carry_the_countdown_alone() {
        use crate::usage::SuperGrokPeriod;

        for period in [SuperGrokPeriod::Monthly, SuperGrokPeriod::Unknown] {
            let sections = sections_with_metadata_for(&ready(supergrok(period)), now(), 5);
            let Section::Metric { footnote, .. } = &only_metric(&sections).section else {
                unreachable!()
            };
            assert_eq!(footnote, "Resets in 2d 0h", "{period:?}");
        }
    }

    /// With no reset reported there is nothing to count down to, so the row
    /// carries no footnote rather than a "Resets in" line with a placeholder.
    #[test]
    fn supergrok_usage_row_without_a_reset_has_no_footnote() {
        let now = now();
        let snap = crate::usage::SuperGrokSnapshot {
            plan: "SuperGrok".into(),
            account: "scope".into(),
            weekly_pct: 40,
            period: crate::usage::SuperGrokPeriod::Weekly,
            reset_at: None,
            prepaid_balance: None,
            on_demand_used_cents: None,
            on_demand_cap_cents: None,
            reset_credits: ResetCredits::default(),
            products: Vec::new(),
        };
        let projected = sections_with_metadata_for(&ready(VendorSnapshot::SuperGrok(snap)), now, 5);
        let Section::Metric { footnote, .. } = &only_metric(&projected).section else {
            unreachable!()
        };
        assert_eq!(footnote, "");
    }

    /// Product slices share the overall pool's window, so only the overall
    /// meter carries the reset line.
    #[test]
    fn supergrok_product_slices_keep_an_empty_footnote() {
        let now = now();
        let snap = crate::usage::SuperGrokSnapshot {
            plan: "SuperGrok".into(),
            account: "scope".into(),
            weekly_pct: 90,
            period: crate::usage::SuperGrokPeriod::Weekly,
            reset_at: Some(now + chrono::Duration::days(3)),
            prepaid_balance: None,
            on_demand_used_cents: None,
            on_demand_cap_cents: None,
            reset_credits: ResetCredits::default(),
            products: vec![crate::usage::SuperGrokProduct {
                label: "Grok Build".into(),
                percent: 87,
            }],
        };
        let projected = sections_with_metadata_for(&ready(VendorSnapshot::SuperGrok(snap)), now, 5);
        let footnotes: Vec<&str> = projected
            .iter()
            .filter_map(|p| match &p.section {
                Section::Metric { footnote, .. } => Some(footnote.as_str()),
                _ => None,
            })
            .collect();
        assert_eq!(
            footnotes,
            ["Resets in 3d 0h · 57% elapsed · 33pts ahead", ""]
        );
    }

    #[test]
    fn kimi_sections_include_weekly_and_window_with_used_over_limit() {
        let now = now();
        let snap = KimiSnapshot {
            plan: Some("LEVEL_INTERMEDIATE".into()),
            weekly_limit: 100,
            weekly_used: 26,
            weekly_remaining: 74,
            weekly_reset_at: Some(now + chrono::Duration::days(4)),
            has_weekly: true,
            monthly_pct: None,
            monthly_reset_at: None,
            window_limit: 100,
            window_used: 15,
            window_remaining: 85,
            window_reset_at: Some(now + chrono::Duration::hours(2)),
        };
        let sections = sections_for(&ready(VendorSnapshot::Kimi(snap)), now, 5);
        let metrics: Vec<_> = sections
            .iter()
            .filter(|s| matches!(s, Section::Metric { .. }))
            .collect();
        assert_eq!(metrics.len(), 2);
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Metric { label, .. } if label == "Weekly quota"
        )));
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Metric { label, .. } if label == "Rolling window (5h)"
        )));

        let find_footnote = |label: &str| -> (String, String) {
            sections
                .iter()
                .find_map(|s| match s {
                    Section::Metric {
                        label: l,
                        value_label,
                        footnote,
                        ..
                    } if l == label => Some((value_label.clone(), footnote.clone())),
                    _ => None,
                })
                .unwrap_or_else(|| panic!("missing metric {label}"))
        };

        // The bar carries the percentage, so the footnote is the plain
        // `Resets in …` every other window row shows — not the counters, which
        // against Kimi's limit of 100 only restate the percentage.
        let (weekly_value, weekly_footnote) = find_footnote("Weekly quota");
        assert_eq!(weekly_value, "26%");
        assert_eq!(weekly_footnote, "Resets in 4d 0h");

        let (window_value, window_footnote) = find_footnote("Rolling window (5h)");
        assert_eq!(window_value, "15%");
        assert_eq!(window_footnote, "Resets in 2h 00m");
    }

    /// Every vendor holding both a short and a long window opens on the short
    /// one — Claude's `Session (5h)`, Codex's `Codex 5h`, GLM's `Session (5h)`,
    /// OpenCode Go's `Rolling`. Kimi's rolling bucket is that window, so it
    /// leads both projections this module feeds: the section list the Quattro
    /// panel and the KDE plasmoid render in order, and the Overview's compact
    /// cells.
    #[test]
    fn kimi_leads_with_the_rolling_window_like_every_other_two_window_vendor() {
        let now = now();
        let snap = KimiSnapshot {
            plan: Some("LEVEL_INTERMEDIATE".into()),
            weekly_limit: 100,
            weekly_used: 26,
            weekly_remaining: 74,
            weekly_reset_at: Some(now + chrono::Duration::days(4)),
            has_weekly: true,
            monthly_pct: None,
            monthly_reset_at: None,
            window_limit: 100,
            window_used: 15,
            window_remaining: 85,
            window_reset_at: Some(now + chrono::Duration::hours(2)),
        };
        let sections = sections_for(&ready(VendorSnapshot::Kimi(snap.clone())), now, 5);
        let labels: Vec<&str> = sections
            .iter()
            .filter_map(|s| match s {
                Section::Metric { label, .. } => Some(label.as_str()),
                _ => None,
            })
            .collect();
        assert_eq!(labels, ["Rolling window (5h)", "Weekly quota"]);

        let (_, cells) = compact_cells(&VendorSnapshot::Kimi(snap));
        let texts: Vec<&str> = cells.iter().map(|(text, _)| text.as_str()).collect();
        assert_eq!(texts, ["5h 15%", "wk 26%"]);
    }

    #[test]
    fn kimi_sections_omit_window_when_limit_zero() {
        let snap = KimiSnapshot {
            plan: None,
            weekly_limit: 100,
            weekly_used: 10,
            weekly_remaining: 90,
            weekly_reset_at: None,
            has_weekly: true,
            monthly_pct: None,
            monthly_reset_at: None,
            window_limit: 0,
            window_used: 0,
            window_remaining: 0,
            window_reset_at: None,
        };
        let sections = sections_for(&ready(VendorSnapshot::Kimi(snap)), now(), 5);
        let metric_count = sections
            .iter()
            .filter(|s| matches!(s, Section::Metric { .. }))
            .count();
        assert_eq!(metric_count, 1);
    }

    /// The newer `usages`-map shape has no weekly bucket: the panel drops the
    /// weekly row and lists the monthly pool — with its reset, but with no
    /// window metadata, because the reset hangs on the order date and there
    /// is no fixed length to pace against.
    #[test]
    fn kimi_sections_on_the_monthly_shape_drop_weekly_and_add_monthly() {
        let now = now();
        let snap = KimiSnapshot {
            plan: Some("Allegretto".into()),
            weekly_limit: 0,
            weekly_used: 0,
            weekly_remaining: 0,
            weekly_reset_at: None,
            has_weekly: false,
            monthly_pct: Some(42),
            monthly_reset_at: Some(now + chrono::Duration::days(30)),
            window_limit: 100,
            window_used: 15,
            window_remaining: 85,
            window_reset_at: Some(now + chrono::Duration::hours(2)),
        };
        let projected =
            sections_with_metadata_for(&ready(VendorSnapshot::Kimi(snap.clone())), now, 5);
        let metrics: Vec<_> = projected
            .iter()
            .filter(|p| matches!(p.section, Section::Metric { .. }))
            .collect();
        assert_eq!(metrics.len(), 2);
        let monthly = metrics
            .iter()
            .find(|p| matches!(&p.section, Section::Metric { label, .. } if label == "Monthly"))
            .expect("a Monthly metric");
        assert!(matches!(
            &monthly.section,
            Section::Metric { value_label, footnote, .. }
            if value_label == "42%" && footnote == "Resets in 30d 0h"
        ));
        assert_eq!(monthly.reset_at, Some(now + chrono::Duration::days(30)));
        assert_eq!(monthly.window, None, "no fixed window length, no pacing");
        assert!(!metrics.iter().any(
            |p| matches!(&p.section, Section::Metric { label, .. } if label == "Weekly quota")
        ));

        // The Overview cells follow the same presence rules.
        let (_, cells) = compact_cells(&VendorSnapshot::Kimi(snap));
        let texts: Vec<&str> = cells.iter().map(|(text, _)| text.as_str()).collect();
        assert_eq!(texts, ["5h 15%", "mo 42%"]);
    }

    fn cursor_snap() -> crate::usage::CursorSnapshot {
        crate::usage::CursorSnapshot {
            plan: "Ultra".into(),
            auto_pct: 98,
            api_pct: 100,
            total_pct: 99,
            unlimited: false,
            on_demand_enabled: false,
            on_demand_used_cents: None,
            on_demand_limit_cents: None,
            reset_at: Some(now() + chrono::Duration::days(9)),
            cycle_start: None,
            credits: Vec::new(),
        }
    }

    #[test]
    fn compact_cells_flatten_key_metrics_for_the_overview() {
        // Percent vendor (Cursor): plan + two colored pool cells.
        let (plan, cells) = compact_cells(&VendorSnapshot::Cursor(cursor_snap()));
        assert_eq!(plan, "Ultra");
        assert_eq!(cells[0].0, "auto 98%");
        assert_eq!(cells[1].0, "premium 100%");
        assert_eq!(cells[1].1, PaceSeverity::Critical); // 100% is critical

        // Balance vendor (Kilo): no plan, a single money cell, calm severity.
        let (plan, cells) = compact_cells(&VendorSnapshot::Kilo(crate::usage::KiloSnapshot {
            label: "Kilo".into(),
            balance: 8.42,
        }));
        assert!(plan.is_empty());
        assert_eq!(cells, vec![("$8.42".to_string(), PaceSeverity::Low)]);
    }

    #[test]
    fn terminal_controls_are_removed_from_detail_and_overview_fields() {
        let error = TabState::error("bad\x1b]52;c;Y2FuYXJ5\x07 value");
        let sections = sections_for(&error, now(), 5);
        assert!(matches!(
            &sections[1],
            Section::Text { value, .. }
                if value == "bad]52;c;Y2FuYXJ5 value"
                    && !value.chars().any(|ch| ch.is_control())
        ));

        let mut snapshot = cursor_snap();
        snapshot.plan = "Ultra\x1b[2J\x07".into();
        let (plan, _) = compact_cells(&VendorSnapshot::Cursor(snapshot));
        assert_eq!(plan, "Ultra[2J");
        assert!(!plan.chars().any(char::is_control));
    }

    #[test]
    fn headline_pct_is_the_worst_window_or_combined_total() {
        // Cursor: the combined total, not the worse pool (mirrors the menu bar).
        assert_eq!(
            headline_pct(&VendorSnapshot::Cursor(cursor_snap())),
            Some(99)
        );

        // Balance-only vendors have no meaningful percentage → no bar.
        let kilo = VendorSnapshot::Kilo(crate::usage::KiloSnapshot {
            label: "Kilo".into(),
            balance: 8.42,
        });
        assert_eq!(headline_pct(&kilo), None);
    }

    #[test]
    fn droid_headline_counts_only_started_standard_windows() {
        let window = |pct: i32, started: bool| {
            Some(crate::usage::UsageWindow {
                utilization_pct: pct,
                resets_at: started.then(|| now() + chrono::Duration::hours(2)),
                window_duration: chrono::Duration::hours(5),
            })
        };
        let droid = |session, weekly, monthly, core| {
            VendorSnapshot::Droid(crate::usage::DroidSnapshot {
                session,
                weekly,
                monthly,
                core_session: core,
                core_weekly: None,
                core_monthly: None,
                extra_balance_cents: Some(250),
            })
        };

        // Core at 100% never feeds the headline; the started Standard does.
        let snapshot = droid(
            window(2, true),
            window(0, false),
            window(0, false),
            window(100, true),
        );
        assert_eq!(headline_pct(&snapshot), Some(2));
        let (_, cells) = compact_cells(&snapshot);
        assert!(cells.iter().any(|(label, _)| label == "$2.50"));

        // Every Standard window unstarted → no headline, whatever Core says.
        let unstarted = droid(
            window(0, false),
            window(0, false),
            window(0, false),
            window(100, true),
        );
        assert_eq!(headline_pct(&unstarted), None);
    }

    #[test]
    fn droid_unstarted_windows_say_so_and_an_idle_core_is_one_row() {
        let window = |pct: i32, started: bool| {
            Some(crate::usage::UsageWindow {
                utilization_pct: pct,
                resets_at: started.then(|| now() + chrono::Duration::hours(2)),
                window_duration: chrono::Duration::hours(5),
            })
        };
        let snapshot = |core_session| crate::usage::DroidSnapshot {
            session: window(0, false),
            weekly: window(23, true),
            monthly: None,
            core_session,
            core_weekly: window(0, false),
            core_monthly: window(0, false),
            extra_balance_cents: Some(0),
        };
        let footnotes = |sections: &[Section]| {
            sections
                .iter()
                .filter_map(|s| match s {
                    Section::Metric {
                        label, footnote, ..
                    } => Some((label.clone(), footnote.clone())),
                    _ => None,
                })
                .collect::<Vec<_>>()
        };

        let idle = sections_for(
            &ready(VendorSnapshot::Droid(snapshot(window(0, false)))),
            now(),
            5,
        );
        let rows = footnotes(&idle);
        assert_eq!(rows.len(), 2, "Standard only: {rows:?}");
        assert_eq!(rows[0], ("5-hour quota".into(), "Not started".into()));
        assert!(rows[1].1.starts_with("Resets in"), "{rows:?}");
        assert!(idle.iter().any(|s| matches!(
            s,
            Section::Text { label, value } if label == "Droid Core" && value == "not used yet"
        )));

        // Any Core use brings its windows back, unstarted ones labeled.
        let used = sections_for(
            &ready(VendorSnapshot::Droid(snapshot(window(4, true)))),
            now(),
            5,
        );
        let rows = footnotes(&used);
        assert_eq!(rows.len(), 5, "{rows:?}");
        assert_eq!(rows[3].1, "Not started");
        assert!(!used.iter().any(|s| matches!(
            s,
            Section::Text { value, .. } if value == "not used yet"
        )));
    }

    #[test]
    fn cursor_sections_show_both_pools_and_reset() {
        let mut snapshot = cursor_snap();
        snapshot.on_demand_enabled = true;
        snapshot.on_demand_used_cents = Some(1785);
        snapshot.on_demand_limit_cents = Some(35000);
        let sections = sections_for(&ready(VendorSnapshot::Cursor(snapshot)), now(), 5);
        let metrics: Vec<_> = sections
            .iter()
            .filter_map(|s| match s {
                Section::Metric {
                    label, value_label, ..
                } => Some((label.clone(), value_label.clone())),
                _ => None,
            })
            .collect();
        assert_eq!(metrics.len(), 2, "two pools");
        assert!(
            metrics
                .iter()
                .any(|(l, v)| l == "Cursor Models" && v == "98%")
        );
        assert!(
            metrics
                .iter()
                .any(|(l, v)| l == "Other Models" && v == "100%")
        );
        assert!(sections.iter().any(|section| matches!(
            section,
            Section::Text { label, value }
                if label == "On-Demand" && value == "$17.85 / $350.00"
        )));
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Text { label, value } if label == "Resets" && value.contains("9d")
        )));
    }

    #[test]
    fn cursor_credit_grant_is_a_meter_like_on_demand() {
        let mut snapshot = cursor_snap();
        snapshot.credits.push(crate::usage::CursorCreditGrant {
            remaining_cents: 2100,
            total_cents: 2500,
            expires_at: Some(now() + chrono::Duration::days(30)),
            display_name: "Power user grant".into(),
        });
        let sections = sections_for(&ready(VendorSnapshot::Cursor(snapshot)), now(), 5);
        assert!(sections.iter().any(|section| matches!(
            section,
            Section::Metric { label, pct, value_label, footnote, .. }
                if label == "Credits"
                    && *pct == 16
                    && value_label == "$21.00"
                    && footnote.contains("$4.00 of $25.00 used (16%)")
                    && footnote.contains("30d 0h")
        )));
    }

    #[test]
    fn cursor_on_demand_projection_keeps_the_cents() {
        let mut snapshot = cursor_snap();
        snapshot.on_demand_enabled = true;
        snapshot.on_demand_used_cents = Some(1785);
        snapshot.on_demand_limit_cents = Some(35000);
        let projected =
            sections_with_metadata_for(&ready(VendorSnapshot::Cursor(snapshot.clone())), now(), 5);
        let row = projected
            .iter()
            .find(|row| {
                matches!(
                    &row.section,
                    Section::Text { label, .. } if label == "On-Demand"
                )
            })
            .expect("on-demand row");
        assert_eq!(row.used_cents, Some(1785));
        assert_eq!(row.limit_cents, Some(35000));

        // Spend with no positive cap is still a row, and still not a meter.
        snapshot.on_demand_limit_cents = Some(0);
        let bare = sections_with_metadata_for(&ready(VendorSnapshot::Cursor(snapshot)), now(), 5);
        let bare_row = bare
            .iter()
            .find(|row| {
                matches!(
                    &row.section,
                    Section::Text { label, value }
                        if label == "On-Demand" && value == "$17.85 / $0.00"
                )
            })
            .expect("on-demand row without a cap");
        assert_eq!(bare_row.used_cents, Some(1785));
        assert_eq!(bare_row.limit_cents, None);
    }

    #[test]
    fn cursor_unlimited_plan_shows_no_pool_bars() {
        let mut snap = cursor_snap();
        snap.unlimited = true;
        let sections = sections_for(&ready(VendorSnapshot::Cursor(snap)), now(), 5);
        let metric_count = sections
            .iter()
            .filter(|s| matches!(s, Section::Metric { .. }))
            .count();
        assert_eq!(metric_count, 0);
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Text { value, .. } if value.contains("Unlimited")
        )));
    }

    fn kiro_snap() -> crate::usage::KiroSnapshot {
        crate::usage::KiroSnapshot {
            plan: "KIRO POWER".into(),
            used: 9943.38,
            limit: 10000.0,
            reset_at: Some(now() + chrono::Duration::days(1)),
        }
    }

    #[test]
    fn kiro_compact_cell_shows_the_credit_percentage() {
        let (plan, cells) = compact_cells(&VendorSnapshot::Kiro(kiro_snap()));
        assert_eq!(plan, "KIRO POWER");
        assert_eq!(
            cells,
            vec![("credits 99%".to_string(), PaceSeverity::Critical)]
        );
    }

    #[test]
    fn kiro_headline_pct_is_the_credit_percentage() {
        assert_eq!(headline_pct(&VendorSnapshot::Kiro(kiro_snap())), Some(99));
    }

    #[test]
    fn kiro_sections_show_the_credit_metric_and_reset() {
        let sections = sections_for(&ready(VendorSnapshot::Kiro(kiro_snap())), now(), 5);
        let metrics: Vec<_> = sections
            .iter()
            .filter_map(|s| match s {
                Section::Metric {
                    label, value_label, ..
                } => Some((label.clone(), value_label.clone())),
                _ => None,
            })
            .collect();
        assert_eq!(metrics, vec![("Credits".to_string(), "99%".to_string())]);
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Text { label, value } if label == "Resets" && value.contains("1d")
        )));
    }

    fn grokbot_snap() -> crate::usage::GrokbotSnapshot {
        crate::usage::GrokbotSnapshot {
            plan: "Grok Bot Plan".into(),
            billed_by: None,
            has_included_allowance: true,
            weekly_pct: 42,
            has_available_usage: true,
            on_demand_enabled: false,
            period_start: Some(now() - chrono::Duration::days(3)),
            reset_at: Some(now() + chrono::Duration::days(4)),
            window: Some(chrono::Duration::days(7)),
        }
    }

    #[test]
    fn grokbot_sections_show_one_weekly_meter_with_the_derived_window() {
        let sections =
            sections_with_metadata_for(&ready(VendorSnapshot::Grokbot(grokbot_snap())), now(), 5);
        let metric = only_metric(&sections);
        let Section::Metric {
            label,
            value_label,
            footnote,
            ..
        } = &metric.section
        else {
            unreachable!()
        };
        assert_eq!(label, "Weekly");
        assert_eq!(value_label, "42%");
        assert!(footnote.contains("Resets in"), "{footnote}");
        // The honest derived window, so a frontend paces against 7d exactly.
        assert!(footnote.contains("42% elapsed · on track"), "{footnote}");
        assert_eq!(metric.window, Some(chrono::Duration::days(7)));
        assert_eq!(metric.reset_at, grokbot_snap().reset_at);
    }

    #[test]
    fn grokbot_pacing_details_use_variable_periods_and_skip_missing_bounds() {
        for (reset_at, window, expected) in [
            (
                Some(now() + chrono::Duration::days(5)),
                Some(chrono::Duration::days(10)),
                Some("50% elapsed · 8pts under"),
            ),
            (None, Some(chrono::Duration::days(10)), None),
            (Some(now() + chrono::Duration::days(5)), None, None),
            (
                Some(now() + chrono::Duration::days(5)),
                Some(chrono::Duration::zero()),
                None,
            ),
        ] {
            let snap = crate::usage::GrokbotSnapshot {
                reset_at,
                window,
                ..grokbot_snap()
            };
            let sections =
                sections_with_metadata_for(&ready(VendorSnapshot::Grokbot(snap)), now(), 5);
            let Section::Metric { footnote, .. } = &only_metric(&sections).section else {
                panic!("expected a weekly metric");
            };
            if let Some(expected) = expected {
                assert!(footnote.contains(expected), "{footnote}");
            } else {
                assert!(!footnote.contains("elapsed"), "{footnote}");
            }
        }
    }

    #[test]
    fn grokbot_no_allowance_state_is_a_text_row_not_a_meter() {
        let snap = crate::usage::GrokbotSnapshot {
            has_included_allowance: false,
            weekly_pct: 0,
            ..grokbot_snap()
        };
        let sections = sections_for(&ready(VendorSnapshot::Grokbot(snap.clone())), now(), 5);
        assert!(
            sections
                .iter()
                .all(|s| !matches!(s, Section::Metric { .. })),
            "no meter without an included allowance"
        );
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Text { value, .. } if value.contains("no included allowance")
        )));
        assert_eq!(headline_pct(&VendorSnapshot::Grokbot(snap)), None);
        let (_, cells) = compact_cells(&VendorSnapshot::Grokbot(grokbot_snap()));
        assert_eq!(cells.len(), 1);
        assert!(cells[0].0.contains("42%"), "{cells:?}");
    }

    #[test]
    fn grokbot_names_the_subscription_that_bills_it_over_the_generic_plan() {
        // "Grok Bot Plan" is the app's label on every account; the billing
        // product says where the pool comes from.
        let (plan, _) = compact_cells(&VendorSnapshot::Grokbot(grokbot_snap()));
        assert_eq!(plan, "Grok Bot Plan");
        let billed = crate::usage::GrokbotSnapshot {
            billed_by: Some("Cursor Ultra".into()),
            ..grokbot_snap()
        };
        let (plan, _) = compact_cells(&VendorSnapshot::Grokbot(billed.clone()));
        assert_eq!(plan, "Cursor Ultra");
        // The report's plan is the title section, which the popover shows.
        let sections = sections_for(&ready(VendorSnapshot::Grokbot(billed)), now(), 5);
        assert!(matches!(
            sections.first(),
            Some(Section::Title { left, .. }) if left == "Cursor Ultra"
        ));
    }

    #[test]
    fn grokbot_on_demand_footnote_is_a_text_row_when_it_applies() {
        let mut snap = grokbot_snap();
        snap.weekly_pct = 100;
        snap.has_available_usage = true;
        snap.on_demand_enabled = true;
        let sections = sections_for(&ready(VendorSnapshot::Grokbot(snap)), now(), 5);
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Text { label, value } if label == "On-demand" && value.contains("on-demand")
        )));

        let mut snap = grokbot_snap();
        snap.weekly_pct = 100;
        snap.has_available_usage = true;
        snap.on_demand_enabled = false;
        let sections = sections_for(&ready(VendorSnapshot::Grokbot(snap)), now(), 5);
        assert!(
            sections
                .iter()
                .all(|s| !matches!(s, Section::Text { label, .. } if label == "On-demand")),
            "on-demand off: no footnote"
        );
    }

    #[test]
    fn grokbot_without_a_period_start_reports_no_window() {
        let mut snap = grokbot_snap();
        snap.period_start = None;
        snap.window = None;
        let sections = sections_with_metadata_for(&ready(VendorSnapshot::Grokbot(snap)), now(), 5);
        assert_eq!(only_metric(&sections).window, None);
    }

    fn modelstudio_snap() -> crate::usage::ModelStudioSnapshot {
        crate::usage::ModelStudioSnapshot {
            session: Some(crate::usage::UsageWindow {
                utilization_pct: 42,
                resets_at: Some(now() + chrono::Duration::hours(2)),
                window_duration: chrono::Duration::hours(5),
            }),
            weekly: Some(crate::usage::UsageWindow {
                utilization_pct: 74,
                resets_at: Some(now() + chrono::Duration::days(3)),
                window_duration: chrono::Duration::days(7),
            }),
            monthly: None,
        }
    }

    /// Present windows ride the shared window metric, so the absolute reset
    /// travels with each row and a frontend can pace against the real length.
    #[test]
    fn modelstudio_sections_show_both_windows_with_resets() {
        let sections = sections_with_metadata_for(
            &ready(VendorSnapshot::ModelStudio(modelstudio_snap())),
            now(),
            5,
        );
        let metrics: Vec<_> = sections
            .iter()
            .filter_map(|projected| match &projected.section {
                Section::Metric {
                    label, value_label, ..
                } => Some((label.clone(), value_label.clone())),
                _ => None,
            })
            .collect();
        assert_eq!(
            metrics,
            vec![
                ("Token Plan 5h".to_string(), "42%".to_string()),
                ("Token Plan 7d".to_string(), "74%".to_string()),
            ]
        );
        let with_meta: Vec<_> = sections
            .iter()
            .filter(|p| matches!(p.section, Section::Metric { .. }))
            .map(|p| (p.window, p.reset_at))
            .collect();
        assert_eq!(
            with_meta[0],
            (
                Some(chrono::Duration::hours(5)),
                modelstudio_snap().session.unwrap().resets_at
            )
        );
        assert_eq!(
            with_meta[1],
            (
                Some(chrono::Duration::days(7)),
                modelstudio_snap().weekly.unwrap().resets_at
            )
        );
    }

    /// An absent percentage is no-data (possibly unlimited): the window drops
    /// its meter and its compact cell — never a 0% anything.
    #[test]
    fn modelstudio_absent_windows_are_text_rows_never_zero_meters() {
        let snap = crate::usage::ModelStudioSnapshot {
            session: None,
            weekly: None,
            monthly: None,
        };
        let sections = sections_for(&ready(VendorSnapshot::ModelStudio(snap.clone())), now(), 5);
        assert!(
            sections
                .iter()
                .all(|s| !matches!(s, Section::Metric { .. })),
            "no meter without a reported window"
        );
        assert!(sections.iter().any(|s| matches!(
            s,
            Section::Text { value, .. } if value.contains("no usage windows reported")
        )));
        assert_eq!(
            headline_pct(&VendorSnapshot::ModelStudio(snap.clone())),
            None
        );
        let (_, cells) = compact_cells(&VendorSnapshot::ModelStudio(snap));
        assert!(cells.is_empty(), "{cells:?}");

        // One window present: one meter, one cell, worst-of headline.
        let snap = crate::usage::ModelStudioSnapshot {
            session: None,
            weekly: modelstudio_snap().weekly,
            monthly: None,
        };
        let (_, cells) = compact_cells(&VendorSnapshot::ModelStudio(snap.clone()));
        assert_eq!(cells.len(), 1);
        assert!(cells[0].0.contains("74%"), "{cells:?}");
        assert_eq!(headline_pct(&VendorSnapshot::ModelStudio(snap)), Some(74));
    }

    /// The monthly window — the individual Token Plan's only reported window —
    /// gets its own meter with the exact reset, but no declared window length
    /// (the cycle is plan-dependent), so no frontend paces against a guessed
    /// denominator.
    #[test]
    fn modelstudio_monthly_only_renders_a_meter_with_reset_and_no_window_length() {
        let snap = crate::usage::ModelStudioSnapshot {
            session: None,
            weekly: None,
            monthly: Some(crate::usage::UsageWindow {
                utilization_pct: 100,
                resets_at: Some(now() + chrono::Duration::days(21)),
                window_duration: chrono::Duration::days(30),
            }),
        };
        let sections =
            sections_with_metadata_for(&ready(VendorSnapshot::ModelStudio(snap.clone())), now(), 5);
        let metrics: Vec<_> = sections
            .iter()
            .filter_map(|projected| match &projected.section {
                Section::Metric { label, .. } => Some(label.clone()),
                _ => None,
            })
            .collect();
        assert_eq!(metrics, vec!["Token Plan 30d".to_string()]);
        let metric = sections
            .iter()
            .find(|p| matches!(p.section, Section::Metric { .. }))
            .unwrap();
        assert_eq!(
            metric.reset_at,
            Some(now() + chrono::Duration::days(21)),
            "the exact reset travels with the row"
        );
        assert_eq!(
            metric.window, None,
            "a plan-dependent monthly cycle declares no window length"
        );
        assert_eq!(headline_pct(&VendorSnapshot::ModelStudio(snap)), Some(100));

        // The absent 5h/weekly windows stay text rows, never zero meters.
        let (_, cells) = compact_cells(&crate::usage::VendorSnapshot::ModelStudio(
            crate::usage::ModelStudioSnapshot {
                session: None,
                weekly: None,
                monthly: Some(crate::usage::UsageWindow {
                    utilization_pct: 100,
                    resets_at: Some(now() + chrono::Duration::days(21)),
                    window_duration: chrono::Duration::days(30),
                }),
            },
        ));
        assert_eq!(cells.len(), 1, "{cells:?}");
    }

    #[test]
    fn devin_daily_and_weekly_windows_keep_reset_metadata_and_no_fake_session() {
        let daily_reset = now() + chrono::Duration::hours(4);
        let weekly_reset = now() + chrono::Duration::days(2);
        let snapshot = crate::usage::DevinSnapshot {
            daily: Some(UsageWindow {
                utilization_pct: 35,
                resets_at: Some(daily_reset),
                window_duration: chrono::Duration::days(1),
            }),
            weekly: Some(UsageWindow {
                utilization_pct: 72,
                resets_at: Some(weekly_reset),
                window_duration: chrono::Duration::days(7),
            }),
            overage_balance_micros: Some(9_168_615),
        };
        let vendor = VendorSnapshot::Devin(snapshot.clone());
        let sections = sections_with_metadata_for(&ready(vendor.clone()), now(), 5);
        let metrics: Vec<_> = sections
            .iter()
            .filter_map(|projection| match &projection.section {
                Section::Metric {
                    label, value_label, ..
                } => Some((
                    label.as_str(),
                    value_label.as_str(),
                    projection.reset_at,
                    projection.window,
                )),
                _ => None,
            })
            .collect();
        assert_eq!(metrics.len(), 2);
        assert_eq!(
            metrics[0],
            (
                "Daily quota",
                "35%",
                Some(daily_reset),
                Some(chrono::Duration::days(1))
            )
        );
        assert_eq!(
            metrics[1],
            (
                "Weekly quota",
                "72%",
                Some(weekly_reset),
                Some(chrono::Duration::days(7))
            )
        );
        assert_eq!(headline_pct(&vendor), Some(72));
        let (plan, cells) = compact_cells(&vendor);
        assert_eq!(plan, "", "the caller prints the vendor name");
        assert_eq!(cells.len(), 3, "daily, weekly and text balance only");
        assert_eq!(cells[2].0, "$9.168615");

        let no_data = VendorSnapshot::Devin(crate::usage::DevinSnapshot {
            daily: None,
            weekly: None,
            overage_balance_micros: None,
        });
        let sections = sections_for(&ready(no_data.clone()), now(), 5);
        assert!(sections.iter().any(|section| matches!(
            section,
            Section::Text { value, .. } if value == "no quota fields reported"
        )));
        assert_eq!(headline_pct(&no_data), None);
        assert!(compact_cells(&no_data).1.is_empty());

        let balance_only = VendorSnapshot::Devin(crate::usage::DevinSnapshot {
            daily: None,
            weekly: None,
            overage_balance_micros: Some(1),
        });
        assert_eq!(headline_pct(&balance_only), None);
        assert_eq!(compact_cells(&balance_only).1.len(), 1);
    }

    #[test]
    fn schema_drift_and_generic_code_zero_diagnostics_are_visible_without_http_labels() {
        let snap = KimiSnapshot {
            plan: None,
            weekly_limit: 100,
            weekly_used: 10,
            weekly_remaining: 90,
            weekly_reset_at: None,
            has_weekly: true,
            monthly_pct: None,
            monthly_reset_at: None,
            window_limit: 0,
            window_used: 0,
            window_remaining: 0,
            window_reset_at: None,
        };
        let mut schema = ready(VendorSnapshot::Kimi(snap.clone()));
        let TabState::Ready(tab) = &mut schema else {
            unreachable!()
        };
        tab.last_error = Some((0, crate::kimi::fetch::SCHEMA_DRIFT_MESSAGE.into()));
        let schema_sections = sections_for(&schema, now(), 5);
        assert!(schema_sections.iter().any(|section| matches!(
            section,
            Section::Text { label, value } if label == "Kimi API schema drift" && value.is_empty()
        )));

        let mut generic = ready(VendorSnapshot::Kimi(snap));
        let TabState::Ready(tab) = &mut generic else {
            unreachable!()
        };
        tab.last_error = Some((0, "cache lock unavailable".into()));
        let generic_sections = sections_for(&generic, now(), 5);
        assert!(generic_sections.iter().any(|section| matches!(
            section,
            Section::Text { label, value } if label == "Warning" && value == "cache lock unavailable"
        )));
        assert!(!generic_sections.iter().any(|section| matches!(
            section,
            Section::Text { label, .. } if label.starts_with("HTTP")
        )));

        let http = warning_label(
            &VendorSnapshot::Kimi(KimiSnapshot {
                plan: None,
                weekly_limit: 0,
                weekly_used: 0,
                weekly_remaining: 0,
                weekly_reset_at: None,
                has_weekly: true,
                monthly_pct: None,
                monthly_reset_at: None,
                window_limit: 0,
                window_used: 0,
                window_remaining: 0,
                window_reset_at: None,
            }),
            &Some((503, "service unavailable".into())),
        );
        assert_eq!(
            http,
            Some(("HTTP 503".into(), "service unavailable".into()))
        );
    }

    fn antigravity_snap(source: crate::usage::AntigravitySource) -> VendorSnapshot {
        VendorSnapshot::Antigravity(crate::usage::AntigravitySnapshot {
            plan: "Pro".into(),
            account: "acct:test".into(),
            source,
            session: Some(UsageWindow {
                utilization_pct: 43,
                resets_at: Some(now() + chrono::Duration::hours(2)),
                window_duration: chrono::Duration::hours(5),
            }),
            weekly: None,
            third_party_session: None,
            third_party_weekly: None,
            model_pools: Vec::new(),
        })
    }

    /// A per-model pool is a row of its own under the heading of its cadence,
    /// and that heading appears even when no shared window of the cadence did.
    #[test]
    fn antigravity_model_pool_gets_its_own_row_under_its_cadence() {
        let VendorSnapshot::Antigravity(mut snap) =
            antigravity_snap(crate::usage::AntigravitySource::Local)
        else {
            unreachable!()
        };
        snap.model_pools.push(crate::usage::ModelPoolWindow {
            name: "Gemini 4 Argon".into(),
            window: UsageWindow {
                utilization_pct: 60,
                resets_at: Some(now() + chrono::Duration::days(3)),
                window_duration: chrono::Duration::days(7),
            },
        });
        let sections = sections_for(&ready(VendorSnapshot::Antigravity(snap)), now(), 5);
        let weekly = sections
            .iter()
            .position(|s| matches!(s, Section::Text { label, .. } if label == "Weekly"))
            .expect("Weekly heading");
        let argon = sections
            .iter()
            .position(|s| {
                matches!(s, Section::Metric { label, pct: 60, .. } if label == "Gemini 4 Argon")
            })
            .expect("Argon row");
        assert!(argon > weekly);
    }

    /// Figures read off the API while nothing runs say so; a running product's
    /// do not, since that is the normal case.
    #[test]
    fn antigravity_names_the_remote_source_and_only_that() {
        use crate::usage::AntigravitySource;

        let remote = sections_for(
            &ready(antigravity_snap(AntigravitySource::Remote)),
            now(),
            5,
        );
        let n = remote.len();
        assert!(matches!(remote[n - 2], Section::Spacer));
        assert!(matches!(
            &remote[n - 1],
            Section::Text { label, value }
                if label == "Source" && value == "Google API"
        ));

        let local = sections_for(&ready(antigravity_snap(AntigravitySource::Local)), now(), 5);
        assert!(
            !local
                .iter()
                .any(|s| matches!(s, Section::Text { label, .. } if label == "Source"))
        );

        for source in [AntigravitySource::Statusline, AntigravitySource::Agy] {
            let sections = sections_for(&ready(antigravity_snap(source)), now(), 5);
            assert!(
                !sections
                    .iter()
                    .any(|s| matches!(s, Section::Text { label, .. } if label == "Source")),
                "{source:?}"
            );
        }
    }

    /// A custom provider's rows come out in declaration order: title, gauges,
    /// then texts. Only a metric that states its window length carries one;
    /// every metric's own `resets_at` rides along as reset metadata.
    #[test]
    fn custom_sections_follow_declaration_order_and_carry_reset_metadata() {
        use crate::custom::types::{CustomMetric, CustomSnapshot, CustomText};

        let session_reset = now() + chrono::Duration::hours(3);
        let monthly_reset = now() + chrono::Duration::days(12);
        let snapshot = VendorSnapshot::Custom(CustomSnapshot {
            plan: Some("Team".into()),
            metrics: vec![
                CustomMetric {
                    label: "Session".into(),
                    pct: 40,
                    footnote: "40 of 100".into(),
                    resets_at: Some(session_reset),
                    window_secs: Some(18_000),
                },
                CustomMetric {
                    label: "Monthly".into(),
                    pct: 120,
                    footnote: String::new(),
                    resets_at: Some(monthly_reset),
                    window_secs: None,
                },
            ],
            texts: vec![CustomText {
                label: "Region".into(),
                value: "eu".into(),
            }],
        });

        let sections = sections_with_metadata_for(&ready(snapshot.clone()), now(), 5);
        assert!(matches!(
            &sections[0].section,
            Section::Title { left, right } if left == "Team" && right.is_some()
        ));
        assert!(matches!(sections[1].section, Section::Spacer));
        assert!(matches!(
            &sections[2].section,
            Section::Metric { label, pct, value_label, footnote, .. }
                if label == "Session" && *pct == 40 && value_label == "40%" && footnote == "40 of 100"
        ));
        assert_eq!(sections[2].reset_at, Some(session_reset));
        assert_eq!(sections[2].window, Some(chrono::Duration::hours(5)));
        // An over-100 percentage is clamped for the gauge; no window is invented.
        assert!(matches!(
            &sections[3].section,
            Section::Metric { label, pct, value_label, .. }
                if label == "Monthly" && *pct == 100 && value_label == "100%"
        ));
        assert_eq!(sections[3].reset_at, Some(monthly_reset));
        assert_eq!(sections[3].window, None);
        assert!(matches!(sections[4].section, Section::Spacer));
        assert!(matches!(
            &sections[5].section,
            Section::Text { label, value } if label == "Region" && value == "eu"
        ));
        assert_eq!(sections.len(), 6);

        let (plan, cells) = compact_cells(&snapshot);
        assert_eq!(plan, "Team");
        assert_eq!(cells[0].0, "Session 40%");
        assert_eq!(cells[1].0, "Monthly 120%");
        assert_eq!(headline_pct(&snapshot), Some(40));

        // No plan and no texts: an empty title, no trailing spacer, no bar.
        let bare = VendorSnapshot::Custom(CustomSnapshot {
            plan: None,
            metrics: vec![],
            texts: vec![],
        });
        let sections = sections_with_metadata_for(&ready(bare.clone()), now(), 5);
        assert!(matches!(&sections[0].section, Section::Title { left, .. } if left.is_empty()));
        assert_eq!(sections.len(), 2);
        assert_eq!(compact_cells(&bare), (String::new(), vec![]));
        assert_eq!(headline_pct(&bare), None);
    }

    // --- prepaid-balance tank + headline (display_limit) ---

    fn deepseek(balance: f64) -> VendorSnapshot {
        VendorSnapshot::Deepseek(crate::usage::DeepseekSnapshot {
            is_available: true,
            balance,
            granted: balance,
            topped_up: 0.0,
            currency: "USD".into(),
        })
    }

    fn balance_row(sections: &[SectionProjection]) -> &SectionProjection {
        sections
            .iter()
            .find(|projection| {
                matches!(&projection.section,
                    Section::Metric { label, .. } | Section::Text { label, .. }
                        if label == "Balance" || label == "Prepaid balance")
            })
            .expect("a balance row")
    }

    /// No `display_limit`: nothing supplies a denominator, so the row stays
    /// free text rather than becoming a fabricated 0% gauge.
    #[test]
    fn a_balance_vendor_without_a_tank_keeps_its_plain_text_row() {
        let sections = sections_with_metadata_for(&ready(deepseek(5.50)), now(), 5);
        assert!(matches!(
            &balance_row(&sections).section,
            Section::Text { value, .. } if value == "$5.50"
        ));
    }

    /// A tank turns the same row into a consumed meter. The default headline
    /// for a balance vendor is the money figure, and setting `display_limit`
    /// alone does not change that — the percentage rides in the detail.
    #[test]
    fn a_tank_meters_the_balance_without_moving_the_money_off_the_bar() {
        let prefs = DisplayPrefs::balance(Some(200.0), crate::balance::Headline::Amount);
        let sections = sections_with_metadata_for(&ready_with(deepseek(50.0), prefs), now(), 5);
        let row = balance_row(&sections);
        assert_eq!(row.headline, MetricHeadline::Value);
        match &row.section {
            Section::Metric {
                pct,
                value_label,
                footnote,
                ..
            } => {
                assert_eq!(*pct, 75);
                assert_eq!(value_label, "$50.00");
                assert_eq!(footnote, "75% of $200.00 used ($50.00 left)");
            }
            _ => panic!("expected a metric"),
        }
    }

    /// Choosing `percent` moves the percentage onto the bar and the dollar
    /// figure into the detail line — the two numbers swap, neither is lost.
    #[test]
    fn choosing_percent_swaps_which_number_is_the_headline() {
        let prefs = DisplayPrefs::balance(Some(200.0), crate::balance::Headline::Percent);
        let sections = sections_with_metadata_for(&ready_with(deepseek(50.0), prefs), now(), 5);
        let row = balance_row(&sections);
        assert_eq!(row.headline, MetricHeadline::Percent);
        match &row.section {
            Section::Metric {
                pct,
                value_label,
                footnote,
                ..
            } => {
                assert_eq!(*pct, 75);
                assert_eq!(value_label, "75%");
                assert_eq!(footnote, "$50.00 of $200.00 left (75% used)");
            }
            _ => panic!("expected a metric"),
        }
    }

    /// `percent` with nothing to divide by keeps the amount on the bar rather
    /// than inventing a denominator.
    #[test]
    fn percent_without_a_tank_keeps_the_amount_on_the_bar() {
        let prefs = DisplayPrefs::balance(None, crate::balance::Headline::Percent);
        let sections = sections_with_metadata_for(&ready_with(deepseek(5.50), prefs), now(), 5);
        assert!(matches!(
            &balance_row(&sections).section,
            Section::Text { value, .. } if value == "$5.50"
        ));
    }

    /// A balance above the cap is 0% used; the money figure is what says how
    /// far above it sits, and it stays in the detail line.
    #[test]
    fn a_balance_over_the_cap_reads_as_zero_percent_with_the_money_in_the_detail() {
        let prefs = DisplayPrefs::balance(Some(20.0), crate::balance::Headline::Percent);
        let sections = sections_with_metadata_for(&ready_with(deepseek(50.0), prefs), now(), 5);
        match &balance_row(&sections).section {
            Section::Metric {
                pct,
                value_label,
                footnote,
                severity,
                ..
            } => {
                assert_eq!(*pct, 0);
                assert_eq!(value_label, "0%");
                assert!(footnote.contains("$50.00"), "{footnote}");
                assert_eq!(*severity, PaceSeverity::Low);
            }
            _ => panic!("expected a metric"),
        }
    }

    /// The money tier stays the floor: a nearly-empty wallet is critical even
    /// when the tank it is measured against is tiny enough to look healthy.
    #[test]
    fn severity_is_the_worse_of_the_money_tier_and_the_percentage_tier() {
        // $0.50 left of a $1 tank: 50% used is only "mid", but under the $1
        // USD floor the wallet itself is critical.
        let prefs = DisplayPrefs::balance(Some(1.0), crate::balance::Headline::Percent);
        let sections = sections_with_metadata_for(&ready_with(deepseek(0.50), prefs), now(), 5);
        match &balance_row(&sections).section {
            Section::Metric { severity, .. } => assert_eq!(*severity, PaceSeverity::Critical),
            _ => panic!("expected a metric"),
        }

        // $30 left of a $200 tank: the money tier is comfortable, but 85% of
        // the tank is gone and the meter has to say so.
        let prefs = DisplayPrefs::balance(Some(200.0), crate::balance::Headline::Percent);
        let sections = sections_with_metadata_for(&ready_with(deepseek(30.0), prefs), now(), 5);
        match &balance_row(&sections).section {
            Section::Metric { pct, severity, .. } => {
                assert_eq!(*pct, 85);
                assert_eq!(*severity, PaceSeverity::High);
            }
            _ => panic!("expected a metric"),
        }
    }

    /// Every balance-only vendor gets the same shape from one helper, so a
    /// tank and a headline behave identically across all of them.
    #[test]
    fn every_balance_only_vendor_meters_the_same_way() {
        let snapshots: Vec<VendorSnapshot> = vec![
            deepseek(50.0),
            VendorSnapshot::Kilo(crate::usage::KiloSnapshot {
                label: "Kilo".into(),
                balance: 50.0,
            }),
            VendorSnapshot::Novita(crate::usage::NovitaSnapshot {
                available: 50.0,
                cash: 50.0,
                credit_limit: 0.0,
                outstanding: 0.0,
            }),
            VendorSnapshot::Moonshot(crate::usage::MoonshotSnapshot {
                available: 50.0,
                cash: 50.0,
                voucher: 0.0,
                currency: "USD".into(),
            }),
            VendorSnapshot::Grok(crate::usage::GrokSnapshot { balance: 50.0 }),
        ];
        for snapshot in snapshots {
            let bare = sections_with_metadata_for(&ready(snapshot.clone()), now(), 5);
            assert!(
                matches!(&balance_row(&bare).section, Section::Text { .. }),
                "{snapshot:?} should keep a text row without a tank"
            );

            let prefs = DisplayPrefs::balance(Some(200.0), crate::balance::Headline::Percent);
            let metered =
                sections_with_metadata_for(&ready_with(snapshot.clone(), prefs), now(), 5);
            let row = balance_row(&metered);
            assert_eq!(row.headline, MetricHeadline::Percent, "{snapshot:?}");
            match &row.section {
                Section::Metric {
                    pct, value_label, ..
                } => {
                    assert_eq!(*pct, 75, "{snapshot:?}");
                    assert_eq!(value_label, "75%", "{snapshot:?}");
                }
                _ => panic!("{snapshot:?} should meter with a tank"),
            }
        }
    }

    /// OpenRouter states its own denominator, so a `display_limit` on it never
    /// applies — the fallback order puts the API's number first.
    #[test]
    fn openrouters_own_credits_win_over_a_configured_display_limit() {
        let snapshot = VendorSnapshot::Openrouter(crate::usage::OpenRouterSnapshot {
            label: "OpenRouter".into(),
            total_credits: 100.0,
            total_usage: 25.0,
            usage_daily: 0.0,
            usage_weekly: 0.0,
            usage_monthly: 0.0,
            is_free_tier: false,
            limit: None,
            limit_remaining: None,
            recent_models: Vec::new(),
        });
        // A wildly different tank size changes nothing: 25 of 100 is 25%.
        // `[openrouter]` carries no `display_limit`, so this can only arrive
        // through a hand-built `DisplayPrefs` — and the call site drops it.
        let prefs = DisplayPrefs::balance(Some(10_000.0), crate::balance::Headline::Percent);
        let sections = sections_with_metadata_for(&ready_with(snapshot, prefs), now(), 5);
        let metric = only_metric(&sections);
        assert_eq!(metric.headline, MetricHeadline::Percent);
        match &metric.section {
            Section::Metric { pct, .. } => assert_eq!(*pct, 25),
            _ => unreachable!(),
        }
    }

    /// The default for OpenRouter is the percent it always has a denominator
    /// for; the dollar figure stays available in `value` for the detail line.
    #[test]
    fn openrouter_defaults_to_percent_and_keeps_the_money_in_the_value() {
        let snapshot = VendorSnapshot::Openrouter(crate::usage::OpenRouterSnapshot {
            label: "OpenRouter".into(),
            total_credits: 100.0,
            total_usage: 25.0,
            usage_daily: 0.0,
            usage_weekly: 0.0,
            usage_monthly: 0.0,
            is_free_tier: false,
            limit: None,
            limit_remaining: None,
            recent_models: Vec::new(),
        });
        let sections = sections_with_metadata_for(
            &ready_with(
                snapshot,
                crate::config::Config::default().display_prefs(crate::vendor::VendorId::Openrouter),
            ),
            now(),
            5,
        );
        let metric = only_metric(&sections);
        assert_eq!(metric.headline, MetricHeadline::Percent);
        match &metric.section {
            Section::Metric { value_label, .. } => assert_eq!(value_label, "$75.00"),
            _ => unreachable!(),
        }
    }

    /// A free-tier-only OpenRouter account bought no credits, so there is no
    /// denominator and the money stays on the bar even at the percent default.
    ///
    /// The `prefs` loop is the regression: `openrouter_sections` used to route
    /// `prefs.display_limit` into `balance::denominator`, and with credits at 0
    /// the API value was dropped as unusable, so a tank took over and named the
    /// headline `percent` — while `pct` still came from `consumed_pct()`, which
    /// is 0 without credits. The bar read "0%" for an account holding money. No
    /// `[openrouter] display_limit` exists any more, and the call site passes
    /// `None` literally, so neither half of that can come back.
    #[test]
    fn a_free_tier_openrouter_account_has_no_denominator_and_shows_the_money() {
        let snapshot = VendorSnapshot::Openrouter(crate::usage::OpenRouterSnapshot {
            label: "OpenRouter".into(),
            total_credits: 0.0,
            total_usage: 0.0,
            usage_daily: 0.0,
            usage_weekly: 0.0,
            usage_monthly: 0.0,
            is_free_tier: true,
            limit: None,
            limit_remaining: None,
            recent_models: Vec::new(),
        });
        for prefs in [
            DisplayPrefs::default(),
            DisplayPrefs::balance(Some(200.0), crate::balance::Headline::Percent),
            DisplayPrefs::balance(Some(200.0), crate::balance::Headline::Amount),
        ] {
            let sections =
                sections_with_metadata_for(&ready_with(snapshot.clone(), prefs), now(), 5);
            let metric = only_metric(&sections);
            assert_eq!(metric.headline, MetricHeadline::Value, "{prefs:?}");
            match &metric.section {
                Section::Metric { value_label, .. } => {
                    assert_eq!(value_label, "$0.00", "{prefs:?}")
                }
                _ => unreachable!(),
            }
        }
    }

    /// The same corner with money actually in the account: an overdrawn or
    /// zero-credit snapshot must never be metered against a tank, because the
    /// percentage on that row does not come from one.
    #[test]
    fn a_credit_less_openrouter_snapshot_is_never_metered_against_a_tank() {
        let snapshot = VendorSnapshot::Openrouter(crate::usage::OpenRouterSnapshot {
            label: "OpenRouter".into(),
            total_credits: 0.0,
            total_usage: 0.0,
            usage_daily: 0.0,
            usage_weekly: 0.0,
            usage_monthly: 0.0,
            is_free_tier: false,
            limit: Some(50.0),
            limit_remaining: Some(50.0),
            recent_models: Vec::new(),
        });
        let prefs = DisplayPrefs::balance(Some(200.0), crate::balance::Headline::Percent);
        let sections = sections_with_metadata_for(&ready_with(snapshot, prefs), now(), 5);
        let metric = only_metric(&sections);
        assert_eq!(metric.headline, MetricHeadline::Value);
        match &metric.section {
            // Not "0%": the row reports the money, which is what this snapshot
            // actually knows.
            Section::Metric {
                pct, value_label, ..
            } => {
                assert_eq!(*pct, 0);
                assert_eq!(value_label, "$0.00");
            }
            _ => unreachable!(),
        }
    }

    /// Muse's generic report carries both windows' absolute reset metadata.
    #[test]
    fn muse_windows_keep_their_reset_and_duration_in_the_report_projection() {
        let at = now();
        let snapshot = crate::usage::MuseSnapshot {
            plan: "Muse Code Power Usage".into(),
            session: Some(crate::usage::UsageWindow {
                utilization_pct: 38,
                resets_at: Some(at + chrono::Duration::hours(3)),
                window_duration: chrono::Duration::hours(5),
            }),
            weekly: Some(crate::usage::UsageWindow {
                utilization_pct: 34,
                resets_at: Some(at + chrono::Duration::days(4)),
                window_duration: chrono::Duration::days(7),
            }),
        };
        let vendor = VendorSnapshot::MuseCode(snapshot.clone());
        assert_eq!(headline_pct(&vendor), Some(38));
        let sections = sections_with_metadata_for(&ready(vendor), at, 5);
        let metrics = sections
            .iter()
            .filter(|section| matches!(section.section, Section::Metric { .. }))
            .collect::<Vec<_>>();
        assert_eq!(metrics.len(), 2);
        assert_eq!(
            metrics[0].reset_at,
            snapshot.session.as_ref().unwrap().resets_at
        );
        assert_eq!(metrics[0].window, Some(chrono::Duration::hours(5)));
        assert_eq!(
            metrics[1].reset_at,
            snapshot.weekly.as_ref().unwrap().resets_at
        );
        assert_eq!(metrics[1].window, Some(chrono::Duration::days(7)));
    }

    /// Nothing else moved: a quota vendor's metrics stay percentages.
    #[test]
    fn a_quota_vendors_metrics_stay_percent_headlines() {
        let sections = sections_with_metadata_for(
            &ready(supergrok(crate::usage::SuperGrokPeriod::Weekly)),
            now(),
            5,
        );
        for projection in &sections {
            if matches!(projection.section, Section::Metric { .. }) {
                assert_eq!(projection.headline, MetricHeadline::Percent);
            }
        }
    }
}