cctally 1.16.0 → 1.18.0

package/CHANGELOG.md

@@ -5,6 +5,19 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.18.0] - 2026-05-27
+
+### Added
+- **Project-axis flags on `cctally daily` (and `cctally claude daily`): `-i/--instances`, `-p/--project`, and `--project-aliases`** — a drop-in for `ccusage daily`. `-i/--instances` groups the daily report by project (git-root), rendering a `Project: <label>` section per project with one global Total (`--json` becomes `{projects: {...}, totals}`); `-p/--project PATTERN` filters to matching projects by case-insensitive substring of the project label or path, and is repeatable with OR semantics; `--project-aliases key=Label,...` overrides project display labels (table headers only — never the JSON keys). Two distinct git-roots that share a basename stay separate (`app (work)` / `app (personal)`), null-project entries collect under `(unknown)`, and under `--format` shareable output `-i` is a no-op while `-p` is honored (the filter survives into the artifact). (#86)
+
+## [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

package/bin/_cctally_cache.py

@@ -937,6 +937,13 @@ class _JoinedClaudeEntry:
     # reconciles with daily/range-cost paths that already pass
     # `entry.cost_usd` into `_calculate_entry_cost`.
     cost_usd: float | None = None
+    # Non-token `usage` extras (parsed `usage_extra_json`) — notably
+    # `speed`, which `_aggregate_buckets` reads to render `<model>-fast`.
+    # `iter_entries` merges these into its `UsageEntry.usage`; the joined
+    # path must carry them too so `_usage_entry_from_joined` can restore
+    # them (else `daily -i`/`-p` lose fast-tier model labels). None when
+    # the row has no extras.
+    usage_extra: dict | None = None
 
 
 def get_claude_session_entries(
@@ -996,7 +1003,7 @@ def get_claude_session_entries(
         "  se.cache_create_tokens, se.cache_read_tokens, "
         "  se.source_path, "
         "  sf.session_id, sf.project_path, "
-        "  se.cost_usd_raw "
+        "  se.cost_usd_raw, se.usage_extra_json "
         "FROM session_entries se "
         "LEFT JOIN session_files sf ON sf.path = se.source_path "
         "WHERE se.timestamp_utc >= ? AND se.timestamp_utc <= ?"
@@ -1024,6 +1031,7 @@ def get_claude_session_entries(
             session_id=row[7],
             project_path=row[8],
             cost_usd=row[9],
+            usage_extra=(json.loads(row[10]) if row[10] else None),
         )
         for row in rows
     ]
@@ -1135,9 +1143,16 @@ def _direct_parse_claude_session_entries(
     results: list[_JoinedClaudeEntry] = []
     flat: list[tuple[UsageEntry, str]] = list(dedupe_map.values()) + no_key_with_meta
     flat.sort(key=lambda pair: pair[0].timestamp)
+    _token_keys = {
+        "input_tokens", "output_tokens",
+        "cache_creation_input_tokens", "cache_read_input_tokens",
+    }
     for entry, source_path in flat:
         usage = entry.usage
         sid, cwd = meta_by_path[source_path]
+        # Mirror the cache-backed path: carry non-token `usage` extras
+        # (e.g. `speed`) so `_usage_entry_from_joined` can restore them.
+        extras = {k: v for k, v in usage.items() if k not in _token_keys}
         results.append(_JoinedClaudeEntry(
             timestamp=entry.timestamp,
             model=entry.model,
@@ -1153,6 +1168,7 @@ def _direct_parse_claude_session_entries(
             session_id=sid,
             project_path=cwd,
             cost_usd=entry.cost_usd,
+            usage_extra=(extras or None),
         ))
 
     return results

package/bin/_lib_aggregators.py

@@ -232,6 +232,41 @@ def _aggregate_monthly(
     )
 
 
+def _aggregate_daily_by_project(
+    keyed_entries: list[tuple[Any, UsageEntry]],
+    *,
+    tz: "Any | None" = None,
+    mode: str = "auto",
+) -> list[tuple[Any, list[BucketUsage]]]:
+    """Group ``(project_key, UsageEntry)`` pairs into per-project daily buckets.
+
+    Returns ``[(project_key, [BucketUsage date-asc]), ...]`` ordered by each
+    project's total cost descending, ties broken by ``project_key.display_key``
+    ascending. ``project_key`` is opaque/hashable (a ``ProjectKey``); resolution
+    happened in the caller, so this stays pure (no filesystem).
+
+    Reuses ``_aggregate_daily`` per group, so per-model breakdowns, token sums,
+    and ``mode``/``cost_usd`` threading are identical to the non-instances path.
+    """
+    grouped: dict[Any, list[UsageEntry]] = {}
+    order: list[Any] = []
+    for key, entry in keyed_entries:
+        bucket = grouped.get(key)
+        if bucket is None:
+            grouped[key] = bucket = []
+            order.append(key)
+        bucket.append(entry)
+
+    ranked: list[tuple[Any, list[BucketUsage], float]] = []
+    for key in order:
+        buckets = _aggregate_daily(grouped[key], mode=mode, tz=tz)  # date-asc
+        total = sum(b.cost_usd for b in buckets)
+        ranked.append((key, buckets, total))
+
+    ranked.sort(key=lambda t: (-t[2], t[0].display_key))
+    return [(key, buckets) for key, buckets, _ in ranked]
+
+
 def _aggregate_weekly(
     entries: list[UsageEntry],
     weeks: list[SubWeek],
@@ -363,6 +398,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 +422,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 +478,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 +486,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 +499,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 +525,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 +560,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 +583,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

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_render.py

@@ -680,6 +680,40 @@ def _render_blocks_table(
     return rendered
 
 
+def _daily_row_dict(d: BucketUsage, *, date_key: str) -> dict[str, Any]:
+    """Single bucket → upstream-shaped row dict.
+
+    Shared by `_bucket_to_json` and `_bucket_by_project_to_json` so the per-row
+    shape (field set + order) can never drift. Key order matches ccusage:
+      date_key, inputTokens, outputTokens, cacheCreationTokens,
+      cacheReadTokens, totalTokens, totalCost, modelsUsed, modelBreakdowns.
+    """
+    return {
+        date_key: d.bucket,
+        "inputTokens": d.input_tokens,
+        "outputTokens": d.output_tokens,
+        "cacheCreationTokens": d.cache_creation_tokens,
+        "cacheReadTokens": d.cache_read_tokens,
+        "totalTokens": d.total_tokens,
+        "totalCost": d.cost_usd,
+        "modelsUsed": list(d.models),
+        "modelBreakdowns": list(d.model_breakdowns),
+    }
+
+
+def _bucket_totals_dict(buckets) -> dict[str, Any]:
+    """Aggregate totals across buckets (key order matches ccusage; note
+    totalCost BEFORE totalTokens)."""
+    return {
+        "inputTokens": sum(b.input_tokens for b in buckets),
+        "outputTokens": sum(b.output_tokens for b in buckets),
+        "cacheCreationTokens": sum(b.cache_creation_tokens for b in buckets),
+        "cacheReadTokens": sum(b.cache_read_tokens for b in buckets),
+        "totalCost": sum(b.cost_usd for b in buckets),
+        "totalTokens": sum(b.total_tokens for b in buckets),
+    }
+
+
 def _bucket_to_json(
     buckets: list[BucketUsage],
     *,
@@ -696,43 +730,27 @@ def _bucket_to_json(
       cacheReadTokens, totalTokens, totalCost, modelsUsed, modelBreakdowns.
     Totals key order (note: totalCost BEFORE totalTokens, per ccusage).
     """
-    bucket_list: list[dict[str, Any]] = []
-    tot_input = 0
-    tot_output = 0
-    tot_cc = 0
-    tot_cr = 0
-    tot_cost = 0.0
-    tot_tokens = 0
-    for d in buckets:
-        bucket_list.append({
-            date_key: d.bucket,
-            "inputTokens": d.input_tokens,
-            "outputTokens": d.output_tokens,
-            "cacheCreationTokens": d.cache_creation_tokens,
-            "cacheReadTokens": d.cache_read_tokens,
-            "totalTokens": d.total_tokens,
-            "totalCost": d.cost_usd,
-            "modelsUsed": list(d.models),
-            "modelBreakdowns": list(d.model_breakdowns),
-        })
-        tot_input += d.input_tokens
-        tot_output += d.output_tokens
-        tot_cc += d.cache_creation_tokens
-        tot_cr += d.cache_read_tokens
-        tot_cost += d.cost_usd
-        tot_tokens += d.total_tokens
-
-    totals = {
-        "inputTokens": tot_input,
-        "outputTokens": tot_output,
-        "cacheCreationTokens": tot_cc,
-        "cacheReadTokens": tot_cr,
-        "totalCost": tot_cost,
-        "totalTokens": tot_tokens,
-    }
+    bucket_list = [_daily_row_dict(d, date_key=date_key) for d in buckets]
+    totals = _bucket_totals_dict(buckets)
     return json.dumps({list_key: bucket_list, "totals": totals}, indent=2)
 
 
+def _bucket_by_project_to_json(project_groups, *, date_key: str = "date") -> str:
+    """Serialize ``[(label, [BucketUsage]), ...]`` to ``{projects:{label:[rows]},
+    totals}`` (upstream ccusage daily --instances shape). Caller passes the
+    disambiguated (unique, non-aliased) label per group; insertion order is
+    preserved as the JSON key order."""
+    projects: dict[str, Any] = {}
+    all_buckets: list = []
+    for label, buckets in project_groups:
+        projects[label] = [_daily_row_dict(b, date_key=date_key) for b in buckets]
+        all_buckets.extend(buckets)
+    return json.dumps(
+        {"projects": projects, "totals": _bucket_totals_dict(all_buckets)},
+        indent=2,
+    )
+
+
 def _weekly_to_json(
     buckets: list[BucketUsage],
     weeks: list[SubWeek],
@@ -1079,6 +1097,7 @@ def _render_bucket_table(
     compact_split_fn: Callable[[str], str],
     breakdown: bool = False,
     compact: bool = False,
+    project_groups=None,
 ) -> str:
     """Render bucket aggregates as a ccusage-style ANSI table.
 
@@ -1089,6 +1108,12 @@ def _render_bucket_table(
                          "YYYY\\n..." for compact-mode two-line display.
       compact         — force compact layout regardless of terminal width
                         (Session A `--compact` flag; spec §7.6.1).
+      project_groups  — when provided as ``[(label, [BucketUsage]), ...]``,
+                        render section layout: a ``Project: <label>`` header
+                        per group with one global Total footer summed across
+                        all groups (`daily -i/--instances`; issue #86 Session
+                        E). Default ``None`` = today's flat single-table
+                        behavior driven by ``buckets``.
 
     Mirrors ccusage's ResponsiveTable behavior: single-line headers and dates
     when content fits the terminal; falls back to two-line compact headers
@@ -1126,10 +1151,10 @@ def _render_bucket_table(
     # ── Build raw rows: each is (cells, row_type) where a cell is the
     #    tuple (text, color_fn_or_none). `text` may contain '\n' for
     #    multi-line cells (Models list, compact Date).
-    ROW_DATA, ROW_BREAKDOWN, ROW_FOOTER = "data", "breakdown", "footer"
+    ROW_DATA, ROW_BREAKDOWN, ROW_FOOTER, ROW_PROJECT = "data", "breakdown", "footer", "project"
     raw_rows: list[tuple[list[tuple[str, Any]], str]] = []
 
-    for d in buckets:
+    def _emit_data_and_breakdown(d):
         # ccusage formatModelsDisplayMultiline: uniq → sort alphabetical
         short_models = sorted({_short_model_name(m) for m in d.models})
         models_text = "\n".join(f"- {m}" for m in short_models) if short_models else ""
@@ -1166,13 +1191,30 @@ def _render_bucket_table(
                 ]
                 raw_rows.append((bd_cells, ROW_BREAKDOWN))
 
+    if project_groups is not None:
+        # Project-aware section layout (daily --instances): one cyan
+        # `Project: <label>` header per group, then that group's normal
+        # ROW_DATA (+ ROW_BREAKDOWN children); the single footer is computed
+        # by flattening all groups' buckets.
+        footer_buckets: list = []
+        for label, group_buckets in project_groups:
+            header_cells = [(f"Project: {label}", _cyan)] + [("", None)] * (num_cols - 1)
+            raw_rows.append((header_cells, ROW_PROJECT))
+            for d in group_buckets:
+                _emit_data_and_breakdown(d)
+                footer_buckets.append(d)
+    else:
+        for d in buckets:
+            _emit_data_and_breakdown(d)
+        footer_buckets = buckets
+
     # Total footer row — yellow on all populated cells.
-    tot_input = sum(d.input_tokens for d in buckets)
-    tot_output = sum(d.output_tokens for d in buckets)
-    tot_cc = sum(d.cache_creation_tokens for d in buckets)
-    tot_cr = sum(d.cache_read_tokens for d in buckets)
-    tot_tokens = sum(d.total_tokens for d in buckets)
-    tot_cost = sum(d.cost_usd for d in buckets)
+    tot_input = sum(d.input_tokens for d in footer_buckets)
+    tot_output = sum(d.output_tokens for d in footer_buckets)
+    tot_cc = sum(d.cache_creation_tokens for d in footer_buckets)
+    tot_cr = sum(d.cache_read_tokens for d in footer_buckets)
+    tot_tokens = sum(d.total_tokens for d in footer_buckets)
+    tot_cost = sum(d.cost_usd for d in footer_buckets)
     footer_cells = [
         ("Total", _yellow),
         ("", None),

package/bin/_lib_view_models.py

@@ -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")
@@ -364,6 +368,7 @@ CodexSessionUsage = _lib_aggregators.CodexSessionUsage
 ClaudeSessionUsage = _lib_aggregators.ClaudeSessionUsage
 _aggregate_buckets = _lib_aggregators._aggregate_buckets
 _aggregate_daily = _lib_aggregators._aggregate_daily
+_aggregate_daily_by_project = _lib_aggregators._aggregate_daily_by_project
 _aggregate_monthly = _lib_aggregators._aggregate_monthly
 _aggregate_weekly = _lib_aggregators._aggregate_weekly
 _aggregate_codex_buckets = _lib_aggregators._aggregate_codex_buckets
@@ -404,7 +409,10 @@ build_codex_session_view = _lib_view_models.build_codex_session_view
 _lib_render = _load_sibling("_lib_render")
 _CODEX_MONTHS = _lib_render._CODEX_MONTHS
 _render_blocks_table = _lib_render._render_blocks_table
+_daily_row_dict = _lib_render._daily_row_dict
+_bucket_totals_dict = _lib_render._bucket_totals_dict
 _bucket_to_json = _lib_render._bucket_to_json
+_bucket_by_project_to_json = _lib_render._bucket_by_project_to_json
 _weekly_to_json = _lib_render._weekly_to_json
 _daily_compact_split = _lib_render._daily_compact_split
 _monthly_compact_split = _lib_render._monthly_compact_split
@@ -1383,7 +1391,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 +1422,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 +1509,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 +1527,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)
@@ -1532,16 +1542,27 @@ def _usage_entry_from_joined(je) -> "UsageEntry":
     The joined-entry shape already carries ``source_path``, ``cost_usd``,
     and the per-token integers; this adapter is pure shape conversion
     with no cache re-read.
+
+    Non-token ``usage`` extras (``je.usage_extra``) — notably ``speed`` —
+    are merged AFTER the four token keys, mirroring ``iter_entries``'
+    ``usage.update(json.loads(...))``. Without this, the project-axis
+    ``daily`` path (and the diff/report joined-entry consumers) would
+    drop the fast-tier flag and render ``<model>`` where the normal path
+    renders ``<model>-fast``. The write-side strips the four token keys
+    from ``usage_extra_json`` so the merge never shadows the integers.
     """
+    usage = {
+        "input_tokens": je.input_tokens,
+        "output_tokens": je.output_tokens,
+        "cache_creation_input_tokens": je.cache_creation_tokens,
+        "cache_read_input_tokens": je.cache_read_tokens,
+    }
+    if je.usage_extra:
+        usage.update(je.usage_extra)
     return UsageEntry(
         timestamp=je.timestamp,
         model=je.model,
-        usage={
-            "input_tokens": je.input_tokens,
-            "output_tokens": je.output_tokens,
-            "cache_creation_input_tokens": je.cache_creation_tokens,
-            "cache_read_input_tokens": je.cache_read_tokens,
-        },
+        usage=usage,
         cost_usd=je.cost_usd,
         source_path=je.source_path,
     )
@@ -1580,6 +1601,42 @@ def _project_filter_matches(key, project_patterns):
     return any((p in dname) or (p in pname) for p in project_patterns)
 
 
+def _parse_project_aliases(raw):
+    """Parse a ``--project-aliases`` value into ``{key: label}``.
+
+    Form: comma-separated ``key=Label`` pairs. Whitespace around keys, labels,
+    and pairs is stripped; segments without ``=`` or with an empty key/label are
+    dropped (ported from ccusage's tolerant parser). ``None``/"" → ``{}``.
+    """
+    result: dict[str, str] = {}
+    if not raw:
+        return result
+    for pair in raw.split(","):
+        pair = pair.strip()
+        if not pair or "=" not in pair:
+            continue
+        k, _, v = pair.partition("=")
+        k = k.strip()
+        v = v.strip()
+        if k and v:
+            result[k] = v
+    return result
+
+
+def _alias_for(key, aliases):
+    """Return the alias label for a ProjectKey, or None.
+
+    Looks up ``aliases`` by ``display_key``, then ``git_root``, then
+    ``bucket_path`` (first hit). Display-only — never alters JSON keys.
+    """
+    if not aliases:
+        return None
+    for cand in (key.display_key, key.git_root, key.bucket_path):
+        if cand and cand in aliases:
+            return aliases[cand]
+    return None
+
+
 def _emit_diff_debug_samples(args, window_a, window_b) -> None:
     """Two-window diff report (spec §7.2.2 Pattern D).
 
@@ -4506,6 +4563,29 @@ def _parse_cli_date_range(
     return range_start, range_end
 
 
+def _emit_daily_view_table_or_json(view, args):
+    """Order + emit a DailyView as the flat daily table or {daily} JSON.
+
+    Shared by cmd_daily's default path and its -p-only (filter, no grouping)
+    path so the two cannot drift. Body is exactly the default path's order +
+    emit tail; callers keep their own --format share gate upstream of this.
+    """
+    days = list(reversed(view.aggregated))
+    if args.order == "desc":
+        days = list(reversed(days))
+    if args.json:
+        print(_bucket_to_json(days, list_key="daily", date_key="date"))
+        return
+    print(_render_bucket_table(
+        days,
+        first_col_name="Date",
+        title_suffix="Daily",
+        compact_split_fn=_daily_compact_split,
+        breakdown=args.breakdown,
+        compact=getattr(args, "compact", False),
+    ))
+
+
 def cmd_daily(args: argparse.Namespace) -> int:
     """Show usage report grouped by display-timezone date."""
     _share_validate_args(args)
@@ -4527,6 +4607,109 @@ def cmd_daily(args: argparse.Namespace) -> int:
         return range
     range_start, range_end = range
 
+    # ── Project-axis path (issue #86 Session E / T1.11) ────────────────────
+    # Gated by -i/--instances or -p/--project; the default path below is
+    # untouched/byte-stable. Mirrors cmd_project's I/O-layer git-root
+    # resolution + substring-OR-path filter.
+    aliases = _parse_project_aliases(getattr(args, "project_aliases", None))
+    project_patterns = [p.lower() for p in (getattr(args, "project", None) or [])]
+
+    if getattr(args, "instances", False) or project_patterns:
+        joined = list(get_claude_session_entries(range_start, range_end))
+        resolver_cache: dict = {}
+        keyed: list = []              # [(ProjectKey, UsageEntry)] — for -i grouping
+        filtered_uentries: list = []  # UsageEntry — for -p-only / --format / debug
+        for je in joined:
+            if je.model == "<synthetic>":
+                continue
+            key = _resolve_project_key(je.project_path, "git-root", resolver_cache)
+            if project_patterns and not _project_filter_matches(key, project_patterns):
+                continue
+            ue = _usage_entry_from_joined(je)
+            keyed.append((key, ue))
+            filtered_uentries.append(ue)
+
+        # Debug scope = the filtered entries (mirrors cmd_project).
+        _emit_debug_samples_if_set(args, filtered_uentries, command_label="daily")
+
+        # --format share gate: -i is a no-op (no project-section share render),
+        # but -p IS honored by building the snapshot from the filtered view.
+        if getattr(args, "format", None):
+            view = build_daily_view(filtered_uentries, now_utc=_command_as_of(),
+                                    display_tz=tz, mode=args.mode)
+            display_tz_str = _share_display_tz_label(tz)
+            snap = _build_daily_snapshot(
+                view, period_start=range_start, period_end=range_end,
+                display_tz=display_tz_str, version=_share_resolve_version(),
+                theme=args.theme, reveal_projects=args.reveal_projects,
+            )
+            if args.order == "desc":
+                snap = dataclasses.replace(snap, rows=tuple(reversed(snap.rows)))
+            _share_render_and_emit(snap, args)
+            return 0
+
+        if getattr(args, "instances", False):
+            groups = _aggregate_daily_by_project(keyed, tz=tz, mode=args.mode)
+            aug = _project_disambiguate_labels(
+                [{"key": k, "cost_usd": sum(b.cost_usd for b in bl)}
+                 for k, bl in groups]
+            )
+            json_groups: list = []
+            table_groups: list = []
+            # `_project_disambiguate_labels` only suffixes the immediate
+            # parent-dir basename, so two distinct git-roots like
+            # `/a/x/app` + `/b/x/app` both resolve to `app (x)`. Guarantee
+            # per-group JSON-key uniqueness with a counter suffix on any
+            # residual collision — otherwise `_bucket_by_project_to_json`'s
+            # `projects[label] = ...` silently overwrites the earlier group
+            # (data loss in --json). The table_label derives from the now-
+            # unique json_label, so section headers stay distinct too.
+            # `json_label`s are unique by construction (the `(#N)` counter
+            # above). Table labels, however, can re-collide: `_alias_for`
+            # matches on `display_key` first, so a basename alias like
+            # `--project-aliases app=Alias` maps BOTH same-basename git-roots
+            # to "Alias" — re-merging the exact sections this feature
+            # disambiguates. Apply the SAME `(#N)` counter to table labels so
+            # the two distinct-total sections stay tellable apart (JSON keys
+            # are untouched — they use the non-aliased `json_label`).
+            seen_json_labels: dict[str, int] = {}
+            seen_table_labels: dict[str, int] = {}
+            for i, (k, bl) in enumerate(groups):
+                ordered = list(reversed(bl)) if args.order == "desc" else bl
+                base_json_label = aug.get(i, k.display_key)
+                n = seen_json_labels.get(base_json_label, 0) + 1
+                seen_json_labels[base_json_label] = n
+                json_label = (
+                    base_json_label if n == 1 else f"{base_json_label} (#{n})"
+                )
+                base_table_label = _alias_for(k, aliases) or json_label
+                nt = seen_table_labels.get(base_table_label, 0) + 1
+                seen_table_labels[base_table_label] = nt
+                table_label = (
+                    base_table_label if nt == 1
+                    else f"{base_table_label} (#{nt})"
+                )
+                json_groups.append((json_label, ordered))
+                table_groups.append((table_label, ordered))
+            if args.json:
+                print(_bucket_by_project_to_json(json_groups, date_key="date"))
+                return 0
+            print(_render_bucket_table(
+                [], first_col_name="Date", title_suffix="Daily",
+                compact_split_fn=_daily_compact_split,
+                breakdown=args.breakdown,
+                compact=getattr(args, "compact", False),
+                project_groups=table_groups,
+            ))
+            return 0
+
+        # -p only (no -i): filter-only → normal date-aggregated daily output.
+        view = build_daily_view(filtered_uentries, now_utc=_command_as_of(),
+                                display_tz=tz, mode=args.mode)
+        _emit_daily_view_table_or_json(view, args)
+        return 0
+
+    # ── Default path (UNCHANGED) ───────────────────────────────────────────
     # Collect entries.
     all_entries = get_entries(range_start, range_end)
 
@@ -4543,10 +4726,6 @@ def cmd_daily(args: argparse.Namespace) -> int:
     # `_aggregate_daily` call is the same one we used inline.
     view = build_daily_view(all_entries, now_utc=_command_as_of(),
                             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.
-    days = list(reversed(view.aggregated))
 
     # Shareable-reports gate: --format short-circuits the JSON / table
     # dispatch via `_share_render_and_emit`. The mutex in
@@ -4577,23 +4756,10 @@ def cmd_daily(args: argparse.Namespace) -> int:
         _share_render_and_emit(snap, args)
         return 0
 
-    # Apply sort order.
-    if args.order == "desc":
-        days = list(reversed(days))
-
-    if args.json:
-        print(_bucket_to_json(days, list_key="daily", date_key="date"))
-        return 0
-
-    # Table output.
-    print(_render_bucket_table(
-        days,
-        first_col_name="Date",
-        title_suffix="Daily",
-        compact_split_fn=_daily_compact_split,
-        breakdown=args.breakdown,
-        compact=getattr(args, "compact", False),
-    ))
+    # Order + emit the flat daily table / {daily} JSON. Extracted into
+    # `_emit_daily_view_table_or_json` so this default path and the
+    # -p-only (filter, no grouping) path above stay byte-identical.
+    _emit_daily_view_table_or_json(view, args)
     return 0
 
 
@@ -4804,6 +4970,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()
@@ -4823,13 +5015,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":
@@ -4883,10 +5076,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":
@@ -4943,11 +5137,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":
@@ -5004,12 +5199,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":
@@ -9959,6 +10155,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 "
@@ -10131,6 +10333,8 @@ def _build_daily_parser(subparsers, name, *, help_text, xref):
               cctally daily --since 20260414 --breakdown
               cctally daily --since 20260414 --json
               cctally daily --order desc
+              cctally daily --instances
+              cctally daily -i --project-aliases repos=Repos
         """),
     )
     p.add_argument(
@@ -10168,6 +10372,28 @@ def _build_daily_parser(subparsers, name, *, help_text, xref):
         help="Display timezone: local, utc, or IANA name. "
              "Overrides config display.tz for this call.",
     )
+    p.add_argument(
+        "-i", "--instances",
+        action="store_true",
+        default=False,
+        help="Group the report by project (git-root).",
+    )
+    p.add_argument(
+        "-p", "--project",
+        action="append",
+        default=None,
+        metavar="PATTERN",
+        help="Filter to projects matching PATTERN (substring of the project "
+             "label or path; repeatable, OR semantics).",
+    )
+    p.add_argument(
+        "--project-aliases",
+        dest="project_aliases",
+        default=None,
+        metavar="PAIRS",
+        help="Comma-separated key=Label pairs overriding project display "
+             "labels (e.g. cctally-dev=Tracker). Display-only.",
+    )
     _add_ccusage_alias_args(p, ansi_emit=False)
     _add_mode_arg(p)
     _add_share_args(p)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cctally",
-  "version": "1.16.0",
+  "version": "1.18.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": {