cctally 1.20.2 → 1.20.4

package/CHANGELOG.md

@@ -5,6 +5,16 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.20.4] - 2026-05-28
+
+### Changed
+- **Hardened the v1.20.3 canonical-anchor bypass in `_select_non_overlapping_recorded_windows`: provenance is now passed explicitly from the loader instead of being inferred from merged weight.** v1.20.3 identified canonical anchors as `items[*].weight >= 1000`, treating the loader's `+1000` overlay as a provenance proxy. But the merged weight is `raw_snapshot_count + (1000 if canonical else 0)`, so a raw-only bucket can also reach 1000+ under bulk-imported history or any future polling-frequency change to `record-usage`. Two such raw-only buckets <5h apart would both force-restore through the bypass and render as overlapping recorded blocks. The selector now takes an explicit `canonical_anchors` keyword set, populated by `_load_recorded_five_hour_windows` from `set(canonical_intervals.keys()) - truncated_anchors` — the loader already knows which anchors came from `five_hour_blocks`, so there's no need to re-derive provenance from weight. The DP still runs over the full item set (canonical + raw) so non-canonical phantoms adjacent to a canonical anchor in a different floor bucket continue to lose by weight comparison; the force-restore step only puts back items the caller marked canonical, never any raw-only bucket regardless of its weight. `_CANONICAL_WEIGHT_THRESHOLD = 1000` stays as the loader's overlay value (still names what dominates the DP arithmetic). No user-visible behavior change under current production data — the v1.20.3 fix already worked correctly for every real input shape we've observed — but the contract is no longer fragile to changes in polling cadence or future bulk-import surfaces. Regression: new `test_select_non_overlapping_recorded_windows_high_weight_raw_does_not_bypass` covers two raw-only items at weights 1500/1200; pre-fix returned both, post-fix DP arbitrates to one. (#116 review follow-up)
+
+## [1.20.3] - 2026-05-28
+
+### Fixed
+- **The dashboard's Blocks panel no longer renders the just-started active block with a `~` heuristic marker, and the previous block no longer silently disappears from the panel ~20 minutes after a 5h reset.** Both symptoms came from the same root cause in `_select_non_overlapping_recorded_windows`: when two genuinely-adjacent canonical 5h windows had `resets_at` values whose 10-minute-floored keys landed less than 5h apart (e.g. OLD `R=09:00:01Z` → floor `09:00`, NEW `R=13:59:59Z` → floor `13:50` — a 4h 50m floored-distance for a real block-pair with a 2-second sub-second overlap on the boundary), the weighted-interval-scheduling DP treated them as conflicting and dropped the lighter-weighted one. At `t≈0` after a reset that meant the NEW canonical window vanished from the selector's output, so the dashboard's Blocks panel partitioned NEW-window entries into the heuristic leftover bucket and rendered them with `anchor='heuristic'` and a `_floor_to_hour` `start_at` (the `~` chip in `BlocksPanel.tsx:33-34`); ~20 minutes later, once the NEW window's snapshot count caught up, the DP would flip and drop OLD instead, making the previous block silently disappear. CLI `cctally blocks --active` was unaffected (it queries `five_hour_blocks` directly with `is_closed=0`, bypassing this scheduler). Fix: any item carrying the canonical-source weight overlay (`_CANONICAL_WEIGHT_THRESHOLD = 1000`) is force-restored to the result set if the DP dropped it — `maybe_update_five_hour_block` already deduplicated via `_canonical_5h_window_key` pre-insert, so two canonical rows are by definition non-overlapping physically and don't need re-arbitration on a floor-distance check. The DP still runs over the full item set (canonical + raw), so a non-canonical phantom R adjacent to a canonical anchor in a different floor bucket continues to lose by weight comparison; the bypass only restores canonical items, never adds back a raw-only phantom. (#116)
+
 ## [1.20.2] - 2026-05-28
 
 ### Fixed

package/bin/cctally

@@ -3951,11 +3951,27 @@ def _resolve_block_selector(
     return dict(row) if row else None
 
 
+# Weight overlay applied per canonical (``five_hour_blocks``) row by
+# ``_load_recorded_five_hour_windows``: ``counts[snapped] += _CANONICAL_WEIGHT_THRESHOLD``.
+# Gives canonical anchors dominant weight inside the
+# ``_select_non_overlapping_recorded_windows`` DP, so any non-canonical
+# phantom adjacent to a canonical anchor loses on weight comparison. NOT
+# used as a provenance check — the selector takes an explicit
+# ``canonical_anchors`` set from the loader for the force-restore bypass
+# (issue #116 review follow-up: raw-only buckets with bulk-imported /
+# high-frequency snapshot histories can also accumulate >= 1000 weight,
+# so the threshold conflates provenance with support count).
+_CANONICAL_WEIGHT_THRESHOLD = 1000
+
+
 def _select_non_overlapping_recorded_windows(
     items: list[tuple[dt.datetime, int]],
+    *,
+    canonical_anchors: set[dt.datetime] | None = None,
 ) -> list[dt.datetime]:
     """Pick the max-weight subset of recorded ``R`` values that respect
-    the 5h non-overlap constraint.
+    the 5h non-overlap constraint, with canonical anchors guaranteed
+    to survive.
 
     Anthropic 5h windows cannot truly overlap: the next window only
     opens once the previous one resets, so consecutive real ``R``
@@ -3968,8 +3984,31 @@ def _select_non_overlapping_recorded_windows(
     snapshots: the subset that maximizes total support wins. Tie-break
     in the take branch favors including more ``R`` values.
 
+    Canonical bypass (issue #116): any ``R`` passed in ``canonical_anchors``
+    came from the authoritative ``five_hour_blocks`` rollup.
+    ``maybe_update_five_hour_block`` already deduped via
+    ``_canonical_5h_window_key`` pre-insert, so two canonical rows are
+    by definition non-overlapping physically — they only appear "in
+    conflict" here when their 10-min-floored keys land less than
+    ``BLOCK_DURATION`` apart, which happens at every real reset
+    boundary when Anthropic's ``resets_at`` jitters sub-second across
+    the boundary (e.g. OLD ``R=09:00:01Z`` floors to ``09:00``, NEW
+    ``R=13:59:59Z`` floors to ``13:50`` — 4h 50m floored-distance for
+    a genuinely-adjacent block pair). The DP still runs over the full
+    item set so non-canonical phantoms next to a canonical anchor get
+    dropped by weight comparison; the canonical-bypass only force-
+    restores anchors the caller marked canonical, never adds back a
+    raw-only phantom (even one whose raw weight ≥ ``_CANONICAL_WEIGHT_THRESHOLD``
+    — the v1.20.3 fix used weight as a provenance proxy, which the
+    review correctly flagged as conflating support count with provenance).
+
     Args:
       items: ``(R, support_count)`` pairs.
+      canonical_anchors: explicit set of ``R`` values sourced from
+        ``five_hour_blocks``. Any present in ``items`` is guaranteed to
+        appear in the result, even if the DP dropped it on the 5h
+        non-overlap constraint. ``None`` / empty set = pure DP behavior
+        (no bypass).
 
     Returns:
       Sorted ascending list of selected ``R`` values.
@@ -4012,6 +4051,14 @@ def _select_non_overlapping_recorded_windows(
         else:
             i -= 1
     chosen.reverse()
+    # Canonical bypass: force-restore any canonical anchor the DP dropped
+    # (issue #116). Intersect with items' keys so a caller passing anchors
+    # outside the item set can't corrupt the result.
+    if canonical_anchors:
+        items_keys = {R for R, _ in items_sorted}
+        present_canonical = canonical_anchors & items_keys
+        if present_canonical and not present_canonical.issubset(chosen):
+            return sorted(set(chosen) | present_canonical)
     return chosen
 
 
@@ -4297,13 +4344,21 @@ def _load_recorded_five_hour_windows(
         # (only credit-truncated entries land there).
         if snapped in block_start_overrides:
             truncated_anchors.add(snapped)
-        counts[snapped] = counts.get(snapped, 0) + 1000
+        counts[snapped] = counts.get(snapped, 0) + _CANONICAL_WEIGHT_THRESHOLD
 
     non_truncated_items = [
         (a, w) for a, w in counts.items() if a not in truncated_anchors
     ]
+    # Pass canonical provenance explicitly: every key currently in
+    # canonical_intervals came from a `five_hour_blocks` row (raw-only
+    # buckets never land in this map). Subtract truncated_anchors because
+    # those bypass the DP via the separate merge below — keeping them
+    # out of canonical_anchors here is a no-op for correctness but
+    # mirrors the same scope as non_truncated_items for clarity.
+    canonical_anchors_for_dp = set(canonical_intervals.keys()) - truncated_anchors
     selected_non_truncated = _select_non_overlapping_recorded_windows(
-        non_truncated_items
+        non_truncated_items,
+        canonical_anchors=canonical_anchors_for_dp,
     )
     # Merge truncated anchors back in, sorted ascending. Their non-
     # overlap with the surrounding canonical blocks is guaranteed by

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cctally",
-  "version": "1.20.2",
+  "version": "1.20.4",
   "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": {