cctally 1.25.0 → 1.26.0

package/CHANGELOG.md

@@ -5,6 +5,14 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [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/bin/_cctally_dashboard.py

@@ -4285,20 +4285,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_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

@@ -132,6 +132,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",

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/_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/cctally

@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cctally",
-  "version": "1.25.0",
+  "version": "1.26.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": {