cctally 1.7.1 → 1.7.2

package/bin/_cctally_record.py

@@ -398,7 +398,31 @@ def maybe_record_milestone(
 
     conn = open_db()
     try:
-        max_existing = get_max_milestone_for_week(conn, week_start_date)
+        # Resolve the active segment for THIS captured moment. The segment
+        # is the latest week_reset_events row keyed on week_end_at whose
+        # effective_reset_at_utc <= captured_at; 0 = pre-credit / no-event
+        # sentinel. ``unixepoch()`` normalizes the comparison across mixed
+        # +00:00 / Z offsets (see precedent at bin/cctally:_compute_block_totals
+        # cross-reset detection; also project gotcha
+        # ``unixepoch_for_cross_offset_compare``).
+        captured_at_iso = saved.get("capturedAt") or now_utc_iso()
+        reset_event_id = 0
+        if week_end_at:
+            seg_row = conn.execute(
+                """
+                SELECT id FROM week_reset_events
+                 WHERE new_week_end_at = ?
+                   AND unixepoch(effective_reset_at_utc) <= unixepoch(?)
+                 ORDER BY id DESC LIMIT 1
+                """,
+                (week_end_at, captured_at_iso),
+            ).fetchone()
+            if seg_row is not None:
+                reset_event_id = int(seg_row["id"])
+
+        max_existing = get_max_milestone_for_week(
+            conn, week_start_date, reset_event_id=reset_event_id,
+        )
         if max_existing is not None and current_floor <= max_existing:
             return
 
@@ -482,7 +506,10 @@ def maybe_record_milestone(
         pending_alerts: list[dict[str, Any]] = []
         for pct in range(start_threshold, current_floor + 1):
             if pct == start_threshold and max_existing is not None:
-                prev_cost = get_milestone_cost_for_week(conn, week_start_date, max_existing)
+                prev_cost = get_milestone_cost_for_week(
+                    conn, week_start_date, max_existing,
+                    reset_event_id=reset_event_id,
+                )
                 marginal = (cumulative_cost - prev_cost) if prev_cost is not None else None
             else:
                 marginal = None
@@ -499,6 +526,7 @@ def maybe_record_milestone(
                 cost_snapshot_id=cost_snapshot_id,
                 five_hour_percent_at_crossing=five_hour_percent,
                 commit=False,
+                reset_event_id=reset_event_id,
             )
             # ── Threshold-actions dispatch (set-then-dispatch, spec §3.2) ──
             # Only the genuine-new-crossing winner (rowcount==1) reaches this
@@ -523,17 +551,22 @@ def maybe_record_milestone(
                     conn.execute(
                         "UPDATE percent_milestones SET alerted_at = ? "
                         "WHERE week_start_date = ? AND percent_threshold = ? "
-                        "AND alerted_at IS NULL",
-                        (crossed_at, week_start_date, pct),
+                        "  AND reset_event_id = ? "
+                        "  AND alerted_at IS NULL",
+                        (crossed_at, week_start_date, pct, reset_event_id),
                     )
                     # Cheap re-read for payload context (cumulative_cost_usd
                     # reflects the value persisted on insert, immune to any
                     # subsequent recompute drift). SELECT inside the open
                     # transaction is fine; values reflect post-INSERT state.
+                    # Filter by reset_event_id so a credited week's
+                    # alert payload reads the post-credit row, not a
+                    # stale pre-credit row at the same (week, threshold).
                     row = conn.execute(
                         "SELECT cumulative_cost_usd FROM percent_milestones "
-                        "WHERE week_start_date = ? AND percent_threshold = ?",
-                        (week_start_date, pct),
+                        "WHERE week_start_date = ? AND percent_threshold = ? "
+                        "  AND reset_event_id = ?",
+                        (week_start_date, pct, reset_event_id),
                     ).fetchone()
                     if row is not None:
                         cum = float(row["cumulative_cost_usd"])
@@ -1305,9 +1338,9 @@ def cmd_record_usage(args: argparse.Namespace) -> int:
                     prior["week_end_at"], "record.prior"
                 )
                 prior_pct = prior["weekly_percent"]
+                now_utc = dt.datetime.now(dt.timezone.utc)
                 if prior_end_canon and prior_end_canon != cur_end_canon:
                     prior_end_dt = parse_iso_datetime(prior_end_canon, "prior.week_end_at")
-                    now_utc = dt.datetime.now(dt.timezone.utc)
                     # Fire only when (a) prior window was still in the FUTURE
                     # (Anthropic shifted the boundary before natural expiration),
                     # AND (b) weekly_percent dropped by RESET_PCT_DROP_THRESHOLD
@@ -1331,15 +1364,149 @@ def cmd_record_usage(args: argparse.Namespace) -> int:
                              effective_iso),
                         )
                         conn.commit()
