cctally 1.116.0 → 1.117.0

package/CHANGELOG.md

@@ -5,6 +5,42 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.117.0] - 2026-11-02
+
+### Added
+- `cctally doctor` adds `accounts.claude_cost_attribution`, reporting how recent Claude cost was attributed to accounts and the progress of the one-time upgrade step that records existing attribution.
+
+### Changed
+- `cctally quota` no longer withholds a forecast over a small Sonnet 5.5 share shift that meter evidence shows to be immaterial, and withheld lines name the family reason. Stored calibrations go stale until the next `cctally quota` run.
+- When a reviewed `cctally db rederive` correction changes a calibration's inputs, `cctally forecast` and the dashboard withhold calibrated figures ("recalibration needed") until `cctally quota` refits. Stats rebuilds once on upgrade.
+- A metering-rate change fitted from corrected inputs no longer shows its status-line marker or sends its notification; the dashboard's Recent Alerts keeps it, labelled "superseded by a correction".
+- After a gap without a running `cctally dashboard`, its first transcript catch-up writes less to `conversations.db`, and `cctally dashboard-perf` and `cctally doctor` no longer judge that catch-up as steady-state disk writes.
+- Automatic credit, early-reset and status-line drop detection paused by an older cctally process now resumes on its own, per account and per limit; `cctally doctor` shows what each limit waits for. Stats rebuilds once on upgrade.
+
+### Fixed
+- A `stats.db` upgrade rebuild or `cctally db rebuild --db stats` no longer reprices closed five-hour blocks and their milestones at the current rate card when it recovers missing records.
+- Archived Codex threads now count in `codex-*` reports, quota history and the dashboard, and archiving no longer deletes history. Archived usage first seen with no recorded account stays unattributed unless quota windows assign it.
+- On Python builds that link SQLite 3.54.1, a running `cctally dashboard` reclaims transcript space freed by retention again, so `conversations.db` shrinks instead of keeping the freed pages.
+- An idle Claude Code session's stale `cctally statusline` reading no longer records a false weekly reset, five-hour credit or zero-cost milestone once a later usage check reads higher; the stats index rebuilds once after upgrading.
+- Claude cost is attributed to the account active when Claude Code wrote it, not the one active when cctally read it. Upgrades and `cctally cache-sync --rebuild` keep each row's account.
+- `cctally statusline` measures `🧠` context % against the session's real context window (1M for Opus, Sonnet and Haiku 5.5), so an Opus 5.5 session no longer shows a red percentage five times too high and Fable sessions no longer show `N/A`.
+- A `stats.db` upgrade rebuild could exit early as busy when a status-line check for a running rebuild landed at the instant it started, delaying the rebuild; that check no longer interferes with a starting rebuild.
+- `cctally explain` and the dashboard's Explain view measure Opus, Sonnet and Haiku 5.5 requests against their 1M context window and now evaluate Fable requests, so short conversations are no longer flagged for large context against 200K.
+- `cctally five-hour-blocks`, `cctally five-hour-breakdown` and the dashboard keep each five-hour window's genuine peak, milestones and readings through a usage credit and through every stats.db rebuild, instead of dropping some.
+- `cctally record-credit` records the exact `--at` time instead of the start of that hour, keeping readings taken earlier in that hour, and a `--force` replacement at the replaced credit's own second now takes effect.
+- A weekly usage credit is no longer lost when recording is interrupted while it is being saved.
+- After stats.db is rebuilt from a missing or corrupt file, the stats index keeps updating incrementally instead of falling back to rereading the whole recorded history.
+- On an exFAT data folder, cctally now quarantines and rebuilds a corrupt `conversations.db` or `cache.db` and can run `db repair --db stats`, and a rebuild no longer fails after 20 s while another cctally process has the store open but idle.
+- On macOS, `cctally cache-sync --rebuild` no longer writes a full copy of `conversations.db` on volumes without copy-on-write clones (HFS+, exFAT); there and on Linux ext4 its integrity check runs in place when no write-ahead log is pending.
+- `cctally dashboard` no longer waits on a reverse-DNS lookup of its bind address before it prints its URL and serves, a wait that lasted the resolver's whole timeout where the network never answers that lookup.
+- Codex hooks installed by `cctally setup` no longer stall Codex sessions for over 10 seconds on large histories or after upgrading, or for over a minute with Codex budget alerts on; leftover work runs in the background.
+- `cctally db rederive` restores a five-hour milestone's cost when an earlier rederive repriced it under a closed block; one whose history is ambiguous keeps its cost and is listed in `withheldMilestoneRepairs`.
+
+## [1.116.1] - 2026-10-28
+
+### Maintenance
+- Internal improvements only; no user-facing changes.
+
 ## [1.116.0] - 2026-10-28
 
 ### Added

package/README.md

@@ -30,13 +30,11 @@ Your Claude Code plan meters you with a percentage that creeps up all week. ccta
 </p>
 
 <!-- cctally:latest-stable:begin -->
-**Latest stable: v1.113.0** (2026-09-29)
+**Latest stable: v1.116.1** (2026-10-28)
 
-Highlights from the `v1.112.0` to `v1.113.0` stable upgrade:
+Highlights from the `v1.113.0` to `v1.116.1` stable upgrade:
 
