cctally 1.104.0 → 1.106.0

package/CHANGELOG.md

@@ -5,6 +5,76 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.106.0] - 2026-09-03
+
+### Changed
+- `cctally record-credit --force` replaces the single credit `--at` names instead of clearing the whole week, and refuses when `--at` names none. Recording a second credit in one week needs no `--force`: rerun with a different `--at`.
+- A week Anthropic credited in place renders as one row on its own boundaries, instead of two rows split at the credit. A credit that also moved the week's declared end is marked, but still renders on the windows the API stated.
+- The dashboard's Current Week header and modal name the week's own boundaries on a credited week, instead of the window that starts at the credit.
+- A credited week's row is marked `+` in `cctally report` and `cctally weekly`, so a low `Used %` beside a week's worth of spend has a visible explanation.
+- The dashboard's Weekly panel and its week detail mark a credited week, and the week detail, the Current Week card and its modal name why `$/1%` is withheld instead of the em-dash or `$0.000` you cannot tell from a week with no usage.
+- The dashboard's `$/1%` tables — the Weekly modal's week list, the `$/1% Trend` panel and its modal — say `No climb` for a credited week whose ratio is withheld, instead of the em-dash you cannot tell from a week with no usage.
+- `$/1%` for a credited week is measured from the credit forward, over the climb since it. With no climb yet the figure is withheld and names why. Uncredited weeks are unchanged.
+- The dashboard's Current Week card, the TUI header and a shared Current Week recap report a credited week's whole spend, matching the week they name and the Weekly card beside them. Only `$/1%` is measured from the credit forward.
+- `cctally milestone` history lists a credited week once instead of once per credit, and its detail separates the week's percent ladders with a row naming each credit and the level it dropped from.
+
+### Fixed
+- A conversation open in the viewer updates its own cost as its turns stream, for both Claude and Codex. The live tail advanced the transcript but not the accounting the cost is read from.
+- A Codex conversation's cost no longer reads `$0.00` long after its turns finish. The dashboard now re-scans each provider at least every two minutes, so accounting stays current even when that provider's activity hooks never fire.
+- Upgrading an existing installation to v1.105.0 left every background sync failing and the dashboard stuck on `server sync error`. The two columns that release added now reach an existing database, not only a freshly created one.
+- After Anthropic zeroes your weekly counter, every 7d surface lowers on the next status-line tick. A reading captured in the same hour no longer holds the week at its pre-credit percentage, and no manual command is needed.
+- A goodwill credit to a non-zero level records that level's own percent milestone. Before, the ladder for the new period opened one percent late, and `cctally percent-breakdown` was missing its first row.
+- `cctally percent-breakdown`, the TUI's milestone panel and the milestone writer agree on which credit a percent belongs to, including after a database rebuild and for a credit recorded with `cctally record-credit`.
+- A percent milestone crossed after a credit reports the cost spent since that credit. After a credit recorded with `cctally record-credit` it reported the whole week's spend, which made the first post-credit `$/1%` figure far too high.
+- `cctally record-credit` no longer deletes genuine usage recorded between the moment you assert with `--at` and the moment you run the command.
+- On an install with more than one Claude account, a reset detected for one account no longer records a credit for another, and no longer discards the first account's pending detection.
+- `cctally forecast` measures its rate from the latest credit rather than across it, including one you recorded yourself. `cctally budget` keeps summing the whole week, because the money was spent inside one unchanged window.
+- `cctally doctor`'s post-credit milestone check now sees a week credited with `cctally record-credit`, which it silently skipped before.
+- `cctally record-credit` accepts a second credit inside the same hour as the first. Only a credit at the identical instant is still refused, because that is indistinguishable from running the command twice.
+- An install upgrading from a version that predates the append-only journal now gets the current weekly-credit table shape, instead of reporting the new database version while missing the columns a credit needs.
+- `cctally record-credit --force` no longer leaves a replaced credit's percent milestones behind after a database rebuild, and `cctally record-usage` no longer leaves a removed stale reading's five-hour milestones pointing at it.
+- `cctally` no longer records a second, automatically-shaped credit for a large credit you already recorded with `cctally record-credit`.
+- A stale pre-credit reading replayed by the status line after a credit is removed on the next tick that contradicts it, instead of holding every 7d surface at the old percentage and provoking a second, phantom credit.
+- On an install with more than one Claude account, `cctally record-credit` no longer names another account's credit when refusing, and no longer finishes another account's interrupted credit as though it were yours.
+
+## [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

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

@@ -149,8 +149,9 @@ def _alert_text_meter_rate_change(payload: dict, tz) -> tuple[str, str, str]:
     is no threshold to name, which is the whole reason this family is not an
     `AXIS_REGISTRY` member.
 
-    Two DELIBERATE divergences from the threshold builders, both recorded in
-    `docs/alerts-gotchas.md` (#661 S2 Stage C review, F7b):
+    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
@@ -159,7 +160,20 @@ def _alert_text_meter_rate_change(payload: dict, tz) -> tuple[str, str, str]:
       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 five. That is the placement both non-registry families use.
+      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`
@@ -183,10 +197,13 @@ def _alert_text_meter_rate_change(payload: dict, tz) -> tuple[str, str, str]:
             raw, tz, fmt="%Y-%m-%d", suffix=False) if raw else ""
     except ValueError:
         effective = ""
-    body = (
-        f"Effective {effective}. Run `cctally quota` for the fitted budget "
-        f"and its evidence." if effective else
-        "Run `cctally quota` for the fitted budget and its evidence.")
+    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
 
 
@@ -227,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
@@ -236,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
@@ -355,8 +386,10 @@ 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