cctally 1.79.0 → 1.79.2

package/bin/_cctally_milestone_history.py

@@ -11,8 +11,8 @@ This module is the IMPURE counterpart to the pure kernel
 ``_lib_milestone_history.py``. Honest imports are restricted to pure
 siblings (``_cctally_core`` kernel + ``_lib_*`` pure kernels, none of which
 back-import ``cctally``); every impure cctally-namespace symbol
-(``get_recent_weeks`` / ``get_milestones_for_week`` /
-``_tui_build_five_hour_milestones`` / ``load_config``) is reached via the
+(``get_recent_weeks`` / ``_tui_build_five_hour_milestones`` / ``load_config``)
+is reached via the
 call-time ``_cctally()`` accessor so test monkeypatches through the
 ``cctally`` namespace are preserved.
 
@@ -24,8 +24,11 @@ host-local offset while boundaries are canonical UTC).
 """
 from __future__ import annotations
 
+import datetime as dt
+import json
 import sqlite3
 import sys
+from dataclasses import replace
 
 from _cctally_core import make_week_ref, parse_iso_datetime
 from _cctally_quota import codex_quota_breakdown
@@ -34,9 +37,6 @@ from _lib_display_tz import _resolve_display_tz_obj, format_display_dt
 from _lib_json_envelope import _iso_z
 from _lib_quota import QuotaWindowIdentity
 
-import datetime as dt
-import json
-
 import _lib_milestone_history as _mh
 
 UTC = dt.timezone.utc
@@ -115,7 +115,7 @@ def _navigable_claude_refs(conn: sqlite3.Connection) -> list:
 
     Navigable set = weeks with ≥1 ``weekly_usage_snapshots`` row ∪ weeks with
     ≥1 ``percent_milestones`` row (cost-only weeks excluded). Same-key credit
-    segments are coalesced to one outer-boundary ref; a defensive
+    reset-defined segment remains independently navigable; a defensive
     milestone-only week absent from ``get_recent_weeks`` is synthesized from
     its milestone rows' stored boundaries.
     """
@@ -137,14 +137,104 @@ def _navigable_claude_refs(conn: sqlite3.Connection) -> list:
     navigable = usage_keys | milestone_keys
 
     refs = [r for r in refs if r.key in navigable]
-    refs = _mh.coalesce_week_refs(refs)
-
     present = {r.key for r in refs}
     for k in sorted(milestone_keys - present, reverse=True):
         ref = _synthesize_milestone_only_ref(conn, k)
         if ref is not None:
             refs.append(ref)
