cctally 1.25.0 → 1.27.0

package/CHANGELOG.md

@@ -5,6 +5,19 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [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
+- **`cctally budget set --project` now hints the correct argument order when you put the amount after the flag.** Writing the flag-first form `cctally budget set --project 25` binds `25` to the `--project` value (argparse `nargs='?'`) and leaves the amount unset; instead of the generic "`set --project` requires an amount" error, cctally now points you at the supported `cctally budget set 25 --project` ordering. A bare numeric value that names a real directory (e.g. a repo literally called `2025`) is treated as a project path rather than a misplaced amount, so the hint never misfires on a numeric-named repo. The exit code is unchanged (2, a safe no-write failure) and valid invocations are unaffected.
+
+### Changed
+- **Internal refactor (no user-facing change): consolidated the per-project budget label-disambiguation and threshold-crossing arithmetic onto two shared helpers (`_project_budget_labels`, `_project_crossings`), used by the budget table, the alert firing path, the config-write reconcile, and the dashboard SSE envelope, and replaced the share-ranking hidden-`MoneyCell` hack with an explicit `ProjectCell.rank_cost` field.** The firing-path label resolution is now lazy (resolved only when a crossing actually dispatches, off the common no-dispatch tick). Output is byte-identical — the per-project budget reconcile invariants (61/61), the budget/share goldens (26/26), and the full pytest suite are unchanged; nothing to do on upgrade.
+
 ## [1.25.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;
@@ -4285,20 +4288,14 @@ def _envelope_rows_project_budget(conn, descriptor, limit, severity_for) -> list
         (limit,),
     ).fetchall()
     c = _cctally()
-    resolve = c._resolve_project_key
-    resolver_cache: dict = {}
-    # Collision-aware labels ACROSS the distinct project_keys in these rows so
-    # two same-basename roots (/work/app + /personal/app) don't both render
-    # "app" — byte-matching the live notification + budget table via the shared
-    # `_project_disambiguate_labels`. Disambiguated across the ROWS (not live
-    # config) to preserve the render-from-the-snapshotted-row invariant above.
-    distinct_keys = sorted({r["project_key"] for r in rows})
-    pkeys = [resolve(k, "git-root", resolver_cache) for k in distinct_keys]
-    disambig = c._project_disambiguate_labels([{"key": pk} for pk in pkeys])
-    label_by_key = {
-        distinct_keys[i]: disambig.get(i, pkeys[i].display_key)
-        for i in range(len(distinct_keys))
-    }
+    # Collision-aware labels via the shared primitive (#130), disambiguated
+    # across the alerted ROWS (NOT live config) to preserve the
+    # render-from-the-snapshotted-row invariant above — so a deleted/renamed
+    # config key still renders. This is intentionally a different feed than the
+    # table/notification (full config); see spec §1 Goals (Codex F1).
+    label_by_key = c._project_budget_labels(
+        sorted({r["project_key"] for r in rows})
+    )
     out: list[dict] = []
     for r in rows:
         threshold = int(r["threshold"])

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_forecast.py

@@ -1711,6 +1711,16 @@ def _resolve_project_budget_target(raw: str):
     return key.git_root or key.bucket_path
 
 