+                elif prior_end_canon and prior_end_canon == cur_end_canon:
+                    # In-place credit branch (v1.7.2). When `resets_at` stays
+                    # unchanged but `weekly_percent` drops by RESET_PCT_DROP_THRESHOLD
+                    # or more, Anthropic has issued a goodwill in-place weekly
+                    # credit. Emit one week_reset_events row keyed on the
+                    # current end_at (old == new) so the reset-aware clamp
+                    # above and the milestone segment writer can pivot to
+                    # the post-credit segment. The seed snapshot lands via
+                    # the now-reset-aware clamp on this same call.
+                    prior_end_dt = parse_iso_datetime(prior_end_canon, "prior.week_end_at")
+                    if (
+                        prior_end_dt > now_utc
+                        and prior_pct is not None
+                        and (float(prior_pct) - float(weekly_percent)) >= c._RESET_PCT_DROP_THRESHOLD
+                    ):
+                        # Pre-check (Q5 belt-and-suspenders): suppress duplicate
+                        # event rows for the same new_week_end_at across
+                        # consecutive ticks. UNIQUE(old, new) at the DDL
+                        # also catches the duplicate in the (old == new) case,
+                        # but the pre-check avoids a useless write attempt
+                        # and keeps the log clean. After the seed lands at
+                        # post-credit %, the next tick's `prior_pct` will be
+                        # the post-credit value so the drop predicate alone
+                        # also suffices — pre-check is belt-and-suspenders.
+                        already = conn.execute(
+                            "SELECT 1 FROM week_reset_events "
+                            "WHERE new_week_end_at = ? LIMIT 1",
+                            (cur_end_canon,),
+                        ).fetchone()
+                        if already is None:
+                            effective_dt = _floor_to_hour(now_utc)
+                            effective_iso = effective_dt.isoformat(timespec="seconds")
+                            # Row shape: old=effective_iso, new=cur_end_canon
+                            # (distinct values). The previous shape stored
+                            # old==new==cur_end_canon, which let BOTH
+                            # _apply_reset_events_to_weekrefs maps
+                            # (pre_map[old] and post_map[new]) fire on the
+                            # SAME WeekRef — pre_map rewrote week_end_at to
+                            # effective, post_map rewrote week_start_at to
+                            # effective, collapsing the credited week to a
+                            # zero-width window in downstream renders. With
+                            # old==effective and new==cur_end_canon, only
+                            # post_map fires on the credited week (setting
+                            # week_start_at = effective, the intended
+                            # behavior); pre_map keys on effective_iso and
+                            # finds no matching WeekRef in practice. The
+                            # UNIQUE(old, new) constraint permits this
+                            # row, and the pre-check above keys on
+                            # new_week_end_at so dedup still works.
+                            conn.execute(
+                                "INSERT OR IGNORE INTO week_reset_events "
+                                "(detected_at_utc, old_week_end_at, new_week_end_at, "
+                                " effective_reset_at_utc) VALUES (?, ?, ?, ?)",
+                                (now_utc_iso(), effective_iso, cur_end_canon,
+                                 effective_iso),
+                            )
+                            conn.commit()
+                            # Force-write hwm-7d so the next status-line
+                            # render reflects the post-credit value. The
+                            # monotonic guard at the normal write site (below)
+                            # would refuse to decrease the file; this write
+                            # is the credit-only escape hatch. Lands AFTER
+                            # the conn.commit() so a concurrent record-usage
+                            # reader doesn't see the new HWM before the
+                            # event row is durable.
+                            try:
+                                (c.APP_DIR / "hwm-7d").write_text(
+                                    f"{week_start_date} {weekly_percent}\n"
+                                )
+                            except OSError:
+                                pass
+
+                            # Race-defensive cleanup. Between the moment
+                            # Anthropic credited the user (effective_iso)
+                            # and this code firing, the EXTERNAL
+                            # claude-statusline tool can replay stale
+                            # pre-credit `--percent` values (it has its
+                            # own in-memory HWM cache and re-runs us once
+                            # per status-line tick). Those replays land
+                            # captured_at_utc >= effective_iso with
+                            # weekly_percent == prior_pct (the pre-credit
+                            # value), and they dominate the reset-aware
+                            # clamp's MAX over the post-credit segment so
+                            # legitimate fresh OAuth values are rejected.
+                            # Strict equality (round(.,1)) keeps this
+                            # narrow: we only delete rows whose percent
+                            # exactly matches the pre-credit value we just
+                            # observed — legitimate post-credit climbs
+                            # past `prior_pct` (rare, but possible if the
+                            # credit is small + activity is heavy) stay.
+                            try:
+                                conn.execute(
+                                    "DELETE FROM weekly_usage_snapshots "
+                                    "WHERE week_start_date = ? "
+                                    "  AND unixepoch(captured_at_utc) >= "
+                                    "      unixepoch(?) "
+                                    "  AND round(weekly_percent, 1) = "
+                                    "      round(?, 1)",
+                                    (week_start_date, effective_iso,
+                                     float(prior_pct)),
+                                )
+                                conn.commit()
+                            except sqlite3.DatabaseError as exc:
+                                eprint(
+                                    "[record-usage] post-credit cleanup "
+                                    f"failed: {exc}"
+                                )
         except (sqlite3.DatabaseError, ValueError) as exc:
             eprint(f"[record-usage] reset-event detection failed: {exc}")
 
