cctally 1.20.2 → 1.20.3

package/CHANGELOG.md

@@ -5,6 +5,11 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [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,21 @@ def _resolve_block_selector(
     return dict(row) if row else None
 
 
+# Items in `_select_non_overlapping_recorded_windows` whose weight is
+# >= this threshold are treated as canonical (sourced from
+# ``five_hour_blocks``) and bypass the 5h non-overlap constraint. Must
+# stay in sync with the ``counts[snapped] = counts.get(snapped, 0) + 1000``
+# overlay in ``_load_recorded_five_hour_windows`` — same constant, same
+# meaning. Issue #116.
+_CANONICAL_WEIGHT_THRESHOLD = 1000
+
+
 def _select_non_overlapping_recorded_windows(
     items: list[tuple[dt.datetime, int]],
 ) -> 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,6 +3978,23 @@ 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 item with weight at least
+    ``_CANONICAL_WEIGHT_THRESHOLD`` came from the authoritative
+    ``five_hour_blocks`` rollup (the caller overlays at +1000).
+    ``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 canonical items the DP dropped, never adds back a raw-
+    only phantom.
+
     Args:
       items: ``(R, support_count)`` pairs.
 
@@ -4012,6 +4039,11 @@ def _select_non_overlapping_recorded_windows(
         else:
             i -= 1
     chosen.reverse()
+    # Canonical bypass: force-restore any canonical-weight anchor the DP
+    # dropped (issue #116). Keep the result sorted ascending.
+    canonical = {R for R, w in items_sorted if w >= _CANONICAL_WEIGHT_THRESHOLD}
+    if canonical and not canonical.issubset(chosen):
+        return sorted(set(chosen) | canonical)
     return chosen
 
 
@@ -4297,7 +4329,7 @@ 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

package/package.json

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