cctally 1.65.0 → 1.67.0

package/bin/_cctally_percent_breakdown.py

@@ -156,7 +156,7 @@ def cmd_percent_breakdown(args: argparse.Namespace) -> int:
         }
 
         if args.json:
-            print(json.dumps(output, indent=2))
+            print(json.dumps(c.stamp_schema_version(output), indent=2))
             return 0
 
         # Prefer the reset-adjusted ISO timestamps in the terminal header

package/bin/_cctally_pricing_check.py

@@ -283,6 +283,14 @@ def cmd_pricing_check(args: argparse.Namespace) -> int:
 
     drift = {"value_drift": [], "missing_from_us": [], "ahead_of_litellm": []}
     existence = {"status": "skipped", "unpriced_vendor_models": []}
+    # staleSuppressions is network-derived (needs the LiteLLM scoped table), so
+    # under --offline it is SKIPPED, not degraded — matching the offline branch,
+    # which leaves degraded_components empty (#279 S7 W7). expiredSuppressions is
+    # date-derived and runs OFFLINE too, off the _command_as_of() clock seam.
+    stale_suppressions: list = []
+    expired_suppressions = _lib_pricing_check.expired_allowlist_entries(
+        c.PRICING_DRIFT_ALLOWLIST, now_utc,
+    )
 
     if not args.offline:
         litellm, ok = _fetch_litellm_prices()
@@ -297,6 +305,10 @@ def cmd_pricing_check(args: argparse.Namespace) -> int:
                 "missing_from_us": list(res.missing_from_us),
                 "ahead_of_litellm": list(res.ahead_of_litellm),
             }
+            stale_suppressions = _lib_pricing_check.stale_allowlist_entries(
+                c.PRICING_DRIFT_ALLOWLIST, c.CLAUDE_MODEL_PRICING,
+                c.CODEX_MODEL_PRICING, scoped,
+            )
         else:
             status = "degraded"
             degraded.append("litellm")
@@ -307,11 +319,15 @@ def cmd_pricing_check(args: argparse.Namespace) -> int:
 
     # Actionable = any finding on a leg that ran. `ahead_of_litellm` is
     # NEVER actionable (invariant #2). A degraded leg contributes no finding.
+    # A stale OR expired suppression is actionable (remove the allowlist entry /
+    # re-sync the snapshot) — both wired in explicitly (#279 S7 W7).
     actionable = (
         bool(coverage)
         or bool(drift["value_drift"])
         or bool(drift["missing_from_us"])
         or bool(existence["unpriced_vendor_models"])
+        or bool(stale_suppressions)
+        or bool(expired_suppressions)
     )
 
     payload = {
@@ -322,6 +338,12 @@ def cmd_pricing_check(args: argparse.Namespace) -> int:
         "coverage": [dataclasses.asdict(g) for g in coverage],
         "drift": drift,
         "existence": existence,
+        # Additive keys on the existing schemaVersion 1 envelope (no bump — CLI
+        # contract additive rule). staleSuppressions: allowlist entries whose
+        # divergence no longer exists (network). expiredSuppressions: allowlist
+        # entries past their `expires` cutover (date).
+        "staleSuppressions": list(stale_suppressions),
+        "expiredSuppressions": list(expired_suppressions),
         "litellmSource": c.LITELLM_PRICES_URL,
     }
 