-        # 7-day usage is monotonically non-decreasing within a billing week.
-        # A lower value means stale rate-limit data from a previous API call;
-        # skip the insert to avoid regressing the reported usage.
+        # 7-day usage is monotonically non-decreasing within a billing week
+        # — UNTIL Anthropic issues an in-place weekly credit. When a
+        # week_reset_events row exists for THIS week_end_at, the MAX query
+        # filters to samples captured at-or-after the segment's
+        # effective_reset_at_utc so a fresh post-credit OAuth value (e.g.
+        # 2%) lands instead of being held back by stale pre-credit history
+        # (e.g. 67%). When no event row exists, COALESCE defaults to
+        # epoch-zero so the filter is a no-op and legacy clamp behavior
+        # is preserved byte-identically.
+        # NB: comparison wrapped with ``unixepoch()`` on BOTH sides.
+        # ``captured_at_utc`` is stored with `Z` suffix, but
+        # ``effective_reset_at_utc`` may have a non-UTC offset on
+        # historical backfill rows written before Bug 3 was fixed
+        # (parse_iso_datetime returned host-local). Lex string compare
+        # on mixed offsets silently mis-orders moments for non-UTC
+        # hosts (CLAUDE.md gotcha: 5h-block cross-reset flag — "all
+        # comparisons go through unixepoch(), NOT lex
+        # BETWEEN/`<`/`>`"). Same rule applies here.
         max_row = conn.execute(
-            "SELECT MAX(weekly_percent) AS v FROM weekly_usage_snapshots WHERE week_start_date = ?",
-            (week_start_date,),
+            """
+            SELECT MAX(weekly_percent) AS v
+              FROM weekly_usage_snapshots
+             WHERE week_start_date = ?
+               AND unixepoch(captured_at_utc) >= unixepoch(COALESCE(
+                 (SELECT effective_reset_at_utc
+                    FROM week_reset_events
+                   WHERE new_week_end_at = ?
+                   ORDER BY id DESC
+                   LIMIT 1),
+                 '1970-01-01T00:00:00Z'
+               ))
+            """,
+            (week_start_date, week_end_at),
         ).fetchone()
         if max_row and max_row["v"] is not None and round(weekly_percent, 1) < round(float(max_row["v"]), 1):
             should_insert = False