-    return refs
+    return _derive_claude_reset_cycles(conn, refs)
+
+
+def _parse_optional_iso(value):
+    if not value:
+        return None
+    try:
+        return parse_iso_datetime(value, "milestone_cycle.boundary")
+    except (TypeError, ValueError):
+        return None
+
+
+def _claude_storage_boundaries(conn: sqlite3.Connection, key: str):
+    """Return the outer retained boundary for one storage date bucket."""
+    rows = conn.execute(
+        "SELECT week_start_at, week_end_at FROM weekly_usage_snapshots "
+        "WHERE week_start_date=? AND week_start_at IS NOT NULL "
+        "AND week_end_at IS NOT NULL "
+        "UNION ALL "
+        "SELECT week_start_at, week_end_at FROM percent_milestones "
+        "WHERE week_start_date=? AND week_start_at IS NOT NULL "
+        "AND week_end_at IS NOT NULL",
+        (key, key),
+    ).fetchall()
+    pairs = [
+        (start, end)
+        for row in rows
+        if (start := _parse_optional_iso(row[0])) is not None
+        and (end := _parse_optional_iso(row[1])) is not None
+        and end > start
+    ]
+    if not pairs:
+        return None
+    return min(start for start, _end in pairs), max(end for _start, end in pairs)
+
+
+def _linked_reset_events(conn: sqlite3.Connection, key: str) -> list:
+    """Reset rows linked to any retained boundary in a storage bucket."""
+    return conn.execute(
+        "SELECT DISTINCT e.id, e.effective_reset_at_utc "
+        "FROM week_reset_events e "
+        "WHERE EXISTS ("
+        "  SELECT 1 FROM weekly_usage_snapshots s "
+        "  WHERE s.week_start_date=? AND ("
+        "    unixepoch(s.week_end_at)=unixepoch(e.old_week_end_at) OR "
+        "    unixepoch(s.week_end_at)=unixepoch(e.new_week_end_at)"
+        "  )"
+        ") OR EXISTS ("
+        "  SELECT 1 FROM percent_milestones m "
+        "  WHERE m.week_start_date=? AND ("
+        "    unixepoch(m.week_end_at)=unixepoch(e.old_week_end_at) OR "
+        "    unixepoch(m.week_end_at)=unixepoch(e.new_week_end_at)"
+        "  )"
+        ") "
+        "ORDER BY unixepoch(e.effective_reset_at_utc), e.id",
+        (key, key),
+    ).fetchall()
+
+
+def _derive_claude_reset_cycles(conn: sqlite3.Connection, refs: list) -> list:
+    """Expand storage buckets into provider reset-defined cycles.
+
+    ``get_recent_weeks`` can split an in-place credit, but an early re-anchor
+    whose old and new boundaries both remain under one ``week_start_date``
+    only exposes the pre-reset half. The retained snapshot boundary set plus
+    ``week_reset_events`` is the authoritative reset ledger for both shapes.
+    """
+    out: list = []
+    by_key: dict = {}
+    for ref in refs:
+        by_key.setdefault(ref.key, ref)
+    for key, template in by_key.items():
+        outer = _claude_storage_boundaries(conn, key)
+        if outer is None:
+            out.append(template)
+            continue
+        start, end = outer
+        cuts = []
+        for event in _linked_reset_events(conn, key):
+            effective = _parse_optional_iso(event["effective_reset_at_utc"])
+            if effective is not None and start < effective < end:
+                cuts.append(effective)
+        boundaries = [start, *sorted(set(cuts)), end]
+        cycles = []
+        for cycle_start, cycle_end in zip(boundaries, boundaries[1:]):
+            cycles.append(replace(
+                template,
+                week_start_at=cycle_start.isoformat(timespec="seconds"),
+                week_end_at=cycle_end.isoformat(timespec="seconds"),
+                week_end=(cycle_end - dt.timedelta(seconds=1)).date(),
+            ))
+        out.extend(reversed(cycles))
+    return _cctally()._apply_overlap_clamp_to_weekrefs(out)
 
 
 def _synthesize_milestone_only_ref(conn: sqlite3.Connection, key: str):
@@ -181,31 +271,65 @@ def _current_claude_week_key(conn: sqlite3.Connection) -> "str | None":
     return row[0] if row is not None else None
 
 
-def _index_entry(conn, ref, current_key, tz) -> dict:
-    counts = conn.execute(
-        "SELECT COUNT(*), COUNT(DISTINCT reset_event_id), MAX(captured_at_utc) "
-        "FROM percent_milestones WHERE week_start_date = ?",
-        (ref.key,),
-    ).fetchone()
-    milestone_count = int(counts[0] or 0)
-    segment_count = int(counts[1] or 0)
-    max_captured = counts[2]
+def _claude_cycle_key(ref) -> str:
+    return dashboard_resource_key(
+        "milestone_cycle", "claude", ref.key,
+        ref.week_start_at or "", ref.week_end_at or "",
+    )
+
+
+def _claude_cycle_rows(conn: sqlite3.Connection, ref) -> list:
+    cohort_id = 0
+    if ref.week_start_at:
+        row = conn.execute(
+            "SELECT e.id FROM week_reset_events e "
+            "WHERE unixepoch(e.effective_reset_at_utc)=unixepoch(?) "
+            "AND (EXISTS ("
+            "  SELECT 1 FROM weekly_usage_snapshots s "
+            "  WHERE s.week_start_date=? AND ("
+            "    unixepoch(s.week_end_at)=unixepoch(e.old_week_end_at) OR "
+            "    unixepoch(s.week_end_at)=unixepoch(e.new_week_end_at)"
+            "  )"
+            ") OR EXISTS ("
+            "  SELECT 1 FROM percent_milestones m "
+            "  WHERE m.week_start_date=? AND ("
+            "    unixepoch(m.week_end_at)=unixepoch(e.old_week_end_at) OR "
+            "    unixepoch(m.week_end_at)=unixepoch(e.new_week_end_at)"
+            "  )"
+            ")) ORDER BY e.id DESC LIMIT 1",
+            (ref.week_start_at, ref.key, ref.key),
+        ).fetchone()
+        if row is not None:
+            cohort_id = int(row[0])
+    return conn.execute(
+        "SELECT * FROM percent_milestones WHERE week_start_date=? "
+        "AND reset_event_id=? "
+        "ORDER BY unixepoch(captured_at_utc) ASC, percent_threshold ASC",
+        (ref.key, cohort_id),
+    ).fetchall()
+
 
+def _index_entry(conn, ref, current_cycle_key, tz) -> dict:
+    rows = _claude_cycle_rows(conn, ref)
+    milestone_count = len(rows)
+    segment_count = 1 if rows else 0
+    max_captured = max((r["captured_at_utc"] for r in rows), default=None)
     start_z = _to_iso_z(ref.week_start_at)
     end_z = _to_iso_z(ref.week_end_at)
     block_count = _count_blocks(conn, start_z, end_z)
+    key = _claude_cycle_key(ref)
 
     return {
-        "key": ref.key,
+        "key": key,
         "start_at_utc": start_z,
         "end_at_utc": end_z,
         "label": _week_label(ref, tz),
-        "is_current": ref.key == current_key,
+        "is_current": key == current_cycle_key,
         "milestone_count": milestone_count,
         "block_count": block_count,
         "segment_count": segment_count,
         "detail_stamp": _mh.compute_detail_stamp(
-            ref.key, milestone_count, block_count, segment_count, max_captured
+            key, milestone_count, block_count, segment_count, max_captured
         ),
     }
 
@@ -213,16 +337,21 @@ def _index_entry(conn, ref, current_key, tz) -> dict:
 def build_claude_week_index(conn: sqlite3.Connection) -> list:
     """Newest-first navigable Claude week index (spec §1a, §3).
 
-    One entry per navigable week; credit-split weeks collapse to a single
-    entry (segment structure lives in the detail payload). ``detail_stamp``
-    is a content digest that moves when the week's underlying rows change so
-    the client cache revalidates.
+    One entry per effective reset-defined cycle. Multiple cycles may share one
+    storage ``week_start_date`` but always have distinct opaque keys.
     """
     refs = _navigable_claude_refs(conn)
     current_key = _current_claude_week_key(conn)
+    current_refs = [r for r in refs if r.key == current_key]
+    current_ref = max(
+        current_refs,
+        key=lambda r: r.week_start_at or "",
+        default=None,
+    )
+    current_cycle_key = _claude_cycle_key(current_ref) if current_ref else None
     tz = _resolve_display_tz()
-    entries = [_index_entry(conn, ref, current_key, tz) for ref in refs]
-    entries.sort(key=lambda e: e["key"], reverse=True)
+    entries = [_index_entry(conn, ref, current_cycle_key, tz) for ref in refs]
+    entries.sort(key=lambda e: e["start_at_utc"] or "", reverse=True)
     return entries
 
 
@@ -244,58 +373,6 @@ def _shape_weekly_milestone(row) -> dict:
     }
 
 
