cctally 1.103.0 → 1.105.0

package/CHANGELOG.md

@@ -5,6 +5,100 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.105.0] - 2026-09-02
+
+### Added
+- `cctally` prices Claude Fable 5.1 and Claude Mythos 5.1, including their cache reads at $0.25 per million tokens, so usage on either model is costed instead of contributing nothing with only a warning.
+
+### Changed
+- `cctally quota` counts Claude Fable 5.1 and Claude Mythos 5.1 as part of the Fable 5 and Mythos 5 families, so a week containing that usage no longer has its weekly-quota fit withheld as an unsupported model mix.
+- `cctally quota` refits your stored calibration once after this upgrade, because the set of model names it recognises has changed.
+- `cctally quota` excludes fast-mode requests that Anthropic bills to usage credits, and widens its family-composition support floor to the corrected empirical bound.
+- The dashboard's Forecast basis and `cctally statusline` use one vocabulary; the status line remains a meter-only hot path, while Forecast can name its calibrated model.
+- The dashboard's Conversation viewer opens long histories from a bounded, integrity-checked outline ticket, hydrates the exact account-scoped outline automatically, and skips unchanged transcript estates between updates.
+- `cctally dashboard` compresses and caches content-hashed assets and loads conversations and detail views only when opened, cutting cold JavaScript transfer while warm reloads reuse unchanged code.
+
+### Fixed
+- `cctally dashboard` shares a progressive outline's first-chunk build, cancels abandoned transfers, and rejects an oversized outline before allocating its encoded body.
+- `cctally dashboard` applies failed or over-limit background memory checks as soon as they finish, including while sync is paused, and its soak gate now distinguishes measured growth from noisy flat samples.
+- `cctally dashboard` keeps production-size cache admission checks inside the whole-process memory ceiling without shrinking or evicting the retained caches.
+- `cctally dashboard` stops loading a previous conversation's outline after you switch sessions, so the new reader stays current and avoids duplicate outline requests.
+- Concurrent dashboard Explain requests share identical in-flight work and admit only one diagnosis process tree at a time, so multiple tabs or LAN clients no longer multiply provider workers and transient memory.
+- `cctally dashboard` bounds retained source, snapshot, conversation, ingest, and SSE work; invalidates conversation caches after same-path database replacement; keeps the newest slow-tab update; and releases owners without slowing refreshes.
+- `cctally quota` now records a metering-rate change it detected earlier but could not store at the time, so a busy or rebuilding database no longer costs you that entry in your rate-change history permanently.
+- `cctally quota` delivers a metering-rate change notification that an interrupted write recorded but never announced, and remembers which ones it has announced, so upgrading never replays your whole rate-change history at once.
+- `cctally quota` retries a metering-rate notification that was recorded without an account attribution, including on a run narrowed with `--account`, so an install that later adds a second Claude account no longer loses that announcement.
+- A metering-rate change notification names the account whose rate changed, so two accounts changing rate no longer produce two identical popups. An install with one account, or none, sees exactly the notification it saw before.
+- `cctally explain` and the dashboard's Explain modal build current, baseline and conversation-derived evidence within their documented warm and cold latency budgets without caching a stale report or slowing dashboard updates.
+- `cctally doctor` reports `not assessed` rather than `no change detected` when no quota calibration has been fitted, so a withheld fit no longer reads as a confirmed all-clear about your metering rate.
+- `cctally quota` records the durable metering-rate history whenever its detector confirms a change, even when the fitted budget is withheld because this week's composition sits outside the calibration's support.
+- The metering-rate notification says the calibration was withheld, and names why, instead of promising a fitted budget it cannot supply.
+- `cctally doctor` stops telling you to run `cctally quota` for a fitted budget when the calibration behind the change has none, and names the withholding instead.
+- The dashboard's rate-change toast points at the evidence for a metering-rate change rather than promising a fitted budget.
+- `cctally dashboard` skips both provider file estates on caught-up ticks, falls back to a full pass when hook activity cannot be recorded, and reports the main refresh loop's measured CPU duty.
+- `cctally dashboard` reuses unchanged Codex accounting and account-card populations across quota and one-file updates, shortening active refreshes without changing cadence or freshness.
+- `cctally quota` withholds malformed retained timestamps without a traceback, filters offset-bearing credit times by their instant, and emits every JSON timestamp with a trailing `Z`.
+- Historical forecast replays ignore mid-week reset events until their recorded detection instant, so a future event can no longer erase the samples that were available at the replayed time.
+- Weekly projected-pace alerts use the same model-backed value as `cctally forecast` when a quota calibration applies, instead of silently stopping for calibrated users.
+- The dashboard's Forecast modal keeps an extreme projection label inside the card instead of clipping it at the 110% track edge.
+- `cctally record-usage` no longer fabricates a percent milestone from a stale pre-credit reading after Anthropic zeroes your weekly counter, so a fresh week's milestone ladder no longer opens at a percentage you never reached.
+
+## [1.104.0] - 2026-08-29
+
+### Added
+- `cctally quota` reports how much of your weekly quota your usage consumes and whether Anthropic has changed the metering rate, from a budget fitted to your own history rather than a shipped constant. See `docs/commands/quota.md`.
+- `cctally quota --json` publishes the fit, the current week's consumption and projection, the composition support radii and the detector's own bound under `schemaVersion` 1.
+- `cctally quota --reset-calibration` discards the stored calibration for one account, and `--since` and `--watch-from` narrow or override the window the analysis uses.
+- `bin/cctally-preflight` compiles every Python file in the repository, not only the ones beside it, so a syntax error anywhere in the tree now blocks a test run instead of surfacing during one.
+- `cctally forecast --json` states the reading its arithmetic used and where its projection came from, through `weekly_percent_corrected`, `right_censored`, `projection_basis`, `projection_code` and `calibration_code`.
+- `cctally forecast --json` moves to `schemaVersion` 2: its three projection fields can now be null, and they are measured from a different reading than before.
+- `cctally project --json` moves to `schemaVersion` 2. `attributedUsedPercent` and `costPerPercent` keep their spelling and change their meaning, from a share of the window's cost to modelled weekly quota.
+- `cctally project` reports each project's `Used %` as modelled quota units rather than as its share of the window's dollars, so a cache-heavy project no longer reads high and an output-heavy Opus one no longer reads low.
+- `cctally doctor` reports a new Quota category: whether Anthropic changed your weekly metering rate, and whether the stored calibration is usable. Neither check can fail, so neither changes doctor's exit code.
+- `cctally quota` records a durable event when it confirms a metering-rate change, so it and `doctor` report the change with no configuration. The desktop notification stays off until you set `alerts.rate_change_enabled`.
+- `cctally project` states its four modelled-quota figures under the table — window total, listed-row total, filtered or unmodelled, and the meter's reading minus the modelled total — where before they were in `--json` only.
+- The status line's 7d slot shows where the week is heading and which measurement said so, as `7d 42% (2d 3h) → 58% meter`, plus a `Δrate` marker while a metering-rate change is in force.
+- The dashboard's Forecast panel names the basis its projection came from and shows a `Δ rate` chip while a metering-rate change is in force.
+- The dashboard's Forecast modal adds the modelled consumption, the headroom, what the meter reading covers, and the meter's reading minus the modelled total.
+- The dashboard's Recent Alerts modal lists metering-rate changes in their own section, with the size and direction of the change and the instant it took effect, and a rate change now raises its own toast.
+- `alerts.rate_change_enabled` is settable with `cctally config set` and from the dashboard's Settings overlay, so turning the notification on no longer means editing `config.json` by hand.
+- `bin/cctally-test-all` refuses to start when the recorded test estate disagrees with what this tree collects, when a recorded test disappeared without a declaration authorizing it, or when it cannot derive the estate at all.
+- `bin/cctally-test-all --with-estate-check` runs that check on a `--harness` subset, which otherwise skips it to keep a targeted run fast.
+
+### Changed
+- `cctally forecast`, the TUI and the dashboard measure your pace from what you consumed rather than from the rounded-up meter reading, so rates and projections read about half a point lower and daily budgets a little larger.
+- At a displayed 100% the forecast shows no projection, no time-to-cap and no daily budget, because a capped meter says only that you are past 99%. `cctally quota` still models consumption there, from tokens.
+- The projected-pace weekly alert stays quiet once `cctally quota` has fitted your budget, rather than firing on a pace the forecast no longer shows you.
+- `cctally forecast`'s trailing four-week dollar rate divides each prior week's cost by the meter movement that week realized, not by its post-credit high-water mark, which priced one measured week at $355 per point against a true $25.
+- A prior week whose realized movement cannot be established is left out of the forecast's four-week median rather than guessed at, and so is a week whose meter reached 100%.
+- `cctally project` withholds its meter-versus-modelled difference when the requested range slices a subscription week, instead of stating a whole-week difference beside a three-day range.
+- `cctally forecast` names its dollar rate's source in words — `trailing 4wk median (drift-reduced confidence)` rather than the bare code — and says when the comparability test behind that rate could not run.
+- `rates.week_average_pct_per_hour` in `cctally forecast --json` is null at a reading of 100% or more, because a capped meter supplies no rate to average.
+- `cctally quota` refuses to predict from a metering rate it has only just detected. It says so, and the forecast, the TUI and the dashboard fall back to the meter and state the reason, rather than projecting from a three-day fit.
+- `bin/cctally-preflight` lists the repository once instead of once per check, so widening the Python check to the whole tree costs one pass rather than two.
+- `docs/commands/report.md` states that `$ / 1%` falls when the provider charges more points for the same tokens, so a drop can read as improved efficiency, and points at `cctally quota` as the detector. The metric itself is unchanged.
+- `cctally project` names the absent operand when it withholds the meter-versus-modelled difference — a modelled week with no snapshot, or a window that modelled no week — instead of reporting either as a misaligned population.
+- `bin/cctally-test-all` builds both of its pytest phases from one recorded declaration rather than from hard-coded file names, and refuses at startup when a named target no longer exists.
+- `bin/cctally-test-all` removes `PYTEST_ADDOPTS` and `PYTEST_PLUGINS` from both pytest phases so neither can narrow a run; set `CCTALLY_PYTEST_DURATIONS=1` for per-test timings instead.
+
+### Fixed
+- The dashboard keeps the full account-count value visible in the `All` hero at tablet widths instead of clipping it mid-word.
+- A shared forecast artifact writes a ceiling more than 30 days out as `>30d` instead of printing the literal figure, which on a barely-used week read `1166.8`.
+- The terminal forecast's explain modal says why it shows no daily budgets at a capped meter, instead of printing the heading over nothing.
+- `bin/cctally-preflight` bounds every command it runs, including the harness-ownership check, and reports a hung system bash version probe rather than silently skipping the bash 3.2 floor check.
+- `bin/cctally-preflight` stops its shell syntax sweep and reports what went unchecked when an interpreter hangs, rather than spending its full per-file timeout on every remaining file.
+- `cctally project` withholds modelled quota on a multi-account install whose account registry cannot be read, instead of falling back to a cost share under the `Used %` column.
+- `cctally forecast` leaves a prior week out of its four-week median when the recorded credit or reset rows for that week cannot be read, instead of summing the week as if the credit had zeroed the meter.
+- `cctally forecast` keeps prior weeks from before a metering-rate change out of its four-week median even when it cannot read the entry cache, instead of admitting every one of them after a single failed read.
+- The dashboard hero shows no week-over-week `$ / 1%` comparison when it has no `$ / 1%` to compare, instead of printing a change beside a dash.
+- The dashboard's Forecast panel keeps its pace bar visible and its content inside the card when the source reports a degradation, where the bar collapsed to nothing and the panel overflowed.
+- The dashboard's Forecast modal says when a published `$ / 1%` rate was measured over a reduced or unverified population, where before the qualification was only visible in `--json`.
+- A metering-rate change desktop notification shows the effective date in your own timezone rather than in UTC.
+- Interrupting `cctally quota` with Ctrl-C while it records a metering-rate change stops the command, rather than printing a recording failure and carrying on.
+- `cctally quota` carries on when it cannot read your stored calibration file, rather than stopping with a Python traceback.
+- The status line's 7d slot shows no projection once the stored reset instant has passed, rather than projecting over a week that has already ended.
+- The dashboard's Forecast panel puts its verdict, status and `Δ rate` chips on one line instead of stacking them, giving the card back a row of height. The Forecast modal's Quota model heading is now tinted like every other section heading.
+
 ## [1.103.0] - 2026-08-26
 
 ### Added