@@ -1426,11 +1593,29 @@ def cmd_record_usage(args: argparse.Namespace) -> int:
                 )
                 need_milestone_heal = False
                 if latest_floor >= 1:
+                    # v1.7.2: scope the heal probe to the ACTIVE segment.
+                    # Without this, a credited week's MAX over the whole
+                    # ledger would still read the pre-credit ceiling
+                    # (e.g. 67%) and silently suppress the post-credit
+                    # ledger's heal even though it has zero rows.
+                    captured_at_for_probe = latest_row["captured_at_utc"]
+                    week_end_at_for_probe = latest_row["week_end_at"]
+                    heal_segment = 0
+                    if week_end_at_for_probe and captured_at_for_probe:
+                        seg = heal_conn.execute(
+                            "SELECT id FROM week_reset_events "
+                            "WHERE new_week_end_at = ? "
+                            "  AND unixepoch(effective_reset_at_utc) <= unixepoch(?) "
+                            "ORDER BY id DESC LIMIT 1",
+                            (week_end_at_for_probe, captured_at_for_probe),
+                        ).fetchone()
+                        if seg is not None:
+                            heal_segment = int(seg["id"])
                     max_existing = heal_conn.execute(
                         "SELECT MAX(percent_threshold) AS m "
                         "FROM percent_milestones "
-                        "WHERE week_start_date = ?",
-                        (week_start_date,),
+                        "WHERE week_start_date = ? AND reset_event_id = ?",
+                        (week_start_date, heal_segment),
                     ).fetchone()
                     if max_existing is None or max_existing["m"] is None:
                         need_milestone_heal = True

package/bin/_cctally_tui.py

@@ -317,6 +317,10 @@ def get_milestones_for_week(*args, **kwargs):
     return sys.modules["cctally"].get_milestones_for_week(*args, **kwargs)
 
 
+def _canonicalize_optional_iso(*args, **kwargs):
+    return sys.modules["cctally"]._canonicalize_optional_iso(*args, **kwargs)
+
+
 def get_recent_weeks(*args, **kwargs):
     return sys.modules["cctally"].get_recent_weeks(*args, **kwargs)
 
@@ -949,7 +953,8 @@ class TuiPercentMilestone:
 def _tui_build_percent_milestones(
     conn: sqlite3.Connection,
 ) -> list[TuiPercentMilestone]:
-    """Return per-percent crossings for the current week, ascending by percent.
+    """Return per-percent crossings for the current week's ACTIVE
+    segment, ascending by percent.
 
     Resolves `week_start_date` from the latest `weekly_usage_snapshots` row
     — the same path `cmd_percent_breakdown` takes. The post-override
