cctally 1.7.1 → 1.7.3

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:
@@ -985,6 +1030,56 @@ def _tui_build_percent_milestones(
     return out
 
 
+def _tui_build_five_hour_milestones(
+    conn: sqlite3.Connection,
+    five_hour_window_key: int | None,
+) -> list[dict]:
+    """Return per-percent 5h-block milestones for the given window, in
+    capture-time order. Spec §5.3 — drives the CurrentWeekModal's new
+    5h-milestone timeline section.
+
+    Bucket B per §3.2: NO ``reset_event_id`` filter — both pre- and
+    post-credit segments render in the merged chronological stream so
+    the user sees the full history of the active block including
+    repeated threshold values after an in-place credit. The React layer
+    differentiates rows by ``reset_event_id`` for key uniqueness.
+
+    Returns [] when the current week has no API-anchored 5h block. The
+    envelope-shaped dict mirrors the CLI ``five-hour-breakdown --json``
+    milestone objects but with snake_case keys (envelope convention).
+    """
+    if five_hour_window_key is None:
+        return []
+    rows = conn.execute(
+        """
+        SELECT percent_threshold, captured_at_utc, block_cost_usd,
+               marginal_cost_usd, seven_day_pct_at_crossing,
+               reset_event_id
+          FROM five_hour_milestones
+         WHERE five_hour_window_key = ?
+         ORDER BY captured_at_utc ASC, id ASC
+        """,
+        (int(five_hour_window_key),),
+    ).fetchall()
+    out: list[dict] = []
+    for r in rows:
+        out.append({
+            "percent_threshold": int(r["percent_threshold"]),
+            "captured_at_utc":   r["captured_at_utc"],
+            "block_cost_usd":    float(r["block_cost_usd"]),
+            "marginal_cost_usd": (
+                None if r["marginal_cost_usd"] is None
+                else float(r["marginal_cost_usd"])
+            ),
+            "seven_day_pct_at_crossing": (
+                None if r["seven_day_pct_at_crossing"] is None
+                else float(r["seven_day_pct_at_crossing"])
+            ),
+            "reset_event_id": int(r["reset_event_id"] or 0),
+        })
+    return out
+
+
 @dataclass
 class DataSnapshot:
     """All data needed to render one TUI frame. Produced by sync thread,
@@ -1017,6 +1112,13 @@ class DataSnapshot:
     # `current_week.five_hour_block` is precomputed via
     # `_select_current_block_for_envelope`).
     alerts: list[dict] = field(default_factory=list)
+    # ---- 5h in-place credit (v1.7.x) ----
+    # Already-envelope-shaped dicts for the CurrentWeekModal's new 5h
+    # milestone timeline (spec §5.3, Codex r1 finding 3). Parallel to
+    # ``percent_milestones`` (which carries the WEEKLY timeline). Loaded
+    # at sync-thread time so ``snapshot_to_envelope`` stays a pure
+    # renderer; empty list when no current 5h block is bound.
+    five_hour_milestones: list[dict] = field(default_factory=list)
 
     @classmethod
     def synthesize_for_marketing(cls, *, as_of_iso: str) -> "DataSnapshot":
@@ -1423,27 +1525,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 +1637,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 +1665,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
@@ -1782,6 +1945,19 @@ def _tui_build_snapshot(
             alerts = _build_alerts_envelope_array(conn)
         except Exception as exc:
             errors.append(f"alerts: {exc}")
+        # ---- 5h in-place credit (v1.7.x) ----
+        # Load 5h milestones (pre + post credit) for the current
+        # block's window so CurrentWeekModal can render a merged
+        # chronological timeline alongside its weekly milestones.
+        # Spec §5.3 (Codex r1 finding 3).
+        fh_milestones: list[dict] = []
+        try:
+            win_key = None
+            if cw is not None and isinstance(cw.five_hour_block, dict):
+                win_key = cw.five_hour_block.get("five_hour_window_key")
+            fh_milestones = _tui_build_five_hour_milestones(conn, win_key)
+        except Exception as exc:
+            errors.append(f"five-hour-milestones: {exc}")
         return DataSnapshot(
             current_week=cw,
             forecast=fc,
@@ -1797,6 +1973,7 @@ def _tui_build_snapshot(
             blocks_panel=blocks_panel,
             daily_panel=daily_panel,
             alerts=alerts,
+            five_hour_milestones=fh_milestones,
         )
     finally:
         conn.close()
@@ -2269,11 +2446,26 @@ def _tui_panel_current_week(
         f"${cw.dollars_per_percent:.2f}"
         if cw.dollars_per_percent is not None else "—"
     )
+    # Spec §5.4 — credit badge next to the 5h percent. Source: same
+    # ``cw.five_hour_block.credits`` channel that drives the dashboard
+    # chip; only show when at least one credit is present for the
+    # current block. Format: ``⚡ -Xpp`` (single) / ``⚡ -Xpp, -Ypp``
+    # (stacked across distinct 10-min slots).
+    fh_credit_badge = ""
+    fhb = getattr(cw, "five_hour_block", None)
+    if isinstance(fhb, dict):
+        fh_credits = fhb.get("credits") or []
+        if fh_credits:
+            deltas = ", ".join(
+                f"{float(c.get('delta_pp', 0.0)):+.0f}pp"
+                for c in fh_credits
+            )
+            fh_credit_badge = f" {{bright}}⚡ {deltas}{{/}}"
     lines = [
         "",
         f" Used   {{{used_cls}}}{bar_fill}{{/}} {{{used_cls}.b}}{cw.used_pct:>5.1f}%{{/}}",
         "",
-        f" 5-hour {{bar.accent}}{five_bar}{{/}} {{bright}}{int(five):>3d}%{{/}}",
+        f" 5-hour {{bar.accent}}{five_bar}{{/}} {{bright}}{int(five):>3d}%{{/}}{fh_credit_badge}",
         f"        {{dim}}{fr_str}{{/}}" if fr_str else "",
         "",
         f" {{dim}}Spent{{/}}    {{bright}}${cw.spent_usd:.2f}{{/}}        "
@@ -2322,6 +2514,19 @@ def _tui_panel_current_week_hero(
     else:
         reset_suffix = ""
 
+    # Spec §5.4 — credit badge in the hero variant. Same source as the
+    # grid variant; append after the reset suffix so the badge follows
+    # the "resets in" timer.
+    fhb_hero = getattr(cw, "five_hour_block", None)
+    if isinstance(fhb_hero, dict):
+        fh_credits_hero = fhb_hero.get("credits") or []
+        if fh_credits_hero:
+            deltas_hero = ", ".join(
+                f"{float(c.get('delta_pp', 0.0)):+.0f}pp"
+                for c in fh_credits_hero
+            )
+            reset_suffix = f"{reset_suffix}  {{bright}}⚡ {deltas_hero}{{/}}"
+
     if snap.last_sync_error:
         health = "{warn}daemon error{/}"
     elif snap.last_sync_at is None:

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"),

package/bin/_lib_render.py

@@ -2671,6 +2671,12 @@ def _five_hour_blocks_to_json(
             "sevenDayPctAtBlockEnd":   p_end,
             "sevenDayPctDeltaPp":      delta,
             "crossedSevenDayReset":    crossed,
+            # Spec §5.1 — in-place credit events for this 5h block, in
+            # ascending effective_reset_at order. Empty list when the
+            # block carries no credit detections. Source: ``__credits``
+            # side-channel attached by ``cmd_five_hour_blocks`` via
+            # ``credits_by_window``.
+            "credits":                 d.get("__credits") or [],
         }
         if breakdown_axis == "model":
             out["modelBreakdowns"] = [
@@ -2752,6 +2758,20 @@ def _render_five_hour_blocks_table(
         formatted_start = _format_block_start(d["block_start_at"], args._resolved_tz)
         if crossed:
             formatted_start = f"⚡ {formatted_start}"
+        # Spec §5.1 — credit chip suffix. When the block carries one or
+        # more in-place credit events (5h credit detection v1.7.x;
+        # __credits side-channel set by ``cmd_five_hour_blocks``), append
+        # a ⚡-prefixed chip listing the per-credit delta-pp. Multiple
+        # credits in the same block concatenate (e.g.
+        # `⚡ credited -20pp, -8pp`). The chip text sits AFTER the
+        # block-start cell's existing crossed-reset glyph so the two
+        # signals visually disambiguate by position (crossed-reset
+        # prefix vs. credit suffix). Both use ⚡ — different semantics,
+        # different positions.
+        credits = d.get("__credits") or []
+        if credits:
+            deltas = ", ".join(f"{c['deltaPp']:+.0f}pp" for c in credits)
+            formatted_start = f"{formatted_start} ⚡ credited {deltas}"
         rows.append([
             formatted_start,
             "ACTIVE" if d["__is_active"] else "closed",