Add files using upload-large-folder tool

codex-rs/tui/src/analytics/account_layout_tests.rs

@@ -0,0 +1,491 @@
+//! Account layouts, authenticated report loading, independent ranges, and model filters.
+use super::*;
+use codex_config::types::KeybindingSpec;
+use codex_config::types::KeybindingsSpec;
+use codex_config::types::TuiKeymap;
+use pretty_assertions::assert_eq;
+
+use crate::analytics::sections::Section;
+#[test]
+fn account_layouts_show_reports_and_wrap_navigation() {
+    let mut screens = Vec::new();
+    for (kind, expected) in [
+        (
+            models::AccountKind::Consumer,
+            vec![
+                Section::Summary,
+                Section::Usage,
+                Section::Activity,
+                Section::Plugins,
+                Section::Skills,
+                Section::Chats,
+            ],
+        ),
+        (
+            models::AccountKind::Enterprise,
+            vec![
+                Section::Summary,
+                Section::Credits,
+                Section::Usage,
+                Section::Plugins,
+                Section::Skills,
+                Section::Chats,
+            ],
+        ),
+    ] {
+        let mut view = fixture::view(kind);
+        for (index, section) in expected.iter().enumerate() {
+            press(
+                &mut view,
+                KeyCode::Char(char::from_digit(index as u32 + 1, /*radix*/ 10).unwrap()),
+            );
+            assert_eq!(view.section, *section);
+            screens.push(screen(&mut view, /*width*/ 100, /*height*/ 30));
+        }
+        press(&mut view, KeyCode::Tab);
+        assert_eq!(view.section, expected[0]);
+        press(&mut view, KeyCode::BackTab);
+        assert_eq!(view.section, *expected.last().unwrap());
+        view.zoomed = false;
+        screens.push(screen(&mut view, /*width*/ 140, /*height*/ 64));
+    }
+    insta::assert_snapshot!(screens.join("\n"));
+}
+
+#[tokio::test]
+async fn changing_ranges_and_grouping_preserves_other_reports_and_focus() {
+    let server = test_support::server().await;
+    let (_home, _app_server, mut view) = client::tests::connected_view(&server, "plus").await;
+    test_support::settle(&mut view).await;
+    view.section = Section::Usage;
+    press(&mut view, KeyCode::Left);
+    press(&mut view, KeyCode::Enter);
+    press(&mut view, KeyCode::Char('r'));
+    test_support::settle(&mut view).await;
+    press(&mut view, KeyCode::Char('g'));
+    test_support::settle(&mut view).await;
+    assert_eq!(
+        (
+            view.ranges,
+            view.sections.0.each_ref().map(|state| state.cursor),
+            view.sections[Section::Usage].detail,
+            view.sections[Section::Usage].group
+        ),
+        ([1, 0, 0], [28, 6, 6, 0, 6, 6, 6, 6], Some(28), 2)
+    );
+    let context = (
+        view.ranges,
+        view.sections.0.each_ref().map(|state| state.cursor),
+        view.sections.0.each_ref().map(|state| state.detail),
+        view.sections.0.each_ref().map(|state| state.group),
+    );
+    press(&mut view, KeyCode::Char('z'));
+    screen(&mut view, /*width*/ 58, /*height*/ 25);
+    press(&mut view, KeyCode::Char('z'));
+    assert_eq!(
+        (
+            view.ranges,
+            view.sections.0.each_ref().map(|state| state.cursor),
+            view.sections.0.each_ref().map(|state| state.detail),
+            view.sections.0.each_ref().map(|state| state.group)
+        ),
+        context
+    );
+    press(&mut view, KeyCode::Char('3'));
+    press(&mut view, KeyCode::Char('r'));
+    test_support::settle(&mut view).await;
+    assert_eq!(view.ranges, [1, 1, 0]);
+    assert_eq!(
+        view.sections
+            .0
+            .each_ref()
+            .map(|state| state.history.ready().map(|history| history.data.len())),
+        [Some(30), Some(7), None, None, Some(30), Some(7), None, None]
+    );
+    let server = test_support::server().await;
+    let (_business_home, _business_server, mut view) =
+        client::tests::connected_view(&server, "business").await;
+    test_support::settle(&mut view).await;
+    view.ranges = [1, 1, 0];
+    view.load_report(Section::Usage);
+    press(&mut view, KeyCode::Char('2'));
+    press(&mut view, KeyCode::Char('r'));
+    test_support::settle(&mut view).await;
+    assert_eq!(view.ranges, [0, 1, 0]);
+    assert_eq!(
+        view.sections
+            .0
+            .each_ref()
+            .map(|state| state.history.ready().map(|history| history.data.len())),
+        [Some(30), Some(7), Some(7), None, None, Some(7), None, None]
+    );
+}
+
+#[tokio::test]
+async fn business_tokens_filter_models() {
+    let server = test_support::server().await;
+    let (_home, _app_server, mut view) = client::tests::connected_view(&server, "business").await;
+    test_support::settle(&mut view).await;
+    view.end_date = fixture::END_DATE;
+    fixture::seed_reports(&mut view);
+    press(&mut view, KeyCode::Char('3'));
+    let all = screen(&mut view, /*width*/ 100, /*height*/ 30);
+    assert!(all.contains("All models") && all.contains("Cached input"));
+    press(&mut view, KeyCode::Char('m'));
+    test_support::settle(&mut view).await;
+    assert_eq!(
+        view.sections[Section::Usage]
+            .history
+            .ready()
+            .unwrap()
+            .data
+            .iter()
+            .map(|day| day.total)
+            .sum::<f64>(),
+        420.0
+    );
+    fixture::seed_reports(&mut view);
+    assert_eq!(view.token_model.as_deref(), Some("GPT-5.5"));
+    let filtered = screen(&mut view, /*width*/ 100, /*height*/ 30);
+    press(&mut view, KeyCode::Char('m'));
+    test_support::settle(&mut view).await;
+    fixture::seed_reports(&mut view);
+    assert_eq!(view.token_model, None);
+    insta::assert_snapshot!(format!("{all}\n{filtered}"));
+}
+
+#[tokio::test]
+async fn account_pending_and_error_do_not_start_reports() {
+    let mut view = AnalyticsView::new(RuntimeKeymap::defaults().list);
+    let (send, receive) = tokio::sync::oneshot::channel();
+    view.account = Load::start(
+        async move { receive.await.unwrap() },
+        FrameRequester::test_dummy(),
+    );
+    screen(&mut view, /*width*/ 80, /*height*/ 24);
+    assert!(
+        view.sections
+            .0
+            .iter()
+            .all(|state| matches!(state.history, Load::Unavailable))
+    );
+    send.send(Err("Sign in again to view Analytics.".to_string()))
+        .unwrap();
+    tokio::task::yield_now().await;
+    let error = screen(&mut view, /*width*/ 80, /*height*/ 24);
+    assert!(error.contains("Sign in again"));
+    assert!(
+        view.sections
+            .0
+            .iter()
+            .all(|state| matches!(state.history, Load::Unavailable))
+    );
+    insta::assert_snapshot!(error);
+}
+
+#[tokio::test]
+async fn account_reports_request_only_eligible_endpoints_and_refresh() {
+    for (plan, usage, activity) in [
+        (
+            "plus",
+            "usage/daily-token-usage-breakdown",
+            "analytics/daily-workspace-usage-counts",
+        ),
+        (
+            "business",
+            "usage/daily-workspace-user-token-usage-breakdown",
+            "usage/daily-workspace-user-credit-usage",
+        ),
+    ] {
+        let server = test_support::server().await;
+        wiremock::Mock::given(wiremock::matchers::method("GET"))
+            .and(wiremock::matchers::path("/backend-api/wham/profiles/me"))
+            .respond_with(
+                wiremock::ResponseTemplate::new(/*s*/ 200)
+                    .set_body_json(serde_json::json!({"stats":{}})),
+            )
+            .mount(&server)
+            .await;
+        let (_home, _app_server, mut view) = client::tests::connected_view(&server, plan).await;
+        test_support::settle(&mut view).await;
+        let mut expected = [
+            "accounts/check",
+            usage,
+            activity,
+            "analytics/daily-plugin-usage-metrics",
+            "analytics/daily-skill-usage-metrics",
+            "profiles/me",
+        ]
+        .map(|endpoint| format!("/backend-api/wham/{endpoint}"));
+        expected.sort();
+        let mut paths = server
+            .received_requests()
+            .await
+            .unwrap()
+            .into_iter()
+            .filter(|request| request.url.path().starts_with("/backend-api/wham/"))
+            .map(|request| request.url.path().to_string())
+            .collect::<Vec<_>>();
+        paths.sort();
+        assert_eq!(paths, expected);
+        let ready = view
+            .sections
+            .0
+            .each_ref()
+            .map(|state| state.history.ready().is_some());
+        assert_eq!(
+            ready,
+            if plan == "plus" {
+                [true, true, false, false, true, true, false, false]
+            } else {
+                [true, true, true, false, false, true, false, false]
+            }
+        );
+        press(&mut view, KeyCode::Char('R'));
+        test_support::settle(&mut view).await;
+        assert_eq!(
+            view.sections
+                .0
+                .each_ref()
+                .map(|state| state.history.ready().is_some()),
+            ready
+        );
+        assert_eq!(
+            server
+                .received_requests()
+                .await
+                .unwrap()
+                .iter()
+                .filter(|request| request.url.path().starts_with("/backend-api/wham/"))
+                .count(),
+            12
+        );
+        view.cancel_loads();
+    }
+}
+
+#[tokio::test]
+async fn grouping_cycle_uses_current_server_capabilities() {
+    let server = test_support::server().await;
+    let (_home, _app_server, mut view) = client::tests::connected_view(&server, "plus").await;
+    view.section = Section::Usage;
+    view.account = Load::Ready(codex_protocol::account::PlanType::Plus);
+    view.sections[Section::Usage].group = 3;
+    view.start_reports();
+    test_support::settle(&mut view).await;
+    assert_eq!(
+        (view.group_options(), view.sections[Section::Usage].group),
+        (&[0, 2][..], 0)
+    );
+    press(&mut view, KeyCode::Char('g'));
+    assert_eq!(view.sections[Section::Usage].group, 2);
+    press(&mut view, KeyCode::Char('g'));
+    assert_eq!(view.sections[Section::Usage].group, 0);
+}
+
+#[test]
+fn ungrouped_sections_preserve_configured_g_jump_top() {
+    let mut config = TuiKeymap::default();
+    config.list.jump_top = Some(KeybindingsSpec::One(KeybindingSpec("g".into())));
+    let keymap = RuntimeKeymap::from_config(&config).expect("valid list keymap");
+    let mut view = fixture::view(models::AccountKind::Enterprise);
+    view.keymap = keymap.list;
+    for section in [
+        Section::Chats,
+        Section::Plugins,
+        Section::Skills,
+        Section::Credits,
+    ] {
+        view.section = section;
+        press(&mut view, KeyCode::End);
+        assert!(view.sections[section].cursor > 0, "{section:?}");
+        press(&mut view, KeyCode::Char('g'));
+        assert_eq!(view.sections[section].cursor, 0, "{section:?}");
+    }
+}
+
+#[test]
+fn business_chats_display_only_supplied_dollars() {
+    let mut view = fixture::view(models::AccountKind::Enterprise);
+    let chats = match &mut view.chats {
+        Load::Ready(chats) => chats,
+        _ => panic!("fixture chats"),
+    };
+    for chat in &mut chats.rows {
+        if let Some(usage) = &mut chat.usage {
+            usage.estimated_usage_usd_micros = None;
+        }
+    }
+    press(&mut view, KeyCode::Char('6'));
+    assert!(!screen(&mut view, /*width*/ 100, /*height*/ 30).contains("Est. $ spent"));
+    if let Load::Ready(chats) = &mut view.chats {
+        chats.rows[0]
+            .usage
+            .as_mut()
+            .unwrap()
+            .estimated_usage_usd_micros = Some(123_450_000);
+    }
+    let dollars = screen(&mut view, /*width*/ 100, /*height*/ 30);
+    assert!(dollars.contains("$123.45") && dollars.contains("Est. $ spent"));
+    let narrow = screen(&mut view, /*width*/ 42, /*height*/ 30);
+    insta::assert_snapshot!(format!("{dollars}\n{narrow}"));
+}
+
+#[tokio::test]
+async fn unsupported_workspace_plans_hide_top_chats_and_skip_loading() {
+    for plan in [
+        "team",
+        "self_serve_business_prolite",
+        "self_serve_business_usage_based",
+        "enterprise",
+        "ent26",
+        "edu",
+        "edu_plus",
+        "edu_pro",
+    ] {
+        let server = test_support::server().await;
+        let (_home, _app_server, mut view) = client::tests::connected_view(&server, plan).await;
+        test_support::settle(&mut view).await;
+        assert_eq!(
+            view.visible_sections(),
+            &[
+                Section::Summary,
+                Section::Credits,
+                Section::Usage,
+                Section::Plugins,
+                Section::Skills
+            ],
+            "{plan}"
+        );
+        assert!(matches!(view.chats, Load::Unavailable), "{plan}");
+        let selected = view.section;
+        press(&mut view, KeyCode::Char('6'));
+        assert_eq!(view.section, selected);
+    }
+    for plan in [
+        "business",
+        "enterprise_cbp_usage_based",
+        "enterprise_cbp_automation",
+    ] {
+        let server = test_support::server().await;
+        let (_home, _app_server, mut view) = client::tests::connected_view(&server, plan).await;
+        test_support::settle(&mut view).await;
+        assert!(view.visible_sections().contains(&Section::Chats), "{plan}");
+        press(&mut view, KeyCode::Char('6'));
+        assert_eq!(view.section, Section::Chats);
+    }
+    let mut view = fixture::view(models::AccountKind::Enterprise);
+    view.account = Load::Ready(codex_protocol::account::PlanType::Enterprise);
+    insta::assert_snapshot!(screen(&mut view, /*width*/ 110, /*height*/ 24));
+}
+
+#[tokio::test]
+async fn unknown_plan_keeps_summary_available_without_billing_reports() {
+    let server = test_support::server().await;
+    wiremock::Mock::given(wiremock::matchers::method("GET"))
+        .and(wiremock::matchers::path("/backend-api/wham/profiles/me"))
+        .respond_with(
+            wiremock::ResponseTemplate::new(/*s*/ 200)
+                .set_body_json(serde_json::json!({"stats":{"lifetime_tokens":12345}})),
+        )
+        .expect(/*r*/ 1)
+        .mount(&server)
+        .await;
+    let (_home, _app_server, mut view) =
+        client::tests::connected_view(&server, "future-plan").await;
+    test_support::settle(&mut view).await;
+    assert_eq!(view.visible_sections(), &[Section::Summary]);
+    assert_eq!(
+        view.profile.ready().unwrap().stats.tokens.lifetime_tokens,
+        Some(12345)
+    );
+    assert!(
+        view.sections
+            .0
+            .iter()
+            .all(|section| matches!(section.history, Load::Unavailable))
+    );
+    let paths = server
+        .received_requests()
+        .await
+        .unwrap()
+        .into_iter()
+        .filter(|request| request.url.path().starts_with("/backend-api/wham/"))
+        .map(|request| request.url.path().to_owned())
+        .collect::<Vec<_>>();
+    assert_eq!(
+        paths,
+        [
+            "/backend-api/wham/accounts/check",
+            "/backend-api/wham/profiles/me"
+        ]
+    );
+    view.end_date = "2026-09-09".parse().unwrap();
+    let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(
+        /*width*/ 100, /*height*/ 40,
+    ))
+    .unwrap();
+    terminal
+        .draw(|frame| view.render(frame.area(), frame.buffer_mut()))
+        .unwrap();
+    insta::assert_snapshot!(terminal.backend().to_string());
+}
+
+#[test]
+fn navigation_keeps_its_row_when_sections_change() {
+    for width in [64, 120] {
+        let mut view = fixture::view(models::AccountKind::Consumer);
+        let mut positions = Vec::new();
+        for section in [
+            Section::Summary,
+            Section::Usage,
+            Section::Chats,
+            Section::Summary,
+        ] {
+            view.section = section;
+            let rendered = screen(&mut view, width, /*height*/ 40);
+            positions.push(
+                rendered
+                    .lines()
+                    .position(|line| line.contains("Summary") && line.contains("usage history"))
+                    .unwrap(),
+            );
+        }
+        assert_eq!(positions, vec![positions[0]; 4]);
+    }
+}
+
+#[test]
+fn taller_report_reveals_more_legend_rows_and_keeps_timestamp_in_footer() {
+    let mut view = fixture::view(models::AccountKind::Consumer);
+    view.section = Section::Usage;
+    let mut history = fixture::history(/*report*/ 0, /*range*/ 0, /*group*/ 1);
+    history.updated_at = Some(1_788_364_800);
+    for day in &mut history.data {
+        day.values = (0..10)
+            .map(|index| models::AccountAnalyticsValue {
+                key: format!("feature-{index}"),
+                label: format!("Feature {}", index + 1),
+                value: day.total / 10.0,
+            })
+            .collect();
+    }
+    view.sections[Section::Usage].history = data::Load::Ready(history);
+    let short = screen(&mut view, /*width*/ 120, /*height*/ 30);
+    let tall = screen(&mut view, /*width*/ 120, /*height*/ 60);
+    assert!(
+        tall.lines().filter(|line| line.contains('●')).count()
+            > short.lines().filter(|line| line.contains('●')).count()
+    );
+    assert!(
+        tall.lines()
+            .rev()
+            .take(3)
+            .any(|line| line.contains("Updated"))
+    );
+    insta::assert_snapshot!("legend_tall_report", tall);
+    for width in [24, 40, 64] {
+        let narrow = screen(&mut view, width, /*height*/ 60);
+        assert!(narrow.lines().last().unwrap().contains("UTC"));
+    }
+}

codex-rs/tui/src/analytics/account_plan_tests.rs

@@ -0,0 +1,167 @@
+//! Server plan discovery survives stale token claims and remains bound to the local identity.
+
+use super::tests::live;
+use super::tests::sign_in;
+use super::*;
+use pretty_assertions::assert_eq;
+use serde_json::json;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+use wiremock::Mock;
+use wiremock::MockServer;
+use wiremock::ResponseTemplate;
+use wiremock::matchers::header;
+use wiremock::matchers::method;
+use wiremock::matchers::path;
+
+#[tokio::test]
+async fn refresh_uses_server_plan_and_routes_with_unchanged_local_credentials() {
+    let server = MockServer::start().await;
+    let (_home, client) = live(&server, "plus").await;
+    let reads = Arc::new(AtomicUsize::new(/*v*/ 0));
+    let plan_reads = Arc::clone(&reads);
+    Mock::given(method("GET"))
+        .and(path("/backend-api/wham/accounts/check"))
+        .and(header("chatgpt-account-id", "account-a"))
+        .respond_with(move |_: &wiremock::Request| {
+            let plan = if plan_reads.fetch_add(/*val*/ 1, Ordering::SeqCst) == 0 {
+                "team"
+            } else {
+                "enterprise"
+            };
+            ResponseTemplate::new(/*s*/ 200).set_body_json(json!({
+                "accounts": [
+                    {"id": "other-account", "plan_type": "free"},
+                    {"id": "account-a", "plan_type": plan}
+                ],
+                "account_ordering": ["other-account", "account-a"]
+            }))
+        })
+        .with_priority(/*p*/ 1)
+        .expect(/*r*/ 2)
+        .mount(&server)
+        .await;
+    for endpoint in [
+        "/backend-api/wham/usage/daily-workspace-user-token-usage-breakdown",
+        "/backend-api/wham/usage/daily-workspace-user-credit-usage",
+    ] {
+        Mock::given(method("GET"))
+            .and(path(endpoint))
+            .and(header("chatgpt-account-id", "account-a"))
+            .respond_with(
+                ResponseTemplate::new(/*s*/ 200)
+                    .set_body_json(json!({"breakdown": "product", "series": [], "data": []})),
+            )
+            .expect(/*r*/ 1)
+            .mount(&server)
+            .await;
+    }
+    let first = client
+        .history(Report::Credits, /*days*/ 7, Grouping::Surface)
+        .await
+        .unwrap();
+    assert_eq!(client.session().await.unwrap().kind, AccountKind::Business);
+    assert_eq!(
+        client
+            .history(Report::Credits, /*days*/ 7, Grouping::Surface)
+            .await
+            .unwrap(),
+        first
+    );
+    assert_eq!(reads.load(Ordering::SeqCst), 1);
+    let refreshed = Live::new(Arc::clone(&client.config), client.end_date);
+    refreshed
+        .history(Report::Credits, /*days*/ 7, Grouping::Surface)
+        .await
+        .unwrap();
+    assert_eq!(
+        refreshed.session().await.unwrap().kind,
+        AccountKind::Enterprise
+    );
+    server.verify().await;
+}
+
+#[tokio::test]
+async fn account_plan_lookup_recovers_from_unauthorized() {
+    let server = MockServer::start().await;
+    let (_home, client) = live(&server, "plus").await;
+    let reads = AtomicUsize::new(/*v*/ 0);
+    Mock::given(method("GET"))
+        .and(path("/backend-api/wham/accounts/check"))
+        .and(header("chatgpt-account-id", "account-a"))
+        .respond_with(move |_: &wiremock::Request| {
+            if reads.fetch_add(/*val*/ 1, Ordering::SeqCst) == 0 {
+                ResponseTemplate::new(/*s*/ 401)
+            } else {
+                ResponseTemplate::new(/*s*/ 200).set_body_json(json!({
+                    "accounts": {"account-a": {"account": {
+                        "account_id": "account-a", "plan_type": "enterprise"
+                    }}},
+                    "account_ordering": ["account-a"]
+                }))
+            }
+        })
+        .with_priority(/*p*/ 1)
+        .expect(/*r*/ 2)
+        .mount(&server)
+        .await;
+    assert_eq!(
+        client.session().await.unwrap().kind,
+        AccountKind::Enterprise
+    );
+    server.verify().await;
+}
+
+#[tokio::test]
+async fn failed_plan_discovery_can_retry_without_using_token_plan() {
+    for response in [
+        ResponseTemplate::new(/*s*/ 503),
+        ResponseTemplate::new(/*s*/ 200).set_body_string("invalid account response"),
+        ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"accounts": [{"id": "account-a"}]})),
+        ResponseTemplate::new(/*s*/ 200).set_body_json(json!({
+            "accounts": [{"id": "other-account", "plan_type": "enterprise"}]
+        })),
+    ] {
+        let server = MockServer::start().await;
+        let (_home, client) = live(&server, "plus").await;
+        Mock::given(method("GET"))
+            .and(path("/backend-api/wham/accounts/check"))
+            .respond_with(response)
+            .with_priority(/*p*/ 1)
+            .expect(/*r*/ 1)
+            .up_to_n_times(/*n*/ 1)
+            .mount(&server)
+            .await;
+        assert_eq!(
+            client.session().await.err().unwrap(),
+            "Couldn't load account plan. Press R to retry Analytics."
+        );
+        assert_eq!(client.session().await.unwrap().kind, AccountKind::Consumer);
+        server.verify().await;
+    }
+}
+
+#[tokio::test]
+async fn account_plan_lookup_rejects_account_and_user_switches() {
+    for (account, user) in [("account-b", "user-a"), ("account-a", "user-b")] {
+        let server = MockServer::start().await;
+        let (home, client) = live(&server, "plus").await;
+        Mock::given(method("GET"))
+            .and(path("/backend-api/wham/accounts/check"))
+            .respond_with(move |_: &wiremock::Request| {
+                sign_in(home.path(), account, user, "plus");
+                ResponseTemplate::new(/*s*/ 200).set_body_json(json!({
+                    "accounts": [{"id": "account-a", "plan_type": "enterprise"}]
+                }))
+            })
+            .with_priority(/*p*/ 1)
+            .expect(/*r*/ 1)
+            .mount(&server)
+            .await;
+        assert_eq!(
+            client.session().await.err().unwrap(),
+            "Account changed. Press R to refresh Analytics."
+        );
+        server.verify().await;
+    }
+}

codex-rs/tui/src/analytics/activity_chart.rs

@@ -0,0 +1,319 @@
+//! Calendar and weekly token charts for the account Summary. Bucketing is independent of view state.
+
+mod palette;
+
+use std::collections::BTreeMap;
+
+use chrono::Datelike;
+use chrono::Duration;
+use chrono::NaiveDate;
+use ratatui::style::Style;
+use ratatui::style::Stylize;
+use ratatui::text::Line;
+use ratatui::text::Span;
+
+use crate::render::highlight::foreground_style_for_scopes;
+use palette::TokenActivityPalette;
+
+const WEEK_COUNT: usize = 52;
+const DAY_COUNT: usize = 7;
+const CELL_COUNT: usize = WEEK_COUNT * DAY_COUNT;
+const CHART_LEFT_WIDTH: usize = 4;
+
+/// Selects the aggregation represented by the token activity chart.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum TokenActivityView {
+    Daily,
+    Weekly,
+    Cumulative,
+}
+
+impl TokenActivityView {
+    /// Parses the optional `/usage` argument into a supported chart view.
+    ///
+    /// An empty argument selects Daily when a mode is requested. The bare `/usage`
+    /// command opens its menu. Returning `None` lets the slash-command dispatcher
+    /// report unsupported arguments instead of silently choosing a view.
+    pub(crate) fn parse(value: &str) -> Option<Self> {
+        match value.trim().to_ascii_lowercase().as_str() {
+            "" | "day" | "daily" => Some(Self::Daily),
+            "week" | "weekly" => Some(Self::Weekly),
+            "cumulative" => Some(Self::Cumulative),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn label(self) -> &'static str {
+        match self {
+            Self::Daily => "Daily",
+            Self::Weekly => "Weekly",
+            Self::Cumulative => "Cumulative",
+        }
+    }
+}
+
+pub(super) fn chart_lines(
+    view: TokenActivityView,
+    buckets: &[codex_backend_client::TokenUsageProfileDailyBucket],
+    today: NaiveDate,
+    width: u16,
+) -> Vec<Line<'static>> {
+    let mut lines = Vec::new();
+    let values = daily_values(buckets, today);
+    let shown_columns = shown_columns(width);
+    if shown_columns == 0 {
+        lines.push("   Widen terminal to show activity graph".dim().into());
+        return lines;
+    }
+
+    let palette = TokenActivityPalette::current();
+    let levels = levels_for_view(&values, view);
+    let first_column = WEEK_COUNT - shown_columns;
+    lines.push(month_labels(today, first_column, shown_columns));
+    for row in 0..DAY_COUNT {
+        let mut spans = vec![weekday_label(view, row)];
+        for column in first_column..WEEK_COUNT {
+            if column > first_column {
+                spans.push(" ".into());
+            }
+            let index = column * DAY_COUNT + row;
+            if view == TokenActivityView::Daily
+                && cell_date(today, index).is_some_and(|date| date > today)
+            {
+                spans.push(" ".into());
+            } else {
+                let style = if view == TokenActivityView::Daily {
+                    palette.for_level(levels[index])
+                } else {
+                    palette.for_bar_level(levels[index])
+                };
+                spans.push(Span::styled(palette.glyph(view, levels[index]), style));
+            }
+        }
+        lines.push(spans.into());
+    }
+    // Separate the calendar from the legend/footer below.
+    lines.push(Line::default());
+    match view {
+        TokenActivityView::Daily => lines.push(legend_line(&palette)),
+        TokenActivityView::Weekly | TokenActivityView::Cumulative => {
+            lines.push(bar_caption(view, &values))
+        }
+    }
+    lines
+}
+
+fn shown_columns(width: u16) -> usize {
+    (usize::from(width)
+        .saturating_sub(CHART_LEFT_WIDTH)
+        .saturating_add(/*rhs*/ 1)
+        / 2)
+    .min(WEEK_COUNT)
+}
+
+fn numeric_style() -> Style {
+    foreground_style_for_scopes(&["constant.numeric", "constant"])
+        .unwrap_or_else(|| Style::default().green())
+}
+
+fn label_style() -> Style {
+    foreground_style_for_scopes(&["comment"]).unwrap_or_else(|| Style::default().dim())
+}
+
+fn weekday_label(view: TokenActivityView, row: usize) -> Span<'static> {
+    if view != TokenActivityView::Daily {
+        // Bar views fill from the bottom (row 6) upward, so the gutter doubles
+        // as a coarse Y-axis: peak at the top, baseline at the bottom.
+        return Span::styled(
+            match row {
+                0 => "max ",
+                6 => "  0 ",
+                _ => "    ",
+            },
+            label_style(),
+        );
+    }
+    Span::styled(
+        match row {
+            0 => " Su ",
+            1 => " Mo ",
+            2 => " Tu ",
+            3 => " We ",
+            4 => " Th ",
+            5 => " Fr ",
+            6 => " Sa ",
+            _ => "    ",
+        },
+        label_style(),
+    )
+}
+
+fn legend_line(palette: &TokenActivityPalette) -> Line<'static> {
+    let mut spans = vec![Span::styled("   Less ", label_style())];
+    for level in 0..=4 {
+        if level > 0 {
+            spans.push(" ".into());
+        }
+        spans.push(Span::styled(
+            palette.glyph(TokenActivityView::Daily, level),
+            palette.for_level(level),
+        ));
+    }
+    spans.push(Span::styled(" More", label_style()));
+    spans.into()
+}
+
+/// Caption for the bar-chart views, where the 5-step daily legend would be
+/// misleading. States what each bar represents and the peak it is scaled to.
+fn bar_caption(view: TokenActivityView, values: &[i64]) -> Line<'static> {
+    let weeks = weekly_totals(values);
+    let (lead, peak) = match view {
+        TokenActivityView::Weekly => (
+            "Each column = 1 week · tallest ",
+            weeks.iter().copied().max().unwrap_or(/*default*/ 0),
+        ),
+        TokenActivityView::Cumulative => (
+            "Running total · top ",
+            weeks
+                .iter()
+                .fold(/*init*/ 0_i64, |sum, value| sum.saturating_add(*value)),
+        ),
+        TokenActivityView::Daily => ("", 0),
+    };
+    if peak <= 0 {
+        return Span::styled("   No token activity in the last 12 months", label_style()).into();
+    }
+    vec![
+        Span::styled(format!("   {lead}"), label_style()),
+        Span::styled(super::data::compact_amount(peak as f64), numeric_style()),
+    ]
+    .into()
+}
+
+fn month_labels(today: NaiveDate, first_column: usize, shown_columns: usize) -> Line<'static> {
+    let mut cells = vec![' '; shown_columns * 2 - 1];
+    let start = chart_start(today);
+    let mut last_end = 0;
+    for column in first_column..WEEK_COUNT {
+        let date = start + Duration::days((column * DAY_COUNT) as i64);
+        if date.day() > 7 {
+            continue;
+        }
+        let label = date.format("%b").to_string();
+        let offset = (column - first_column) * 2;
+        if offset < last_end || offset + label.len() > cells.len() {
+            continue;
+        }
+        for (index, ch) in label.chars().enumerate() {
+            cells[offset + index] = ch;
+        }
+        last_end = offset + label.len() + 1;
+    }
+    vec![
+        "    ".into(),
+        Span::styled(cells.into_iter().collect::<String>(), label_style()),
+    ]
+    .into()
+}
+
+/// Normalizes backend daily buckets into the fixed 52-week display window.
+///
+/// The returned vector is ordered by chart cell, starting with the oldest Sunday.
+/// Invalid, out-of-window, and future dates are ignored. Duplicate dates are
+/// accumulated and negative token values do not reduce activity.
+fn daily_values(
+    buckets: &[codex_backend_client::TokenUsageProfileDailyBucket],
+    today: NaiveDate,
+) -> Vec<i64> {
+    let start = chart_start(today);
+    let end = start + Duration::days(CELL_COUNT as i64);
+    let mut by_date = BTreeMap::new();
+    for bucket in buckets {
+        let Ok(date) = NaiveDate::parse_from_str(&bucket.start_date, "%Y-%m-%d") else {
+            continue;
+        };
+        if date < start || date >= end || date > today {
+            continue;
+        }
+        let value: &mut i64 = by_date.entry(date).or_insert(/*default*/ 0);
+        *value = value.saturating_add(bucket.tokens.max(/*other*/ 0));
+    }
+    (0..CELL_COUNT)
+        .map(|offset| {
+            by_date
+                .get(&(start + Duration::days(offset as i64)))
+                .copied()
+                .unwrap_or(/*default*/ 0)
+        })
+        .collect()
+}
+
+fn levels_for_view(values: &[i64], view: TokenActivityView) -> Vec<usize> {
+    match view {
+        TokenActivityView::Daily => graded_levels(values),
+        TokenActivityView::Weekly => bar_levels(&weekly_totals(values)),
+        TokenActivityView::Cumulative => {
+            let cumulative = weekly_totals(values)
+                .into_iter()
+                .scan(/*initial_state*/ 0, |sum, value| {
+                    *sum = i64::saturating_add(*sum, value);
+                    Some(*sum)
+                })
+                .collect::<Vec<_>>();
+            bar_levels(&cumulative)
+        }
+    }
+}
+
+fn graded_levels(values: &[i64]) -> Vec<usize> {
+    let max = values.iter().copied().max().unwrap_or(/*default*/ 0);
+    values
+        .iter()
+        .map(|value| match (*value, max) {
+            (0, _) | (_, 0) => 0,
+            (value, max) if i128::from(value) * 4 > i128::from(max) * 3 => 4,
+            (value, max) if i128::from(value) * 2 > i128::from(max) => 3,
+            (value, max) if i128::from(value) * 4 > i128::from(max) => 2,
+            _ => 1,
+        })
+        .collect()
+}
+
+fn weekly_totals(values: &[i64]) -> Vec<i64> {
+    values
+        .chunks(DAY_COUNT)
+        .map(|week| {
+            week.iter()
+                .fold(/*init*/ 0_i64, |sum, value| sum.saturating_add(*value))
+        })
+        .collect()
+}
+
+fn bar_levels(totals: &[i64]) -> Vec<usize> {
+    let max = totals.iter().copied().max().unwrap_or(/*default*/ 0);
+    totals
+        .iter()
+        .flat_map(|value| {
+            let height = if *value <= 0 || max <= 0 {
+                0
+            } else {
+                ((i128::from(*value) * DAY_COUNT as i128 + i128::from(max) - 1) / i128::from(max))
+                    as usize
+            };
+            (0..DAY_COUNT).map(move |row| if DAY_COUNT - row <= height { 4 } else { 0 })
+        })
+        .collect()
+}
+
+fn chart_start(today: NaiveDate) -> NaiveDate {
+    let week_start = today - Duration::days(i64::from(today.weekday().num_days_from_sunday()));
+    week_start - Duration::weeks((WEEK_COUNT - 1) as i64)
+}
+
+fn cell_date(today: NaiveDate, index: usize) -> Option<NaiveDate> {
+    chart_start(today).checked_add_signed(Duration::days(index as i64))
+}
+
+#[cfg(test)]
+#[path = "activity_chart_tests.rs"]
+mod tests;

codex-rs/tui/src/analytics/activity_chart/palette.rs

@@ -0,0 +1,151 @@
+//! Builds terminal-aware styles and glyph choices for token activity charts.
+//!
+//! The palette adapts theme colors to the active terminal color level while
+//! keeping chart-specific glyph policy local to the token activity renderer.
+
+use ratatui::style::Color;
+use ratatui::style::Style;
+
+use super::TokenActivityView;
+use crate::color::blend;
+use crate::render::highlight::foreground_style_for_scopes;
+use crate::style::accent_style;
+use crate::terminal_palette::StdoutColorLevel;
+use crate::terminal_palette::best_color_for_level;
+use crate::terminal_palette::default_bg;
+use crate::terminal_palette::default_fg;
+use crate::terminal_palette::stdout_color_level;
+
+// In low-color terminals we distinguish empty vs active cells by glyph (a
+// width-matched filled/hollow pair). In truecolor terminals the grid uses a
+// single glyph and lets color carry the intensity (GitHub-style), which keeps
+// the grid perfectly aligned and free of texture noise.
+const EMPTY_CELL_GLYPH: &str = "□";
+const ACTIVE_CELL_GLYPH: &str = "■";
+const BAR_CELL_GLYPH: &str = "█";
+
+/// Stores the terminal-specific styles and glyph strategy for token activity cells.
+pub(super) struct TokenActivityPalette {
+    styles: [Style; 5],
+    bar_style: Style,
+    /// True when the terminal supports a truecolor gradient, so the grid can
+    /// encode intensity purely by color and render every cell with a single
+    /// glyph. False on low-color terminals, where we fall back to a
+    /// filled/hollow glyph pair so empty and active cells stay distinguishable.
+    uses_color: bool,
+}
+
+impl TokenActivityPalette {
+    pub(super) fn current() -> Self {
+        Self::from_parts(
+            default_fg(),
+            default_bg(),
+            stdout_color_level(),
+            theme_activity_style(),
+        )
+    }
+
+    fn from_parts(
+        default_fg: Option<(u8, u8, u8)>,
+        default_bg: Option<(u8, u8, u8)>,
+        color_level: StdoutColorLevel,
+        active_style: Style,
+    ) -> Self {
+        let fallback_palette = || Self::fallback(active_style);
+        let (Some(fg), Some(bg), Some(anchor)) =
+            (default_fg, default_bg, activity_anchor_rgb(active_style))
+        else {
+            return fallback_palette();
+        };
+        if matches!(
+            color_level,
+            StdoutColorLevel::Ansi16 | StdoutColorLevel::Unknown
+        ) {
+            return fallback_palette();
+        }
+
+        let empty_alpha = if crate::color::is_light(bg) {
+            0.18
+        } else {
+            0.14
+        };
+        let alphas = [empty_alpha, 0.22, 0.42, 0.68, 1.00];
+        let styles = std::array::from_fn(|index| {
+            let color = if index == 0 {
+                blend(fg, bg, alphas[index])
+            } else {
+                blend(anchor, bg, alphas[index])
+            };
+            Style::default().fg(best_color_for_level(color, color_level))
+        });
+        let bar_style = Style::default().fg(best_color_for_level(
+            blend(anchor, bg, /*alpha*/ 0.78),
+            color_level,
+        ));
+        Self {
+            styles,
+            bar_style,
+            uses_color: true,
+        }
+    }
+
+    fn fallback(active_style: Style) -> Self {
+        let empty_style = Style::default().dim();
+        Self {
+            styles: [
+                empty_style,
+                active_style,
+                active_style,
+                active_style,
+                active_style,
+            ],
+            bar_style: active_style,
+            uses_color: false,
+        }
+    }
+
+    pub(super) fn for_level(&self, level: usize) -> Style {
+        self.styles[level.min(/*other*/ 4)]
+    }
+
+    pub(super) fn for_bar_level(&self, level: usize) -> Style {
+        if level == 0 {
+            self.for_level(/*level*/ 0)
+        } else {
+            self.bar_style
+        }
+    }
+
+    /// The glyph for a cell at `level`. Daily truecolor renders every visible
+    /// cell with the same square glyph and lets color carry the intensity; in
+    /// low-color we use the hollow glyph for empty cells so they remain visible
+    /// without a color gradient. Bar views use full blocks for filled height and
+    /// spaces for empty height so the silhouette reads as a column chart.
+    pub(super) fn glyph(&self, view: TokenActivityView, level: usize) -> &'static str {
+        if view != TokenActivityView::Daily {
+            return if level == 0 { " " } else { BAR_CELL_GLYPH };
+        }
+        if self.uses_color || level > 0 {
+            ACTIVE_CELL_GLYPH
+        } else {
+            EMPTY_CELL_GLYPH
+        }
+    }
+}
+
+fn theme_activity_style() -> Style {
+    foreground_style_for_scopes(&["entity.name.type", "support.type", "variable"])
+        .unwrap_or_else(accent_style)
+        .bold()
+}
+
+fn activity_anchor_rgb(style: Style) -> Option<(u8, u8, u8)> {
+    match style.fg? {
+        Color::Rgb(r, g, b) => Some((r, g, b)),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+#[path = "palette_tests.rs"]
+mod tests;

codex-rs/tui/src/analytics/activity_chart/palette_tests.rs

@@ -0,0 +1,115 @@
+use super::*;
+use crate::terminal_palette::rgb_color;
+use pretty_assertions::assert_eq;
+use ratatui::style::Modifier;
+
+#[test]
+fn truecolor_palette_blends_theme_accent_against_dark_background() {
+    let default_fg = Some((240, 240, 240));
+    let default_bg = Some((0, 0, 0));
+    let active_style = Style::default().fg(rgb_color((100, 200, 50))).bold();
+    let palette = TokenActivityPalette::from_parts(
+        default_fg,
+        default_bg,
+        StdoutColorLevel::TrueColor,
+        active_style,
+    );
+
+    assert_eq!(
+        palette.for_level(/*level*/ 0).fg,
+        Some(rgb_color((33, 33, 33)))
+    );
+    assert_eq!(
+        palette.for_level(/*level*/ 1).fg,
+        Some(rgb_color((22, 44, 11)))
+    );
+    assert_eq!(
+        palette.for_level(/*level*/ 4).fg,
+        Some(rgb_color((100, 200, 50)))
+    );
+    assert_eq!(
+        palette.for_bar_level(/*level*/ 4).fg,
+        Some(rgb_color((78, 156, 39)))
+    );
+    assert!(palette.uses_color);
+}
+
+#[test]
+fn truecolor_palette_blends_empty_cell_for_light_background() {
+    let default_fg = Some((0, 0, 0));
+    let default_bg = Some((255, 255, 255));
+    let active_style = Style::default().fg(rgb_color((0, 95, 135))).bold();
+    let palette = TokenActivityPalette::from_parts(
+        default_fg,
+        default_bg,
+        StdoutColorLevel::TrueColor,
+        active_style,
+    );
+
+    assert_eq!(
+        palette.for_level(/*level*/ 0).fg,
+        Some(rgb_color((209, 209, 209)))
+    );
+    assert_eq!(
+        palette.for_level(/*level*/ 4).fg,
+        Some(rgb_color((0, 95, 135)))
+    );
+    assert!(palette.uses_color);
+}
+
+#[test]
+fn ansi16_palette_uses_theme_accent_without_green_fallback() {
+    let default_fg = Some((240, 240, 240));
+    let default_bg = Some((0, 0, 0));
+    let active_style = Style::default().fg(Color::Magenta).bold();
+    let palette = TokenActivityPalette::from_parts(
+        default_fg,
+        default_bg,
+        StdoutColorLevel::Ansi16,
+        active_style,
+    );
+
+    assert_eq!(palette.for_level(/*level*/ 0), Style::default().dim());
+    assert_eq!(palette.for_level(/*level*/ 1), active_style);
+    assert_eq!(palette.for_bar_level(/*level*/ 4), active_style);
+    assert!(!palette.uses_color);
+}
+
+#[test]
+fn non_rgb_theme_accent_remains_active_fallback() {
+    let default_fg = Some((240, 240, 240));
+    let default_bg = Some((0, 0, 0));
+    let active_style = Style::default().fg(Color::Cyan).bold();
+    let palette = TokenActivityPalette::from_parts(
+        default_fg,
+        default_bg,
+        StdoutColorLevel::TrueColor,
+        active_style,
+    );
+
+    assert_eq!(palette.for_level(/*level*/ 1), active_style);
+    assert!(
+        palette
+            .for_level(/*level*/ 1)
+            .add_modifier
+            .contains(Modifier::BOLD)
+    );
+    assert!(!palette.uses_color);
+}
+
+#[test]
+fn missing_terminal_colors_use_theme_accent_fallback() {
+    let default_fg = None;
+    let default_bg = Some((0, 0, 0));
+    let active_style = Style::default().fg(Color::Blue).bold();
+    let palette = TokenActivityPalette::from_parts(
+        default_fg,
+        default_bg,
+        StdoutColorLevel::TrueColor,
+        active_style,
+    );
+
+    assert_eq!(palette.for_level(/*level*/ 0), Style::default().dim());
+    assert_eq!(palette.for_level(/*level*/ 4), active_style);
+    assert!(!palette.uses_color);
+}

codex-rs/tui/src/analytics/activity_chart_tests.rs

@@ -0,0 +1,239 @@
+//! Calendar, aggregation, and chart rendering regressions.
+use super::*;
+use codex_backend_client::TokenUsageProfileDailyBucket as AccountTokenUsageDailyBucket;
+use insta::assert_snapshot;
+use pretty_assertions::assert_eq;
+
+fn graph_width(width: u16) -> u16 {
+    if width == u16::MAX {
+        return width;
+    }
+    (CHART_LEFT_WIDTH + shown_columns(width) * 2 - 1) as u16
+}
+
+#[test]
+fn duplicate_dates_sum_and_negative_values_clamp() {
+    let today =
+        NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 5, /*day*/ 29).expect("valid date");
+    let buckets = vec![
+        AccountTokenUsageDailyBucket {
+            start_date: "2026-05-29".to_string(),
+            tokens: 10,
+        },
+        AccountTokenUsageDailyBucket {
+            start_date: "2026-05-29".to_string(),
+            tokens: 5,
+        },
+        AccountTokenUsageDailyBucket {
+            start_date: "2026-05-28".to_string(),
+            tokens: -4,
+        },
+    ];
+
+    let values = daily_values(&buckets, today);
+
+    assert_eq!(values.iter().sum::<i64>(), 15);
+}
+
+#[test]
+fn bar_levels_fill_from_bottom() {
+    let levels = bar_levels(&[0, 10]);
+
+    assert_eq!(&levels[..DAY_COUNT], &[0; DAY_COUNT]);
+    assert_eq!(&levels[DAY_COUNT..], &[4; DAY_COUNT]);
+}
+
+#[test]
+fn token_activity_view_aliases_parse() {
+    assert_eq!(TokenActivityView::parse(""), Some(TokenActivityView::Daily));
+    assert_eq!(
+        TokenActivityView::parse("day"),
+        Some(TokenActivityView::Daily)
+    );
+    assert_eq!(
+        TokenActivityView::parse("week"),
+        Some(TokenActivityView::Weekly)
+    );
+    assert_eq!(
+        TokenActivityView::parse("cumulative"),
+        Some(TokenActivityView::Cumulative)
+    );
+    assert_eq!(TokenActivityView::parse("year"), None);
+}
+
+#[test]
+fn daily_graph_snapshot_uses_distinct_empty_and_active_cells() {
+    let today =
+        NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 5, /*day*/ 29).expect("valid date");
+    let buckets = vec![
+        AccountTokenUsageDailyBucket {
+            start_date: "2026-05-25".to_string(),
+            tokens: 1,
+        },
+        AccountTokenUsageDailyBucket {
+            start_date: "2026-05-29".to_string(),
+            tokens: 4,
+        },
+    ];
+
+    let rendered = chart_lines(TokenActivityView::Daily, &buckets, today, /*width*/ 22)
+        .into_iter()
+        .map(|line| line.to_string().trim_end().to_string())
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    assert_snapshot!(rendered, @r"
+         Apr     May
+    Su □ □ □ □ □ □ □ □ □
+    Mo □ □ □ □ □ □ □ □ ■
+    Tu □ □ □ □ □ □ □ □ □
+    We □ □ □ □ □ □ □ □ □
+    Th □ □ □ □ □ □ □ □ □
+    Fr □ □ □ □ □ □ □ □ ■
+    Sa □ □ □ □ □ □ □ □
+
+      Less □ ■ ■ ■ ■ More
+    ");
+}
+
+#[test]
+fn daily_graph_snapshot_stays_left_aligned_in_wide_terminal() {
+    assert_eq!(graph_width(/*width*/ 160), 107);
+    assert_eq!(graph_width(/*width*/ u16::MAX), u16::MAX);
+
+    let today =
+        NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 5, /*day*/ 29).expect("valid date");
+    let lines = chart_lines(TokenActivityView::Daily, &[], today, /*width*/ 160);
+    let rendered = [&lines[0], &lines[1], lines.last().expect("legend line")]
+        .into_iter()
+        .map(|line| line.to_string().trim_end().to_string())
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    assert_snapshot!(rendered, @"
+       Jun       Jul     Aug       Sep     Oct     Nov       Dec     Jan     Feb     Mar       Apr     May
+    Su □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □
+      Less □ ■ ■ ■ ■ More
+    ");
+}
+
+#[test]
+fn weekly_graph_snapshot_renders_bar_chart_and_caption() {
+    let today =
+        NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 5, /*day*/ 29).expect("valid date");
+    let buckets = vec![
+        AccountTokenUsageDailyBucket {
+            start_date: "2026-05-11".to_string(),
+            tokens: 3,
+        },
+        AccountTokenUsageDailyBucket {
+            start_date: "2026-05-18".to_string(),
+            tokens: 6,
+        },
+        AccountTokenUsageDailyBucket {
+            start_date: "2026-05-25".to_string(),
+            tokens: 9,
+        },
+    ];
+
+    let rendered = chart_lines(
+        TokenActivityView::Weekly,
+        &buckets,
+        today,
+        /*width*/ 22,
+    )
+    .into_iter()
+    .map(|line| line.to_string().trim_end().to_string())
+    .collect::<Vec<_>>()
+    .join("\n");
+
+    assert_snapshot!(rendered, @"
+          Apr     May
+    max                 █
+                        █
+                      █ █
+                      █ █
+                    █ █ █
+                    █ █ █
+      0             █ █ █
+
+       Each column = 1 week · tallest 9
+     ");
+}
+
+#[test]
+fn cumulative_graph_snapshot_renders_running_total_bar_chart_and_caption() {
+    let today =
+        NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 5, /*day*/ 29).expect("valid date");
+    let buckets = vec![
+        AccountTokenUsageDailyBucket {
+            start_date: "2026-05-11".to_string(),
+            tokens: 3,
+        },
+        AccountTokenUsageDailyBucket {
+            start_date: "2026-05-18".to_string(),
+            tokens: 6,
+        },
+        AccountTokenUsageDailyBucket {
+            start_date: "2026-05-25".to_string(),
+            tokens: 9,
+        },
+    ];
+
+    let rendered = chart_lines(
+        TokenActivityView::Cumulative,
+        &buckets,
+        today,
+        /*width*/ 22,
+    )
+    .into_iter()
+    .map(|line| line.to_string().trim_end().to_string())
+    .collect::<Vec<_>>()
+    .join("\n");
+
+    assert_snapshot!(rendered, @"
+          Apr     May
+    max                 █
+                        █
+                        █
+                      █ █
+                      █ █
+                    █ █ █
+      0             █ █ █
+
+       Running total · top 18
+     ");
+}
+
+#[test]
+fn year_window_ignores_other_dates_and_saturates_extreme_totals() {
+    let today: NaiveDate = "2026-09-09".parse().unwrap();
+    let buckets = [
+        ("2025-01-01", 100),
+        ("2026-09-10", 100),
+        ("invalid", 100),
+        ("2026-09-08", i64::MAX),
+        ("2026-09-08", i64::MAX),
+        ("2026-09-09", i64::MAX),
+    ]
+    .map(|(date, tokens)| AccountTokenUsageDailyBucket {
+        start_date: date.into(),
+        tokens,
+    });
+    let values = daily_values(&buckets, today);
+    let mut expected = vec![0; CELL_COUNT];
+    let index = (today - chart_start(today)).num_days() as usize;
+    expected[index - 1] = i64::MAX;
+    expected[index] = i64::MAX;
+    assert_eq!(values, expected);
+    for view in [
+        TokenActivityView::Daily,
+        TokenActivityView::Weekly,
+        TokenActivityView::Cumulative,
+    ] {
+        let levels = levels_for_view(&values, view);
+        assert!(levels.iter().all(|level| *level <= 4));
+        assert!(levels.contains(&4));
+        assert!(!chart_lines(view, &buckets, today, /*width*/ 110).is_empty());
+    }
+}

codex-rs/tui/src/analytics/chart.rs

@@ -0,0 +1,338 @@
+//! Daily history with a stable chart and a compact, separated breakdown table.
+//! Chart series rank by the full range; table rows rank by the selected day and retain series colors.
+//! Missing and zero days retain the same row count; only viewport changes and explicit expansion change height.
+
+use super::AnalyticsView;
+use super::data;
+use super::plot;
+use super::render::categories;
+use super::render::columns;
+use super::styles::number;
+use super::styles::secondary_style;
+use super::styles::series_colors;
+use crate::analytics::models::AccountAnalyticsUnit;
+use crate::analytics::models::AccountAnalyticsValue;
+use crate::analytics::sections::Section;
+use crate::line_truncation::truncate_line_with_ellipsis_if_overflow;
+use ratatui::style::Styled;
+use ratatui::style::Stylize;
+use ratatui::text::Line;
+
+impl AnalyticsView {
+    pub(super) fn day_has_details(&self, section: Section, day_index: usize) -> bool {
+        let Some(history) = self.sections[section].history.ready() else {
+            return false;
+        };
+        let date = self
+            .section_date_range(section)
+            .start()
+            .iter_days()
+            .nth(day_index);
+        history.data.iter().any(|day| {
+            date.is_some_and(|date| day.date == date)
+                && day.values.iter().any(|value| value.value != 0.0)
+        })
+    }
+
+    pub(super) fn history_lines(
+        &self,
+        section: Section,
+        width: usize,
+        height: usize,
+    ) -> plot::Chart {
+        let state = &self.sections[section].history;
+        let Some(history) = state.ready() else {
+            return plot::Chart {
+                lines: state
+                    .message()
+                    .into_iter()
+                    .map(|message| message.to_string().set_style(secondary_style()).into())
+                    .collect(),
+                bands: 0,
+            };
+        };
+        if history.data.is_empty() {
+            return plot::Chart {
+                lines: vec![
+                    "No data reported for this range."
+                        .set_style(secondary_style())
+                        .into(),
+                ],
+                bands: 0,
+            };
+        }
+        let range = self.section_date_range(section);
+        // At most 30 daily slots; index by date if report ranges grow.
+        let days = range
+            .start()
+            .iter_days()
+            .take_while(|date| date <= range.end())
+            .map(|date| {
+                let day = history.data.iter().find(|day| day.date == date);
+                (date, day)
+            })
+            .collect::<Vec<_>>();
+        let cursor = self.sections[section].cursor.min(days.len() - 1);
+        let selected_date = days[cursor].0.format("%b %-d").to_string();
+        let day = days[cursor].1;
+        let expanded = self.zoomed && self.sections[section].detail.is_some();
+        let colors = series_colors();
+        let mut categories = categories(history);
+        if matches!(section, Section::Plugins | Section::Skills) {
+            for category in &mut categories {
+                category.label = super::tool_panel::tool_name(&category.label);
+            }
+        }
+        if self.sections[section].group == 2 {
+            for category in &mut categories {
+                category.label = self.model_name(&category.label).to_string();
+            }
+        }
+        let unit = match section {
+            Section::Usage if history.unit == AccountAnalyticsUnit::Tokens => "tokens",
+            Section::Summary => "tokens",
+            Section::Activity => "messages",
+            Section::Plugins => "calls",
+            Section::Skills => "uses",
+            Section::Usage | Section::Credits | Section::Chats | Section::Plan => "credits",
+        };
+        let empty_breakdown = matches!(
+            section,
+            Section::Plugins | Section::Activity | Section::Skills
+        ) && day.is_none_or(|day| {
+            day.total == 0.0 && day.values.iter().all(|value| value.value == 0.0)
+        });
+        let relative = history.unit == AccountAnalyticsUnit::RelativeUsage;
+        let format_amount = if history.unit == AccountAnalyticsUnit::Credits {
+            data::credit_amount
+        } else {
+            data::amount
+        };
+        let total: f64 = history.data.iter().map(|day| day.total).sum();
+        let formatted_total = if total.abs() >= 1_000.0 {
+            data::compact_amount(total)
+        } else {
+            format_amount(total)
+        };
+        let mut lines = vec![if relative {
+            "Total usage · relative units"
+                .set_style(secondary_style())
+                .into()
+        } else {
+            number(format!(
+                "{} {}{unit}",
+                formatted_total,
+                if section == Section::Activity {
+                    "reported "
+                } else {
+                    ""
+                }
+            ))
+            .into()
+        }];
+        if section == Section::Usage && !self.business() && self.zoomed {
+            lines.push(
+                "Approximate · may be delayed up to 6 hours"
+                    .set_style(secondary_style())
+                    .into(),
+            );
+        }
+        if self.sections[section].group == 3 {
+            lines.push(
+                "All usage by how each turn started"
+                    .set_style(secondary_style())
+                    .into(),
+            );
+        }
+        let has_activity = history
+            .data
+            .iter()
+            .any(|day| day.total != 0.0 || day.values.iter().any(|value| value.value != 0.0));
+        let mut bands = 0;
+        if has_activity {
+            let chart = plot::chart(&days, &categories, cursor, width, height, history.unit);
+            bands = chart.bands;
+            lines.extend(chart.lines);
+        } else {
+            lines.push(
+                if matches!(
+                    section,
+                    Section::Plugins | Section::Activity | Section::Skills
+                ) {
+                    format!("No {unit} reported in this range.")
+                        .set_style(secondary_style())
+                        .into()
+                } else {
+                    "No activity reported in this range."
+                        .set_style(secondary_style())
+                        .into()
+                },
+            );
+        }
+
+        let table_width = width.min(/*other*/ 56);
+        lines.push(Line::default());
+        if self.zoomed {
+            lines.push("─".repeat(table_width).dim().into());
+        }
+        let table_start = lines.len();
+        let summary = match day {
+            None => " · Not reported".set_style(secondary_style()),
+            Some(day) if day.total == 0.0 && day.values.iter().all(|value| value.value == 0.0) => {
+                " · No activity (0)".set_style(secondary_style())
+            }
+            Some(day) if relative => number(format!(" · {} usage units", data::amount(day.total))),
+            Some(day) => number(format!(
+                " · {} {unit}",
+                if expanded {
+                    day.total.to_string()
+                } else {
+                    format_amount(day.total)
+                }
+            )),
+        };
+        lines.push(truncate_line_with_ellipsis_if_overflow(
+            vec![selected_date.clone().bold(), summary].into(),
+            width,
+        ));
+        if self.zoomed {
+            lines.push(columns(
+                match section {
+                    Section::Plugins => "Plugin",
+                    Section::Skills => "Skill",
+                    Section::Chats => "Chat",
+                    Section::Summary
+                    | Section::Usage
+                    | Section::Credits
+                    | Section::Activity
+                    | Section::Plan => self.group_label(section, self.sections[section].group),
+                }
+                .bold()
+                .into(),
+                if history.unit == AccountAnalyticsUnit::Tokens {
+                    "Tokens"
+                } else if section == Section::Usage {
+                    "Share"
+                } else if section == Section::Activity {
+                    "Messages"
+                } else if section == Section::Plugins {
+                    "Calls"
+                } else if section == Section::Skills {
+                    "Uses"
+                } else {
+                    "Credits"
+                }
+                .bold()
+                .into(),
+                table_width,
+            ));
+        }
+        let mut values = categories
+            .iter()
+            .enumerate()
+            .map(|(index, category)| {
+                (
+                    index,
+                    AccountAnalyticsValue {
+                        value: day
+                            .and_then(|day| {
+                                day.values.iter().find(|value| value.key == category.key)
+                            })
+                            .map_or(/*default*/ 0.0, |value| value.value),
+                        ..category.clone()
+                    },
+                )
+            })
+            .collect::<Vec<_>>();
+        values.sort_by(|(_, a), (_, b)| b.value.abs().total_cmp(&a.value.abs()));
+        let row_budget = if self.zoomed {
+            (self.viewport_height / 4).max(/*other*/ 4)
+        } else {
+            4
+        };
+        let remainder = if !expanded && values.len() > row_budget {
+            let remaining = values.split_off(row_budget - 1);
+            Some((
+                format!("{} more", remaining.len()),
+                remaining.iter().map(|(_, value)| value.value).sum::<f64>(),
+            ))
+        } else {
+            None
+        };
+        let rows = values
+            .iter()
+            .map(|(index, value)| {
+                (
+                    Line::from(vec![
+                        "● ".fg(colors[(*index).min(/*other*/ 3)]),
+                        value.label.clone().into(),
+                    ]),
+                    value.value,
+                )
+            })
+            .chain(
+                remainder.map(|(label, value)| (Line::from(vec!["… ".dim(), label.dim()]), value)),
+            );
+        for (label, value) in rows.take(if self.zoomed { usize::MAX } else { 2 }) {
+            let amount = match day {
+                None => "—".into(),
+                Some(day)
+                    if section == Section::Usage
+                        && history.unit != AccountAnalyticsUnit::Tokens =>
+                {
+                    format!(
+                        "{:.1}%",
+                        if day.total == 0.0 {
+                            0.0
+                        } else {
+                            value / day.total * 100.0
+                        }
+                    )
+                }
+                Some(_) if expanded => value.to_string(),
+                Some(_) => format_amount(value),
+            };
+            lines.push(columns(
+                truncate_line_with_ellipsis_if_overflow(
+                    label,
+                    table_width.saturating_sub(amount.len() + 2),
+                ),
+                if day.is_none() || value == 0.0 {
+                    amount.dim()
+                } else {
+                    amount.into()
+                }
+                .into(),
+                table_width,
+            ));
+        }
+        if empty_breakdown {
+            // Preserve the measured table allocation when the selected day has no breakdown.
+            let table_end = lines.len();
+            lines.truncate(table_start);
+            lines.push(truncate_line_with_ellipsis_if_overflow(
+                if day.is_none() {
+                    format!("Data not reported for {selected_date}.")
+                } else {
+                    format!("No {unit} reported for {selected_date}.")
+                }
+                .set_style(secondary_style())
+                .into(),
+                width,
+            ));
+            lines.resize(table_end, Line::default());
+        }
+        if !self.zoomed
+            && let Some(updated) = history
+                .updated_at
+                .and_then(|value| chrono::DateTime::from_timestamp(value, /*nsecs*/ 0))
+        {
+            lines.push(
+                format!("Updated {} UTC", updated.format("%b %-d %H:%M"))
+                    .set_style(secondary_style())
+                    .into(),
+            );
+        }
+        plot::Chart { lines, bands }
+    }
+}

codex-rs/tui/src/analytics/chat_panel.rs

@@ -0,0 +1,317 @@
+//! Bounded chat tables with inline credit breakdowns and a viewport-sized row window.
+//! Zero-credit groups are optional; missing dimensions and signed adjustments stay distinct.
+
+use super::AnalyticsView;
+use super::data;
+use super::render::columns;
+use super::styles::number;
+use super::styles::secondary_style;
+use crate::analytics::sections::Section;
+use crate::line_truncation::truncate_line_with_ellipsis_if_overflow;
+use crate::style::accent_style;
+use crate::wrapping::RtOptions;
+use crate::wrapping::word_wrap_lines;
+use ratatui::style::Styled;
+use ratatui::style::Stylize;
+use ratatui::text::Line;
+use std::ops::Range;
+
+impl AnalyticsView {
+    pub(super) fn chat_lines(&self, width: usize) -> (Vec<Line<'static>>, Range<usize>) {
+        let width = width.clamp(/*min*/ 1, /*max*/ 96);
+        let wrap = |lines: Vec<Line<'static>>| word_wrap_lines(lines, RtOptions::new(width));
+        let mut lines = wrap(vec![
+            "Active in past 30 days · sorted by lifetime credits"
+                .set_style(secondary_style())
+                .into(),
+        ]);
+        if let Some(message) = self.chats.message() {
+            lines.extend(wrap(vec![
+                message.to_string().set_style(secondary_style()).into(),
+            ]));
+        }
+        let Some(chats) = self.chats.ready() else {
+            return (lines, 0..1);
+        };
+        if chats.rows.is_empty() {
+            lines.extend(wrap(vec![
+                "No recent local chats.".set_style(secondary_style()).into(),
+            ]));
+            return (lines, 0..1);
+        }
+        let missing = chats.rows.iter().filter(|row| row.usage.is_none()).count();
+        if missing > 0 {
+            lines.extend(wrap(vec![
+                format!(
+                    "{missing} chat estimate{} unavailable",
+                    if missing == 1 { "" } else { "s" }
+                )
+                .set_style(secondary_style())
+                .into(),
+            ]));
+        }
+        lines.push(Line::default());
+        let show_usd = chats.rows.iter().any(|chat| {
+            chat.usage
+                .as_ref()
+                .is_some_and(|usage| usage.estimated_usage_usd_micros.is_some())
+        });
+        let stacked_amounts = show_usd && width < 70;
+        lines.extend(wrap(vec![columns(
+            "  Chat".bold().into(),
+            if stacked_amounts {
+                "Est. $ / credits"
+            } else if show_usd {
+                "Est. $ spent  Lifetime credits"
+            } else {
+                "Lifetime credits"
+            }
+            .bold()
+            .into(),
+            width,
+        )]));
+        let rows = chats
+            .rows
+            .iter()
+            .enumerate()
+            .map(|(index, chat)| {
+                let selected =
+                    self.section == Section::Chats && index == self.sections[Section::Chats].cursor;
+                let amount = chat.usage.as_ref().map_or_else(
+                    || "—".into(),
+                    |usage| data::credits(usage.estimated_usage_credits_micros),
+                );
+                let amount = if show_usd {
+                    let usd = chat
+                        .usage
+                        .as_ref()
+                        .and_then(|usage| usage.estimated_usage_usd_micros)
+                        .map(|micros| format!("${:.2}", micros as f64 / 1_000_000.0))
+                        .unwrap_or_else(|| "—".into());
+                    format!("{usd:>12}  {amount:>16}")
+                } else {
+                    amount
+                };
+                let label = format!(
+                    "{} {}",
+                    if selected { "›" } else { " " },
+                    chat.display_title()
+                );
+                let label: Line<'static> = if selected {
+                    label.set_style(accent_style()).into()
+                } else {
+                    label.into()
+                };
+                let label_width = if stacked_amounts {
+                    width
+                } else {
+                    width.saturating_sub(amount.len() + 1)
+                };
+                let truncated = label.width() > label_width;
+                let mut row = if stacked_amounts {
+                    vec![
+                        truncate_line_with_ellipsis_if_overflow(label, label_width),
+                        format!("  {}", amount.trim()).into(),
+                    ]
+                } else {
+                    vec![columns(
+                        truncate_line_with_ellipsis_if_overflow(label, label_width),
+                        if chat.usage.is_none() {
+                            amount.set_style(secondary_style()).into()
+                        } else if selected {
+                            number(amount).into()
+                        } else {
+                            amount.into()
+                        },
+                        width,
+                    )]
+                };
+                if self.sections[Section::Chats].detail == Some(index)
+                    && let Some(usage) = &chat.usage
+                {
+                    row.push(
+                        format!("  {}", "─".repeat(width.saturating_sub(/*rhs*/ 2)))
+                            .dim()
+                            .into(),
+                    );
+                    if truncated {
+                        row.extend(word_wrap_lines(
+                            [chat.display_title().to_string().bold()],
+                            RtOptions::new(width)
+                                .initial_indent("    ".into())
+                                .subsequent_indent("    ".into()),
+                        ));
+                    }
+                    let zeros = usage
+                        .groups
+                        .iter()
+                        .filter(|group| group.estimated_usage_credits_micros == 0)
+                        .count();
+                    let mut groups = usage
+                        .groups
+                        .iter()
+                        .filter(|group| {
+                            self.show_zero_credit_groups
+                                || group.estimated_usage_credits_micros != 0
+                        })
+                        .collect::<Vec<_>>();
+                    groups.sort_by_key(|group| {
+                        std::cmp::Reverse(group.estimated_usage_credits_micros)
+                    });
+                    // On narrow terminals, retain every dimension on a second line.
+                    let table = width >= 70;
+                    if !groups.is_empty() {
+                        row.push(columns(
+                            if table {
+                                format!(
+                                    "  {:<model_width$}  {:<12}  {:<12}",
+                                    "Model",
+                                    "Effort",
+                                    "Speed",
+                                    model_width = width - 46
+                                )
+                                .set_style(secondary_style())
+                                .into()
+                            } else {
+                                "  Model / effort / speed"
+                                    .set_style(secondary_style())
+                                    .into()
+                            },
+                            "Credits".bold().into(),
+                            width,
+                        ));
+                    }
+                    for group in groups {
+                        let model =
+                            self.model_name(group.model.as_deref().unwrap_or("Not reported"));
+                        let effort = group.reasoning_effort.as_deref().unwrap_or("Not reported");
+                        let speed = group.speed.as_deref().unwrap_or("Not reported");
+                        let amount = data::credits(group.estimated_usage_credits_micros);
+                        let label = if table {
+                            // Wrap long model names instead of hiding distinctions between groups.
+                            let model_width = width - 46;
+                            let models = textwrap::wrap(model, model_width);
+                            for model in models.iter().take(models.len().saturating_sub(/*rhs*/ 1))
+                            {
+                                row.push(format!("  {model}").bold().into());
+                            }
+                            vec![
+                                format!(
+                                    "  {:<model_width$}",
+                                    models
+                                        .last()
+                                        .map(std::convert::AsRef::as_ref)
+                                        .unwrap_or_default()
+                                )
+                                .bold(),
+                                format!("  {effort:<12}  {speed:<12}").set_style(secondary_style()),
+                            ]
+                            .into()
+                        } else {
+                            let label = Line::from(format!("  {model}").bold());
+                            if label.width() + amount.len() + 1 > width {
+                                row.push(label);
+                                "  ".into()
+                            } else {
+                                label
+                            }
+                        };
+                        row.push(columns(label, amount.into(), width));
+                        if !table {
+                            row.push(
+                                format!("    {effort} · {speed}")
+                                    .set_style(secondary_style())
+                                    .into(),
+                            );
+                        }
+                    }
+                    if usage.groups.is_empty() {
+                        row.push(
+                            "  Breakdown unavailable"
+                                .set_style(secondary_style())
+                                .into(),
+                        );
+                    }
+                    if zeros > 0 {
+                        row.push(
+                            format!(
+                                "  {zeros} zero-credit {}{} · a {}",
+                                if zeros == 1 { "group" } else { "groups" },
+                                if self.show_zero_credit_groups {
+                                    ""
+                                } else {
+                                    " hidden"
+                                },
+                                if self.show_zero_credit_groups {
+                                    "hide zeros"
+                                } else {
+                                    "show all"
+                                },
+                            )
+                            .set_style(secondary_style())
+                            .into(),
+                        );
+                    }
+                    row.push(Line::default());
+                }
+                wrap(row)
+            })
+            .collect::<Vec<_>>();
+        let coverage = wrap(vec![
+            "Local chats · excludes archived chats and subagent usage"
+                .set_style(secondary_style())
+                .into(),
+        ]);
+        self.chat_window(lines, rows, coverage, width)
+    }
+
+    pub(super) fn chat_window(
+        &self,
+        mut lines: Vec<Line<'static>>,
+        rows: Vec<Vec<Line<'static>>>,
+        coverage: Vec<Line<'static>>,
+        width: usize,
+    ) -> (Vec<Line<'static>>, Range<usize>) {
+        let wrap = |lines: Vec<Line<'static>>| word_wrap_lines(lines, RtOptions::new(width));
+        let count = rows.len();
+        let range_height = wrap(vec![
+            format!("Showing {count}–{count} of {count} chats").into(),
+        ])
+        .len();
+        // Measure wrapped details before choosing neighbors so the range describes the rendered rows.
+        let budget = if self.zoomed {
+            self.viewport_height
+                .saturating_sub(lines.len() + coverage.len() + range_height + 4)
+        } else {
+            usize::MAX
+        };
+        let row_limit = if self.zoomed { count } else { 5 };
+        let cursor = self.sections[Section::Chats].cursor.min(count - 1);
+        let mut first = cursor;
+        let mut end = cursor + 1;
+        let mut used = rows[cursor].len();
+        while first > 0 && end - first < row_limit && used + rows[first - 1].len() <= budget {
+            first -= 1;
+            used += rows[first].len();
+        }
+        while end < count && end - first < row_limit && used + rows[end].len() <= budget {
+            used += rows[end].len();
+            end += 1;
+        }
+        let mut selection = 0..1;
+        for (index, row) in rows.into_iter().enumerate().take(end).skip(first) {
+            if index == cursor {
+                selection = lines.len()..lines.len() + row.len();
+            }
+            lines.extend(row);
+        }
+        lines.push(Line::default());
+        lines.extend(wrap(vec![
+            format!("Showing {}–{end} of {count} chats", first + 1)
+                .set_style(secondary_style())
+                .into(),
+        ]));
+        lines.extend(coverage);
+        (lines, selection)
+    }
+}

codex-rs/tui/src/analytics/chat_panel_tests.rs

@@ -0,0 +1,215 @@
+//! Chat list coverage, responsive expansion, and controls for fixed-period data.
+
+use super::*;
+use pretty_assertions::assert_eq;
+
+#[test]
+fn chats_range_controls_and_visible_rows() {
+    let mut view = fixture::view(models::AccountKind::Enterprise);
+    let mut chats = fixture::chats();
+    let usage = chats.rows[0].usage.clone();
+    chats.rows = (1..=30)
+        .map(|index| chats::Chat {
+            title: format!("Chat {index:02}"),
+            usage: usage.clone(),
+        })
+        .collect();
+    view.chats = Load::Ready(chats);
+    press(&mut view, KeyCode::Char('6'));
+    let before = (
+        view.ranges,
+        view.sections.0.each_ref().map(|state| state.cursor),
+        view.sections.0.each_ref().map(|state| state.detail),
+    );
+    press(&mut view, KeyCode::Char('r'));
+    assert_eq!(
+        (
+            view.ranges,
+            view.sections.0.each_ref().map(|state| state.cursor),
+            view.sections.0.each_ref().map(|state| state.detail)
+        ),
+        before
+    );
+    let mut screens = Vec::new();
+    for key in [KeyCode::Home, KeyCode::End, KeyCode::Enter] {
+        press(&mut view, key);
+        let output = screen(&mut view, /*width*/ 110, /*height*/ 24);
+        assert!(!output.contains("7d") && !output.contains("r 7/30d"));
+        let visible = (1..=30)
+            .filter(|index| output.contains(&format!("Chat {index:02}")))
+            .collect::<Vec<_>>();
+        assert!(output.contains(&format!(
+            "Showing {}–{} of 30 chats",
+            visible.first().unwrap(),
+            visible.last().unwrap()
+        )));
+        screens.push(output);
+    }
+    press(&mut view, KeyCode::Char('z'));
+    press(&mut view, KeyCode::Char('r'));
+    assert_eq!(view.ranges, [0; 3]);
+    press(&mut view, KeyCode::Char('2'));
+    press(&mut view, KeyCode::Char('r'));
+    press(&mut view, KeyCode::Char('z'));
+    assert!(screen(&mut view, /*width*/ 110, /*height*/ 24).contains("[30d]"));
+    insta::assert_snapshot!(screens.join("\n"));
+}
+
+#[test]
+fn chats_breakdown_ranks_nonzero_groups_and_reflows() {
+    let mut view = fixture::view(models::AccountKind::Enterprise);
+    let mut chats = fixture::chats();
+    let usage = chats.rows[0].usage.as_mut().unwrap();
+    let seed = usage.groups[0].clone();
+    usage.groups = [
+        ("Zero model", 0),
+        ("Small model", 215_610_920),
+        ("Top model", 19_134_430_635),
+        ("Refund model", -4),
+    ]
+    .map(
+        |(model, credits)| codex_backend_client::ThreadUsageBreakdownGroup {
+            model: Some(model.into()),
+            speed: (credits != 19_134_430_635).then(|| "standard".into()),
+            estimated_usage_credits_micros: credits,
+            ..seed.clone()
+        },
+    )
+    .to_vec();
+    usage.estimated_usage_credits_micros = usage
+        .groups
+        .iter()
+        .map(|group| group.estimated_usage_credits_micros)
+        .sum();
+    view.chats = Load::Ready(chats);
+    press(&mut view, KeyCode::Char('6'));
+    press(&mut view, KeyCode::Enter);
+    let mut screens = Vec::new();
+    for width in [110, 58] {
+        view.follow_selection = true;
+        let output = screen(&mut view, width, /*height*/ 32);
+        assert!(output.find("Top model").unwrap() < output.find("Small model").unwrap());
+        assert!(output.find("Small model").unwrap() < output.find("Refund model").unwrap());
+        assert!(!output.contains("Zero model"));
+        assert!(output.contains("-0.000004") && output.contains("Not reported"));
+        assert!(output.contains("19,350.04") && output.contains("19,134.43"));
+        assert!(output.contains("1 zero-credit group hidden · a show all"));
+        assert!(output.contains("Refactor billing usage"));
+        screens.push(output);
+    }
+    press(&mut view, KeyCode::Char('a'));
+    let expanded = screen(&mut view, /*width*/ 110, /*height*/ 32);
+    assert!(expanded.contains("Zero model") && expanded.contains("a hide zeros"));
+    screens.push(expanded);
+    press(&mut view, KeyCode::Char('a'));
+    assert!(!view.show_zero_credit_groups);
+    let wide = view.chat_lines(/*width*/ 220).0;
+    assert!(wide.iter().all(|line| line.width() <= 96));
+    insta::assert_snapshot!(screens.join("\n"));
+}
+
+#[test]
+fn chats_long_title_keeps_detail_indent_and_counts_missing_estimates() {
+    let mut view = fixture::view(models::AccountKind::Enterprise);
+    let mut chats = fixture::chats();
+    chats.rows[0].title = "Create a comprehensive list of areas to investigate across the runtime and describe how each area affects performance in a long conversation".into();
+    chats.rows[1].usage = None;
+    chats.rows[2].usage = None;
+    view.chats = Load::Ready(chats);
+    press(&mut view, KeyCode::Char('6'));
+    press(&mut view, KeyCode::Enter);
+    let output = screen(&mut view, /*width*/ 110, /*height*/ 30);
+    assert!(output.contains("2 chat estimates unavailable"));
+    insta::assert_snapshot!(output);
+}
+
+#[tokio::test]
+async fn unavailable_chats_do_not_open_invisible_details() {
+    for key in [KeyCode::Enter, KeyCode::Right] {
+        for state in 0..5 {
+            let mut view = fixture::view(models::AccountKind::Enterprise);
+            view.section = Section::Chats;
+            view.chats = match state {
+                0 => Load::Unavailable,
+                1 => Load::Error("Temporary failure".into()),
+                2 => Load::Ready(chats::Chats::default()),
+                3 => Load::Ready(chats::Chats {
+                    rows: vec![chats::Chat {
+                        title: "Another workspace's private title".into(),
+                        usage: None,
+                    }],
+                }),
+                _ => Load::start(std::future::pending(), FrameRequester::test_dummy()),
+            };
+            press(&mut view, key);
+            assert_eq!(view.sections[Section::Chats].detail, None);
+            press(&mut view, KeyCode::Esc);
+            assert!(view.is_done);
+        }
+    }
+}
+
+#[test]
+fn unavailable_chat_titles_are_hidden_in_panel_and_overview() {
+    let mut view = fixture::view(models::AccountKind::Enterprise);
+    view.section = Section::Chats;
+    view.chats = Load::Ready(chats::Chats {
+        rows: vec![chats::Chat {
+            title: "Another workspace's private title".into(),
+            usage: None,
+        }],
+    });
+    let mut screens = Vec::new();
+    for zoomed in [true, false] {
+        view.zoomed = zoomed;
+        view.follow_selection = true;
+        let output = screen(&mut view, /*width*/ 110, /*height*/ 28);
+        assert!(!output.contains("Another workspace's private title"));
+        assert!(output.contains("Chat usage unavailable"));
+        screens.push(output);
+    }
+    insta::assert_snapshot!(screens.join("\n"));
+}
+
+#[test]
+fn refreshing_chats_clears_details_before_replacing_the_ranked_rows() {
+    for unavailable in [true, false] {
+        let mut view = fixture::view(models::AccountKind::Enterprise);
+        view.section = Section::Chats;
+        press(&mut view, KeyCode::Enter);
+        assert_eq!(view.sections[Section::Chats].detail, Some(0));
+        press(&mut view, KeyCode::Char('R'));
+        assert_eq!(view.sections[Section::Chats].detail, None);
+        view.account = Load::Ready(codex_protocol::account::PlanType::EnterpriseCbpUsageBased);
+        view.chats = if unavailable {
+            Load::Error("Temporarily unavailable".into())
+        } else {
+            Load::Ready(chats::Chats::default())
+        };
+        press(&mut view, KeyCode::Esc);
+        assert!(view.is_done);
+    }
+}
+
+#[test]
+fn moving_chat_selection_collapses_details_before_they_leave_the_viewport() {
+    for (start, key) in [
+        (0, KeyCode::Down),
+        (1, KeyCode::Up),
+        (0, KeyCode::End),
+        (2, KeyCode::Home),
+    ] {
+        let mut view = fixture::view(models::AccountKind::Enterprise);
+        view.section = Section::Chats;
+        view.sections[Section::Chats].cursor = start;
+        press(&mut view, KeyCode::Enter);
+        assert_eq!(view.sections[Section::Chats].detail, Some(start));
+        press(&mut view, key);
+        assert_eq!(view.sections[Section::Chats].detail, None);
+        if key == KeyCode::End {
+            insta::assert_snapshot!(screen(&mut view, /*width*/ 110, /*height*/ 24));
+        }
+        press(&mut view, KeyCode::Esc);
+        assert!(view.is_done);
+    }
+}

codex-rs/tui/src/analytics/chats.rs

@@ -0,0 +1,195 @@
+//! Discover recent local roots and load business chat credit estimates.
+
+use super::client::Live;
+use super::client::Session;
+use super::data;
+use codex_app_server_client::AppServerRequestHandle;
+use codex_app_server_protocol::ClientRequest;
+use codex_app_server_protocol::RequestId;
+use codex_app_server_protocol::SortDirection;
+use codex_app_server_protocol::ThreadListParams;
+use codex_app_server_protocol::ThreadListResponse;
+use codex_app_server_protocol::ThreadSortKey;
+use codex_backend_client::ThreadUsage;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::sync::Arc;
+
+pub(super) struct Chat {
+    pub title: String,
+    pub usage: Option<ThreadUsage>,
+}
+
+impl Chat {
+    /// Local history can span accounts; expose titles only with a returned account estimate.
+    pub(super) fn display_title(&self) -> &str {
+        if self.usage.is_some() {
+            &self.title
+        } else {
+            "Chat usage unavailable"
+        }
+    }
+}
+
+#[derive(Default)]
+pub(super) struct Chats {
+    pub rows: Vec<Chat>,
+}
+
+pub(super) async fn read(
+    handle: AppServerRequestHandle,
+    live: Arc<Live>,
+) -> Result<Option<Chats>, String> {
+    let session = live.session().await?;
+    if !super::models::thread_usage_supported(session.backend.account().plan_type) {
+        return Ok(None);
+    }
+    session.backend.ensure_identity().await?;
+    let threads = tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 60), roots(&handle))
+        .await
+        .map_err(|_| "Chat listing timed out. Press R to retry.".to_string())??;
+    session.backend.ensure_identity().await?;
+    if threads.is_empty() {
+        return Ok(Some(Chats { rows: Vec::new() }));
+    }
+    let ids = threads
+        .iter()
+        .map(|thread| thread.id.as_str())
+        .collect::<Vec<_>>();
+    // Repairing local history has its own budget; it must not consume estimate time.
+    let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(/*secs*/ 25);
+    let mut data = Vec::new();
+    for pair in ids.chunks(/*chunk_size*/ 200) {
+        let midpoint = pair.len().min(/*other*/ 100);
+        let (first, second) = tokio::join!(
+            tokio::time::timeout_at(deadline, estimates(session, &pair[..midpoint])),
+            tokio::time::timeout_at(deadline, estimates(session, &pair[midpoint..])),
+        );
+        for batch in [first, second].into_iter().flatten() {
+            data.extend(batch?);
+        }
+        if tokio::time::Instant::now() >= deadline {
+            break;
+        }
+    }
+    session.backend.ensure_identity().await?;
+    let mut usage: HashMap<_, _> = data
+        .into_iter()
+        .map(|row| (row.thread_id.clone(), row))
+        .collect();
+    let mut rows = threads
+        .into_iter()
+        .map(|thread| Chat {
+            usage: usage.remove(&thread.id),
+            title: thread
+                .name
+                .filter(|name| !name.trim().is_empty())
+                .unwrap_or_else(|| {
+                    if thread.preview.trim().is_empty() {
+                        "Untitled chat".into()
+                    } else {
+                        thread.preview
+                    }
+                }),
+        })
+        .collect::<Vec<_>>();
+    rows.sort_by_key(|row| {
+        std::cmp::Reverse(
+            row.usage
+                .as_ref()
+                .map(|usage| usage.estimated_usage_credits_micros),
+        )
+    });
+    Ok(Some(Chats { rows }))
+}
+
+/// Recent local roots are shared by consumer task and business credit reporting.
+pub(super) async fn roots(
+    handle: &AppServerRequestHandle,
+) -> Result<Vec<codex_app_server_protocol::Thread>, String> {
+    let cutoff = chrono::Utc::now().timestamp() - 30 * 24 * 60 * 60;
+    let mut threads = Vec::new();
+    let mut cursor = None;
+    let mut seen_cursors = HashSet::new();
+    loop {
+        let page: ThreadListResponse = handle
+            .request_typed(ClientRequest::ThreadList {
+                request_id: RequestId::String(uuid::Uuid::new_v4().to_string()),
+                params: ThreadListParams {
+                    cursor,
+                    ..list_params()
+                },
+            })
+            .await
+            .map_err(data::error)?;
+        let reached_cutoff = page.data.iter().any(|thread| thread.updated_at < cutoff);
+        threads.extend(page.data.into_iter().filter(|thread| {
+            thread.updated_at >= cutoff && !thread.ephemeral && thread.parent_thread_id.is_none()
+        }));
+        match page.next_cursor {
+            Some(next) if !seen_cursors.insert(next.clone()) => {
+                return Err("Chat listing repeated a cursor. Press R to retry.".into());
+            }
+            Some(next) if !reached_cutoff => cursor = Some(next),
+            _ => break,
+        }
+    }
+    // Keep repeated rows from overlapping pages out of the backend's distinct-ID batches.
+    let mut seen_ids = HashSet::new();
+    threads.retain(|thread| seen_ids.insert(thread.id.clone()));
+    Ok(threads)
+}
+
+pub(super) fn list_params() -> ThreadListParams {
+    ThreadListParams {
+        limit: Some(100),
+        sort_key: Some(ThreadSortKey::UpdatedAt),
+        sort_direction: Some(SortDirection::Desc),
+        model_providers: Some(Vec::new()),
+        source_kinds: None,
+        originators: None,
+        archived: Some(false),
+        cursor: None,
+        section_id: None,
+        project_id: None,
+        cwd: None,
+        use_state_db_only: false,
+        search_term: None,
+        parent_thread_id: None,
+        ancestor_thread_id: None,
+    }
+}
+
+/// Isolate unavailable estimates within the existing concurrency slot; keep healthy rows.
+async fn estimates(session: &Session, ids: &[&str]) -> Result<Vec<ThreadUsage>, String> {
+    let mut pending = if ids.is_empty() {
+        Vec::new()
+    } else {
+        vec![ids]
+    };
+    let mut rows = Vec::new();
+    // At most 15 requests per batch; leave remaining estimates unavailable during an outage.
+    for _ in 0..15 {
+        let Some(ids) = pending.pop() else { break };
+        match session
+            .backend
+            .request(|client| async move { client.get_threads_usage(ids).await })
+            .await
+        {
+            Ok(batch) => rows.extend(batch),
+            Err(error) if error.status().is_some_and(|status| status.as_u16() == 503) => {
+                if ids.len() > 1 {
+                    let midpoint = ids.len().div_ceil(/*rhs*/ 2);
+                    pending.push(&ids[midpoint..]);
+                    pending.push(&ids[..midpoint]);
+                }
+            }
+            Err(error) => return Err(super::client::request_error(error)),
+        }
+    }
+    Ok(rows)
+}
+
+#[cfg(test)]
+#[path = "chats_tests.rs"]
+mod tests;

codex-rs/tui/src/analytics/chats_tests.rs

@@ -0,0 +1,178 @@
+//! Verify bounded chat discovery, account eligibility, and partial estimate handling.
+
+use super::super::client::tests::live;
+use super::*;
+use pretty_assertions::assert_eq;
+use serde_json::json;
+use wiremock::Mock;
+use wiremock::MockServer;
+use wiremock::ResponseTemplate;
+use wiremock::matchers::method;
+use wiremock::matchers::path;
+
+#[tokio::test]
+async fn incomplete_chat_batches_retain_available_estimates_without_inventing_zeroes() {
+    let server = MockServer::start().await;
+    let (_home, live) = live(&server, "enterprise_cbp_usage_based").await;
+    Mock::given(method("POST")).and(path("/backend-api/wham/usage/thread_usage/query"))
+        .respond_with(|request: &wiremock::Request| {
+            let body: serde_json::Value = request.body_json().unwrap();
+            let ids = body["thread_ids"].as_array().unwrap();
+            if ids.len() > 1 || ids[0] == "incomplete" {
+                ResponseTemplate::new(/*s*/ 503).set_body_json(json!({"detail": "Thread usage is temporarily unavailable."}))
+            } else {
+                ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"threads": [{
+                    "thread_id": ids[0], "estimated_usage_credits_micros": if ids[0] == "missing" { None } else { Some(1250000) },
+                    "estimated_usage_usd_micros": null, "groups": null,
+                }]}))
+            }
+        }).expect(/*r*/ 5).mount(&server).await;
+    let session = live.session().await.unwrap();
+    assert_eq!(
+        estimates(session, &["available", "incomplete", "missing"])
+            .await
+            .unwrap(),
+        vec![ThreadUsage {
+            thread_id: "available".into(),
+            estimated_usage_credits_micros: 1250000,
+            estimated_usage_usd_micros: None,
+            groups: Vec::new(),
+        }]
+    );
+}
+
+#[tokio::test]
+async fn slow_repairing_chat_listing_keeps_estimate_budget_and_ranks_across_pages() {
+    use codex_app_server_client::RemoteAppServerClient;
+    use codex_app_server_client::RemoteAppServerConnectArgs;
+    use codex_app_server_client::RemoteAppServerEndpoint;
+    use futures::SinkExt;
+    use futures::StreamExt;
+    use tokio_tungstenite::tungstenite::Message;
+
+    let server = MockServer::start().await;
+    let (_home, live) = live(&server, "enterprise_cbp_usage_based").await;
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let websocket_url = format!("ws://{}", listener.local_addr().unwrap());
+    let rpc = tokio::spawn(async move {
+        let (stream, _) = listener.accept().await.unwrap();
+        let mut socket = tokio_tungstenite::accept_async(stream).await.unwrap();
+        let mut pages = Vec::new();
+        while let Some(Ok(Message::Text(text))) = socket.next().await {
+            let request: serde_json::Value = serde_json::from_str(&text).unwrap();
+            let result = match request["method"].as_str() {
+                Some("initialize") => {
+                    json!({"userAgent": "analytics-test", "codexHome": "/unused"})
+                }
+                Some("thread/list") => {
+                    let params = &request["params"];
+                    pages.push(json!([
+                        params["cursor"],
+                        params["limit"],
+                        params["useStateDbOnly"].as_bool().unwrap_or_default(),
+                        params["modelProviders"]
+                    ]));
+                    if pages.len() == 1 {
+                        // Simulate repair exceeding the HTTP estimate budget without a wall-clock wait.
+                        tokio::time::pause();
+                        tokio::time::advance(std::time::Duration::from_secs(/*secs*/ 26)).await;
+                        tokio::time::resume();
+                    }
+                    let range = if pages.len() == 1 { 0..100 } else { 100..101 };
+                    let data = range.map(|index| json!({
+                        "id": format!("chat-{index}"), "sessionId": format!("chat-{index}"),
+                        "preview": "", "name": format!("Chat {index}"), "ephemeral": false,
+                        "modelProvider": "openai", "createdAt": 0,
+                        "updatedAt": chrono::Utc::now().timestamp(), "status": {"type": "idle"},
+                        "cwd": std::env::temp_dir(), "cliVersion": "test", "source": "cli", "turns": [],
+                    })).collect::<Vec<_>>();
+                    json!({"data": data, "nextCursor": if pages.len() == 1 { Some("next") } else { None }})
+                }
+                _ => continue,
+            };
+            socket
+                .send(Message::Text(
+                    json!({"jsonrpc": "2.0", "id": request["id"], "result": result})
+                        .to_string()
+                        .into(),
+                ))
+                .await
+                .unwrap();
+            if pages.len() == 2 {
+                break;
+            }
+        }
+        pages
+    });
+    let remote = RemoteAppServerClient::connect(RemoteAppServerConnectArgs {
+        endpoint: RemoteAppServerEndpoint::WebSocket {
+            websocket_url,
+            auth_token: None,
+        },
+        client_name: "analytics-test".into(),
+        client_version: "test".into(),
+        experimental_api: false,
+        mcp_server_openai_form_elicitation: false,
+        opt_out_notification_methods: Vec::new(),
+        channel_capacity: 16,
+    })
+    .await
+    .unwrap();
+    Mock::given(method("POST")).and(path("/backend-api/wham/usage/thread_usage/query"))
+        .respond_with(|request: &wiremock::Request| {
+            let body: serde_json::Value = request.body_json().unwrap();
+            let ids = body["thread_ids"].as_array().unwrap();
+            assert!(ids.len() <= 100);
+            if ids.iter().any(|id| id == "chat-35") {
+                return ResponseTemplate::new(/*s*/ 503)
+                    .set_body_json(json!({"detail": "Thread usage is temporarily unavailable."}));
+            }
+            let threads = ids.iter().map(|id| json!({
+                "thread_id": id,
+                "estimated_usage_credits_micros": id.as_str().unwrap().strip_prefix("chat-").unwrap().parse::<i64>().unwrap(),
+            })).collect::<Vec<_>>();
+            ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"threads": threads}))
+        }).expect(/*r*/ 2..=16).mount(&server).await;
+    let chats = read(
+        AppServerRequestHandle::Remote(remote.request_handle()),
+        Arc::new(live),
+    )
+    .await
+    .unwrap()
+    .unwrap();
+    assert_eq!(
+        (
+            chats.rows.len(),
+            chats.rows[0].title.as_str(),
+            chats.rows.last().unwrap().title.as_str(),
+            chats.rows.last().unwrap().usage.clone()
+        ),
+        (101, "Chat 100", "Chat 35", None)
+    );
+    assert_eq!(
+        rpc.await.unwrap(),
+        vec![
+            json!([null, 100, false, []]),
+            json!(["next", 100, false, []])
+        ]
+    );
+}
+
+#[tokio::test]
+async fn unavailable_chat_batches_bound_requests_during_an_outage() {
+    let server = MockServer::start().await;
+    let (_home, live) = live(&server, "enterprise_cbp_usage_based").await;
+    Mock::given(method("POST"))
+        .respond_with(ResponseTemplate::new(/*s*/ 503))
+        .expect(/*r*/ 15)
+        .mount(&server)
+        .await;
+    let ids = (0..100).map(|i| format!("chat-{i}")).collect::<Vec<_>>();
+    let ids = ids.iter().map(String::as_str).collect::<Vec<_>>();
+    assert_eq!(
+        estimates(live.session().await.unwrap(), &ids)
+            .await
+            .unwrap(),
+        Vec::<ThreadUsage>::new()
+    );
+}

codex-rs/tui/src/analytics/client.rs

@@ -0,0 +1,267 @@
+//! Local account report loading with backend-owned authentication and identity checks.
+//! Cached responses belong to one local account and user, independently of the connected server.
+//! Every report uses the view's captured end date until refresh replaces the session.
+
+use super::models::AccountAnalyticsGrouping as Grouping;
+use super::models::AccountAnalyticsReport as Report;
+use super::models::AccountKind;
+use super::report_data::AnalyticsData;
+use crate::legacy_core::config::Config;
+use codex_backend_client::AnalyticsReport;
+use codex_backend_client::AnalyticsSession;
+use codex_backend_client::RequestError;
+use codex_protocol::account::PlanType;
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use tokio::sync::OnceCell;
+
+pub(super) struct Live {
+    config: Arc<Config>,
+    end_date: chrono::NaiveDate,
+    session: OnceCell<Session>,
+    token_models: std::sync::RwLock<Vec<String>>,
+    attributed_usage: std::sync::atomic::AtomicBool,
+}
+
+pub(super) struct Session {
+    pub(super) kind: AccountKind,
+    pub(super) backend: AnalyticsSession,
+    credit_groups: Vec<usize>,
+    cache: Mutex<HashMap<(AnalyticsReport, String, String), AnalyticsData>>,
+}
+
+impl Live {
+    pub(super) fn new(config: Arc<Config>, end_date: chrono::NaiveDate) -> Self {
+        Self {
+            config,
+            end_date,
+            session: OnceCell::new(),
+            token_models: std::sync::RwLock::new(Vec::new()),
+            attributed_usage: std::sync::atomic::AtomicBool::new(/*v*/ true),
+        }
+    }
+
+    pub(super) fn account_label(&self) -> Option<String> {
+        let session = self.session.get()?;
+        session.backend.account().email.clone()
+    }
+
+    pub(super) fn credit_groups(&self) -> &[usize] {
+        self.session
+            .get()
+            .map_or(&[0], |session| &session.credit_groups)
+    }
+
+    pub(super) fn attributed_usage(&self) -> bool {
+        self.attributed_usage
+            .load(std::sync::atomic::Ordering::Relaxed)
+    }
+
+    pub(super) fn token_models(&self) -> Vec<String> {
+        self.token_models
+            .read()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+            .clone()
+    }
+
+    pub(super) async fn session(&self) -> Result<&Session, String> {
+        self.session
+            .get_or_try_init(|| async {
+                let session = AnalyticsSession::from_config(
+                    self.config.as_ref(),
+                    self.config.http_client_factory(),
+                )
+                .await?;
+                let credit_groups = Grouping::credit_groupings(session.account().plan_type)
+                    .iter()
+                    .filter_map(|group| {
+                        super::data::GROUPINGS
+                            .iter()
+                            .position(|candidate| candidate == group)
+                    })
+                    .collect();
+                Ok(Session {
+                    kind: AccountKind::from(session.account().plan_type),
+                    credit_groups,
+                    backend: session,
+                    cache: Mutex::new(HashMap::new()),
+                })
+            })
+            .await
+    }
+
+    pub(super) async fn plan_history(&self) -> Result<Option<super::plan::Report>, String> {
+        let session = self.session().await?;
+        if session.kind != AccountKind::Consumer {
+            return Ok(None);
+        }
+        let history = session
+            .backend
+            .request(|client| async move { client.get_plan_limit_history().await })
+            .await;
+        session.backend.ensure_identity().await?;
+        history
+            .map_err(request_error)?
+            .map(super::plan::Report::parse)
+            .transpose()
+            .map(Option::flatten)
+    }
+
+    pub(super) async fn history(
+        &self,
+        report: Report,
+        days: u32,
+        grouping: Grouping,
+    ) -> Result<Option<super::models::AccountAnalyticsHistory>, String> {
+        self.filtered_history(report, days, grouping, /*model_filter*/ None)
+            .await
+    }
+
+    pub(super) async fn filtered_history(
+        &self,
+        report: Report,
+        days: u32,
+        grouping: Grouping,
+        model_filter: Option<&str>,
+    ) -> Result<Option<super::models::AccountAnalyticsHistory>, String> {
+        let end = self.end_date;
+        let start = days
+            .checked_sub(/*rhs*/ 1)
+            .and_then(|offset| end.checked_sub_days(chrono::Days::new(u64::from(offset))))
+            .ok_or("Invalid analytics date range.")?;
+        let session = self.session().await?;
+        session.backend.ensure_identity().await?;
+        let enterprise_tokens = report == Report::Usage
+            && matches!(
+                session.kind,
+                AccountKind::Enterprise | AccountKind::Business
+            );
+        let grouping =
+            if enterprise_tokens && !matches!(grouping, Grouping::Model | Grouping::TokenType) {
+                Grouping::TokenType
+            } else {
+                grouping
+            };
+        let route =
+            route(report, grouping, session.backend.account().plan_type).ok_or_else(|| {
+                "This credit breakdown is not supported for this account type.".to_string()
+            })?;
+        // Credit events have no range parameters. Other grouping changes reuse the same payload.
+        let key = if route == AnalyticsReport::Credits {
+            (route, String::new(), String::new())
+        } else {
+            (route, start.to_string(), end.to_string())
+        };
+        let cached = session.cache.lock().await.get(&key).cloned();
+        let response = if let Some(response) = cached {
+            Ok(response)
+        } else {
+            session
+                .backend
+                .request(|client| {
+                    let (_, start, end) = key.clone();
+                    async move { client.get_account_analytics(route, &start, &end).await }
+                })
+                .await
+                .map(AnalyticsData::from)
+        };
+        session.backend.ensure_identity().await?;
+        let response = response.map_err(request_error)?;
+        let history = (|| {
+            if enterprise_tokens {
+                let models = super::tokens::history(response.clone(), Grouping::Model, start, end)?;
+                *self
+                    .token_models
+                    .write()
+                    .unwrap_or_else(std::sync::PoisonError::into_inner) =
+                    super::render::categories(&models)
+                        .into_iter()
+                        .map(|model| model.key)
+                        .collect();
+                super::tokens::filtered_history(
+                    response.clone(),
+                    grouping,
+                    start,
+                    end,
+                    model_filter,
+                )
+                .map(Some)
+            } else {
+                let grouping = if report == Report::Usage {
+                    let attributed =
+                        super::normalize::has_complete_attribution(&response, start, end)?;
+                    self.attributed_usage
+                        .store(attributed, std::sync::atomic::Ordering::Relaxed);
+                    if !attributed && matches!(grouping, Grouping::Feature | Grouping::TaskStart) {
+                        Grouping::Surface
+                    } else {
+                        grouping
+                    }
+                } else {
+                    grouping
+                };
+                super::normalize::history(response.clone(), report, grouping, start, end)
+            }
+        })();
+        let mut cache = session.cache.lock().await;
+        if history.is_ok() {
+            cache.insert(key, response);
+        } else {
+            cache.remove(&key);
+        }
+        history
+    }
+}
+
+// Account type selects billing semantics, never activity-report eligibility.
+fn route(report: Report, grouping: Grouping, plan: Option<PlanType>) -> Option<AnalyticsReport> {
+    let kind = AccountKind::from(plan);
+    let enterprise = kind == AccountKind::Enterprise;
+    Some(match report {
+        Report::Usage if enterprise => AnalyticsReport::EnterpriseTokens,
+        Report::Usage if kind == AccountKind::Business => AnalyticsReport::WorkspaceCredits,
+        Report::Usage => AnalyticsReport::Usage,
+        Report::Messages => AnalyticsReport::Messages,
+        Report::Credits if !Grouping::credit_groupings(plan).contains(&grouping) => return None,
+        Report::Credits if enterprise => AnalyticsReport::EnterpriseCredits {
+            breakdown: match grouping {
+                Grouping::Surface => "product",
+                Grouping::Model => "model",
+                Grouping::Speed => "speed",
+                Grouping::Reasoning => "reasoning_effort",
+                Grouping::Feature | Grouping::TaskStart | Grouping::TokenType => return None,
+            },
+        },
+        Report::Credits if kind == AccountKind::Business => AnalyticsReport::WorkspaceCredits,
+        Report::Credits => AnalyticsReport::Credits,
+        Report::Plugins => AnalyticsReport::Plugins {
+            limit: if enterprise { 8 } else { 10 },
+        },
+        Report::Skills => AnalyticsReport::Skills {
+            limit: if enterprise { 6 } else { 10 },
+        },
+    })
+}
+
+pub(super) fn request_error(error: RequestError) -> String {
+    match error.status().map(|status| status.as_u16()) {
+        Some(401) => "Sign in again to load this report.",
+        Some(403) => "Access denied for this report.",
+        Some(404) => "This report endpoint is unavailable. Press R to retry.",
+        _ => "Report request failed. Press R to retry.",
+    }
+    .into()
+}
+
+#[cfg(test)]
+#[path = "client_tests.rs"]
+pub(super) mod tests;
+
+#[cfg(test)]
+#[path = "connection_tests.rs"]
+mod connection_tests;
+
+#[cfg(test)]
+#[path = "account_plan_tests.rs"]
+mod account_plan_tests;

codex-rs/tui/src/analytics/client_tests.rs

@@ -0,0 +1,851 @@
+//! Account-scoped authentication and request identity regression coverage.
+
+use super::*;
+use crate::analytics::sections::Section;
+use crate::legacy_core::config::ConfigBuilder;
+use base64::Engine;
+use codex_config::LoaderOverrides;
+use pretty_assertions::assert_eq;
+use serde_json::json;
+use wiremock::Mock;
+use wiremock::MockServer;
+use wiremock::ResponseTemplate;
+use wiremock::matchers::header;
+use wiremock::matchers::method;
+use wiremock::matchers::path;
+
+pub(super) fn sign_in(home: &std::path::Path, account: &str, user: &str, plan: &str) {
+    let claims = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(
+        json!({
+            "exp": 4102444800_i64, "email": "analytics@example.test",
+            "https://api.openai.com/auth": {
+                "chatgpt_account_id": account, "chatgpt_user_id": user, "chatgpt_plan_type": plan,
+            },
+        })
+        .to_string(),
+    );
+    let token = format!("e30.{claims}.test");
+    let auth = serde_json::from_value(json!({
+        "auth_mode": "chatgpt", "tokens": {"id_token": token, "access_token": token,
+            "refresh_token": "test-refresh", "account_id": account},
+        "last_refresh": chrono::Utc::now(),
+    }))
+    .unwrap();
+    codex_login::save_auth(
+        home,
+        &auth,
+        codex_login::AuthCredentialsStoreMode::File,
+        codex_login::AuthKeyringBackendKind::default(),
+    )
+    .unwrap();
+}
+
+pub(in crate::analytics) async fn live(
+    server: &MockServer,
+    plan: &str,
+) -> (tempfile::TempDir, Live) {
+    let home = tempfile::tempdir().unwrap();
+    let mut config = ConfigBuilder::default()
+        .codex_home(home.path().to_path_buf())
+        .loader_overrides(LoaderOverrides::without_managed_config_for_tests())
+        .build()
+        .await
+        .unwrap();
+    config.chatgpt_base_url = format!("{}/backend-api", server.uri());
+    config.cli_auth_credentials_store_mode = codex_login::AuthCredentialsStoreMode::File;
+    sign_in(home.path(), "account-a", "user-a", plan);
+    Mock::given(method("GET"))
+        .and(path("/backend-api/wham/accounts/check"))
+        .respond_with(ResponseTemplate::new(/*s*/ 200).set_body_json(json!({
+            "accounts": [{"id": "account-a", "plan_type": plan}],
+            "account_ordering": ["account-a"]
+        })))
+        .with_priority(/*p*/ 2)
+        .mount(server)
+        .await;
+    (
+        home,
+        Live::new(Arc::new(config), "2026-01-15".parse().unwrap()),
+    )
+}
+
+async fn report_requests(server: &MockServer) -> Vec<wiremock::Request> {
+    server
+        .received_requests()
+        .await
+        .unwrap()
+        .into_iter()
+        .filter(|request| request.url.path() != "/backend-api/wham/accounts/check")
+        .collect()
+}
+
+#[tokio::test]
+async fn analytics_rejects_identity_changes_during_requests() {
+    let server = MockServer::start().await;
+    let (home, live) = live(&server, "business").await;
+    let session = live.session().await.unwrap();
+    let authenticated = &session.backend;
+    let result = authenticated
+        .request(|_| async {
+            sign_in(home.path(), "account-b", "user-a", "business");
+            Ok(123)
+        })
+        .await;
+    assert_eq!(
+        result.unwrap_err().to_string(),
+        "Account changed. Press R to refresh Analytics."
+    );
+    assert!(report_requests(&server).await.is_empty());
+}
+
+#[tokio::test]
+async fn analytics_rejects_account_and_user_changes_before_requests() {
+    for (account, user) in [("account-b", "user-a"), ("account-a", "user-b")] {
+        let server = MockServer::start().await;
+        let (home, live) = live(&server, "plus").await;
+        let session = live.session().await.unwrap();
+        let authenticated = &session.backend;
+        sign_in(home.path(), account, user, "plus");
+        let requested = std::cell::Cell::new(/*value*/ false);
+        let result = authenticated
+            .request(|_| async {
+                requested.set(/*val*/ true);
+                Ok(())
+            })
+            .await;
+        assert!(!requested.get());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Account changed. Press R to refresh Analytics."
+        );
+    }
+}
+
+#[tokio::test]
+async fn analytics_requires_local_chatgpt_authentication() {
+    for auth in [None, Some(json!({"OPENAI_API_KEY": "sk-test-only"}))] {
+        let server = MockServer::start().await;
+        let (home, live) = live(&server, "plus").await;
+        let path = home.path().join("auth.json");
+        match auth {
+            Some(auth) => std::fs::write(path, serde_json::to_vec(&auth).unwrap()).unwrap(),
+            None => std::fs::remove_file(path).unwrap(),
+        }
+        assert_eq!(
+            live.session().await.err(),
+            Some("Sign in locally with ChatGPT to view Analytics.".to_string())
+        );
+        assert!(report_requests(&server).await.is_empty());
+    }
+}
+
+#[tokio::test]
+async fn analytics_requests_use_reloaded_credentials_for_the_same_identity() {
+    let server = MockServer::start().await;
+    let (home, live) = live(&server, "plus").await;
+    let session = live.session().await.unwrap();
+    let authenticated = &session.backend;
+    assert_eq!(
+        live.account_label().as_deref(),
+        Some("analytics@example.test")
+    );
+    let auth_path = home.path().join("auth.json");
+    let mut auth: serde_json::Value =
+        serde_json::from_slice(&std::fs::read(&auth_path).unwrap()).unwrap();
+    auth["tokens"]["access_token"] = json!("refreshed-access-token");
+    std::fs::write(auth_path, serde_json::to_vec(&auth).unwrap()).unwrap();
+    Mock::given(method("GET"))
+        .and(path("/backend-api/wham/usage/daily-token-usage-breakdown"))
+        .and(header("chatgpt-account-id", "account-a"))
+        .and(header("authorization", "Bearer refreshed-access-token"))
+        .respond_with(ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"data": []})))
+        .expect(/*r*/ 1)
+        .mount(&server)
+        .await;
+    let result = authenticated
+        .request(|client| async move {
+            client
+                .get_account_analytics(
+                    codex_backend_client::AnalyticsReport::Usage,
+                    "2026-09-01",
+                    "2026-09-07",
+                )
+                .await
+        })
+        .await
+        .unwrap();
+    assert_eq!(
+        result,
+        codex_backend_client::AnalyticsResponse::Usage(
+            codex_backend_client::analytics_models::DailyProductSurfaceUsageResponse::default()
+        )
+    );
+    server.verify().await;
+}
+
+#[tokio::test]
+async fn analytics_retries_unauthorized_requests_after_credentials_reload() {
+    let server = MockServer::start().await;
+    let (home, live) = live(&server, "plus").await;
+    let session = live.session().await.unwrap();
+    let authenticated = &session.backend;
+    let auth_path = home.path().join("auth.json");
+    let mut auth: serde_json::Value =
+        serde_json::from_slice(&std::fs::read(&auth_path).unwrap()).unwrap();
+    let original_token = auth["tokens"]["access_token"].as_str().unwrap().to_owned();
+    auth["tokens"]["access_token"] = json!("recovered-access-token");
+    let updated_auth = serde_json::to_vec(&auth).unwrap();
+    Mock::given(method("GET"))
+        .and(header("authorization", format!("Bearer {original_token}")))
+        .respond_with(move |_: &wiremock::Request| {
+            std::fs::write(&auth_path, &updated_auth).unwrap();
+            ResponseTemplate::new(/*s*/ 401)
+        })
+        .expect(/*r*/ 1)
+        .mount(&server)
+        .await;
+    Mock::given(method("GET"))
+        .and(header("authorization", "Bearer recovered-access-token"))
+        .and(header("chatgpt-account-id", "account-a"))
+        .respond_with(ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"data": []})))
+        .expect(/*r*/ 1)
+        .mount(&server)
+        .await;
+    let result = authenticated
+        .request(|client| async move {
+            client
+                .get_account_analytics(
+                    codex_backend_client::AnalyticsReport::Usage,
+                    "2026-09-01",
+                    "2026-09-07",
+                )
+                .await
+        })
+        .await
+        .unwrap();
+    assert_eq!(
+        result,
+        codex_backend_client::AnalyticsResponse::Usage(
+            codex_backend_client::analytics_models::DailyProductSurfaceUsageResponse::default()
+        )
+    );
+    server.verify().await;
+}
+
+#[tokio::test]
+async fn analytics_retries_session_initialization_after_sign_in() {
+    let server = MockServer::start().await;
+    let (home, live) = live(&server, "plus").await;
+    std::fs::remove_file(home.path().join("auth.json")).unwrap();
+    assert!(live.session().await.is_err());
+    sign_in(home.path(), "account-a", "user-a", "plus");
+    assert_eq!(
+        live.session().await.unwrap().backend.account().id,
+        "account-a"
+    );
+}
+
+#[tokio::test]
+async fn analytics_matches_app_account_routes_and_parameters() {
+    let server = MockServer::start().await;
+    for (plan, report, grouping, endpoint, extra) in [
+        (
+            "plus",
+            Report::Usage,
+            Grouping::Model,
+            "usage/daily-token-usage-breakdown",
+            vec![("group_by", "day")],
+        ),
+        (
+            "business",
+            Report::Usage,
+            Grouping::TokenType,
+            "usage/daily-workspace-user-token-usage-breakdown",
+            vec![
+                ("group_by", "day"),
+                ("breakdown_by", "model"),
+                ("modes", "codex"),
+                ("modes", "work"),
+            ],
+        ),
+        (
+            "business",
+            Report::Messages,
+            Grouping::Model,
+            "analytics/daily-workspace-usage-counts",
+            vec![("group_by", "day"), ("workspace_user", "true")],
+        ),
+        (
+            "unknown",
+            Report::Usage,
+            Grouping::Surface,
+            "usage/daily-token-usage-breakdown",
+            vec![("group_by", "day")],
+        ),
+        (
+            "unknown",
+            Report::Messages,
+            Grouping::Model,
+            "analytics/daily-workspace-usage-counts",
+            vec![("group_by", "day"), ("workspace_user", "true")],
+        ),
+        (
+            "unknown",
+            Report::Plugins,
+            Grouping::Feature,
+            "analytics/daily-plugin-usage-metrics",
+            vec![
+                ("group_by", "day"),
+                ("workspace_user", "true"),
+                ("top_plugin_limit", "10"),
+            ],
+        ),
+        (
+            "unknown",
+            Report::Skills,
+            Grouping::Feature,
+            "analytics/daily-skill-usage-metrics",
+            vec![
+                ("group_by", "day"),
+                ("workspace_user", "true"),
+                ("top_skill_limit", "10"),
+            ],
+        ),
+        (
+            "edu",
+            Report::Credits,
+            Grouping::Model,
+            "usage/daily-workspace-user-credit-usage",
+            vec![("breakdown", "model")],
+        ),
+        (
+            "plus",
+            Report::Credits,
+            Grouping::Surface,
+            "usage/credit-usage-events",
+            vec![],
+        ),
+        (
+            "team",
+            Report::Usage,
+            Grouping::Model,
+            "usage/daily-workspace-user-token-usage-breakdown",
+            vec![("group_by", "day")],
+        ),
+        (
+            "team",
+            Report::Credits,
+            Grouping::Speed,
+            "usage/daily-workspace-user-token-usage-breakdown",
+            vec![("group_by", "day")],
+        ),
+        (
+            "business",
+            Report::Credits,
+            Grouping::Reasoning,
+            "usage/daily-workspace-user-credit-usage",
+            vec![("breakdown", "reasoning_effort")],
+        ),
+        (
+            "plus",
+            Report::Messages,
+            Grouping::Model,
+            "analytics/daily-workspace-usage-counts",
+            vec![("group_by", "day"), ("workspace_user", "true")],
+        ),
+        (
+            "plus",
+            Report::Plugins,
+            Grouping::Feature,
+            "analytics/daily-plugin-usage-metrics",
+            vec![
+                ("group_by", "day"),
+                ("workspace_user", "true"),
+                ("top_plugin_limit", "10"),
+            ],
+        ),
+        (
+            "business",
+            Report::Plugins,
+            Grouping::Feature,
+            "analytics/daily-plugin-usage-metrics",
+            vec![
+                ("group_by", "day"),
+                ("workspace_user", "true"),
+                ("top_plugin_limit", "8"),
+            ],
+        ),
+        (
+            "business",
+            Report::Skills,
+            Grouping::Feature,
+            "analytics/daily-skill-usage-metrics",
+            vec![
+                ("group_by", "day"),
+                ("workspace_user", "true"),
+                ("top_skill_limit", "6"),
+            ],
+        ),
+    ] {
+        server.reset().await;
+        let (_home, live) = live(&server, plan).await;
+        let today = live.end_date;
+        let start = (today - chrono::Days::new(/*num*/ 6)).to_string();
+        let response = if endpoint == "usage/daily-workspace-user-credit-usage" {
+            let breakdown = extra.iter().find(|(key, _)| *key == "breakdown").unwrap().1;
+            json!({"data": [], "series": [], "breakdown": breakdown})
+        } else {
+            json!({"data": []})
+        };
+        Mock::given(method("GET"))
+            .and(path(format!("/backend-api/wham/{endpoint}")))
+            .and(header("chatgpt-account-id", "account-a"))
+            .respond_with(ResponseTemplate::new(/*s*/ 200).set_body_json(response))
+            .expect(/*r*/ 1)
+            .mount(&server)
+            .await;
+        assert!(
+            live.history(report, /*days*/ 7, grouping)
+                .await
+                .unwrap()
+                .is_some()
+        );
+        let requests = report_requests(&server).await;
+        let mut actual = requests[0]
+            .url
+            .query_pairs()
+            .map(|(key, value)| (key.into_owned(), value.into_owned()))
+            .collect::<Vec<_>>();
+        let mut expected = extra
+            .into_iter()
+            .map(|(key, value)| (key.to_string(), value.to_string()))
+            .collect::<Vec<_>>();
+        if endpoint != "usage/credit-usage-events" {
+            expected.push(("start_date".into(), start.clone()));
+            expected.push(("end_date".into(), today.to_string()));
+        }
+        actual.sort();
+        expected.sort();
+        assert_eq!(actual, expected);
+        assert!(requests[0].headers.get("authorization").is_some());
+    }
+}
+
+#[tokio::test]
+async fn analytics_uses_api_response_for_usage_and_turns_availability() {
+    let server = MockServer::start().await;
+    for report in [Report::Usage, Report::Messages] {
+        for status in [403, 404] {
+            server.reset().await;
+            let (_home, live) = live(&server, "business").await;
+            Mock::given(method("GET"))
+                .respond_with(ResponseTemplate::new(status))
+                .expect(/*r*/ 1)
+                .mount(&server)
+                .await;
+            assert_eq!(
+                live.history(report, /*days*/ 7, Grouping::Surface)
+                    .await
+                    .unwrap_err(),
+                if status == 403 {
+                    "Access denied for this report."
+                } else {
+                    "This report endpoint is unavailable. Press R to retry."
+                }
+            );
+            server.verify().await;
+        }
+    }
+}
+
+#[tokio::test]
+async fn analytics_reuses_payload_for_grouping_and_rejects_account_changes() {
+    let server = MockServer::start().await;
+    let (home, live) = live(&server, "team").await;
+    let today = live.end_date.to_string();
+    Mock::given(method("GET"))
+        .and(path(
+            "/backend-api/wham/usage/daily-workspace-user-token-usage-breakdown",
+        ))
+        .respond_with(
+            ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"data": [{
+                "date": today, "product_surface_usage_values": {}, "premium_usage_values": {
+                    "credit_usage_credits": {"cli": 12.5}, "total_usage_credits": {},
+                    "uncached_text_input_tokens_by_surface": {}, "cached_text_input_tokens_by_surface": {},
+                    "text_output_tokens_by_surface": {}, "text_total_tokens_by_surface": {}
+                },
+                "models": [{"model": "model-a", "credits": 12.5, "speed": "fast", "on_demand_credits": 12.5}]
+            }]})),
+        )
+        .expect(/*r*/ 1)
+        .mount(&server)
+        .await;
+    let surface = live
+        .history(Report::Credits, /*days*/ 7, Grouping::Surface)
+        .await
+        .unwrap()
+        .unwrap();
+    let model = live
+        .history(Report::Credits, /*days*/ 7, Grouping::Model)
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(
+        (
+            surface.data.last().unwrap().total,
+            model.data.last().unwrap().total
+        ),
+        (12.5, 12.5)
+    );
+    sign_in(home.path(), "account-a", "user-b", "team");
+    assert_eq!(
+        live.history(Report::Credits, /*days*/ 7, Grouping::Model)
+            .await
+            .unwrap_err(),
+        "Account changed. Press R to refresh Analytics."
+    );
+}
+
+#[tokio::test]
+async fn token_model_filter_reuses_the_account_scoped_response() {
+    let server = MockServer::start().await;
+    let (_home, live) = live(&server, "business").await;
+    let today = live.end_date.to_string();
+    Mock::given(method("GET"))
+        .and(path("/backend-api/wham/usage/daily-workspace-user-token-usage-breakdown"))
+        .respond_with(ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"data":[{
+            "date":today, "product_surface_usage_values": {}, "groups":[
+                {"dimensions":{"model":"alpha"}, "credits": 0, "uncached_text_input_tokens":10,"cached_text_input_tokens":20,"text_output_tokens":30},
+                {"dimensions":{"model":"beta"}, "credits": 0, "uncached_text_input_tokens":100,"cached_text_input_tokens":200,"text_output_tokens":300}
+            ]
+        }]})))
+        .expect(/*r*/ 1).mount(&server).await;
+    let all = live
+        .history(Report::Usage, /*days*/ 7, Grouping::TokenType)
+        .await
+        .unwrap()
+        .unwrap();
+    let alpha = live
+        .filtered_history(
+            Report::Usage,
+            /*days*/ 7,
+            Grouping::TokenType,
+            Some("alpha"),
+        )
+        .await
+        .unwrap()
+        .unwrap();
+    let beta = live
+        .filtered_history(
+            Report::Usage,
+            /*days*/ 7,
+            Grouping::TokenType,
+            Some("beta"),
+        )
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(
+        (all.data[0].total, alpha.data[0].total, beta.data[0].total),
+        (660.0, 60.0, 600.0)
+    );
+    assert_eq!(
+        live.token_models(),
+        vec!["beta".to_string(), "alpha".to_string()]
+    );
+    assert_eq!(report_requests(&server).await.len(), 1);
+}
+
+#[tokio::test]
+async fn legacy_usage_falls_back_to_surface_for_attribution_only_groupings() {
+    let server = MockServer::start().await;
+    let (_home, live) = live(&server, "plus").await;
+    let today = live.end_date.to_string();
+    Mock::given(method("GET"))
+        .respond_with(
+            ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"data": [{
+                "date": today, "product_surface_usage_values": {"cli": 12.5}
+            }]})),
+        )
+        .expect(/*r*/ 1)
+        .mount(&server)
+        .await;
+    let surface = live
+        .history(Report::Usage, /*days*/ 7, Grouping::Surface)
+        .await
+        .unwrap();
+    for grouping in [Grouping::Feature, Grouping::TaskStart] {
+        let history = live
+            .history(Report::Usage, /*days*/ 7, grouping)
+            .await
+            .unwrap();
+        assert_eq!((live.attributed_usage(), history), (false, surface.clone()));
+    }
+    server.verify().await;
+}
+
+#[tokio::test]
+async fn invalid_ranges_fail_without_requesting_reports() {
+    let server = MockServer::start().await;
+    let (_home, live) = live(&server, "plus").await;
+    for days in [0, u32::MAX] {
+        assert_eq!(
+            live.history(Report::Usage, days, Grouping::Surface)
+                .await
+                .unwrap_err(),
+            "Invalid analytics date range."
+        );
+    }
+    assert!(report_requests(&server).await.is_empty());
+}
+
+#[tokio::test]
+async fn unknown_plan_exposes_no_credit_breakdowns() {
+    let server = MockServer::start().await;
+    let (_home, live) = live(&server, "unknown").await;
+    live.session().await.unwrap();
+    assert!(live.credit_groups().is_empty());
+    assert!(
+        live.history(Report::Credits, /*days*/ 7, Grouping::Surface)
+            .await
+            .is_err()
+    );
+    assert!(report_requests(&server).await.is_empty());
+}
+
+#[tokio::test]
+async fn in_flight_account_switch_retains_refresh_guidance() {
+    let server = MockServer::start().await;
+    let (home, live) = live(&server, "plus").await;
+    let home_path = home.path().to_path_buf();
+    Mock::given(method("GET"))
+        .respond_with(move |_: &wiremock::Request| {
+            sign_in(&home_path, "account-b", "user-a", "plus");
+            ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"data": []}))
+        })
+        .expect(/*r*/ 1)
+        .mount(&server)
+        .await;
+    assert_eq!(
+        live.history(Report::Usage, /*days*/ 7, Grouping::Surface)
+            .await
+            .unwrap_err(),
+        "Account changed. Press R to refresh Analytics."
+    );
+    server.verify().await;
+}
+
+#[tokio::test]
+async fn missing_breakdowns_remain_unavailable() {
+    let server = MockServer::start().await;
+    let (_home, live) = live(&server, "plus").await;
+    let today = live.end_date.to_string();
+    Mock::given(method("GET"))
+        .respond_with(
+            ResponseTemplate::new(/*s*/ 200).set_body_json(
+                json!({"data": [{"date": today, "product_surface_usage_values": {}}]}),
+            ),
+        )
+        .expect(/*r*/ 1)
+        .mount(&server)
+        .await;
+    assert_eq!(
+        live.history(Report::Usage, /*days*/ 7, Grouping::Model)
+            .await,
+        Ok(None)
+    );
+    server.verify().await;
+}
+
+#[tokio::test]
+async fn out_of_range_legacy_rows_do_not_disable_attribution() {
+    let server = MockServer::start().await;
+    let (_home, live) = live(&server, "plus").await;
+    let today = live.end_date.to_string();
+    Mock::given(method("GET"))
+        .respond_with(
+            ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"data": [
+                {"date": "2000-01-01", "product_surface_usage_values": {}},
+                {"date": today, "product_surface_usage_values": {}, "attribution": [{"thread_source": "user", "turn_trigger": "composer", "model": "example", "surface": "cli", "value": 12.0}]}
+            ]})),
+        )
+        .expect(/*r*/ 1)
+        .mount(&server)
+        .await;
+    let history = live
+        .history(Report::Usage, /*days*/ 7, Grouping::Feature)
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(
+        history.data,
+        vec![super::super::models::AccountAnalyticsDay {
+            date: live.end_date,
+            total: 12.0,
+            values: vec![super::super::models::AccountAnalyticsValue {
+                key: "user".into(),
+                label: "Tasks".into(),
+                value: 12.0,
+            }],
+        }]
+    );
+    assert!(live.attributed_usage());
+}
+
+#[tokio::test]
+async fn invalid_reports_can_retry_without_recreating_the_session() {
+    for plan in ["plus", "business"] {
+        let server = MockServer::start().await;
+        let (_home, live) = live(&server, plan).await;
+        let requests = Arc::new(std::sync::atomic::AtomicUsize::new(/*v*/ 0));
+        let count = Arc::clone(&requests);
+        Mock::given(method("GET"))
+            .respond_with(move |_: &wiremock::Request| {
+                let body = if count.fetch_add(/*val*/ 1, std::sync::atomic::Ordering::SeqCst) == 0 {
+                    json!({"data": [{"date": "invalid"}]})
+                } else {
+                    json!({"data": []})
+                };
+                ResponseTemplate::new(/*s*/ 200).set_body_json(body)
+            })
+            .expect(/*r*/ 2)
+            .mount(&server)
+            .await;
+        assert!(
+            live.history(Report::Usage, /*days*/ 7, Grouping::Surface)
+                .await
+                .is_err()
+        );
+        assert!(
+            live.history(Report::Usage, /*days*/ 7, Grouping::Surface)
+                .await
+                .is_ok()
+        );
+        assert_eq!(requests.load(std::sync::atomic::Ordering::SeqCst), 2);
+        server.verify().await;
+    }
+}
+
+#[tokio::test]
+async fn invalid_cached_breakdowns_are_evicted_before_retry() {
+    let server = MockServer::start().await;
+    let (_home, live) = live(&server, "plus").await;
+    let today = live.end_date.to_string();
+    let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(/*v*/ 0));
+    let count = Arc::clone(&attempts);
+    Mock::given(method("GET"))
+        .respond_with(move |_: &wiremock::Request| {
+            let model = if count.fetch_add(/*val*/ 1, std::sync::atomic::Ordering::SeqCst) == 0 {
+                json!({"model": "alpha", "credits": -1})
+            } else {
+                json!({"model": "alpha", "credits": 12})
+            };
+            ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"data": [{
+                "date": today, "product_surface_usage_values": {"cli": 12}, "models": [model]
+            }]}))
+        })
+        .expect(/*r*/ 2)
+        .mount(&server)
+        .await;
+    live.history(Report::Usage, /*days*/ 7, Grouping::Surface)
+        .await
+        .unwrap();
+    assert!(
+        live.history(Report::Usage, /*days*/ 7, Grouping::Model)
+            .await
+            .is_err()
+    );
+    assert!(
+        live.history(Report::Usage, /*days*/ 7, Grouping::Model)
+            .await
+            .unwrap()
+            .is_some()
+    );
+    assert_eq!(attempts.load(std::sync::atomic::Ordering::SeqCst), 2);
+    server.verify().await;
+}
+
+pub(in crate::analytics) async fn connected_view(
+    server: &MockServer,
+    plan: &str,
+) -> (
+    tempfile::TempDir,
+    crate::AppServerSession,
+    crate::analytics::AnalyticsView,
+) {
+    let (home, live) = live(server, plan).await;
+    let config = Arc::clone(&live.config);
+    let app_server = crate::start_embedded_app_server_for_picker(&config)
+        .await
+        .unwrap();
+    let mut view =
+        crate::analytics::AnalyticsView::new(crate::keymap::RuntimeKeymap::defaults().list);
+    view.open(
+        app_server.request_handle(),
+        crate::tui::FrameRequester::test_dummy(),
+        Vec::new(),
+        config,
+    );
+    (home, app_server, view)
+}
+
+#[tokio::test]
+async fn live_account_identity_is_visible_and_closing_aborts_pending_loads() {
+    let server = MockServer::start().await;
+    let (_home, live) = live(&server, "plus").await;
+    live.session().await.unwrap();
+    let mut view =
+        crate::analytics::AnalyticsView::new(crate::keymap::RuntimeKeymap::defaults().list);
+    view.live = Some(Arc::new(live));
+    view.sections[Section::Usage].history =
+        super::super::data::Load::Error("Couldn't load usage. Press R to retry.".into());
+    let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(
+        /*width*/ 100, /*height*/ 24,
+    ))
+    .unwrap();
+    terminal
+        .draw(|frame| view.render(frame.area(), frame.buffer_mut()))
+        .unwrap();
+    insta::assert_snapshot!(terminal.backend().to_string());
+    let (draw_tx, _) = tokio::sync::broadcast::channel(/*capacity*/ 1);
+    let (cancelled_tx, cancelled_rx) = tokio::sync::oneshot::channel::<()>();
+    view.sections[Section::Usage].history = super::super::data::Load::start(
+        async move {
+            let _cancelled = cancelled_tx;
+            std::future::pending().await
+        },
+        crate::tui::FrameRequester::new(draw_tx),
+    );
+    view.cancel_loads();
+    assert!(cancelled_rx.await.is_err());
+}
+
+#[tokio::test]
+async fn plan_history_rejects_account_change_during_response() {
+    let server = MockServer::start().await;
+    for status in [200, 404, 503] {
+        server.reset().await;
+        let (home, live) = live(&server, "plus").await;
+        let home_path = home.path().to_path_buf();
+        Mock::given(method("GET"))
+            .and(path("/backend-api/wham/usage/plan_limit_history"))
+            .and(header("chatgpt-account-id", "account-a"))
+            .respond_with(move |_: &wiremock::Request| {
+                sign_in(&home_path, "account-a", "user-b", "plus");
+                ResponseTemplate::new(status).set_body_json(json!({
+                    "data_as_of":"2026-09-02T00:00:00Z", "coverage_start":null,
+                    "coverage_complete":true, "periods":[]
+                }))
+            })
+            .expect(/*r*/ 1)
+            .mount(&server)
+            .await;
+        assert_eq!(
+            live.plan_history().await.err().unwrap(),
+            "Account changed. Press R to refresh Analytics."
+        );
+    }
+}
+
+#[path = "profile_identity_tests.rs"]
+mod profile_identity;

codex-rs/tui/src/analytics/compact_tests.rs

@@ -0,0 +1,48 @@
+//! Large report totals and axes stay compact while selected-day details retain precision.
+use super::*;
+
+#[test]
+fn report_headlines_and_axes_compact_large_values() {
+    let mut screenshots = Vec::new();
+    for (section, unit, total, headline) in [
+        (
+            Section::Usage,
+            models::AccountAnalyticsUnit::Tokens,
+            12_280_365_226.0,
+            "12.3B tokens",
+        ),
+        (
+            Section::Plugins,
+            models::AccountAnalyticsUnit::Count,
+            9_749.0,
+            "9.7K calls",
+        ),
+        (
+            Section::Skills,
+            models::AccountAnalyticsUnit::Count,
+            2_901.0,
+            "2.9K uses",
+        ),
+    ] {
+        let mut view = fixture::view(models::AccountKind::Enterprise);
+        view.section = section;
+        view.sections[section].history = Load::Ready(models::AccountAnalyticsHistory {
+            unit,
+            updated_at: None,
+            data: vec![models::AccountAnalyticsDay {
+                date: view.end_date,
+                total,
+                values: vec![models::AccountAnalyticsValue {
+                    key: "test".into(),
+                    label: "Example".into(),
+                    value: total,
+                }],
+            }],
+        });
+        let rendered = screen(&mut view, /*width*/ 100, /*height*/ 30);
+        assert!(rendered.contains(headline));
+        assert!(rendered.contains(&data::amount(total)));
+        screenshots.push(rendered);
+    }
+    insta::assert_snapshot!(screenshots.join("\n"));
+}

codex-rs/tui/src/analytics/connection_tests.rs

@@ -0,0 +1,237 @@
+//! Exercise local Analytics plan discovery and report recovery while connected to an app-server.
+
+use super::tests::live;
+use codex_app_server_client::AppServerRequestHandle;
+use codex_app_server_client::RemoteAppServerClient;
+use codex_app_server_client::RemoteAppServerConnectArgs;
+use codex_app_server_client::RemoteAppServerEndpoint;
+use futures::SinkExt;
+use futures::StreamExt;
+use pretty_assertions::assert_eq;
+use serde_json::Value;
+use serde_json::json;
+use tokio::net::TcpListener;
+use tokio::net::TcpStream;
+use tokio_tungstenite::WebSocketStream;
+use tokio_tungstenite::tungstenite::Message;
+use wiremock::Mock;
+use wiremock::ResponseTemplate;
+use wiremock::matchers::header;
+use wiremock::matchers::method;
+
+async fn read(socket: &mut WebSocketStream<TcpStream>) -> Value {
+    let frame = socket.next().await.unwrap().unwrap();
+    serde_json::from_str(frame.to_text().unwrap()).unwrap()
+}
+
+async fn remote() -> (RemoteAppServerClient, tokio::task::JoinHandle<()>) {
+    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let address = listener.local_addr().unwrap();
+    let server = tokio::spawn(async move {
+        let (stream, _) = listener.accept().await.unwrap();
+        let mut socket = tokio_tungstenite::accept_async(stream).await.unwrap();
+        let initialize = read(&mut socket).await;
+        assert_eq!(initialize["method"], "initialize");
+        socket
+            .send(Message::Text(
+                json!({"id": initialize["id"], "result": {
+                    "userAgent": "analytics-test", "codexHome": "/server/.codex",
+                }})
+                .to_string()
+                .into(),
+            ))
+            .await
+            .unwrap();
+        assert_eq!(read(&mut socket).await["method"], "initialized");
+        // Analytics uses the local account without requesting connected-server account data.
+        assert!(socket.next().await.unwrap().unwrap().is_close());
+    });
+    let client = RemoteAppServerClient::connect(RemoteAppServerConnectArgs {
+        endpoint: RemoteAppServerEndpoint::WebSocket {
+            websocket_url: format!("ws://{address}"),
+            auth_token: None,
+        },
+        client_name: "analytics-test".into(),
+        client_version: "0.0.0-test".into(),
+        experimental_api: true,
+        mcp_server_openai_form_elicitation: false,
+        opt_out_notification_methods: Vec::new(),
+        channel_capacity: 8,
+    })
+    .await
+    .unwrap();
+    (client, server)
+}
+
+#[tokio::test]
+async fn local_reports_share_an_account_and_recover_profile_errors() {
+    use crate::analytics::AnalyticsView;
+    use crate::analytics::data::Load;
+    use crate::analytics::sections::Section;
+
+    let http = crate::analytics::test_support::server().await;
+    let (_home, local) = live(&http, "enterprise").await;
+    let (client, server) = remote().await;
+    let failed_profile = Mock::given(method("GET"))
+        .and(wiremock::matchers::path("/backend-api/wham/profiles/me"))
+        .and(header("chatgpt-account-id", "account-a"))
+        .respond_with(ResponseTemplate::new(/*s*/ 503))
+        .expect(/*r*/ 1)
+        .mount_as_scoped(&http)
+        .await;
+    let mut view = AnalyticsView::new(crate::keymap::RuntimeKeymap::defaults().list);
+    view.open(
+        AppServerRequestHandle::Remote(client.request_handle()),
+        crate::tui::FrameRequester::test_dummy(),
+        Vec::new(),
+        std::sync::Arc::clone(&local.config),
+    );
+    crate::analytics::test_support::settle(&mut view).await;
+    assert_eq!(
+        view.visible_sections(),
+        &[
+            Section::Summary,
+            Section::Credits,
+            Section::Usage,
+            Section::Plugins,
+            Section::Skills,
+        ]
+    );
+    assert!(matches!(view.profile, Load::Error(_)));
+    for section in view.visible_sections() {
+        if section.report().is_some() {
+            assert!(view.sections[*section].history.ready().is_some());
+        }
+    }
+    view.select_summary(/*view*/ None);
+    view.end_date = "2026-09-09".parse().unwrap();
+    let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(
+        /*width*/ 100, /*height*/ 48,
+    ))
+    .unwrap();
+    terminal
+        .draw(|frame| view.render(frame.area(), frame.buffer_mut()))
+        .unwrap();
+    insta::assert_snapshot!("local_profile_error", terminal.backend().to_string());
+    drop(failed_profile);
+
+    let profile = json!({
+        "profile":{"display_name":"Local account","username":"local-user"},
+        "stats":{"lifetime_tokens":12345,"peak_daily_tokens":12345,
+            "daily_usage_buckets":[{"start_date":"2026-09-09","tokens":12345}]}
+    });
+    Mock::given(method("GET"))
+        .and(wiremock::matchers::path("/backend-api/wham/profiles/me"))
+        .and(header("chatgpt-account-id", "account-a"))
+        .respond_with(ResponseTemplate::new(/*s*/ 200).set_body_json(profile.clone()))
+        .expect(/*r*/ 1)
+        .mount(&http)
+        .await;
+    view.refresh();
+    crate::analytics::test_support::settle(&mut view).await;
+    assert_eq!(
+        view.profile.ready(),
+        Some(&serde_json::from_value(profile).unwrap())
+    );
+    view.end_date = "2026-09-09".parse().unwrap();
+    terminal
+        .draw(|frame| view.render(frame.area(), frame.buffer_mut()))
+        .unwrap();
+    insta::assert_snapshot!("local_profile_recovered", terminal.backend().to_string());
+    for request in http.received_requests().await.unwrap() {
+        assert_eq!(
+            request.headers.get("chatgpt-account-id").unwrap(),
+            "account-a"
+        );
+    }
+    view.cancel_loads();
+    client.shutdown().await.unwrap();
+    server.await.unwrap();
+}
+
+#[tokio::test]
+async fn account_lookup_failure_recovers_on_refresh_with_the_server_plan() {
+    use crate::analytics::AnalyticsView;
+    use crate::analytics::data::Load;
+    use crate::analytics::sections::Section;
+
+    let http = crate::analytics::test_support::server().await;
+    let (_home, local) = live(&http, "plus").await;
+    let (client, server) = remote().await;
+    Mock::given(method("GET"))
+        .and(wiremock::matchers::path("/backend-api/wham/accounts/check"))
+        .respond_with(ResponseTemplate::new(/*s*/ 503))
+        .with_priority(/*p*/ 1)
+        .expect(/*r*/ 1)
+        .up_to_n_times(/*n*/ 1)
+        .mount(&http)
+        .await;
+    let mut view = AnalyticsView::new(crate::keymap::RuntimeKeymap::defaults().list);
+    view.open(
+        AppServerRequestHandle::Remote(client.request_handle()),
+        crate::tui::FrameRequester::test_dummy(),
+        Vec::new(),
+        std::sync::Arc::clone(&local.config),
+    );
+    crate::analytics::test_support::settle(&mut view).await;
+    assert!(matches!(view.account, Load::Error(_)));
+    assert_eq!(
+        http.received_requests()
+            .await
+            .unwrap()
+            .iter()
+            .map(|request| request.url.path())
+            .collect::<Vec<_>>(),
+        ["/backend-api/wham/accounts/check"]
+    );
+    view.end_date = "2026-09-09".parse().unwrap();
+    let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(
+        /*width*/ 100, /*height*/ 40,
+    ))
+    .unwrap();
+    terminal
+        .draw(|frame| view.render(frame.area(), frame.buffer_mut()))
+        .unwrap();
+    insta::assert_snapshot!("account_plan_error", terminal.backend().to_string());
+
+    Mock::given(method("GET"))
+        .and(wiremock::matchers::path("/backend-api/wham/accounts/check"))
+        .and(header("chatgpt-account-id", "account-a"))
+        .respond_with(ResponseTemplate::new(/*s*/ 200).set_body_json(json!({
+            "accounts": [{"id": "account-a", "plan_type": "enterprise"}]
+        })))
+        .with_priority(/*p*/ 1)
+        .expect(/*r*/ 1)
+        .mount(&http)
+        .await;
+    Mock::given(method("GET"))
+        .and(wiremock::matchers::path("/backend-api/wham/profiles/me"))
+        .respond_with(ResponseTemplate::new(/*s*/ 200).set_body_json(json!({"stats": {}})))
+        .mount(&http)
+        .await;
+    view.refresh();
+    crate::analytics::test_support::settle(&mut view).await;
+    assert_eq!(
+        view.visible_sections(),
+        &[
+            Section::Summary,
+            Section::Credits,
+            Section::Usage,
+            Section::Plugins,
+            Section::Skills,
+        ]
+    );
+    assert_eq!(
+        view.account.ready(),
+        Some(&codex_protocol::account::PlanType::Enterprise)
+    );
+    for section in view.visible_sections() {
+        if section.report().is_some() {
+            assert!(view.sections[*section].history.ready().is_some());
+        }
+    }
+    http.verify().await;
+    view.cancel_loads();
+    client.shutdown().await.unwrap();
+    server.await.unwrap();
+}

codex-rs/tui/src/analytics/consumer_refresh_tests.rs

@@ -0,0 +1,105 @@
+//! Consumer chat columns follow reported metrics without substituting billing estimates.
+use super::*;
+use crate::analytics::tasks::Chat;
+use crate::analytics::tasks::Chats;
+use pretty_assertions::assert_eq;
+use serde_json::json;
+
+#[test]
+fn consumer_chats_keep_missing_rows_and_only_offer_known_metrics() {
+    let mut view = fixture::view(models::AccountKind::Consumer);
+    view.section = Section::Chats;
+    view.tasks = Load::Ready(Chats {
+        rows: vec![
+            Chat { title: "Private title from another account".into(), task: None },
+            Chat { title: "Unverified backend row".into(), task: Some(serde_json::from_value(json!({
+                "thread_id":"unavailable", "data_status":"unavailable", "usage_source":"unknown",
+                "weekly_limit_percent":null,"five_hour_limit_percent":null,"balance_usage_credits":null,"groups":[]
+            })).unwrap()) },
+            Chat { title: "Refunded task".into(), task: Some(serde_json::from_value(json!({
+                "thread_id":"refund", "data_status":"partial", "usage_source":"credits",
+                "weekly_limit_percent":null,"five_hour_limit_percent":null,"balance_usage_credits":"-0.000004","groups":[{
+                    "product_experience":"codex", "model":"gpt-5.5", "reasoning_effort":"high", "speed":"fast",
+                    "weekly_limit_percent":null,"five_hour_limit_percent":null,"balance_usage_credits":"-0.000004"
+                }]
+            })).unwrap()) },
+        ], ..Chats::default()
+    });
+    assert_eq!(view.task_metrics(), vec![2]);
+    assert_eq!(
+        view.task_rows()
+            .iter()
+            .map(|row| row.title.as_str())
+            .collect::<Vec<_>>(),
+        vec![
+            "Refunded task",
+            "Private title from another account",
+            "Unverified backend row"
+        ]
+    );
+    press(&mut view, KeyCode::Down);
+    press(&mut view, KeyCode::Enter);
+    assert_eq!(view.sections[Section::Chats].detail, None);
+    let hidden = screen(&mut view, /*width*/ 90, /*height*/ 30);
+    assert!(!hidden.contains("Private title") && !hidden.contains("Unverified backend row"));
+    press(&mut view, KeyCode::Up);
+    press(&mut view, KeyCode::Enter);
+    insta::assert_snapshot!(screen(&mut view, /*width*/ 90, /*height*/ 30));
+    let chats = match &mut view.tasks {
+        Load::Ready(chats) => chats,
+        _ => unreachable!(),
+    };
+    chats.rows[2]
+        .task
+        .as_mut()
+        .unwrap()
+        .amounts
+        .five_hour_limit_percent = Some(0.0);
+    chats.rows[2]
+        .task
+        .as_mut()
+        .unwrap()
+        .amounts
+        .weekly_limit_percent = Some(125.0);
+    assert_eq!(view.task_metrics(), vec![0, 1, 2]);
+    insta::assert_snapshot!(
+        "consumer_chat_all_metrics",
+        screen(&mut view, /*width*/ 110, /*height*/ 30)
+    );
+    press(&mut view, KeyCode::Char('s'));
+    insta::assert_snapshot!(
+        "consumer_chat_available_limits",
+        screen(&mut view, /*width*/ 58, /*height*/ 30)
+    );
+}
+
+#[test]
+fn consumer_overview_shows_top_five_and_closes_with_retained_details() {
+    let mut view = fixture::view(models::AccountKind::Consumer);
+    view.section = Section::Chats;
+    view.tasks = Load::Ready(Chats {
+        rows: (0..6).map(|index| Chat {
+            title: format!("Task {index}"),
+            task: Some(serde_json::from_value(json!({
+                "thread_id":format!("task-{index}"), "data_status":"available", "usage_source":"credits",
+                "balance_usage_credits":index.to_string(), "groups":[]
+            })).unwrap()),
+        }).collect(),
+        ..Chats::default()
+    });
+    press(&mut view, KeyCode::End);
+    press(&mut view, KeyCode::Enter);
+    assert_eq!(view.sections[Section::Chats].detail, Some(5));
+    press(&mut view, KeyCode::Char('z'));
+    let content = view
+        .task_lines(/*width*/ 70)
+        .0
+        .iter()
+        .map(ToString::to_string)
+        .collect::<Vec<_>>()
+        .join("\n");
+    assert!(content.contains("Task 5") && !content.contains("Task 0"));
+    insta::assert_snapshot!(content);
+    press(&mut view, KeyCode::Esc);
+    assert!(view.is_done);
+}

codex-rs/tui/src/analytics/dashboard.rs

@@ -0,0 +1,225 @@
+//! Bordered, aligned overview cards. Detailed reports remain in maximized mode.
+//! Card heights depend on the viewport, never on the selected day or load state.
+
+use super::AnalyticsView;
+use super::data;
+use super::render::columns;
+use super::render::join_columns;
+use super::styles::number;
+use super::styles::secondary_style;
+use crate::analytics::sections::Section;
+use crate::line_truncation::truncate_line_with_ellipsis_if_overflow as truncate;
+use crate::style::accent_style;
+use crate::wrapping::RtOptions;
+use crate::wrapping::word_wrap_lines;
+use ratatui::style::Styled;
+use ratatui::style::Stylize;
+use ratatui::text::Line;
+use std::ops::Range;
+
+impl AnalyticsView {
+    pub(super) fn dashboard_lines(
+        &self,
+        width: usize,
+        height: usize,
+    ) -> (Vec<Line<'static>>, Range<usize>) {
+        let count = if width >= 104 { 2 } else { 1 };
+        let card_width = if count == 2 { (width - 4) / 2 } else { width };
+        let visible = self.visible_sections();
+        let rows = visible.len().div_ceil(count).max(/*other*/ 1);
+        let card_height =
+            (height.saturating_sub(/*rhs*/ 2) / rows).clamp(/*min*/ 16, /*max*/ 24);
+        let inner_width = card_width.saturating_sub(/*rhs*/ 4).max(/*other*/ 1);
+        let inner_height = card_height - 4;
+        let mut lines = Vec::new();
+        let mut selected = 0..0;
+        for (row, chunk) in visible.chunks(count).enumerate() {
+            let mut cards = Vec::new();
+            for (column, section) in chunk.iter().copied().enumerate() {
+                let focused = self.section == section;
+                let border = if focused {
+                    accent_style()
+                } else {
+                    secondary_style().dim()
+                };
+                let mut content = Vec::new();
+                if !matches!(section, Section::Chats | Section::Plan | Section::Summary) {
+                    content.push(
+                        format!(
+                            "{}d{}",
+                            if self.ranges[self.range_group(section) as usize] == 0 {
+                                7
+                            } else {
+                                30
+                            },
+                            if section == Section::Usage && self.business() {
+                                format!(
+                                    " · {}",
+                                    self.token_model.as_deref().unwrap_or("All models")
+                                )
+                            } else {
+                                String::new()
+                            }
+                        )
+                        .set_style(secondary_style())
+                        .into(),
+                    );
+                }
+                if matches!(
+                    section,
+                    Section::Usage | Section::Credits | Section::Activity | Section::Plan
+                ) {
+                    content.push(
+                        format!(
+                            "By {}",
+                            self.group_label(section, self.sections[section].group)
+                                .to_lowercase()
+                        )
+                        .set_style(secondary_style())
+                        .into(),
+                    );
+                }
+                match section {
+                    Section::Summary => content.extend(self.summary_lines(inner_width)),
+                    Section::Usage
+                    | Section::Plugins
+                    | Section::Credits
+                    | Section::Activity
+                    | Section::Skills => content.extend(
+                        self.history_lines(
+                            section,
+                            inner_width,
+                            inner_height.saturating_sub(/*rhs*/ 13).max(/*other*/ 1),
+                        )
+                        .lines,
+                    ),
+                    Section::Plan => content.extend(self.plan_lines(inner_width).0),
+                    Section::Chats if !self.business() => {
+                        content.extend(self.task_lines(inner_width).0)
+                    }
+                    Section::Chats => {
+                        content.push(
+                            "30d active · lifetime credits"
+                                .set_style(secondary_style())
+                                .into(),
+                        );
+                        content.push(Line::default());
+                        if let Some(chats) = self.chats.ready() {
+                            if chats.rows.is_empty() {
+                                content.push(
+                                    "No recent local chats.".set_style(secondary_style()).into(),
+                                );
+                            }
+                            for chat in chats.rows.iter().take(/*n*/ 5) {
+                                let amount = chat
+                                    .usage
+                                    .as_ref()
+                                    .map(|usage| {
+                                        data::credits(usage.estimated_usage_credits_micros)
+                                    })
+                                    .unwrap_or_else(|| "—".into());
+                                content.push(columns(
+                                    truncate(
+                                        chat.display_title().to_string().into(),
+                                        inner_width.saturating_sub(amount.len() + 1),
+                                    ),
+                                    number(amount).into(),
+                                    inner_width,
+                                ));
+                            }
+                            content.push(Line::default());
+                            content.push(
+                                "Local chats · excludes subagents"
+                                    .set_style(secondary_style())
+                                    .into(),
+                            );
+                            if chats.rows.iter().any(|chat| chat.usage.is_none()) {
+                                content.push(
+                                    "Some estimates unavailable"
+                                        .set_style(secondary_style())
+                                        .into(),
+                                );
+                            }
+                        } else if let Some(message) = self.chats.message() {
+                            content.push(message.to_string().set_style(secondary_style()).into());
+                        }
+                    }
+                }
+                let mut content = word_wrap_lines(content, RtOptions::new(inner_width));
+                if content.len() > inner_height {
+                    content.truncate(inner_height);
+                    content[inner_height - 1] =
+                        "… z to maximize".set_style(secondary_style()).into();
+                }
+                content.resize(inner_height, Line::default());
+                let label = format!(
+                    " {} {} ",
+                    row * count + column + 1,
+                    self.section_title(section)
+                );
+                let title = truncate(
+                    Line::from(vec![
+                        " ".into(),
+                        if focused {
+                            "▸".set_style(accent_style())
+                        } else {
+                            " ".into()
+                        },
+                        if focused {
+                            label.bold()
+                        } else {
+                            label.set_style(secondary_style())
+                        },
+                    ]),
+                    card_width.saturating_sub(/*rhs*/ 3),
+                );
+                let mut top = vec!["╭─".set_style(border)];
+                top.extend(title.spans.iter().cloned());
+                top.push(
+                    "─"
+                        .repeat(card_width.saturating_sub(title.width() + 3))
+                        .set_style(border),
+                );
+                top.push("╮".set_style(border));
+                let blank = columns(
+                    "│".set_style(border).into(),
+                    "│".set_style(border).into(),
+                    card_width,
+                );
+                let mut card = vec![Line::from(top), blank.clone()];
+                card.extend(content.into_iter().map(|line| {
+                    let line = truncate(line, inner_width);
+                    let padding = card_width.saturating_sub(line.width() + 3);
+                    let mut padded = vec!["│".set_style(border), " ".into()];
+                    padded.extend(line.spans);
+                    padded.push(" ".repeat(padding).into());
+                    padded.push("│".set_style(border));
+                    Line::from(padded)
+                }));
+                card.push(blank);
+                card.push(
+                    format!("╰{}╯", "─".repeat(card_width.saturating_sub(/*rhs*/ 2)))
+                        .set_style(border)
+                        .into(),
+                );
+                cards.push(
+                    card.into_iter()
+                        .map(|line| truncate(line, card_width))
+                        .collect::<Vec<_>>(),
+                );
+            }
+            if chunk.contains(&self.section) {
+                selected = lines.len()..lines.len() + card_height;
+            }
+            lines.extend(if cards.len() == 2 {
+                join_columns(&cards[0], &cards[1], card_width)
+            } else {
+                cards.remove(/*index*/ 0)
+            });
+            if (row + 1) * count < visible.len() {
+                lines.push(Line::default());
+            }
+        }
+        (lines, selected)
+    }
+}

codex-rs/tui/src/analytics/dashboard_tests.rs

@@ -0,0 +1,99 @@
+//! Overview cards retain alignment and geometry while selection and report states change.
+use super::*;
+use crate::style::accent_style;
+use pretty_assertions::assert_eq;
+use ratatui::style::Modifier;
+
+use crate::analytics::sections::Section;
+#[test]
+fn dashboard_focus_uses_marker_and_default_foreground_title() {
+    let mut view = fixture::view(models::AccountKind::Consumer);
+    view.zoomed = false;
+    for section in [Section::Usage, Section::Activity] {
+        view.section = section;
+        let (lines, _) = view.dashboard_lines(/*width*/ 140, /*height*/ 56);
+        let title = lines
+            .iter()
+            .find(|line| line.spans.iter().any(|span| span.content == "▸"))
+            .unwrap();
+        let marker = title.spans.iter().find(|span| span.content == "▸").unwrap();
+        assert_eq!(marker.style, accent_style());
+        let focused_title = title
+            .spans
+            .iter()
+            .find(|span| span.content.contains(view.section_title(section)))
+            .unwrap();
+        assert_eq!(focused_title.style.fg, None);
+        assert!(focused_title.style.add_modifier.contains(Modifier::BOLD));
+        assert_eq!(title.to_string().matches('▸').count(), 1);
+    }
+}
+
+#[test]
+fn dashboard_cards_align_and_keep_stable_summary_heights() {
+    let mut view = fixture::view(models::AccountKind::Consumer);
+    press(&mut view, KeyCode::Char('z'));
+    let wide = screen(&mut view, /*width*/ 144, /*height*/ 64);
+    for (left, right) in [
+        ("1 Summary", "2 Total usage history"),
+        ("3 Messages", "4 Plugins called"),
+        ("5 Skills used", "6 Top chats"),
+    ] {
+        assert!(
+            wide.lines()
+                .any(|line| line.contains(left) && line.contains(right))
+        );
+    }
+    assert!(!wide.contains("Coverage from"));
+    let before = view.dashboard_lines(/*width*/ 140, /*height*/ 56);
+    press(&mut view, KeyCode::Left);
+    view.sections[Section::Plugins].history = Load::Error("Access denied for this report.".into());
+    let after = view.dashboard_lines(/*width*/ 140, /*height*/ 56);
+    assert_eq!((before.0.len(), before.1), (after.0.len(), after.1));
+    let edges = |lines: &[ratatui::text::Line<'_>]| {
+        lines
+            .iter()
+            .enumerate()
+            .filter(|(_, line)| line.to_string().starts_with(['╭', '╰']))
+            .map(|(index, _)| index)
+            .collect::<Vec<_>>()
+    };
+    assert_eq!(edges(&before.0), edges(&after.0));
+    for width in [1, 4, 40, 100, 140] {
+        assert!(
+            view.dashboard_lines(width, /*height*/ 56)
+                .0
+                .iter()
+                .all(|line| line.width() <= width)
+        );
+    }
+    let narrow = screen(&mut view, /*width*/ 72, /*height*/ 48);
+    assert!(narrow.contains("1 Summary"));
+    let context = (
+        view.section,
+        view.sections.0.each_ref().map(|state| state.cursor),
+        view.sections.0.each_ref().map(|state| state.group),
+    );
+    press(&mut view, KeyCode::Enter);
+    assert!(view.zoomed);
+    assert_eq!(
+        context,
+        (
+            view.section,
+            view.sections.0.each_ref().map(|state| state.cursor),
+            view.sections.0.each_ref().map(|state| state.group)
+        )
+    );
+    insta::assert_snapshot!(format!("{wide}\n{narrow}"));
+}
+
+#[test]
+fn overview_closes_on_escape_with_retained_day_details() {
+    let mut view = fixture::view(models::AccountKind::Consumer);
+    press(&mut view, KeyCode::Enter);
+    assert_eq!(view.sections[Section::Usage].detail, Some(6));
+    press(&mut view, KeyCode::Char('z'));
+    assert!(!view.zoomed);
+    press(&mut view, KeyCode::Esc);
+    assert!(view.is_done);
+}

codex-rs/tui/src/analytics/data.rs

@@ -0,0 +1,216 @@
+//! Report loading and grouping metadata for the account dashboard.
+//! Replacing a pending load aborts it; its response cannot populate a newer range or account.
+
+use super::models::AccountAnalyticsGrouping as Grouping;
+use crate::tui::FrameRequester;
+use futures::FutureExt;
+use std::panic::AssertUnwindSafe;
+use tokio::sync::oneshot;
+use tokio::task::JoinHandle;
+
+pub(super) const GROUPINGS: [Grouping; 7] = [
+    Grouping::Surface,
+    Grouping::Feature,
+    Grouping::Model,
+    Grouping::TaskStart,
+    Grouping::Speed,
+    Grouping::Reasoning,
+    Grouping::TokenType,
+];
+
+pub(super) const GROUP_LABELS: [&str; 7] = [
+    "Surface",
+    "Feature",
+    "Model",
+    "Turn start",
+    "Speed",
+    "Reasoning",
+    "Token type",
+];
+
+pub(super) struct Pending<T> {
+    receiver: oneshot::Receiver<Result<Option<T>, String>>,
+    task: JoinHandle<()>,
+}
+
+impl<T> Drop for Pending<T> {
+    fn drop(&mut self) {
+        self.task.abort();
+    }
+}
+
+pub(super) enum Load<T> {
+    Loading(Pending<T>),
+    Ready(T),
+    Unavailable,
+    Error(String),
+}
+
+impl<T: Send + 'static> Load<T> {
+    pub(super) fn start(
+        future: impl std::future::Future<Output = Result<Option<T>, String>> + Send + 'static,
+        frame: FrameRequester,
+    ) -> Self {
+        Self::start_with_timeout(future, frame, std::time::Duration::from_secs(/*secs*/ 30))
+    }
+
+    pub(super) fn start_with_timeout(
+        future: impl std::future::Future<Output = Result<Option<T>, String>> + Send + 'static,
+        frame: FrameRequester,
+        timeout: std::time::Duration,
+    ) -> Self {
+        let (sender, receiver) = oneshot::channel();
+        let task =
+            tokio::spawn(async move {
+                let result =
+                    match tokio::time::timeout(timeout, AssertUnwindSafe(future).catch_unwind())
+                        .await
+                    {
+                        Ok(Ok(result)) => result,
+                        Ok(Err(_)) => Err("Request interrupted. Press R to retry.".into()),
+                        Err(_) => Err("Request timed out. Press R to retry.".into()),
+                    };
+                let _ = sender.send(result);
+                frame.schedule_frame();
+            });
+        Self::Loading(Pending { receiver, task })
+    }
+
+    pub(super) fn poll(&mut self) {
+        if let Self::Loading(pending) = self {
+            *self = match pending.receiver.try_recv() {
+                Ok(Ok(Some(data))) => Self::Ready(data),
+                Ok(Ok(None)) => Self::Unavailable,
+                Ok(Err(message)) => Self::Error(message),
+                Err(oneshot::error::TryRecvError::Closed) => {
+                    Self::Error("Request interrupted. Press R to retry.".into())
+                }
+                Err(oneshot::error::TryRecvError::Empty) => return,
+            };
+        }
+    }
+
+    pub(super) fn ready(&self) -> Option<&T> {
+        if let Self::Ready(value) = self {
+            Some(value)
+        } else {
+            None
+        }
+    }
+
+    pub(super) fn message(&self) -> Option<&str> {
+        match self {
+            Self::Ready(_) => None,
+            Self::Loading(_) => Some("Loading…"),
+            Self::Unavailable => Some("No history has been reported."),
+            Self::Error(message) => Some(message),
+        }
+    }
+}
+
+/// Keep untyped server and transport diagnostics out of account reports.
+pub(super) fn error(_error: codex_app_server_client::TypedRequestError) -> String {
+    "Couldn't load analytics. Press R to retry.".into()
+}
+
+/// Keep tiny refunds visible while avoiding noise on ordinary credit amounts.
+pub(super) fn amount(value: f64) -> String {
+    if value == 0.0 {
+        return "0".into();
+    }
+    if value.abs() < 0.000001 {
+        return format!("{value:.2e}");
+    }
+    let rounded = if value.abs() < 0.01 {
+        format!("{value:.6}")
+    } else {
+        format!("{value:.2}")
+    };
+    let (whole, fraction) = rounded.split_once('.').unwrap_or((&rounded, ""));
+    let mut grouped = String::new();
+    for (index, ch) in whole.chars().enumerate() {
+        if index > 0
+            && ch.is_ascii_digit()
+            && (whole.len() - index).is_multiple_of(/*rhs*/ 3)
+            && !grouped.ends_with('-')
+        {
+            grouped.push(',');
+        }
+        grouped.push(ch);
+    }
+    let fraction = fraction.trim_end_matches('0');
+    if !fraction.is_empty() {
+        grouped.push('.');
+        grouped.push_str(fraction);
+    }
+    grouped
+}
+
+/// Compact headline and axis labels to one decimal, preserving small signed adjustments.
+pub(super) fn compact_amount(value: f64) -> String {
+    if value.abs() < 1_000.0 || !value.is_finite() {
+        return amount(value);
+    }
+    let units = ["K", "M", "B", "T"];
+    let mut scaled = value / 1_000.0;
+    let mut unit = 0;
+    // Promote before rounding would produce a label such as 1000K.
+    while scaled.abs() >= 999.95 && unit + 1 < units.len() {
+        scaled /= 1_000.0;
+        unit += 1;
+    }
+    let rounded = format!("{:.1}", (scaled * 10.0).round() / 10.0);
+    format!(
+        "{}{}",
+        rounded.trim_end_matches('0').trim_end_matches('.'),
+        units[unit]
+    )
+}
+
+/// Align ordinary credit amounts to two decimals without hiding tiny adjustments.
+pub(super) fn credit_amount(value: f64) -> String {
+    let formatted = amount(value);
+    if value != 0.0 && value.abs() < 0.01 {
+        return formatted;
+    }
+    match formatted.split_once('.') {
+        None => format!("{formatted}.00"),
+        Some((_, fraction)) if fraction.len() == 1 => format!("{formatted}0"),
+        Some(_) => formatted,
+    }
+}
+
+pub(super) fn credits(micros: i64) -> String {
+    let magnitude = micros.unsigned_abs();
+    if magnitude > 0 && magnitude < 10_000 {
+        let fractional = format!("{magnitude:06}");
+        return format!(
+            "{}0.{}",
+            if micros < 0 { "-" } else { "" },
+            fractional.trim_end_matches('0')
+        );
+    }
+    let cents = (magnitude + 5_000) / 10_000;
+    let mut whole = (cents / 100).to_string();
+    let digits = whole.len();
+    for index in (1..digits).rev() {
+        if (digits - index).is_multiple_of(/*rhs*/ 3) {
+            whole.insert(index, ',');
+        }
+    }
+    format!(
+        "{}{whole}.{:02}",
+        if micros < 0 { "-" } else { "" },
+        cents % 100
+    )
+}
+
+pub(super) fn date(date: &str) -> String {
+    chrono::NaiveDate::parse_from_str(date, "%Y-%m-%d")
+        .map(|date| date.format("%b %-d").to_string())
+        .unwrap_or_else(|_| date.to_string())
+}
+
+#[cfg(test)]
+#[path = "data_tests.rs"]
+mod tests;

codex-rs/tui/src/analytics/data_tests.rs

@@ -0,0 +1,132 @@
+//! Loading transitions and cancellation when a view replaces pending work.
+
+use super::*;
+use pretty_assertions::assert_eq;
+
+#[tokio::test]
+async fn completed_loads_publish_data_unavailability_and_errors() {
+    for (result, expected) in [
+        (Ok(Some(7)), (Some(7), None)),
+        (Ok(None), (None, Some("No history has been reported."))),
+        (
+            Err("temporary failure".to_string()),
+            (None, Some("temporary failure")),
+        ),
+    ] {
+        let mut load = Load::start(async move { result }, FrameRequester::test_dummy());
+        let Load::Loading(pending) = &mut load else {
+            unreachable!()
+        };
+        (&mut pending.task).await.unwrap();
+        load.poll();
+        assert_eq!((load.ready().copied(), load.message()), expected);
+    }
+}
+
+#[tokio::test]
+async fn replacing_a_pending_load_cancels_its_request() {
+    let (cancelled_tx, cancelled_rx) = oneshot::channel::<()>();
+    let load = Load::<()>::start(
+        async move {
+            let _cancelled = cancelled_tx;
+            std::future::pending().await
+        },
+        FrameRequester::test_dummy(),
+    );
+    tokio::task::yield_now().await;
+    drop(load);
+    assert!(cancelled_rx.await.is_err());
+}
+
+#[tokio::test]
+async fn panicking_loads_request_a_frame_and_report_interruption() {
+    let (draw, mut frames) = tokio::sync::broadcast::channel(/*capacity*/ 1);
+    let frame = FrameRequester::new(draw);
+    let mut load = Load::<()>::start(async { panic!("report task failed") }, frame.clone());
+    let Load::Loading(pending) = &mut load else {
+        unreachable!()
+    };
+    let _ = (&mut pending.task).await;
+    tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 1), frames.recv())
+        .await
+        .unwrap()
+        .unwrap();
+    load.poll();
+    assert_eq!(
+        load.message(),
+        Some("Request interrupted. Press R to retry.")
+    );
+}
+
+#[test]
+fn rpc_errors_do_not_expose_server_diagnostics() {
+    let error = codex_app_server_client::TypedRequestError::Server {
+        method: "thread/list".into(),
+        source: codex_app_server_protocol::JSONRPCErrorError {
+            code: -32603,
+            message: "Failed opening /private/workspace: token=secret".into(),
+            data: Some(serde_json::json!({"credential": "secret"})),
+        },
+    };
+    assert_eq!(
+        super::error(error),
+        "Couldn't load analytics. Press R to retry."
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn extended_chat_load_budget_still_times_out_and_can_be_cancelled() {
+    let (cancelled_tx, cancelled_rx) = oneshot::channel::<()>();
+    let mut load = Load::<()>::start_with_timeout(
+        async move {
+            let _cancelled = cancelled_tx;
+            std::future::pending().await
+        },
+        FrameRequester::test_dummy(),
+        std::time::Duration::from_secs(/*secs*/ 90),
+    );
+    tokio::task::yield_now().await;
+    tokio::time::advance(std::time::Duration::from_secs(/*secs*/ 31)).await;
+    load.poll();
+    assert!(matches!(load, Load::Loading(_)));
+    tokio::time::advance(std::time::Duration::from_secs(/*secs*/ 60)).await;
+    assert!(cancelled_rx.await.is_err());
+    load.poll();
+    assert_eq!(load.message(), Some("Request timed out. Press R to retry."));
+}
+
+#[test]
+fn compact_counts_round_promote_units_and_preserve_small_adjustments() {
+    let values = [
+        0.0,
+        959.0,
+        1_000.0,
+        9_749.0,
+        2_901.0,
+        12_280_365_226.0,
+        142_300_000_000.0,
+        999_999.0,
+        999_999_999.0,
+        -1_250.0,
+        -0.000004,
+        1_200_000_000_000.0,
+    ];
+    assert_eq!(
+        values.map(compact_amount),
+        [
+            "0",
+            "959",
+            "1K",
+            "9.7K",
+            "2.9K",
+            "12.3B",
+            "142.3B",
+            "1M",
+            "1B",
+            "-1.3K",
+            "-0.000004",
+            "1.2T"
+        ]
+        .map(str::to_string)
+    );
+}

codex-rs/tui/src/analytics/models.rs

@@ -0,0 +1,99 @@
+//! Private analytics display types, independent of the app-server wire protocol.
+
+use codex_protocol::account::PlanType;
+
+/// Billing families match the App's consumer, business, and workspace scopes.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum AccountKind {
+    Consumer,
+    Business,
+    Enterprise,
+    Unknown,
+}
+
+impl From<Option<PlanType>> for AccountKind {
+    fn from(plan: Option<PlanType>) -> Self {
+        match plan {
+            None | Some(PlanType::Unknown) => Self::Unknown,
+            Some(plan) if plan.is_team_like() => Self::Business,
+            Some(plan) if plan.is_workspace_account() => Self::Enterprise,
+            Some(_) => Self::Consumer,
+        }
+    }
+}
+
+/// Match the existing CLI thread-usage capability without widening other workspace reports.
+pub(super) fn thread_usage_supported(plan: Option<PlanType>) -> bool {
+    matches!(
+        plan,
+        Some(
+            PlanType::Business
+                | PlanType::EnterpriseCbpUsageBased
+                | PlanType::EnterpriseCbpAutomation
+        )
+    )
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum AccountAnalyticsReport {
+    Usage,
+    Credits,
+    Messages,
+    Plugins,
+    Skills,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum AccountAnalyticsGrouping {
+    Feature,
+    Model,
+    Surface,
+    TaskStart,
+    Speed,
+    Reasoning,
+    TokenType,
+}
+
+impl AccountAnalyticsGrouping {
+    /// Credit breakdowns supported by the account's billing report.
+    pub(crate) fn credit_groupings(plan: Option<PlanType>) -> &'static [Self] {
+        match AccountKind::from(plan) {
+            AccountKind::Business => &[Self::Surface, Self::Model, Self::Speed],
+            AccountKind::Enterprise => &[Self::Surface, Self::Model, Self::Speed, Self::Reasoning],
+            AccountKind::Consumer => &[Self::Surface],
+            AccountKind::Unknown => &[],
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum AccountAnalyticsUnit {
+    RelativeUsage,
+    Credits,
+    Count,
+    Tokens,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct AccountAnalyticsHistory {
+    pub(crate) unit: AccountAnalyticsUnit,
+    /// Source freshness in Unix seconds, when provided. Not a completeness watermark.
+    pub(crate) updated_at: Option<i64>,
+    pub(crate) data: Vec<AccountAnalyticsDay>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct AccountAnalyticsDay {
+    /// Source reporting date; display formatting belongs to the UI.
+    pub(crate) date: chrono::NaiveDate,
+    /// Full daily denominator, including non-task usage when grouped by task start.
+    pub(crate) total: f64,
+    pub(crate) values: Vec<AccountAnalyticsValue>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct AccountAnalyticsValue {
+    pub(crate) key: String,
+    pub(crate) label: String,
+    pub(crate) value: f64,
+}

codex-rs/tui/src/analytics/navigation_tests.rs

@@ -0,0 +1,272 @@
+//! Vim navigation aliases share arrow behavior while preserving configured bindings.
+
+use super::*;
+use crate::analytics::models::AccountKind;
+use codex_config::types::KeybindingSpec;
+use codex_config::types::KeybindingsSpec;
+use codex_config::types::TuiKeymap;
+use pretty_assertions::assert_eq;
+use serde_json::json;
+
+fn navigate(views: &mut [AnalyticsView; 2], keys: &[(char, KeyCode)], size: (u16, u16)) -> String {
+    let mut output = String::new();
+    for &(alias, arrow) in keys {
+        press(&mut views[0], KeyCode::Char(alias));
+        press(&mut views[1], arrow);
+        output = screen(&mut views[0], size.0, size.1);
+        assert_eq!(output, screen(&mut views[1], size.0, size.1), "{alias}");
+    }
+    output
+}
+
+#[test]
+fn vim_chart_navigation_matches_arrows_in_focused_and_dashboard_views() {
+    for (kind, section) in [
+        (AccountKind::Consumer, Section::Usage),
+        (AccountKind::Consumer, Section::Activity),
+        (AccountKind::Consumer, Section::Plugins),
+        (AccountKind::Consumer, Section::Skills),
+        (AccountKind::Business, Section::Usage),
+        (AccountKind::Business, Section::Credits),
+    ] {
+        for zoomed in [true, false] {
+            let mut views = [fixture::view(kind), fixture::view(kind)];
+            for view in &mut views {
+                view.section = section;
+                view.zoomed = zoomed;
+                view.sections[section].cursor = 3;
+                view.sections[section].detail = Some(3);
+            }
+            let output = navigate(
+                &mut views,
+                &[
+                    ('h', KeyCode::Left),
+                    ('h', KeyCode::Left),
+                    ('l', KeyCode::Right),
+                    ('j', KeyCode::Down),
+                    ('k', KeyCode::Up),
+                ],
+                /*size*/ (96, 32),
+            );
+            assert_eq!(
+                (
+                    views[0].section,
+                    views[0].sections[section].cursor,
+                    views[0].sections[section].detail
+                ),
+                (section, 2, Some(2))
+            );
+            if kind == AccountKind::Consumer && section == Section::Usage && zoomed {
+                insta::assert_snapshot!("vim_chart_navigation", output);
+            }
+        }
+    }
+}
+
+#[test]
+fn vim_plan_navigation_preserves_independent_windows_and_collapses_old_details() {
+    let mut views = [
+        fixture::view(AccountKind::Consumer),
+        fixture::view(AccountKind::Consumer),
+    ];
+    for view in &mut views {
+        let as_of = "2026-09-02T12:00:00Z"
+            .parse::<chrono::DateTime<chrono::Utc>>()
+            .unwrap();
+        view.plan.enabled = true;
+        view.plan.report = Load::Ready(plan::Report {
+            as_of,
+            coverage_start: None,
+            coverage_complete: true,
+            approximate: false,
+            periods: std::array::from_fn(|window| {
+                let length = if window == 0 {
+                    chrono::Duration::hours(/*hours*/ 5)
+                } else {
+                    chrono::Duration::days(/*days*/ 7)
+                };
+                (0..2)
+                    .map(|index| plan::Period {
+                        id: format!("{window}-{index}"),
+                        start: as_of - length * index,
+                        end: as_of - length * index + length,
+                        complete: true,
+                        used: Some(2500.0),
+                        breakdowns: None,
+                    })
+                    .collect()
+            }),
+        });
+        view.plan.poll();
+        view.plan.expanded = [Some("0-0".into()), Some("1-0".into())];
+        view.section = Section::Plan;
+    }
+    navigate(
+        &mut views,
+        &[
+            ('l', KeyCode::Right),
+            ('j', KeyCode::Down),
+            ('k', KeyCode::Up),
+            ('h', KeyCode::Left),
+            ('j', KeyCode::Down),
+        ],
+        /*size*/ (120, 30),
+    );
+    assert_eq!(
+        (
+            views[0].plan.window,
+            views[0].plan.cursor,
+            &views[0].plan.expanded
+        ),
+        (0, [1, 0], &[None, None])
+    );
+}
+
+#[test]
+fn vim_summary_navigation_scrolls_like_arrows() {
+    let mut views = [
+        fixture::view(AccountKind::Consumer),
+        fixture::view(AccountKind::Consumer),
+    ];
+    for view in &mut views {
+        view.section = Section::Summary;
+        view.profile = Load::Ready(
+            serde_json::from_value(json!({
+                "stats": {"lifetime_tokens": 123, "daily_usage_buckets": [
+                    {"start_date": "2026-09-02", "tokens": 123}
+                ]}
+            }))
+            .unwrap(),
+        );
+        assert!(screen(view, /*width*/ 64, /*height*/ 18).contains("scroll"));
+    }
+    navigate(
+        &mut views,
+        &[
+            ('h', KeyCode::Left),
+            ('l', KeyCode::Right),
+            ('j', KeyCode::Down),
+            ('j', KeyCode::Down),
+            ('k', KeyCode::Up),
+        ],
+        /*size*/ (64, 18),
+    );
+    assert_eq!(views[0].scroll_offset, 1);
+}
+
+#[test]
+fn vim_chat_navigation_expands_collapses_and_moves_like_arrows() {
+    for kind in [AccountKind::Consumer, AccountKind::Business] {
+        let mut views = [fixture::view(kind), fixture::view(kind)];
+        for view in &mut views {
+            view.section = Section::Chats;
+            if kind == AccountKind::Consumer {
+                view.tasks = Load::Ready(tasks::Chats {
+                    rows: (0..2)
+                        .map(|index| tasks::Chat {
+                            title: format!("Example chat {index}"),
+                            task: Some(
+                                serde_json::from_value(json!({
+                                    "thread_id": format!("chat-{index}"),
+                                    "data_status": "available", "usage_source": "accounting",
+                                    "weekly_limit_percent": 20 - index,
+                                    "five_hour_limit_percent": null, "balance_usage_credits": null,
+                                    "groups": []
+                                }))
+                                .unwrap(),
+                            ),
+                        })
+                        .collect(),
+                    ..tasks::Chats::default()
+                });
+            }
+        }
+        navigate(
+            &mut views,
+            &[
+                ('l', KeyCode::Right),
+                ('h', KeyCode::Left),
+                ('l', KeyCode::Right),
+                ('j', KeyCode::Down),
+                ('l', KeyCode::Right),
+                ('k', KeyCode::Up),
+            ],
+            /*size*/ (96, 32),
+        );
+        assert_eq!(
+            (
+                views[0].sections[Section::Chats].cursor,
+                views[0].sections[Section::Chats].detail
+            ),
+            (0, None)
+        );
+    }
+}
+
+#[test]
+fn configured_vim_keys_win_over_horizontal_aliases() {
+    let mut config = TuiKeymap::default();
+    config.list.jump_top = Some(KeybindingsSpec::Many(vec![
+        KeybindingSpec("h".into()),
+        KeybindingSpec("l".into()),
+    ]));
+    let mut view = fixture::view(AccountKind::Consumer);
+    view.keymap = RuntimeKeymap::from_config(&config).unwrap().list;
+    for alias in ['h', 'l'] {
+        view.sections[Section::Usage].cursor = 3;
+        press(&mut view, KeyCode::Char(alias));
+        assert_eq!(view.sections[Section::Usage].cursor, 0);
+    }
+}
+
+#[test]
+fn vim_aliases_respect_removed_and_remapped_arrows() {
+    let mut config = TuiKeymap::default();
+    config.list.move_left = Some(KeybindingsSpec::Many(Vec::new()));
+    config.list.move_right = Some(KeybindingsSpec::Many(Vec::new()));
+    config.list.move_up = Some(KeybindingsSpec::One(KeybindingSpec("up".into())));
+    config.list.move_down = Some(KeybindingsSpec::One(KeybindingSpec("down".into())));
+    let mut view = fixture::view(AccountKind::Consumer);
+    view.keymap = RuntimeKeymap::from_config(&config).unwrap().list;
+    view.sections[Section::Usage].cursor = 3;
+    for alias in ['h', 'j', 'k', 'l'] {
+        press(&mut view, KeyCode::Char(alias));
+        assert_eq!(view.sections[Section::Usage].cursor, 3);
+    }
+
+    config.list.move_up = Some(KeybindingsSpec::One(KeybindingSpec("right".into())));
+    config.list.move_down = Some(KeybindingsSpec::One(KeybindingSpec("left".into())));
+    view.keymap = RuntimeKeymap::from_config(&config).unwrap().list;
+    press(&mut view, KeyCode::Char('h'));
+    assert_eq!(view.sections[Section::Usage].cursor, 4);
+    press(&mut view, KeyCode::Char('l'));
+    assert_eq!(view.sections[Section::Usage].cursor, 3);
+}
+
+#[test]
+fn horizontal_aliases_ignore_modifiers_and_release_but_accept_repeat() {
+    let mut view = fixture::view(AccountKind::Consumer);
+    view.sections[Section::Usage].cursor = 3;
+    for alias in ['h', 'l'] {
+        for modifiers in [
+            KeyModifiers::ALT,
+            KeyModifiers::SHIFT,
+            KeyModifiers::CONTROL | KeyModifiers::ALT,
+        ] {
+            view.handle_key(KeyEvent::new(KeyCode::Char(alias), modifiers));
+            assert_eq!(view.sections[Section::Usage].cursor, 3);
+        }
+        view.handle_key(KeyEvent {
+            kind: KeyEventKind::Release,
+            ..KeyEvent::new(KeyCode::Char(alias), KeyModifiers::NONE)
+        });
+        assert_eq!(view.sections[Section::Usage].cursor, 3);
+    }
+    for (alias, cursor) in [('h', 2), ('l', 3)] {
+        view.handle_key(KeyEvent {
+            kind: KeyEventKind::Repeat,
+            ..KeyEvent::new(KeyCode::Char(alias), KeyModifiers::NONE)
+        });
+        assert_eq!(view.sections[Section::Usage].cursor, cursor);
+    }
+}

codex-rs/tui/src/analytics/normalize.rs

@@ -0,0 +1,364 @@
+//! Converts backend reports into display data while preserving missing values and full denominators.
+
+use super::models::AccountAnalyticsGrouping as Grouping;
+use super::models::AccountAnalyticsReport as Report;
+use super::models::*;
+use super::report_data::AnalyticsData;
+use chrono::DateTime;
+use chrono::NaiveDate;
+use std::collections::BTreeMap;
+
+/// Out-of-range legacy rows do not change attribution semantics for the requested period.
+pub(super) fn has_complete_attribution(
+    response: &AnalyticsData,
+    start: NaiveDate,
+    end: NaiveDate,
+) -> Result<bool, String> {
+    response
+        .data
+        .iter()
+        .try_fold(/*init*/ true, |complete, record| {
+            let date = NaiveDate::parse_from_str(
+                record.date.get(..10).unwrap_or(&record.date),
+                "%Y-%m-%d",
+            )
+            .map_err(|_| String::from("Analytics returned an invalid date."))?;
+            Ok(complete && (date < start || date > end || record.attribution.is_some()))
+        })
+}
+
+pub(super) fn history(
+    response: AnalyticsData,
+    report: Report,
+    grouping: Grouping,
+    start: NaiveDate,
+    end: NaiveDate,
+) -> Result<Option<AccountAnalyticsHistory>, String> {
+    if report == Report::Messages {
+        match grouping {
+            Grouping::Model | Grouping::Surface => {}
+            Grouping::Feature
+            | Grouping::TaskStart
+            | Grouping::Speed
+            | Grouping::Reasoning
+            | Grouping::TokenType => {
+                return Err(String::from("Unsupported message count grouping."));
+            }
+        }
+    }
+    let attributed = has_complete_attribution(&response, start, end)?;
+    let series = response.series.as_ref();
+    let mut days: BTreeMap<NaiveDate, (f64, BTreeMap<String, f64>)> = BTreeMap::new();
+    for record in response.data {
+        let date =
+            NaiveDate::parse_from_str(record.date.get(..10).unwrap_or(&record.date), "%Y-%m-%d")
+                .map_err(|_| String::from("Analytics returned an invalid date."))?;
+        if date < start || date > end {
+            continue;
+        }
+        let (total, values) = days.entry(date).or_default();
+        match report {
+            Report::Usage => {
+                let daily = if attributed {
+                    None
+                } else {
+                    match grouping {
+                        Grouping::Surface => record.product_surface_usage_values,
+                        Grouping::Model => record
+                            .models
+                            .map(|models| -> Result<_, String> {
+                                let mut values = BTreeMap::new();
+                                for model in models {
+                                    let amount = model
+                                        .credits
+                                        .ok_or("Plan usage amount was not reported.")?;
+                                    *values.entry(model.model).or_insert(/*default*/ 0.0) += amount;
+                                }
+                                Ok(values)
+                            })
+                            .transpose()?,
+                        _ => None,
+                    }
+                };
+                if let Some(daily) = daily {
+                    for (key, amount) in daily {
+                        if !amount.is_finite() || amount < 0.0 {
+                            return Err(String::from("Analytics returned an invalid amount."));
+                        }
+                        let key = if grouping == Grouping::Surface {
+                            if key.starts_with("work_") {
+                                "work"
+                            } else {
+                                "codex"
+                            }
+                            .to_string()
+                        } else if key.eq_ignore_ascii_case("other") {
+                            "other".to_string()
+                        } else {
+                            key
+                        };
+                        *total += amount;
+                        *values.entry(key).or_default() += amount;
+                    }
+                } else if let Some(attribution) = record.attribution.filter(|_| attributed) {
+                    for entry in attribution {
+                        if !entry.value.is_finite() || entry.value < 0.0 {
+                            return Err(String::from("Analytics returned an invalid amount."));
+                        }
+                        *total += entry.value;
+                        let key = match grouping {
+                            Grouping::Feature => entry.thread_source,
+                            Grouping::Model => entry.model,
+                            Grouping::Surface => entry.surface,
+                            Grouping::TaskStart => {
+                                entry.turn_trigger.map(|trigger| format!("start-{trigger}"))
+                            }
+                            Grouping::Speed | Grouping::Reasoning | Grouping::TokenType => {
+                                return Err(String::from("unsupported analytics grouping"));
+                            }
+                        }
+                        .unwrap_or_else(|| "unknown".to_string());
+                        *values.entry(key).or_default() += entry.value;
+                    }
+                } else {
+                    return Ok(None);
+                }
+            }
+
+            Report::Credits => {
+                if series.is_some() {
+                    let Some(credits) = record.values else {
+                        return Ok(None);
+                    };
+                    for (key, amount) in credits {
+                        *values.entry(key).or_default() += amount;
+                        *total += amount;
+                    }
+                } else if matches!(grouping, Grouping::Model | Grouping::Speed) {
+                    let Some(models) = record.models else {
+                        return Ok(None);
+                    };
+                    for model in models {
+                        let amount = model.on_demand_credits.unwrap_or(/*default*/ 0.0);
+                        let key = if grouping == Grouping::Speed {
+                            model.speed.unwrap_or_else(|| "unknown".to_string())
+                        } else {
+                            model.model
+                        };
+                        *values.entry(key).or_default() += amount;
+                        *total += amount;
+                    }
+                } else if let Some(premium) = record.premium_usage_values {
+                    for (surface, amount) in premium.credit_usage_credits {
+                        if !amount.is_finite() {
+                            return Err(String::from("Analytics returned an invalid amount."));
+                        }
+                        *values.entry(surface).or_default() += amount;
+                        *total += amount;
+                    }
+                } else if let (Some(amount), Some(surface)) =
+                    (record.credit_amount, record.product_surface)
+                {
+                    *values.entry(surface).or_default() += amount;
+                    *total += amount;
+                } else {
+                    return Ok(None);
+                }
+            }
+            Report::Messages => {
+                let authoritative = record
+                    .totals
+                    .ok_or_else(|| String::from("Message count is unavailable."))?
+                    .turns;
+                if !authoritative.is_finite() || authoritative < 0.0 {
+                    return Err(String::from("Analytics returned an invalid amount."));
+                }
+                let mut record_values = BTreeMap::<String, f64>::new();
+                if grouping == Grouping::Model {
+                    for model in record.models.unwrap_or_default() {
+                        let key = if model.model.eq_ignore_ascii_case("codex-auto-review")
+                            || model.model.eq_ignore_ascii_case("other")
+                        {
+                            "other".to_string()
+                        } else {
+                            model.model
+                        };
+                        let count = model
+                            .turns
+                            .ok_or_else(|| String::from("Turn count is unavailable."))?;
+                        if !count.is_finite() || count < 0.0 {
+                            return Err(String::from("Analytics returned an invalid amount."));
+                        }
+                        *record_values.entry(key).or_default() += count;
+                    }
+                } else {
+                    for client in record.clients.unwrap_or_default() {
+                        if !client.turns.is_finite() || client.turns < 0.0 {
+                            return Err(String::from("Analytics returned an invalid amount."));
+                        }
+                        let key = match client.client_id.as_str() {
+                            "CODEX_CLI" => "cli",
+                            "CODEX_IDE_VSCODE" => "vscode",
+                            "CODEX_WEB" => "web",
+                            "CODEX_DESKTOP_APP" | "CODEX_WORK_DESKTOP" => "desktop_app",
+                            "CODEX_WORK_WEB" => "work_web",
+                            "CODEX_WORK_MOBILE" => "mobile",
+                            "CODEX_GITHUB" => "github_code_review",
+                            _ => "other",
+                        };
+                        *record_values.entry(key.to_string()).or_default() += client.turns;
+                    }
+                }
+                let remainder =
+                    (authoritative - record_values.values().sum::<f64>()).max(/*other*/ 0.0);
+                if remainder > 0.0 {
+                    *record_values.entry("other".to_string()).or_default() += remainder;
+                }
+                for (key, count) in record_values {
+                    *values.entry(key).or_default() += count;
+                }
+                *total += authoritative;
+            }
+            Report::Plugins | Report::Skills => {
+                let overviews = if report == Report::Skills {
+                    record.skill_usage_overviews
+                } else {
+                    record.plugin_usage_overviews
+                }
+                .ok_or_else(|| String::from("Tool activity is unavailable."))?;
+                for tool in overviews {
+                    if !tool.invocation_counts.is_finite() || tool.invocation_counts < 0.0 {
+                        return Err(String::from("Analytics returned an invalid amount."));
+                    }
+                    *values.entry(tool.display_name).or_default() += tool.invocation_counts;
+                    *total += tool.invocation_counts;
+                }
+            }
+        }
+        if !total.is_finite()
+            || values
+                .values()
+                .any(|value| !value.is_finite() || (report != Report::Credits && *value < 0.0))
+        {
+            return Err(String::from("Analytics returned an invalid amount."));
+        }
+    }
+    if report == Report::Usage
+        && !attributed
+        && grouping == Grouping::Model
+        && response.units.as_deref() != Some("credits")
+    {
+        let mut totals = BTreeMap::<String, f64>::new();
+        for (_, values) in days.values() {
+            for (key, value) in values {
+                *totals.entry(key.clone()).or_default() += value;
+            }
+        }
+        let total: f64 = totals.values().sum();
+        for (_, values) in days.values_mut() {
+            let mut other = 0.0;
+            values.retain(|key, value| {
+                let amount = totals[key];
+                if key.eq_ignore_ascii_case("other") || (amount > 0.0 && amount < total * 0.01) {
+                    other += *value;
+                    false
+                } else {
+                    true
+                }
+            });
+            if other > 0.0 {
+                values.insert("other".to_string(), other);
+            }
+        }
+    }
+    if report == Report::Credits {
+        for date in start.iter_days().take_while(|date| *date <= end) {
+            days.entry(date).or_default();
+        }
+    }
+    Ok(Some(AccountAnalyticsHistory {
+        unit: match report {
+            Report::Usage if !attributed && response.units.as_deref() == Some("credits") => {
+                AccountAnalyticsUnit::Credits
+            }
+            Report::Usage => AccountAnalyticsUnit::RelativeUsage,
+            Report::Credits => AccountAnalyticsUnit::Credits,
+            Report::Messages | Report::Plugins | Report::Skills => AccountAnalyticsUnit::Count,
+        },
+        updated_at: response
+            .data_freshness_ts
+            .as_deref()
+            .and_then(|timestamp| DateTime::parse_from_rfc3339(timestamp).ok())
+            .map(|timestamp| timestamp.timestamp()),
+        data: days
+            .into_iter()
+            .map(|(date, (total, values))| AccountAnalyticsDay {
+                date,
+                total,
+                values: values
+                    .into_iter()
+                    .map(|(key, value)| AccountAnalyticsValue {
+                        label: series
+                            .and_then(|series| series.iter().find(|series| series.key == key))
+                            .map(|series| series.label.clone())
+                            .unwrap_or_else(|| label(&key).to_string()),
+                        key,
+                        value,
+                    })
+                    .collect(),
+            })
+            .collect(),
+    }))
+}
+
+pub(super) fn label(key: &str) -> &str {
+    match key {
+        "user" => "Tasks",
+        "subagent" => "Subagents",
+        "image_generation" => "Image generation",
+        "automation" => "Automations",
+        "guardian_review" => "Auto review",
+        "guardian_classifier" => "Auto review classifier",
+        "thread_title" => "Thread title",
+        "system" => "System",
+        "automated_review" => "Auto review",
+        "agent_identity" => "Workspace agents",
+        "memory_consolidation" => "Memory consolidation",
+        "cli" => "CLI",
+        "desktop_app" => "Desktop app",
+        "vscode" => "VS Code",
+        "web" => "Web",
+        "work_web" => "Work web",
+        "work_desktop" => "Work desktop",
+        "work_mobile" => "Work mobile",
+        "mobile" => "Mobile",
+        "slack" => "Slack",
+        "linear" => "Linear",
+        "jetbrains" => "JetBrains",
+        "sdk" => "SDK",
+        "exec" => "Exec",
+        "github" => "GitHub",
+        "codex" => "Codex",
+        "work" => "Work",
+        "code_review" | "github_code_review" => "Code review",
+        "start-user" | "start-composer" => "User messages",
+        "start-goal" => "Goals",
+        "start-composer_queue" => "Queued messages",
+        "start-composer_queue_run_now" => "Queued messages run now",
+        "start-automation_cron_scheduled" => "Scheduled automations",
+        "start-automation_cron_run_now" => "Automations run now",
+        "start-automation_heartbeat_scheduled" => "Scheduled follow-ups",
+        "start-automation_heartbeat_run_now" => "Follow-ups run now",
+        "start-app_tool_create_thread" => "Agent-created tasks",
+        "start-app_tool_send_message" => "Agent follow-ups",
+        "unknown" | "start-unknown" => "Unknown",
+        "fast" => "Fast",
+        "standard" => "Standard",
+        "other" | "start-other" => "Other",
+        _ => key,
+    }
+}
+
+#[cfg(test)]
+#[path = "normalize_tests.rs"]
+mod tests;

codex-rs/tui/src/analytics/normalize_tests.rs

@@ -0,0 +1,358 @@
+//! Regression coverage for daily report normalization and billing semantics.
+
+use super::*;
+use pretty_assertions::assert_eq;
+use serde_json::json;
+
+#[test]
+fn turn_start_includes_all_features_and_missing_attribution_is_unavailable() {
+    let date = NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 1, /*day*/ 9).unwrap();
+    let response = serde_json::from_value(json!({"data": [{"date": "2026-01-09", "attribution": [
+        {"thread_source": "user", "turn_trigger": "composer", "value": 30},
+        {"thread_source": "subagent", "value": 70}
+    ]}]}))
+    .unwrap();
+    assert_eq!(
+        history(response, Report::Usage, Grouping::TaskStart, date, date).unwrap(),
+        Some(AccountAnalyticsHistory {
+            unit: AccountAnalyticsUnit::RelativeUsage,
+            updated_at: None,
+            data: vec![AccountAnalyticsDay {
+                date: "2026-01-09".parse().unwrap(),
+                total: 100.0,
+                values: vec![
+                    AccountAnalyticsValue {
+                        key: "start-composer".to_string(),
+                        label: "User messages".to_string(),
+                        value: 30.0
+                    },
+                    AccountAnalyticsValue {
+                        key: "unknown".to_string(),
+                        label: "Unknown".to_string(),
+                        value: 70.0
+                    }
+                ],
+            }],
+        })
+    );
+    let response = serde_json::from_value(json!({"data": [{"date": "2026-01-09"}]})).unwrap();
+    assert_eq!(
+        history(response, Report::Usage, Grouping::Feature, date, date).unwrap(),
+        None
+    );
+}
+
+#[test]
+fn signed_credits_keep_daily_activity_when_the_period_nets_to_zero() {
+    let start = NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 1, /*day*/ 8).unwrap();
+    let end = NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 1, /*day*/ 9).unwrap();
+    let response = serde_json::from_value(json!({"data": [
+        {"date": "2026-01-08", "product_surface": "cli", "credit_amount": 0.004},
+        {"date": "2026-01-09", "product_surface": "desktop_app", "credit_amount": -0.004}
+    ]}))
+    .unwrap();
+    assert_eq!(
+        history(response, Report::Credits, Grouping::Surface, start, end).unwrap(),
+        Some(AccountAnalyticsHistory {
+            unit: AccountAnalyticsUnit::Credits,
+            updated_at: None,
+            data: [
+                ("2026-01-08", 0.004, "cli", "CLI"),
+                ("2026-01-09", -0.004, "desktop_app", "Desktop app")
+            ]
+            .into_iter()
+            .map(|(date, amount, key, label)| AccountAnalyticsDay {
+                date: date.parse().unwrap(),
+                total: amount,
+                values: vec![AccountAnalyticsValue {
+                    key: key.to_string(),
+                    label: label.to_string(),
+                    value: amount
+                }],
+            })
+            .collect(),
+        })
+    );
+}
+
+#[test]
+fn message_surfaces_include_both_desktop_clients_and_unmapped_counts() {
+    let date = NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 1, /*day*/ 9).unwrap();
+    let response = serde_json::from_value(
+        json!({"data": [{"date": "2026-01-09", "totals": {"turns": 10}, "clients": [
+            {"client_id": "CODEX_DESKTOP_APP", "turns": 2},
+            {"client_id": "CODEX_WORK_DESKTOP", "turns": 3},
+            {"client_id": "new_client", "turns": 1}
+        ]}]}),
+    )
+    .unwrap();
+    assert_eq!(
+        history(response, Report::Messages, Grouping::Surface, date, date)
+            .unwrap()
+            .unwrap()
+            .data,
+        vec![AccountAnalyticsDay {
+            date: "2026-01-09".parse().unwrap(),
+            total: 10.0,
+            values: vec![
+                AccountAnalyticsValue {
+                    key: "desktop_app".to_string(),
+                    label: "Desktop app".to_string(),
+                    value: 5.0
+                },
+                AccountAnalyticsValue {
+                    key: "other".to_string(),
+                    label: "Other".to_string(),
+                    value: 5.0
+                },
+            ],
+        }]
+    );
+}
+
+#[test]
+fn enterprise_credit_series_keep_labels_signed_values_and_freshness() {
+    let date = NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 1, /*day*/ 9).unwrap();
+    let response = serde_json::from_value(json!({
+        "series": [{"key": "medium", "label": "Medium", "total": 12.5}, {"key": "high", "label": "High", "total": -0.004}],
+        "data_freshness_ts": "2026-01-09T10:00:00Z",
+        "data": [{"date": "2026-01-09", "values": {"medium": 12.5, "high": -0.004}}]
+    })).unwrap();
+    assert_eq!(
+        history(response, Report::Credits, Grouping::Reasoning, date, date).unwrap(),
+        Some(AccountAnalyticsHistory {
+            unit: AccountAnalyticsUnit::Credits,
+            updated_at: Some(1767952800),
+            data: vec![AccountAnalyticsDay {
+                date,
+                total: 12.496,
+                values: vec![
+                    AccountAnalyticsValue {
+                        key: "high".into(),
+                        label: "High".into(),
+                        value: -0.004
+                    },
+                    AccountAnalyticsValue {
+                        key: "medium".into(),
+                        label: "Medium".into(),
+                        value: 12.5
+                    }
+                ],
+            }],
+        })
+    );
+}
+
+#[test]
+fn credit_timestamps_and_legacy_model_usage_follow_app_fallbacks() {
+    let date = NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 1, /*day*/ 9).unwrap();
+    let credits = serde_json::from_value(json!({"data": [{"date": "2026-01-09T05:00:00Z", "product_surface": "cli", "credit_amount": 12.5}]})).unwrap();
+    let usage = serde_json::from_value(json!({"data": [{"date": "2026-01-09", "models": [{"model": "model-a", "credits": 12.5}]}]})).unwrap();
+    let credits = history(credits, Report::Credits, Grouping::Surface, date, date)
+        .unwrap()
+        .unwrap();
+    let usage = history(usage, Report::Usage, Grouping::Model, date, date)
+        .unwrap()
+        .unwrap();
+    assert_eq!(
+        (
+            credits.data[0].total,
+            usage.data[0].total,
+            usage.data[0].values[0].key.as_str()
+        ),
+        (12.5, 12.5, "model-a")
+    );
+}
+
+#[test]
+fn count_reports_preserve_explicit_zero_and_omit_unreported_days() {
+    let start = NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 1, /*day*/ 8).unwrap();
+    let end = NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 1, /*day*/ 10).unwrap();
+    for (report, field) in [
+        (Report::Messages, "totals"),
+        (Report::Plugins, "plugin_usage_overviews"),
+        (Report::Skills, "skill_usage_overviews"),
+    ] {
+        let value = if report == Report::Messages {
+            json!({"turns": 0})
+        } else {
+            json!([])
+        };
+        let response =
+            serde_json::from_value(json!({"data": [{"date": "2026-01-08", (field): value}]}))
+                .unwrap();
+        assert_eq!(
+            history(response, report, Grouping::Surface, start, end).unwrap(),
+            Some(AccountAnalyticsHistory {
+                unit: AccountAnalyticsUnit::Count,
+                updated_at: None,
+                data: vec![AccountAnalyticsDay {
+                    date: start,
+                    total: 0.0,
+                    values: Vec::new()
+                }],
+            })
+        );
+    }
+}
+
+#[test]
+fn legacy_consumer_history_keeps_daily_products_and_models() {
+    let date = "2026-09-01".parse().unwrap();
+    let response: AnalyticsData = serde_json::from_value(json!({"units":"relative", "data":[{
+        "date":"2026-09-01",
+        "product_surface_usage_values":{"work_desktop":12,"work_web":8,"cli":30,"desktop_app":50},
+        "models":[{"model":"major","credits":98.5},{"model":"one-percent","credits":1},{"model":"tiny","credits":0.3},{"model":"OTHER","credits":0.2}]
+    }]})).unwrap();
+    for (grouping, expected) in [
+        (
+            Grouping::Surface,
+            vec![("codex", "Codex", 80.0), ("work", "Work", 20.0)],
+        ),
+        (
+            Grouping::Model,
+            vec![
+                ("major", "major", 98.5),
+                ("one-percent", "one-percent", 1.0),
+                ("other", "Other", 0.5),
+            ],
+        ),
+    ] {
+        assert_eq!(
+            history(response.clone(), Report::Usage, grouping, date, date).unwrap(),
+            Some(AccountAnalyticsHistory {
+                unit: AccountAnalyticsUnit::RelativeUsage,
+                updated_at: None,
+                data: vec![AccountAnalyticsDay {
+                    date,
+                    total: 100.0,
+                    values: expected
+                        .into_iter()
+                        .map(|(key, label, value)| AccountAnalyticsValue {
+                            key: key.into(),
+                            label: label.into(),
+                            value
+                        })
+                        .collect()
+                }],
+            })
+        );
+    }
+    let mut credits = response;
+    credits.units = Some("credits".into());
+    let model = history(credits, Report::Usage, Grouping::Model, date, date)
+        .unwrap()
+        .unwrap();
+    assert_eq!(
+        (model.unit, model.data[0].values.len()),
+        (AccountAnalyticsUnit::Credits, 4)
+    );
+}
+
+#[test]
+fn complete_attribution_wins_consistently_and_incomplete_attribution_is_not_mixed() {
+    let date = "2026-09-01".parse().unwrap();
+    let response: AnalyticsData = serde_json::from_value(json!({"units":"credits", "data":[{
+        "date":"2026-09-01", "product_surface_usage_values":{"cli":999},
+        "models":[{"model":"legacy","credits":999}],
+        "attribution":[
+            {"thread_source":"user","turn_trigger":"composer","surface":"desktop_app","model":"alpha","value":30},
+            {"thread_source":"subagent","turn_trigger":"goal","surface":"cli","model":"tiny","value":0.1}
+        ]
+    }]})).unwrap();
+    for grouping in [
+        Grouping::Feature,
+        Grouping::Model,
+        Grouping::Surface,
+        Grouping::TaskStart,
+    ] {
+        let normalized = history(response.clone(), Report::Usage, grouping, date, date)
+            .unwrap()
+            .unwrap();
+        assert_eq!(
+            (
+                normalized.unit,
+                normalized.data[0].total,
+                normalized.data[0].values.len()
+            ),
+            (AccountAnalyticsUnit::RelativeUsage, 30.1, 2)
+        );
+    }
+    let incomplete = serde_json::from_value(json!({"data":[
+        {"date":"2026-09-01", "attribution":[]}, {"date":"2026-09-02"}
+    ]}))
+    .unwrap();
+    assert_eq!(
+        history(
+            incomplete,
+            Report::Usage,
+            Grouping::Feature,
+            date,
+            "2026-09-02".parse().unwrap()
+        )
+        .unwrap(),
+        None
+    );
+}
+
+#[test]
+fn duplicate_message_dates_preserve_each_records_other_remainder() {
+    let date = NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 1, /*day*/ 9).unwrap();
+    for grouping in [Grouping::Model, Grouping::Surface] {
+        let response = serde_json::from_value(json!({"data": [
+            {"date": "2026-01-09", "totals": {"turns": 10}, "models": [{"model": "example", "turns": 8}], "clients": [{"client_id": "CODEX_CLI", "turns": 8}]},
+            {"date": "2026-01-09", "totals": {"turns": 10}, "models": [{"model": "example", "turns": 8}], "clients": [{"client_id": "CODEX_CLI", "turns": 8}]}
+        ]})).unwrap();
+        let (key, label) = if grouping == Grouping::Model {
+            ("example", "example")
+        } else {
+            ("cli", "CLI")
+        };
+        assert_eq!(
+            history(response, Report::Messages, grouping, date, date).unwrap(),
+            Some(AccountAnalyticsHistory {
+                unit: AccountAnalyticsUnit::Count,
+                updated_at: None,
+                data: vec![AccountAnalyticsDay {
+                    date,
+                    total: 20.0,
+                    values: vec![
+                        AccountAnalyticsValue {
+                            key: key.into(),
+                            label: label.into(),
+                            value: 16.0
+                        },
+                        AccountAnalyticsValue {
+                            key: "other".into(),
+                            label: "Other".into(),
+                            value: 4.0
+                        },
+                    ]
+                }],
+            })
+        );
+    }
+}
+
+#[test]
+fn unsupported_message_groupings_fail_even_without_records() {
+    let date = NaiveDate::from_ymd_opt(/*year*/ 2026, /*month*/ 1, /*day*/ 9).unwrap();
+    for grouping in [
+        Grouping::Feature,
+        Grouping::TaskStart,
+        Grouping::Speed,
+        Grouping::Reasoning,
+        Grouping::TokenType,
+    ] {
+        for data in [
+            json!([]),
+            json!([{"date": "2026-01-09", "totals": {"turns": 10}, "clients": []}]),
+        ] {
+            let response = serde_json::from_value(json!({"data": data})).unwrap();
+            assert_eq!(
+                history(response, Report::Messages, grouping, date, date),
+                Err("Unsupported message count grouping.".into())
+            );
+        }
+    }
+}

codex-rs/tui/src/analytics/panels.rs

@@ -0,0 +1,106 @@
+//! Responsive panels with consistent category colors and signed daily amounts.
+
+use super::AnalyticsView;
+use super::render::columns;
+use super::styles::secondary_style;
+use crate::analytics::sections::Section;
+use crate::style::accent_style;
+use crate::wrapping::RtOptions;
+use crate::wrapping::word_wrap_lines;
+use ratatui::style::Styled;
+use ratatui::style::Stylize;
+use ratatui::text::Line;
+use std::ops::Range;
+
+/// Panel content and measured geometry shared by layout and scrolling.
+pub(super) struct Panel {
+    pub(super) lines: Vec<Line<'static>>,
+    pub(super) selection: Range<usize>,
+    pub(super) chart_bands: usize,
+}
+
+impl AnalyticsView {
+    pub(super) fn panel(&self, section: Section, width: usize, chart_height: usize) -> Panel {
+        let focused = section == self.section;
+        let title = format!(
+            "{} {}",
+            if focused { "▎" } else { " " },
+            self.section_title(section)
+        );
+        let heading = if focused {
+            title.set_style(accent_style()).into()
+        } else {
+            title.bold().into()
+        };
+        let group = self.sections[section].group;
+        let heading = if matches!(
+            section,
+            Section::Usage | Section::Credits | Section::Activity | Section::Plan
+        ) {
+            columns(
+                heading,
+                format!("By {}", self.group_label(section, group).to_lowercase())
+                    .set_style(secondary_style())
+                    .into(),
+                width,
+            )
+        } else {
+            heading
+        };
+        let mut lines = vec![heading, "─".repeat(width).dim().into()];
+        if section == Section::Usage && self.business() {
+            lines.push(
+                format!(
+                    "{} · m change model",
+                    self.token_model.as_deref().unwrap_or("All models")
+                )
+                .set_style(secondary_style())
+                .into(),
+            );
+        }
+        let selection;
+        let mut chart_bands = 0;
+
+        if section == Section::Summary {
+            selection = 0..1;
+            lines.extend(self.summary_lines(width));
+        } else if section == Section::Plan {
+            let (plan, detail) = self.plan_lines(width);
+            selection = lines.len() + detail.start..lines.len() + detail.end;
+            lines.extend(plan);
+        } else if section == Section::Chats {
+            let (chats, detail) = if self.business() {
+                self.chat_lines(width)
+            } else {
+                self.task_lines(width)
+            };
+            selection = lines.len() + detail.start..lines.len() + detail.end;
+            lines.extend(chats);
+        } else {
+            let history = self.history_lines(section, width, chart_height);
+            chart_bands = history.bands;
+            lines.extend(history.lines);
+            selection = 0..lines.len();
+        }
+
+        let mut wrapped = Vec::new();
+        let mut wrapped_selection = 0..0;
+        for (index, line) in lines.into_iter().enumerate() {
+            if index == selection.start {
+                wrapped_selection.start = wrapped.len();
+            }
+            wrapped.extend(word_wrap_lines(
+                [line],
+                RtOptions::new(width.max(/*other*/ 1)),
+            ));
+            if index + 1 == selection.end {
+                wrapped_selection.end = wrapped.len();
+            }
+        }
+        Panel {
+            lines: wrapped,
+            selection: wrapped_selection,
+            chart_bands,
+        }
+    }
+}

codex-rs/tui/src/analytics/plan.rs

@@ -0,0 +1,121 @@
+//! Historical allowance snapshots, separate from daily usage and current chat allowances.
+//! Period IDs are snapshot-scoped; unknown accounting is never converted to zero.
+use super::data::Load;
+use chrono::DateTime;
+use chrono::Utc;
+use codex_backend_client::PlanLimitBreakdown;
+use codex_backend_client::PlanLimitHistory;
+
+pub(super) struct Period {
+    pub id: String,
+    pub start: DateTime<Utc>,
+    pub end: DateTime<Utc>,
+    pub complete: bool,
+    pub used: Option<f64>,
+    pub breakdowns: Option<Vec<PlanLimitBreakdown>>,
+}
+
+pub(super) struct Report {
+    pub as_of: DateTime<Utc>,
+    pub coverage_start: Option<DateTime<Utc>>,
+    pub coverage_complete: bool,
+    pub approximate: bool,
+    pub periods: [Vec<Period>; 2],
+}
+
+impl Report {
+    pub(super) fn parse(history: PlanLimitHistory) -> Result<Option<Self>, String> {
+        let parse = |value: &str| {
+            DateTime::parse_from_rfc3339(value)
+                .map(|date| date.with_timezone(&Utc))
+                .map_err(|_| "Invalid plan history timestamp.".to_string())
+        };
+        let Some(as_of) = history.data_as_of.as_deref().map(parse).transpose()? else {
+            return Ok(None);
+        };
+        let mut periods = [Vec::new(), Vec::new()];
+        let mut ids = std::collections::HashSet::new();
+        if history.periods.len() > 1_000 {
+            return Err("Plan history contains too many periods.".into());
+        }
+        for period in history.periods {
+            let window = match period.window_minutes {
+                300 => 0,
+                10080 => 1,
+                _ => return Err("Unsupported plan history window.".into()),
+            };
+            let start = parse(&period.starts_at)?;
+            let end = parse(&period.ends_at)?;
+            if start >= end
+                || !ids.insert(period.id.clone())
+                || period
+                    .used_basis_points
+                    .is_some_and(|amount| !amount.is_finite())
+                || period
+                    .breakdowns
+                    .iter()
+                    .flatten()
+                    .flat_map(|group| &group.rows)
+                    .any(|row| !row.basis_points.is_finite())
+            {
+                return Err("Invalid plan history period.".into());
+            }
+            periods[window].push(Period {
+                id: period.id,
+                start,
+                end,
+                complete: period.accounting_complete,
+                used: period.used_basis_points,
+                breakdowns: period.breakdowns,
+            });
+        }
+        for window in &mut periods {
+            window.sort_by_key(|period| std::cmp::Reverse(period.start));
+        }
+        Ok(Some(Self {
+            as_of,
+            coverage_start: history.coverage_start.as_deref().map(parse).transpose()?,
+            coverage_complete: history.coverage_complete,
+            approximate: history.approximate,
+            periods,
+        }))
+    }
+}
+
+pub(super) struct State {
+    pub enabled: bool,
+    pub report: Load<Report>,
+    pub window: usize,
+    pub cursor: [usize; 2],
+    pub expanded: [Option<String>; 2],
+    snapshot: Option<DateTime<Utc>>,
+}
+
+impl Default for State {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            report: Load::Unavailable,
+            window: 0,
+            cursor: [0; 2],
+            expanded: [None, None],
+            snapshot: None,
+        }
+    }
+}
+
+impl State {
+    pub(super) fn poll(&mut self) {
+        self.report.poll();
+        let snapshot = self.report.ready().map(|report| report.as_of);
+        if snapshot != self.snapshot {
+            self.snapshot = snapshot;
+            self.cursor = [0; 2];
+            self.expanded = [None, None];
+        }
+    }
+}
+
+#[cfg(test)]
+#[path = "plan_tests.rs"]
+mod tests;

codex-rs/tui/src/analytics/plan_panel.rs

@@ -0,0 +1,259 @@
+//! Five-hour and weekly period tables share grouping, with independent row expansion.
+use super::AnalyticsView;
+use super::data;
+use super::plan;
+use super::render::columns;
+use super::render::join_columns;
+use super::sections::Section;
+use super::styles::secondary_style;
+use crate::keymap::ListAction;
+use crate::style::accent_style;
+use codex_backend_client::PlanLimitDimension;
+use ratatui::style::Styled;
+use ratatui::style::Stylize;
+use ratatui::text::Line;
+use std::ops::Range;
+
+impl AnalyticsView {
+    pub(super) fn plan_action(&mut self, action: Option<ListAction>) {
+        let window = self.plan.window;
+        let periods = self
+            .plan
+            .report
+            .ready()
+            .map(|report| &report.periods[window]);
+        let count = periods.map_or(/*default*/ 0, Vec::len);
+        let cursor = &mut self.plan.cursor[window];
+        let previous_cursor = *cursor;
+        match action {
+            Some(ListAction::MoveLeft | ListAction::MoveRight) => self.plan.window ^= 1,
+            Some(ListAction::MoveUp) => *cursor = cursor.saturating_sub(/*rhs*/ 1),
+            Some(ListAction::MoveDown) => {
+                *cursor = (*cursor + 1).min(count.saturating_sub(/*rhs*/ 1))
+            }
+            Some(ListAction::JumpTop) => *cursor = 0,
+            Some(ListAction::JumpBottom) => *cursor = count.saturating_sub(/*rhs*/ 1),
+            Some(ListAction::Accept) => {
+                if let Some(period) = periods.and_then(|periods| periods.get(*cursor)) {
+                    self.plan.expanded[window] =
+                        if self.plan.expanded[window].as_ref() == Some(&period.id) {
+                            None
+                        } else {
+                            Some(period.id.clone())
+                        };
+                }
+            }
+            Some(ListAction::Cancel) => {
+                self.is_done |= !self.zoomed || self.plan.expanded[window].take().is_none();
+            }
+            Some(ListAction::PageDown) => {
+                self.scroll_offset += self.viewport_height;
+                self.follow_selection = false;
+            }
+            Some(ListAction::PageUp) => {
+                self.scroll_offset = self.scroll_offset.saturating_sub(self.viewport_height);
+                self.follow_selection = false;
+            }
+            None => {}
+        }
+        if *cursor != previous_cursor {
+            self.plan.expanded[window] = None;
+        }
+    }
+
+    pub(super) fn plan_lines(&self, width: usize) -> (Vec<Line<'static>>, Range<usize>) {
+        let side_by_side = width >= 100;
+        let table_width = if side_by_side { (width - 4) / 2 } else { width };
+        let group = self.sections[Section::Plan].group;
+        let dimension = match group {
+            1 => PlanLimitDimension::ThreadSource,
+            2 => PlanLimitDimension::Model,
+            3 => PlanLimitDimension::TurnTrigger,
+            _ => PlanLimitDimension::Surface,
+        };
+        let mut tables = Vec::new();
+        let mut selections = Vec::new();
+        for (window, title) in ["5-hour limits", "Weekly limits"].into_iter().enumerate() {
+            let heading = format!(
+                "{} {title}",
+                if self.plan.window == window {
+                    "›"
+                } else {
+                    " "
+                }
+            );
+            let mut lines = vec![heading.bold().into(), Line::default()];
+            let mut selection = 0..2;
+            if let Some(report) = self.plan.report.ready() {
+                if report.periods[window].is_empty() {
+                    lines.push(
+                        if report.coverage_complete {
+                            "No limit periods in this date range"
+                        } else {
+                            "Limit history isn't available yet"
+                        }
+                        .set_style(secondary_style())
+                        .into(),
+                    );
+                }
+                for (index, period) in report.periods[window]
+                    .iter()
+                    .take(if self.zoomed { usize::MAX } else { 1 })
+                    .enumerate()
+                {
+                    let start = lines.len();
+                    let selected = self.plan.cursor[window] == index;
+                    let label = if !self.zoomed {
+                        format!("Latest period · {} total", report.periods[window].len())
+                    } else {
+                        format!(
+                            "{} {} – {}{}",
+                            if selected { "›" } else { " " },
+                            period.start.format("%b %-d %H:%M"),
+                            period.end.format("%b %-d %H:%M"),
+                            if period.start <= report.as_of && period.end > report.as_of {
+                                " *"
+                            } else {
+                                ""
+                            }
+                        )
+                    };
+                    let amount = period
+                        .used
+                        .map(|value| format!("{}%", data::amount(value / 100.0)))
+                        .unwrap_or_else(|| "Not available".into());
+                    let row = columns(label.into(), amount.into(), table_width);
+                    lines.push(if selected && self.plan.window == window {
+                        row.set_style(accent_style())
+                    } else {
+                        row
+                    });
+                    if self.zoomed && self.plan.expanded[window].as_ref() == Some(&period.id) {
+                        if !period.complete {
+                            lines.push(
+                                "  Some usage is unavailable; this period may be incomplete"
+                                    .dim()
+                                    .into(),
+                            );
+                        }
+                        if let Some(breakdown) = period.breakdowns.as_ref().and_then(|groups| {
+                            groups.iter().find(|group| group.dimension == dimension)
+                        }) {
+                            for row in &breakdown.rows {
+                                let key = if dimension == PlanLimitDimension::TurnTrigger {
+                                    format!("start-{}", row.key)
+                                } else {
+                                    row.key.clone()
+                                };
+                                let label = if dimension == PlanLimitDimension::Model {
+                                    self.model_name(&key)
+                                } else {
+                                    super::normalize::label(&key)
+                                };
+                                lines.push(columns(
+                                    format!("  {label}").into(),
+                                    format!("{}%", data::amount(row.basis_points / 100.0)).into(),
+                                    table_width,
+                                ));
+                            }
+                        } else {
+                            lines.push("  Breakdown isn't available for this period".dim().into());
+                        }
+                    }
+                    if selected {
+                        selection = start..lines.len();
+                    }
+                }
+            } else {
+                lines.push(
+                    match &self.plan.report {
+                        data::Load::Unavailable => "Limit history isn't available yet",
+                        state => state
+                            .message()
+                            .unwrap_or("Limit history isn't available yet"),
+                    }
+                    .to_string()
+                    .set_style(secondary_style())
+                    .into(),
+                );
+            }
+            // Wrap each column before joining so long timestamps never collide with its neighbor.
+            let mut wrapped = Vec::new();
+            let mut wrapped_selection = 0..0;
+            for (index, line) in lines.into_iter().enumerate() {
+                if index == selection.start {
+                    wrapped_selection.start = wrapped.len();
+                }
+                wrapped.extend(crate::wrapping::word_wrap_lines(
+                    [line],
+                    crate::wrapping::RtOptions::new(table_width.max(/*other*/ 1)),
+                ));
+                if index + 1 == selection.end {
+                    wrapped_selection.end = wrapped.len();
+                }
+            }
+            tables.push(wrapped);
+            selections.push(wrapped_selection);
+        }
+        let mut selection = selections[self.plan.window].clone();
+        let mut lines = if side_by_side {
+            join_columns(&tables[0], &tables[1], table_width)
+        } else {
+            if self.plan.window == 1 {
+                selection =
+                    selection.start + tables[0].len() + 1..selection.end + tables[0].len() + 1;
+            }
+            let mut lines = std::mem::take(&mut tables[0]);
+            lines.push(Line::default());
+            lines.append(&mut tables[1]);
+            lines
+        };
+        if group == 3 {
+            lines.push(
+                "By turn start includes Tasks only; percentages use the full period limit"
+                    .dim()
+                    .into(),
+            );
+        }
+        if let Some(plan::Report {
+            as_of,
+            coverage_start,
+            coverage_complete,
+            approximate,
+            ..
+        }) = self.plan.report.ready()
+        {
+            if !*coverage_complete {
+                lines.push("Some periods aren't available yet".dim().into());
+            }
+            lines.push(
+                format!(
+                    "Usage as of {} UTC{}",
+                    as_of.format("%b %-d %H:%M"),
+                    if self.zoomed {
+                        " · * current at last update"
+                    } else {
+                        ""
+                    }
+                )
+                .dim()
+                .into(),
+            );
+            if let Some(start) = coverage_start {
+                lines.push(
+                    format!("Available since {} UTC", start.format("%b %-d %H:%M"))
+                        .dim()
+                        .into(),
+                );
+            }
+            if *approximate {
+                lines.push(
+                    "Amounts and period boundaries are approximate; recent activity may be delayed"
+                        .dim()
+                        .into(),
+                );
+            }
+        }
+        (lines, selection)
+    }
+}

codex-rs/tui/src/analytics/plan_tests.rs

@@ -0,0 +1,252 @@
+//! Snapshot semantics and independent plan-period navigation without a live billing service.
+use super::*;
+use crate::analytics::fixture;
+use crate::analytics::models::AccountKind;
+use crate::analytics::sections::Section;
+use crossterm::event::KeyCode;
+use crossterm::event::KeyEvent;
+use crossterm::event::KeyModifiers;
+use pretty_assertions::assert_eq;
+use serde_json::json;
+
+fn response() -> PlanLimitHistory {
+    serde_json::from_value(json!({
+        "data_as_of":"2026-09-02T12:00:00Z", "coverage_start":"2026-09-01T00:00:00Z",
+        "coverage_complete":false, "boundary_tolerance_seconds":60,
+        "periods":[
+            {"id":"five", "window_minutes":300,"plan_type":"plus",
+             "starts_at":"2026-09-02T10:00:00Z","ends_at":"2026-09-02T15:00:00Z",
+             "accounting_complete":false,"used_basis_points":12500,
+             "breakdowns":[
+                {"dimension":"future_dimension","rows":[{"key":"future","basis_points":500}]},
+                {"dimension":"thread_source","rows":[{"key":"user","basis_points":12500}]}]},
+            {"id":"weekly", "window_minutes":10080,"plan_type":"plus",
+             "starts_at":"2026-09-01T00:00:00Z","ends_at":"2026-09-08T00:00:00Z",
+             "accounting_complete":true,"used_basis_points":null,"breakdowns":null}
+        ]
+    }))
+    .unwrap()
+}
+
+#[test]
+fn period_navigation_preserves_unknowns_and_resets_on_new_snapshot() {
+    let mut view = fixture::view(AccountKind::Consumer);
+    view.plan.enabled = true;
+    view.plan.report = Load::Ready(Report::parse(response()).unwrap().unwrap());
+    view.plan.poll();
+    view.section = Section::Plan;
+    view.handle_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
+    view.handle_key(KeyEvent::new(KeyCode::Right, KeyModifiers::NONE));
+    view.handle_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
+    assert_eq!(
+        view.plan.expanded,
+        [Some("five".into()), Some("weekly".into())]
+    );
+    let mut output = Vec::new();
+    for width in [120, 58] {
+        let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(
+            width, /*height*/ 30,
+        ))
+        .unwrap();
+        terminal
+            .draw(|frame| view.render(frame.area(), frame.buffer_mut()))
+            .unwrap();
+        output.push(terminal.backend().to_string());
+    }
+    insta::assert_snapshot!(output.join("\n"));
+    let mut next = response();
+    next.data_as_of = Some("2026-09-02T13:00:00Z".into());
+    view.plan.report = Load::Ready(Report::parse(next).unwrap().unwrap());
+    view.plan.poll();
+    assert_eq!(
+        (view.plan.cursor, view.plan.expanded),
+        ([0, 0], [None, None])
+    );
+}
+
+#[test]
+fn unavailable_empty_and_zero_history_are_distinct() {
+    let mut view = fixture::view(AccountKind::Consumer);
+    view.plan.enabled = true;
+    view.section = Section::Plan;
+    let mut states = Vec::new();
+    states.push(
+        view.plan_lines(/*width*/ 100)
+            .0
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join("\n"),
+    );
+    let mut history = response();
+    history.coverage_complete = true;
+    history.periods.clear();
+    view.plan.report = Load::Ready(Report::parse(history).unwrap().unwrap());
+    states.push(
+        view.plan_lines(/*width*/ 100)
+            .0
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join("\n"),
+    );
+    let mut history = response();
+    history.periods[0].used_basis_points = Some(0.0);
+    view.plan.report = Load::Ready(Report::parse(history).unwrap().unwrap());
+    states.push(
+        view.plan_lines(/*width*/ 100)
+            .0
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join("\n"),
+    );
+    let mut future = response();
+    future.periods[0].starts_at = "2026-09-02T13:00:00Z".into();
+    view.plan.report = Load::Ready(Report::parse(future).unwrap().unwrap());
+    states.push(
+        view.plan_lines(/*width*/ 100)
+            .0
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join("\n"),
+    );
+    let snapshot = states.join("\n\n");
+    let snapshot = snapshot
+        .lines()
+        .map(str::trim_end)
+        .collect::<Vec<_>>()
+        .join("\n");
+    insta::assert_snapshot!(snapshot);
+    let mut missing = response();
+    missing.data_as_of = None;
+    assert!(Report::parse(missing).unwrap().is_none());
+}
+
+#[tokio::test]
+async fn plan_gate_prevents_requests_and_unavailable_plan_does_not_block_other_reports() {
+    use crate::analytics::client;
+    use crate::analytics::test_support;
+    use wiremock::Mock;
+    use wiremock::ResponseTemplate;
+    use wiremock::matchers::path;
+    let server = test_support::server().await;
+    let (_home, _server, mut view) = client::tests::connected_view(&server, "plus").await;
+    test_support::settle(&mut view).await;
+    assert!(
+        !server
+            .received_requests()
+            .await
+            .unwrap()
+            .iter()
+            .any(|request| request.url.path().ends_with("plan_limit_history"))
+    );
+    assert!(!view.visible_sections().contains(&Section::Plan));
+    Mock::given(path("/backend-api/wham/usage/plan_limit_history"))
+        .respond_with(ResponseTemplate::new(/*s*/ 404))
+        .with_priority(/*p*/ 1)
+        .expect(/*r*/ 1)
+        .mount(&server)
+        .await;
+    let (mut config, handle, frame) = view.connection.clone().unwrap();
+    std::sync::Arc::make_mut(&mut config)
+        .features
+        .enable(codex_features::Feature::AnalyticsPlanHistory)
+        .unwrap();
+    view.open(handle, frame, Vec::new(), config);
+    test_support::settle(&mut view).await;
+    assert!(matches!(view.plan.report, Load::Unavailable));
+    assert!(view.sections[Section::Usage].history.ready().is_some());
+    assert!(view.visible_sections().contains(&Section::Plan));
+    // Closing cancels the pending plan task along with the other account-owned work.
+    let (sender, receiver) = tokio::sync::oneshot::channel::<()>();
+    view.plan.report = Load::start(
+        async move {
+            let _sender = sender;
+            std::future::pending().await
+        },
+        crate::tui::FrameRequester::test_dummy(),
+    );
+    view.cancel_loads();
+    assert!(receiver.await.is_err());
+    server.verify().await;
+    let server = test_support::server().await;
+    let (_home, _server, mut business) = client::tests::connected_view(&server, "business").await;
+    let (mut config, handle, frame) = business.connection.clone().unwrap();
+    std::sync::Arc::make_mut(&mut config)
+        .features
+        .enable(codex_features::Feature::AnalyticsPlanHistory)
+        .unwrap();
+    business.open(handle, frame, Vec::new(), config);
+    test_support::settle(&mut business).await;
+    assert!(!business.visible_sections().contains(&Section::Plan));
+    assert!(matches!(business.plan.report, Load::Unavailable));
+    server.verify().await;
+}
+
+#[test]
+fn plan_overview_escape_closes_with_retained_expansion() {
+    let mut history = response();
+    for index in 1..12 {
+        let mut period = history.periods[0].clone();
+        period.id = format!("five-{index}");
+        history.periods.push(period);
+    }
+    let mut view = fixture::view(AccountKind::Consumer);
+    view.plan.enabled = true;
+    view.plan.report = Load::Ready(Report::parse(history).unwrap().unwrap());
+    view.plan.poll();
+    view.section = Section::Plan;
+    view.handle_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
+    view.handle_key(KeyEvent::new(KeyCode::Char('z'), KeyModifiers::NONE));
+    let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(
+        /*width*/ 120, /*height*/ 60,
+    ))
+    .unwrap();
+    terminal
+        .draw(|frame| view.render(frame.area(), frame.buffer_mut()))
+        .unwrap();
+    let output = terminal.backend().to_string();
+    assert!(output.contains("Latest period · 12 total") && output.contains("Weekly limits"));
+    insta::assert_snapshot!(output);
+    view.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
+    assert!(view.is_done);
+}
+
+#[test]
+fn moving_period_selection_collapses_its_previous_details() {
+    let mut history = response();
+    let mut older = history.periods[0].clone();
+    older.id = "older-five".into();
+    older.starts_at = "2026-09-02T05:00:00Z".into();
+    older.ends_at = "2026-09-02T10:00:00Z".into();
+    history.periods.push(older);
+    let mut view = fixture::view(AccountKind::Consumer);
+    view.plan.enabled = true;
+    view.plan.report = Load::Ready(Report::parse(history).unwrap().unwrap());
+    view.plan.poll();
+    view.section = Section::Plan;
+    view.handle_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
+    view.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
+    assert_eq!(
+        (view.plan.cursor, view.plan.expanded),
+        ([1, 0], [None, None])
+    );
+}
+
+#[test]
+fn invalid_history_returns_safe_errors() {
+    for invalid in 0..5 {
+        let mut history = response();
+        match invalid {
+            0 => history.periods[0].starts_at = "private wire value".into(),
+            1 => history.periods[0].ends_at = history.periods[0].starts_at.clone(),
+            2 => history.periods.push(history.periods[0].clone()),
+            3 => history.periods[0].window_minutes = 1,
+            _ => history.periods[0].used_basis_points = Some(f64::INFINITY),
+        }
+        let error = Report::parse(history).err().unwrap();
+        assert!(!error.contains("private wire value"));
+    }
+}

codex-rs/tui/src/analytics/plot.rs

@@ -0,0 +1,176 @@
+//! Daily stacked bars with fixed calendar ticks, a selection cursor, and an anchored value.
+//! Relative usage retains the server's scale; signed credits keep both bands.
+
+mod annotations;
+mod layout;
+mod painting;
+
+use self::layout::Layout;
+use self::painting::Band;
+use super::data;
+use super::data::compact_amount as tick;
+use super::render::parts;
+use crate::analytics::models::AccountAnalyticsDay;
+use crate::analytics::models::AccountAnalyticsUnit;
+use crate::analytics::models::AccountAnalyticsValue;
+use chrono::NaiveDate;
+use ratatui::buffer::Buffer;
+use ratatui::layout::Rect;
+use ratatui::text::Line;
+use ratatui::text::Span;
+use unicode_width::UnicodeWidthStr;
+
+/// Share the chart's scale with the selected-day summary, including signed values.
+pub(super) fn peak(
+    days: &[(NaiveDate, Option<&AccountAnalyticsDay>)],
+    categories: &[AccountAnalyticsValue],
+) -> f64 {
+    days.iter()
+        .filter_map(|(_, day)| *day)
+        .map(|day| {
+            parts(&day.values, categories)
+                .iter()
+                .map(|value| value.abs())
+                .sum::<f64>()
+                .max(day.total.abs())
+        })
+        .fold(/*init*/ 0.0, f64::max)
+}
+
+/// Two readable intervals cover the range; counts never use fractional ticks.
+pub(super) fn axis_max(peak: f64, unit: AccountAnalyticsUnit) -> f64 {
+    if peak == 0.0 {
+        return if matches!(
+            unit,
+            AccountAnalyticsUnit::Count | AccountAnalyticsUnit::Tokens
+        ) {
+            2.0
+        } else {
+            1.0
+        };
+    }
+    let step = if matches!(
+        unit,
+        AccountAnalyticsUnit::Count | AccountAnalyticsUnit::Tokens
+    ) {
+        (peak / 2.0).max(/*other*/ 1.0)
+    } else {
+        peak / 2.0
+    };
+    let magnitude = 10.0_f64.powf(step.log10().floor());
+    let normalized = step / magnitude;
+    let multiple = [1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 7.5, 10.0]
+        .into_iter()
+        .find(|multiple| {
+            *multiple >= normalized
+                && (!matches!(
+                    unit,
+                    AccountAnalyticsUnit::Count | AccountAnalyticsUnit::Tokens
+                ) || (multiple * magnitude).fract() == 0.0)
+        })
+        .unwrap_or(/*default*/ 10.0);
+    let ceiling = multiple * magnitude * 2.0;
+    if ceiling.is_finite() && ceiling >= peak {
+        ceiling
+    } else {
+        peak
+    }
+}
+
+/// Rendered chart geometry exposes its positive and optional negative value bands.
+#[derive(Default)]
+pub(super) struct Chart {
+    pub(super) lines: Vec<Line<'static>>,
+    pub(super) bands: usize,
+}
+
+/// Render a calendar selection; the cursor must index days and dimensions fit the terminal.
+pub(super) fn chart(
+    days: &[(NaiveDate, Option<&AccountAnalyticsDay>)],
+    categories: &[AccountAnalyticsValue],
+    cursor: usize,
+    width: usize,
+    height: usize,
+    unit: AccountAnalyticsUnit,
+) -> Chart {
+    if days.is_empty() || width == 0 {
+        return Chart::default();
+    }
+    let values = days
+        .iter()
+        .map(|(_, day)| {
+            day.map_or(
+                /*default*/ [0.0; 4],
+                |day| parts(&day.values, categories),
+            )
+        })
+        .collect::<Vec<_>>();
+    let bands = if values.iter().flatten().any(|value| *value < 0.0) {
+        &[Band::Positive, Band::Negative][..]
+    } else {
+        &[Band::Positive][..]
+    };
+    let peak = axis_max(peak(days, categories), unit);
+    let label_width = tick(peak).width().max(tick(peak / 2.0).width()) + bands.len() - 1 + 2;
+    let layout = Layout::new(days.len(), cursor, width, height, label_width, bands);
+    let renderer = Renderer {
+        days,
+        values,
+        cursor,
+        peak,
+        unit,
+        bands,
+        layout,
+    };
+    let mut buf = Buffer::empty(Rect::new(
+        /*x*/ 0,
+        /*y*/ 0,
+        width as u16,
+        (layout.marker_row + 2) as u16,
+    ));
+    renderer.paint_bars(&mut buf);
+    renderer.annotate_missing(&mut buf);
+    renderer.paint_axis(&mut buf);
+    renderer.annotate_selection(&mut buf);
+    renderer.annotate_calendar(&mut buf);
+    let lines = buf
+        .content
+        .chunks(width)
+        .map(|row| {
+            Line::from(
+                row.iter()
+                    .map(|cell| Span::styled(cell.symbol().to_owned(), cell.style()))
+                    .collect::<Vec<_>>(),
+            )
+        })
+        .collect();
+    Chart {
+        lines,
+        bands: bands.len(),
+    }
+}
+
+/// Shared inputs for painting and annotations; all phases use the same calendar geometry.
+struct Renderer<'a> {
+    days: &'a [(NaiveDate, Option<&'a AccountAnalyticsDay>)],
+    values: Vec<[f64; 4]>,
+    cursor: usize,
+    peak: f64,
+    unit: AccountAnalyticsUnit,
+    bands: &'static [Band],
+    layout: Layout,
+}
+
+fn amount(value: f64, unit: AccountAnalyticsUnit) -> String {
+    match unit {
+        AccountAnalyticsUnit::RelativeUsage => data::amount(value),
+        AccountAnalyticsUnit::Count | AccountAnalyticsUnit::Tokens => {
+            data::compact_amount(value.round())
+        }
+        AccountAnalyticsUnit::Credits => data::credit_amount(value),
+    }
+}
+
+#[cfg(test)]
+#[path = "plot_tests.rs"]
+mod tests;

codex-rs/tui/src/analytics/plot/annotations.rs

@@ -0,0 +1,213 @@
+//! Missing-day markers, daily-value callouts, and stable calendar labels.
+
+use super::Renderer;
+use super::amount;
+use super::layout::Layout;
+use super::painting::Band;
+use crate::analytics::styles::secondary_style;
+use crate::color::is_light;
+use crate::style::accent_style;
+use crate::terminal_palette::default_bg;
+use ratatui::buffer::Buffer;
+use ratatui::style::Style;
+use ratatui::style::Styled;
+use ratatui::style::Stylize;
+use ratatui::text::Line;
+use unicode_width::UnicodeWidthStr;
+
+impl Renderer<'_> {
+    pub(super) fn annotate_missing(&self, buf: &mut Buffer) {
+        let Layout {
+            count,
+            height,
+            start,
+            ..
+        } = self.layout;
+        for (index, parts) in self.values[start..start + count].iter().enumerate() {
+            // The selected zero/missing value gets its own callout below; avoid repeating it.
+            if start + index != self.cursor {
+                let marker = match self.days[start + index].1 {
+                    None => Some('—'),
+                    Some(day) if day.total == 0.0 && parts.iter().all(|value| *value == 0.0) => {
+                        Some('0')
+                    }
+                    Some(_) => None,
+                };
+                if let Some(marker) = marker {
+                    buf[(self.layout.center(index) as u16, height as u16)]
+                        .set_char(marker)
+                        .set_style(Style::default().dim());
+                }
+            }
+        }
+    }
+
+    pub(super) fn annotate_selection(&self, buf: &mut Buffer) {
+        let Layout {
+            axis_width,
+            baseline,
+            height,
+            marker_row,
+            plot_width,
+            start,
+            width,
+            ..
+        } = self.layout;
+        // Give the selected value first choice of space; the other labels never overwrite it.
+        for index in
+            std::iter::once(self.cursor).chain((start..start + self.layout.count).filter(|index| {
+                self.days.len() <= 7
+                    && *index != self.cursor
+                    && self.days[*index].1.is_some_and(|day| {
+                        day.total != 0.0 || self.values[*index].iter().any(|value| *value != 0.0)
+                    })
+            }))
+        {
+            let total = self.days[index].1.map_or(/*default*/ 0.0, |day| day.total);
+            let label = self.days[index]
+                .1
+                .map_or_else(|| "—".into(), |_| amount(total, self.unit));
+            // A partial number can mean a different amount; leave the cursor when the value cannot fit.
+            if label.width() > plot_width {
+                continue;
+            }
+            let x = self.layout.center(index - start);
+            let label_width = label.width();
+            let label_x = x
+                .saturating_sub(label_width / 2)
+                .clamp(axis_width, width - label_width);
+            let occupied = label_x.saturating_sub(/*rhs*/ 1).max(axis_width)
+                ..(label_x + label_width + 1).min(width);
+            let below = total < 0.0;
+            let band = if below {
+                Band::Negative
+            } else {
+                Band::Positive
+            };
+            let extent = self.values[index]
+                .iter()
+                .map(|value| band.amount(*value))
+                .sum::<f64>();
+            let rows = ((extent * height as f64 / self.peak).ceil() as usize).min(height);
+            let cap = if below {
+                baseline + rows
+            } else {
+                baseline - rows
+            };
+            let mut label_y = if below {
+                cap + 1
+            } else {
+                cap.saturating_sub(/*rhs*/ 1)
+            };
+            // Keep the callout close without painting over a neighboring bar. A guide connects any gap.
+            while occupied
+                .clone()
+                .any(|col| buf[(col as u16, label_y as u16)].symbol() != " ")
+            {
+                if below && label_y + 1 < marker_row {
+                    label_y += 1;
+                } else if !below && label_y > 0 {
+                    label_y -= 1;
+                } else {
+                    break;
+                }
+            }
+            if occupied
+                .clone()
+                .any(|col| buf[(col as u16, label_y as u16)].symbol() != " ")
+            {
+                continue;
+            }
+            // Use white on dark backgrounds and the terminal foreground on light backgrounds.
+            let style = if index == self.cursor {
+                let selected = Style::default().bold().not_dim();
+                if default_bg().is_some_and(is_light) {
+                    selected
+                } else {
+                    selected.white()
+                }
+            } else {
+                Style::default().dim()
+            };
+            let guide = if below {
+                cap + 1..label_y
+            } else {
+                label_y + 1..cap
+            };
+            for y in guide {
+                let cell = &mut buf[(x as u16, y as u16)];
+                if cell.symbol() == " " {
+                    cell.set_char('┊').set_style(style);
+                }
+            }
+            buf.set_line(
+                label_x as u16,
+                label_y as u16,
+                &Line::from(label.set_style(style)),
+                label_width as u16,
+            );
+        }
+        let x = self.layout.center(self.cursor - start);
+        buf[(x as u16, marker_row as u16)]
+            .set_char('▲')
+            .set_style(accent_style());
+    }
+
+    pub(super) fn annotate_calendar(&self, buf: &mut Buffer) {
+        let Layout {
+            axis_width,
+            count,
+            marker_row,
+            plot_width,
+            start,
+            width,
+            ..
+        } = self.layout;
+        // Calendar ticks depend only on the range/width, never on the current selection.
+        let mut occupied = vec![false; width];
+        // Give the two range endpoints priority over intermediate weekly ticks.
+        for index in std::iter::once(/*value*/ 0).chain((1..count).rev()) {
+            if self.days.len() > 7
+                && !(start + index).is_multiple_of(/*rhs*/ 7)
+                && index + 1 != count
+            {
+                continue;
+            }
+            let format = if self.days.len() <= 7 && plot_width / count < 7 {
+                "%-d"
+            } else {
+                "%b %-d"
+            };
+            let mut label = self.days[start + index].0.format(format).to_string();
+            if label.width() > plot_width {
+                label = self.days[start + index].0.format("%-d").to_string();
+            }
+            if label.width() > plot_width {
+                continue;
+            }
+            let offset = self
+                .layout
+                .center(index)
+                .saturating_sub(label.len() / 2)
+                .clamp(axis_width, width - label.len());
+            if occupied[offset.saturating_sub(/*rhs*/ 1)..(offset + label.len() + 1).min(width)]
+                .iter()
+                .any(|used| *used)
+            {
+                continue;
+            }
+            occupied[offset..offset + label.len()].fill(/*value*/ true);
+            let label = if start + index == self.cursor {
+                label.set_style(accent_style()).underlined()
+            } else {
+                label.set_style(secondary_style())
+            };
+            buf.set_line(
+                offset as u16,
+                (marker_row + 1) as u16,
+                &Line::from(label),
+                (width - offset) as u16,
+            );
+        }
+    }
+}

codex-rs/tui/src/analytics/plot/layout.rs

@@ -0,0 +1,55 @@
+//! Calendar viewport and shared coordinates for bars, axes, and annotations.
+
+use super::painting::Band;
+
+#[derive(Clone, Copy)]
+pub(super) struct Layout {
+    pub(super) width: usize,
+    pub(super) height: usize,
+    pub(super) axis_width: usize,
+    pub(super) plot_width: usize,
+    pub(super) count: usize,
+    pub(super) start: usize,
+    pub(super) baseline: usize,
+    pub(super) marker_row: usize,
+}
+
+impl Layout {
+    pub(super) fn new(
+        day_count: usize,
+        cursor: usize,
+        width: usize,
+        height: usize,
+        label_width: usize,
+        bands: &[Band],
+    ) -> Self {
+        // Hide the axis when a complete label would crowd out the bars.
+        let axis_width = if width >= 30 && label_width <= width / 3 {
+            label_width
+        } else {
+            0
+        };
+        let plot_width = width - axis_width;
+        let count = day_count.min(plot_width);
+        let start = cursor.saturating_sub(count - 1).min(day_count - count);
+        let baseline = height + 1;
+        let marker_row = baseline + if bands.len() == 2 { height + 2 } else { 1 };
+        Self {
+            width,
+            height,
+            axis_width,
+            plot_width,
+            count,
+            start,
+            baseline,
+            marker_row,
+        }
+    }
+
+    pub(super) fn center(self, index: usize) -> usize {
+        self.axis_width
+            + (index * self.plot_width / self.count + (index + 1) * self.plot_width / self.count
+                - 1)
+                / 2
+    }
+}

codex-rs/tui/src/analytics/plot/painting.rs

@@ -0,0 +1,132 @@
+//! Paint signed bar cells and numeric axes using the shared layout and scale.
+
+use super::Renderer;
+use super::layout::Layout;
+use super::tick;
+use crate::analytics::styles::secondary_style;
+use crate::analytics::styles::series_colors;
+use ratatui::buffer::Buffer;
+use ratatui::style::Style;
+use ratatui::style::Styled;
+use ratatui::text::Line;
+
+/// A signed stack grows away from the baseline; amounts are nonnegative within each band.
+#[derive(Clone, Copy)]
+pub(super) enum Band {
+    Positive,
+    Negative,
+}
+
+impl Band {
+    pub(super) fn amount(self, value: f64) -> f64 {
+        match self {
+            Self::Positive => value,
+            Self::Negative => -value,
+        }
+        .max(/*other*/ 0.0)
+    }
+
+    fn row_y(self, baseline: usize, row: usize) -> usize {
+        match self {
+            Self::Positive => baseline - row - 1,
+            Self::Negative => baseline + row + 1,
+        }
+    }
+
+    fn partial_glyph(self, level: usize) -> char {
+        // Reversing the complementary lower block paints a top-anchored partial refund.
+        let index = match self {
+            Self::Negative if level < 8 => 8 - level,
+            Self::Positive | Self::Negative => level,
+        };
+        [' ', '▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'][index]
+    }
+}
+
+impl Renderer<'_> {
+    pub(super) fn paint_bars(&self, buf: &mut Buffer) {
+        let Layout {
+            axis_width,
+            baseline,
+            count,
+            height,
+            plot_width,
+            start,
+            ..
+        } = self.layout;
+        let colors = series_colors();
+        for (index, parts) in self.values[start..start + count].iter().enumerate() {
+            let left = axis_width + index * plot_width / count;
+            let step = (index + 1) * plot_width / count - index * plot_width / count;
+            let bar_width = (step * 2 / 3).clamp(/*min*/ 1, /*max*/ 12);
+            let x = left + (step - bar_width) / 2;
+            for band in self.bands {
+                let plotted = parts.iter().map(|value| band.amount(*value)).sum::<f64>();
+                let scaled = ((plotted * (height * 8) as f64 / self.peak) as usize)
+                    .max(usize::from(plotted > 0.0));
+                for row in 0..height {
+                    let level = scaled.saturating_sub(row * 8).min(/*other*/ 8);
+                    if level == 0 {
+                        continue;
+                    }
+                    let reverse = matches!(band, Band::Negative) && level < 8;
+                    let glyph = band.partial_glyph(level);
+                    let bottom = (row * 8) as f64 * self.peak / (height * 8) as f64;
+                    let top =
+                        ((row * 8 + level) as f64 * self.peak / (height * 8) as f64).min(plotted);
+                    let sample = bottom + (top - bottom) / 2.0;
+                    let mut cumulative = 0.0;
+                    let color = parts
+                        .iter()
+                        .position(|value| {
+                            cumulative += band.amount(*value);
+                            sample < cumulative
+                        })
+                        .unwrap_or(/*default*/ 3);
+                    let y = band.row_y(baseline, row);
+                    for col in x..x + bar_width {
+                        let cell = &mut buf[(col as u16, y as u16)];
+                        cell.set_char(glyph).set_fg(colors[color]);
+                        if reverse {
+                            cell.set_style(Style::default().reversed());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    pub(super) fn paint_axis(&self, buf: &mut Buffer) {
+        let Layout {
+            axis_width,
+            baseline,
+            height,
+            width,
+            ..
+        } = self.layout;
+        for x in axis_width..width {
+            buf[(x as u16, baseline as u16)]
+                .set_char('─')
+                .set_style(Style::default().dim());
+        }
+        if axis_width > 0 {
+            let mut ticks = vec![(1, self.peak), (baseline, 0.0)];
+            if height >= 4 {
+                ticks.push((1 + height / 2, self.peak / 2.0));
+            }
+            if self.bands.len() == 2 {
+                ticks.push((baseline + height, -self.peak));
+            }
+            for (y, value) in ticks {
+                let label = tick(value);
+                let x = axis_width.saturating_sub(label.len() + 1);
+                buf.set_line(
+                    x as u16,
+                    y as u16,
+                    &Line::from(label.set_style(secondary_style())),
+                    axis_width as u16,
+                );
+            }
+        }
+    }
+}

codex-rs/tui/src/analytics/plot_tests.rs

@@ -0,0 +1,535 @@
+//! Chart scales, signed bands, missing days, narrow viewports, and terminal palettes.
+
+use super::*;
+use crate::analytics::models::AccountAnalyticsHistory;
+use crate::analytics::render::categories;
+use crate::analytics::styles::series_colors;
+use crate::terminal_palette::with_test_default_colors;
+use crate::terminal_probe::DefaultColors;
+use pretty_assertions::assert_eq;
+
+fn value(key: &str, value: f64) -> AccountAnalyticsValue {
+    AccountAnalyticsValue {
+        key: key.into(),
+        label: key.into(),
+        value,
+    }
+}
+
+fn display(chart: &Chart) -> String {
+    let text = chart
+        .lines
+        .iter()
+        .map(|line| line.to_string().trim_end().to_owned())
+        .collect::<Vec<_>>()
+        .join("\n");
+    let mut palette = Vec::new();
+    let mut rows = Vec::new();
+    for (row, line) in chart.lines.iter().enumerate() {
+        let mut previous = None;
+        let mut runs = Vec::new();
+        let mut column = 0;
+        for span in &line.spans {
+            let style = format!("{:?}", span.style);
+            let index = palette
+                .iter()
+                .position(|candidate| *candidate == style)
+                .unwrap_or_else(|| {
+                    palette.push(style);
+                    palette.len() - 1
+                });
+            if previous != Some(index) {
+                runs.push(format!("{column}:{index}"));
+                previous = Some(index);
+            }
+            column += span.width();
+        }
+        rows.push(format!("{row}: {}", runs.join(" ")));
+    }
+    let palette = palette
+        .iter()
+        .enumerate()
+        .map(|(index, style)| format!("{index}: {style}"))
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!(
+        "{text}\n\nPalette:\n{palette}\nRows (column:palette):\n{}",
+        rows.join("\n")
+    )
+}
+
+#[test]
+fn numeric_axes_use_readable_intervals() {
+    use AccountAnalyticsUnit::Count;
+    use AccountAnalyticsUnit::Credits;
+    use AccountAnalyticsUnit::RelativeUsage;
+    use AccountAnalyticsUnit::Tokens;
+    let cases = [
+        (82.0, Count, 100.0),
+        (4_400.0, Credits, 5_000.0),
+        (4_999.0, Credits, 5_000.0),
+        (5_001.0, Credits, 6_000.0),
+        (49.0, Count, 50.0),
+        (1.0, Count, 2.0),
+        (3.0, Count, 4.0),
+        (1_337.0, Credits, 1_500.0),
+        (0.07, Credits, 0.08),
+        (0.000004, Credits, 0.000004),
+        (82.0, RelativeUsage, 100.0),
+        (1.0, Tokens, 2.0),
+    ];
+    assert_eq!(
+        cases.map(|(peak, unit, _)| axis_max(peak, unit)),
+        cases.map(|(_, _, expected)| expected)
+    );
+}
+
+#[test]
+fn stacked_parts_keep_the_remainder_and_full_denominator() {
+    let values = vec![
+        value("a", /*value*/ 4.0),
+        value("b", /*value*/ 2.0),
+        value("c", /*value*/ 1.0),
+        value("d", /*value*/ 6.0),
+        value("e", /*value*/ -1.0),
+    ];
+    let categories = vec![values[1].clone(), values[0].clone(), values[2].clone()];
+    assert_eq!(parts(&values, &categories), [2.0, 4.0, 1.0, 5.0]);
+    let day = AccountAnalyticsDay {
+        date: "2026-01-15".parse().unwrap(),
+        total: 20.0,
+        values,
+    };
+    let date = day.date;
+    assert_eq!(peak(&[(date, Some(&day))], &categories), 20.0);
+    let refund = AccountAnalyticsDay {
+        total: -1.0,
+        values: vec![value("a", /*value*/ 4.0), value("b", /*value*/ -5.0)],
+        ..day
+    };
+    assert_eq!(peak(&[(date, Some(&refund))], &categories), 9.0);
+}
+
+#[test]
+fn signed_chart_on_light_terminal() {
+    signed_chart(
+        "light",
+        DefaultColors {
+            fg: (0, 0, 0),
+            bg: (255, 255, 255),
+        },
+    );
+}
+
+#[test]
+fn signed_chart_on_dark_terminal() {
+    signed_chart(
+        "dark",
+        DefaultColors {
+            fg: (230, 230, 230),
+            bg: (16, 16, 16),
+        },
+    );
+}
+
+fn signed_chart(theme: &str, colors: DefaultColors) {
+    let history = AccountAnalyticsHistory {
+        unit: AccountAnalyticsUnit::Credits,
+        updated_at: None,
+        data: vec![
+            AccountAnalyticsDay {
+                date: "2026-01-13".parse().unwrap(),
+                total: 8.0,
+                values: vec![value("a", /*value*/ 10.0), value("b", /*value*/ -2.0)],
+            },
+            AccountAnalyticsDay {
+                date: "2026-01-14".parse().unwrap(),
+                total: -3.0,
+                values: vec![value("a", /*value*/ 1.0), value("b", /*value*/ -4.0)],
+            },
+            AccountAnalyticsDay {
+                date: "2026-01-15".parse().unwrap(),
+                total: 0.0,
+                values: vec![value("a", /*value*/ 3.0), value("b", /*value*/ -3.0)],
+            },
+        ],
+    };
+    let days = history
+        .data
+        .iter()
+        .map(|day| (day.date, Some(day)))
+        .collect::<Vec<_>>();
+    let categories = categories(&history);
+    with_test_default_colors(colors, || {
+        let rendered = chart(
+            &days,
+            &categories,
+            /*cursor*/ 1,
+            /*width*/ 44,
+            /*height*/ 4,
+            history.unit,
+        );
+        assert_eq!(rendered.bands, 2);
+        insta::assert_snapshot!(format!("signed_chart_{theme}"), display(&rendered));
+    });
+}
+
+#[test]
+fn missing_zero_and_narrow_charts_keep_the_selection_visible() {
+    let zero = AccountAnalyticsDay {
+        date: "2026-01-14".parse().unwrap(),
+        total: 0.0,
+        values: vec![value("a", /*value*/ 0.0)],
+    };
+    let used = AccountAnalyticsDay {
+        date: "2026-01-15".parse().unwrap(),
+        total: 5.0,
+        values: vec![value("a", /*value*/ 5.0)],
+    };
+    let days = [
+        ("2026-01-13".parse().unwrap(), None),
+        (zero.date, Some(&zero)),
+        (used.date, Some(&used)),
+    ];
+    with_test_default_colors(
+        DefaultColors {
+            fg: (230, 230, 230),
+            bg: (16, 16, 16),
+        },
+        || {
+            let mut snapshots = Vec::new();
+            for (width, cursor) in [(36, 0), (36, 1), (8, 2), (1, 2)] {
+                let rendered = chart(
+                    &days,
+                    &used.values,
+                    cursor,
+                    width,
+                    /*height*/ 3,
+                    AccountAnalyticsUnit::Count,
+                );
+                assert_eq!(rendered.bands, 1);
+                assert!(rendered.lines.iter().all(|line| line.width() <= width));
+                assert_eq!(
+                    rendered
+                        .lines
+                        .iter()
+                        .flat_map(|line| &line.spans)
+                        .filter(|span| span.content == "▲")
+                        .count(),
+                    1
+                );
+                if cursor == 0 {
+                    let dash = rendered
+                        .lines
+                        .iter()
+                        .find_map(|line| line.to_string().find('—'));
+                    let cursor = rendered
+                        .lines
+                        .iter()
+                        .find_map(|line| line.to_string().find('▲'));
+                    assert_eq!(dash, cursor);
+                }
+                snapshots.push(format!(
+                    "width={width}, cursor={cursor}\n{}",
+                    display(&rendered)
+                ));
+            }
+            insta::assert_snapshot!(snapshots.join("\n\n"));
+        },
+    );
+}
+
+#[test]
+fn zero_credit_history_uses_a_readable_scale() {
+    let history = crate::analytics::normalize::history(
+        serde_json::from_str(r#"{"data":[]}"#).unwrap(),
+        crate::analytics::models::AccountAnalyticsReport::Credits,
+        crate::analytics::models::AccountAnalyticsGrouping::Surface,
+        "2026-01-09".parse().unwrap(),
+        "2026-01-15".parse().unwrap(),
+    )
+    .unwrap()
+    .unwrap();
+    let days = history
+        .data
+        .iter()
+        .map(|day| (day.date, Some(day)))
+        .collect::<Vec<_>>();
+    let rendered = chart(
+        &days,
+        &[],
+        /*cursor*/ 6,
+        /*width*/ 44,
+        /*height*/ 4,
+        history.unit,
+    );
+    assert_eq!(axis_max(peak(&days, &[]), history.unit), 1.0);
+    insta::assert_snapshot!(display(&rendered));
+}
+
+#[test]
+fn partial_cells_use_the_midpoint_and_descend_from_the_baseline() {
+    let categories = vec![value("a", /*value*/ 0.8), value("b", /*value*/ 0.95)];
+    let mut snapshots = Vec::new();
+    for sign in [1.0, -1.0] {
+        let day = AccountAnalyticsDay {
+            date: "2026-01-14".parse().unwrap(),
+            total: 1.75 * sign,
+            values: categories
+                .iter()
+                .map(|value| AccountAnalyticsValue {
+                    value: value.value * sign,
+                    ..value.clone()
+                })
+                .collect(),
+        };
+        let days = [
+            (day.date, Some(&day)),
+            ("2026-01-15".parse().unwrap(), None),
+        ];
+        let rendered = chart(
+            &days,
+            &categories,
+            /*cursor*/ 1,
+            /*width*/ 12,
+            /*height*/ 1,
+            AccountAnalyticsUnit::Credits,
+        );
+        let cell = &rendered.lines[if sign > 0.0 { 1 } else { 3 }].spans[1];
+        assert_eq!(cell.style.fg, Some(series_colors()[1]));
+        assert_eq!(cell.content.as_ref(), if sign > 0.0 { "▇" } else { "▁" });
+        assert_eq!(
+            cell.style
+                .add_modifier
+                .contains(ratatui::style::Modifier::REVERSED),
+            sign < 0.0
+        );
+        snapshots.push(format!("sign={sign}\n{}", display(&rendered)));
+    }
+    insta::assert_snapshot!(snapshots.join("\n\n"));
+}
+
+#[test]
+fn oversized_axes_are_hidden_instead_of_truncated() {
+    let mut snapshots = Vec::new();
+    for (width, total) in [
+        (8, 100_000_000.0),
+        (30, 100_000_000.0),
+        (35, 100_000_000.0),
+        (44, 100_000_000.0),
+        (30, 1e30),
+    ] {
+        let day = AccountAnalyticsDay {
+            date: "2026-01-15".parse().unwrap(),
+            total,
+            values: vec![value("a", total)],
+        };
+        let days = [(day.date, Some(&day))];
+
+        let rendered = chart(
+            &days,
+            &day.values,
+            /*cursor*/ 0,
+            width,
+            /*height*/ 4,
+            AccountAnalyticsUnit::Tokens,
+        );
+        let baseline = rendered.lines[5].to_string();
+        assert_eq!(baseline.starts_with('─'), width < 30 || total == 1e30);
+        if width == 8 {
+            assert!(rendered.lines[0].to_string().contains("100M"));
+        }
+        snapshots.push(format!("width={width}\n{}", display(&rendered)));
+    }
+    insta::assert_snapshot!(snapshots.join("\n\n"));
+}
+
+#[test]
+fn selected_callout_keeps_the_authoritative_daily_total() {
+    let day = AccountAnalyticsDay {
+        date: "2026-01-15".parse().unwrap(),
+        total: 20.0,
+        values: vec![value("a", /*value*/ 8.0), value("b", /*value*/ 4.0)],
+    };
+    let days = [(day.date, Some(&day))];
+    let rendered = chart(
+        &days,
+        &day.values,
+        /*cursor*/ 0,
+        /*width*/ 44,
+        /*height*/ 4,
+        AccountAnalyticsUnit::Credits,
+    );
+    assert!(display(&rendered).contains("20.00"));
+    assert!(!display(&rendered).contains("12.00"));
+    insta::assert_snapshot!(display(&rendered));
+}
+
+#[test]
+fn narrow_long_range_charts_never_truncate_dates() {
+    let start: NaiveDate = "2026-01-01".parse().unwrap();
+    let history = start
+        .iter_days()
+        .take(/*n*/ 30)
+        .map(|date| AccountAnalyticsDay {
+            date,
+            total: 1.0,
+            values: vec![value("a", /*value*/ 1.0)],
+        })
+        .collect::<Vec<_>>();
+    let days = history
+        .iter()
+        .map(|day| (day.date, Some(day)))
+        .collect::<Vec<_>>();
+    let mut snapshots = Vec::new();
+    for (width, expected) in [(1, ""), (2, "15"), (5, "15"), (6, "Jan 15")] {
+        let rendered = chart(
+            &days,
+            &history[0].values,
+            /*cursor*/ 14,
+            width,
+            /*height*/ 3,
+            AccountAnalyticsUnit::Count,
+        );
+        assert_eq!(rendered.lines.last().unwrap().to_string().trim(), expected);
+        snapshots.push(format!("width={width}\n{}", display(&rendered)));
+    }
+    insta::assert_snapshot!(snapshots.join("\n\n"));
+}
+
+#[test]
+fn tiny_segments_keep_their_series_color_beside_a_large_day() {
+    let large = AccountAnalyticsDay {
+        date: "2026-01-14".parse().unwrap(),
+        total: 100.0,
+        values: vec![value("a", /*value*/ 100.0)],
+    };
+    let mut snapshots = Vec::new();
+    for sign in [1.0, -1.0] {
+        let tiny = AccountAnalyticsDay {
+            date: "2026-01-15".parse().unwrap(),
+            total: 0.01 * sign,
+            values: vec![value("a", 0.01 * sign)],
+        };
+        let days = [(large.date, Some(&large)), (tiny.date, Some(&tiny))];
+        let rendered = chart(
+            &days,
+            &large.values,
+            /*cursor*/ 0,
+            /*width*/ 44,
+            /*height*/ 4,
+            AccountAnalyticsUnit::Credits,
+        );
+        let glyph = if sign > 0.0 { "▁" } else { "▇" };
+        let cells = rendered
+            .lines
+            .iter()
+            .flat_map(|line| &line.spans)
+            .filter(|span| span.content == glyph)
+            .collect::<Vec<_>>();
+        assert!(!cells.is_empty());
+        assert!(
+            cells
+                .iter()
+                .all(|cell| cell.style.fg == Some(series_colors()[0]))
+        );
+        snapshots.push(format!("sign={sign}\n{}", display(&rendered)));
+    }
+    insta::assert_snapshot!(snapshots.join("\n\n"));
+}
+
+#[test]
+fn duplicate_message_dates_render_the_full_other_remainder() {
+    use crate::analytics::models::AccountAnalyticsGrouping;
+    use crate::analytics::models::AccountAnalyticsReport;
+    let date = "2026-01-15".parse().unwrap();
+    let response = serde_json::from_value(serde_json::json!({"data": [
+        {"date": "2026-01-15", "totals": {"turns": 10}, "clients": [{"client_id": "CODEX_CLI", "turns": 8}]},
+        {"date": "2026-01-15", "totals": {"turns": 10}, "clients": [{"client_id": "CODEX_CLI", "turns": 8}]}
+    ]})).unwrap();
+    let history = crate::analytics::normalize::history(
+        response,
+        AccountAnalyticsReport::Messages,
+        AccountAnalyticsGrouping::Surface,
+        date,
+        date,
+    )
+    .unwrap()
+    .unwrap();
+    let day = &history.data[0];
+    let rendered = chart(
+        &[(date, Some(day))],
+        &day.values,
+        /*cursor*/ 0,
+        /*width*/ 44,
+        /*height*/ 10,
+        AccountAnalyticsUnit::Count,
+    );
+    insta::assert_snapshot!(display(&rendered));
+}
+
+#[test]
+fn seven_day_totals_render_without_selecting_each_bar() {
+    let start: NaiveDate = "2026-01-01".parse().unwrap();
+    let rows = (0..7)
+        .map(|index| AccountAnalyticsDay {
+            date: start + chrono::Duration::days(index),
+            total: 111.0 + index as f64 * 100.0,
+            values: vec![value("a", 111.0 + index as f64 * 100.0)],
+        })
+        .collect::<Vec<_>>();
+    let days = rows
+        .iter()
+        .map(|day| (day.date, Some(day)))
+        .collect::<Vec<_>>();
+    let rendered = chart(
+        &days,
+        &rows[0].values,
+        /*cursor*/ 3,
+        /*width*/ 100,
+        /*height*/ 8,
+        AccountAnalyticsUnit::Count,
+    );
+    let text = display(&rendered);
+    for day in &rows {
+        assert!(text.contains(&day.total.to_string()));
+    }
+    insta::assert_snapshot!("seven_day_totals", text);
+}
+
+#[test]
+fn narrow_equal_height_totals_remain_separate_numbers() {
+    let start: NaiveDate = "2026-01-01".parse().unwrap();
+    let rows = (0..7)
+        .map(|index| AccountAnalyticsDay {
+            date: start + chrono::Duration::days(index),
+            total: 111.0,
+            values: vec![value("a", /*value*/ 111.0)],
+        })
+        .collect::<Vec<_>>();
+    let days = rows
+        .iter()
+        .map(|day| (day.date, Some(day)))
+        .collect::<Vec<_>>();
+    let mut screens = Vec::new();
+    for width in [21, 28, 35] {
+        let rendered = chart(
+            &days,
+            &rows[0].values,
+            /*cursor*/ 3,
+            width,
+            /*height*/ 4,
+            AccountAnalyticsUnit::Count,
+        );
+        let text = rendered
+            .lines
+            .iter()
+            .map(|line| line.to_string().trim_end().to_owned())
+            .collect::<Vec<_>>()
+            .join("\n");
+        assert!(text.contains("111"));
+        assert!(!text.contains("111111"));
+        screens.push(text);
+    }
+    insta::assert_snapshot!(screens.join("\n\n"));
+}

codex-rs/tui/src/analytics/profile_identity_tests.rs

@@ -0,0 +1,28 @@
+//! In-flight profile responses cannot expose data after the active account changes.
+use super::*;
+use pretty_assertions::assert_eq;
+
+#[tokio::test]
+async fn profile_rejects_account_change_during_success_or_error_response() {
+    let server = MockServer::start().await;
+    for status in [200, 404, 503] {
+        server.reset().await;
+        let (home, live) = live(&server, "plus").await;
+        let home_path = home.path().to_path_buf();
+        Mock::given(method("GET"))
+            .and(path("/backend-api/wham/profiles/me"))
+            .and(header("chatgpt-account-id", "account-a"))
+            .respond_with(move |_: &wiremock::Request| {
+                sign_in(&home_path, "account-a", "user-b", "plus");
+                ResponseTemplate::new(status)
+                    .set_body_json(json!({"stats":{"lifetime_tokens":123}}))
+            })
+            .expect(/*r*/ 1)
+            .mount(&server)
+            .await;
+        assert_eq!(
+            live.profile().await.err().unwrap(),
+            "Account changed. Press R to refresh Analytics."
+        );
+    }
+}

codex-rs/tui/src/analytics/render.rs

@@ -0,0 +1,391 @@
+//! Maximized sections and a responsive overview share the same panels and scrolling behavior.
+//! Zoom, section changes, and reflow preserve report selections and inline details.
+
+use super::AnalyticsView;
+use super::data;
+use super::styles::secondary_style;
+use crate::analytics::models::AccountAnalyticsHistory;
+use crate::analytics::models::AccountAnalyticsValue;
+use crate::analytics::sections::Section;
+use crate::keymap::ListAction;
+use crate::style::accent_style;
+use crate::style::footer_hint_key_style;
+use crate::wrapping::RtOptions;
+use crate::wrapping::word_wrap_lines;
+use ratatui::buffer::Buffer;
+use ratatui::layout::Constraint;
+use ratatui::layout::Layout;
+use ratatui::layout::Rect;
+use ratatui::style::Color;
+use ratatui::style::Styled;
+use ratatui::style::Stylize;
+use ratatui::text::Line;
+use ratatui::widgets::Paragraph;
+use ratatui::widgets::Widget;
+use std::collections::BTreeMap;
+
+pub(super) fn columns(left: Line<'static>, right: Line<'static>, width: usize) -> Line<'static> {
+    let padding = width
+        .saturating_sub(left.width() + right.width())
+        .max(/*other*/ 1);
+    let mut spans = left.spans;
+    spans.push(" ".repeat(padding).into());
+    spans.extend(right.spans);
+    Line::from(spans)
+}
+
+/// Join independently stacked panels without leaving holes below shorter sections.
+pub(super) fn join_columns(
+    left: &[Line<'static>],
+    right: &[Line<'static>],
+    column_width: usize,
+) -> Vec<Line<'static>> {
+    (0..left.len().max(right.len()))
+        .map(|row| {
+            let left = left.get(row).cloned().unwrap_or_default();
+            let mut line = columns(left, Line::default(), column_width + 4);
+            if let Some(right) = right.get(row) {
+                line.spans.extend(right.spans.iter().cloned());
+            }
+            line
+        })
+        .collect()
+}
+
+pub(super) fn categories(history: &AccountAnalyticsHistory) -> Vec<AccountAnalyticsValue> {
+    let mut totals = BTreeMap::<String, AccountAnalyticsValue>::new();
+    for value in history.data.iter().flat_map(|day| &day.values) {
+        totals
+            .entry(value.key.clone())
+            .or_insert_with(|| AccountAnalyticsValue {
+                value: 0.0,
+                ..value.clone()
+            })
+            .value += value.value;
+    }
+    let mut values = totals.into_values().collect::<Vec<_>>();
+    values.sort_by(|a, b| {
+        b.value
+            .abs()
+            .total_cmp(&a.value.abs())
+            .then_with(|| a.key.cmp(&b.key))
+    });
+    values
+}
+
+/// The last plotted category collects all remaining values without renormalizing them.
+pub(super) fn parts(
+    values: &[AccountAnalyticsValue],
+    categories: &[AccountAnalyticsValue],
+) -> [f64; 4] {
+    let mut parts = [0.0; 4];
+    for value in values {
+        let index = categories
+            .iter()
+            .take(/*n*/ 3)
+            .position(|category| category.key == value.key)
+            .unwrap_or(/*default*/ 3);
+        parts[index] += value.value;
+    }
+    parts
+}
+
+impl AnalyticsView {
+    pub(super) fn render(&mut self, area: Rect, buf: &mut Buffer) {
+        self.poll_reports();
+        let width = usize::from(area.width.saturating_sub(/*rhs*/ 4)).max(/*other*/ 1);
+        let show_range = !matches!(
+            self.section,
+            Section::Chats | Section::Plan | Section::Summary
+        ) && !self.visible_sections().is_empty();
+        let hint = |action| {
+            self.keymap
+                .primary_hint(action)
+                .map(crate::key_hint::ShortcutHint::display_label)
+                .unwrap_or_default()
+        };
+        let mut controls = if self.visible_sections().is_empty() {
+            format!("R refresh · {} back · q close", hint(ListAction::Cancel))
+        } else {
+            let navigation = if !self.zoomed {
+                format!("{}/z maximize", hint(ListAction::Accept))
+            } else if self.section == Section::Summary {
+                format!(
+                    "{}/{} scroll",
+                    hint(ListAction::MoveUp),
+                    hint(ListAction::MoveDown)
+                )
+            } else if self.section == Section::Plan {
+                format!(
+                    "{}/{} window · {}/{} period · {} details",
+                    hint(ListAction::MoveLeft),
+                    hint(ListAction::MoveRight),
+                    hint(ListAction::MoveUp),
+                    hint(ListAction::MoveDown),
+                    hint(ListAction::Accept)
+                )
+            } else if self.section != Section::Chats {
+                format!(
+                    "{}/{} day · {} details",
+                    hint(ListAction::MoveLeft),
+                    hint(ListAction::MoveRight),
+                    hint(ListAction::Accept)
+                )
+            } else {
+                format!(
+                    "{}/{} row · {} details",
+                    hint(ListAction::MoveUp),
+                    hint(ListAction::MoveDown),
+                    hint(ListAction::Accept)
+                )
+            };
+            format!(
+                "tab/1–{} section · {}{navigation}\n{}{}R refresh · {}/{} scroll · {} back · q close",
+                self.visible_sections().len(),
+                if self.section == Section::Chats && !self.business() && !self.zoomed {
+                    "s sort · "
+                } else if self.section == Section::Chats && !self.business() {
+                    "s sort · z dashboard · "
+                } else if self.zoomed {
+                    "z dashboard · "
+                } else {
+                    ""
+                },
+                if show_range { "r 7/30d · " } else { "" },
+                if self.group_options().len() < 2 {
+                    ""
+                } else if self.section == Section::Summary {
+                    "g view · "
+                } else {
+                    "g group · "
+                },
+                hint(ListAction::PageUp),
+                hint(ListAction::PageDown),
+                hint(ListAction::Cancel)
+            )
+        };
+        let control_line = |line: &str| {
+            let mut spans = Vec::new();
+            for (index, control) in line.split(" · ").enumerate() {
+                if index > 0 {
+                    spans.push(" · ".into());
+                }
+                let (keys, description) = control.rsplit_once(' ').unwrap_or((control, ""));
+                spans.push(
+                    keys.to_owned()
+                        .fg(Color::Reset)
+                        .patch_style(footer_hint_key_style().bold().not_dim()),
+                );
+                if !description.is_empty() {
+                    spans.push(format!(" {description}").into());
+                }
+            }
+            Line::from(spans)
+        };
+        let updated = self
+            .zoomed
+            .then(|| self.sections[self.section].history.ready())
+            .flatten()
+            .and_then(|history| history.updated_at)
+            .and_then(|value| chrono::DateTime::from_timestamp(value, /*nsecs*/ 0))
+            .map(|updated| format!("Updated {} UTC", updated.format("%b %-d %H:%M")));
+        let add_updated = |footer: &mut Vec<Line<'static>>| {
+            if let Some(updated) = &updated {
+                let timestamp = Line::from(updated.clone().set_style(secondary_style()));
+                if let Some(line) = footer
+                    .last_mut()
+                    .filter(|line| line.width() + timestamp.width() + 3 <= width)
+                {
+                    *line = columns(line.clone(), timestamp, width);
+                } else {
+                    footer.extend(word_wrap_lines(
+                        [columns(Line::default(), timestamp, width)],
+                        RtOptions::new(width),
+                    ));
+                }
+            }
+        };
+        let mut footer = word_wrap_lines(controls.lines().map(control_line), RtOptions::new(width));
+        if matches!(
+            self.section,
+            Section::Plugins | Section::Activity | Section::Skills
+        ) && !self.day_has_details(self.section, self.sections[self.section].cursor)
+        {
+            let height = footer.len();
+            controls = controls.replace(&format!(" · {} details", hint(ListAction::Accept)), "");
+            footer = word_wrap_lines(controls.lines().map(control_line), RtOptions::new(width));
+            // Removing a contextual hint must not resize the chart on narrow terminals.
+            footer.resize(height, Line::default());
+        }
+        add_updated(&mut footer);
+        let sections = if self.zoomed {
+            let line = Line::from(
+                self.visible_sections()
+                    .iter()
+                    .copied()
+                    .enumerate()
+                    .map(|(index, section)| {
+                        let label = self.section_title(section);
+                        let label = if width >= 64 {
+                            format!("{} {label}", index + 1)
+                        } else {
+                            label.to_string()
+                        };
+                        if section == self.section {
+                            format!("[{label}]  ").set_style(accent_style())
+                        } else {
+                            format!("{label}  ").set_style(secondary_style())
+                        }
+                    })
+                    .collect::<Vec<_>>(),
+            );
+            word_wrap_lines([line], RtOptions::new(width))
+        } else {
+            Vec::new()
+        };
+        let [title, range, tabs, body, hints] = Layout::vertical([
+            Constraint::Length(1),
+            Constraint::Length(2),
+            Constraint::Length(if sections.is_empty() {
+                0
+            } else {
+                sections.len() as u16 + 1
+            }),
+            Constraint::Min(0),
+            Constraint::Length(footer.len() as u16),
+        ])
+        .areas(Rect {
+            x: area.x + area.width.min(/*other*/ 2),
+            width: area.width.saturating_sub(/*rhs*/ 4),
+            ..area
+        });
+        Line::from(vec![
+            "Analytics".bold(),
+            self.live
+                .as_ref()
+                .and_then(|live| live.account_label())
+                .map(|account| format!("  ·  Live account · {account}"))
+                .unwrap_or_else(|| "  ·  Live account".into())
+                .set_style(secondary_style()),
+        ])
+        .render(title, buf);
+        if show_range {
+            let dates = self.date_range();
+            let (start, end) = (dates.start(), dates.end());
+            Line::from(vec![
+                if self.ranges[self.range_group(self.section) as usize] == 0 {
+                    "[7d]".set_style(accent_style())
+                } else {
+                    "7d".into()
+                },
+                "  ".into(),
+                if self.ranges[self.range_group(self.section) as usize] == 1 {
+                    "[30d]".set_style(accent_style())
+                } else {
+                    "30d".into()
+                },
+                format!(
+                    "  ·  {}–{}",
+                    data::date(&start.to_string()),
+                    end.format("%b %-d, %Y")
+                )
+                .set_style(secondary_style()),
+            ])
+            .render(range, buf);
+        }
+        Paragraph::new(sections).render(tabs, buf);
+        self.viewport_height = usize::from(body.height).max(/*other*/ 1);
+        let (lines, selection) = if self.visible_sections().is_empty() {
+            let message = self
+                .account
+                .message()
+                .unwrap_or("Analytics is not available for this account type.");
+            let lines = textwrap::wrap(message, width)
+                .into_iter()
+                .map(|line| Line::from(line.into_owned()))
+                .collect::<Vec<_>>();
+            let selection = 0..lines.len();
+            (lines, selection)
+        } else if self.zoomed {
+            let chart_height =
+                (usize::from(body.height) / 5).clamp(/*min*/ 4, /*max*/ 10);
+            let mut panel = self.panel(self.section, width, chart_height);
+            if panel.chart_bands > 0 {
+                let overhead = panel.lines.len() - chart_height * panel.chart_bands;
+                let height =
+                    usize::from(body.height).saturating_sub(overhead + 1) / panel.chart_bands;
+                let height = height.max(/*other*/ 2);
+                if height != chart_height {
+                    panel = self.panel(self.section, width, height);
+                }
+            }
+            let center_summary = self.section == Section::Summary && self.profile.ready().is_some();
+            if center_summary {
+                // Keep the section heading and rule fixed; center the profile below them.
+                let padding = usize::from(body.height).saturating_sub(panel.lines.len()) / 2;
+                panel
+                    .lines
+                    .splice(2..2, std::iter::repeat_n(Line::default(), padding));
+            }
+            let selection = if panel.lines.len() <= usize::from(body.height) {
+                0..panel.lines.len()
+            } else {
+                panel.selection
+            };
+            if !center_summary && panel.lines.len() > usize::from(body.height) {
+                panel.lines.push(Line::default());
+            }
+            (panel.lines, selection)
+        } else {
+            self.dashboard_lines(width, usize::from(body.height))
+        };
+        if lines.len() <= self.viewport_height {
+            let height = footer.len();
+            let controls = controls
+                .replace(
+                    &format!(
+                        " · {}/{} scroll",
+                        hint(ListAction::PageUp),
+                        hint(ListAction::PageDown)
+                    ),
+                    "",
+                )
+                .replace(
+                    &format!(
+                        " · {}/{} scroll",
+                        hint(ListAction::MoveUp),
+                        hint(ListAction::MoveDown)
+                    ),
+                    "",
+                );
+            footer = word_wrap_lines(controls.lines().map(control_line), RtOptions::new(width));
+            add_updated(&mut footer);
+            if updated.is_some() {
+                let padding = height.saturating_sub(footer.len());
+                footer.splice(0..0, std::iter::repeat_n(Line::default(), padding));
+            } else {
+                footer.resize(height, Line::default());
+            }
+        }
+        if self.follow_selection {
+            if selection.start < self.scroll_offset {
+                self.scroll_offset = selection.start;
+            } else {
+                let end = selection.start + selection.len().min(self.viewport_height);
+                if end > self.scroll_offset + self.viewport_height {
+                    self.scroll_offset = end - self.viewport_height;
+                }
+            }
+        }
+        self.scroll_offset = self
+            .scroll_offset
+            .min(lines.len().saturating_sub(self.viewport_height));
+        self.follow_selection = false;
+        Paragraph::new(lines)
+            .scroll(/*offset*/ (self.scroll_offset as u16, 0))
+            .render(body, buf);
+        Paragraph::new(footer)
+            .set_style(secondary_style())
+            .render(hints, buf);
+    }
+}

codex-rs/tui/src/analytics/report_data.rs

@@ -0,0 +1,289 @@
+//! Projects endpoint-specific backend models into inputs for display normalization.
+//! This representation is never used to deserialize HTTP responses.
+//! Optional fields select the inputs used by each report; missing backend values stay missing.
+
+use codex_backend_client::AnalyticsResponse;
+use codex_backend_client::analytics_models as backend;
+
+/// Report values projected for normalization after endpoint-specific decoding.
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(test, derive(serde::Deserialize))]
+pub(super) struct AnalyticsData {
+    pub(super) data: Vec<AnalyticsRecord>,
+    pub(super) units: Option<String>,
+    pub(super) data_freshness_ts: Option<String>,
+    pub(super) series: Option<Vec<AnalyticsSeries>>,
+}
+
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(test, derive(serde::Deserialize))]
+pub(super) struct AnalyticsSeries {
+    pub(super) key: String,
+    pub(super) label: String,
+}
+
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(test, derive(serde::Deserialize))]
+pub(super) struct AnalyticsRecord {
+    pub(super) date: String,
+    pub(super) values: Option<std::collections::BTreeMap<String, f64>>,
+    pub(super) product_surface_usage_values: Option<std::collections::BTreeMap<String, f64>>,
+    pub(super) premium_usage_values: Option<PremiumUsage>,
+    pub(super) attribution: Option<Vec<UsageAttribution>>,
+    pub(super) credit_amount: Option<f64>,
+    pub(super) product_surface: Option<String>,
+    pub(super) totals: Option<AnalyticsCount>,
+    pub(super) models: Option<Vec<AnalyticsModel>>,
+    pub(super) groups: Option<Vec<AnalyticsTokenGroup>>,
+    pub(super) clients: Option<Vec<AnalyticsClient>>,
+    pub(super) plugin_usage_overviews: Option<Vec<AnalyticsTool>>,
+    pub(super) skill_usage_overviews: Option<Vec<AnalyticsTool>>,
+}
+
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(test, derive(serde::Deserialize))]
+pub(super) struct PremiumUsage {
+    pub(super) credit_usage_credits: std::collections::BTreeMap<String, f64>,
+}
+
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(test, derive(serde::Deserialize))]
+pub(super) struct UsageAttribution {
+    pub(super) thread_source: Option<String>,
+    pub(super) turn_trigger: Option<String>,
+    pub(super) model: Option<String>,
+    pub(super) surface: Option<String>,
+    pub(super) value: f64,
+}
+
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(test, derive(serde::Deserialize))]
+pub(super) struct AnalyticsCount {
+    pub(super) turns: f64,
+}
+
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(test, derive(serde::Deserialize))]
+pub(super) struct AnalyticsModel {
+    pub(super) model: String,
+    pub(super) credits: Option<f64>,
+    pub(super) uncached_text_input_tokens: Option<f64>,
+    pub(super) cached_text_input_tokens: Option<f64>,
+    pub(super) text_output_tokens: Option<f64>,
+    pub(super) text_total_tokens: Option<f64>,
+    pub(super) turns: Option<f64>,
+    pub(super) on_demand_credits: Option<f64>,
+    pub(super) speed: Option<String>,
+}
+
+/// Enterprise model groups carry text token counts independently of billing amounts.
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(test, derive(serde::Deserialize))]
+pub(super) struct AnalyticsTokenGroup {
+    pub(super) dimensions: std::collections::BTreeMap<String, String>,
+    #[cfg_attr(test, serde(default))]
+    pub(super) is_other: bool,
+    pub(super) uncached_text_input_tokens: Option<f64>,
+    pub(super) cached_text_input_tokens: Option<f64>,
+    pub(super) text_output_tokens: Option<f64>,
+}
+
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(test, derive(serde::Deserialize))]
+pub(super) struct AnalyticsClient {
+    pub(super) client_id: String,
+    pub(super) turns: f64,
+}
+
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(test, derive(serde::Deserialize))]
+pub(super) struct AnalyticsTool {
+    pub(super) display_name: String,
+    pub(super) invocation_counts: f64,
+}
+
+impl From<AnalyticsResponse> for AnalyticsData {
+    fn from(response: AnalyticsResponse) -> Self {
+        match response {
+            AnalyticsResponse::Usage(response) => Self {
+                units: response.units,
+                data_freshness_ts: response.data_freshness_ts,
+                data: response
+                    .data
+                    .into_iter()
+                    .map(|record| AnalyticsRecord {
+                        date: record.date,
+                        product_surface_usage_values: Some(record.product_surface_usage_values),
+                        premium_usage_values: record.premium_usage_values.map(|value| {
+                            PremiumUsage {
+                                credit_usage_credits: value.credit_usage_credits,
+                            }
+                        }),
+                        attribution: record.attribution.map(|values| {
+                            values
+                                .into_iter()
+                                .map(|value| UsageAttribution {
+                                    thread_source: Some(value.thread_source),
+                                    turn_trigger: Some(value.turn_trigger),
+                                    model: Some(value.model),
+                                    surface: Some(value.surface),
+                                    value: value.value,
+                                })
+                                .collect()
+                        }),
+                        models: record
+                            .models
+                            .map(|values| values.into_iter().map(AnalyticsModel::from).collect()),
+                        groups: record.groups.map(|values| {
+                            values
+                                .into_iter()
+                                .map(|value| AnalyticsTokenGroup {
+                                    dimensions: value.dimensions,
+                                    is_other: value.is_other.unwrap_or(/*default*/ false),
+                                    uncached_text_input_tokens: value
+                                        .uncached_text_input_tokens
+                                        .map(|count| count as f64),
+                                    cached_text_input_tokens: value
+                                        .cached_text_input_tokens
+                                        .map(|count| count as f64),
+                                    text_output_tokens: value
+                                        .text_output_tokens
+                                        .map(|count| count as f64),
+                                })
+                                .collect()
+                        }),
+                        ..Default::default()
+                    })
+                    .collect(),
+                ..Default::default()
+            },
+            AnalyticsResponse::Credits(response) => Self {
+                data: response
+                    .data
+                    .into_iter()
+                    .map(|record| AnalyticsRecord {
+                        date: record.date,
+                        credit_amount: Some(record.credit_amount),
+                        product_surface: Some(record.product_surface),
+                        ..Default::default()
+                    })
+                    .collect(),
+                ..Default::default()
+            },
+            AnalyticsResponse::EnterpriseCredits(response) => Self {
+                data_freshness_ts: response.data_freshness_ts,
+                series: Some(
+                    response
+                        .series
+                        .into_iter()
+                        .map(|value| AnalyticsSeries {
+                            key: value.key,
+                            label: value.label,
+                        })
+                        .collect(),
+                ),
+                data: response
+                    .data
+                    .into_iter()
+                    .map(|record| AnalyticsRecord {
+                        date: record.date,
+                        values: Some(record.values),
+                        ..Default::default()
+                    })
+                    .collect(),
+                ..Default::default()
+            },
+            AnalyticsResponse::Messages(response) => Self {
+                data: response
+                    .data
+                    .into_iter()
+                    .map(|record| AnalyticsRecord {
+                        date: record.date,
+                        totals: Some(AnalyticsCount {
+                            turns: record.totals.turns as f64,
+                        }),
+                        clients: Some(
+                            record
+                                .clients
+                                .into_iter()
+                                .map(|value| AnalyticsClient {
+                                    client_id: value.client_id,
+                                    turns: value.turns as f64,
+                                })
+                                .collect(),
+                        ),
+                        models: record
+                            .models
+                            .map(|values| values.into_iter().map(AnalyticsModel::from).collect()),
+                        ..Default::default()
+                    })
+                    .collect(),
+                ..Default::default()
+            },
+            AnalyticsResponse::Plugins(response) => Self {
+                data_freshness_ts: response.data_freshness_ts,
+                data: response
+                    .data
+                    .into_iter()
+                    .map(|record| AnalyticsRecord {
+                        date: record.date,
+                        plugin_usage_overviews: Some(
+                            record
+                                .plugin_usage_overviews
+                                .into_iter()
+                                .map(|value| AnalyticsTool {
+                                    display_name: value.display_name,
+                                    invocation_counts: value.invocation_counts as f64,
+                                })
+                                .collect(),
+                        ),
+                        ..Default::default()
+                    })
+                    .collect(),
+                ..Default::default()
+            },
+            AnalyticsResponse::Skills(response) => Self {
+                data_freshness_ts: response.data_freshness_ts,
+                data: response
+                    .data
+                    .into_iter()
+                    .map(|record| AnalyticsRecord {
+                        date: record.date,
+                        skill_usage_overviews: Some(
+                            record
+                                .skill_usage_overviews
+                                .into_iter()
+                                .map(|value| AnalyticsTool {
+                                    display_name: value.display_name,
+                                    invocation_counts: value.invocation_counts as f64,
+                                })
+                                .collect(),
+                        ),
+                        ..Default::default()
+                    })
+                    .collect(),
+                ..Default::default()
+            },
+        }
+    }
+}
+
+impl From<backend::ModelUsage> for AnalyticsModel {
+    fn from(value: backend::ModelUsage) -> Self {
+        Self {
+            model: value.model,
+            credits: Some(value.credits),
+            uncached_text_input_tokens: value.uncached_text_input_tokens.map(|count| count as f64),
+            cached_text_input_tokens: value.cached_text_input_tokens.map(|count| count as f64),
+            text_output_tokens: value.text_output_tokens.map(|count| count as f64),
+            text_total_tokens: value.text_total_tokens.map(|count| count as f64),
+            turns: value.turns.map(|count| count as f64),
+            on_demand_credits: value.on_demand_credits,
+            speed: value.speed,
+        }
+    }
+}
+
+#[cfg(test)]
+#[path = "report_data_tests.rs"]
+mod tests;

codex-rs/tui/src/analytics/report_data_tests.rs

@@ -0,0 +1,84 @@
+use super::*;
+use pretty_assertions::assert_eq;
+
+#[test]
+fn typed_usage_preserves_missing_counts_and_supplied_zero() {
+    let input = backend::DailyProductSurfaceUsageResponse {
+        data: vec![backend::DailyProductSurfaceUsage {
+            date: "2026-01-09".into(),
+            models: Some(vec![backend::ModelUsage {
+                model: "example".into(),
+                credits: 1.5,
+                cached_text_input_tokens: Some(0),
+                text_output_tokens: Some(42),
+                ..Default::default()
+            }]),
+            ..Default::default()
+        }],
+        ..Default::default()
+    };
+    let actual = AnalyticsData::from(AnalyticsResponse::Usage(input));
+    let model = &actual.data[0].models.as_ref().unwrap()[0];
+    assert_eq!(
+        (
+            model.credits,
+            model.uncached_text_input_tokens,
+            model.cached_text_input_tokens,
+            model.text_output_tokens
+        ),
+        (Some(1.5), None, Some(0.0), Some(42.0))
+    );
+}
+
+#[test]
+fn typed_message_records_keep_independent_daily_remainders() {
+    use super::super::models::*;
+    let date = "2026-01-09".parse().unwrap();
+    let row = backend::DailyWorkspaceUsageCount {
+        date: "2026-01-09".into(),
+        totals: backend::WorkspaceUsageCount {
+            turns: 10,
+            ..Default::default()
+        },
+        clients: vec![backend::ClientWorkspaceUsageCount {
+            client_id: "CODEX_CLI".into(),
+            turns: 8,
+            ..Default::default()
+        }],
+        ..Default::default()
+    };
+    let response = AnalyticsResponse::Messages(backend::DailyWorkspaceUsageCountResponse {
+        data: vec![row.clone(), row],
+        ..Default::default()
+    });
+    assert_eq!(
+        super::super::normalize::history(
+            response.into(),
+            AccountAnalyticsReport::Messages,
+            AccountAnalyticsGrouping::Surface,
+            date,
+            date
+        )
+        .unwrap(),
+        Some(AccountAnalyticsHistory {
+            unit: AccountAnalyticsUnit::Count,
+            updated_at: None,
+            data: vec![AccountAnalyticsDay {
+                date,
+                total: 20.0,
+                values: vec![
+                    AccountAnalyticsValue {
+                        key: "cli".into(),
+                        label: "CLI".into(),
+                        value: 16.0
+                    },
+                    AccountAnalyticsValue {
+                        key: "other".into(),
+                        label: "Other".into(),
+                        value: 4.0
+                    },
+                ]
+            }],
+        })
+    );
+}

codex-rs/tui/src/analytics/sections.rs

@@ -0,0 +1,294 @@
+//! Account-specific section order, request eligibility, and independent report ranges.
+//! Resolving the account precedes report loading; refreshing drops all account-owned data.
+
+use super::AnalyticsView;
+use super::chats;
+use super::data::Load;
+use super::models::AccountKind;
+
+/// Stable identities preserve selections while account layouts change their order.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum Section {
+    Usage,
+    Plugins,
+    Credits,
+    Chats,
+    Activity,
+    Skills,
+    Plan,
+    Summary,
+}
+
+impl Section {
+    pub(super) fn report(self) -> Option<super::models::AccountAnalyticsReport> {
+        use super::models::AccountAnalyticsReport as Report;
+        match self {
+            Self::Usage => Some(Report::Usage),
+            Self::Plugins => Some(Report::Plugins),
+            Self::Credits => Some(Report::Credits),
+            Self::Chats | Self::Plan | Self::Summary => None,
+            Self::Activity => Some(Report::Messages),
+            Self::Skills => Some(Report::Skills),
+        }
+    }
+}
+
+/// Section-only indexing keeps report identity separate from array positions.
+pub(super) struct SectionStates(pub(super) [SectionState; 8]);
+
+impl std::ops::Index<Section> for SectionStates {
+    type Output = SectionState;
+    fn index(&self, section: Section) -> &Self::Output {
+        &self.0[section as usize]
+    }
+}
+
+impl std::ops::IndexMut<Section> for SectionStates {
+    fn index_mut(&mut self, section: Section) -> &mut Self::Output {
+        &mut self.0[section as usize]
+    }
+}
+
+/// A report and its selection are replaced independently of the other sections.
+pub(super) struct SectionState {
+    pub(super) history: Load<super::models::AccountAnalyticsHistory>,
+    pub(super) cursor: usize,
+    pub(super) detail: Option<usize>,
+    pub(super) group: usize,
+}
+
+impl Default for SectionState {
+    fn default() -> Self {
+        Self {
+            history: Load::Unavailable,
+            cursor: 6,
+            detail: None,
+            group: 0,
+        }
+    }
+}
+
+/// Usage, product activity, and tools each share one range across their related sections.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum RangeGroup {
+    Usage,
+    Activity,
+    Tools,
+}
+
+impl AnalyticsView {
+    pub(super) fn poll_reports(&mut self) {
+        for section in &mut self.sections.0 {
+            section.history.poll();
+        }
+        self.chats.poll();
+        self.tasks.poll();
+        self.profile.poll();
+        self.plan.poll();
+        self.account.poll();
+        self.start_reports();
+        if !self.business()
+            && !self.consumer_attribution()
+            && ![0, 2].contains(&self.sections[Section::Usage].group)
+        {
+            self.sections[Section::Usage].group = 0;
+        }
+        if let Some(chats) = self.tasks.ready() {
+            self.sections[Section::Chats].cursor = self.sections[Section::Chats]
+                .cursor
+                .min(chats.rows.len().saturating_sub(/*rhs*/ 1));
+        }
+        if let Some(chats) = self.chats.ready() {
+            self.sections[Section::Chats].cursor = self.sections[Section::Chats]
+                .cursor
+                .min(chats.rows.len().saturating_sub(/*rhs*/ 1));
+        }
+    }
+
+    pub(super) fn range_group(&self, section: Section) -> RangeGroup {
+        match section {
+            Section::Usage if self.business() => RangeGroup::Activity,
+            Section::Usage
+            | Section::Credits
+            | Section::Chats
+            | Section::Plan
+            | Section::Summary => RangeGroup::Usage,
+            Section::Activity => RangeGroup::Activity,
+            Section::Plugins | Section::Skills => RangeGroup::Tools,
+        }
+    }
+
+    pub(super) fn group_label(&self, section: Section, group: usize) -> &'static str {
+        if section == Section::Summary {
+            return super::summary::VIEWS[group].label();
+        }
+        if group == 0
+            && (section == Section::Credits
+                || (section == Section::Usage && !self.consumer_attribution()))
+        {
+            "Product"
+        } else {
+            super::data::GROUP_LABELS[group]
+        }
+    }
+
+    fn account_kind(&self) -> Option<AccountKind> {
+        self.account
+            .ready()
+            .copied()
+            .map(|plan| AccountKind::from(Some(plan)))
+    }
+
+    pub(super) fn business(&self) -> bool {
+        matches!(
+            self.account_kind(),
+            Some(AccountKind::Business | AccountKind::Enterprise)
+        )
+    }
+
+    pub(super) fn visible_sections(&self) -> &'static [Section] {
+        match self.account_kind() {
+            Some(AccountKind::Consumer) if self.plan.enabled => &[
+                Section::Summary,
+                Section::Usage,
+                Section::Plan,
+                Section::Activity,
+                Section::Plugins,
+                Section::Skills,
+                Section::Chats,
+            ],
+            Some(AccountKind::Consumer) => &[
+                Section::Summary,
+                Section::Usage,
+                Section::Activity,
+                Section::Plugins,
+                Section::Skills,
+                Section::Chats,
+            ],
+            Some(AccountKind::Business | AccountKind::Enterprise)
+                if super::models::thread_usage_supported(self.account.ready().copied()) =>
+            {
+                &[
+                    Section::Summary,
+                    Section::Credits,
+                    Section::Usage,
+                    Section::Plugins,
+                    Section::Skills,
+                    Section::Chats,
+                ]
+            }
+            Some(AccountKind::Business | AccountKind::Enterprise) => &[
+                Section::Summary,
+                Section::Credits,
+                Section::Usage,
+                Section::Plugins,
+                Section::Skills,
+            ],
+            Some(AccountKind::Unknown) => &[Section::Summary],
+            None => &[],
+        }
+    }
+
+    pub(super) fn start_reports(&mut self) {
+        if self.reports_started || self.account.ready().is_none() {
+            return;
+        }
+        self.reports_started = true;
+        let visible = self.visible_sections();
+        let Some(first) = visible.first() else {
+            return;
+        };
+        if !visible.contains(&self.section) {
+            self.section = *first;
+        }
+        let usage_groups: &[usize] = if self.business() {
+            &[6, 2]
+        } else {
+            &[1, 2, 0, 3]
+        };
+        if !usage_groups.contains(&self.sections[Section::Usage].group) {
+            self.sections[Section::Usage].group =
+                if matches!(self.account_kind(), Some(AccountKind::Business)) {
+                    2
+                } else {
+                    usage_groups[0]
+                };
+        }
+        if visible.contains(&Section::Credits)
+            && let Some(live) = &self.live
+            && !live
+                .credit_groups()
+                .contains(&self.sections[Section::Credits].group)
+        {
+            self.sections[Section::Credits].group = live.credit_groups()[0];
+        }
+        self.load_summary();
+        for section in visible {
+            if section.report().is_some() {
+                self.load_report(*section);
+            }
+        }
+        if visible.contains(&Section::Plan)
+            && let (Some((_, _, frame)), Some(live)) = (&self.connection, &self.live)
+        {
+            let live = std::sync::Arc::clone(live);
+            self.plan.report = Load::start(async move { live.plan_history().await }, frame.clone());
+        }
+        if visible.contains(&Section::Chats) && !self.business() {
+            if let (Some((_, handle, frame)), Some(live)) = (&self.connection, &self.live) {
+                self.tasks = Load::start_with_timeout(
+                    super::tasks::read(handle.clone(), std::sync::Arc::clone(live)),
+                    frame.clone(),
+                    std::time::Duration::from_secs(/*secs*/ 120),
+                );
+            }
+        } else if visible.contains(&Section::Chats) {
+            self.chats =
+                if let (Some((_, handle, frame)), Some(live)) = (&self.connection, &self.live) {
+                    Load::start_with_timeout(
+                        chats::read(handle.clone(), std::sync::Arc::clone(live)),
+                        frame.clone(),
+                        std::time::Duration::from_secs(/*secs*/ 90),
+                    )
+                } else {
+                    Load::Unavailable
+                };
+        }
+    }
+
+    pub(super) fn section_date_range(
+        &self,
+        section: Section,
+    ) -> std::ops::RangeInclusive<chrono::NaiveDate> {
+        let end = self.end_date;
+        let range = self.ranges[self.range_group(section) as usize];
+        (end - chrono::Days::new(if range == 0 { 6 } else { 29 }))..=end
+    }
+
+    pub(super) fn change_range(&mut self) {
+        let index = self.range_group(self.section);
+        self.ranges[index as usize] ^= 1;
+        for section in self.visible_sections() {
+            if matches!(section, Section::Chats | Section::Plan | Section::Summary)
+                || self.range_group(*section) != index
+            {
+                continue;
+            }
+            self.sections[*section].cursor = if self.ranges[index as usize] == 1 {
+                self.sections[*section].cursor + 23
+            } else {
+                self.sections[*section].cursor.saturating_sub(/*rhs*/ 23)
+            };
+            self.sections[*section].detail = self.sections[*section].detail.and_then(|day| {
+                if self.ranges[index as usize] == 1 {
+                    Some(day + 23)
+                } else {
+                    day.checked_sub(/*rhs*/ 23)
+                }
+            });
+            if section.report().is_some() {
+                self.load_report(*section);
+            }
+        }
+    }
+}

codex-rs/tui/src/analytics/snapshots/codex_tui__analytics__client__connection_tests__account_plan_error.snap

@@ -0,0 +1,44 @@
+---
+source: tui/src/analytics/connection_tests.rs
+expression: terminal.backend().to_string()
+---
+"  Analytics  ·  Live account                                                                        "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"  Couldn't load account plan. Press R to retry Analytics.                                           "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"  R refresh · esc back · q close                                                                    "

codex-rs/tui/src/analytics/snapshots/codex_tui__analytics__client__connection_tests__local_profile_error.snap

@@ -0,0 +1,52 @@
+---
+source: tui/src/analytics/connection_tests.rs
+expression: terminal.backend().to_string()
+---
+"  Analytics  ·  Live account · analytics@example.test                                               "
+"                                                                                                    "
+"                                                                                                    "
+"  [1 Summary]  2 Credits usage history  3 Token usage history  4 Plugins called  5 Skills used      "
+"                                                                                                    "
+"  ▎ Summary                                                                                         "
+"  ────────────────────────────────────────────────────────────────────────────────────────────────  "
+"  Report request failed. Press R to retry.                                                          "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"  tab/1–5 section · z dashboard                                                                     "
+"  g view · R refresh · esc back · q close                                                           "

codex-rs/tui/src/analytics/snapshots/codex_tui__analytics__client__connection_tests__local_profile_recovered.snap

@@ -0,0 +1,52 @@
+---
+source: tui/src/analytics/connection_tests.rs
+expression: terminal.backend().to_string()
+---
+"  Analytics  ·  Live account · analytics@example.test                                               "
+"                                                                                                    "
+"                                                                                                    "
+"  [1 Summary]  2 Credits usage history  3 Token usage history  4 Plugins called  5 Skills used      "
+"                                                                                                    "
+"  ▎ Summary                                                                                         "
+"  ────────────────────────────────────────────────────────────────────────────────────────────────  "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                           Local account                                            "
+"                                            @local-user                                             "
+"                                             Enterprise                                             "
+"                                                                                                    "
+"         12.3K              12.3K                —                  —                  —            "
+"    Lifetime tokens      Peak tokens       Longest chat      Current streak     Longest streak      "
+"                                                                                                    "
+"  Token activity                                                                             Daily  "
+"  Last 12 months                                                                                    "
+"                                                                                                    "
+"        Nov       Dec     Jan     Feb     Mar       Apr     May       Jun     Jul     Aug           "
+"   Su □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □   "
+"   Mo □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □   "
+"   Tu □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □   "
+"   We □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ ■   "
+"   Th □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □     "
+"   Fr □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □     "
+"   Sa □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □ □     "
+"                                                                                                    "
+"     Less □ ■ ■ ■ ■ More                                                                            "
+"                                                                                                    "
+"  Activity insights                                 Most used plugins and skills                    "
+"                                                                                                    "
+"  Fast Mode                                    —    Plugin and skill usage unavailable.             "
+"  Most used reasoning                          —                                                    "
+"  Skills explored                              —                                                    "
+"  Total skills used                            —                                                    "
+"  Total chats                                  —                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"  tab/1–5 section · z dashboard                                                                     "
+"  g view · R refresh · esc back · q close                                                           "

codex-rs/tui/src/analytics/snapshots/codex_tui__analytics__client__tests__live_account_identity_is_visible_and_closing_aborts_pending_loads.snap

@@ -0,0 +1,28 @@
+---
+source: tui/src/analytics/client_tests.rs
+expression: terminal.backend().to_string()
+---
+"  Analytics  ·  Live account · analytics@example.test                                               "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"  No history has been reported.                                                                     "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"                                                                                                    "
+"  R refresh · esc back · q close                                                                    "

codex-rs/tui/src/analytics/snapshots/codex_tui__analytics__plan__tests__period_navigation_preserves_unknowns_and_resets_on_new_snapshot.snap

@@ -0,0 +1,65 @@
+---
+source: tui/src/analytics/plan_tests.rs
+expression: "output.join(\"\\n\")"
+---
+"  Analytics  ·  Live account                                                                                            "
+"                                                                                                                        "
+"                                                                                                                        "
+"  1 Summary  2 Total usage history  [3 Plan usage history]  4 Messages  5 Plugins called  6 Skills used  7 Top chats    "
+"                                                                                                                        "
+"  ▎ Plan usage history                                                                                      By feature  "
+"  ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────  "
+"    5-hour limits                                             › Weekly limits                                           "
+"                                                                                                                        "
+"  › Sep 2 10:00 – Sep 2 15:00 *                       125%    › Sep 1 00:00 – Sep 8 00:00 *              Not available  "
+"    Some usage is unavailable; this period may be               Breakdown isn't available for this period               "
+"  incomplete                                                                                                            "
+"    Tasks                                             125%                                                              "
+"  Some periods aren't available yet                                                                                     "
+"  Usage as of Sep 2 12:00 UTC · * current at last update                                                                "
+"  Available since Sep 1 00:00 UTC                                                                                       "
+"  Amounts and period boundaries are approximate; recent activity may be delayed                                         "
+"                                                                                                                        "
+"                                                                                                                        "
+"                                                                                                                        "
+"                                                                                                                        "
+"                                                                                                                        "
+"                                                                                                                        "
+"                                                                                                                        "
+"                                                                                                                        "
+"                                                                                                                        "
+"                                                                                                                        "
+"                                                                                                                        "
+"  tab/1–7 section · z dashboard · ←/→ window · ↑/↓ period · enter details                                               "
+"  g group · R refresh · esc back · q close                                                                              "
+
+"  Analytics  ·  Live account                              "
+"                                                          "
+"                                                          "
+"  Summary  Total usage history  [Plan usage history]      "
+"  Messages  Plugins called  Skills used  Top chats        "
+"                                                          "
+"  ▎ Plan usage history                        By feature  "
+"  ──────────────────────────────────────────────────────  "
+"    5-hour limits                                         "
+"                                                          "
+"  › Sep 2 10:00 – Sep 2 15:00 *                     125%  "
+"    Some usage is unavailable; this period may be         "
+"  incomplete                                              "
+"    Tasks                                           125%  "
+"                                                          "
+"  › Weekly limits                                         "
+"                                                          "
+"  › Sep 1 00:00 – Sep 8 00:00 *            Not available  "
+"    Breakdown isn't available for this period             "
+"  Some periods aren't available yet                       "
+"  Usage as of Sep 2 12:00 UTC · * current at last update  "
+"  Available since Sep 1 00:00 UTC                         "
+"  Amounts and period boundaries are approximate; recent   "
+"  activity may be delayed                                 "
+"                                                          "
+"                                                          "
+"  tab/1–7 section · z dashboard · ←/→ window · ↑/↓        "
+"  period · enter details                                  "
+"  g group · R refresh · esc back · q close                "
+"                                                          "

codex-rs/tui/src/analytics/snapshots/codex_tui__analytics__plan__tests__plan_overview_escape_closes_with_retained_expansion.snap

@@ -0,0 +1,64 @@
+---
+source: tui/src/analytics/plan_tests.rs
+expression: output
+---
+"  Analytics  ·  Live account                                                                                            "
+"                                                                                                                        "
+"                                                                                                                        "
+"  ╭─   1 Summary ────────────────────────────────────────╮    ╭─   2 Total usage history ────────────────────────────╮  "
+"  │                                                      │    │                                                      │  "
+"  │ No history has been reported.                        │    │ 7d                                                   │  "
+"  │                                                      │    │ By feature                                           │  "
+"  │                                                      │    │ Total usage · relative units                         │  "
+"  │                                                      │    │       20     73     64    91     81     100    86    │  "
+"  │                                                      │    │  100  ▁▁▁▁  ▅▅▅▅   ▅▅▅▅   ▇▇▇▇  ▆▆▆▆   ████   ▆▆▆▆   │  "
+"  │                                                      │    │    0 ─────────────────────────────────────────────── │  "
+"  │                                                      │    │                                                 ▲    │  "
+"  │                                                      │    │       27     28     29    30     31      1      2    │  "
+"  │                                                      │    │                                                      │  "
+"  │                                                      │    │ Sep 2 · 86 usage units                               │  "
+"  │                                                      │    │ ● Tasks                                        64.0% │  "
+"  │                                                      │    │ ● Code review                                  14.0% │  "
+"  │                                                      │    │                                                      │  "
+"  ╰──────────────────────────────────────────────────────╯    ╰──────────────────────────────────────────────────────╯  "
+"                                                                                                                        "
+"  ╭─ ▸ 3 Plan usage history ─────────────────────────────╮    ╭─   4 Messages ───────────────────────────────────────╮  "
+"  │                                                      │    │                                                      │  "
+"  │ By feature                                           │    │ 7d                                                   │  "
+"  │ › 5-hour limits                                      │    │ By model                                             │  "
+"  │                                                      │    │ 574 reported messages                                │  "
+"  │ Latest period · 12 total                        125% │    │       62     83     107   75     59     85     103   │  "
+"  │                                                      │    │  150  ▃▃▃▃  ▄▄▄▄   ▅▅▅▅   ▄▄▄▄  ▃▃▃▃   ▄▄▄▄   ▅▅▅▅   │  "
+"  │   Weekly limits                                      │    │    0 ─────────────────────────────────────────────── │  "
+"  │                                                      │    │                                                 ▲    │  "
+"  │ Latest period · 1 total                Not available │    │       27     28     29    30     31      1      2    │  "
+"  │ Some periods aren't available yet                    │    │                                                      │  "
+"  │ Usage as of Sep 2 12:00 UTC                          │    │ Sep 2 · 103 messages                                 │  "
+"  │ Available since Sep 1 00:00 UTC                      │    │ ● GPT-5.6-Sol                                     61 │  "
+"  │ … z to maximize                                      │    │ ● GPT-5.6-Terra                                   25 │  "
+"  │                                                      │    │                                                      │  "
+"  ╰──────────────────────────────────────────────────────╯    ╰──────────────────────────────────────────────────────╯  "
+"                                                                                                                        "
+"  ╭─   5 Plugins called ─────────────────────────────────╮    ╭─   6 Skills used ────────────────────────────────────╮  "
+"  │                                                      │    │                                                      │  "
+"  │ 7d                                                   │    │ 7d                                                   │  "
+"  │ 186 calls                                            │    │ 54 uses                                              │  "
+"  │      34     23     29     26     22     23     29    │    │       8      6      9      8      7      5     11    │  "
+"  │  40  ▆▆▆▆  ▄▄▄▄   ▅▅▅▅   ▅▅▅▅   ▄▄▄▄   ▄▄▄▄   ▅▅▅▅   │    │  20  ▃▃▃▃  ▂▂▂▂   ▃▃▃▃   ▃▃▃▃   ▂▂▂▂   ▂▂▂▂   ▄▄▄▄   │  "
+"  │   0 ──────────────────────────────────────────────── │    │   0 ──────────────────────────────────────────────── │  "
+"  │                                                 ▲    │    │                                                 ▲    │  "
+"  │      27     28     29     30     31      1      2    │    │      27     28     29     30     31      1      2    │  "
+"  │                                                      │    │                                                      │  "
+"  │ Sep 2 · 29 calls                                     │    │ Sep 2 · 11 uses                                      │  "
+"  │ ● Slack                                           10 │    │ ● Testing                                          4 │  "
+"  │ ● Figma                                           10 │    │ ● Code review                                      3 │  "
+"  │                                                      │    │                                                      │  "
+"  │                                                      │    │                                                      │  "
+"  ╰──────────────────────────────────────────────────────╯    ╰──────────────────────────────────────────────────────╯  "
+"                                                                                                                        "
+"  ╭─   7 Top chats ──────────────────────────────────────╮                                                              "
+"  │                                                      │                                                              "
+"  │ No history has been reported.                        │                                                              "
+"  │                                                      │                                                              "
+"  tab/1–7 section · enter/z maximize                                                                                    "
+"  g group · R refresh · pgup/pgdn scroll · esc back · q close                                                           "

codex-rs/tui/src/analytics/snapshots/codex_tui__analytics__plan__tests__unavailable_empty_and_zero_history_are_distinct.snap

@@ -0,0 +1,31 @@
+---
+source: tui/src/analytics/plan_tests.rs
+assertion_line: 105
+expression: snapshot
+---
+› 5-hour limits                                       Weekly limits
+
+Limit history isn't available yet                   Limit history isn't available yet
+
+› 5-hour limits                                       Weekly limits
+
+No limit periods in this date range                 No limit periods in this date range
+Usage as of Sep 2 12:00 UTC · * current at last update
+Available since Sep 1 00:00 UTC
+Amounts and period boundaries are approximate; recent activity may be delayed
+
+› 5-hour limits                                       Weekly limits
+
+› Sep 2 10:00 – Sep 2 15:00 *                 0%    › Sep 1 00:00 – Sep 8 00:00 *      Not available
+Some periods aren't available yet
+Usage as of Sep 2 12:00 UTC · * current at last update
+Available since Sep 1 00:00 UTC
+Amounts and period boundaries are approximate; recent activity may be delayed
+
+› 5-hour limits                                       Weekly limits
+
+› Sep 2 13:00 – Sep 2 15:00                 125%    › Sep 1 00:00 – Sep 8 00:00 *      Not available
+Some periods aren't available yet
+Usage as of Sep 2 12:00 UTC · * current at last update
+Available since Sep 1 00:00 UTC
+Amounts and period boundaries are approximate; recent activity may be delayed

codex-rs/tui/src/analytics/snapshots/codex_tui__analytics__plot__tests__duplicate_message_dates_render_the_full_other_remainder.snap

@@ -0,0 +1,42 @@
+---
+source: tui/src/analytics/plot_tests.rs
+expression: display(&rendered)
+---
+                      20
+ 20               ████████████
+                  ████████████
+                  ████████████
+                  ████████████
+                  ████████████
+ 10               ████████████
+                  ████████████
+                  ████████████
+                  ████████████
+                  ████████████
+  0 ────────────────────────────────────────
+                       ▲
+                    Jan 15
+
+Palette:
+0: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+1: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+2: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+3: Style::new().magenta().bg(Color::Reset).underline_color(Color::Reset)
+4: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+5: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+6: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold().underlined()
+Rows (column:palette):
+0: 0:0 22:1 24:0
+1: 0:0 1:2 3:0 18:3 30:0
+2: 0:0 18:3 30:0
+3: 0:0 18:4 30:0
+4: 0:0 18:4 30:0
+5: 0:0 18:4 30:0
+6: 0:0 1:2 3:0 18:4 30:0
+7: 0:0 18:4 30:0
+8: 0:0 18:4 30:0
+9: 0:0 18:4 30:0
+10: 0:0 18:4 30:0
+11: 0:0 2:2 3:0 4:2
+12: 0:0 23:5 24:0
+13: 0:0 20:6 26:0

codex-rs/tui/src/analytics/snapshots/codex_tui__analytics__plot__tests__missing_zero_and_narrow_charts_keep_the_selection_visible.snap

@@ -0,0 +1,105 @@
+---
+source: tui/src/analytics/plot_tests.rs
+expression: "snapshots.join(\"\\n\\n\")"
+---
+width=36, cursor=0
+                              5
+ 6                         ▄▄▄▄▄▄▄
+                           ███████
+        —          0       ███████
+ 0 ─────────────────────────────────
+        ▲
+     Jan 13     Jan 14     Jan 15
+
+Palette:
+0: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+1: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+2: Style::new().fg(Color::Rgb(165, 165, 165)).bg(Color::Reset).underline_color(Color::Reset)
+3: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+4: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+5: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+6: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold().underlined()
+Rows (column:palette):
+0: 0:0 30:1 31:0
+1: 0:0 1:2 2:0 27:3 34:0
+2: 0:0 27:3 34:0
+3: 0:0 8:4 9:0 19:1 20:0 27:3 34:0
+4: 0:0 1:2 2:0 3:1
+5: 0:0 8:5 9:0
+6: 0:0 5:6 11:0 16:2 22:0 27:2 33:0
+
+width=36, cursor=1
+                              5
+ 6                         ▄▄▄▄▄▄▄
+                           ███████
+        —          0       ███████
+ 0 ─────────────────────────────────
+                   ▲
+     Jan 13     Jan 14     Jan 15
+
+Palette:
+0: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+1: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+2: Style::new().fg(Color::Rgb(165, 165, 165)).bg(Color::Reset).underline_color(Color::Reset)
+3: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+4: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+5: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+6: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold().underlined()
+Rows (column:palette):
+0: 0:0 30:1 31:0
+1: 0:0 1:2 2:0 27:3 34:0
+2: 0:0 27:3 34:0
+3: 0:0 8:1 9:0 19:4 20:0 27:3 34:0
+4: 0:0 1:2 2:0 3:1
+5: 0:0 19:5 20:0
+6: 0:0 5:2 11:0 16:6 22:0 27:2 33:0
+
+width=8, cursor=2
+      5
+     ▄▄
+     ██
+—  0 ██
+────────
+      ▲
+13   15
+
+Palette:
+0: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+1: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+2: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+3: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+4: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+5: Style::new().fg(Color::Rgb(165, 165, 165)).bg(Color::Reset).underline_color(Color::Reset)
+6: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold().underlined()
+Rows (column:palette):
+0: 0:0 6:1 7:0
+1: 0:0 5:2 7:0
+2: 0:0 5:2 7:0
+3: 0:3 1:0 3:3 4:0 5:2 7:0
+4: 0:3
+5: 0:0 6:4 7:0
+6: 0:5 2:0 5:6 7:0
+
+width=1, cursor=2
+5
+▄
+█
+█
+─
+▲
+
+
+Palette:
+0: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+1: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+2: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+3: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+4: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+Rows (column:palette):
+0: 0:0
+1: 0:1
+2: 0:1
+3: 0:1
+4: 0:2
+5: 0:3
+6: 0:4

codex-rs/tui/src/analytics/snapshots/codex_tui__analytics__plot__tests__narrow_equal_height_totals_remain_separate_numbers.snap

@@ -0,0 +1,30 @@
+---
+source: tui/src/analytics/plot_tests.rs
+expression: "screens.join(\"\\n\\n\")"
+---
+   111      111   111
+111 ┊    111 ┊ 111 ┊
+▇▇ ▇▇ ▇▇ ▇▇ ▇▇ ▇▇ ▇▇
+██ ██ ██ ██ ██ ██ ██
+██ ██ ██ ██ ██ ██ ██
+─────────────────────
+          ▲
+ 1  2  3  4  5  6  7
+
+
+111 111 111 111 111 111 111
+ ▇▇  ▇▇  ▇▇  ▇▇  ▇▇  ▇▇  ▇▇
+ ██  ██  ██  ██  ██  ██  ██
+ ██  ██  ██  ██  ██  ██  ██
+────────────────────────────
+             ▲
+ 1   2   3   4   5   6   7
+
+
+ 150 111 111 111  111 111 111  111
+      ▇▇  ▇▇  ▇▇  ▇▇▇  ▇▇  ▇▇  ▇▇▇
+  75  ██  ██  ██  ███  ██  ██  ███
+      ██  ██  ██  ███  ██  ██  ███
+   0 ──────────────────────────────
+                   ▲
+      1   2   3    4   5   6    7

codex-rs/tui/src/analytics/snapshots/codex_tui__analytics__plot__tests__narrow_long_range_charts_never_truncate_dates.snap

@@ -0,0 +1,102 @@
+---
+source: tui/src/analytics/plot_tests.rs
+expression: "snapshots.join(\"\\n\\n\")"
+---
+width=1
+
+1
+▄
+█
+─
+▲
+
+
+Palette:
+0: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+1: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+2: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+3: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+4: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+Rows (column:palette):
+0: 0:0
+1: 0:1
+2: 0:2
+3: 0:2
+4: 0:3
+5: 0:4
+6: 0:0
+
+width=2
+
+ 1
+▄▄
+██
+──
+ ▲
+15
+
+Palette:
+0: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+1: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+2: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+3: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+4: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+5: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold().underlined()
+Rows (column:palette):
+0: 0:0
+1: 0:0 1:1
+2: 0:2
+3: 0:2
+4: 0:3
+5: 0:0 1:4
+6: 0:5
+
+width=5
+
+    1
+▄▄▄▄▄
+█████
+─────
+    ▲
+   15
+
+Palette:
+0: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+1: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+2: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+3: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+4: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+5: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold().underlined()
+Rows (column:palette):
+0: 0:0
+1: 0:0 4:1
+2: 0:2
+3: 0:2
+4: 0:3
+5: 0:0 4:4
+6: 0:0 3:5
+
+width=6
+
+     1
+▄▄▄▄▄▄
+██████
+──────
+     ▲
+Jan 15
+
+Palette:
+0: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+1: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+2: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+3: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+4: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+5: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold().underlined()
+Rows (column:palette):
+0: 0:0
+1: 0:0 5:1
+2: 0:2
+3: 0:2
+4: 0:3
+5: 0:0 5:4
+6: 0:5

codex-rs/tui/src/analytics/snapshots/codex_tui__analytics__plot__tests__oversized_axes_are_hidden_instead_of_truncated.snap

@@ -0,0 +1,138 @@
+---
+source: tui/src/analytics/plot_tests.rs
+expression: "snapshots.join(\"\\n\\n\")"
+---
+width=8
+ 100M
+ █████
+ █████
+ █████
+ █████
+────────
+   ▲
+Jan 15
+
+Palette:
+0: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+1: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+2: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+3: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+4: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+5: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold().underlined()
+Rows (column:palette):
+0: 0:0 1:1 5:0
+1: 0:0 1:2 6:0
+2: 0:0 1:2 6:0
+3: 0:0 1:2 6:0
+4: 0:0 1:2 6:0
+5: 0:3
+6: 0:0 3:4 4:0
+7: 0:5 6:0
+
+width=30
+               100M
+ 100M       ████████████
+            ████████████
+  50M       ████████████
+            ████████████
+    0 ────────────────────────
+                 ▲
+              Jan 15
+
+Palette:
+0: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+1: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+2: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+3: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+4: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+5: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold().underlined()
+Rows (column:palette):
+0: 0:0 15:1 19:0
+1: 0:0 1:2 5:0 12:3 24:0
+2: 0:0 12:3 24:0
+3: 0:0 2:2 5:0 12:3 24:0
+4: 0:0 12:3 24:0
+5: 0:0 4:2 5:0 6:2
+6: 0:0 17:4 18:0
+7: 0:0 14:5 20:0
+
+width=35
+                  100M
+ 100M         ████████████
+              ████████████
+  50M         ████████████
+              ████████████
+    0 ─────────────────────────────
+                    ▲
+                 Jan 15
+
+Palette:
+0: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+1: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+2: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+3: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+4: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+5: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold().underlined()
+Rows (column:palette):
+0: 0:0 18:1 22:0
+1: 0:0 1:2 5:0 14:3 26:0
+2: 0:0 14:3 26:0
+3: 0:0 2:2 5:0 14:3 26:0
+4: 0:0 14:3 26:0
+5: 0:0 4:2 5:0 6:2
+6: 0:0 20:4 21:0
+7: 0:0 17:5 23:0
+
+width=44
+                      100M
+ 100M              ████████████
+                   ████████████
+  50M              ████████████
+                   ████████████
+    0 ──────────────────────────────────────
+                        ▲
+                     Jan 15
+
+Palette:
+0: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+1: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+2: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+3: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+4: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+5: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold().underlined()
+Rows (column:palette):
+0: 0:0 22:1 26:0
+1: 0:0 1:2 5:0 19:3 31:0
+2: 0:0 19:3 31:0
+3: 0:0 2:2 5:0 19:3 31:0
+4: 0:0 19:3 31:0
+5: 0:0 4:2 5:0 6:2
+6: 0:0 24:4 25:0
+7: 0:0 21:5 27:0
+
+width=30
+
+    1000000000000000000T
+         ▅▅▅▅▅▅▅▅▅▅▅▅
+         ████████████
+         ████████████
+──────────────────────────────
+              ▲
+           Jan 15
+
+Palette:
+0: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset)
+1: Style::new().white().bg(Color::Reset).underline_color(Color::Reset).bold()
+2: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset)
+3: Style::new().fg(Color::Reset).bg(Color::Reset).underline_color(Color::Reset).dim()
+4: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold()
+5: Style::new().cyan().bg(Color::Reset).underline_color(Color::Reset).bold().underlined()
+Rows (column:palette):
+0: 0:0
+1: 0:0 4:1 24:0
+2: 0:0 9:2 21:0
+3: 0:0 9:2 21:0
+4: 0:0 9:2 21:0
+5: 0:3
+6: 0:0 14:4 15:0
+7: 0:0 11:5 17:0