@@ -957,15 +962,55 @@ def _tui_build_percent_milestones(
     reset, `_apply_midweek_reset_override` shifts that datetime forward to
     the reset instant, whose `.date()` no longer matches the `week_start_date`
     under which milestones were recorded.
-    Returns [] if no usage snapshot (or no milestone) exists.
+
+    v1.7.2: when a `week_reset_events` row exists for the snapshot's
+    `week_end_at`, narrow to the active segment so the dashboard /
+    TUI milestone panel stays coherent with the already-credit-aware
+    header. ``active_segment = 0`` (sentinel) preserves legacy
+    behavior on un-credited weeks.
+
+    Returns [] if no usage snapshot exists, OR if the active segment
+    has no milestone rows yet (post-credit "fresh" state).
     """
     latest = conn.execute(
-        "SELECT week_start_date FROM weekly_usage_snapshots "
+        "SELECT week_start_date, week_end_at FROM weekly_usage_snapshots "
+        "WHERE week_end_at IS NOT NULL "
         "ORDER BY captured_at_utc DESC, id DESC LIMIT 1"
     ).fetchone()
     if latest is None:
-        return []
-    rows = get_milestones_for_week(conn, latest["week_start_date"])
+        # Legacy fallback: a snapshot without week_end_at can still have
+        # milestones — keep the prior behavior in that path.
+        latest = conn.execute(
+            "SELECT week_start_date, NULL AS week_end_at "
+            "FROM weekly_usage_snapshots "
+            "ORDER BY captured_at_utc DESC, id DESC LIMIT 1"
+        ).fetchone()
+        if latest is None:
+            return []
+
+    # Resolve active segment via the canonical end_at.
+    active_segment = 0
+    if latest["week_end_at"]:
+        try:
+            canon_end = _canonicalize_optional_iso(
+                latest["week_end_at"], "tui.pm.cur"
+            )
+        except (AttributeError, ValueError):
+            canon_end = None
+        if canon_end:
+            seg_row = conn.execute(
+                "SELECT id FROM week_reset_events "
+                "WHERE new_week_end_at = ? "
+                "ORDER BY id DESC LIMIT 1",
+                (canon_end,),
+            ).fetchone()
+            if seg_row is not None:
+                active_segment = int(seg_row["id"])
+
+    rows = [
+        r for r in get_milestones_for_week(conn, latest["week_start_date"])
+        if int(r["reset_event_id"] or 0) == active_segment
+    ]
     out: list[TuiPercentMilestone] = []
     for r in rows:
         try:
@@ -1423,27 +1468,71 @@ def _tui_build_trend(
     columns (`week_start_at`, `used_pct`, `dollars_per_percent`) matches
     `cmd_report` byte-for-byte — verified in the bundle regression diff.
     """
-    # `get_recent_weeks` returns WeekRef rows DESC by week_start_date.
+    # `get_recent_weeks` returns WeekRef rows DESC by week_start_date,
+    # already routed through `_apply_reset_events_to_weekrefs` so credited
+    # weeks come back as TWO refs (pre-credit + post-credit) sharing the
+    # same `WeekRef.key`.
     week_refs = get_recent_weeks(conn, max(1, count))
 
     # Figure out which week_ref corresponds to the current subscription week.
-    # Uses the same key derivation `cmd_report` does — latest usage snapshot's
-    # week_start_date, canonicalized through `_get_canonical_boundary_for_date`.
+    # Mirrors `cmd_report`'s Bug D pattern: build a current_ref from the
+    # latest usage snapshot, route it through `_apply_reset_events_to_weekrefs`
+    # so its `week_start_at` reflects the post-credit segment (or the
+    # original start for non-credit weeks), then disambiguate the
+    # synthesized pre-credit ref from the live post-credit ref via BOTH
+    # `key` AND `week_start_at`. Key-only equality marks both segments
+    # as current, which is why the dashboard's trend panel previously
+    # showed two adjacent rows both highlighted as "current" with
+    # identical 4.0% values on the user's live in-place credit data.
     latest_usage = conn.execute(
         "SELECT week_start_date, week_end_date "
         "FROM weekly_usage_snapshots "
         "ORDER BY captured_at_utc DESC, id DESC LIMIT 1"
     ).fetchone()
     current_key: str | None = None
-    if latest_usage is not None:
+    current_week_start_at: str | None = None
+    if latest_usage is not None and latest_usage["week_start_date"] is not None:
         current_key = latest_usage["week_start_date"]
+        try:
+            c = _cctally()
+            canon_start, canon_end = c._get_canonical_boundary_for_date(
+                conn, latest_usage["week_start_date"]
+            )
+            current_ref = c.make_week_ref(
+                week_start_date=latest_usage["week_start_date"],
+                week_end_date=latest_usage["week_end_date"],
+                week_start_at=canon_start,
+                week_end_at=canon_end,
+            )
+            _adjusted = c._apply_reset_events_to_weekrefs(conn, [current_ref])
+            if _adjusted:
+                current_week_start_at = _adjusted[0].week_start_at
+        except (ValueError, sqlite3.DatabaseError, AttributeError):
+            current_week_start_at = None
 
     # Build an intermediate list of (week_ref, used_pct, dpp) in oldest-first
     # chronological order.
     chrono = list(reversed(week_refs))
+    # Split-key set (Bug D): credited weeks appear twice in `week_refs`
+    # with identical `WeekRef.key`. For those keys ONLY, pin
+    # `as_of_utc=week_ref.week_end_at` so each segment finds its own
+    # latest snapshot — without this both segments collapse to the
+    # post-credit snapshot's weekly_percent. Non-credit weeks (single
+    # ref per key) keep the legacy unfiltered lookup.
+    _split_keys = {
+        r.key
+        for r in week_refs
+        if sum(1 for x in week_refs if x.key == r.key) > 1
+    }
     intermediate: list[tuple[Any, float | None, float | None]] = []
     for week_ref in chrono:
-        usage = get_latest_usage_for_week(conn, week_ref)
+        usage = get_latest_usage_for_week(
+            conn,
+            week_ref,
+            as_of_utc=(
+                week_ref.week_end_at if week_ref.key in _split_keys else None
+            ),
+        )
         # See cmd_report for why reset-affected weeks skip the cost cache
         # and live-compute from session_entries over the effective range.
         if _week_ref_has_reset_event(conn, week_ref):
@@ -1491,6 +1580,23 @@ def _tui_build_trend(
             # localizing midnight-UTC doesn't shift it to the prior day in
             # zones west of UTC (e.g. 2026-04-14 → "Apr 13" in America/New_York).
             week_label = week_ref.week_start.strftime("%b %d")
+        # Bug G (v1.7.2 round-5): match on BOTH `key` AND `week_start_at`
+        # for credited weeks so the pre-credit synthesized ref doesn't
+        # also light up as "current" — both refs share `key`, only their
+        # `week_start_at` differs (post-credit = effective reset moment,
+        # pre-credit = original API-derived start). Non-credit weeks
+        # have only one ref per key so `week_start_at` matching is
+        # automatic. When `current_week_start_at` is None (no reset
+        # event for the current week, or the resolution above failed),
+        # falls back to legacy key-only matching.
+        is_cur = (
+            current_key is not None
+            and week_ref.key == current_key
+            and (
+                current_week_start_at is None
+                or week_ref.week_start_at == current_week_start_at
+            )
+        )
         out.append(TuiTrendRow(
             week_label=week_label,
             week_start_at=week_start_dt,
@@ -1502,7 +1608,7 @@ def _tui_build_trend(
             dollars_per_percent=dpp,
             delta_dpp=delta,
             spark_height=spark,
-            is_current=(current_key is not None and week_ref.key == current_key),
+            is_current=is_cur,
         ))
         if dpp is not None:
             prev_dpp = dpp

package/bin/_lib_blocks.py

@@ -94,6 +94,7 @@ def _group_entries_into_blocks(
     mode: str = "auto",
     *,
     recorded_windows: list[dt.datetime] | None = None,
+    block_start_overrides: dict[dt.datetime, dt.datetime] | None = None,
     now: dt.datetime | None = None,
 ) -> list[Block]:
     """Group sorted UsageEntry objects into 5-hour blocks with gap detection.
@@ -106,6 +107,18 @@ def _group_entries_into_blocks(
     into per-R buckets and built as 'recorded' blocks. Leftover entries
     run through the existing gap-detection heuristic (anchor='heuristic').
 
+    `block_start_overrides` (v1.7.2 round-5 / Bug J): an optional
+    `{R → block_start_at}` map. When present for a given R, the
+    recorded block's displayed ``start_time`` becomes the override
+    instead of the default ``R - BLOCK_DURATION``. Used by
+    ``_load_recorded_five_hour_windows`` to preserve the real
+    ``five_hour_blocks.block_start_at`` for credit-truncated windows
+    (an in-place credit shortens the prior 5h block's effective end
+    to the credit moment, but the block's API-derived START is
+    unchanged — without an override the renderer would compute
+    ``start = truncated_R - 5h`` which is hours before the real start
+    and confuses the user with an off-by-hours window header).
+
     `now` pins the current instant (typically via `_command_as_of()`). When
     omitted, falls back to wall clock so existing callers are unaffected.
     """
@@ -117,13 +130,22 @@ def _group_entries_into_blocks(
         now = dt.datetime.now(dt.timezone.utc)
 
     recorded_windows = sorted(recorded_windows or [])
+    block_start_overrides = block_start_overrides or {}
 
     # ── Partition entries by recorded windows ──────────────────────────
     # For each R in recorded_windows, entries whose timestamp falls in
-    # [R - BLOCK_DURATION, R) go into recorded_buckets[R]. Everything else
-    # (gaps between recorded windows, or fully outside any window) drops
-    # into `leftover` and runs through the existing heuristic grouper.
-    # Task 5 will consume recorded_buckets; for now it is built but unused.
+    # [override_start_or_R-5h, R) go into recorded_buckets[R]. Everything
+    # else (gaps between recorded windows, or fully outside any window)
+    # drops into `leftover` and runs through the existing heuristic
+    # grouper.
+    #
+    # Why override_start_or_R-5h, not always R-5h: a credit-truncated
+    # canonical block has R = effective_reset_at_utc (e.g. 17:58Z) but
+    # its real ``block_start_at`` is unchanged (e.g. 15:50Z). Using
+    # `R - 5h` as the partition floor would pull entries from earlier
+    # blocks (e.g. 12:58-15:50Z range) into the truncated bucket. The
+    # override keeps the real start so each entry lands in the bucket
+    # whose API-defined interval actually contains it.
     recorded_buckets: dict[dt.datetime, list[UsageEntry]] = {
         R: [] for R in recorded_windows
     }
@@ -132,7 +154,8 @@ def _group_entries_into_blocks(
         idx = bisect.bisect_right(recorded_windows, entry.timestamp)
         if idx < len(recorded_windows):
             R = recorded_windows[idx]
-            if R - BLOCK_DURATION <= entry.timestamp:
+            bucket_start = block_start_overrides.get(R, R - BLOCK_DURATION)
+            if bucket_start <= entry.timestamp:
                 recorded_buckets[R].append(entry)
                 continue
         leftover.append(entry)
@@ -193,7 +216,11 @@ def _group_entries_into_blocks(
         bucket = recorded_buckets[R]
         if not bucket:
             continue
-        start_time = R - BLOCK_DURATION
+        # Display start: override when present (credit-truncated
+        # canonical blocks need their real block_start_at so the
+        # rendered window header matches Anthropic's actual interval);
+        # default to R - BLOCK_DURATION for normal canonical anchors.
+        start_time = block_start_overrides.get(R, R - BLOCK_DURATION)
         end_time = R
         bucket_sorted = sorted(bucket, key=lambda e: e.timestamp)
         blk = _build_activity_block(

package/bin/_lib_doctor.py

@@ -60,6 +60,19 @@ class DoctorState:
     # skipped/failed/pending or (b) a buggy writer slipped through
     # after the migration ran.
     forked_bucket_counts: Optional[dict]
+    # v1.7.2 credited-week tracking. Each entry is a dict with:
+    #   * ``week_start_date``   — the credited week's bucket key
+    #   * ``latest_weekly_percent`` — most recent weekly_percent for that
+    #     week (used to gate the WARN — a credit + 0% means the user
+    #     hasn't started the new segment yet, which is the EXPECTED
+    #     state and shouldn't warn)
+    #   * ``post_credit_milestone_count`` — count of percent_milestones
+    #     rows with ``reset_event_id`` matching the credit event for
+    #     this week
+    # None means the stats.db couldn't be opened to gather; check
+    # degrades to OK rather than FAIL (consistent with the rest of
+    # the doctor kernel's degradation posture).
+    credited_weeks: Optional[list[dict]]
     codex_entries_count: Optional[int]
     codex_last_entry_at: Optional[dt.datetime]
     codex_jsonl_present: bool
@@ -559,6 +572,71 @@ def _check_data_forked_buckets(s: DoctorState) -> CheckResult:
 
 
 
+def _check_data_post_credit_milestones(s: DoctorState) -> CheckResult:
+    """Invariant: for every week with a ``week_reset_events`` row whose
+    ``effective_reset_at_utc`` is in the past AND latest_weekly_percent
+    >= 1.0, the percent_milestones ledger should have at least one row
+    in the credit's segment.
+
+    Pre-v1.7.2 the milestone writer didn't know about segments, so a
+    credited week could have a non-empty pre-credit ledger but zero
+    post-credit rows even after the user's usage climbed past 1%. This
+    check surfaces that drift as a WARN (informational; no remediation
+    — the next ``record-usage`` tick at >=1% will self-heal via the
+    segment-aware probe).
+
+    OK (silent) when:
+      * No credited weeks exist (state.credited_weeks is empty/None).
+      * Every credited week has at least one post-credit milestone row
+        OR latest_weekly_percent < 1.0 (= "new segment not started yet,
+        which is expected on a fresh credit").
+    """
+    weeks = s.credited_weeks
+    if weeks is None:
+        # Gather failed (stats.db open error). Don't double-warn; the
+        # db.stats.file check already covers DB-open issues.
+        return CheckResult(
+            id="data.post_credit_milestones",
+            title="Post-credit milestones",
+            severity="ok",
+            summary="no data",
+            remediation=None,
+            details={"reason": "credited_weeks gather returned None"},
+        )
+    stuck = [
+        w for w in weeks
+        if float(w.get("latest_weekly_percent") or 0.0) >= 1.0
+        and int(w.get("post_credit_milestone_count") or 0) == 0
+    ]
+    if not stuck:
+        return CheckResult(
+            id="data.post_credit_milestones",
+            title="Post-credit milestones",
+            severity="ok",
+            summary=(
+                f"{len(weeks)} credited week(s); all tracked"
+                if weeks else "no credited weeks"
+            ),
+            remediation=None,
+            details={"credited_weeks": len(weeks)},
+        )
+    starts = ", ".join(sorted(w["week_start_date"] for w in stuck))
+    return CheckResult(
+        id="data.post_credit_milestones",
+        title="Post-credit milestones",
+        severity="warn",
+        summary=(
+            f"{len(stuck)} credited week(s) with no post-credit milestone "
+            f"crossings yet: {starts}"
+        ),
+        remediation=None,
+        details={
+            "stuck_week_count": len(stuck),
+            "stuck_week_starts": [w["week_start_date"] for w in stuck],
+        },
+    )
+
+
 _LOOPBACK_HOSTS = frozenset({"loopback", "127.0.0.1", "::1", "localhost"})
 
 
@@ -786,6 +864,7 @@ _CATEGORY_DEFINITIONS: tuple[tuple[str, str, tuple[tuple[str, str], ...]], ...]
         ("data.cache_sync_state", "_check_data_cache_sync_state"),
         ("data.codex_cache", "_check_data_codex_cache"),
         ("data.forked_buckets", "_check_data_forked_buckets"),
+        ("data.post_credit_milestones", "_check_data_post_credit_milestones"),
     )),
     ("safety", "Safety", (
         ("safety.dashboard_bind", "_check_safety_dashboard_bind"),