package/README.md

@@ -30,15 +30,15 @@ Your Claude Code plan meters you with a percentage that creeps up all week. ccta
 </p>
 
 <!-- cctally:latest-stable:begin -->
-**Latest stable: v1.101.0** (2026-08-19)
+**Latest stable: v1.104.0** (2026-08-29)
 
-Highlights from the `v1.95.5` to `v1.101.0` stable upgrade:
+Highlights from the `v1.101.0` to `v1.104.0` stable upgrade:
 
-- Dashboard refreshes release their read lock on `cache.db` sooner, cutting the measured median hold from 3.40 seconds to 1.04. The published data is unchanged.
-- Every dashboard warning carries a button that opens the surface explaining it, the week, the five-hour block, the month, the project, or the forecast. A warning whose window has closed says so and opens nothing.
-- The dashboard's Projects table writes out what its two percentages mean under the week selector, where a phone can read it. `Used pp` is relabelled `Used pp (sum)`, and the caption names the denominator of `Cost share`.
+- `cctally quota` reports how much of your weekly quota your usage consumes and whether Anthropic has changed the metering rate, from a budget fitted to your own history rather than a shipped constant. See `docs/commands/quota.md`.
+- `cctally quota --json` publishes the fit, the current week's consumption and projection, the composition support radii and the detector's own bound under `schemaVersion` 1.
+- `cctally quota --reset-calibration` discards the stored calibration for one account, and `--since` and `--watch-from` narrow or override the window the analysis uses.
 