-def _build_segments(rows) -> list:
-    """Group milestone rows into segments (by ``reset_event_id``), ordered
-    chronologically by each segment's first ``captured_at_utc``; rows within a
-    segment ascend by capture time then threshold (spec §1b)."""
-    groups: dict = {}
-    for r in rows:
-        seg = int(r["reset_event_id"] or 0)
-        groups.setdefault(seg, []).append(r)
-    ordered: list = []
-    for seg, seg_rows in groups.items():
-        seg_rows.sort(key=lambda r: (r["captured_at_utc"], int(r["percent_threshold"])))
-        first_cap = seg_rows[0]["captured_at_utc"]
-        ordered.append(
-            (first_cap, seg, [_shape_weekly_milestone(r) for r in seg_rows])
-        )
-    ordered.sort(key=lambda t: (t[0], t[1]))
-    return [{"reset_event_id": seg, "milestones": ms} for (_c, seg, ms) in ordered]
-
-
-def _build_dividers(conn: sqlite3.Connection, segments: list) -> list:
-    """Credit dividers between consecutive segments (spec §1b, Q4).
-
-    A divider is emitted for each later segment whose ``reset_event_id``
-    resolves to an in-place-credit ``week_reset_events`` row
-    (``old_week_end_at == effective_reset_at_utc``). It carries the effective
-    time + prior percent (``observed_pre_credit_pct``); no post/delta value is
-    recorded for weekly credits.
-    """
-    dividers: list = []
-    for later in segments[1:]:
-        seg_id = later["reset_event_id"]
-        if not seg_id:
-            continue
-        ev = conn.execute(
-            "SELECT effective_reset_at_utc, observed_pre_credit_pct, old_week_end_at "
-            "FROM week_reset_events WHERE id = ?",
-            (seg_id,),
-        ).fetchone()
-        if ev is None:
-            continue
-        if ev["old_week_end_at"] != ev["effective_reset_at_utc"]:
-            continue  # not an in-place credit → no divider
-        prior = ev["observed_pre_credit_pct"]
-        dividers.append(
-            {
-                "effective_at_utc": _to_iso_z(ev["effective_reset_at_utc"]),
-                "prior_percent": None if prior is None else float(prior),
-            }
-        )
-    return dividers
-
-
 def _load_block_credits(conn: sqlite3.Connection, window_key: int) -> list:
     """5h in-place credit rows for a block, ascending by effective time —
     same wire shape as the envelope's ``five_hour_block.credits``."""
@@ -354,30 +431,21 @@ def _build_blocks(conn: sqlite3.Connection, start_iso, end_iso) -> list:
     return out
 
 
-def build_claude_week_detail(
-    conn: sqlite3.Connection, week_start_date: str
-) -> "dict | None":
-    """Complete payload for one Claude week (spec §1b). ``None`` for an
-    unknown/non-navigable key.
-
-    Segments carry ALL ``reset_event_id`` cohorts (both pre- and post-credit)
-    ordered chronologically; ``dividers`` sit between consecutive segments;
-    ``blocks`` are the intersecting 5h blocks (dual-membership straddlers
-    included). Boundary/label/``is_current``/``detail_stamp`` are taken from
-    the index entry so the detail and index agree exactly.
-    """
-    c = _cctally()
-    entry = None
-    for e in build_claude_week_index(conn):
-        if e["key"] == week_start_date:
-            entry = e
-            break
-    if entry is None:
+def build_claude_week_detail(conn: sqlite3.Connection, key: str) -> "dict | None":
+    """Complete payload for one reset-defined Claude cycle."""
+    refs = _navigable_claude_refs(conn)
+    ref = next((candidate for candidate in refs if _claude_cycle_key(candidate) == key), None)
+    if ref is None:
         return None