-- Codex cost reports price `gpt-6.1-sol` at its published input, cached-input and output rates, including long-context and Fast pricing, instead of using fallback rates.
-
-[See every change in this stable upgrade](https://github.com/omrikais/cctally/releases/tag/v1.113.0)
+[See every change in this stable upgrade](https://github.com/omrikais/cctally/releases/tag/v1.116.1)
 <!-- cctally:latest-stable:end -->
 
 ## Quick start
@@ -135,7 +133,7 @@ See [docs/commands/blocks.md](docs/commands/blocks.md) and [docs/commands/five-h
 
 ## Codex
 
-If you also use OpenAI's Codex CLI, cctally tracks it with the same depth. `cctally codex daily`, `monthly`, and `session` are drop-in replacements for the ccusage codex commands, reading from your local `~/.codex/sessions/`. `cctally codex weekly` adds a subscription week rollup, and `cctally codex quota` shows your native Codex rate limit windows.
+If you also use OpenAI's Codex CLI, cctally tracks it with the same depth. `cctally codex daily`, `monthly`, and `session` are drop-in replacements for the ccusage codex commands, reading from your local `~/.codex/sessions/`, archived threads in `~/.codex/archived_sessions/` included. `cctally codex weekly` adds a subscription week rollup, and `cctally codex quota` shows your native Codex rate limit windows.
 
 <p align="center">
   <img src="docs/img/cli-codex-daily.svg" alt="cctally codex daily: Codex cost by day">

package/bin/_cctally_account.py

@@ -1295,9 +1295,34 @@ def _attribute_apply(planned, *, account_key, mode, since, until, at,
                 conn.execute("BEGIN IMMEDIATE")
                 _landed, skipped = _cache_mod.rehydrate_codex_window_attributions(
                     conn)
+                # #980 F1: the reconciliation's adoption demotes Spark windows
+                # through the RESOLVED `observed_model` (#373), so owed model
+                # resolution runs first, on this transaction and under the
+                # writer flocks this command holds. When it still cannot
+                # resolve, nothing is reconciled over an unresolved model: the
+                # apply aborts (`recordedPending` once records were appended)
+                # and a rerun finishes it.
+                if _cache_mod.codex_model_resolution_pending(conn):
+                    _cache_mod._codex_settle_finalization(
+                        conn, deadline=None, stages=("expand", "model"))
+                    if _cache_mod.codex_model_resolution_pending(conn):
+                        raise sqlite3.DatabaseError(
+                            _quota.PROJECTION_DEFERRED_MODEL)
                 restored, adopted = (
                     _cache_mod.reconcile_codex_window_attribution_spend(
                         conn, strict=True))
+                # #980 R7: the rehydrate above armed `attribution` debt for
+                # exactly the reconciliation that just succeeded, on this
+                # transaction; settle it here, or every account-scoped hook
+                # read defers until a later settlement repeats it. Kept while
+                # adoption items remain: the reconcile runs after them (D4).
+                # A later failure rolls this back with everything else.
+                debt = _cache_mod.load_codex_finalization_debt(conn)
+                if (debt.attribution and not debt.malformed
+                        and not debt.full and debt.first_item() is None):
+                    debt.attribution = False
+                    debt.strikes = 0
+                    _cache_mod._store_codex_finalization_debt(conn, debt)
                 # Verify the applied record set against the plan we locked,
                 # BEFORE the commit: a silent partial application must abort the
                 # transaction rather than be reported as success (spec §8.2).
@@ -1365,20 +1390,49 @@ def _attribute_apply(planned, *, account_key, mode, since, until, at,
     # rerun completes it, because the certificate's attribution revision is
     # still behind the derived table's (`_attribute_tail_pending`).
     try:
-        _quota.reconcile_codex_quota_projection()
+        deferred = _attribute_publish_projection()
     except Exception as exc:  # noqa: BLE001 - reported, never swallowed
+        deferred = str(exc)
+    if deferred is not None:
         return ("recordedPending", actions, [{
             "code": "recordedPending",
             "message": (
                 f"the attribution was recorded and applied but the quota "
-                f"projection did not finish ({exc}); rerun the same command "
-                f"to complete it"),
+                f"projection did not finish ({deferred}); rerun the same "
+                f"command to complete it"),
         }], fresh)
     status = ("recovered" if ((recovered or completion) and not appended)
               else "applied")
     return (status, actions, [], fresh)
 
 
+def _attribute_publish_projection() -> "str | None":
+    """Publish the quota projection; return None, or why it is still refused.
+
+    #980 D6: every projection publisher refuses while model resolution is
+    owed, returning a ``deferred_model`` status rather than raising, so a bare
+    reconcile here reported success over an unpublished projection. Owed
+    resolution is therefore settled first, unbudgeted, through the cache
+    writer flocks an unbudgeted sync takes; when the projection still refuses
+    (those flocks were contended) the caller reports ``recordedPending``.
+    """
+    import _cctally_cache as _cache_mod
+    import _cctally_quota as _quota
+
+    settled = False
+    if _cache_mod.codex_model_resolution_pending_now():
+        _cache_mod.settle_codex_finalization_unbudgeted()
+        settled = True
+    result = _quota.reconcile_codex_quota_projection()
+    if (getattr(result, "status", None) == _quota.PROJECTION_DEFERRED_MODEL
+            and not settled):
+        _cache_mod.settle_codex_finalization_unbudgeted()
+        result = _quota.reconcile_codex_quota_projection()
+    if getattr(result, "status", None) == _quota.PROJECTION_DEFERRED_MODEL:
+        return _quota.PROJECTION_DEFERRED_MODEL
+    return None
+
+
 def _cmd_account_attribute(args: argparse.Namespace) -> int:
     """`cctally account attribute` — preview by default, `--yes` applies.