-[See every change in this stable upgrade](https://github.com/omrikais/cctally/releases/tag/v1.101.0)
+[See every change in this stable upgrade](https://github.com/omrikais/cctally/releases/tag/v1.104.0)
 <!-- cctally:latest-stable:end -->
 
 ## Quick start

package/bin/_cctally_alerts.py

@@ -140,6 +140,73 @@ def _alert_text_quota(payload: dict, _tz) -> tuple[str, str, str]:
     # dashboard alert envelope, so the CLI line is the only routing it gets.
     return title, subtitle, _with_next_step(body, payload, _tz)
 
+
+def _alert_text_meter_rate_change(payload: dict, tz) -> tuple[str, str, str]:
+    """#661 S2 §6.1: the non-threshold family's own copy.
+
+    It states the direction and the size of the change, and it states them as
+    a rate the provider sets rather than as anything cctally can act on. There
+    is no threshold to name, which is the whole reason this family is not an
+    `AXIS_REGISTRY` member.
+
+    THREE deliberate divergences from the threshold builders, all recorded
+    in `docs/alerts-gotchas.md` (#661 S2 Stage C review, F7b; the third
+    added by #688):
+
+    * The body does not end with `_with_next_step`. That helper derives its
+      affordance through `alert_next_step_command`, which branches on
+      `AXIS_REGISTRY` axes; this family is deliberately not one, so it has no
+      window to scope and no branch to reach. The affordance is stated
+      directly instead.
+    * This builder and `_alert_text_quota` above it live in this glue module
+      rather than in the pure `_lib_alerts_payload` kernel, which holds the
+      other six. That is the placement both non-registry families use.
+    * The BODY varies on a payload field, which no threshold builder does.
+      #688 records a transition whenever the detector qualifies, including
+      when the command's own verdict is withheld for a reason that bears on
+      predicting forward, so a recorded transition may sit beside a verdict
+      `cctally quota` refuses. Sending that user to a fitted budget that
+      does not exist is a false instruction, so the body names the
+      withholding instead and points at the evidence.
+
+    NOT a fourth divergence (#697): the standard R8 `[<label>] ` title prefix
+    is applied DOWNSTREAM by `_dispatch_alert_notification`, which resolves the
+    account registry from this payload's own `provider` field rather than from
+    `_AXIS_VENDOR`. The prefix is shared behaviour every axis takes, so this
+    builder keeps its signature and its return and never learns about accounts.
+
+    `effective_from` IS routed through `format_display_dt`. It is a clock
+    instant, not a calendar day, so the carve-out `_alert_text_weekly`
+    documents for `week_start_date` does not apply: slicing its first ten
+    characters showed a user at UTC+13 or UTC-8 a date one day away from
+    their own.
+    """
+    previous = float(payload.get("previous_units_per_point") or 0.0)
+    new = float(payload.get("new_units_per_point") or 0.0)
+    provider = str(payload.get("provider") or "claude").capitalize()
+    if previous > 0.0 and new > 0.0:
+        change = (new - previous) / previous * 100.0
+        direction = "less" if change < 0 else "more"
+        subtitle = (
+            f"each meter point now covers {abs(change):.0f}% {direction} usage")
+    else:
+        subtitle = "the rate this account is metered at changed"
+    raw = str(payload.get("effective_from") or "")
+    try:
+        effective = _lib_alerts_payload.format_display_dt(
+            raw, tz, fmt="%Y-%m-%d", suffix=False) if raw else ""
+    except ValueError:
+        effective = ""
+    withheld = payload.get("withholding_status")
+    if withheld:
+        tail = (f"The calibration was withheld ({withheld}), so no fitted "
+                f"budget is available. Run `cctally quota` for the evidence.")
+    else:
+        tail = "Run `cctally quota` for the fitted budget and its evidence."
+    body = f"Effective {effective}. {tail}" if effective else tail
+    return f"cctally - {provider} metering rate changed", subtitle, body
+
+
 # Phase B: severity policy + the cross-platform dispatch kernel. The kernel is
 # pure (parameterized on platform + which_on_path); this module is the I/O glue
 # that injects the real sys.platform / shutil.which and spawns with shell=False.
@@ -177,7 +244,8 @@ _AXIS_VENDOR = {
 }
 
 
-def _alert_label_prefix(axis: str, account_key: "str | None") -> str:
+def _alert_label_prefix(axis: str, account_key: "str | None",
+                        provider: "object | None" = None) -> str:
     """Return ``"[<label>] "`` for an account-specific crossing when the vendor
     has >1 real account (R8), else ``""``. Best-effort + never-raise: a missing
     DB / read error / vendor-wide (`*`) row yields no prefix, so a ≤1-real-account
@@ -186,13 +254,26 @@ def _alert_label_prefix(axis: str, account_key: "str | None") -> str:
     Delegates the R8 gate + label precedence to the single-definition helpers
     ``_cctally_account.real_account_count`` / ``account_label`` (P2-CQ1) so the
     ">1 real account" trigger and the key->label map have exactly one home; this
-    wrapper only opens the RO connection and stays best-effort/never-raise."""
+    wrapper only opens the RO connection and stays best-effort/never-raise.
+
+    #697: the VENDOR comes from the payload's own ``provider`` when it carries
+    one, and from ``_AXIS_VENDOR`` otherwise. The metering-rate-change family
+    is the only payload that carries the key, and it is authoritative there —
+    the family's visible title is derived from that same field, so a static map
+    entry could send a Codex title to Claude's registry with nothing reporting
+    the disagreement. The lookup is normalized because ``real_account_count``
+    matches ``accounts.provider`` exactly, and an unmatched provider degrades
+    silently to no prefix. The whole resolution sits INSIDE the guard so that a
+    provider whose ``__str__`` raises cannot escape the never-raise contract.
+    """
     if not account_key or account_key == _lib_accounts.VENDOR_WIDE:
         return ""
-    vendor = _AXIS_VENDOR.get(axis)
-    if vendor is None:
-        return ""
     try:
+        vendor = str(provider).strip().lower() if provider is not None else ""
+        if not vendor:
+            vendor = _AXIS_VENDOR.get(axis)
+        if vendor is None:
+            return ""
         import sqlite3 as _sq
         import _cctally_account
         db_path = _cctally_core.DB_PATH
@@ -293,6 +374,8 @@ def _dispatch_alert_notification(
         title, subtitle, body = _alert_text_projected(payload, tz)
     elif axis == "quota":
         title, subtitle, body = _alert_text_quota(payload, tz)
+    elif axis == "meter_rate_change":
+        title, subtitle, body = _alert_text_meter_rate_change(payload, tz)
     else:
         title, subtitle, body = (
             "cctally - alert",
@@ -303,17 +386,28 @@ def _dispatch_alert_notification(
     # R8 label prefix (#341): an account-specific crossing gains a `[<label>] `
     # title prefix ONLY when the vendor has >1 real account. Byte-identical at
     # <=1 real account (empty prefix). Applied to the notification title only.
+    # #697: the vendor whose registry is counted comes from the payload's own
+    # `provider` when it carries one, and from `_AXIS_VENDOR` otherwise.
     account_key = payload.get("account_key")
-    title = _alert_label_prefix(axis, account_key) + title
+    title = _alert_label_prefix(axis, account_key, payload.get("provider")) + title
 
     # Severity (3-tier) drives both the notify-send urgency token and the
     # trailing log column. A missing threshold (defensive — shouldn't happen for
     # a real crossing) floors at "info".
     threshold = payload.get("threshold")
-    try:
-        severity = severity_for(int(threshold)) if threshold is not None else "info"
-    except (TypeError, ValueError):
-        severity = "info"
+    if axis == "meter_rate_change":
+        # #661 S2 §6.1: this family carries an EXPLICIT severity, because a
+        # rate transition has no percentage threshold for `severity_for` to
+        # map. Reading it verbatim is what keeps the three tiers meaningful
+        # here; falling through would floor every transition at `info`.
+        severity = str(payload.get("severity") or "info")
+        if severity not in ("info", "warn", "alarm"):
+            severity = "info"
+    else:
+        try:
+            severity = severity_for(int(threshold)) if threshold is not None else "info"
+        except (TypeError, ValueError):
+            severity = "info"
     urgency = severity_to_urgency(severity)
 
     if platform is None: