cctally 1.15.0 → 1.17.0

package/CHANGELOG.md

@@ -5,6 +5,22 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.17.0] - 2026-05-27
+
+### Added
+- **`--speed {auto,standard,fast}` on `cctally codex-daily`, `codex-monthly`, `codex-weekly`, and `codex-session` (and their `cctally codex <cmd>` subgroup forms)** — a drop-in for `ccusage codex --speed`. `auto` (the default) reads `service_tier` from `~/.codex/config.toml` and applies fast-tier pricing when it is `fast` or `priority`; `fast`/`standard` force the tier. Fast-tier multiplies the per-model Codex cost by a fixed factor (`gpt-5.5` ×2.5, all other models ×2.0). `--json` gains no new field; only the `costUSD` figures change. On the flat `codex-*` forms this is a cctally extension (the standalone `ccusage-codex` binary has no `--speed`); the subgroup form mirrors `ccusage codex`. (#86)
+
+### Changed
+- **`cctally codex-*` now applies fast-tier (≥2×) Codex pricing by default when `~/.codex/config.toml` sets `service_tier = "fast"` or `"priority"`.** Previously cctally always priced Codex usage at the standard tier, under-reporting cost for workstations on the fast/priority tier (who pay the premium). With the new `--speed auto` default, those costs now match what was actually billed; pass `--speed standard` to force the old behavior. Users without a fast/priority `service_tier` see identical numbers. (#86)
+
+## [1.16.0] - 2026-05-26
+
+### Added
+- **`-m/--mode {auto,calculate,display}` cost-source selector on `cctally daily`, `monthly`, `weekly`, `session`, and `blocks`** — a drop-in for `ccusage <cmd> --mode`. `auto` (the default) uses the recorded `costUSD` from JSONL when present and otherwise computes from embedded pricing; `calculate` always computes from pricing, ignoring any recorded `costUSD`; `display` shows the recorded `costUSD` only and renders `$0.00` when an entry has none (ccusage-faithful — and because most modern Claude Code JSONL omits `costUSD`, `display` reports `$0` for nearly everything). On `blocks` the mode is honored on both the main grouping and the active canonical-swapped block. `cctally five-hour-blocks` also accepts `--mode` but as a documented no-op, since its cost is the authoritative per-block value materialized at record-time. The default-`auto` output is byte-identical to before for `daily`, `monthly`, `weekly`, and `blocks`, and no `mode` key is added to any JSON shape (see the Changed note below for the one `session` exception). (#86)
+
+### Changed
+- **`cctally session` (and the TUI session views) now prefer a session's recorded `costUSD` over a recomputed cost by default, for the historical sessions whose JSONL still carries it.** `session` was the one report that always recomputed cost from embedded pricing and ignored any recorded `costUSD`, even though `daily`, `monthly`, `weekly`, and the dashboard already preferred the recorded value — so on `costUSD`-bearing windows `cctally session` totals silently disagreed with `cctally daily`. Wiring the new `--mode auto` default through the session aggregator closes that gap: default totals now match the other reports (and the shipped reconcile invariant `Σ session.totalCost == Σ daily.totalCost`). Only the ~3.9% of historical files that still carry `costUSD` are affected (modern Claude Code omits it); everything else is unchanged. The TUI session panel/detail follow the same default and have no `--mode` flag; pass `cctally session --mode calculate` on the CLI to force the previous always-recompute behavior. (#86)
+
 ## [1.15.0] - 2026-05-26
 
 ### Added

package/bin/_lib_aggregators.py

@@ -363,6 +363,7 @@ class ClaudeSessionUsage:
 def _aggregate_codex_buckets(
     entries: list[CodexEntry],
     key_fn: Callable[[CodexEntry], str],
+    speed: str = "standard",
 ) -> list[CodexBucketUsage]:
     """Group CodexEntry list into per-bucket records sorted by key ascending.
 
@@ -386,6 +387,7 @@ def _aggregate_codex_buckets(
             entry.cached_input_tokens,
             entry.output_tokens,
             entry.reasoning_output_tokens,
+            speed=speed,
         )
 
         bucket["input"] += entry.input_tokens
@@ -441,6 +443,7 @@ def _aggregate_codex_buckets(
 
 def _aggregate_codex_daily(
     entries: list[CodexEntry], *, tz_name: str | None = None,
+    speed: str = "standard",
 ) -> list[CodexBucketUsage]:
     """Daily grouping. Default: local tz. With ``tz_name``: that IANA zone."""
     tz = _resolve_tz(tz_name)
@@ -448,11 +451,12 @@ def _aggregate_codex_daily(
         key_fn = lambda e: e.timestamp.astimezone(tz).strftime("%Y-%m-%d")  # noqa: E731
     else:
         key_fn = lambda e: e.timestamp.astimezone().strftime("%Y-%m-%d")    # noqa: E731
-    return _aggregate_codex_buckets(entries, key_fn=key_fn)
+    return _aggregate_codex_buckets(entries, key_fn=key_fn, speed=speed)
 
 
 def _aggregate_codex_monthly(
     entries: list[CodexEntry], *, tz_name: str | None = None,
+    speed: str = "standard",
 ) -> list[CodexBucketUsage]:
     """Monthly grouping. Default: local tz. With ``tz_name``: that IANA zone."""
     tz = _resolve_tz(tz_name)
@@ -460,13 +464,14 @@ def _aggregate_codex_monthly(
         key_fn = lambda e: e.timestamp.astimezone(tz).strftime("%Y-%m")  # noqa: E731
     else:
         key_fn = lambda e: e.timestamp.astimezone().strftime("%Y-%m")    # noqa: E731
-    return _aggregate_codex_buckets(entries, key_fn=key_fn)
+    return _aggregate_codex_buckets(entries, key_fn=key_fn, speed=speed)
 
 
 def _aggregate_codex_weekly(
     entries: list[CodexEntry],
     tz_name: str | None,
     week_start_idx: int,
+    speed: str = "standard",
 ) -> list[CodexBucketUsage]:
     """Group Codex entries by calendar week.
 
@@ -485,7 +490,7 @@ def _aggregate_codex_weekly(
         week_start = local_date - dt.timedelta(days=diff)
         return week_start.isoformat()
 
-    return _aggregate_codex_buckets(entries, key_fn=_week_key)
+    return _aggregate_codex_buckets(entries, key_fn=_week_key, speed=speed)
 
 
 def _session_path_parts(source_path: str) -> tuple[str, str, str]:
@@ -520,7 +525,7 @@ def _session_path_parts(source_path: str) -> tuple[str, str, str]:
     return str(stem), stem.name, str(stem.parent)
 
 
-def _aggregate_codex_sessions(entries: list[CodexEntry]) -> list[CodexSessionUsage]:
+def _aggregate_codex_sessions(entries: list[CodexEntry], speed: str = "standard") -> list[CodexSessionUsage]:
     """Group by session file path (upstream-compatible).
 
     Sessions are keyed by the full relative-path-without-.jsonl rather than
@@ -543,7 +548,7 @@ def _aggregate_codex_sessions(entries: list[CodexEntry]) -> list[CodexSessionUsa
         })
         cost = _calculate_codex_entry_cost(
             entry.model, entry.input_tokens, entry.cached_input_tokens,
-            entry.output_tokens, entry.reasoning_output_tokens,
+            entry.output_tokens, entry.reasoning_output_tokens, speed=speed,
         )
         sess["input"] += entry.input_tokens
         sess["cached_input"] += entry.cached_input_tokens
@@ -608,6 +613,7 @@ def _aggregate_codex_sessions(entries: list[CodexEntry]) -> list[CodexSessionUsa
 
 def _aggregate_claude_sessions(
     entries: list["_JoinedClaudeEntry"],
+    mode: str = "auto",
 ) -> list[ClaudeSessionUsage]:
     """Group entries by session_id, collapsing resumed-across-files sessions.
 
@@ -666,7 +672,7 @@ def _aggregate_claude_sessions(
             "cache_creation_input_tokens": entry.cache_creation_tokens,
             "cache_read_input_tokens": entry.cache_read_tokens,
         }
-        cost = _calculate_entry_cost(entry.model, usage)
+        cost = _calculate_entry_cost(entry.model, usage, mode=mode, cost_usd=entry.cost_usd)
 
         sess["input"] += entry.input_tokens
         sess["cache_create"] += entry.cache_creation_tokens

package/bin/_lib_pricing.py

@@ -346,6 +346,44 @@ _unknown_codex_model_warnings: set[str] = set()
 # directly comparable.
 CODEX_LEGACY_FALLBACK_MODEL = "gpt-5"
 
+# Per-model fast-tier price multipliers, ported from ryoppippi/ccusage
+# fast-multiplier-overrides.json ("exact" map — Codex/gpt entries only; the
+# upstream claude-opus-* entries are for ccusage's Claude adapter and never
+# price Codex models). Any fast-tier model NOT listed falls back to
+# CODEX_FAST_MULTIPLIER_FALLBACK — upstream's `fast_multiplier == 1.0 → 2.0`
+# rule in adapter/codex/report.rs:calculate_codex_model_cost.
+CODEX_FAST_MULTIPLIER_OVERRIDES: dict[str, float] = {
+    "gpt-5.5": 2.5,
+    "gpt-5.4": 2.0,
+    "gpt-5.3-codex": 2.0,
+}
+CODEX_FAST_MULTIPLIER_FALLBACK = 2.0
+
+
+def _codex_fast_multiplier(model: str) -> float:
+    """Fast-tier price multiplier for a Codex model (standard tier = 1.0)."""
+    return CODEX_FAST_MULTIPLIER_OVERRIDES.get(model, CODEX_FAST_MULTIPLIER_FALLBACK)
+
+
+def _codex_config_requests_fast_service_tier(content: str) -> bool:
+    """True iff any line sets ``service_tier = "fast"|"priority"``.
+
+    Naive line-scan ported from ryoppippi/ccusage adapter/codex/speed.rs
+    (NOT a TOML parse): strip the trailing ``#``-comment, split on the first
+    ``=``, the key must be exactly ``service_tier``, and the quote-stripped
+    value must be ``fast`` or ``priority``. Matches a ``service_tier`` line in
+    ANY table; ignores ``service_tier_override`` and substrings like
+    ``"breakfast"``.
+    """
+    for line in content.splitlines():
+        setting = line.split("#", 1)[0].strip()
+        key, sep, value = setting.partition("=")
+        if not sep or key.strip() != "service_tier":
+            continue
+        if value.strip().strip("\"'") in ("fast", "priority"):
+            return True
+    return False
+
 
 def _resolve_codex_pricing(model: str) -> tuple[dict[str, Any] | None, bool]:
     """Return (pricing_dict, is_fallback).
@@ -450,6 +488,7 @@ def _calculate_codex_entry_cost(
     cached_input_tokens: int,
     output_tokens: int,
     reasoning_output_tokens: int,
+    speed: str = "standard",
 ) -> float:
     """Compute USD cost for one Codex `token_count` event.
 
@@ -505,7 +544,10 @@ def _calculate_codex_entry_cost(
         "output_cost_per_token",
         "output_cost_per_token_above_272k_tokens",
     )
-    return input_cost + cached_input_cost + output_cost
+    base = input_cost + cached_input_cost + output_cost
+    if speed == "fast":
+        base *= _codex_fast_multiplier(model)
+    return base
 
 
 def _short_model_name(model: str) -> str:

package/bin/_lib_view_models.py

@@ -318,7 +318,7 @@ class DailyView:
     display_tz_label: str = ""
 
 
-def build_daily_view(entries, *, now_utc, display_tz=None):
+def build_daily_view(entries, *, now_utc, display_tz=None, mode="auto"):
     """Build a ``DailyView`` from raw ``UsageEntry`` list (spec §5.1).
 
     Gap-free: only days with entries appear in ``view.rows`` /
@@ -336,7 +336,7 @@ def build_daily_view(entries, *, now_utc, display_tz=None):
     share consumers ignore them and read ``view.aggregated`` instead.
     """
     _agg = _load_lib("_lib_aggregators")
-    buckets = _agg._aggregate_daily(entries, mode="auto", tz=display_tz)
+    buckets = _agg._aggregate_daily(entries, mode=mode, tz=display_tz)
     if not buckets:
         return DailyView(
             rows=(),
@@ -427,7 +427,7 @@ class MonthlyView:
     display_tz_label: str = ""
 
 
-def build_monthly_view(entries, *, now_utc, n=12, display_tz=None):
+def build_monthly_view(entries, *, now_utc, n=12, display_tz=None, mode="auto"):
     """Build a ``MonthlyView`` for the trailing ``n`` calendar months
     (spec §5.2).
 
@@ -440,7 +440,7 @@ def build_monthly_view(entries, *, now_utc, n=12, display_tz=None):
     CLI table footer would.
     """
     _agg = _load_lib("_lib_aggregators")
-    buckets = _agg._aggregate_monthly(entries, mode="auto", tz=display_tz)
+    buckets = _agg._aggregate_monthly(entries, mode=mode, tz=display_tz)
     if not buckets:
         return MonthlyView(
             rows=(), aggregated=(),
@@ -528,7 +528,7 @@ class WeeklyView:
 
 
 def build_weekly_view(conn, entries, *, weeks, now_utc, display_tz=None,
-                      as_of_utc=None):
+                      as_of_utc=None, mode="auto"):
     """Build a ``WeeklyView`` from subscription-week boundaries
     (spec §5.3).
 
@@ -548,7 +548,7 @@ def build_weekly_view(conn, entries, *, weeks, now_utc, display_tz=None,
     """
     _agg = _load_lib("_lib_aggregators")
     _cct_core = _load_lib("_cctally_core")
-    buckets_asc = _agg._aggregate_weekly(entries, weeks)
+    buckets_asc = _agg._aggregate_weekly(entries, weeks, mode=mode)
     if not buckets_asc:
         return WeeklyView(
             rows=(), aggregated=(), overlay=(),
@@ -1022,7 +1022,7 @@ class SessionsView:
     display_tz_label: str = ""
 
 
-def build_sessions_view(entries, *, now_utc, limit=None, display_tz=None):
+def build_sessions_view(entries, *, now_utc, limit=None, display_tz=None, mode="auto"):
     """Build a ``SessionsView`` from joined Claude session entries
     (spec §5.5).
 
@@ -1053,7 +1053,7 @@ def build_sessions_view(entries, *, now_utc, limit=None, display_tz=None):
     """
     import os as _os                # late: keep top-level imports lean.
     _agg = _load_lib("_lib_aggregators")
-    aggregated = _agg._aggregate_claude_sessions(entries)
+    aggregated = _agg._aggregate_claude_sessions(entries, mode=mode)
     # Apply limit truncation up front so `rows` and `aggregated` stay
     # in lockstep (spec §4.3 invariant: `total_sessions == len(rows)
     # == len(aggregated)`). limit=None → keep everything.
@@ -1703,7 +1703,7 @@ def _codex_period_start_from_month_bucket(buckets) -> "dt.datetime | None":
         return None
 
 
-def build_codex_daily_view(entries, *, now_utc, tz_name=None):
+def build_codex_daily_view(entries, *, now_utc, tz_name=None, speed="standard"):
     """Build a ``CodexDailyView`` from a list of ``CodexEntry`` (issue #58).
 
     Delegates bucketing to ``_aggregate_codex_daily`` (LiteLLM-snapshot
@@ -1712,7 +1712,7 @@ def build_codex_daily_view(entries, *, now_utc, tz_name=None):
     (None → host-local fallback inside the aggregator).
     """
     _agg = _load_lib("_lib_aggregators")
-    buckets = _agg._aggregate_codex_daily(entries, tz_name=tz_name)
+    buckets = _agg._aggregate_codex_daily(entries, tz_name=tz_name, speed=speed)
     total_cost, total_tok = _codex_bucket_totals(buckets)
     return CodexDailyView(
         rows=tuple(buckets),
@@ -1724,7 +1724,7 @@ def build_codex_daily_view(entries, *, now_utc, tz_name=None):
     )
 
 
-def build_codex_monthly_view(entries, *, now_utc, tz_name=None):
+def build_codex_monthly_view(entries, *, now_utc, tz_name=None, speed="standard"):
     """Build a ``CodexMonthlyView`` from a list of ``CodexEntry`` (issue #58).
 
     Same wrap-the-kernel posture as ``build_codex_daily_view``; bucket
@@ -1732,7 +1732,7 @@ def build_codex_monthly_view(entries, *, now_utc, tz_name=None):
     earliest visible month at UTC midnight.
     """
     _agg = _load_lib("_lib_aggregators")
-    buckets = _agg._aggregate_codex_monthly(entries, tz_name=tz_name)
+    buckets = _agg._aggregate_codex_monthly(entries, tz_name=tz_name, speed=speed)
     total_cost, total_tok = _codex_bucket_totals(buckets)
     return CodexMonthlyView(
         rows=tuple(buckets),
@@ -1745,7 +1745,7 @@ def build_codex_monthly_view(entries, *, now_utc, tz_name=None):
 
 
 def build_codex_weekly_view(entries, *, now_utc, tz_name=None,
-                            week_start_idx=0):
+                            week_start_idx=0, speed="standard"):
     """Build a ``CodexWeeklyView`` from a list of ``CodexEntry`` (issue #58).
 
     ``week_start_idx`` is the resolved Mon=0..Sun=6 index the caller
@@ -1754,7 +1754,7 @@ def build_codex_weekly_view(entries, *, now_utc, tz_name=None,
     timezone (matches ``_aggregate_codex_weekly`` contract).
     """
     _agg = _load_lib("_lib_aggregators")
-    buckets = _agg._aggregate_codex_weekly(entries, tz_name, week_start_idx)
+    buckets = _agg._aggregate_codex_weekly(entries, tz_name, week_start_idx, speed=speed)
     total_cost, total_tok = _codex_bucket_totals(buckets)
     return CodexWeeklyView(
         rows=tuple(buckets),
@@ -1766,7 +1766,7 @@ def build_codex_weekly_view(entries, *, now_utc, tz_name=None,
     )
 
 
-def build_codex_session_view(entries, *, now_utc, tz_name=None):
+def build_codex_session_view(entries, *, now_utc, tz_name=None, speed="standard"):
     """Build a ``CodexSessionView`` from a list of ``CodexEntry`` (issue #58).
 
     ``rows`` order mirrors the aggregator: descending by
@@ -1779,7 +1779,7 @@ def build_codex_session_view(entries, *, now_utc, tz_name=None):
     aggregator only tracks ``last`` per session). ``None`` on empty.
     """
     _agg = _load_lib("_lib_aggregators")
-    sessions = _agg._aggregate_codex_sessions(entries)
+    sessions = _agg._aggregate_codex_sessions(entries, speed=speed)
     total_cost = 0.0
     total_tok = 0
     earliest = None

package/bin/cctally

@@ -268,6 +268,10 @@ _resolve_model_pricing = _lib_pricing._resolve_model_pricing
 _calculate_entry_cost = _lib_pricing._calculate_entry_cost
 _warn_unknown_codex_model = _lib_pricing._warn_unknown_codex_model
 _calculate_codex_entry_cost = _lib_pricing._calculate_codex_entry_cost
+_codex_fast_multiplier = _lib_pricing._codex_fast_multiplier
+CODEX_FAST_MULTIPLIER_OVERRIDES = _lib_pricing.CODEX_FAST_MULTIPLIER_OVERRIDES
+CODEX_FAST_MULTIPLIER_FALLBACK = _lib_pricing.CODEX_FAST_MULTIPLIER_FALLBACK
+_codex_config_requests_fast_service_tier = _lib_pricing._codex_config_requests_fast_service_tier
 _short_model_name = _lib_pricing._short_model_name
 
 _lib_display_tz = _load_sibling("_lib_display_tz")
@@ -1383,7 +1387,7 @@ class _CodexCostStats:
     samples: list = field(default_factory=list)
 
 
-def _compute_codex_cost_stats(entries):
+def _compute_codex_cost_stats(entries, speed: str = "standard"):
     """Walk ``entries: Iterable[CodexEntry]`` and compute the totals +
     per-entry computed-cost samples that ``_render_codex_cost_report``
     consumes (issue #92).
@@ -1414,6 +1418,7 @@ def _compute_codex_cost_stats(entries):
             entry.cached_input_tokens,
             entry.output_tokens,
             entry.reasoning_output_tokens,
+            speed=speed,
         )
         stats.total_cost += cost
         stats.samples.append(_CodexCostSample(
@@ -1500,6 +1505,7 @@ def _emit_codex_debug_samples_if_set(
     entries,
     *,
     command_label: str,
+    speed: str = "standard",
 ) -> None:
     """Emit the codex --debug report once per process when ``args.debug``
     is True (issue #92).
@@ -1517,7 +1523,7 @@ def _emit_codex_debug_samples_if_set(
     if not getattr(args, "debug", False):
         return
     sample_limit = int(getattr(args, "debug_samples", 5))
-    stats = _compute_codex_cost_stats(entries)
+    stats = _compute_codex_cost_stats(entries, speed=speed)
     stats.command_label = command_label
     for line in _render_codex_cost_report(stats, sample_limit):
         eprint(line)
@@ -4238,7 +4244,7 @@ def cmd_blocks(args: argparse.Namespace) -> int:
         range_start=range_start,
         range_end=range_end,
         display_tz=tz,
-        mode="auto",
+        mode=args.mode,
         skip_rows=True,
     )
     blocks = list(view.aggregated)
@@ -4263,7 +4269,7 @@ def cmd_blocks(args: argparse.Namespace) -> int:
     # additional entries. Without re-aggregation the displayed window
     # said one thing and the cost said another (live data: window
     # 20:50→01:50 with $45 cost vs the real $128).
-    _maybe_swap_active_block_to_canonical(blocks, all_entries, now=now_utc)
+    _maybe_swap_active_block_to_canonical(blocks, all_entries, now=now_utc, mode=args.mode)
 
     if args.json:
         print(_blocks_to_json(blocks))
@@ -4284,6 +4290,7 @@ def _maybe_swap_active_block_to_canonical(
     all_entries: list[Any],
     *,
     now: dt.datetime,
+    mode: str = "auto",
 ) -> None:
     """In-place swap of an ACTIVE heuristic block to its API-anchored
     canonical window — timestamps AND token/cost totals.
@@ -4359,10 +4366,10 @@ def _maybe_swap_active_block_to_canonical(
     if block_end_utc <= now.astimezone(dt.timezone.utc):
         return
     # Re-aggregate entries over the canonical interval. Build a fresh
-    # Block via ``_build_activity_block`` (mode="auto" matches
-    # ``_group_entries_into_blocks``'s default) so every total stays in
-    # one code path — no field-by-field assignment that could drift if
-    # the dataclass grows new fields.
+    # Block via ``_build_activity_block`` so every total stays in one code
+    # path — no field-by-field assignment that could drift if the dataclass
+    # grows new fields. Thread the caller's ``mode`` so the active block's
+    # cost honors --mode like the main grouping (Session C / Codex F1).
     canonical_entries = [
         e for e in all_entries
         if block_start_utc <= e.timestamp < block_end_utc
@@ -4372,7 +4379,7 @@ def _maybe_swap_active_block_to_canonical(
         block_start_utc,
         block_end_utc,
         now.astimezone(dt.timezone.utc),
-        "auto",
+        mode,
         anchor="recorded",
     )
     blocks[active_idx] = rebuilt
@@ -4541,7 +4548,7 @@ def cmd_daily(args: argparse.Namespace) -> int:
     # fields live on BucketUsage, not on DailyPanelRow. The builder's
     # `_aggregate_daily` call is the same one we used inline.
     view = build_daily_view(all_entries, now_utc=_command_as_of(),
-                            display_tz=tz)
+                            display_tz=tz, mode=args.mode)
     # `_aggregate_daily` returned ascending order; build_daily_view stores
     # `aggregated` newest-first. CLI's default order is ascending, so
     # re-reverse to match the prior on-the-wire shape.
@@ -4628,7 +4635,7 @@ def cmd_monthly(args: argparse.Namespace) -> int:
     # Pass a large `n` so the CLI's `--since`/`--until` window controls
     # how many months render (the dashboard caps at n=12; CLI doesn't).
     view = build_monthly_view(all_entries, now_utc=_command_as_of(),
-                              n=10**6, display_tz=tz)
+                              n=10**6, display_tz=tz, mode=args.mode)
     # The view stores `aggregated` newest-first; CLI default is asc.
     months = list(reversed(view.aggregated))
 
@@ -4745,7 +4752,7 @@ def cmd_weekly(args: argparse.Namespace) -> int:
     # assertions stay aligned.
     view = build_weekly_view(
         conn, all_entries, weeks=weeks, now_utc=now_utc,
-        display_tz=args._resolved_tz, as_of_utc=as_of_utc,
+        display_tz=args._resolved_tz, as_of_utc=as_of_utc, mode=args.mode,
     )
     buckets = list(reversed(view.aggregated))
     overlay = list(reversed(view.overlay))
@@ -4803,6 +4810,32 @@ def cmd_weekly(args: argparse.Namespace) -> int:
     return 0
 
 
+def _detect_codex_fast_service_tier() -> bool:
+    """True iff ``~/.codex/config.toml`` requests the fast/priority tier.
+
+    Reads from ``~/.codex`` only (single root; ``$CODEX_HOME`` multi-root is
+    deferred — see #108). Tolerates an absent/unreadable config (→ False →
+    standard tier).
+    """
+    cfg = pathlib.Path.home() / ".codex" / "config.toml"
+    try:
+        content = cfg.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return False
+    return _codex_config_requests_fast_service_tier(content)
+
+
+def _resolve_codex_speed(requested: str) -> str:
+    """Resolve a ``--speed`` value to an effective tier.
+
+    ``auto`` → ``fast`` iff ``~/.codex/config.toml`` requests it, else
+    ``standard``. ``fast``/``standard`` pass through unchanged.
+    """
+    if requested == "auto":
+        return "fast" if _detect_codex_fast_service_tier() else "standard"
+    return requested
+
+
 def cmd_codex_daily(args: argparse.Namespace) -> int:
     """Show Codex usage report grouped by date (display tz, --tz, or --timezone)."""
     config = load_config()
@@ -4822,13 +4855,14 @@ def cmd_codex_daily(args: argparse.Namespace) -> int:
     range_start, range_end = range
 
     entries = get_codex_entries(range_start, range_end)
-    _emit_codex_debug_samples_if_set(args, entries, command_label="codex-daily")
+    speed = _resolve_codex_speed(args.speed)
+    _emit_codex_debug_samples_if_set(args, entries, command_label="codex-daily", speed=speed)
     # Route through ``build_codex_daily_view`` (issue #58). The View
     # wraps ``_aggregate_codex_daily`` without changing it — preserves
     # LiteLLM token semantics, intentional dedup vs upstream, and
     # ``CODEX_LEGACY_FALLBACK_MODEL`` warning end-to-end.
     view = build_codex_daily_view(
-        entries, now_utc=_command_as_of(), tz_name=tz_name,
+        entries, now_utc=_command_as_of(), tz_name=tz_name, speed=speed,
     )
     days = list(view.rows)                  # asc — matches aggregator default
     if args.order == "desc":
@@ -4882,10 +4916,11 @@ def cmd_codex_monthly(args: argparse.Namespace) -> int:
     range_start, range_end = range
 
     entries = get_codex_entries(range_start, range_end)
-    _emit_codex_debug_samples_if_set(args, entries, command_label="codex-monthly")
+    speed = _resolve_codex_speed(args.speed)
+    _emit_codex_debug_samples_if_set(args, entries, command_label="codex-monthly", speed=speed)
     # Route through ``build_codex_monthly_view`` (issue #58).
     view = build_codex_monthly_view(
-        entries, now_utc=_command_as_of(), tz_name=tz_name,
+        entries, now_utc=_command_as_of(), tz_name=tz_name, speed=speed,
     )
     months = list(view.rows)
     if args.order == "desc":
@@ -4942,11 +4977,12 @@ def cmd_codex_weekly(args: argparse.Namespace) -> int:
     week_start_idx = WEEKDAY_MAP[week_start_name]
 
     entries = get_codex_entries(range_start, range_end)
-    _emit_codex_debug_samples_if_set(args, entries, command_label="codex-weekly")
+    speed = _resolve_codex_speed(args.speed)
+    _emit_codex_debug_samples_if_set(args, entries, command_label="codex-weekly", speed=speed)
     # Route through ``build_codex_weekly_view`` (issue #58).
     view = build_codex_weekly_view(
         entries, now_utc=now_utc, tz_name=tz_name,
-        week_start_idx=week_start_idx,
+        week_start_idx=week_start_idx, speed=speed,
     )
     weeks = list(view.rows)
     if args.order == "desc":
@@ -5003,12 +5039,13 @@ def cmd_codex_session(args: argparse.Namespace) -> int:
     range_start, range_end = range
 
     entries = get_codex_entries(range_start, range_end)
-    _emit_codex_debug_samples_if_set(args, entries, command_label="codex-session")
+    speed = _resolve_codex_speed(args.speed)
+    _emit_codex_debug_samples_if_set(args, entries, command_label="codex-session", speed=speed)
     # Route through ``build_codex_session_view`` (issue #58). View rows
     # come descending by last_activity (aggregator default + upstream
     # parity); --order asc reverses.
     view = build_codex_session_view(
-        entries, now_utc=_command_as_of(), tz_name=tz_name,
+        entries, now_utc=_command_as_of(), tz_name=tz_name, speed=speed,
     )
     sessions = list(view.rows)
     if args.order == "asc":
@@ -5973,6 +6010,7 @@ def cmd_session(args: argparse.Namespace) -> int:
     # files collapses to ONE entry in BOTH tuples).
     view = build_sessions_view(
         entries, now_utc=_command_as_of(), limit=None, display_tz=tz,
+        mode=args.mode,
     )
     sessions = list(view.aggregated)
 
@@ -9783,6 +9821,36 @@ def _argparse_has_arg(parser, option_string: str) -> bool:
     return False
 
 
+def _add_mode_arg(parser, *, noop: bool = False) -> None:
+    """Add ccusage's -m/--mode {auto,calculate,display} cost-source flag.
+
+    Standalone (not folded into _add_ccusage_alias_args) so it lands only
+    on the six Session-C reporting commands and never collides with
+    range-cost, which defines its own -m/--mode.
+
+    noop=True (five-hour-blocks only): the flag is accepted for surface
+    parity with `blocks` but does not alter numbers — that command's cost
+    is the authoritative materialized five_hour_blocks.total_cost_usd
+    computed at record-time (always auto semantics).
+    """
+    help_real = (
+        "Cost source: auto (recorded costUSD when present, else computed), "
+        "calculate (always compute from embedded pricing), display "
+        "(recorded costUSD only; $0 when absent). Default: auto."
+    )
+    help_noop = (
+        "Accepted for ccusage drop-in compat; no-op here — five-hour-blocks "
+        "cost is the authoritative materialized per-block value computed at "
+        "record-time. Default: auto."
+    )
+    parser.add_argument(
+        "-m", "--mode",
+        default="auto",
+        choices=["auto", "calculate", "display"],
+        help=help_noop if noop else help_real,
+    )
+
+
 def _add_ccusage_alias_args(parser, *, ansi_emit: bool) -> None:
     """Attach the Session A ccusage alias surface to a Claude-cmd subparser.
 
@@ -9927,6 +9995,12 @@ def _add_codex_shared_args(parser: argparse.ArgumentParser) -> None:
         "-O", "--offline", action=argparse.BooleanOptionalAction, default=False,
         help="Accepted for drop-in compat with ccusage-codex; we are always offline.",
     )
+    parser.add_argument(
+        "--speed", choices=("auto", "standard", "fast"), default="auto",
+        help="Codex pricing tier. auto (default) reads service_tier from "
+             "~/.codex/config.toml (fast|priority -> fast pricing); fast "
+             "forces the fast-tier multiplier; standard forces base pricing.",
+    )
     parser.add_argument(
         "--tz", default=None, type=_argparse_tz, metavar="TZ",
         help="Display timezone: local, utc, or IANA name. Overrides "
@@ -10137,6 +10211,7 @@ def _build_daily_parser(subparsers, name, *, help_text, xref):
              "Overrides config display.tz for this call.",
     )
     _add_ccusage_alias_args(p, ansi_emit=False)
+    _add_mode_arg(p)
     _add_share_args(p)
     p.set_defaults(func=cmd_daily)
     return p
@@ -10195,6 +10270,7 @@ def _build_monthly_parser(subparsers, name, *, help_text, xref):
              "Overrides config display.tz for this call.",
     )
     _add_ccusage_alias_args(p, ansi_emit=False)
+    _add_mode_arg(p)
     _add_share_args(p)
     p.set_defaults(func=cmd_monthly)
     return p
@@ -10235,6 +10311,7 @@ def _build_weekly_parser(subparsers, name, *, help_text, xref):
                    help="Display timezone: local, utc, or IANA name. "
                         "Overrides config display.tz for this call.")
     _add_ccusage_alias_args(p, ansi_emit=False)
+    _add_mode_arg(p)
     _add_share_args(p)
     p.set_defaults(func=cmd_weekly)
     return p
@@ -10286,6 +10363,7 @@ def _build_session_parser(subparsers, name, *, help_text, xref):
              "Unknown id → exit 0 with the empty-render branch.",
     )
     _add_ccusage_alias_args(p, ansi_emit=False)
+    _add_mode_arg(p)
     _add_share_args(p)
     p.set_defaults(func=cmd_session)
     return p
@@ -10340,6 +10418,7 @@ def _build_blocks_parser(subparsers, name, *, help_text, xref):
              "Overrides config display.tz for this call.",
     )
     _add_ccusage_alias_args(p, ansi_emit=False)
+    _add_mode_arg(p)
     p.set_defaults(func=cmd_blocks)
     return p
 
@@ -11266,6 +11345,7 @@ def build_parser() -> argparse.ArgumentParser:
     # guard. The helper's --color add lands as a parsed-and-ignored
     # no-op (the renderer emits plain text).
     _add_ccusage_alias_args(fhb, ansi_emit=False)
+    _add_mode_arg(fhb, noop=True)
     _add_share_args(fhb)
     fhb.set_defaults(func=cmd_five_hour_blocks)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cctally",
-  "version": "1.15.0",
+  "version": "1.17.0",
   "description": "Claude Code usage tracker and local dashboard for Pro/Max subscription limits - weekly cost-per-percent trend, quota forecasts, threshold alerts. ccusage-compatible.",
   "homepage": "https://github.com/omrikais/cctally",
   "repository": {