+def _looks_numeric(s) -> bool:
+    """True iff `s` parses as a positive finite number — used to detect the
+    `budget set --project 25` footgun (#130)."""
+    try:
+        v = float(s)
+    except (TypeError, ValueError):
+        return False
+    return math.isfinite(v) and v > 0
+
+
 def _cmd_budget_set_project(args: argparse.Namespace) -> int:
     """`cctally budget set AMOUNT --project[=PATH]` — write one entry into
     `budget.projects`, keyed by the resolved canonical git-root. Writes the
@@ -1718,10 +1728,26 @@ def _cmd_budget_set_project(args: argparse.Namespace) -> int:
     c = _cctally()
     raw_amount = getattr(args, "amount", None)
     if raw_amount is None:
-        eprint(
-            "cctally budget: `set --project` requires an amount, e.g. "
-            "cctally budget set 25 --project"
-        )
+        proj = getattr(args, "project", None)
+        if proj and proj != "__CWD__" and _looks_numeric(proj) and not os.path.isdir(proj):
+            # `budget set --project 25` → argparse bound 25 to --project,
+            # leaving amount=None (#130). A bare numeric value is almost always
+            # the amount in the wrong slot — but NOT when it names a real
+            # directory (e.g. a repo literally called `./2025`), which the
+            # `not os.path.isdir(proj)` guard excludes so a numeric-named path
+            # falls through to the generic "requires an amount" message below
+            # instead of being misread as a misplaced amount. Point at the
+            # right ordering.
+            eprint(
+                f"cctally budget: '{proj}' looks like an amount, not a "
+                f"project path. Did you mean: cctally budget set {proj} "
+                f"--project"
+            )
+        else:
+            eprint(
+                "cctally budget: `set --project` requires an amount, e.g. "
+                "cctally budget set 25 --project"
+            )
         return 2
     try:
         amount = float(raw_amount)
@@ -2131,26 +2157,13 @@ def _build_project_budget_rows(conn, budget_cfg, now_utc):
     last24h = c._sum_cost_by_project(recent_start, now_utc, mode="auto")
     thresholds = tuple(budget_cfg["alert_thresholds"])
 
-    # Resolve every configured key to its ProjectKey ONCE, then route the
-    # display labels through the shared collision-disambiguation primitive
-    # (`_project_disambiguate_labels`, the SAME one cmd_project's table and
-    # `_build_project_snapshot` use). A bare `display_key` is just the
-    # basename, so two distinct git-roots sharing a basename (e.g.
-    # `/work/app` + `/personal/app`) would BOTH render as `app` — and in
-    # anonymized share BOTH collapse to a single `project-1`. The primitive
-    # suffixes the colliding rows with their parent-dir segment
-    # ("app (work)" / "app (personal)"); non-colliding rows keep `display_key`.
-    resolver_cache: dict = {}
-    pkeys = [
-        c._resolve_project_key(key, "git-root", resolver_cache)
-        for key in budget_cfg["projects"]
-    ]
-    disambig = c._project_disambiguate_labels(
-        [{"key": pk} for pk in pkeys]
-    )
+    # Collision-aware labels via the shared primitive (#130). Same-basename
+    # roots (/work/app + /personal/app) get a parent segment ("app (work)");
+    # uniquely-named roots keep their bare display_key.
+    labels = c._project_budget_labels(budget_cfg["projects"])
 
     rows = []
-    for idx, (key, target) in enumerate(budget_cfg["projects"].items()):
+    for key, target in budget_cfg["projects"].items():
         inputs = c.BudgetInputs(
             target_usd=float(target),
             spent_usd=float(week.get(key, 0.0)),
@@ -2161,7 +2174,7 @@ def _build_project_budget_rows(conn, budget_cfg, now_utc):
             alert_thresholds=thresholds,
         )
         status = c.compute_budget_status(inputs)
-        label = disambig.get(idx, pkeys[idx].display_key)
+        label = labels[key]
         rows.append({
             "project": label,
             "project_key": key,
@@ -2256,19 +2269,12 @@ def _append_project_share_rows(snap, rows, has_projects):
     }))
     for r in rows:
         verdict = r["verdict"].upper()
-        # `spent` is the ONLY MoneyCell in the row so
-        # `_lib_share._collect_project_costs` (which SUMS every MoneyCell in a
-        # ProjectCell row) spend-RANKs the anonymized labels by spend alone —
-        # matching the `project` share convention. A TextCell here would leave
-        # every project at cost=0, falling back to lexical ordering. Budget /
-        # consumption / verdict stay in the visible `value` TextCell (NOT a
-        # second MoneyCell — that would inflate the rank key to spent+budget).
-        # The 2-col Metric/Value table renders only `metric` + `value`, so the
-        # extra `spent` cell is invisible in the artifact while the Value
-        # column keeps the full "spent / budget (pct) VERDICT" string.
+        # Explicit rank via ProjectCell.rank_cost (#130) — spend-ranks the
+        # anonymized labels (matching the `project` share convention) without a
+        # hidden MoneyCell. Budget / consumption / verdict stay in the visible
+        # `value` TextCell.
         extra_rows.append(_lib_share.Row(cells={
-            "metric": _lib_share.ProjectCell(r["project"]),
-            "spent": _lib_share.MoneyCell(r["spent_usd"]),
+            "metric": _lib_share.ProjectCell(r["project"], rank_cost=r["spent_usd"]),
             "value": _lib_share.TextCell(
                 f"${r['spent_usd']:,.2f} / ${r['budget_usd']:,.2f} "
                 f"({r['consumption_pct']:.0f}%) {verdict}"

package/bin/_cctally_milestones.py

@@ -547,6 +547,23 @@ def _reconcile_budget_on_config_write(validated_budget):
         eprint(f"[budget-milestone] reconcile on set failed: {exc}")
 
 
+def _project_crossings(items, thresholds, by_proj):
+    """Yield ``(project_key, threshold, spent, target, consumption_pct)`` for
+    every crossed (project, threshold) pair (#130). Shared by the firing path
+    (record-usage) and the reconcile path (config write) so they differ ONLY in
+    the dispatch tail. Pure arithmetic — no DB, no I/O. Applies the +1e-9
+    float-floor snap (CLAUDE.md gotcha) and yields thresholds in sorted order.
+    ``items`` is an iterable of ``(project_key, target)`` pairs."""
+    sorted_thresholds = sorted(thresholds)
+    for project_key, target in items:
+        spent = float(by_proj.get(project_key, 0.0))
+        target = float(target)
+        consumption_pct = (spent / target * 100.0) if target > 0 else 0.0
+        for t in sorted_thresholds:
+            if consumption_pct + 1e-9 >= t:
+                yield (project_key, t, spent, target, consumption_pct)
+
+
 def _reconcile_project_budget_milestones_on_write(
     validated_budget, touched_projects=None
 ):
@@ -614,30 +631,29 @@ def _reconcile_project_budget_milestones_on_write(
                     if k in touched_projects
                 ]
             )
-            for project_key, target in items:
-                spent = float(by_proj.get(project_key, 0.0))
-                target = float(target)
-                consumption_pct = (
-                    (spent / target * 100.0) if target > 0 else 0.0
+            # Same crossing arithmetic as firing, via the shared generator
+            # (#130). Reconcile differs ONLY in the tail: UPDATE alerted_at with
+            # NO dispatch (retroactive-storm suppression). `items` already
+            # honors touched_projects filtering above.
+            for project_key, t, spent, target, consumption_pct in c._project_crossings(
+                items, thresholds, by_proj
+            ):
+                insert_project_budget_milestone(
+                    conn,
+                    week_start_at=week_key,
+                    project_key=project_key,
+                    threshold=t,
+                    budget_usd=target,
+                    spent_usd=spent,
+                    consumption_pct=consumption_pct,
+                    commit=False,
+                )
+                conn.execute(
+                    "UPDATE project_budget_milestones SET alerted_at = ? "
+                    "WHERE week_start_at = ? AND project_key = ? "
+                    "  AND threshold = ? AND alerted_at IS NULL",
+                    (now_utc_iso(), week_key, project_key, t),
                 )
-                for t in sorted(thresholds):
-                    if consumption_pct + 1e-9 >= t:
-                        insert_project_budget_milestone(
-                            conn,
-                            week_start_at=week_key,
-                            project_key=project_key,
-                            threshold=t,
-                            budget_usd=target,
-                            spent_usd=spent,
-                            consumption_pct=consumption_pct,
-                            commit=False,
-                        )
-                        conn.execute(
-                            "UPDATE project_budget_milestones SET alerted_at = ? "
-                            "WHERE week_start_at = ? AND project_key = ? "
-                            "  AND threshold = ? AND alerted_at IS NULL",
-                            (now_utc_iso(), week_key, project_key, t),
-                        )
             conn.commit()
         finally:
             conn.close()

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():
@@ -132,6 +133,27 @@ def _sum_cost_by_project(
     return out
 
 
+def _project_budget_labels(keys):
+    """Collision-aware ``{project_key: label}`` for a set of budget project
+    keys. Single source of the resolve+disambiguate primitive used by the
+    budget table (`_build_project_budget_rows`), the alert payload
+    (`maybe_record_project_budget_milestone`), and the dashboard SSE envelope
+    (`_envelope_rows_project_budget`) — issue #130. Each caller passes its own
+    key feed; the label for a key is identical across callers only when they
+    feed the same key set (the dashboard intentionally feeds its alerted-row
+    subset). Output is order-independent (disambiguation keys off basename
+    collisions, not position)."""
+    c = _cctally()
+    keys = list(keys)
+    resolver_cache: dict = {}
+    pkeys = [c._resolve_project_key(k, "git-root", resolver_cache) for k in keys]
+    disambig = c._project_disambiguate_labels([{"key": pk} for pk in pkeys])
+    return {
+        keys[i]: disambig.get(i, pkeys[i].display_key)
+        for i in range(len(keys))
+    }
+
+
 def _accumulate_entry_into_bucket(
     b: dict,
     entry: "_JoinedClaudeEntry",
@@ -222,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_record.py

@@ -277,12 +277,12 @@ def insert_project_budget_milestone(*args, **kwargs):
     return sys.modules["cctally"].insert_project_budget_milestone(*args, **kwargs)
 
 
-def _resolve_project_key(*args, **kwargs):
-    return sys.modules["cctally"]._resolve_project_key(*args, **kwargs)
+def _project_budget_labels(*args, **kwargs):
+    return sys.modules["cctally"]._project_budget_labels(*args, **kwargs)
 
 
-def _project_disambiguate_labels(*args, **kwargs):
-    return sys.modules["cctally"]._project_disambiguate_labels(*args, **kwargs)
+def _project_crossings(*args, **kwargs):
+    return sys.modules["cctally"]._project_crossings(*args, **kwargs)
 
 
 def _get_budget_config(*args, **kwargs):
@@ -912,28 +912,17 @@ def maybe_record_project_budget_milestone(saved: dict[str, Any]) -> None:
         if not pending:
             return  # nothing left to cross this week → skip the cost scan
 
-        # Resolve every configured key to its ProjectKey ONCE, then route the
-        # firing-path labels through the SAME collision-disambiguation primitive
-        # the display uses (`_build_project_budget_rows` → `cmd_project`'s table
-        # / share snapshot). A bare `display_key` is just the basename, so a
-        # uniquely-named project keeps its bare basename in the notification —
-        # byte-matching the table + dashboard chip — and only same-basename
-        # roots (`/work/app` + `/personal/app`) get the `(parent)` segment
-        # ("app (work)" / "app (personal)"). The configured set is small + the
-        # resolver caches, so this is near-free on the rare crossing tick.
-        resolver_cache: dict = {}
-        proj_keys = sorted(projects)
-        pkeys = [
-            _resolve_project_key(p, "git-root", resolver_cache)
-            for p in proj_keys
-        ]
-        disambig = _project_disambiguate_labels(
-            [{"key": pk} for pk in pkeys]
-        )
-        label_by_key = {
-            proj_keys[i]: disambig.get(i, pkeys[i].display_key)
-            for i in range(len(proj_keys))
-        }
+        # Collision-aware labels via the shared primitive (#130) — byte-matching
+        # the display table + dashboard chip for the same key feed. A
+        # uniquely-named project keeps its bare basename in the notification;
+        # only same-basename roots (`/work/app` + `/personal/app`) get the
+        # `(parent)` segment ("app (work)" / "app (personal)"). Resolved LAZILY
+        # (just-in-time on the first genuine crossing below): the map does
+        # per-key git-root resolution but is consumed ONLY when a new crossing
+        # dispatches, and most pending ticks scan without crossing — so we skip
+        # the resolution entirely on the common no-dispatch tick. Same map,
+        # same labels; only the timing moves.
+        label_by_key = None
 
         # ONE grouped scan over the week's session entries, bucketed by
         # canonical git-root. skip_sync=False (self-sufficient): the global
@@ -945,55 +934,57 @@ def maybe_record_project_budget_milestone(saved: dict[str, Any]) -> None:
         by_proj = _sum_cost_by_project(
             week_start_at, now_utc, mode="auto", skip_sync=False
         )
-        for project_key, t in pending:
-            spent = float(by_proj.get(project_key, 0.0))
-            target = float(projects[project_key])
-            # +1e-9 snap-up: spent/target*100 can land one ULP below an integer
-            # threshold (CLAUDE.md float-floor gotcha).
-            consumption_pct = (spent / target * 100.0) if target > 0 else 0.0
-            if consumption_pct + 1e-9 >= t:
-                inserted = insert_project_budget_milestone(
-                    conn,
+        # Crossing arithmetic via the shared generator (#130). Feed ALL
+        # configured (project, threshold) pairs; dispatch is gated SOLELY by
+        # INSERT-OR-IGNORE rowcount==1 (genuine new crossing). The pending
+        # pre-probe above stays as the scan-skip optimization, NOT a write gate
+        # — already-recorded pairs get rowcount==0 here and silently skip
+        # ([Dedup mustn't gate side effects]).
+        for project_key, t, spent, target, consumption_pct in _project_crossings(
+            projects.items(), sorted_thresholds, by_proj
+        ):
+            inserted = insert_project_budget_milestone(
+                conn,
+                week_start_at=week_key,
+                project_key=project_key,
+                threshold=t,
+                budget_usd=target,
+                spent_usd=spent,
+                consumption_pct=consumption_pct,
+                commit=False,
+            )
+            # Only the genuine-new-crossing winner (rowcount==1) dispatches; a
+            # racing record-usage instance OR an already-recorded pair gets
+            # rowcount==0 and skips.
+            if inserted == 1:
+                crossed_at = now_utc_iso()
+                # set-then-dispatch: alerted_at lands on the row BEFORE the
+                # Popen, sharing this transaction with the INSERT (commit=False).
+                # `alerted_at IS NULL` is write-once defense-in-depth.
+                conn.execute(
+                    "UPDATE project_budget_milestones SET alerted_at = ? "
+                    "WHERE week_start_at = ? AND project_key = ? "
+                    "  AND threshold = ? AND alerted_at IS NULL",
+                    (crossed_at, week_key, project_key, t),
+                )
+                # Collision-aware label (shared primitive, #130); resolved once
+                # on the first dispatch and reused for the rest of this tick.
+                # Kept defensive fallback (F4).
+                if label_by_key is None:
+                    label_by_key = _project_budget_labels(sorted(projects))
+                project_label = label_by_key.get(
+                    project_key, os.path.basename(project_key) or project_key
+                )
+                pending_alerts.append(_build_alert_payload_project_budget(
+                    threshold=t,
+                    crossed_at_utc=crossed_at,
                     week_start_at=week_key,
+                    project=project_label,
                     project_key=project_key,
-                    threshold=t,
                     budget_usd=target,
                     spent_usd=spent,
                     consumption_pct=consumption_pct,
-                    commit=False,
-                )
-                # Only the genuine-new-crossing winner (rowcount==1) dispatches;
-                # a racing record-usage instance gets rowcount==0 and skips.
-                if inserted == 1:
-                    crossed_at = now_utc_iso()
-                    # set-then-dispatch: alerted_at lands on the row BEFORE the
-                    # Popen, sharing this transaction with the INSERT
-                    # (commit=False). `alerted_at IS NULL` is write-once
-                    # defense-in-depth.
-                    conn.execute(
-                        "UPDATE project_budget_milestones SET alerted_at = ? "
-                        "WHERE week_start_at = ? AND project_key = ? "
-                        "  AND threshold = ? AND alerted_at IS NULL",
-                        (crossed_at, week_key, project_key, t),
-                    )
-                    # Label is collision-aware, byte-matching the display: a
-                    # uniquely-named project notifies as its bare basename,
-                    # only same-basename roots get the `(parent)` segment (the
-                    # `label_by_key` map built above via the shared
-                    # `_project_disambiguate_labels` primitive, spec §5.3).
-                    project_label = label_by_key.get(
-                        project_key, os.path.basename(project_key) or project_key
-                    )
-                    pending_alerts.append(_build_alert_payload_project_budget(
-                        threshold=t,
-                        crossed_at_utc=crossed_at,
-                        week_start_at=week_key,
-                        project=project_label,
-                        project_key=project_key,
-                        budget_usd=target,
-                        spent_usd=spent,
-                        consumption_pct=consumption_pct,
-                    ))
+                ))
         # Single commit: every INSERT + its alerted_at marker durable together.
         conn.commit()
     except Exception as exc:

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_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_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/_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.py

@@ -66,8 +66,14 @@ class DeltaCell:
 
 @dataclass(frozen=True)
 class ProjectCell:
-    """Anonymization chokepoint — scrubber rewrites the `label` field."""
+    """Anonymization chokepoint — scrubber rewrites the `label` field.
+
+    `rank_cost` (#130): an explicit spend value used by
+    `_collect_project_costs` to rank anonymized labels, replacing the old
+    hidden-MoneyCell hack. When None, ranking falls back to summing sibling
+    MoneyCells (back-compat for every non-budget construction site)."""
     label: str
+    rank_cost: float | None = None
 
 Cell = TextCell | MoneyCell | PercentCell | DateCell | DeltaCell | ProjectCell
 
@@ -735,7 +741,8 @@ def _render_svg_footer(snap: ShareSnapshot, *, palette: dict,
 
 def _collect_project_costs(snap: ShareSnapshot) -> dict[str, float]:
     """Walk rows: for each row containing a ProjectCell, sum MoneyCell values
-    in the same row under the project label.
+    in the same row under the project label — unless the ProjectCell carries an
+    explicit ``rank_cost``, which takes precedence over the MoneyCell sum (#130).
 
     Charts also contribute via ChartPoint.project_label + y_value (when y_value
     is in $). For consistency we union both sources; rows take precedence on
@@ -744,13 +751,16 @@ def _collect_project_costs(snap: ShareSnapshot) -> dict[str, float]:
     for row in snap.rows:
         proj_label: str | None = None
         money = 0.0
+        explicit_rank: float | None = None
         for cell in row.cells.values():
             if isinstance(cell, ProjectCell):
                 proj_label = cell.label
+                explicit_rank = cell.rank_cost
             elif isinstance(cell, MoneyCell):
                 money += cell.usd
         if proj_label is not None:
-            costs[proj_label] = costs.get(proj_label, 0.0) + money
+            contribution = explicit_rank if explicit_rank is not None else money
+            costs[proj_label] = costs.get(proj_label, 0.0) + contribution
 
     if snap.chart is not None:
         chart_pts: list[ChartPoint] = []
@@ -825,7 +835,9 @@ def _apply_anon_mapping(
         new_cells: dict[str, Cell] = {}
         for key, cell in row.cells.items():
             if isinstance(cell, ProjectCell) and cell.label in mapping:
-                new_cells[key] = ProjectCell(mapping[cell.label])
+                new_cells[key] = ProjectCell(
+                    mapping[cell.label], rank_cost=cell.rank_cost
+                )
             else:
                 new_cells[key] = cell
         new_rows.append(Row(cells=new_cells))

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(
@@ -634,6 +634,9 @@ cmd_project = _cctally_project.cmd_project
 # per-project budget display (cmd_budget) and the Task 3 firing path reach it
 # via the cctally namespace.
 _sum_cost_by_project = _cctally_project._sum_cost_by_project
+# Shared per-project label disambiguation (#130). Re-exported so the budget
+# display, firing path, and dashboard SSE envelope reach the SAME primitive.
+_project_budget_labels = _cctally_project._project_budget_labels
 
 # Eager re-export of bin/_cctally_pricing_check.py — `cmd_pricing_check`
 # is invoked via the parser's `set_defaults(func=c.cmd_pricing_check)`,
@@ -2081,6 +2084,7 @@ get_milestones_for_week             = _cctally_milestones.get_milestones_for_wee
 insert_percent_milestone            = _cctally_milestones.insert_percent_milestone            # record shim; idempotency-test mod.
 insert_budget_milestone             = _cctally_milestones.insert_budget_milestone             # record shim
 insert_project_budget_milestone     = _cctally_milestones.insert_project_budget_milestone     # record shim; project-budget-config-test ns[]
+_project_crossings                  = _cctally_milestones._project_crossings                  # record shim; milestones c. (#130 firing/reconcile shared crossing arithmetic)
 insert_projected_milestone          = _cctally_milestones.insert_projected_milestone          # record shim
 _projected_levels_already_latched   = _cctally_milestones._projected_levels_already_latched   # record shim
 _reconcile_budget_milestones_on_set = _cctally_milestones._reconcile_budget_milestones_on_set # test_budget_alerts ns[]

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.25.0",
+  "version": "1.27.0",
   "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": {