cctally 1.17.0 → 1.18.0

package/CHANGELOG.md

@@ -5,6 +5,11 @@ 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

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],

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/cctally

@@ -368,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
@@ -408,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
@@ -1538,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,
     )
@@ -1586,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).
 
@@ -4512,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)
@@ -4533,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)
 
@@ -4549,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
@@ -4583,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
 
 
@@ -10173,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(
@@ -10210,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.17.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": {