@@ -385,6 +407,23 @@ def _render_pricing_check_text(payload: dict, *, offline: bool, actionable: bool
                 out("\n  Existence: all vendor models priced.\n")
         elif ex["status"] == "degraded":
             out("\n  Existence: /v1/models unavailable (skipped).\n")
+        stale = payload.get("staleSuppressions") or []
+        if stale:
+            out(f"\n  Stale suppressions ({len(stale)}) — the divergence no "
+                f"longer exists, remove the allowlist entry:\n")
+            for e in stale:
+                fld = f".{e['field']}" if e.get("field") else ""
+                out(f"    • {e['model']}{fld}\n")
+
+    # Expired suppressions are date-derived, so they render in BOTH offline and
+    # online modes.
+    expired = payload.get("expiredSuppressions") or []
+    if expired:
+        out(f"\n  Expired suppressions ({len(expired)}) — past their `expires` "
+            f"cutover, remove the allowlist entry / re-sync the snapshot:\n")
+        for e in expired:
+            fld = f".{e['field']}" if e.get("field") else ""
+            out(f"    • {e['model']}{fld} (expired {e.get('expires')})\n")
 
     # Single-sourced from cmd_pricing_check's exit-code predicate (don't
     # recompute the four-clause boolean here — it would drift).

package/bin/_cctally_project.py

@@ -28,7 +28,7 @@ import sys
 
 from _cctally_core import (
     _command_as_of,
-    _reset_aware_floor,
+    _floored_week_max,
     eprint,
     open_db,
     parse_iso_datetime,
@@ -82,45 +82,18 @@ def _load_week_snapshots(
             "AND datetime(week_end_at) > datetime(?)",
             (until.isoformat(), since.isoformat()),
         )
-        rows = cur.fetchall()
-        # Resolve each week's clamp floor once (keyed on week_start_date) so a
-        # mid-week credit doesn't re-inflate the per-project Used %. None means
-        # "no floor" — every captured row counts.
-        floor_epoch: dict[str, int | None] = {}
-
-        def _floor_for(wsd, ws_iso, we_iso):
-            if wsd not in floor_epoch:
-                f_iso = _reset_aware_floor(conn, wsd, ws_iso, we_iso)
-                floor_epoch[wsd] = (
-                    int(parse_iso_datetime(f_iso, "project.floor").timestamp())
-                    if f_iso else None
-                )
-            return floor_epoch[wsd]
-
-        result: dict[dt.datetime, float] = {}
-        for wsd, ws_iso, we_iso, cap_iso, pct in rows:
+        rows_in = []
+        for wsd, ws_iso, we_iso, cap_iso, pct in cur.fetchall():
             if ws_iso is None or pct is None:
                 continue
-            floor = _floor_for(wsd, ws_iso, we_iso)
-            if floor is not None and cap_iso is not None:
-                try:
-                    cap_epoch = int(
-                        parse_iso_datetime(str(cap_iso), "project.cap").timestamp()
-                    )
-                except ValueError:
-                    cap_epoch = None
-                # Drop pre-floor (stale pre-credit) snapshots from the MAX.
-                if cap_epoch is not None and cap_epoch < floor:
-                    continue
-            ws = dt.datetime.fromisoformat(
-                str(ws_iso).replace("Z", "+00:00")
-            )
+            ws = dt.datetime.fromisoformat(str(ws_iso).replace("Z", "+00:00"))
             key = ws.astimezone(dt.timezone.utc)
-            pct_f = float(pct)
-            prev = result.get(key)
-            if prev is None or pct_f > prev:
-                result[key] = pct_f
-        return result
+            rows_in.append((key, wsd, ws_iso, we_iso, cap_iso, pct))
+        # Reset-aware per-week max (#290): the shared reducer resolves each
+        # week's clamp floor once (keyed on week_start_date) and drops stale
+        # pre-credit captures before taking the per-week maximum. The query
+        # above already filters NULL bounds, so canonical bounds are present.
+        return _floored_week_max(conn, rows_in)
     finally:
         conn.close()
 
@@ -352,7 +325,7 @@ def _project_json_output(
         "projects": projects_json,
         "warnings": warnings,
     }
-    return json.dumps(payload, indent=2)
+    return json.dumps(_cctally().stamp_schema_version(payload), indent=2)
 
 
 def _project_sort_key(row: dict, sort_by: str, order: str):
@@ -390,10 +363,10 @@ def cmd_project(args: argparse.Namespace) -> int:
     # Flag-combination validation (must run before any expensive work).
     if args.weeks is not None and args.weeks < 1:
         eprint("Error: --weeks must be >= 1")
-        return 1
+        return 2
     if args.weeks is not None and (args.since or args.until):
         eprint("Error: --weeks cannot be combined with --since/--until")
-        return 1
+        return 2
     if args.since and args.until:
         # Parse both as dates using the same multi-format helper shape used
         # elsewhere in the codebase so YYYY-MM-DD and YYYYMMDD both compare
@@ -415,7 +388,7 @@ def cmd_project(args: argparse.Namespace) -> int:
         # complaint triggered by garbage input).
         if since_parsed is not None and until_parsed is not None and since_parsed > until_parsed:
             eprint("Error: --since must be <= --until")
-            return 1
+            return 2
 
     now = _command_as_of()
     conn = open_db()
@@ -424,7 +397,10 @@ def cmd_project(args: argparse.Namespace) -> int:
     if args.since or args.until:
         parsed = c._parse_cli_date_range(args, now_utc=now)
         if isinstance(parsed, int):
-            return parsed
+            # Translate the ccusage-parity helper's exit 1 into project's own
+            # native usage code 2 — project is cctally-native, not a ccusage
+            # drop-in (docs/cli-contract.md; #279 S6 W2).
+            return 2
         since_dt, until_dt = parsed
         since_dt = since_dt.astimezone(dt.timezone.utc)
         until_dt = until_dt.astimezone(dt.timezone.utc)