cctally 1.78.0 → 1.79.1

package/bin/_cctally_dashboard_sources.py

@@ -38,6 +38,7 @@ from _lib_dashboard_sources import (
     dashboard_resource_key,
 )
 from _lib_quota import (
+    QuotaWindowIdentity,
     build_blocks,
     build_history,
     forecast_quota,
@@ -94,6 +95,9 @@ class CodexCycleBoundary:
     # Root provenance is server-only accounting input, never public wire data.
     source_root_keys: tuple[str, ...]
     used_percent: float | None = None
+    # Exact server-side quota identity selected for the hero. It is never
+    # serialized; milestone-history keys hash it opaquely.
+    quota_identity: QuotaWindowIdentity | None = None
 
 
 @dataclass(frozen=True)
@@ -126,7 +130,7 @@ def _resolve_codex_weekly_cycle(
     now_utc: dt.datetime,
 ) -> CodexCycleBoundary:
     """Select exactly one active account-level 10,080-minute native cycle."""
-    boundaries: dict[tuple[int, dt.datetime], dict[str, object]] = {}
+    boundaries: dict[tuple[int, dt.datetime], list[tuple[object, object]]] = {}
     stale_weekly_evidence = False
     for history in build_history(tuple(observations)):
         if history.identity.window_minutes != 10_080:
@@ -140,23 +144,33 @@ def _resolve_codex_weekly_cycle(
             stale_weekly_evidence = True
             continue
         boundary = (history.identity.window_minutes, baseline.resets_at)
-        item = boundaries.setdefault(boundary, {"roots": set(), "used": []})
-        item["roots"].add(history.identity.source_root_key)
-        if baseline.used_percent is not None:
-            item["used"].append(float(baseline.used_percent))
+        boundaries.setdefault(boundary, []).append((history, baseline))
     if len(boundaries) != 1:
         if not boundaries:
             raise CodexCycleUnavailable("stale" if stale_weekly_evidence else "missing")
         raise CodexCycleUnavailable("conflicting")
-    (window_minutes, resets_at), boundary_data = next(iter(boundaries.items()))
-    root_keys = boundary_data["roots"]
-    used_values = boundary_data["used"]
+    (window_minutes, resets_at), candidates = next(iter(boundaries.items()))
+    # Preserve the existing hero's max-used-percent choice, then pin every
+    # remaining tie deterministically. The selected full identity—not the
+    # union of sibling roots/slots/limits—owns the hero cycle.
+    history, baseline = max(
+        candidates,
+        key=lambda item: (
+            float(item[1].used_percent),
+            item[1].captured_at.astimezone(UTC),
+            item[0].identity.source_root_key,
+            item[0].identity.logical_limit_key,
+            item[0].identity.observed_slot,
+        ),
+    )
+    selected_identity = history.identity
     return CodexCycleBoundary(
         window_minutes=window_minutes,
         start_at=resets_at - dt.timedelta(minutes=window_minutes),
         resets_at=resets_at,
-        source_root_keys=tuple(sorted(root_keys)),
-        used_percent=max(used_values) if used_values else None,
+        source_root_keys=(selected_identity.source_root_key,),
+        used_percent=float(baseline.used_percent),
+        quota_identity=selected_identity,
     )
 
 
@@ -2080,7 +2094,21 @@ def build_codex_source_state(
         now_utc=context.now_utc,
         display_tz_name=context.display_tz_name,
     )
-    quota = {**quota, "blocks": quota_blocks}
+    # Hero-modal historical-milestone navigation index (spec §1c, §3). Built
+    # here on the non-idle codex source rebuild (idle ticks reuse the stored
+    # bundle) over the durable projection — a pure serializer never touches it.
+    # Guarded: an index failure must never fail the codex source build.
+    cycle_index: tuple = ()
+    if cycle is not None and not hero_failure:
+        try:
+            cycle_index = tuple(
+                sys.modules["cctally"].build_codex_cycle_index(
+                    context.stats_conn, identity=cycle, now_utc=context.now_utc,
+                )
+            )
+        except sqlite3.Error:
+            cycle_index = ()
+    quota = {**quota, "blocks": quota_blocks, "cycle_index": cycle_index}
     budget_rows = _budget_wire(context.stats_conn)
     projected_budget_rows = _projected_budget_wire(context.stats_conn)
     budget_cost_events = _codex_budget_cost_events(context, budget_entries)

package/bin/_cctally_doctor.py

@@ -800,14 +800,28 @@ def doctor_gather_state(
     # on corruption — both behaviors would hide diagnostic state
     # (codex H1).
     config_json_error = None
+    config_parsed: dict = {}
     try:
         if _cctally_core.CONFIG_PATH.exists():
-            json.loads(_cctally_core.CONFIG_PATH.read_text(encoding="utf-8"))
+            config_parsed = json.loads(
+                _cctally_core.CONFIG_PATH.read_text(encoding="utf-8")
+            )
     except json.JSONDecodeError as exc:
         config_json_error = f"{type(exc).__name__}: {exc}"
     except OSError as exc:
         config_json_error = f"OSError: {exc}"
 
+    # Configured update (release) channel (beta-channel, spec 2026-07-21 §3):
+    # derived from the SAME raw read (never load_config, which auto-creates on
+    # first run). Fail-soft to "stable" — resolve_update_channel already
+    # tolerates a non-dict block / junk value.
+    try:
+        update_channel = c.resolve_update_channel(
+            config_parsed if isinstance(config_parsed, dict) else {}
+        )
+    except Exception:
+        update_channel = "stable"
+
     update_state = None
     update_state_error = None
     try:
@@ -880,6 +894,7 @@ def doctor_gather_state(
         codex_jsonl_present=codex_jsonl_present,
         codex_project_metadata_health=codex_project_metadata_health,
         codex_project_metadata_error=codex_project_metadata_error,
+        update_channel=update_channel,
         dashboard_bind_stored=dashboard_bind_stored,
         runtime_bind=runtime_bind,
         # Conversation viewer (Plan 2, spec §5): only consulted on a LAN bind.