cctally 1.10.2 → 1.11.0

package/bin/_cctally_tui.py

@@ -1071,6 +1071,16 @@ class DataSnapshot:
     # declares ``ProjectsEnvelope | null`` and the client renders the
     # panel-empty state until the next tick replaces it.
     projects_envelope: dict | None = None
+    # Cache-report panel + modal envelope block (spec
+    # 2026-05-21-cache-report-panel-design.md §4.2). Populated on the
+    # sync thread by ``build_cache_report_snapshot`` alongside the
+    # existing projects build. The dashboard's
+    # ``snapshot_to_envelope`` reads this back unchanged and assigns it
+    # to ``envelope["cache_report"]``. ``None`` on first tick before
+    # sync completes — the TS envelope mirror declares
+    # ``CacheReportEnvelope | null`` and the client renders the
+    # panel-empty state until the next tick replaces it.
+    cache_report: Any | None = None
 
     @classmethod
     def synthesize_for_marketing(cls, *, as_of_iso: str) -> "DataSnapshot":
@@ -2113,6 +2123,40 @@ def _tui_build_snapshot(
                 sessions = annotated
             except Exception as exc:
                 errors.append(f"projects-cross-nav-bind: {exc}")
+
+        # Cache-report panel + modal envelope block (spec
+        # 2026-05-21-cache-report-panel-design.md §5.2). Per-tick build
+        # alongside the projects envelope. Threshold is read from
+        # ``config.json:cache_report.anomaly_threshold_pp`` (default
+        # 15); ``anomaly_window_days`` is hardcoded at 14 in v1.
+        # display_tz inherits the same resolved zone as every other
+        # panel so today-bucketing matches the envelope's ``display``
+        # block. Errors record on ``last_sync_error``; ``None`` lands
+        # on the DataSnapshot field and the client renders the empty
+        # state.
+        cache_report_block = None
+        try:
+            cfg_cr = load_config().get("cache_report") or {}
+            threshold_raw = cfg_cr.get("anomaly_threshold_pp", 15)
+            try:
+                threshold_pp = int(threshold_raw)
+            except (TypeError, ValueError):
+                threshold_pp = 15
+            if threshold_pp < 1 or threshold_pp > 100:
+                threshold_pp = 15
+            _dash_mod = sys.modules["_cctally_dashboard"]
+            _bcr = _dash_mod.build_cache_report_snapshot
+            cache_report_block = _bcr(
+                now_utc=now_utc,
+                anomaly_threshold_pp=threshold_pp,
+                # Hardcoded for v1; F10 tracks lifting via cache_report.anomaly_window_days config.
+                anomaly_window_days=_dash_mod.CACHE_REPORT_ANOMALY_WINDOW_DAYS,
+                display_tz=_build_display_tz,
+                skip_sync=skip_sync,
+            )
+        except Exception as exc:
+            errors.append(f"cache-report: {exc}")
+
         return DataSnapshot(
             current_week=cw,
             forecast=fc,
@@ -2141,6 +2185,7 @@ def _tui_build_snapshot(
             trend_history_median_dpp=history_median_dpp,
             forecast_view=fc_view,
             projects_envelope=projects_envelope_block,
+            cache_report=cache_report_block,
         )
     finally:
         conn.close()

package/bin/_lib_blocks.py

@@ -290,6 +290,10 @@ def _group_entries_into_blocks(
             if prev.end_time < b.start_time:
                 first_entry_ts = first_entry_ts_by_block.get(id(b), b.start_time)
                 prev_actual_end = prev.actual_end_time or prev.end_time
+                gap_seconds = (first_entry_ts - prev_actual_end).total_seconds()
+                if gap_seconds < 60:
+                    final_blocks.append(b)
+                    continue
                 final_blocks.append(Block(
                     start_time=prev_actual_end,
                     end_time=first_entry_ts,

package/bin/_lib_render.py

@@ -206,10 +206,11 @@ def _render_blocks_table(
         return f"{h}h {m:02d}m"
 
     def _fmt_gap_duration(total_seconds: float) -> str:
-        hours = round(total_seconds / 3600)
-        if hours < 1:
-            hours = 1
-        return f"{hours}h gap"
+        total_minutes = int(total_seconds / 60)
+        if total_minutes < 60:
+            return f"{max(total_minutes, 1)}m gap"
+        h, m = divmod(total_minutes, 60)
+        return f"{h}h {m:02d}m gap" if m else f"{h}h gap"
 
     # ── determine if % column is needed ─────────────────────────────────
     max_completed_tokens = 0

package/bin/cctally

@@ -2179,71 +2179,24 @@ def _trend_row_recency_seconds(row: dict[str, Any]) -> float:
     return 0.0
 
 
-@dataclass
-class CacheModelBreakdown:
-    model_name: str
-    input_tokens: int
-    output_tokens: int
-    cache_creation_tokens: int
-    cache_read_tokens: int
-    cache_hit_percent: float
-    cost: float
-    saved_usd: float = 0.0
-    wasted_usd: float = 0.0
-    net_usd: float = 0.0
-
-
-@dataclass
-class CacheRow:
-    # Identity (exactly one group populated)
-    date: str | None = None
-    session_id: str | None = None
-    project_path: str | None = None
-    last_activity: dt.datetime | None = None
-    source_paths: list[str] = field(default_factory=list)
-
-    # Token counters
-    input_tokens: int = 0
-    output_tokens: int = 0
-    cache_creation_tokens: int = 0
-    cache_read_tokens: int = 0
-
-    # Financials (populated by Task 2; zero here)
-    cost: float = 0.0
-    saved_usd: float = 0.0
-    wasted_usd: float = 0.0
-    net_usd: float = 0.0
-
-    # Per-model breakdown children
-    model_breakdowns: list[CacheModelBreakdown] = field(default_factory=list)
-
-    # Anomaly (populated by Task 5; defaults here)
-    anomaly_triggered: bool = False
-    anomaly_reasons: list[str] = field(default_factory=list)
-
-    @property
-    def total_tokens(self) -> int:
-        return (
-            self.input_tokens + self.output_tokens
-            + self.cache_creation_tokens + self.cache_read_tokens
-        )
-
-    @property
-    def cache_hit_percent(self) -> float:
-        return _compute_cache_hit_percent(
-            self.input_tokens, self.cache_creation_tokens, self.cache_read_tokens
-        )
-
-
-def _compute_cache_hit_percent(
-    input_tokens: int,
-    cache_creation_tokens: int,
-    cache_read_tokens: int,
-) -> float:
-    total_input = input_tokens + cache_creation_tokens + cache_read_tokens
-    if total_input == 0:
-        return 0.0
-    return (cache_read_tokens / total_input) * 100
+# === Cache-report kernel re-exports (Task A2 onward) =========================
+# The dataclasses + pure helpers below previously lived inline in bin/cctally;
+# the cache-report panel/modal effort moved them to bin/_cctally_cache_report
+# so the dashboard sync builder can reuse the same pure aggregation as the
+# CLI. cctally-side callers continue to reach for ``CacheRow`` /
+# ``CacheModelBreakdown`` / ``_compute_cache_hit_percent`` /
+# ``_compute_entry_cache_dollars`` by bare name (extensive — every cache-report
+# renderer + JSON emitter); per-symbol re-export here preserves the call sites
+# unchanged. ``_compute_entry_cache_dollars`` keeps its pre-extraction
+# signature on this side by wrapping the kernel version with the embedded
+# ``CLAUDE_MODEL_PRICING`` injected as the ``pricing`` kwarg.
+#
+# Spec: docs/superpowers/specs/2026-05-21-cache-report-panel-design.md §5.2
+_cctally_cache_report = _load_sibling("_cctally_cache_report")
+CacheModelBreakdown = _cctally_cache_report.CacheModelBreakdown
+CacheRow = _cctally_cache_report.CacheRow
+_compute_cache_hit_percent = _cctally_cache_report._compute_cache_hit_percent
+_compute_entry_cache_dollars_kernel = _cctally_cache_report._compute_entry_cache_dollars
 
 
 def _compute_entry_cache_dollars(
@@ -2251,142 +2204,57 @@ def _compute_entry_cache_dollars(
     cache_creation_tokens: int,
     cache_read_tokens: int,
 ) -> tuple[float, float, float]:
-    """Return (saved_usd, wasted_usd, net_usd) for a single API-call entry.
-
-    saved_usd  = cache_read_tokens  x (base_rate - read_rate)
-                 "what you'd have paid without caching"
-    wasted_usd = cache_creation_tokens x (create_rate - base_rate)
-                 "the premium paid to write cache"
-    net_usd    = saved_usd - wasted_usd
-                 positive = caching helped; negative = caching hurt
-
-    Applies Anthropic's per-call >200K-tokens tier (mirrors the
-    `_tiered` helper in `_calculate_entry_cost`). Aggregating tokens
-    across multiple calls and then pricing would under-count savings on
-    any single call that crossed the tier. Resolves `anthropic/` and
-    `anthropic.` aliases via `_resolve_model_pricing` so cache-dollar
-    numbers stay aligned with cost numbers.
+    """Compatibility wrapper — pre-extraction signature.
+
+    The kernel function takes ``pricing`` explicitly so it stays pure;
+    bin/cctally callers inject the embedded ``CLAUDE_MODEL_PRICING``.
+    ``_lookup_pricing`` inside the kernel handles the ``anthropic/`` /
+    ``anthropic.`` alias-stripping that the legacy ``_resolve_model_pricing``
+    did, but without the stderr warning (the warning is the CLI's concern
+    and already fires elsewhere via ``_calculate_entry_cost``).
     """
-    pricing = _resolve_model_pricing(model) or {}
-
-    def _tiered_rate(tokens: int, base_key: str, tiered_key: str) -> float:
-        """Blended $/token rate for a single-call token count under tiered pricing."""
-        base_rate = pricing.get(base_key, 0.0)
-        tiered_rate = pricing.get(tiered_key)
-        if tokens <= 0:
-            return 0.0
-        if tokens > TIERED_THRESHOLD and tiered_rate is not None:
-            below = TIERED_THRESHOLD
-            above = tokens - TIERED_THRESHOLD
-            return (below * base_rate + above * tiered_rate) / tokens
-        return base_rate
-
-    base_for_read = _tiered_rate(
-        cache_read_tokens,
-        "input_cost_per_token",
-        "input_cost_per_token_above_200k_tokens",
-    )
-    read_rate = _tiered_rate(
-        cache_read_tokens,
-        "cache_read_input_token_cost",
-        "cache_read_input_token_cost_above_200k_tokens",
-    )
-    base_for_create = _tiered_rate(
-        cache_creation_tokens,
-        "input_cost_per_token",
-        "input_cost_per_token_above_200k_tokens",
-    )
-    create_rate = _tiered_rate(
-        cache_creation_tokens,
-        "cache_creation_input_token_cost",
-        "cache_creation_input_token_cost_above_200k_tokens",
-    )
-
-    saved = cache_read_tokens * max(0.0, base_for_read - read_rate)
-    wasted = cache_creation_tokens * max(0.0, create_rate - base_for_create)
-    net = saved - wasted
-    return (saved, wasted, net)
+    return _compute_entry_cache_dollars_kernel(
+        model, cache_creation_tokens, cache_read_tokens,
+        pricing=CLAUDE_MODEL_PRICING,
+        tiered_threshold=TIERED_THRESHOLD,
+    )
 
 
 def _aggregate_cache_by_day(
     since: dt.datetime,
     until: dt.datetime,
     project: str | None = None,
+    *,
+    display_tz: "ZoneInfo | None" = None,
 ) -> list[CacheRow]:
-    """Group Claude Code entries by local date within [since, until]."""
-    # internal fallback: host-local intentional
-    local_tz = dt.datetime.now().astimezone().tzinfo
-
-    day_model_buckets: dict[str, dict[str, dict[str, Any]]] = {}
-    for entry in get_entries(since, until, project=project):
-        day_key = entry.timestamp.astimezone(local_tz).strftime("%Y-%m-%d")
-        cost = _calculate_entry_cost(
-            entry.model, entry.usage, mode="auto", cost_usd=entry.cost_usd
-        )
-        create_tok = entry.usage.get("cache_creation_input_tokens", 0)
-        read_tok = entry.usage.get("cache_read_input_tokens", 0)
-        saved, wasted, net = _compute_entry_cache_dollars(
-            entry.model, create_tok, read_tok
-        )
-        models = day_model_buckets.setdefault(day_key, {})
-        b = models.setdefault(entry.model, {
-            "inputTokens": 0, "outputTokens": 0,
-            "cacheCreationTokens": 0, "cacheReadTokens": 0, "cost": 0.0,
-            "savedUsd": 0.0, "wastedUsd": 0.0, "netUsd": 0.0,
-        })
-        b["inputTokens"] += entry.usage.get("input_tokens", 0)
-        b["outputTokens"] += entry.usage.get("output_tokens", 0)
-        b["cacheCreationTokens"] += create_tok
-        b["cacheReadTokens"] += read_tok
-        b["cost"] += cost
-        b["savedUsd"] += saved
-        b["wastedUsd"] += wasted
-        b["netUsd"] += net
-
-    result: list[CacheRow] = []
-    for day_key in sorted(day_model_buckets.keys()):
-        models = day_model_buckets[day_key]
-        row = CacheRow(date=day_key)
-        for model_name in sorted(models.keys()):
-            b = models[model_name]
-            mb = CacheModelBreakdown(
-                model_name=model_name,
-                input_tokens=b["inputTokens"],
-                output_tokens=b["outputTokens"],
-                cache_creation_tokens=b["cacheCreationTokens"],
-                cache_read_tokens=b["cacheReadTokens"],
-                cache_hit_percent=_compute_cache_hit_percent(
-                    b["inputTokens"], b["cacheCreationTokens"], b["cacheReadTokens"]
-                ),
-                cost=b["cost"],
-                saved_usd=b["savedUsd"],
-                wasted_usd=b["wastedUsd"],
-                net_usd=b["netUsd"],
-            )
-            row.model_breakdowns.append(mb)
-            row.input_tokens += mb.input_tokens
-            row.output_tokens += mb.output_tokens
-            row.cache_creation_tokens += mb.cache_creation_tokens
-            row.cache_read_tokens += mb.cache_read_tokens
-            row.cost += mb.cost
-            row.saved_usd += mb.saved_usd
-            row.wasted_usd += mb.wasted_usd
-            row.net_usd += mb.net_usd
-        result.append(row)
-    return result
-
+    """CLI adapter: pulls entries from ``get_entries`` and delegates to the
+    pure-fn kernel ``_cctally_cache_report._aggregate_cache_by_day``.
+
+    Adds an explicit ``display_tz`` kwarg (closes the pre-existing minor bug
+    where ``--tz`` shifted the window edges but not the day-bucketing —
+    spec §1.6, plan A3). Passes the embedded ``CLAUDE_MODEL_PRICING`` +
+    ``_calculate_entry_cost`` into the kernel so the kernel itself stays
+    free of pricing globals / cost-dispatch I/O.
+
+    Direct callers that don't pass ``display_tz`` (legacy contract) fall
+    back to host-local via the kernel's ``None``-tz handling, matching
+    pre-extraction behavior byte-for-byte. ``since`` / ``until`` bound
+    the I/O query here; the kernel itself trusts the caller's pre-filter.
+    """
+    entries = list(get_entries(since, until, project=project))
+    return _cctally_cache_report._aggregate_cache_by_day(
+        entries,
+        display_tz=display_tz,
+        pricing=CLAUDE_MODEL_PRICING,
+        cost_calculator=_calculate_entry_cost,
+    )
 
-def _filename_uuid_stem(path: str) -> str:
-    """Extract the UUID stem from a JSONL filename.
 
-    Claude JSONL files are named `<uuid>.jsonl`; fall back to the full
-    filename (without extension) if the stem isn't a valid UUID shape.
-    Matches the `session` subcommand's convention for unresolved session
-    IDs.
-    """
-    base = os.path.basename(path)
-    stem, _, _ = base.partition(".")
-    return stem
+# Re-export the kernel's filename stem helper so any bare-name callers
+# inside bin/cctally (and tests poking via ``ns["_filename_uuid_stem"]``)
+# resolve unchanged. Kernel is pure-string; ``os.path.basename``
+# equivalence is asserted by ``test_aggregate_by_session_falls_back_*``.
+_filename_uuid_stem = _cctally_cache_report._filename_uuid_stem
 
 
 def _aggregate_cache_by_session(
@@ -2394,135 +2262,40 @@ def _aggregate_cache_by_session(
     until: dt.datetime,
     project: str | None = None,
 ) -> list[CacheRow]:
-    """Group Claude entries by sessionId (resumed-merged) within [since, until].
-
-    Uses get_claude_session_entries for the existing session_entries x
-    session_files LEFT JOIN. Entries with NULL session_id fall back to
-    the filename UUID stem of source_path (matches the `session`
-    subcommand's convention). A one-shot stderr warning fires when any
-    entry used the fallback. `project`, when set, filters by the same
-    slug semantics as `get_entries(project=...)`.
+    """CLI adapter: pulls Claude session entries from
+    ``get_claude_session_entries`` and delegates to the pure-fn kernel
+    ``_cctally_cache_report._aggregate_cache_by_session``.
+
+    Preserves the legacy one-shot ``Warning: N entries lacked
+    session_files rows (cache may be catching up).`` stderr line by
+    consuming the kernel's ``fallback_count`` and calling ``eprint``
+    here (kept on the I/O side; kernel stays pure). Injects
+    ``CLAUDE_MODEL_PRICING`` + ``_calculate_entry_cost`` +
+    ``_decode_escaped_cwd`` so the kernel doesn't reach for cctally
+    globals. ``since`` / ``until`` bound the I/O query; the kernel
+    itself trusts the caller's pre-filter.
     """
     entries = get_claude_session_entries(since, until, project=project)
     if not entries:
         return []
 
-    # buckets[sid] = {"entries": [...], "project_path": str|None,
-    #                 "last_activity": dt|None, "source_paths": set[str]}
-    buckets: dict[str, dict[str, Any]] = {}
-    fallback_count = 0
-    for entry in entries:
-        # Skip synthetic entries (Claude Code internal markers, not real
-        # model calls). Mirrors `_aggregate_claude_sessions` (line ~2992).
-        # Must occur before the session_id fallback so synthetic entries
-        # don't inflate fallback_count either.
-        if entry.model == "<synthetic>":
-            continue
-        sid = entry.session_id
-        if sid is None:
-            sid = _filename_uuid_stem(entry.source_path)
-            fallback_count += 1
-        b = buckets.setdefault(sid, {
-            "entries": [],
-            # Seed with decoded-cwd fallback so rows still resolve a
-            # Project cell while session_files backfill is incomplete.
-            # Real project_path from session_files (if present on any
-            # joined row) overrides below.
-            "project_path": _decode_escaped_cwd(
-                os.path.basename(os.path.dirname(entry.source_path))
-            ),
-            "last_activity": None,
-            "source_paths": set(),
-        })
-        b["entries"].append(entry)
-        b["source_paths"].add(entry.source_path)
-        if b["last_activity"] is None or entry.timestamp > b["last_activity"]:
-            b["last_activity"] = entry.timestamp
-            # Project path from most-recent in-window entry that has it.
-            if entry.project_path:
-                b["project_path"] = entry.project_path
-
-    if fallback_count:
-        eprint(
-            f"Warning: {fallback_count} entries lacked session_files rows "
-            "(cache may be catching up)."
+    def _project_decoder(source_path: str) -> str:
+        return _decode_escaped_cwd(
+            os.path.basename(os.path.dirname(source_path))
         )
 
-    result: list[CacheRow] = []
-    for sid, b in buckets.items():
-        # Per-model sub-buckets scoped to this session's entries.
-        model_buckets: dict[str, dict[str, Any]] = {}
-        for entry in b["entries"]:
-            mb_raw = model_buckets.setdefault(entry.model, {
-                "inputTokens": 0, "outputTokens": 0,
-                "cacheCreationTokens": 0, "cacheReadTokens": 0, "cost": 0.0,
-                "savedUsd": 0.0, "wastedUsd": 0.0, "netUsd": 0.0,
-            })
-            mb_raw["inputTokens"] += entry.input_tokens
-            mb_raw["outputTokens"] += entry.output_tokens
-            mb_raw["cacheCreationTokens"] += entry.cache_creation_tokens
-            mb_raw["cacheReadTokens"] += entry.cache_read_tokens
-            mb_raw["cost"] += _calculate_entry_cost(
-                entry.model,
-                {
-                    "input_tokens": entry.input_tokens,
-                    "output_tokens": entry.output_tokens,
-                    "cache_creation_input_tokens": entry.cache_creation_tokens,
-                    "cache_read_input_tokens": entry.cache_read_tokens,
-                },
-                mode="auto",
-                cost_usd=entry.cost_usd,
-            )
-            saved, wasted, net = _compute_entry_cache_dollars(
-                entry.model,
-                entry.cache_creation_tokens,
-                entry.cache_read_tokens,
-            )
-            mb_raw["savedUsd"] += saved
-            mb_raw["wastedUsd"] += wasted
-            mb_raw["netUsd"] += net
-
-        row = CacheRow(
-            session_id=sid,
-            project_path=b["project_path"],
-            last_activity=b["last_activity"],
-            source_paths=sorted(b["source_paths"]),
+    agg = _cctally_cache_report._aggregate_cache_by_session(
+        entries,
+        pricing=CLAUDE_MODEL_PRICING,
+        cost_calculator=_calculate_entry_cost,
+        project_decoder=_project_decoder,
+    )
+    if agg.fallback_count:
+        eprint(
+            f"Warning: {agg.fallback_count} entries lacked session_files rows "
+            "(cache may be catching up)."
         )
-        for model_name in sorted(model_buckets.keys()):
-            mb_raw = model_buckets[model_name]
-            mb = CacheModelBreakdown(
-                model_name=model_name,
-                input_tokens=mb_raw["inputTokens"],
-                output_tokens=mb_raw["outputTokens"],
-                cache_creation_tokens=mb_raw["cacheCreationTokens"],
-                cache_read_tokens=mb_raw["cacheReadTokens"],
-                cache_hit_percent=_compute_cache_hit_percent(
-                    mb_raw["inputTokens"],
-                    mb_raw["cacheCreationTokens"],
-                    mb_raw["cacheReadTokens"],
-                ),
-                cost=mb_raw["cost"],
-                saved_usd=mb_raw["savedUsd"],
-                wasted_usd=mb_raw["wastedUsd"],
-                net_usd=mb_raw["netUsd"],
-            )
-            row.model_breakdowns.append(mb)
-            row.input_tokens += mb.input_tokens
-            row.output_tokens += mb.output_tokens
-            row.cache_creation_tokens += mb.cache_creation_tokens
-            row.cache_read_tokens += mb.cache_read_tokens
-            row.cost += mb.cost
-            row.saved_usd += mb.saved_usd
-            row.wasted_usd += mb.wasted_usd
-            row.net_usd += mb.net_usd
-        result.append(row)
-
-    # Initial ordering descending by last_activity; Task 6 adds --sort and
-    # will change the session-mode default. Use tz-aware sentinel to avoid
-    # naive-vs-aware comparison errors on rows missing last_activity.
-    _min_dt = dt.datetime.min.replace(tzinfo=dt.timezone.utc)
-    result.sort(key=lambda r: r.last_activity or _min_dt, reverse=True)
-    return result
+    return agg.rows
 
 
 def _annotate_anomalies(
@@ -2532,83 +2305,20 @@ def _annotate_anomalies(
     *,
     enabled: bool = True,
 ) -> None:
-    """Mutate each row's anomaly_triggered / anomaly_reasons in place.
+    """CLI adapter: thin shim around the kernel's ``_classify_anomalies``.
 
-    Trigger 1 (net_negative): net_usd < 0 (strict). Skipped when the row has
-    zero cache activity (no-op session, not a bug).
-    Trigger 2 (cache_drop): cache_hit_percent is >= threshold_pp below the
-    trailing window_days median of OTHER rows. Requires minimum 5 (daily)
-    or 10 (session) baseline samples; silently skipped otherwise.
-
-    Mode is inferred from the first row: if it has a session_id, session
-    mode (window_days back to <= last_activity - 1s); else daily mode
-    (window_days back to <= date - 1 day).
+    Kept under the original name so the existing call site in
+    ``cmd_cache_report`` resolves unchanged. The kernel mutates each row
+    in place (same contract as the pre-extraction implementation —
+    ``anomaly_triggered`` / ``anomaly_reasons`` set on each ``CacheRow``).
     """
-    import statistics
-
-    if not enabled:
-        for row in rows:
-            row.anomaly_triggered = False
-            row.anomaly_reasons = []
-        return
-    if not rows:
-        return
-
-    # Determine mode + baseline minimum from the first row's identity.
-    is_session_mode = rows[0].session_id is not None
-    min_baseline = 10 if is_session_mode else 5
-
-    def _row_anchor(r: CacheRow) -> dt.datetime | None:
-        """Return the row's position in time for baseline-window comparison."""
-        if r.last_activity is not None:
-            return r.last_activity
-        if r.date:
-            # Use .astimezone() (not .replace(tzinfo=...)) so the OS tzdb
-            # gives the correct offset for the given date — avoids DST drift
-            # on dates that straddle a DST boundary. Mirrors the idiom in
-            # _parse_cli_date_range.
-            # internal fallback: host-local intentional
-            return dt.datetime.strptime(r.date, "%Y-%m-%d").astimezone()
-        return None
-
-    window = dt.timedelta(days=window_days)
-    upper_offset = (
-        dt.timedelta(seconds=1) if is_session_mode else dt.timedelta(days=1)
+    _cctally_cache_report._classify_anomalies(
+        rows,
+        threshold_pp=threshold_pp,
+        window_days=window_days,
+        enabled=enabled,
     )
 
-    # Pre-compute anchors once to avoid O(n^2 * datetime-parse) overhead.
-    anchors: list[dt.datetime | None] = [_row_anchor(r) for r in rows]
-
-    for i, row in enumerate(rows):
-        reasons: list[str] = []
-
-        # Trigger 1: net_negative (no baseline needed; cache-activity guard).
-        if row.cache_creation_tokens + row.cache_read_tokens > 0:
-            if row.net_usd < 0:
-                reasons.append("net_negative")
-
-        # Trigger 2: cache_drop (requires baseline).
-        anchor = anchors[i]
-        if anchor is not None:
-            lower_bound = anchor - window
-            upper_bound = anchor - upper_offset
-            baseline_values: list[float] = []
-            for j, other in enumerate(rows):
-                if j == i:
-                    continue
-                other_anchor = anchors[j]
-                if other_anchor is None:
-                    continue
-                if lower_bound <= other_anchor <= upper_bound:
-                    baseline_values.append(other.cache_hit_percent)
-            if len(baseline_values) >= min_baseline:
-                median = statistics.median(baseline_values)
-                if (median - row.cache_hit_percent) >= threshold_pp:
-                    reasons.append("cache_drop")
-
-        row.anomaly_reasons = reasons
-        row.anomaly_triggered = bool(reasons)
-
 
 @dataclass
 class WeekCostResult:
@@ -8444,7 +8154,13 @@ def cmd_cache_report(args: argparse.Namespace) -> int:
     if mode == "session":
         rows = _aggregate_cache_by_session(since, until, project=args.project)
     else:
-        rows = _aggregate_cache_by_day(since, until, project=args.project)
+        # Task A3: pass the resolved display_tz so day buckets match the
+        # ``--tz`` flag (closes the pre-existing minor bug where the
+        # window edges shifted but day buckets stayed on host-local —
+        # spec §1.6 / plan A3).
+        rows = _aggregate_cache_by_day(
+            since, until, project=args.project, display_tz=tz,
+        )
 
     if not rows:
         if args.json: