cctally 1.117.0 → 1.117.2

package/bin/_lib_dashboard_sources.py

@@ -1020,14 +1020,22 @@ def _decorated_combined_leg(
             5, provider, "account_reconciliation_failed"),)
 
     total = math.fsum(cost for _key, cost in card_rows)
-    hero = _combined_hero(state)
-    hero_cost = hero.get("cost_usd") if hero is not None else None
-    if (
-        _counter_reason(hero_cost, integral=False) is not None
-        or abs(float(hero_cost) - total) > 1e-9
-    ):
-        return None, (_CombinedCause(
-            5, provider, "account_reconciliation_failed"),)
+    # The cards and their certified contributions above (keys, order, costs
+    # within 1e-9, periods) are what certify the leg, and the headline is their
+    # sum. A decorated Codex hero IS that sum (`build_codex_source_state`), so
+    # it must still agree. A decorated Claude hero is not: under #836's U3 it is
+    # the DISPLAYED account's own spend, by design one card rather than all of
+    # them, so requiring equality would withhold the combined headline on every
+    # multi-account Claude install.
+    if provider != "claude":
+        hero = _combined_hero(state)
+        hero_cost = hero.get("cost_usd") if hero is not None else None
+        if (
+            _counter_reason(hero_cost, integral=False) is not None
+            or abs(float(hero_cost) - total) > 1e-9
+        ):
+            return None, (_CombinedCause(
+                5, provider, "account_reconciliation_failed"),)
     return {
         "state": "current",
         "scope": "account_cycles",
@@ -2206,6 +2214,84 @@ def codex_stats_digest(stats_conn: sqlite3.Connection) -> str:
     )
 
 
+# #836 spec 5.7 item 1: the Claude weekly REJECTION state. A weekly credit's
+# retry can retire a stale replica in place with no new snapshot and a
+# deduplicated reset, and a suppression replacement or a convergence can
+# restore one; a DELETE of a referenced snapshot rewrites the milestone's FK to
+# the `0` sentinel without moving any `MAX(id)`. None of those moves another
+# signature leg, so this one digests the two relations they change:
+#
+#   * the suppression-retired snapshots (held, without the held-write payload
+#     marker), which the card's sample selection depends on;
+#   * the five-hour milestones whose effective weekly join is unavailable
+#     (absent snapshot, the `0` sentinel, or retired), which every published
+#     `effective_seven_day_pct_at_crossing` depends on.
+#
+# The predicates are `_cctally_five_hour.effective_weekly_value_sql` /
+# `weekly_join_unavailable_sql`'s, spelled here because this kernel may not
+# import the glue. Ids only, rowid-ordered (no sorter); both relations are
+# empty on a store that never retired a row, and the wrapper maps that state to
+# "" so `data_version` and the Claude source version keep their bytes.
+_WEEKLY_RETIRED_PREDICATE = (
+    "{a}weekly_observation_held = 1 AND "
+    "json_extract({a}payload_json, '$.weeklyObservationHeld') IS NOT 1"
+)
+
+
+def _claude_weekly_retired_relations(
+    stats_conn: sqlite3.Connection,
+) -> tuple[tuple[str, str], ...]:
+    try:
+        cols = {str(row[1]) for row in stats_conn.execute(
+            "PRAGMA table_info(weekly_usage_snapshots)")}
+    except sqlite3.Error:
+        cols = set()
+    if "weekly_observation_held" in cols:
+        retired = _WEEKLY_RETIRED_PREDICATE.format(a="")
+        unavailable = ("s.id IS NULL OR ("
+                       + _WEEKLY_RETIRED_PREDICATE.format(a="s.") + ")")
+    else:
+        # A store without the column cannot hold a held row
+        # (`_cctally_core.weekly_held_exclusion`).
+        retired = "0"
+        unavailable = "s.id IS NULL"
+    return (
+        (
+            "weekly_usage_snapshots_retired",
+            f"SELECT id FROM weekly_usage_snapshots WHERE {retired} "
+            "ORDER BY id",
+        ),
+        (
+            "five_hour_milestones_unavailable_join",
+            "SELECT m.id FROM five_hour_milestones AS m "
+            "LEFT JOIN weekly_usage_snapshots AS s ON s.id = m.usage_snapshot_id "
+            f"WHERE {unavailable} ORDER BY m.id",
+        ),
+    )
+
+
+#: `_stats_relations_digest` over two EMPTY relations: the no-rejection state.
+_EMPTY_TWO_RELATION_DIGEST = hashlib.sha256(b"[[],[]]").hexdigest()
+
+
+def claude_weekly_retired_digest(stats_conn: sqlite3.Connection) -> str:
+    """One digest over the Claude weekly rejection state (#836, spec 5.7
+    item 1), or ``""`` when no snapshot is retired and no five-hour
+    milestone's join is unavailable.
+
+    Read through `_stats_relations_digest` under its own memo namespace,
+    statement-scoped and outside any stats transaction (as
+    `_tui_compute_dispatch_signature` reads every stats leg), so a settled
+    rollback-journal index costs no scan on an idle tick.
+    """
+    digest = _stats_relations_digest(
+        stats_conn,
+        _claude_weekly_retired_relations(stats_conn),
+        memo_namespace="claude_weekly_retired",
+    )
+    return "" if digest == _EMPTY_TWO_RELATION_DIGEST else digest
+
+
 # #1015 spec 5.4: the two relation digests of the dashboard dispatch key's
 # `calibration_dependency` component. Neither is a `SnapshotSignature` leg, so
 # the published `data_version` contract is unchanged; both ride the dispatch

