cctally 1.26.0 → 1.27.1

package/CHANGELOG.md

@@ -5,6 +5,19 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.27.1] - 2026-06-04
+
+### Fixed
+- **Three Linux-only bugs, surfaced by running the full test suite on Linux for the first time** (cctally is developed on macOS, whose case-insensitive filesystem and BSD tooling had masked them): (1) `cctally statusline` with `display.tz = utc` no longer prints a spurious `invalid timezone 'utc'; using 'UTC'` warning on Linux — the lowercase `utc` preference is now normalized to the portable IANA key `UTC` before resolution (Linux's case-sensitive zoneinfo rejects `"utc"` where macOS silently accepts it); (2) the local web dashboard's background update-check thread no longer crashes with `TypeError: 'Event' object is not callable` when the dashboard shuts down — its internal stop-event field was shadowing `threading.Thread._stop`, which `Thread.join()` invokes during teardown; (3) `cctally setup --uninstall` now reliably terminates a running legacy usage-poller on Linux even when it was launched from a long filesystem path — the process-identity check passes `ps -ww` (unlimited-width output) so Linux's default ~80-column truncation can't drop the identifying token and mis-read the live daemon as a dead PID. No action needed on upgrade.
+
+### Changed
+- **Internal (no user-facing change): the full test suite (`bin/cctally-test-all`) is now Linux-portable, and a GitHub-hosted Linux matrix (Ubuntu × Python 3.11/3.12/3.13) runs it on every tag, weekly, and on demand** — closing the cross-version verification gap left when the floor was lowered to 3.11 in 1.27.0. The portability work fixed interpreter- and OS-divergences that only ever ran on macOS before: a `pytest-xdist` timezone leak (one test pinned a Pacific `tzset()` whose libc state outlived `monkeypatch`, flipping later tests' date boundaries — now reset suite-wide via an autouse `conftest` fixture), terminal-width-dependent block-gap rendering under `COLUMNS=80`, Python 3.13's `~~~^^^` traceback caret-anchors in a migration golden, the macOS-`osascript`-vs-Linux-`notify-send` notifier-dispatch assumptions, a BSD-vs-util-linux `script` PTY invocation in the update-banner harness (now a portable `pty.spawn`), a host-config leak in the dashboard-envelope golden, and a detached background update-check that raced fixture teardown. (#132)
+
+## [1.27.0] - 2026-06-04
+
+### Changed
+- **cctally now supports Python 3.11 and 3.12, not just 3.13.** The supported floor is lowered from 3.13 to 3.11 (Debian 12, Ubuntu 24.04, and other distros whose system `python3` is 3.11/3.12 can now run cctally without a newer interpreter). This was previously blocked by a one-cent floating-point rounding difference between Python versions in a rendered cost Total; rendered cost/percent totals now route through a `math.fsum`-backed exact-summation chokepoint, so every figure is byte-identical on 3.11/3.12/3.13 (verified by running the reporting suite on all three interpreters). Homebrew installs are unaffected (the formula still bundles its own modern Python). No action needed on upgrade.
+
 ## [1.26.0] - 2026-06-03
 
 ### Added

package/README.md

@@ -24,7 +24,7 @@ If you're using `ccusage` to watch Claude Code spend, `cctally` covers the same
 
 ## Installation
 
-**Requirements:** Python 3.13+, macOS or Linux, Claude Code installed and run at least once.
+**Requirements:** Python 3.11+, macOS or Linux, Claude Code installed and run at least once.
 
 ### Homebrew (macOS / Linux)
 

package/bin/_cctally_cache_report.py

@@ -19,6 +19,7 @@ from typing import Any, Literal, Optional
 from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 from _cctally_core import eprint, now_utc_iso, parse_iso_datetime, _command_as_of
+from _lib_fmt import stable_sum
 import _lib_cache_report as crk
 
 
@@ -467,10 +468,10 @@ def _render_cache_day_rows(
     tot_cc = sum(row.cache_creation_tokens for row in rows)
     tot_cr = sum(row.cache_read_tokens for row in rows)
     tot_tokens = sum(row.total_tokens for row in rows)
-    tot_cost = sum(row.cost for row in rows)
-    tot_saved = sum(row.saved_usd for row in rows)
-    tot_wasted = sum(row.wasted_usd for row in rows)
-    tot_net = sum(row.net_usd for row in rows)
+    tot_cost = stable_sum(row.cost for row in rows)
+    tot_saved = stable_sum(row.saved_usd for row in rows)
+    tot_wasted = stable_sum(row.wasted_usd for row in rows)
+    tot_net = stable_sum(row.net_usd for row in rows)
     tot_hit = crk._compute_cache_hit_percent(tot_inp, tot_cc, tot_cr)
     footer_cells = [
         ("Total", _yellow),
@@ -616,10 +617,10 @@ def _render_cache_session_rows(
     tot_cc = sum(r.cache_creation_tokens for r in rows)
     tot_cr = sum(r.cache_read_tokens for r in rows)
     tot_tokens = sum(r.total_tokens for r in rows)
-    tot_cost = sum(r.cost for r in rows)
-    tot_saved = sum(r.saved_usd for r in rows)
-    tot_wasted = sum(r.wasted_usd for r in rows)
-    tot_net = sum(r.net_usd for r in rows)
+    tot_cost = stable_sum(r.cost for r in rows)
+    tot_saved = stable_sum(r.saved_usd for r in rows)
+    tot_wasted = stable_sum(r.wasted_usd for r in rows)
+    tot_net = stable_sum(r.net_usd for r in rows)
     tot_hit = crk._compute_cache_hit_percent(tot_inp, tot_cc, tot_cr)
 
     footer_cells = [
@@ -991,13 +992,13 @@ def _emit_cache_report_json(
             "cacheCreationTokens": tot_cc,
             "cacheReadTokens": tot_cr,
             "totalTokens": sum(r.total_tokens for r in rows),
-            "cost": round(sum(r.cost for r in rows), 6),
+            "cost": round(stable_sum(r.cost for r in rows), 6),
             "cacheHitPercent": round(
                 crk._compute_cache_hit_percent(tot_inp, tot_cc, tot_cr), 2
             ),
-            "savedUsd": round(sum(r.saved_usd for r in rows), 6),
-            "wastedUsd": round(sum(r.wasted_usd for r in rows), 6),
-            "netUsd": round(sum(r.net_usd for r in rows), 6),
+            "savedUsd": round(stable_sum(r.saved_usd for r in rows), 6),
+            "wastedUsd": round(stable_sum(r.wasted_usd for r in rows), 6),
+            "netUsd": round(stable_sum(r.net_usd for r in rows), 6),
         },
         "generatedAt": now_utc_iso(now_utc=now_utc),
     }

package/bin/_cctally_dashboard.py

@@ -279,6 +279,7 @@ from _lib_display_tz import (
     _compute_display_block,
 )
 from _lib_aggregators import _aggregate_daily, _aggregate_monthly, _aggregate_weekly
+from _lib_fmt import stable_sum
 from _lib_pricing import _calculate_entry_cost, _chip_for_model, _short_model_name
 from _lib_five_hour import _canonical_5h_window_key
 from _lib_subscription_weeks import _compute_subscription_weeks
@@ -1319,7 +1320,7 @@ def _build_daily_share_panel_data(options: dict,
     # 7 and reverse to oldest→newest so the Recap template's days[-1]
     # anchor lands on today.
     last_7 = list(reversed(daily[:7]))
-    total = sum(float(getattr(r, "cost_usd", 0.0) or 0.0) for r in last_7) or 1.0
+    total = stable_sum(float(getattr(r, "cost_usd", 0.0) or 0.0) for r in last_7) or 1.0
     days: list[dict] = []
     for r in last_7:
         cost = float(getattr(r, "cost_usd", 0.0) or 0.0)
@@ -1721,10 +1722,10 @@ def _build_projects_share_panel_data(options: dict,
             wc = (tp.get("weekly_cost") or [])[-take:]
             wp = (tp.get("weekly_pct") or [])[-take:]
             ws = (tp.get("sessions_per_week") or [])[-take:]
-            cost = float(sum(wc))
+            cost = float(stable_sum(wc))
             running_total += cost
             valid_pct = [float(p) for p in wp if p is not None]
-            attributed = sum(valid_pct) if valid_pct else None
+            attributed = stable_sum(valid_pct) if valid_pct else None
             # Sum per-week distinct session counts. Slight over-count when a
             # single session spans a week boundary; the envelope's per-week
             # bucketing has no session-id sets to union, so this is the
@@ -1735,6 +1736,8 @@ def _build_projects_share_panel_data(options: dict,
                 "bucket_path":    tp["bucket_path"],
                 "cost_usd":       cost,
                 "attributed_pct": attributed,
+                # Integer session counts — bare sum() is exact (NOT a
+                # stable_sum float-output site; see test_stable_sum_chokepoint).
                 "sessions_count": int(sum(ws)),
             })
         rows.sort(key=lambda r: (-r["cost_usd"], r["key"]))
@@ -2193,14 +2196,14 @@ def build_cache_report_snapshot(
     # 7-day rollup: today + 6 prior. Walk by string date; ``days_newest_first``
     # is already in the right order.
     seven_day_rows = days[:7]
-    seven_day_net_usd = sum(r.net_usd for r in seven_day_rows)
+    seven_day_net_usd = stable_sum(r.net_usd for r in seven_day_rows)
     seven_day_anomaly_count = sum(
         1 for r in seven_day_rows if r.anomaly_triggered
     )
 
     # 14-day counterfactual: sum(saved_usd) across the window.
-    fourteen_day_counterfactual_usd = sum(r.saved_usd for r in days)
-    fourteen_day_wasted_usd = sum(r.wasted_usd for r in days)
+    fourteen_day_counterfactual_usd = stable_sum(r.saved_usd for r in days)
+    fourteen_day_wasted_usd = stable_sum(r.wasted_usd for r in days)
     denom = fourteen_day_counterfactual_usd + abs(fourteen_day_wasted_usd)
     fourteen_day_efficiency_ratio = (
         (fourteen_day_counterfactual_usd / denom) if denom > 1e-9 else 0.0
@@ -3431,7 +3434,7 @@ def _build_projects_envelope(
         })
     # Stable sort: desc by total window cost, ties broken by key.
     trend_projects.sort(
-        key=lambda p: (-sum(p["weekly_cost"]), p["key"]),
+        key=lambda p: (-stable_sum(p["weekly_cost"]), p["key"]),
     )
 
     trend_block = {
@@ -3762,7 +3765,7 @@ def _project_detail_for_window(
         sliced = weekly_pct_arr[-take:] if take > 0 else []
         wp = [p for p in sliced if p is not None]
         if wp:
-            win_pct = sum(wp)
+            win_pct = stable_sum(wp)
 
     # Best-effort cleanup of the per-call TEMP TABLE so a reused conn
     # doesn't carry path state into the next drill (tests share conns;

package/bin/_cctally_db.py

@@ -2066,7 +2066,7 @@ def _is_no_such_table_error(exc: sqlite3.OperationalError) -> bool:
 
       * Substring match on the lowercased message (stable for ~20 years).
       * ``exc.sqlite_errorcode == SQLITE_ERROR (1)`` (Python 3.11+;
-        cctally's floor is 3.13 per ``__min_python_version__``). The
+        cctally's floor is 3.11 per ``__min_python_version__``). The
         ``getattr(..., None) in (None, 1)`` form degrades gracefully if
         the attribute is ever missing — substring-only on legacy Python.
 

package/bin/_cctally_project.py

@@ -27,6 +27,7 @@ import os
 import sys
 
 from _cctally_core import _command_as_of, eprint, open_db, parse_iso_datetime
+from _lib_fmt import stable_sum
 
 
 def _cctally():
@@ -243,11 +244,11 @@ def _project_json_output(
     denominator used by per-project attribution). `models[]` is included
     per-project only when `--breakdown` is requested to avoid payload bloat.
     """
-    total_cost = sum(r["cost_usd"] for r in rows)
+    total_cost = stable_sum(r["cost_usd"] for r in rows)
     # Aggregate used % across all weeks with snapshots in the range.
     total_used_pct: float | None
     if week_snapshots:
-        total_used_pct = sum(week_snapshots.values())
+        total_used_pct = stable_sum(week_snapshots.values())
     else:
         total_used_pct = None
 

package/bin/_cctally_reporting.py

@@ -34,6 +34,7 @@ import sys
 from typing import Any
 
 from _cctally_core import _command_as_of, eprint, open_db, parse_iso_datetime
+from _lib_fmt import stable_sum
 
 
 def _cctally():
@@ -134,7 +135,7 @@ def cmd_daily(args: argparse.Namespace) -> int:
         if getattr(args, "instances", False):
             groups = c._aggregate_daily_by_project(keyed, tz=tz, mode=args.mode)
             aug = c._project_disambiguate_labels(
-                [{"key": k, "cost_usd": sum(b.cost_usd for b in bl)}
+                [{"key": k, "cost_usd": stable_sum(b.cost_usd for b in bl)}
                  for k, bl in groups]
             )
             json_groups: list = []

package/bin/_cctally_setup.py

@@ -998,11 +998,15 @@ def _legacy_stop_active_poller() -> str:
     # Ownership probe: the PID file is at a predictable /tmp path that
     # outlives the daemon on uncleanly exit, and macOS PIDs cycle in a
     # narrow space — verify the live process is actually our legacy
-    # poller before signaling. ps's `-o command=` emits the full cmdline
-    # with no header on both macOS BSD ps and Linux util-linux ps.
+    # poller before signaling. `-o command=` emits the cmdline with no
+    # header on both macOS BSD ps and Linux util-linux ps; `-ww` forces
+    # UNLIMITED width so the cmdline is never truncated. Without it,
+    # Linux util-linux ps clamps the column to ~80 chars (macOS BSD ps
+    # does not), so a poller launched from a long path drops the
+    # "usage-poller.py" token off the end → a false "stale-pid".
     try:
         probe = subprocess.run(
-            ["ps", "-p", str(pid), "-o", "command="],
+            ["ps", "-ww", "-p", str(pid), "-o", "command="],
             capture_output=True, text=True, timeout=2.0,
         )
     except (OSError, subprocess.TimeoutExpired):

package/bin/_cctally_share.py

@@ -19,6 +19,7 @@ import sys
 
 import _lib_changelog  # module-qualified: _lib_changelog._read_latest_changelog_version()
 from _lib_display_tz import format_display_dt
+from _lib_fmt import stable_sum
 from _lib_render import _project_disambiguate_labels
 
 
@@ -406,7 +407,7 @@ def _build_report_snapshot(
         avg_dpp = view.avg_dollars_per_pct
     else:
         avg_dpp = (
-            sum(p.y_value for p in chart_pts) / len(chart_pts)
+            stable_sum(p.y_value for p in chart_pts) / len(chart_pts)
             if chart_pts else 0.0
         )
     totals = (
@@ -627,7 +628,7 @@ def _build_monthly_snapshot(
         _lib_share.BarChart(points=tuple(chart_pts), y_label="$")
         if chart_pts else None
     )
-    sum_cost = sum(p.y_value for p in chart_pts)
+    sum_cost = stable_sum(p.y_value for p in chart_pts)
     avg_cost = (sum_cost / len(chart_pts)) if chart_pts else 0.0
     totals = (
         _lib_share.Totalled(label="Sum", value=f"${sum_cost:,.2f}"),
@@ -811,12 +812,12 @@ def _build_weekly_snapshot(
         )
         if chart_pts else None
     )
-    sum_cost = sum(p.y_value for p in chart_pts)
+    sum_cost = stable_sum(p.y_value for p in chart_pts)
     pct_values = [
         float(o[0]) for o in overlay
         if o is not None and o[0] is not None
     ]
-    avg_pct = (sum(pct_values) / len(pct_values)) if pct_values else 0.0
+    avg_pct = (stable_sum(pct_values) / len(pct_values)) if pct_values else 0.0
     peak_pct = max(pct_values, default=0.0)
     totals = (
         _lib_share.Totalled(label="Sum", value=f"${sum_cost:,.2f}"),
@@ -1144,7 +1145,7 @@ def _build_project_snapshot(
         notes = (
             f"Showing top 12 in chart; table includes all {len(chart_pts)}.",
         )
-    sum_cost = sum(p.y_value for p in chart_pts)
+    sum_cost = stable_sum(p.y_value for p in chart_pts)
     totals = (
         _lib_share.Totalled(label="Sum", value=f"${sum_cost:,.2f}"),
         _lib_share.Totalled(label="Projects", value=str(len(chart_pts))),
@@ -1541,7 +1542,7 @@ def _build_session_snapshot(
         notes = (
             f"Showing top 15 in chart; table includes all {len(chart_pts)}.",
         )
-    sum_cost = sum(p.y_value for p in chart_pts)
+    sum_cost = stable_sum(p.y_value for p in chart_pts)
     totals = (
         _lib_share.Totalled(label="Sum", value=f"${sum_cost:,.2f}"),
         _lib_share.Totalled(label="Sessions", value=str(len(chart_pts))),

package/bin/_cctally_statusline.py

@@ -91,6 +91,14 @@ def _resolve_statusline_tz(cli_tz, cfg, warn_once):
             tz_name = c._local_tz_name() or "UTC"
         except Exception:
             tz_name = "UTC"
+    elif tz_name and tz_name.lower() == "utc":
+        # Canonical "utc" (the value get_display_tz_pref / normalize_display_tz_value
+        # emit) -> the portable IANA key "UTC". macOS's case-insensitive
+        # filesystem resolves ZoneInfo("utc") to UTC, but Linux's case-sensitive
+        # /usr/share/zoneinfo raises ZoneInfoNotFoundError, which would emit a
+        # spurious "invalid timezone 'utc'" warning below. Mirrors
+        # resolve_display_tz, which maps canonical "utc" -> ZoneInfo("Etc/UTC").
+        tz_name = "UTC"
     try:
         ZoneInfo(tz_name)
     except (ZoneInfoNotFoundError, Exception):

package/bin/_cctally_tui.py

@@ -221,6 +221,7 @@ from _lib_display_tz import (
     _compute_display_block,
 )
 from _lib_aggregators import _aggregate_monthly
+from _lib_fmt import stable_sum
 
 
 # === Module-level back-ref shims for helpers that STAY in bin/cctally ======
@@ -1926,11 +1927,11 @@ def _tui_build_snapshot(
             weekly_periods = _dashboard_build_weekly_periods(
                 conn, now_utc, n=12, skip_sync=skip_sync
             )
-            # ``sum(..., 0.0)`` pins the type to ``float`` on empty rows so
-            # the envelope stays byte-stable with the pre-fix ``0.0`` shape
+            # ``stable_sum`` (math.fsum) returns float ``0.0`` on empty rows,
+            # so the envelope stays byte-stable with the pre-fix ``0.0`` shape
             # (the dashboard fixture goldens assert exact JSON match).
-            weekly_total_cost_usd = sum(
-                (r.cost_usd for r in weekly_periods), 0.0,
+            weekly_total_cost_usd = stable_sum(
+                r.cost_usd for r in weekly_periods
             )
             weekly_total_tokens = sum(
                 (r.total_tokens for r in weekly_periods), 0,
@@ -1949,8 +1950,8 @@ def _tui_build_snapshot(
                 conn, now_utc, n=12, skip_sync=skip_sync,
                 display_tz=_build_display_tz,
             )
-            monthly_total_cost_usd = sum(
-                (r.cost_usd for r in monthly_periods), 0.0,
+            monthly_total_cost_usd = stable_sum(
+                r.cost_usd for r in monthly_periods
             )
             monthly_total_tokens = sum(
                 (r.total_tokens for r in monthly_periods), 0,
@@ -1992,8 +1993,8 @@ def _tui_build_snapshot(
                 conn, now_utc, n=30, skip_sync=skip_sync,
                 display_tz=_build_display_tz,
             )
-            daily_total_cost_usd = sum(
-                (r.cost_usd for r in daily_panel), 0.0,
+            daily_total_cost_usd = stable_sum(
+                r.cost_usd for r in daily_panel
             )
             daily_total_tokens = sum(
                 (r.total_tokens for r in daily_panel), 0,
@@ -4183,7 +4184,7 @@ def _tui_modal_trend(snap, runtime, width):
     show_age = bucket != "narrow"
     # Header
     valid = [h for h in history if h.dollars_per_percent is not None]
-    avg_dpp = sum(h.dollars_per_percent for h in valid) / len(valid) if valid else 0.0
+    avg_dpp = stable_sum(h.dollars_per_percent for h in valid) / len(valid) if valid else 0.0
     if len(valid) >= 2:
         first_dpp = valid[0].dollars_per_percent
         last_dpp = valid[-1].dollars_per_percent

package/bin/_cctally_update.py

@@ -1890,13 +1890,13 @@ class _DashboardUpdateCheckThread(threading.Thread):
         snapshot_ref: "_SnapshotRef | None" = None,
     ) -> None:
         super().__init__(name="cctally-update-check")
-        self._stop = stop_event
+        self._stop_event = stop_event
         self._hub = hub
         self._ref = snapshot_ref
 
     def run(self) -> None:
         c = _cctally()
-        while not self._stop.is_set():
+        while not self._stop_event.is_set():
             try:
                 # Self-heal runs every tick (every 30 min by default),
                 # NOT gated by `_is_update_check_due`'s 24h TTL. Catches
@@ -1938,7 +1938,7 @@ class _DashboardUpdateCheckThread(threading.Thread):
                         )
                 except Exception:
                     pass
-            self._stop.wait(c.UPDATE_DASHBOARD_CHECK_POLL_S)
+            self._stop_event.wait(c.UPDATE_DASHBOARD_CHECK_POLL_S)
 
 
 def cmd_update(args) -> int:

package/bin/_lib_aggregators.py

@@ -77,6 +77,8 @@ _resolve_tz = _lib_display_tz._resolve_tz
 
 _lib_subscription_weeks = _load_lib("_lib_subscription_weeks")
 SubWeek = _lib_subscription_weeks.SubWeek
+_lib_fmt = _load_lib("_lib_fmt")
+stable_sum = _lib_fmt.stable_sum
 
 
 # === Honest imports from extracted homes ===================================
@@ -260,7 +262,7 @@ def _aggregate_daily_by_project(
     ranked: list[tuple[Any, list[BucketUsage], float]] = []
     for key in order:
         buckets = _aggregate_daily(grouped[key], mode=mode, tz=tz)  # date-asc
-        total = sum(b.cost_usd for b in buckets)
+        total = stable_sum(b.cost_usd for b in buckets)
         ranked.append((key, buckets, total))
 
     ranked.sort(key=lambda t: (-t[2], t[0].display_key))

package/bin/_lib_cache_report.py

@@ -21,6 +21,41 @@ from typing import Any, Callable, Iterable, Literal, Optional
 from zoneinfo import ZoneInfo
 
 
+def _import_stable_sum():
+    """Resolve ``_lib_fmt.stable_sum`` — the interpreter-stable float-summation
+    chokepoint (math.fsum) used for output-bound cost totals.
+
+    This kernel is loaded by file path from both ``bin/cctally`` and the test
+    harness, where ``_lib_fmt`` (a foundational kernel) is already imported, so
+    the ``sys.modules`` fast path is what runs in practice. The path-load
+    fallback differs from ``_import_share_lib``'s: ``_lib_share`` is dep-free,
+    but ``_lib_fmt`` imports the leaf kernels ``_cctally_core`` +
+    ``_lib_display_tz`` *by name*, so the fallback must put ``bin/`` on
+    ``sys.path`` before executing it or those imports raise ModuleNotFoundError.
+    The leaves never import back, so this stays acyclic.
+    """
+    import sys
+    if "_lib_fmt" in sys.modules:
+        return sys.modules["_lib_fmt"].stable_sum
+    from pathlib import Path
+    import importlib.util
+    bin_dir = Path(__file__).resolve().parent
+    if str(bin_dir) not in sys.path:
+        sys.path.insert(0, str(bin_dir))
+    spec = importlib.util.spec_from_file_location("_lib_fmt", bin_dir / "_lib_fmt.py")
+    m = importlib.util.module_from_spec(spec)
+    sys.modules["_lib_fmt"] = m
+    try:
+        spec.loader.exec_module(m)
+    except Exception:
+        sys.modules.pop("_lib_fmt", None)
+        raise
+    return m.stable_sum
+
+
+stable_sum = _import_stable_sum()
+
+
 # Anthropic's per-call >200K-tokens tier — kept in sync with bin/_lib_pricing.
 # Callers may override via the ``tiered_threshold`` kwarg.
 DEFAULT_TIERED_THRESHOLD = 200_000
@@ -732,7 +767,7 @@ def _aggregate_cache_breakdown(
         return tuple(out)
     head = out[:top_n]
     tail = out[top_n:]
-    other_net = sum(r.net_usd for r in tail)
+    other_net = stable_sum(r.net_usd for r in tail)
     # True aggregate hit % over the tail buckets — sum directly from the
     # CacheBreakdownRow token fields (EFF-4 — avoids the previous triple
     # walk over ``buckets.items()``).
@@ -800,7 +835,7 @@ def _aggregate_cache_breakdown_from_rows(
         return tuple(out)
     head = out[:top_n]
     tail = out[top_n:]
-    other_net = sum(r.net_usd for r in tail)
+    other_net = stable_sum(r.net_usd for r in tail)
     tail_input = sum(r.input_tokens for r in tail)
     tail_creation = sum(r.cache_creation_tokens for r in tail)
     tail_read = sum(r.cache_read_tokens for r in tail)

package/bin/_lib_diff_kernel.py

@@ -119,6 +119,7 @@ format_display_dt = _lib_display_tz.format_display_dt
 _lib_fmt = _load_lib("_lib_fmt")
 _style_ansi = _lib_fmt._style_ansi
 _supports_unicode_stdout = _lib_fmt._supports_unicode_stdout
+stable_sum = _lib_fmt.stable_sum
 
 
 # === Honest imports from extracted homes ===================================
@@ -706,7 +707,7 @@ def _diff_resolve_used_pct(window: ParsedWindow) -> tuple:
                 return None, "n/a"
             if not vals:
                 return None, "n/a"
-            return sum(vals) / len(vals), "avg"
+            return stable_sum(vals) / len(vals), "avg"
         finally:
             conn.close()
     return None, "n/a"
@@ -855,7 +856,7 @@ def _sum_metric_bundles(bundles) -> "MetricBundle | None":
     bundles = list(bundles)
     if not bundles:
         return None
-    cost = sum(b.cost_usd for b in bundles)
+    cost = stable_sum(b.cost_usd for b in bundles)
     ti = sum(b.tokens_input or 0 for b in bundles)
     to = sum(b.tokens_output or 0 for b in bundles)
     tcr = sum(b.tokens_cache_read or 0 for b in bundles)

package/bin/_lib_fmt.py

@@ -17,6 +17,7 @@ Spec: docs/superpowers/specs/2026-06-01-extract-fmt-color-table-primitives-desig
 from __future__ import annotations
 
 import datetime as dt
+import math
 import os
 import pathlib
 import re
@@ -275,6 +276,17 @@ def _boxed_table(
     return "\n".join(out_lines)
 
 
+def stable_sum(values):
+    """Exactly-rounded, interpreter-stable sum of float addends.
+
+    math.fsum (Shewchuk) returns a single correctly-rounded result that is
+    byte-identical across all CPython versions, unlike the built-in sum(),
+    which switched to Neumaier compensated summation for floats in 3.12. Use at
+    every float sum() whose result reaches byte-compared output.
+    """
+    return math.fsum(values)
+
+
 def _fmt_num(n: int) -> str:
     """Format integer with comma separators: 1234567 -> '1,234,567'."""
     return f"{n:,}"

package/bin/_lib_render.py

@@ -108,6 +108,7 @@ _style_ansi = _lib_fmt._style_ansi
 _fmt_num = _lib_fmt._fmt_num
 _truncate_num = _lib_fmt._truncate_num
 _boxed_table = _lib_fmt._boxed_table
+stable_sum = _lib_fmt.stable_sum
 
 
 # Module-level back-ref shims. Each shim resolves
@@ -788,7 +789,7 @@ def _bucket_totals_dict(buckets) -> dict[str, Any]:
         "outputTokens": sum(b.output_tokens for b in buckets),
         "cacheCreationTokens": sum(b.cache_creation_tokens for b in buckets),
         "cacheReadTokens": sum(b.cache_read_tokens for b in buckets),
-        "totalCost": sum(b.cost_usd for b in buckets),
+        "totalCost": stable_sum(b.cost_usd for b in buckets),
         "totalTokens": sum(b.total_tokens for b in buckets),
     }
 
@@ -1354,7 +1355,7 @@ def _render_bucket_table(
     tot_cc = sum(d.cache_creation_tokens for d in footer_buckets)
     tot_cr = sum(d.cache_read_tokens for d in footer_buckets)
     tot_tokens = sum(d.total_tokens for d in footer_buckets)
-    tot_cost = sum(d.cost_usd for d in footer_buckets)
+    tot_cost = stable_sum(d.cost_usd for d in footer_buckets)
     footer_cells = [
         ("Total", _yellow),
         ("", None),
@@ -1695,7 +1696,7 @@ def _render_weekly_table(
     tot_cc = sum(d.cache_creation_tokens for d in buckets)
     tot_cr = sum(d.cache_read_tokens for d in buckets)
     tot_tokens = sum(d.total_tokens for d in buckets)
-    tot_cost = sum(d.cost_usd for d in buckets)
+    tot_cost = stable_sum(d.cost_usd for d in buckets)
     footer_cells = [
         ("Total", _yellow),
         ("", None),
@@ -1984,7 +1985,7 @@ def _render_codex_bucket_table(
     tot_reasoning = sum(b.reasoning_output_tokens for b in buckets)
     tot_non_cached = max(0, tot_input_inclusive - tot_cached)
     tot_tokens = tot_input_inclusive + tot_output
-    tot_cost = sum(b.cost_usd for b in buckets)
+    tot_cost = stable_sum(b.cost_usd for b in buckets)
     footer_cells = [
         ("Total", _yellow),
         ("", None),
@@ -2264,7 +2265,7 @@ def _render_codex_session_table(
     tot_reasoning = sum(s.reasoning_output_tokens for s in sessions)
     tot_non_cached = max(0, tot_input_inclusive - tot_cached)
     tot_tokens = tot_input_inclusive + tot_output
-    tot_cost = sum(s.cost_usd for s in sessions)
+    tot_cost = stable_sum(s.cost_usd for s in sessions)
     footer_cells = [
         ("Total", _yellow),
         ("", None), ("", None), ("", None),
@@ -2540,7 +2541,7 @@ def _render_claude_session_table(
     tot_output = sum(s.output_tokens for s in sessions)
     # Issue #104: Total Tokens footer sums all four components.
     tot_tokens = sum(s.total_tokens for s in sessions)
-    tot_cost = sum(s.cost_usd for s in sessions)
+    tot_cost = stable_sum(s.cost_usd for s in sessions)
     footer_cells = [
         ("Total", _yellow),
         ("", None), ("", None), ("", None),

package/bin/_lib_share_templates.py

@@ -155,6 +155,40 @@ def _import_share_lib():
 _LS = _import_share_lib()
 
 
+def _import_stable_sum():
+    """Resolve ``_lib_fmt.stable_sum`` — the interpreter-stable float-summation
+    chokepoint (math.fsum) used for output-bound cost totals.
+
+    The ``sys.modules`` fast path is what runs in practice (``_lib_fmt`` is a
+    foundational kernel already imported by ``bin/cctally`` and the test
+    harness). The path-load fallback differs from ``_import_share_lib``'s:
+    ``_lib_share`` is dep-free, but ``_lib_fmt`` imports the leaf kernels
+    ``_cctally_core`` + ``_lib_display_tz`` *by name*, so the fallback must put
+    ``bin/`` on ``sys.path`` before executing it or those imports raise
+    ModuleNotFoundError. The leaves never import back, so this stays acyclic.
+    """
+    import sys
+    if "_lib_fmt" in sys.modules:
+        return sys.modules["_lib_fmt"].stable_sum
+    from pathlib import Path
+    import importlib.util
+    bin_dir = Path(__file__).resolve().parent
+    if str(bin_dir) not in sys.path:
+        sys.path.insert(0, str(bin_dir))
+    spec = importlib.util.spec_from_file_location("_lib_fmt", bin_dir / "_lib_fmt.py")
+    m = importlib.util.module_from_spec(spec)
+    sys.modules["_lib_fmt"] = m
+    try:
+        spec.loader.exec_module(m)
+    except Exception:
+        sys.modules.pop("_lib_fmt", None)
+        raise
+    return m.stable_sum
+
+
+stable_sum = _import_stable_sum()
+
+
 def _kpi_strip(*items: tuple[str, str]) -> tuple:
     """Generic KPI strip → tuple of `Totalled`."""
     return tuple(_LS.Totalled(label=lbl, value=val) for lbl, val in items)
@@ -280,7 +314,7 @@ def _detect_residual(
     `has_other_residual` in `_cross_tab_columns`.
     """
     for row_total, breakdown in rows_and_breakdowns:
-        top_k_sum = sum(float(breakdown.get(lbl, 0.0)) for lbl in top_k_labels)
+        top_k_sum = stable_sum(float(breakdown.get(lbl, 0.0)) for lbl in top_k_labels)
         if abs(row_total - top_k_sum) > epsilon:
             return True
     return False
@@ -537,7 +571,7 @@ def _build_daily_recap(*, panel_data, options):
     start = _parse_iso_utc(days[0]["date"]) if days else _utc_now()
     end_anchor = _parse_iso_utc(days[-1]["date"]) if days else start
     end = end_anchor + _dt.timedelta(days=1)
-    sum_cost = sum(float(d["cost_usd"]) for d in days)
+    sum_cost = stable_sum(float(d["cost_usd"]) for d in days)
     return _LS.ShareSnapshot(
         cmd="daily",
         title=f"Daily — last {len(days)} day{'s' if len(days) != 1 else ''}",
@@ -591,7 +625,7 @@ def _build_monthly_recap(*, panel_data, options):
         end = end_anchor.replace(day=1) - _dt.timedelta(days=1)
     else:
         end = start
-    sum_cost = sum(float(m["cost_usd"]) for m in months)
+    sum_cost = stable_sum(float(m["cost_usd"]) for m in months)
     return _LS.ShareSnapshot(
         cmd="monthly",
         title=f"Monthly — last {len(months)} month{'s' if len(months) != 1 else ''}",
@@ -761,7 +795,7 @@ def _build_sessions_recap(*, panel_data, options):
     sessions = panel_data.get("sessions") or []
     cap = options.get("top_n", 15)
     rows_iter = sessions[:cap]
-    sum_cost = sum(float(s.get("cost_usd") or 0.0) for s in rows_iter)
+    sum_cost = stable_sum(float(s.get("cost_usd") or 0.0) for s in rows_iter)
     starts = [_parse_iso_utc(s["started_at"]) for s in rows_iter if s.get("started_at")]
     start = min(starts) if starts else _utc_now()
     end = max(starts) if starts else start
@@ -1067,7 +1101,7 @@ def _build_daily_visual(*, panel_data, options):
     start = _parse_iso_utc(days[0]["date"]) if days else _utc_now()
     end_anchor = _parse_iso_utc(days[-1]["date"]) if days else start
     end = end_anchor + _dt.timedelta(days=1)
-    sum_cost = sum(float(d["cost_usd"]) for d in days)
+    sum_cost = stable_sum(float(d["cost_usd"]) for d in days)
     return _LS.ShareSnapshot(
         cmd="daily",
         title=f"Daily visual — last {len(days)} day{'s' if len(days) != 1 else ''}",
@@ -1103,7 +1137,7 @@ def _build_daily_detail(*, panel_data, options):
     start = _parse_iso_utc(days[0]["date"]) if days else _utc_now()
     end_anchor = _parse_iso_utc(days[-1]["date"]) if days else start
     end = end_anchor + _dt.timedelta(days=1)
-    sum_cost = sum(float(d["cost_usd"]) for d in days)
+    sum_cost = stable_sum(float(d["cost_usd"]) for d in days)
     top_n = max(int(options.get("top_n", 5)), 1)
 
     breakdowns = [dict(d.get("projects") or {}) for d in days]
@@ -1170,7 +1204,7 @@ def _build_monthly_visual(*, panel_data, options):
         end = end_anchor.replace(day=1) - _dt.timedelta(days=1)
     else:
         end = start
-    sum_cost = sum(float(m["cost_usd"]) for m in months)
+    sum_cost = stable_sum(float(m["cost_usd"]) for m in months)
     return _LS.ShareSnapshot(
         cmd="monthly",
         title=f"Monthly visual — last {len(months)} month{'s' if len(months) != 1 else ''}",
@@ -1211,7 +1245,7 @@ def _build_monthly_detail(*, panel_data, options):
         end = end_anchor.replace(day=1) - _dt.timedelta(days=1)
     else:
         end = start
-    sum_cost = sum(float(m["cost_usd"]) for m in months)
+    sum_cost = stable_sum(float(m["cost_usd"]) for m in months)
     top_n = max(int(options.get("top_n", 5)), 1)
 
     breakdowns = [dict(m.get("models") or {}) for m in months]
@@ -1476,7 +1510,7 @@ def _build_sessions_visual(*, panel_data, options):
     sessions = panel_data.get("sessions") or []
     cap = int(options.get("top_n", 8))
     rows_iter = sessions[:cap]
-    sum_cost = sum(float(s.get("cost_usd") or 0.0) for s in rows_iter)
+    sum_cost = stable_sum(float(s.get("cost_usd") or 0.0) for s in rows_iter)
     starts = [_parse_iso_utc(s["started_at"]) for s in rows_iter if s.get("started_at")]
     start = min(starts) if starts else _utc_now()
     end = max(starts) if starts else start
@@ -1522,7 +1556,7 @@ def _build_sessions_detail(*, panel_data, options):
     sessions = panel_data.get("sessions") or []
     cap = options.get("top_n", 50)
     rows_iter = sessions[:cap]
-    sum_cost = sum(float(s.get("cost_usd") or 0.0) for s in rows_iter)
+    sum_cost = stable_sum(float(s.get("cost_usd") or 0.0) for s in rows_iter)
     starts = [_parse_iso_utc(s["started_at"]) for s in rows_iter if s.get("started_at")]
     start = min(starts) if starts else _utc_now()
     end = max(starts) if starts else start

package/bin/_lib_view_models.py

@@ -102,6 +102,13 @@ def _load_lib(name: str):
     return mod
 
 
+# ``_lib_fmt``'s only intra-repo deps are the leaf kernels ``_cctally_core`` +
+# ``_lib_display_tz`` (neither imports back), so loading it here is acyclic.
+# ``stable_sum`` is the interpreter-stable
+# float-summation chokepoint (math.fsum) used for output-bound totals.
+stable_sum = _load_lib("_lib_fmt").stable_sum
+
+
 # === Row dataclasses (Task 2: moved verbatim from _cctally_tui.py) =========
 # Field order, types, and defaults match the originals byte-stable.
 
@@ -928,7 +935,7 @@ def build_trend_view(conn, *, now_utc, n=8, display_tz=None):
     # least 3 samples qualify.
     valid_dpps = [r.dollars_per_percent for r in rows
                   if r.dollars_per_percent is not None]
-    avg = (sum(valid_dpps) / len(valid_dpps)) if len(valid_dpps) >= 3 else None
+    avg = (stable_sum(valid_dpps) / len(valid_dpps)) if len(valid_dpps) >= 3 else None
 
     # Issue #59 — pre-compute the 4-week-median-non-current dpp scalar
     # the dashboard's Trend modal hero KV displays. Rule mirrors
@@ -1290,7 +1297,7 @@ def build_blocks_view_from_table_rows(
     (``cmd_five_hour_blocks`` produces newest-first DESC).
     """
     rows_seq = list(block_dicts)
-    total_cost = sum(
+    total_cost = stable_sum(
         float(d.get("total_cost_usd") or 0.0) for d in rows_seq
     )
     total_tok = sum(

package/bin/cctally

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 import sys
 
-__min_python_version__ = (3, 13)
+__min_python_version__ = (3, 11)
 
 if sys.version_info < __min_python_version__:
     print(
@@ -2720,7 +2720,19 @@ def _post_command_update_hooks(command: str | None, args) -> None:
     ``_spawn_background_update_check`` here would create ``config.json``,
     ``update-state.json``, and ``update.log`` on a fresh install where
     the existing-install gate already makes the symlink work a no-op.
-    Same rationale as doctor."""
+    Same rationale as doctor.
+
+    Test/CI seam: ``CCTALLY_DISABLE_UPDATE_CHECK`` short-circuits the whole
+    hook (mirrors ``CCTALLY_DISABLE_DEV_AUTODETECT``). The background
+    ``_spawn_background_update_check`` is a DETACHED process that
+    ``mkdir``s APP_DIR to write ``update-state.json`` / ``update.log``; a
+    fixture harness that runs a command and then asserts on APP_DIR (e.g.
+    ``cctally-setup-test``'s uninstall-purge "data dir is gone" check)
+    otherwise races that detached writer re-creating the dir after the
+    command returns. Setting this env var makes such harnesses
+    deterministic without disabling the feature for real users."""
+    if os.environ.get("CCTALLY_DISABLE_UPDATE_CHECK"):
+        return
     if command == "setup" and getattr(args, "uninstall", False):
         return
     if command == "doctor":

package/bin/cctally-npm-shim.js

@@ -25,7 +25,7 @@ const result = spawnSync(python, [scriptPath, ...process.argv.slice(2)], {
 if (result.error) {
   if (result.error.code === 'ENOENT') {
     console.error(
-      `cctally: cannot find ${python}. Install Python 3.13+ ` +
+      `cctally: cannot find ${python}. Install Python 3.11+ ` +
       'or set CCTALLY_PYTHON to its path.'
     );
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cctally",
-  "version": "1.26.0",
+  "version": "1.27.1",
   "description": "Claude Code usage tracker and local dashboard for Pro/Max subscription limits - weekly cost-per-percent trend, quota forecasts, threshold alerts. ccusage-compatible.",
   "homepage": "https://github.com/omrikais/cctally",
   "repository": {