-
-    rows = c.get_milestones_for_week(conn, week_start_date)
-    segments = _build_segments(rows)
-    dividers = _build_dividers(conn, segments)
+    entry = next(e for e in build_claude_week_index(conn) if e["key"] == key)
+    rows = _claude_cycle_rows(conn, ref)
+    segment_key = dashboard_resource_key(
+        "milestone_segment", "claude", ref.key,
+        ref.week_start_at or "", ref.week_end_at or "",
+    )
+    segments = ([{"key": segment_key,
+                  "milestones": [_shape_weekly_milestone(r) for r in rows]}]
+                if rows else [])
     blocks = _build_blocks(conn, entry["start_at_utc"], entry["end_at_utc"])
 
     return {
@@ -389,7 +457,7 @@ def build_claude_week_detail(
         "is_current": entry["is_current"],
         "detail_stamp": entry["detail_stamp"],
         "segments": segments,
-        "dividers": dividers,
+        "dividers": [],
         "blocks": blocks,
     }
 
@@ -400,9 +468,9 @@ def build_claude_week_detail(
 # (quota_window_blocks, stats.db) — explicitly NOT the bounded public quota
 # read model (35-day / 1000-observation / 250-row caps). Boundaries are the
 # effective clipped, non-overlapping periods: a provider early re-anchor
-# ends the prior cycle at min(raw reset, next nominal start). Cycle keys
-# embed the full native identity tuple so two identities sharing a
-# resets_at get distinct keys and resolve exactly.
+# ends the prior cycle at min(raw reset, next nominal start). One full native
+# identity is selected per physical reset; the opaque cycle key retains that
+# identity so detail resolves the exact selected ledger.
 #
 # `_codex_weekly_periods` (bin/_cctally_dashboard_sources.py) computes the
 # same clip formula but collapses across roots (losing the per-identity key)
@@ -490,6 +558,10 @@ class _CodexCycle:
     def key_parts(self) -> tuple:
         return (self.root, self.limit, self.slot, self.window, self.reset_iso)
 
+    @property
+    def identity_parts(self) -> tuple:
+        return (self.root, self.limit, self.slot, self.window)
+
     @property
     def key(self) -> str:
         return dashboard_resource_key("milestone_cycle", "codex", *self.key_parts)
@@ -499,9 +571,62 @@ class _CodexCycle:
         return dashboard_resource_key("block", "codex", *self.key_parts)
 
 
-def _load_codex_cycles(stats_conn, root_keys, *, include_orphaned=False) -> list:
-    """Non-model-scoped 7-day (window_minutes=10080) cycles for the identity
-    roots, effective-clipped per identity. Unbounded (no 35-day / row cap)."""
+def _identity_matches_cycle(identity, cyc) -> bool:
+    return (
+        identity is not None
+        and getattr(identity, "source_root_key", None) == cyc.root
+        and getattr(identity, "logical_limit_key", None) == cyc.limit
+        and getattr(identity, "observed_slot", None) == cyc.slot
+        and getattr(identity, "window_minutes", None) == cyc.window
+    )
+
+
+def _choose_physical_cycle(candidates: list, *, preferred_identity=None) -> _CodexCycle:
+    preferred = [c for c in candidates if _identity_matches_cycle(preferred_identity, c)]
+    pool = preferred or candidates
+    return max(
+        pool,
+        key=lambda c: (
+            -1.0 if c.current_percent is None else c.current_percent,
+            c.reset,
+            c.identity_parts,
+        ),
+    )
+
+
+def _canonical_identity_cycles(cycles: list) -> list:
+    """Jitter-collapse rows within each full native identity."""
+    groups: dict = {}
+    for cyc in cycles:
+        groups.setdefault(cyc.identity_parts, []).append(cyc)
+    return [
+        _canonicalize_codex_cluster(cluster)
+        for members in groups.values()
+        for cluster in _mh.cluster_by_reset_jitter(
+            members, reset_key=lambda c: c.reset.timestamp()
+        )
+    ]
+
+
+def _select_physical_cycles(cycles: list, *, preferred_identity=None) -> list:
+    """Select one full identity per physical reset boundary, then clip globally."""
+    identity_cycles = _canonical_identity_cycles(cycles)
+    selected = [
+        _choose_physical_cycle(cluster, preferred_identity=preferred_identity)
+        for cluster in _mh.cluster_by_reset_jitter(
+            identity_cycles, reset_key=lambda c: c.reset.timestamp()
+        )
+    ]
+    selected.sort(key=lambda c: (c.start, c.reset, c.identity_parts))
+    for index, cyc in enumerate(selected):
+        next_start = selected[index + 1].start if index + 1 < len(selected) else None
+        cyc.end = min(cyc.reset, next_start) if next_start is not None else cyc.reset
+    return [c for c in selected if c.end > c.start]
+
+
+def _load_codex_cycles(stats_conn, root_keys, *, include_orphaned=False,
+                       preferred_identity=None) -> list:
+    """Unbounded reset-defined 7-day cycles, one selected identity per boundary."""
     roots = tuple(sorted({r for r in root_keys if isinstance(r, str) and r}))
     if not roots:
         return []
@@ -528,34 +653,9 @@ def _load_codex_cycles(stats_conn, root_keys, *, include_orphaned=False) -> list
             continue
         cycles.append(cyc)
 
-    # Canonicalize per identity (root, limit, slot): jitter-cluster the raw
-    # observations so one physical weekly reset — surfacing as several rows
-    # whose ``resets_at`` differ by seconds — becomes ONE cycle instead of a
-    # fan of degenerate 1-second spans (ui-qa P2). Genuine early re-anchors
-    # (hours apart) stay distinct (see ``cluster_by_reset_jitter``).
-    groups: dict = {}
-    for cyc in cycles:
-        groups.setdefault((cyc.root, cyc.limit, cyc.slot), []).append(cyc)
-    clustered: list = []
-    for members in groups.values():
-        for cluster in _mh.cluster_by_reset_jitter(
-            members, reset_key=lambda c: c.reset.timestamp()
-        ):
-            clustered.append(_canonicalize_codex_cluster(cluster))
-
-    # Effective clip per identity: end each canonical cycle at the NEXT
-    # canonical cycle's start (min with its own reset), non-overlapping.
-    cgroups: dict = {}
-    for cyc in clustered:
-        cgroups.setdefault((cyc.root, cyc.limit, cyc.slot), []).append(cyc)
-    for members in cgroups.values():
-        members.sort(key=lambda c: c.start)
-        for i, cyc in enumerate(members):
-            nxt = members[i + 1].start if i + 1 < len(members) else None
-            cyc.end = min(cyc.reset, nxt) if nxt is not None else cyc.reset
-    clustered = [c for c in clustered if c.end > c.start]
-    clustered.sort(key=lambda c: c.reset, reverse=True)
-    return clustered
+    selected = _select_physical_cycles(cycles, preferred_identity=preferred_identity)
+    selected.sort(key=lambda c: c.start, reverse=True)
+    return selected
 
 
 def _canonicalize_codex_cluster(members: list) -> "_CodexCycle":
@@ -596,12 +696,12 @@ def _codex_is_current(cyc, identity, now_utc) -> bool:
 
 
 def _codex_milestone_count(stats_conn, cyc) -> tuple[int, str | None]:
-    """Milestone count + max captured-at over the cluster's union — every
-    jittered member reset contributes (rows split across sibling resets)."""
+    """Unique threshold count + max captured-at for one selected identity."""
     resets = cyc.member_reset_isos
     placeholders = ",".join("unixepoch(?)" for _ in resets)
     row = stats_conn.execute(
-        "SELECT COUNT(*), MAX(captured_at_utc) FROM quota_percent_milestones "
+        "SELECT COUNT(DISTINCT percent_threshold), MAX(captured_at_utc) "
+        "FROM quota_percent_milestones "
         "WHERE source='codex' AND source_root_key=? AND logical_limit_key=? "
         "  AND observed_slot=? AND window_minutes=? "
         f"  AND unixepoch(resets_at_utc) IN ({placeholders}) AND orphaned_at IS NULL",
@@ -611,8 +711,7 @@ def _codex_milestone_count(stats_conn, cyc) -> tuple[int, str | None]:
 
 
 def _codex_five_hour_rows(stats_conn, cyc, *, include_orphaned=False) -> list:
-    """Retained 5h (window_minutes=300) blocks for this cycle's identity
-    (root + observed_slot + limit_id) intersecting [start, end)."""
+    """Every retained 5h block on the selected root intersecting [start, end)."""
     orphan_clause = "" if include_orphaned else "AND orphaned_at IS NULL "
     return stats_conn.execute(
         "SELECT source_root_key, logical_limit_key, observed_slot, "
@@ -621,12 +720,12 @@ def _codex_five_hour_rows(stats_conn, cyc, *, include_orphaned=False) -> list:
         "FROM quota_window_blocks "
         "WHERE source='codex' AND window_minutes=300 "
         f"{orphan_clause}"
-        "AND source_root_key=? AND observed_slot=? AND limit_id IS ? "
+        "AND source_root_key=? "
         "AND unixepoch(nominal_start_at_utc) < unixepoch(?) "
         "AND unixepoch(resets_at_utc) > unixepoch(?) "
         "ORDER BY unixepoch(nominal_start_at_utc) ASC",
-        (cyc.root, cyc.slot, cyc.limit_id,
-         cyc.end.astimezone(UTC).isoformat(), cyc.start.astimezone(UTC).isoformat()),
+        (cyc.root, cyc.end.astimezone(UTC).isoformat(),
+         cyc.start.astimezone(UTC).isoformat()),
     ).fetchall()
 
 
@@ -645,10 +744,11 @@ def _codex_five_hour_clusters(stats_conn, cyc, *, include_orphaned=False) -> lis
         if block.start is None or block.reset is None:
             continue
         blocks.append(block)
+    identity_clusters = _canonical_identity_cycles(blocks)
     clusters = [
-        _canonicalize_codex_cluster(members)
+        _choose_physical_cycle(members)
         for members in _mh.cluster_by_reset_jitter(
-            blocks, reset_key=lambda b: b.reset.timestamp()
+            identity_clusters, reset_key=lambda b: b.reset.timestamp()
         )
     ]
     clusters.sort(key=lambda b: b.start)
@@ -686,11 +786,14 @@ def _codex_cycle_label(cyc, tz) -> str:
 
 def build_codex_cycle_index(stats_conn, *, identity, now_utc) -> list:
     """Newest-first Codex cycle index over the durable projection (spec §1c,
-    §3). Enumerates cycles of the hero-selected identity's roots with no depth
-    cap; one entry per (root, limit, slot, reset) cycle."""
+    §3). Enumerates the hero root's reset-defined ledger with no depth cap;
+    one selected full native identity per physical reset."""
     now = now_utc.astimezone(UTC) if now_utc.tzinfo else now_utc.replace(tzinfo=UTC)
     tz = _resolve_display_tz()
-    cycles = _load_codex_cycles(stats_conn, getattr(identity, "source_root_keys", ()))
+    cycles = _load_codex_cycles(
+        stats_conn, getattr(identity, "source_root_keys", ()),
+        preferred_identity=getattr(identity, "quota_identity", None),
+    )
     return [_codex_cycle_entry(stats_conn, c, identity, now, tz) for c in cycles]
 
 
@@ -753,8 +856,19 @@ def _union_cluster_milestones(cluster, block_key, speed, cache_conn, stats_conn)
             _shape_codex_milestone(r, key_parts=member.key_parts, block_key=block_key)
             for r in breakdown
         )
-    shaped.sort(key=lambda m: (m["captured_at"] or "", m["percent"]))
-    return shaped
+    # One physical quota ledger has one crossing per integer threshold. Jitter
+    # siblings can contribute missing evidence, but never duplicate a row.
+    by_percent: dict[int, dict] = {}
+    for row in shaped:
+        percent = int(row["percent"])
+        prior = by_percent.get(percent)
+        if prior is None or (row["captured_at"] or "", row["key"]) < (
+            prior["captured_at"] or "", prior["key"]
+        ):
+            by_percent[percent] = row
+    return sorted(
+        by_percent.values(), key=lambda m: (m["captured_at"] or "", m["percent"])
+    )
 
 
 def _codex_cycle_blocks(stats_conn, cache_conn, cyc, speed) -> "list | None":
@@ -801,7 +915,8 @@ def build_codex_cycle_detail(
     tz = _resolve_display_tz()
     try:
         cycles = _load_codex_cycles(
-            stats_conn, getattr(identity, "source_root_keys", ())
+            stats_conn, getattr(identity, "source_root_keys", ()),
+            preferred_identity=getattr(identity, "quota_identity", None),
         )
     except sqlite3.Error:
         return (None, "projection_incoherent")
@@ -813,6 +928,7 @@ def build_codex_cycle_detail(
             orphaned = _load_codex_cycles(
                 stats_conn, getattr(identity, "source_root_keys", ()),
                 include_orphaned=True,
+                preferred_identity=getattr(identity, "quota_identity", None),
             )
         except sqlite3.Error:
             return (None, "projection_incoherent")
@@ -839,7 +955,12 @@ def build_codex_cycle_detail(
         "label": entry["label"],
         "is_current": entry["is_current"],
         "detail_stamp": entry["detail_stamp"],
-        "segments": [{"reset_event_id": 0, "milestones": milestones}],
+        "segments": [{
+            "key": dashboard_resource_key(
+                "milestone_segment", "codex", *match.key_parts
+            ),
+            "milestones": milestones,
+        }],
         "dividers": [],
         "blocks": blocks,
     }