package/bin/_lib_quota_model.py

@@ -866,6 +866,24 @@ def family_participation(family: str | None) -> str:
     return FAMILY_PARTICIPATION.get(family, "unknown")
 
 
+def _float_total(values) -> float:
+    """`math.fsum` of `values`, or the plain `sum()` when `fsum` cannot.
+
+    `fsum` is correctly rounded, so a total is the same on Python 3.11, whose
+    float `sum()` is uncompensated, and on 3.12+, whose `sum()` is not; a
+    plain sum printed different last digits from one interpreter to the next.
+    But `fsum` raises where `sum()` saturates: `OverflowError` once finite
+    terms pass the float range, `ValueError` on `inf + -inf`. The plain sum's
+    `inf`/`nan` is what the section-39 `_finite_quantity` guards withhold, so
+    that path returns it unchanged rather than raising out of the kernel.
+    """
+    items = list(values)
+    try:
+        return math.fsum(items)
+    except (OverflowError, ValueError):
+        return sum(items)
+
+
 def _finite_quantity(value) -> bool:
     """True when a token quantity is a real, finite number.
 
@@ -1001,8 +1019,8 @@ def class_units(classes, era: CoefficientEra) -> float:
     a multiplication of its own.
     """
     weights = era.weight_map()
-    return sum(float(classes.get(name, 0.0)) * weights[name]
-               for name in TOKEN_CLASSES)
+    return _float_total(float(classes.get(name, 0.0)) * weights[name]
+                        for name in TOKEN_CLASSES)
 
 
 class EntryWeighting(typing.NamedTuple):
