cctally 1.117.0 → 1.118.0

package/bin/_cctally_dashboard.py

@@ -2450,6 +2450,108 @@ def _dashboard_sync_loop(
             sleep(min(0.1, max(0.0, deadline - now)))
 
 
+def _frozen_deferral_settle_loop(
+    *,
+    stop,
+    interval: float,
+    ref,
+    sync_lock,
+    run_locked,
+    mark_rebuilding,
+    is_deferred,
+    monotonic=time.monotonic,
+    wait=None,
+) -> None:
+    """Retry a frozen dashboard's no-ingest build until recovery permits it (#932).
+
+    `--no-sync` starts no sync thread, so a frozen dashboard whose first build
+    DEFERRED (an older-epoch index, or a corruption heal running detached) would
+    otherwise hold that data-less deferral frame for its whole life. This loop
+    retries the dashboard's existing locked publisher with ``skip_sync=True``
+    (the same no-ingest build a manual ``POST /api/sync`` runs: no ingest, no
+    OAuth refresh, no derivations) only while the held frame is an EXPLICIT
+    stats deferral (``is_deferred``, the `SyncFailureAttribution.deferred`
+    predicate), and exits for good on any other outcome — a populated or empty
+    success, a crash, an exhausted corruption retry.
+
+    Cadence: one ``interval`` before the first attempt, then
+    ``_next_deadline(t0, interval, work)``, the #313 cooldown that bounds duty
+    to 50 %. The ``sync_lock`` acquire is NON-blocking; contention skips that
+    cadence. Every attempt does all of its work under the lock and rechecks
+    ``stop`` right after acquiring it, which is what makes
+    `_retire_frozen_deferral_settle`'s lock fence exact. ``wait(seconds)``
+    returns True when stopped (``stop.wait`` in production).
+    """
+    if wait is None:
+        wait = stop.wait
+    deadline = monotonic() + interval
+    while True:
+        if wait(max(0.0, deadline - monotonic())) or stop.is_set():
+            return
+        if not is_deferred(ref.get()):
+            return   # settled elsewhere (a manual sync): no extra build
+        if not sync_lock.acquire(blocking=False):
+            deadline = monotonic() + interval
+            continue
+        try:
+            if stop.is_set() or not is_deferred(ref.get()):
+                return
+            t0 = monotonic()
+            try:
+                with _rebuilding_claim(mark_rebuilding):
+                    run_locked(skip_sync=True)
+            except Exception:  # noqa: BLE001 — logged; the loop is done
+                _log_sync_iteration_failure()
+                return
+            work = monotonic() - t0
+            still_deferred = is_deferred(ref.get())
+        finally:
+            sync_lock.release()
+        if not still_deferred:
+            return
+        deadline = _next_deadline(t0, interval, work)
+
+
+def _make_frozen_deferral_settle_thread(
+    *, stop, interval, ref, hub, sync_lock, run_sync_now_locked,
+) -> threading.Thread:
+    """The daemon thread running `_frozen_deferral_settle_loop` (#932)."""
+    collaborators = _make_sync_loop_collaborators(ref=ref, hub=hub)
+    tui = _cctally()._cctally_tui
+    return threading.Thread(
+        target=lambda: _frozen_deferral_settle_loop(
+            stop=stop,
+            interval=float(interval),
+            ref=ref,
+            sync_lock=sync_lock,
+            run_locked=run_sync_now_locked,
+            mark_rebuilding=collaborators["mark_rebuilding"],
+            is_deferred=tui._tui_snapshot_is_stats_deferral,
+        ),
+        daemon=True,
+        name="dashboard-frozen-deferral-settle",
+    )
+
+
+def _retire_frozen_deferral_settle(*, stop, sync_lock, thread) -> None:
+    """Retire the settle thread before the resources its attempts use (#932).
+
+    A lock fence, not a timed join: set ``stop``, then acquire and release
+    ``sync_lock`` (blocking, no timeout), which waits out any attempt already
+    in flight — its build, verifier submission, ``set_final`` and publish all
+    run under the lock — and no attempt can start after it, because each
+    rechecks ``stop`` right after acquiring. The join that follows only
+    collects a thread that is waiting on ``stop`` or returning. The lock is
+    released before the caller retires the memory verifiers, whose unsafe
+    completion takes the same lock. Intentionally unbounded: it drains
+    whichever holder has the lock.
+    """
+    stop.set()
+    sync_lock.acquire()
+    sync_lock.release()
+    thread.join()
+
+
 def _dashboard_startup_schema_migration(*, run_derivations: bool = True) -> None:
     """Advance both stores to head once, at startup, in EVERY mode (#780).
 
@@ -7135,6 +7237,25 @@ def _projects_week_usage_rows(
     return rows
 
 
+def _projects_content_revision_leg(conn: "sqlite3.Connection") -> str:
+    """The Claude content revision memo leg read on ``conn`` (#1050) for a
+    call without a dispatch leg (tests, the drill-down fallback).
+
+    A ``current`` store's leg is its token. Any other state names itself, so a
+    store with no revision tracking (a bare fixture database) memoizes exactly
+    as it did before #1050 instead of missing on every call; the tick never
+    takes this path, and its own dispatch leg on such a store is a fresh nonce.
+    """
+    import _lib_stats_content_revision as k
+    try:
+        revision = k.read_claude_content_revision(conn)
+    except k.StatsContentRevisionUnreadable:
+        return "?unreadable"
+    if revision.state == k.STATE_CURRENT:
+        return revision.token
+    return f"?{revision.state}"
+
+
 def _build_projects_envelope(
     conn: "sqlite3.Connection",
     *,
@@ -7142,6 +7263,7 @@ def _build_projects_envelope(
     current_week: "Any | None" = None,
     weeks_back: int = 12,
     use_projects_env_cache: bool = False,
+    content_revision_leg: "str | None" = None,
 ) -> dict:
     """Build the ``projects.{current_week, trend}`` envelope block.
 
@@ -7172,6 +7294,12 @@ def _build_projects_envelope(
     ``(max(session_entries.id), max_wus_id, max(mutation_seq), cw_week_start,
     weeks_back)`` — the ``mutation_seq`` leg (#270 §7d) busts the memo on an
     id-stable in-place finalization.
+
+    ``content_revision_leg`` (#1050 spec 4.5 item 7) is the dashboard tick's
+    dispatch leg of the stats.db Claude content revision, read before this
+    lookup; the memo key carries it, so an in-place ``weekly_percent``
+    correction (which moves no ``MAX(id)``) rebuilds the envelope. ``None``
+    reads it here, on ``conn``.
     """
     c = _cctally()
 
@@ -7184,6 +7312,7 @@ def _build_projects_envelope(
     # SELECT uses below).
     cur = conn.execute("SELECT COALESCE(MAX(id), 0) FROM session_entries")
     max_id = cur.fetchone()[0]
+    stats_readable = True
     try:
         cur = conn.execute(
             "SELECT COALESCE(MAX(id), 0) FROM weekly_usage_snapshots"
@@ -7191,6 +7320,15 @@ def _build_projects_envelope(
         max_wus_id = cur.fetchone()[0]
     except sqlite3.OperationalError:
         max_wus_id = 0
+        stats_readable = False
+    # #1050 spec 4.5 item 7: the attributed percentages are functions of the
+    # stored `weekly_percent`, which a correction rewrites in place. The leg is
+    # the dispatch's; a caller without one reads it here, before the lookup.
+    # A connection with no stats tables publishes no stats-derived value, so
+    # it keys on no leg; an untrusted or unreadable identity is a fresh nonce.
+    if content_revision_leg is None:
+        content_revision_leg = (
+            _projects_content_revision_leg(conn) if stats_readable else "")
     # #270 (§7d, Codex-2b): this OUTER whole-envelope memo returns BEFORE the
     # inner per-(project, week) reconcile cache, so an id-stable in-place
     # finalization — which leaves MAX(id)/MAX(wus id) flat — would serve the
@@ -7214,7 +7352,8 @@ def _build_projects_envelope(
     cw_key: "dt.datetime | None" = None
     if current_week is not None:
         cw_key = getattr(current_week, "week_start_at", None)
-    memo_key = (max_id, max_wus_id, entry_mutation_seq, cw_key, weeks_back)
+    memo_key = (max_id, max_wus_id, entry_mutation_seq, cw_key, weeks_back,
+                content_revision_leg)
     cached = _PROJECTS_ENV_MEMO.get("value")
     if cached is not None and _PROJECTS_ENV_MEMO.get("key") == memo_key:
         return cached
@@ -11544,12 +11683,20 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
         assembly runs inside one transaction per DB. 400 malformed key/source;
         404 ``{code: "unknown_key", reason}`` for keys that don't resolve.
 
-        ``?account=<account_key|unattributed>`` (#416, Codex only) focuses the
-        cycle on one account: its own crossings, its own spend. ABSENT is the
-        shipped merged response and is byte-identical — the client sends the
-        qualifier only under account focus, exactly as `/api/source/` does. The
+        ``?account=<account_key|unattributed>`` (#416 Codex; #836 Claude)
+        focuses the cycle on one account: its own crossings, its own spend.
+        ABSENT is the shipped merged response and is byte-identical — the
+        client sends the qualifier only under account focus (Codex) or for the
+        displayed account (Claude), exactly as `/api/source/` does. The
         vendor-wide ``*`` sentinel is rejected here (unlike `/api/source/`,
         where it labels an alert row): it names no cycle to render.
+
+        Claude (#836 spec 5.6) accepts the qualifier only while Claude is
+        decorated (more than one REAL account), checked in the same read
+        transaction as the assembly: 400 on an undecorated store, 404
+        ``unknown_key`` for an unknown or non-Claude account or a key outside
+        that account's scoped index, and never a retry against the merged
+        index.
         """
         import re as _re
         import urllib.parse as _urlparse
@@ -11576,11 +11723,6 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
             ):
                 self._send_milestones_json(400, {"error": "invalid account"})
                 return
-            if source != "codex":
-                # Claude weeks are not account-partitioned on this route yet;
-                # accepting the qualifier silently would be a privacy lie.
-                self._send_milestones_json(400, {"error": "invalid account"})
-                return
             account_key = raw_account[0]
         c = sys.modules["cctally"]
         try:
@@ -11592,12 +11734,38 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
                     self._send_milestones_json(400, {"error": "invalid cycle key"})
                     return
                 conn = open_db()
+                rejected = False
+                detail = None
                 try:
                     conn.execute("BEGIN")
-                    detail = c.build_claude_week_detail(conn, key)
+                    if account_key is None:
+                        detail = c.build_claude_week_detail(conn, key)
+                    else:
+                        # #836 spec 5.6. Only a DECORATED store partitions
+                        # Claude history by account. On an undecorated one the
+                        # qualifier is refused, never ignored: answering it with
+                        # the merged week would claim an account scope the
+                        # payload does not have, which is the privacy lie the
+                        # earlier blanket rejection guarded against. Checked
+                        # inside this transaction so the gate and the assembly
+                        # read one state.
+                        import _cctally_account
+                        if not _cctally_account.provider_is_decorated(
+                                conn, "claude"):
+                            rejected = True
+                        elif account_key == "unattributed" or conn.execute(
+                                "SELECT 1 FROM accounts WHERE account_key = ? "
+                                "AND provider = 'claude'",
+                                (account_key,)).fetchone() is not None:
+                            detail = c.build_claude_week_detail(
+                                conn, key, account_key=account_key,
+                                now_utc=_command_as_of())
                     conn.commit()
                 finally:
                     conn.close()
+                if rejected:
+                    self._send_milestones_json(400, {"error": "invalid account"})
+                    return
                 if detail is None:
                     self._send_milestones_json(404, {
                         "error": "unknown week", "code": "unknown_key",
@@ -12197,7 +12365,6 @@ def _dashboard_stats_deferred_snapshot(args, *, pinned_now, exc):
     c = _cctally()
     tui = c._cctally_tui
     now_utc = pinned_now or dt.datetime.now(dt.timezone.utc)
-    hydrating = not getattr(args, "no_sync", False)
     errors = [f"stats-open: {exc}"]
     envelope_precompute = None
     try:
@@ -12220,19 +12387,16 @@ def _dashboard_stats_deferred_snapshot(args, *, pinned_now, exc):
         # a fresh success. There is no earlier success to preserve either.
         "last_sync_at": None,
         "last_sync_error": "; ".join(errors),
-        "sync_failures": (
-            tui.SyncFailureAttribution(
-                leg="stats-open",
-                database="stats",
-                corruption=tui._stats_open_failure_is_corruption(exc),
-            ),
-        ),
+        "sync_failures": (tui._tui_deferral_attribution(exc),),
         "doctor_payload": doctor_payload,
         "envelope_precompute": envelope_precompute,
-        "hydrating": hydrating,
+        # #932 §4.2: hydrating in BOTH modes. A frozen dashboard's settle loop
+        # (`_frozen_deferral_settle_loop`) replaces this frame once recovery
+        # permits a build, so it must read as loading, never as "restart the
+        # dashboard".
+        "hydrating": True,
+        "source_bundle": tui._tui_hydrating_source_bundle(),
     }
-    if hydrating:
-        replacements["source_bundle"] = tui._tui_hydrating_source_bundle()
     return dataclasses.replace(tui._tui_empty_snapshot(now_utc), **replacements)
 
 
@@ -12322,8 +12486,11 @@ def _dashboard_initial_snapshot_once(
         )
     if conn is not None:
         try:
+            reading_errors: list[Exception] = []
             try:
-                cw = tui._tui_build_current_week(conn, now_utc, skip_sync=True)
+                cw = tui._tui_build_current_week(
+                    conn, now_utc, skip_sync=True,
+                    reading_errors=reading_errors)
             except Exception as exc:  # noqa: BLE001 — never block the bind
                 tui._tui_capture_sync_failure(
                     conn,
@@ -12334,6 +12501,18 @@ def _dashboard_initial_snapshot_once(
                     exc=exc,
                     stats_heal_attempted=stats_heal_attempted,
                 )
+            # #1018 twin review F1: a failed confirming-reading lookup keeps
+            # the card and is recorded like its other reads.
+            for exc in reading_errors:
+                tui._tui_capture_sync_failure(
+                    conn,
+                    errors,
+                    sync_failures,
+                    leg="current-week-reading",
+                    database="stats_or_cache",
+                    exc=exc,
+                    stats_heal_attempted=stats_heal_attempted,
+                )
             try:
                 fc_view = tui._tui_build_forecast_view(
                     conn, now_utc, skip_sync=True
@@ -12781,6 +12960,8 @@ def cmd_dashboard(args: argparse.Namespace) -> int:
     update_check_stop = threading.Event()
     update_check_thread = _DashboardUpdateCheckThread(
         update_check_stop, hub=hub, snapshot_ref=ref, runtime_bind=args.host,
+        # #932 §4.2: serialize its republish with every snapshot publisher.
+        sync_lock=sync_lock,
     )
     update_check_thread.start()
 
@@ -12880,6 +13061,23 @@ def cmd_dashboard(args: argparse.Namespace) -> int:
                 file=sys.stderr,
             )
 
+    # #932: a frozen dashboard whose first build DEFERRED (an older-epoch
+    # index or a detached heal) has no sync thread to replace that frame, so a
+    # one-shot settle loop retries the no-ingest build until recovery permits
+    # it. Started after the server objects exist and immediately before the
+    # shutdown-managed region below.
+    frozen_settle_stop = threading.Event()
+    frozen_settle_thread = None
+    if args.no_sync and _cctally()._cctally_tui._tui_snapshot_is_stats_deferral(
+            initial):
+        frozen_settle_thread = _make_frozen_deferral_settle_thread(
+            stop=frozen_settle_stop,
+            interval=float(args.sync_interval),
+            ref=ref, hub=hub, sync_lock=sync_lock,
+            run_sync_now_locked=_run_sync_now_locked,
+        )
+        frozen_settle_thread.start()
+
     # Block the main thread until SIGINT/SIGTERM. The wait is driven by a
     # self-pipe wakeup fd (signal.set_wakeup_fd) rather than a
     # threading.Event, so a single signal unblocks it unconditionally — the
@@ -12900,6 +13098,12 @@ def cmd_dashboard(args: argparse.Namespace) -> int:
         _lib_write_io.clear_local_instance()
         if sync_thread is not None:
             sync_thread.stop()
+        # #932: fence the settle thread through `sync_lock` BEFORE the memory
+        # verifiers, their completion locks, the server and the hub retire.
+        if frozen_settle_thread is not None:
+            _retire_frozen_deferral_settle(
+                stop=frozen_settle_stop, sync_lock=sync_lock,
+                thread=frozen_settle_thread)
         conversation_sync_stop.set()
         if conversation_sync_thread is not None:
             conversation_sync_thread.join(timeout=2)

package/bin/_cctally_dashboard_conversation.py

@@ -639,7 +639,11 @@ def _codex_observation_hold_only(stats, *, executor_owned=False):
         return False
     if getattr(stats, "barrier_retry", False) and not executor_owned:
         return False
-    skipped = getattr(stats, "container_skipped", {})
+    # #1052: every skip the pass saw, its unit phase's included, when the
+    # stats object splits them; otherwise its single census dict.
+    every_skip = getattr(stats, "all_container_skipped", None)
+    skipped = (every_skip() if callable(every_skip)
+               else getattr(stats, "container_skipped", {}))
     return (bool(getattr(stats, "container_pending", 0) or any(skipped.values()))
             and set(skipped) <= {
                 "decoder-unavailable", "decode-error", "read-error",

package/bin/_cctally_dashboard_envelope.py

@@ -1274,6 +1274,25 @@ def _sync_failure_envelope(
             "action": "cctally db repair --db stats --yes",
         }
 
+    # #932 §4.1: an epoch deferral whose admission FAILED has no rebuild
+    # running (no marker, no worker), so "rebuilding" would be false. It is the
+    # existing server-sync error until a later admission succeeds.
+    def field(item, key, default=None):
+        return (item.get(key, default) if isinstance(item, dict)
+                else getattr(item, key, default))
+
+    for item in attributions or ():
+        if (field(item, "database") == "stats"
+                and not bool(field(item, "corruption", False))
+                and bool(field(item, "deferred", False))
+                and field(item, "deferral_outcome") == "failed"):
+            return {
+                "kind": "server_sync",
+                "label": "⚠ server sync error",
+                "detail": "The server could not complete its background sync.",
+                "action": None,
+            }
+
     if attributed("stats"):
         return {
             "kind": "maintenance_active",
@@ -1676,6 +1695,29 @@ def _header_rate_and_delta(current_rate, current_week_start, trend):
     return current_rate, None
 
 
+def current_week_freshness(captured, *, now_utc: "dt.datetime",
+                           oauth_usage_cfg: "dict | None" = None
+                           ) -> "dict | None":
+    """`current_week.freshness` (``{label, captured_at, age_seconds}``) of a
+    confirming-reading instant, or None when there is none. The one
+    derivation the envelope and the source payload's idle refresh share
+    (#1018 twin spec 5.4/5.5)."""
+    if not isinstance(captured, dt.datetime):
+        return None
+    if captured.tzinfo is None:
+        captured = captured.replace(tzinfo=dt.timezone.utc)
+    age_s = max(0.0, (now_utc - captured).total_seconds())
+    _fresh_cfg = (
+        oauth_usage_cfg if oauth_usage_cfg is not None
+        else sys.modules["cctally"]._OAUTH_USAGE_DEFAULTS
+    )
+    return {
+        "label":        sys.modules["cctally"]._freshness_label(age_s, _fresh_cfg),
+        "captured_at":  _iso_z(captured),
+        "age_seconds":  int(age_s),
+    }
+
+
 def snapshot_to_envelope(snap: "DataSnapshot", *,
                          now_utc: "dt.datetime",
                          monotonic_now: "float | None" = None,
@@ -1850,25 +1892,14 @@ def snapshot_to_envelope(snap: "DataSnapshot", *,
             elif tp == 90:
                 budget_90 = dpd
 
-    # Freshness envelope for current_week — derived from
-    # cw.latest_snapshot_at (a datetime, not an ISO string). None when
-    # cw is absent or has no snapshot timestamp; the React client renders
-    # a placeholder in that case. Refs spec §3.4.
-    cw_freshness: "dict | None" = None
-    if cw is not None and cw.latest_snapshot_at is not None:
-        captured = cw.latest_snapshot_at
-        if captured.tzinfo is None:
-            captured = captured.replace(tzinfo=dt.timezone.utc)
-        age_s = max(0.0, (now_utc - captured).total_seconds())
-        _fresh_cfg = (
-            oauth_usage_cfg if oauth_usage_cfg is not None
-            else sys.modules["cctally"]._OAUTH_USAGE_DEFAULTS
-        )
-        cw_freshness = {
-            "label":        sys.modules["cctally"]._freshness_label(age_s, _fresh_cfg),
-            "captured_at":  _iso_z(captured),
-            "age_seconds":  int(age_s),
-        }
+    # Freshness envelope for current_week (spec §3.4) — derived from
+    # cw.latest_weekly_reading_at, the newest genuine reading confirming the
+    # displayed value (#1018 twin spec 5.4). None when cw is absent or has no
+    # resolvable confirmation; the React client renders a placeholder then.
+    # `last_snapshot_age_sec` below keeps the stored row's capture.
+    cw_freshness = current_week_freshness(
+        None if cw is None else getattr(cw, "latest_weekly_reading_at", None),
+        now_utc=now_utc, oauth_usage_cfg=oauth_usage_cfg)
 
     week_lbl: "str | None" = None
     reset_at_utc: "dt.datetime | None" = None
@@ -2557,6 +2588,16 @@ def snapshot_to_envelope(snap: "DataSnapshot", *,
         # PREVIEW badge when set.
         **sys.modules["_cctally_dashboard"]._channel_env_fragment(),
     }
+    # #836 (spec 5.1): the displayed account, decorated builds ONLY. Below the
+    # R8 threshold both keys are omitted (never null), so an undecorated
+    # `current_week` keeps its bytes. Appended after the literal so the key
+    # order of every existing field is unchanged. This identity — never
+    # `five_hour_block.account_key`, absent with no live block — is what the
+    # client labels and scopes its history navigation by.
+    if (cw is not None and getattr(cw, "account_decorated", False)
+            and isinstance(envelope.get("current_week"), dict)):
+        envelope["current_week"]["account_key"] = cw.account_key
+        envelope["current_week"]["account_label"] = cw.account_label
     envelope.update(_source_bundle_to_envelope(getattr(snap, "source_bundle", None)))
     _overlay_claude_source_session_titles(envelope, snap, transcripts_visible)
     _overlay_codex_source_session_labels(envelope, snap, transcripts_visible)

package/bin/_cctally_dashboard_sources.py

@@ -1490,6 +1490,7 @@ def resolve_dashboard_source_semantics(
     config: Mapping[str, object] | None,
     *,
     display_tz_name: str | None,
+    speed: str | None = None,
 ) -> DashboardSourceSemantics:
     """Resolve dashboard semantics through the shipped CLI kernels.
 
@@ -1497,12 +1498,17 @@ def resolve_dashboard_source_semantics(
     it preserves the CLI's all-$CODEX_HOME fast-service-tier behavior.  The
     weekly index comes from the same ``get_week_start_name``/``WEEKDAY_MAP``
     pair used by the report and budget command surfaces.
+
+    ``speed`` (#1050 spec 4.7) is a tier that resolver already returned this
+    tick — the dashboard captures it beside its dispatch read and keys the idle
+    gate on it — so the build uses that one value; ``None`` resolves here.
     """
     c = sys.modules["cctally"]
     raw_config = dict(config or {})
     week_start_name = get_week_start_name(raw_config)
     week_start_idx = c.WEEKDAY_MAP[week_start_name]
-    speed = c._resolve_codex_speed("auto")
+    if speed is None:
+        speed = c._resolve_codex_speed("auto")
     budget_config = c._get_budget_config(raw_config)
     quota_alerts = c._get_quota_alerts_config(raw_config)
     raw_cache_report = raw_config.get("cache_report")
@@ -5929,6 +5935,20 @@ def reset_codex_account_scope_cache(*, keep_counters: bool = False) -> None:
     _CODEX_DERIVED_COHERENCE.clear()
 
 
+def _codex_cycle_index_cost_inputs(context: "DashboardReadContext") -> dict:
+    """The cost inputs every Codex cycle stamp names (#1050 spec 4.7): this
+    read's cache handle and resolved speed, and — when the build computed it
+    for its own signature — the `codex_stats_digest` that admits the index's
+    process memo."""
+    stats_identity = context.stats_identity
+    return {
+        "cache_conn": context.cache_conn,
+        "speed": context.speed,
+        "stats_digest": (
+            stats_identity[0] if stats_identity is not None else None),
+    }
+
+
 def _codex_account_scopes_wire(
     context: DashboardReadContext,
     *,
@@ -6060,6 +6080,7 @@ def _codex_account_scopes_wire(
                     sys.modules["cctally"].build_codex_cycle_index(
                         context.stats_conn, identity=cycle,
                         now_utc=context.now_utc, account_key=key,
+                        **_codex_cycle_index_cost_inputs(context),
                     )
                 )
             except sqlite3.Error:
@@ -8704,6 +8725,7 @@ def _build_codex_source_state(
             cycle_index = tuple(
                 sys.modules["cctally"].build_codex_cycle_index(
                     context.stats_conn, identity=cycle, now_utc=context.now_utc,
+                    **_codex_cycle_index_cost_inputs(context),
                 )
             )
         except sqlite3.Error: