@@ -50,7 +50,7 @@ These views support `--json`, `--compact`, `--offline`, and `--speed auto|standa
 - **Per-model grouping** – The active `turn_context` specifies the model for newly counted usage. Replayed parent contexts in current MultiAgent V2 subagent prefixes remain inherited history and do not add model usage to the child. We aggregate tokens per day/month and per model. Sessions lacking model metadata (seen in early September 2025 builds) are skipped.
 - **Pricing** – Rates come from LiteLLM's pricing dataset via the shared `LiteLLMPricingFetcher`. Codex's internal review label uses the manually curated, date-based fallback timeline below and remains marked as approximate.
 - **Scheduled pricing** – DeepSeek V4 Flash and Pro use each event's timestamp: legacy rates apply before `2026-08-16T16:00:00Z`, and the later rates use UTC weekday peak windows of `01:00–04:00` and `06:00–10:00` (endpoints excluded). Cache creation follows the scheduled input rate.
-- **Speed pricing** uses `--speed auto` by default. For rollouts written by Codex CLI 0.144.0 and later, ccusage applies recorded `thread_settings_applied` tier changes chronologically. `priority` and legacy `fast` use Fast pricing, `flex` uses Flex pricing, and `default` or `standard` uses Standard pricing. Unmarked usage falls back to `config.toml` detection. Pass `--speed standard`, `--speed flex`, or `--speed fast` to override every recorded tier. Fast and Flex pricing use model-specific multipliers only when one is available; otherwise, ccusage keeps standard pricing rather than inventing a rate.
+- **Speed pricing** uses `--speed auto` by default. For rollouts written by Codex CLI 0.144.0 and later, ccusage applies recorded `thread_settings_applied` tier changes chronologically. `priority` and legacy `fast` use Fast pricing, `ultrafast` uses Ultrafast pricing, `flex` uses Flex pricing, and `default` or `standard` uses Standard pricing. Unmarked usage falls back to `config.toml` detection. Pass `--speed standard`, `--speed flex`, or `--speed fast` to override every recorded tier. Fast and Flex pricing use model-specific multipliers only when one is available; otherwise, ccusage keeps standard pricing rather than inventing a rate.
 - **Legacy fallback** – Early September 2025 logs that never recorded `turn_context` metadata are still included; the CLI assumes `gpt-5` for pricing so you can review the tokens even though the model tag is missing (the JSON output also marks these rows with `"isFallback": true`).
 - **Cost formula** – Non-cached input uses the standard input price; cached input uses the cache-read price (falling back to the input price when missing); and output tokens are billed at the output price. All prices are per million tokens. Reasoning tokens may be shown for reference, but they are part of the output charge and are not billed separately.
 - **Totals and reports** – Daily, monthly, and session views display per-model breakdowns, overall totals, and optional JSON for automation.
@@ -68,13 +68,13 @@ When Codex emits a model alias, the CLI automatically resolves it through the Li
 
 ## Speed Pricing
 
-By default, `ccusage codex` uses `--speed auto`. Codex CLI 0.144.0 and later can persist `thread_settings_applied` events in session rollouts. ccusage associates each token event with the most recent recognized setting. `service_tier = "priority"` or legacy `"fast"` is Fast, `"flex"` is Flex, and `"default"` or `"standard"` is Standard. This supports sessions that switch modes over time instead of applying one multiplier to the entire day or session.
+By default, `ccusage codex` uses `--speed auto`. Codex CLI 0.144.0 and later can persist `thread_settings_applied` events in session rollouts. ccusage associates each token event with the most recent recognized setting. `service_tier = "priority"` or legacy `"fast"` is Fast, `"ultrafast"` is Ultrafast, `"flex"` is Flex, and `"default"` or `"standard"` is Standard. This supports sessions that switch modes over time instead of applying one multiplier to the entire day or session.
 
 Some usage remains unclassified, including older rollouts, saved headless `codex exec --json` output, and startup usage before the first persisted settings event. For only that unclassified portion, auto mode reads `config.toml` from each `CODEX_HOME` root and uses Fast when any root has `service_tier = "priority"` or legacy `service_tier = "fast"`. If no root requests Fast and a root requests `service_tier = "flex"`, it uses Flex. Otherwise it uses Standard. An unsupported recorded tier is also left unclassified rather than inheriting a stale tier. Explicit `--speed standard`, `--speed flex`, and `--speed fast` override all recorded and fallback tiers.
 
 Fallback detection reads the top-level `service_tier` and lets a named profile override it only when `profile = "name"` selects that profile in `config.toml`. Inactive profiles are ignored, and a selected profile without its own tier inherits the top-level setting. If Codex selected a profile through `--profile` or another configuration file, use an explicit `--speed` for unclassified usage because ccusage cannot infer that selection from `config.toml`.
 
-Fast and Flex pricing use model-specific multipliers only when one is published. GPT-5.6 Sol, Terra, and Luna use the [documented 2× API Priority rate](https://learn.chatgpt.com/docs/agent-configuration/speed#fast-mode), and GPT-6 [Astra](https://developers.openai.com/api/docs/models/gpt-6-astra), [Sol](https://developers.openai.com/api/docs/models/gpt-6-sol), and [Luna](https://developers.openai.com/api/docs/models/gpt-6-luna) and GPT-6.1 [Sol](https://developers.openai.com/api/docs/models/gpt-6.1-sol) and [Terra](https://developers.openai.com/api/docs/models/gpt-6.1-terra) use their documented 2× Fast rates. Models listed in OpenAI's [Flex pricing table](https://developers.openai.com/api/docs/pricing) use 0.5× Standard pricing, including dated and provider-qualified names. These are distinct from ChatGPT credit-consumption rates. ccusage's `costUSD` is an API-equivalent estimate, not a ChatGPT credit balance. When a model's Fast or Flex rate is unknown, ccusage reports standard pricing rather than assuming a multiplier, which may underestimate Fast usage or overestimate Flex usage.
+Fast and Flex pricing use model-specific multipliers only when one is published. GPT-5.6 Sol, Terra, and Luna use the [documented 2× API Priority rate](https://learn.chatgpt.com/docs/agent-configuration/speed#fast-mode), and GPT-6 [Astra](https://developers.openai.com/api/docs/models/gpt-6-astra), [Sol](https://developers.openai.com/api/docs/models/gpt-6-sol), and [Luna](https://developers.openai.com/api/docs/models/gpt-6-luna) and GPT-6.1 [Sol](https://developers.openai.com/api/docs/models/gpt-6.1-sol) and [Terra](https://developers.openai.com/api/docs/models/gpt-6.1-terra) use their documented 2× Fast rates. Models listed in OpenAI's [Flex pricing table](https://developers.openai.com/api/docs/pricing) use 0.5× Standard pricing, including dated and provider-qualified names. Recorded Ultrafast usage uses the 6× Standard rates in the same table's Ultrafast section, which covers GPT-6.1 Sol and GPT-6 Astra; other models keep Standard pricing for Ultrafast requests. These are distinct from ChatGPT credit-consumption rates. ccusage's `costUSD` is an API-equivalent estimate, not a ChatGPT credit balance. When a model's Fast or Flex rate is unknown, ccusage reports standard pricing rather than assuming a multiplier, which may underestimate Fast usage or overestimate Flex usage.
 
 Use [`pricingOverrides`](/guide/config-files#pricing-overrides) to configure a model's `fastMultiplier` or `flexMultiplier`.
 
 
@@ -88,6 +88,7 @@ let
     lib.optionals (lib.elem "ccusage-core" names) [
       (rustRoot + /crates/ccusage-core/src/fast-multiplier-overrides.json)
       (rustRoot + /crates/ccusage-core/src/flex-multiplier-overrides.json)
+      (rustRoot + /crates/ccusage-core/src/ultrafast-multiplier-overrides.json)
     ]
     ++ lib.optionals (lib.elem "ccusage-adapter-codex" names) [
       (rustRoot + /adapters/codex/src/codex-auto-review-fallbacks.json)
 
@@ -27,6 +27,7 @@ let
       || lib.hasSuffix "/cli-commands.json" path
       || lib.hasSuffix "/fast-multiplier-overrides.json" path
       || lib.hasSuffix "/flex-multiplier-overrides.json" path
+      || lib.hasSuffix "/ultrafast-multiplier-overrides.json" path
       || lib.hasSuffix "/models-dev-pricing.json" path
       || lib.hasSuffix "/models-dev-catalog-rules.json" path
       || lib.hasSuffix "/codex-auto-review-fallbacks.json" path;
 
@@ -502,6 +502,9 @@ fn accumulate_codex_event_into_model_usage(
                 }
                 Some(CodexServiceTier::Fast) => Some(&mut timestamped_usage.recorded_fast_usage),
                 Some(CodexServiceTier::Flex) => Some(&mut timestamped_usage.recorded_flex_usage),
+                Some(CodexServiceTier::Ultrafast) => {
+                    Some(&mut timestamped_usage.recorded_ultrafast_usage)
+                }
                 None => None,
             };
             if let Some(recorded_usage) = recorded_usage {
@@ -514,6 +517,7 @@ fn accumulate_codex_event_into_model_usage(
             Some(CodexServiceTier::Standard) => Some(&mut model_usage.recorded_standard_usage),
             Some(CodexServiceTier::Fast) => Some(&mut model_usage.recorded_fast_usage),
             Some(CodexServiceTier::Flex) => Some(&mut model_usage.recorded_flex_usage),
+            Some(CodexServiceTier::Ultrafast) => Some(&mut model_usage.recorded_ultrafast_usage),
             None => None,
         };
         if let Some(recorded_usage) = recorded_usage {
@@ -562,6 +566,7 @@ fn merge_recorded_codex_usage(
         CodexServiceTier::Standard => &mut model_usage.recorded_standard_usage,
         CodexServiceTier::Fast => &mut model_usage.recorded_fast_usage,
         CodexServiceTier::Flex => &mut model_usage.recorded_flex_usage,
+        CodexServiceTier::Ultrafast => &mut model_usage.recorded_ultrafast_usage,
     };
     merge_codex_usage_bucket(recorded_usage, usage);
 
@@ -574,6 +579,7 @@ fn merge_recorded_codex_usage(
             CodexServiceTier::Standard => &mut timestamped_usage.recorded_standard_usage,
             CodexServiceTier::Fast => &mut timestamped_usage.recorded_fast_usage,
             CodexServiceTier::Flex => &mut timestamped_usage.recorded_flex_usage,
+            CodexServiceTier::Ultrafast => &mut timestamped_usage.recorded_ultrafast_usage,
         };
         merge_codex_usage_bucket(recorded_usage, usage);
     }
@@ -826,6 +832,10 @@ fn merge_codex_model_usage(target: &mut crate::CodexModelUsage, source: crate::C
     );
     merge_codex_usage_bucket(&mut target.recorded_fast_usage, source.recorded_fast_usage);
     merge_codex_usage_bucket(&mut target.recorded_flex_usage, source.recorded_flex_usage);
+    merge_codex_usage_bucket(
+        &mut target.recorded_ultrafast_usage,
+        source.recorded_ultrafast_usage,
+    );
     for (timestamp, usage) in source.timestamped_usage {
         let target_usage = target.timestamped_usage.entry(timestamp).or_default();
         merge_codex_usage_bucket(&mut target_usage.usage, usage.usage);
@@ -841,6 +851,10 @@ fn merge_codex_model_usage(target: &mut crate::CodexModelUsage, source: crate::C
             &mut target_usage.recorded_flex_usage,
             usage.recorded_flex_usage,
         );
+        merge_codex_usage_bucket(
+            &mut target_usage.recorded_ultrafast_usage,
+            usage.recorded_ultrafast_usage,
+        );
     }
     target.is_fallback |= source.is_fallback;
 }
 
@@ -767,6 +767,75 @@ mod tests {
         assert!((cost - 10e-6).abs() < f64::EPSILON);
     }
 
+    #[test]
+    fn prices_recorded_ultrafast_usage_at_published_rates() {
+        let pricing = PricingMap::load_embedded();
+        let ultrafast = |usage: CodexUsageBucket| CodexModelUsage {
+            input_tokens: usage.input_tokens,
+            cached_input_tokens: usage.cached_input_tokens,
+            output_tokens: usage.output_tokens,
+            total_tokens: usage.input_tokens + usage.output_tokens,
+            long_context_input_tokens: usage.long_context_input_tokens,
+            long_context_cached_input_tokens: usage.long_context_cached_input_tokens,
+            long_context_output_tokens: usage.long_context_output_tokens,
+            recorded_ultrafast_usage: usage,
+            ..CodexModelUsage::default()
+        };
+        let short = ultrafast(CodexUsageBucket {
+            input_tokens: 1_200,
+            cached_input_tokens: 200,
+            output_tokens: 50,
+            ..CodexUsageBucket::default()
+        });
+        let long = ultrafast(CodexUsageBucket {
+            input_tokens: 300_000,
+            cached_input_tokens: 250_000,
+            output_tokens: 1_000,
+            long_context_input_tokens: 300_000,
+            long_context_cached_input_tokens: 250_000,
+            long_context_output_tokens: 1_000,
+            ..CodexUsageBucket::default()
+        });
+
+        // Expected costs use OpenAI's published Ultrafast USD per 1M tokens.
+        for (model, short_cost, long_cost) in [
+            ("gpt-6.1-sol", 0.01512, 1.59),
+            ("gpt-6-astra", 0.0762, 9.45),
+        ] {
+            for (usage, expected) in [(&short, short_cost), (&long, long_cost)] {
+                let cost = calculate_codex_model_cost(model, usage, &pricing, CodexSpeed::Auto);
+                assert!((cost - expected).abs() < 1e-12, "{model}: {cost}");
+            }
+        }
+    }
+
+    #[test]
+    fn keeps_standard_pricing_for_ultrafast_without_a_published_rate() {
+        let pricing = PricingMap::load_embedded();
+        let usage = CodexModelUsage {
+            input_tokens: 1_200,
+            cached_input_tokens: 200,
+            output_tokens: 50,
+            total_tokens: 1_250,
+            recorded_ultrafast_usage: CodexUsageBucket {
+                input_tokens: 1_200,
+                cached_input_tokens: 200,
+                output_tokens: 50,
+                ..CodexUsageBucket::default()
+            },
+            ..CodexModelUsage::default()
+        };
+
+        for model in ["gpt-6-sol", "gpt-6.1-terra", "gpt-6-luna"] {
+            let standard =
+                calculate_codex_model_cost(model, &usage, &pricing, CodexSpeed::Standard);
+            let auto = calculate_codex_model_cost(model, &usage, &pricing, CodexSpeed::Auto);
+
+            assert!(standard > 0.0, "{model} has embedded pricing");
+            assert!((auto - standard).abs() < f64::EPSILON, "{model}");
+        }
+    }
+
     #[test]
     fn prices_rollout_service_tiers_across_loading_and_report_modes() {
         for (model, expected_costs) in [
 
@@ -667,6 +667,7 @@ fn codex_service_tier(value: &str) -> Option<CodexServiceTier> {
         "default" | "standard" => Some(CodexServiceTier::Standard),
         "fast" | "priority" => Some(CodexServiceTier::Fast),
         "flex" => Some(CodexServiceTier::Flex),
+        "ultrafast" => Some(CodexServiceTier::Ultrafast),
         _ => None,
     }
 }
@@ -1376,6 +1377,7 @@ mod tests {
             ("priority", Some(CodexServiceTier::Fast)),
             ("fast", Some(CodexServiceTier::Fast)),
             ("flex", Some(CodexServiceTier::Flex)),
+            ("ultrafast", Some(CodexServiceTier::Ultrafast)),
             ("", None),
         ] {
             assert_eq!(
Original file line number	Diff line number	Diff line change
`@@ -88,6 +88,7 @@ let`
`88`	`88`	`lib.optionals (lib.elem "ccusage-core" names) [`
`89`	`89`	`(rustRoot + /crates/ccusage-core/src/fast-multiplier-overrides.json)`
`90`	`90`	`(rustRoot + /crates/ccusage-core/src/flex-multiplier-overrides.json)`
	`91`	`+ (rustRoot + /crates/ccusage-core/src/ultrafast-multiplier-overrides.json)`
`91`	`92`	`]`
`92`	`93`	`++ lib.optionals (lib.elem "ccusage-adapter-codex" names) [`
`93`	`94`	`(rustRoot + /adapters/codex/src/codex-auto-review-fallbacks.json)`