@@ -1463,7 +1481,7 @@ def build_daily_series(segments, entries, *, now, newest_entry_at,
             entry_units = class_units(quantities, era)
             units += entry_units
             families[family] = families.get(family, 0.0) + entry_units
-        raw_total = sum(raw.values())
+        raw_total = _float_total(raw.values())
 
         # Cause precedence follows STATUS_PRECEDENCE: an unknown split
         # outranks incomplete history, which outranks an unsupported mix.
@@ -1698,7 +1716,7 @@ def composition_centre(vectors) -> dict[str, float] | None:
         return None
     keys = sorted({k for row in rows for k in row})
     raw = {k: median([row.get(k, 0.0) for row in rows]) for k in keys}
-    total = sum(raw.values())
+    total = _float_total(raw.values())
     if not math.isfinite(total) or total <= 0.0:
         return None
     return {k: v / total for k, v in raw.items()}
@@ -1825,8 +1843,8 @@ def aggregate_composition(entries, *, era: CoefficientEra) -> tuple | None:
             raw[name] += qty
         units = class_units(quantities, era)
         families[family] = families.get(family, 0.0) + units
-    raw_total = sum(raw.values())
-    unit_total = sum(families.values())
+    raw_total = _float_total(raw.values())
+    unit_total = _float_total(families.values())
     if not _finite_quantity(raw_total) or not _finite_quantity(unit_total):
         return None
     if raw_total <= 0.0 or unit_total <= 0.0:
@@ -2060,8 +2078,8 @@ def jackknife_fit(days) -> tuple[float, Interval] | None:
     if any(not _finite_quantity(d.units) or not _finite_quantity(d.meter_delta)
            for d in rows):
         return None
-    total_units = sum(d.units for d in rows)
-    total_meter = sum(d.meter_delta for d in rows)
+    total_units = _float_total(d.units for d in rows)
+    total_meter = _float_total(d.meter_delta for d in rows)
     if total_meter <= 0.0 or total_units <= 0.0:
         return None
     point = total_units / total_meter
@@ -2071,10 +2089,10 @@ def jackknife_fit(days) -> tuple[float, Interval] | None:
         if rest_meter <= 0.0:
             return None
         replicates.append((total_units - row.units) / rest_meter)
-    mean = sum(replicates) / n
+    mean = _float_total(replicates) / n
     # A product, not `** 2`, which is the C library's `pow`.
-    se = math.sqrt((n - 1) / n * sum((v - mean) * (v - mean)
-                                     for v in replicates))
+    se = math.sqrt((n - 1) / n * _float_total((v - mean) * (v - mean)
+                                              for v in replicates))
     half = t_quantile_975(n - 1) * se
     return point, Interval(max(0.0, point - half), point + half)
 

package/bin/_lib_snapshot_cache.py

@@ -131,6 +131,12 @@ class SnapshotSignature(NamedTuple):
     # legs above, this one is a digest and is never empty: a store with no
     # armed Claude alert carries a constant hash, not the empty string.
     claude_stats_digest: str = ""
+    # #836 spec 5.7 item 1: the Claude weekly rejection state
+    # (`_lib_dashboard_sources.claude_weekly_retired_digest`) — a credit
+    # retry's in-place retirement, a restoration, or the deletion of a
+    # referenced snapshot moves no leg above. Empty on a store with no retired
+    # snapshot and no unavailable five-hour join, so it is byte-neutral there.
+    claude_weekly_retired_digest: str = ""
 
 
 def _max_id(conn: sqlite3.Connection, table: str) -> int:
@@ -247,6 +253,7 @@ def compute_signature(
     codex_stats_digest: str = "",
     accounts_digest: str = "",
     claude_stats_digest: str = "",
+    claude_weekly_retired_digest: str = "",
 ) -> SnapshotSignature:
     """Composite data-version signature across cache.db + stats.db (spec §3).
 
@@ -273,6 +280,7 @@ def compute_signature(
         accounts_digest=str(accounts_digest),
         codex_ingest_backlog_sig=_codex_ingest_backlog_sig(cache_conn),
         claude_stats_digest=str(claude_stats_digest),
+        claude_weekly_retired_digest=str(claude_weekly_retired_digest),
     )
 
 

package/bin/_lib_tick_stats.py

@@ -35,12 +35,17 @@ import types
 import _lib_write_io
 
 RING_CAPACITY = 64
-MEMORY_BUDGET_BYTES = 65536
+#: Raised from 65,536 for the v1.117.1 cut: the #939 D5 admission-hold
+#: state put the full rings plus the write state at 65,032 bytes on
+#: Python 3.12 and 3.13 but 66,000 on 3.11, whose objects are larger.
+#: The bound stays structural (ring capacities, PUBLISHED_AT_MAX_CHARS);
+#: this figure only checks it on every supported interpreter.
+MEMORY_BUDGET_BYTES = 73728
 
 #: `published_at` is the only variable-length field in a record, so it is the
 #: only one that can put the whole state over `MEMORY_BUDGET_BYTES`. Measured:
 #: the stored field set is 27,189 bytes over a full ring, and 64 distinct 4 KiB
-#: strings would be 283,039 — 4.3x over budget. All three production callers
+#: strings would be 283,039 — 3.8x over budget. All three production callers
 #: pass a UTC ISO-8601 instant (32 characters), so this is not reachable today;
 #: the cap makes the budget hold by CONSTRUCTION rather than by convention.
 PUBLISHED_AT_MAX_CHARS = 64
@@ -154,7 +159,7 @@ class ConversationSyncRecord:
 MAINTENANCE_PHASES = ("delete", "reclaim", "checkpoint", "other")
 
 #: The maintenance ring is deliberately SHORTER than the two tick rings. The
-#: whole published state is capped at a frozen 65,536 bytes, and a third
+#: whole published state is capped at a frozen 73,728 bytes, and a third
 #: full-length ring would spend that budget on a phase that runs about once a
 #: day rather than about once a second. Sixteen records is several weeks of
 #: maintenance history at the throttled cadence, and many continuation passes
@@ -181,7 +186,7 @@ MAINTENANCE_SKIP_REASONS = (
 SQLITE_SOURCE_ID_MAX_CHARS = 96
 PLAN_DIGEST_MAX_CHARS = 16
 #: One shared object per distinct SQLite source id, so sixteen records of
-#: one runtime hold one string (the 65,536-byte budget).
+#: one runtime hold one string (the 73,728-byte budget).
 _SOURCE_IDS: "dict[str, str]" = {}
 
 
@@ -224,7 +229,7 @@ class MaintenancePhaseRecord:
     # #901 Q8 (a deletion's reservation inputs) and Q9 (a reclaim chunk's
     # plan and outcome, §5.5): `OPERATION_INT_FIELDS` packed into ONE
     # array, -1 for "not recorded", because sixteen records of twenty
-    # separate int objects do not fit the frozen 65,536-byte budget. Read
+    # separate int objects do not fit the frozen 73,728-byte budget. Read
     # them by name (`record.page_count`); `as_wire` publishes them by name.
     numbers: "array.array | None" = None   # typecode "i"
 

package/bin/_lib_write_io.py

@@ -499,7 +499,7 @@ def local_instance() -> "dict | None":
 
 
 def state_for_budget() -> tuple:
-    """Every object this module retains, for the 65,536-byte state test."""
+    """Every object this module retains, for the tick-stats state budget."""
     state = _STATE
     return (state.t, state.b, state.p, state.ledger, state.ex[0],
             state.ex[1:], state.open, state.hysteresis, state.local_instance,

package/bin/cctally

@@ -1772,6 +1772,10 @@ BudgetRow = _cctally_forecast.BudgetRow
 _resolve_forecast_now = _cctally_forecast._resolve_forecast_now
 _fetch_current_week_snapshots = _cctally_forecast._fetch_current_week_snapshots
 _apply_midweek_reset_override = _cctally_forecast._apply_midweek_reset_override
+ClaudeCycleScope = _cctally_forecast.ClaudeCycleScope
+_claude_select_current_owner = _cctally_forecast._claude_select_current_owner
+_claude_current_cycle_scope = _cctally_forecast._claude_current_cycle_scope
+_claude_cycle_scope_samples = _cctally_forecast._claude_cycle_scope_samples
 _current_week_five_hour_percent = _cctally_forecast._current_week_five_hour_percent
 _current_week_five_hour_reading = _cctally_forecast._current_week_five_hour_reading
 _resolve_current_budget_window = _cctally_forecast._resolve_current_budget_window