//! Provider usage limits as the provider itself shows them, read ONLY from PTY screens: the
//! node's limit heartbeat ([`crate::limit_heartbeat`]: one light service PTY per signed-in
//! provider account) and any node PTY session that happens to show the screen.
//!
//! - claude: `/usage` (and `/status`) — "Current session" = 5h window, "Current week" = 7d
//! window, the plan from "Claude Max/Pro/Team/Enterprise".
//! - codex: `/status` — its "5h limit" and "Weekly limit" lines.
//! - grok: `/usage` — the "Usage limit" panel: "Weekly limit (<plan>)", the spent share, the reset.
//! - kimi: `/usage` — its "5h limit" and "Weekly limit" lines (`% left`).
//!
//! Nothing is estimated, and no other source is read: no session logs or rollouts, no
//! provider error text (that only notifies the operator), never tokens, OAuth or `auth.json`.
//! Every entry keeps its `source` and `observed_at_ms`.
use serde::Serialize;
use std::collections::BTreeMap;
use std::sync::{Mutex, OnceLock};
#[derive(Clone, Debug, Serialize, PartialEq)]
pub struct Window {
/// `5h`, `7d`, or `<N>m` for any other length.
pub window: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub used_percent: Option<f64>,
/// `100 - used`, derived here from the raw reading.
#[serde(skip_serializing_if = "Option::is_none")]
pub remaining_percent: Option<f64>,
/// What the provider showed: the line, the number and what it meant (used / left).
#[serde(skip_serializing_if = "Option::is_none")]
pub raw: Option<RawReading>,
/// Reset as the provider said it: epoch ms when known, else its own text.
#[serde(skip_serializing_if = "Option::is_none")]
pub resets_at_ms: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub resets_text: Option<String>,
}
/// A provider's own limit line, kept as it was shown (providers say `% used` or `% left`).
#[derive(Clone, Debug, Serialize, PartialEq)]
pub struct RawReading {
/// The line, trimmed and cut to 160 characters.
pub text: String,
pub value: Option<f64>,
/// `used` | `left` | `unknown`
pub meaning: &'static str,
}
/// The percent on `line` and what it means. `left` also covers `remaining`.
pub fn reading(line: &str) -> Option<RawReading> {
let value = pct(line)?;
let low = line.to_lowercase();
let after = &low[low.find('%').unwrap_or(0)..];
let meaning = if after.contains("left") || after.contains("remaining") {
"left"
} else if after.contains("used") {
"used"
} else {
"unknown"
};
let text: String = line.trim().trim_matches(|c: char| c == '│' || c == '|').trim().chars().filter(|c| !c.is_control()).take(160).collect();
Some(RawReading { text, value: Some(value), meaning })
}
/// A window from a raw reading: used and remaining both derived from it; `unknown` keeps
/// both unset (routing never guesses which way a bare percent goes).
pub fn window_from(name: &str, raw: RawReading, resets_at_ms: Option<u64>, resets_text: Option<String>) -> Window {
let used = match (raw.meaning, raw.value) {
("used", Some(v)) => Some(v),
("left", Some(v)) => Some(100.0 - v),
_ => None,
};
Window { window: name.into(), used_percent: used, remaining_percent: used.map(|u| 100.0 - u), raw: Some(raw), resets_at_ms, resets_text }
}
#[derive(Clone, Debug, Serialize, PartialEq)]
pub struct ProviderLimits {
pub provider: String,
/// `screen`: a session PTY that showed it; `heartbeat`: the node's limit heartbeat.
pub source: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub tier: Option<String>,
pub windows: Vec<Window>,
pub observed_at_ms: u64,
}
fn pct(line: &str) -> Option<f64> {
let i = line.find('%')?;
let head = &line[..i];
let start = head.rfind(|c: char| !(c.is_ascii_digit() || c == '.')).map_or(0, |p| p + 1);
head[start..].parse().ok().filter(|v: &f64| (0.0..=100.0).contains(v))
}
/// Parse a claude `/usage` (or `/status`) screen. `None` when it shows neither.
pub fn parse_claude_screen(screen: &str, now_ms: u64) -> Option<ProviderLimits> {
let lines: Vec<&str> = screen.lines().map(str::trim).collect();
let mut windows = Vec::new();
let mut tier = None;
for (i, l) in lines.iter().enumerate() {
let low = l.to_lowercase();
for t in ["max", "pro", "team", "enterprise"] {
if tier.is_none() && (low.contains(&format!("claude {t}")) || low.contains(&format!("{t} plan"))) {
tier = Some(t.to_owned());
}
}
let name = if low.starts_with("current session") {
"5h"
} else if low.starts_with("current week") && (low.contains("all models") || !low.contains('(')) {
"7d"
} else {
continue;
};
if windows.iter().any(|w: &Window| w.window == name) {
continue;
}
let (mut raw, mut resets_text) = (None, None);
for next in lines.iter().skip(i + 1).take(3) {
let nl = next.to_lowercase();
if nl.starts_with("current ") {
break;
}
if raw.is_none() && (nl.contains("used") || nl.contains("left") || nl.contains("remaining")) {
raw = reading(next);
}
if let Some(p) = nl.find("resets") {
resets_text = Some(next[p..].chars().take(80).collect());
}
}
if let Some(raw) = raw {
windows.push(window_from(name, raw, None, resets_text));
}
}
(!windows.is_empty() || tier.is_some()).then(|| ProviderLimits { provider: "claude".into(), source: "screen".into(), tier, windows, observed_at_ms: now_ms })
}
/// Latest limits the node saw on screens, per (provider, source).
static OBSERVED: OnceLock<Mutex<BTreeMap<(String, String), ProviderLimits>>> = OnceLock::new();
/// Woken on every new observation, so the reporter sends it without waiting for its tick.
static CHANGED: OnceLock<tokio::sync::Notify> = OnceLock::new();
pub fn changed() -> &'static tokio::sync::Notify {
CHANGED.get_or_init(tokio::sync::Notify::new)
}
/// Merge `new` into the observed entry of its (provider, source): its windows replace the same
/// windows, the rest stay.
fn remember(new: ProviderLimits) {
let key = (new.provider.clone(), new.source.clone());
let mut map = OBSERVED.get_or_init(Default::default).lock().unwrap_or_else(|p| p.into_inner());
let before = map.remove(&key);
let merged = match before.clone() {
Some(mut old) => {
if new.tier.is_some() {
old.tier = new.tier.clone();
}
for w in new.windows {
old.windows.retain(|o| o.window != w.window);
old.windows.push(w);
}
old.observed_at_ms = new.observed_at_ms;
old
}
None => new,
};
// A repeat of the same reading (only its time moved) wakes nobody.
let fresh = before.as_ref().is_none_or(|b| b.windows != merged.windows || b.tier != merged.tier);
map.insert(key, merged);
drop(map);
if fresh {
changed().notify_one();
}
}
/// The 5h window usage of `provider` if a reading at most `max_age_ms` old is known (any source).
pub fn fresh_5h_used(provider: &str, max_age_ms: u64) -> Option<f64> {
let map = OBSERVED.get()?.lock().unwrap_or_else(|p| p.into_inner());
let now = now_ms();
map.iter()
.filter(|((p, _), l)| p == provider && now.saturating_sub(l.observed_at_ms) <= max_age_ms)
.max_by_key(|(_, l)| l.observed_at_ms)
.and_then(|(_, l)| l.windows.iter().find(|w| w.window == "5h").and_then(|w| w.used_percent))
}
pub fn now_ms() -> u64 {
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_or(0, |d| d.as_millis() as u64)
}
/// Parse a codex `/status` screen: the `5h limit` / `Weekly limit` lines (`N% used`, or
/// `N% left`), and the reset in parentheses. Nothing else on the screen is kept (it also shows
/// the account's email). `None` when it shows no limit line.
pub fn parse_codex_status(screen: &str, now_ms: u64) -> Option<ProviderLimits> {
let mut windows: Vec<Window> = Vec::new();
for l in screen.lines() {
let l = l.trim().trim_matches(|c: char| c == '│' || c == '|').trim();
let low = l.to_lowercase();
let Some(colon) = low.find("limit:") else { continue };
let label = &low[..colon];
let name = if label.contains("5h") || label.contains("5-hour") || label.contains("session") {
"5h"
} else if label.contains("week") {
"7d"
} else {
continue;
};
let Some(raw) = reading(l) else { continue };
let resets_text = low.find("resets").filter(|_| low.len() == l.len()).map(|i| l[i..].trim_end_matches(|c: char| c == ')' || c.is_whitespace()).chars().take(80).collect::<String>());
if windows.iter().all(|w| w.window != name) {
let resets_at_ms = resets_text.as_deref().and_then(|t| codex_reset_ms(t, chrono::Local::now().fixed_offset()));
windows.push(window_from(name, raw, resets_at_ms, resets_text));
}
}
(!windows.is_empty()).then(|| ProviderLimits { provider: "codex".into(), source: "screen".into(), tier: None, windows, observed_at_ms: now_ms })
}
/// A codex reset as shown on its screen: `resets HH:MM` (the next such time) or
/// `resets HH:MM on D Mon` (that day; next year when already past). The screen gives no zone,
/// so it is the node's local time (`now`'s offset).
pub fn codex_reset_ms(text: &str, now: chrono::DateTime<chrono::FixedOffset>) -> Option<u64> {
use chrono::{Datelike, NaiveDate, NaiveTime, TimeZone};
let rest = text.trim().strip_prefix("resets")?.trim();
let (hm, day) = match rest.split_once(" on ") {
Some((hm, day)) => (hm.trim(), Some(day.trim())),
None => (rest, None),
};
let time = NaiveTime::parse_from_str(hm, "%H:%M").ok()?;
let tz = *now.offset();
let at = match day {
None => {
let today = tz.from_local_datetime(&now.date_naive().and_time(time)).single()?;
if today > now { today } else { today + chrono::Duration::days(1) }
}
Some(day) => {
let mut it = day.split_whitespace();
let d: u32 = it.next()?.parse().ok()?;
let m = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"]
.iter()
.position(|x| it.clone().next().is_some_and(|w| w.to_lowercase().starts_with(x)))? as u32
+ 1;
let mut at = tz.from_local_datetime(&NaiveDate::from_ymd_opt(now.year(), m, d)?.and_time(time)).single()?;
if at < now - chrono::Duration::days(1) {
at = tz.from_local_datetime(&NaiveDate::from_ymd_opt(now.year() + 1, m, d)?.and_time(time)).single()?;
}
at
}
};
u64::try_from(at.timestamp_millis()).ok()
}
/// Parse a grok `/usage` panel ("Usage limit" tab): `Weekly limit (<plan>)`, a bar line with
/// the share of the window spent (`74%`; grok shows usage, so a bare percent there is used),
/// and `Resets: <date>`. The plan in parentheses is the tier. `None` without a limit line.
pub fn parse_grok_usage(screen: &str, now_ms: u64) -> Option<ProviderLimits> {
let clean = |l: &str| l.trim().trim_matches(|c: char| c == '│' || c == '|').trim().to_owned();
let lines: Vec<String> = screen.lines().map(clean).collect();
let (mut windows, mut tier) = (Vec::<Window>::new(), None);
for (i, l) in lines.iter().enumerate() {
let low = l.to_lowercase();
let name = if low.starts_with("weekly limit") {
"7d"
} else if low.starts_with("5h limit") || low.starts_with("5-hour limit") || low.starts_with("session limit") {
"5h"
} else {
continue;
};
if windows.iter().any(|w| w.window == name) {
continue;
}
if tier.is_none() {
if let (Some(a), Some(b)) = (l.find('('), l.rfind(')')) {
// As a plain id: `SuperGrok Heavy` -> `supergrok-heavy`.
let t: String = l[a + 1..b].trim().to_lowercase().split_whitespace().collect::<Vec<_>>().join("-").chars().take(32).collect();
tier = (!t.is_empty()).then_some(t);
}
}
let (mut raw, mut resets_text) = (None, None);
for next in lines.iter().skip(i).take(5) {
let nl = next.to_lowercase();
if raw.is_none() && nl.contains('%') {
raw = reading(next).map(|mut r| {
if r.meaning == "unknown" {
r.meaning = "used";
}
r
});
}
if resets_text.is_none() {
if let Some(p) = nl.find("resets") {
resets_text = Some(next[p..].chars().take(80).collect());
}
}
}
if let Some(raw) = raw {
windows.push(window_from(name, raw, None, resets_text));
}
}
(!windows.is_empty()).then(|| ProviderLimits { provider: "grok".into(), source: "screen".into(), tier, windows, observed_at_ms: now_ms })
}
/// Parse a kimi `/usage` (alias `/status`) screen: `5h limit` / `Weekly limit` lines with
/// `N% left` (kimi shows what is left), with or without a colon, the reset on the same or the
/// next line. `None` without a limit line.
pub fn parse_kimi_usage(screen: &str, now_ms: u64) -> Option<ProviderLimits> {
let clean = |l: &str| l.trim().trim_matches(|c: char| c == '│' || c == '|').trim().to_owned();
let lines: Vec<String> = screen.lines().map(clean).collect();
let mut windows = Vec::<Window>::new();
for (i, l) in lines.iter().enumerate() {
let low = l.to_lowercase();
let Some(at) = low.find("limit") else { continue };
let label = &low[..at];
let name = if label.contains("5h") || label.contains("5-hour") || label.contains("5 hour") {
"5h"
} else if label.contains("week") || label.contains("7d") {
"7d"
} else {
continue;
};
if windows.iter().any(|w| w.window == name) {
continue;
}
let near: Vec<&String> = lines.iter().skip(i).take(3).collect();
let Some(raw) = near.iter().find(|x| x.contains('%')).and_then(|x| reading(x)) else { continue };
let resets_text = near.iter().find_map(|x| x.to_lowercase().find("reset").map(|p| x[p..].trim_end_matches(|c: char| c == ')' || c.is_whitespace()).chars().take(80).collect::<String>()));
windows.push(window_from(name, raw, None, resets_text));
}
(!windows.is_empty()).then(|| ProviderLimits { provider: "kimi".into(), source: "screen".into(), tier: None, windows, observed_at_ms: now_ms })
}
/// A CLI screen that says the CLI is not signed in (no limit screen will ever come).
pub fn says_not_signed_in(provider: &str, screen: &str) -> bool {
let low = screen.to_lowercase();
match provider {
"kimi" => low.contains("run /login or /provider") || low.contains("model: not set"),
// grok starts a browser device sign-in on its own when it has no account.
"grok" => low.contains("approve in your browser to finish signing in") || low.contains("waiting for approval") || low.contains("sign in to grok"),
_ => false,
}
}
/// Parse `screen` as `provider`'s limit screen.
pub fn parse_screen(provider: &str, screen: &str, now_ms: u64) -> Option<ProviderLimits> {
match provider {
"claude" if screen.contains("Current session") || screen.contains("Current week") || screen.contains("Claude ") => parse_claude_screen(screen, now_ms),
"codex" if screen.contains("limit:") => parse_codex_status(screen, now_ms),
"grok" if screen.contains("Weekly limit") || screen.contains("Usage limit") => parse_grok_usage(screen, now_ms),
"kimi" if screen.to_lowercase().contains("limit") && screen.contains('%') => parse_kimi_usage(screen, now_ms),
_ => None,
}
}
/// Called from the frame publisher with every scanned session screen.
pub fn observe_screen(provider: &str, screen: &str) {
observe_screen_as(provider, screen, "screen");
}
/// Remember a limit screen under `source` (`screen` or `heartbeat`). True when it was one.
pub fn observe_screen_as(provider: &str, screen: &str, source: &str) -> bool {
match parse_screen(provider, screen, now_ms()) {
Some(mut new) => {
new.source = source.to_owned();
remember(new);
true
}
None => false,
}
}
/// Everything seen on screens now.
pub fn collect() -> Vec<ProviderLimits> {
OBSERVED.get().map(|m| m.lock().unwrap_or_else(|p| p.into_inner()).values().cloned().collect()).unwrap_or_default()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn raw_reading_keeps_meaning_and_normalizes_both_ways() {
let codex = "│ 5h limit: [██████░░] 30% used (resets 14:05) │\n│ Weekly limit: [█░░░░░░░] 95% left (resets 09:00 on 23 Oct) │";
let l = super::parse_codex_status(codex, 0).unwrap();
let w: Vec<_> = l.windows.iter().map(|w| (w.window.as_str(), w.used_percent, w.remaining_percent, w.raw.as_ref().map(|r| (r.value, r.meaning)))).collect();
assert_eq!(w, vec![("5h", Some(30.0), Some(70.0), Some((Some(30.0), "used"))), ("7d", Some(5.0), Some(95.0), Some((Some(95.0), "left")))]);
assert!(l.windows[1].raw.as_ref().unwrap().text.starts_with("Weekly limit:"));
let sample = include_str!("../tests/fixtures/codex-status-v0.163.0.txt");
let l = super::parse_codex_status(sample, 0).unwrap();
assert_eq!((l.windows[0].used_percent, l.windows[0].remaining_percent, l.windows[0].raw.as_ref().unwrap().meaning), (Some(100.0), Some(0.0), "left"));
let claude = "Current session\n███▌ 82% used\nResets 3:40pm (Asia/Yekaterinburg)\nCurrent week (all models)\n 84% left\n";
let l = super::parse_claude_screen(claude, 0).unwrap();
let w: Vec<_> = l.windows.iter().map(|w| (w.window.as_str(), w.used_percent, w.remaining_percent, w.raw.as_ref().unwrap().meaning)).collect();
assert_eq!(w, vec![("5h", Some(82.0), Some(18.0), "used"), ("7d", Some(16.0), Some(84.0), "left")]);
let bare = super::window_from("5h", super::reading("5h: 40%").unwrap(), None, None);
assert_eq!((bare.used_percent, bare.remaining_percent, bare.raw.unwrap().meaning), (None, None, "unknown"));
}
const USAGE: &str = " Settings: Status Config Usage\n\n Current session\n █████▌ 11% used\n Resets 3pm (Asia/Yekaterinburg)\n\n Current week (all models)\n ███████████ 22% used\n Resets Oct 23, 9am (Asia/Yekaterinburg)\n\n Current week (Opus)\n █ 2% used\n";
#[test]
fn claude_usage_screen() {
let l = parse_claude_screen(USAGE, 7).unwrap();
assert_eq!(l.windows.len(), 2);
assert_eq!(l.windows[0].window, "5h");
assert_eq!(l.windows[0].used_percent, Some(11.0));
assert_eq!(l.windows[0].resets_text.as_deref(), Some("Resets 3pm (Asia/Yekaterinburg)"));
assert_eq!(l.windows[1].window, "7d");
assert_eq!(l.windows[1].used_percent, Some(22.0));
}
/// Real claude /usage screen captured on hatchery-box (2026-10-19).
#[test]
fn claude_usage_screen_live_capture() {
let screen = " Settings Status Config Usage Stats\n\n Session\n\n Total cost: $0.0000\n Usage: 0 input, 0 output, 0 cache read, 0 cache write\n\n Current session\n ▌ 1% used\n Resets 10:39am (Asia/Yekaterinburg)\n\n Current week (all models)\n ▌ 1% used\n Resets Oct 21, 11:59pm (Asia/Yekaterinburg)\n\n What's contributing to your limits usage?\n 31% of your usage came from the MCP server \"m4a\"\n";
let l = parse_claude_screen(screen, 0).unwrap();
assert_eq!(l.windows.iter().map(|w| (w.window.as_str(), w.used_percent)).collect::<Vec<_>>(), vec![("5h", Some(1.0)), ("7d", Some(1.0))]);
assert_eq!(l.windows[1].resets_text.as_deref(), Some("Resets Oct 21, 11:59pm (Asia/Yekaterinburg)"));
}
#[test]
fn claude_status_tier_and_noise() {
assert_eq!(parse_claude_screen("Login method: Claude Max Account", 1).unwrap().tier.as_deref(), Some("max"));
assert!(parse_claude_screen("> fix the tests\n● done", 1).is_none());
}
#[test]
fn codex_status_screen() {
let screen = "╭──────────────────────────────────────────────╮\n│ >_ OpenAI Codex (v0.160.0) │\n│ Account: someone@example.com (Plus) │\n│ 5h limit: [██████░░░░░░░░░░░░░░] 30% used (resets 14:05) │\n│ Weekly limit: [█░░░░░░░░░░░░░░░░░░░] 95% left (resets 09:00 on 23 Oct) │\n╰──────────────────────────────────────────────╯";
let l = parse_codex_status(screen, 5).unwrap();
assert_eq!(l.windows.iter().map(|w| (w.window.as_str(), w.used_percent)).collect::<Vec<_>>(), vec![("5h", Some(30.0)), ("7d", Some(5.0))]);
assert_eq!(l.windows[0].resets_text.as_deref(), Some("resets 14:05"));
assert_eq!(l.windows[1].resets_text.as_deref(), Some("resets 09:00 on 23 Oct"));
// The account line is never kept.
assert!(!format!("{l:?}").contains('@'));
assert!(parse_codex_status("› explain the rate limit: code in src/x.rs", 5).is_none());
}
/// Real codex v0.163.0 `/status` (op-box, 2026-10-19; account and session redacted).
#[test]
fn codex_status_fixture_v0_163() {
let screen = include_str!("../tests/fixtures/codex-status-v0.163.0.txt");
let l = parse_codex_status(screen, 5).unwrap();
assert_eq!(l.windows.iter().map(|w| (w.window.as_str(), w.used_percent)).collect::<Vec<_>>(), vec![("5h", Some(100.0)), ("7d", Some(16.0))]);
assert_eq!(l.windows[0].resets_text.as_deref(), Some("resets 12:11"));
assert_eq!(l.windows[1].resets_text.as_deref(), Some("resets 06:27 on 25 Oct"));
assert!(l.windows.iter().all(|w| w.resets_at_ms.is_some()));
let dbg = format!("{l:?}");
assert!(!dbg.contains('@') && !dbg.contains("00000000-"), "no account or session id kept");
}
/// Real grok 1.0.62 `/usage` panel (op-box, 2026-10-20).
const GROK_USAGE: &str = " E:\\D\\h\\w\\.hatchery-sessions\\grok-29 1.8K / 256K │ [Dashboard]\n ┌──────────────── [x] ─┐\n │ Context usage Usage limit Session info │\n │─────────────────────────│\n │ Weekly limit (SuperGrok Heavy) │\n │ │\n │ ██████████████████████░░░░░░░░ 74% │\n │ Resets: October 23, 18:49 │\n │ │\n │ Session usage: no model calls yet in this session. │\n";
#[test]
fn grok_usage_panel() {
let l = parse_screen("grok", GROK_USAGE, 3).unwrap();
assert_eq!(l.tier.as_deref(), Some("supergrok-heavy"));
let w = &l.windows[0];
assert_eq!((w.window.as_str(), w.used_percent, w.remaining_percent, w.raw.as_ref().unwrap().meaning), ("7d", Some(74.0), Some(26.0), "used"));
assert_eq!(w.resets_text.as_deref(), Some("Resets: October 23, 18:49"));
assert!(parse_screen("grok", "> what is my weekly limit?", 3).is_none());
}
#[test]
fn kimi_usage_screen() {
let screen = "│ Weekly limit ████████░░░░░░░░ 50% left (resets in 3d 4h) │\n│ 5h limit ████████████░░░░ 88% left │\n│ resets in 2h 10m │";
let l = parse_screen("kimi", screen, 3).unwrap();
let w: Vec<_> = l.windows.iter().map(|w| (w.window.as_str(), w.used_percent, w.raw.as_ref().unwrap().meaning)).collect();
assert_eq!(w, vec![("7d", Some(50.0), "left"), ("5h", Some(12.0), "left")]);
assert_eq!(l.windows[0].resets_text.as_deref(), Some("resets in 3d 4h"));
assert_eq!(l.windows[1].resets_text.as_deref(), Some("resets in 2h 10m"));
let welcome = "Welcome to Kimi Code!\nRun /login or /provider to get started.\nModel: not set, run /login or /provider\ncontext: 0%";
assert!(parse_screen("kimi", welcome, 3).is_none());
assert!(says_not_signed_in("kimi", welcome));
assert!(!says_not_signed_in("kimi", screen));
// Real grok 1.0.46 start without an account (hatchery-box, 2026-10-20; code removed).
let grok_login = " ~/w/.hatchery-sessions/grok-1\n Approve in your browser to finish signing in.\n XXXX-XXXX\n Make sure your browser shows this code.\n Waiting for approval...\n ctrl+q quit";
assert!(says_not_signed_in("grok", grok_login) && !says_not_signed_in("grok", GROK_USAGE));
}
#[test]
fn codex_reset_is_node_local_time() {
use chrono::TimeZone;
let tz = chrono::FixedOffset::east_opt(5 * 3600).unwrap();
let now = tz.with_ymd_and_hms(2026, 10, 19, 11, 41, 0).unwrap();
let at = |y, mo, d, h, mi| u64::try_from(tz.with_ymd_and_hms(y, mo, d, h, mi, 0).unwrap().timestamp_millis()).unwrap();
assert_eq!(codex_reset_ms("resets 12:11", now), Some(at(2026, 10, 19, 12, 11)));
assert_eq!(codex_reset_ms("resets 09:00", now), Some(at(2026, 10, 20, 9, 0)), "already past today: tomorrow");
assert_eq!(codex_reset_ms("resets 06:27 on 25 Oct", now), Some(at(2026, 10, 25, 6, 27)));
assert_eq!(codex_reset_ms("resets 06:27 on 2 Jan", now), Some(at(2027, 1, 2, 6, 27)));
assert_eq!(codex_reset_ms("resets soon", now), None);
}
#[test]
fn screens_are_remembered_with_their_source() {
assert!(observe_screen_as("codex", " 5h limit: [█] 88% used (resets 10:00)", "heartbeat"));
assert!(!observe_screen_as("codex", "> hello", "heartbeat"));
assert!(!observe_screen_as("gemini", "5h limit: 10% used", "heartbeat"));
let got = collect().into_iter().find(|l| l.provider == "codex" && l.source == "heartbeat").unwrap();
assert_eq!(got.windows[0].used_percent, Some(88.0));
}
}