cctally 1.117.2 → 1.118.1

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

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: