cctally 1.102.0 → 1.103.0

package/README.md

@@ -34,9 +34,9 @@ Your Claude Code plan meters you with a percentage that creeps up all week. ccta
 
 Highlights from the `v1.95.5` to `v1.101.0` stable upgrade:
 
-- Dashboard refreshes now release their coherent `cache.db` snapshot before constructing provider views, cutting the measured median read hold from 3.40 seconds to 1.04 seconds while preserving the exact published payload (#617).
-- Every dashboard warning state now offers the explanation for its own window. A row in Recent alerts, an alert toast, a warn or over budget block, and a capped forecast each carry a button that opens the surface explaining that warning: a weekly crossing opens the current week, a five-hour crossing opens that block, a calendar-month budget opens that month, a project-budget crossing opens that project's drill-down, and a projected-pace crossing opens the forecast. The window is checked before anything opens, a warning about a week the dashboard is no longer showing states that its window has closed and opens nothing at all, rather than quietly showing you the current week instead. A five-hour block still opens however old it is, as long as the alert recorded which block it was; an alert that recorded no block start says so and opens nothing. On Codex the button says `Open this cycle` rather than `Open this week`, because a Codex quota cycle is what it opens. A project-budget crossing on a machine with more than one account is recorded across all of them, so it states that it cannot be narrowed to one account's projects rather than picking one. Every button is an ordinary control reachable by Tab and activated by Enter or Space, and no keyboard shortcut is claimed (#620).
-- The dashboard's Projects table now writes out what its two percentages mean, under the week selector rather than only in a tooltip, a tooltip never appears on a phone. The `Used pp` column is relabelled `Used pp (sum)` and the caption states that it adds each week's attributed usage percentage across the selected window, so it is a sum of percentage points rather than a share of any one week; the caption also names the denominator of the `Cost share` column as total project spend in that same window. No column is added or removed. On an installation with more than one Claude account, both the Projects panel and the Projects table now also state that accounts are folded into one ranking and that their weekly quota percentages are never added together. That sentence appears on the Claude and All views only, because the Codex view ranks Codex projects and folds no Claude accounts at all (#620).
+- 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`.
 
 [See every change in this stable upgrade](https://github.com/omrikais/cctally/releases/tag/v1.101.0)
 <!-- cctally:latest-stable:end -->

package/bin/_cctally_cache.py

@@ -7327,6 +7327,20 @@ def sync_codex_cache(
                 model=initial_model,
                 total_tokens=initial_total_tokens,
             )
+            if start_offset > 0 and not truncated and not requalified:
+                prior_accounting = conn.execute(
+                    "SELECT MAX(timestamp_utc),MAX(line_offset) "
+                    "FROM codex_session_entries "
+                    "WHERE source_path=? AND line_offset<? ",
+                    (path_str, start_offset),
+                ).fetchone()
+                if prior_accounting is not None and prior_accounting[0] is not None:
+                    iter_state.last_accounting_timestamp = _parse_anchor_iso(
+                        prior_accounting[0])
+                if prior_accounting is not None and prior_accounting[1] is not None:
+                    iter_state.generation_transition_pending = (
+                        _lib_jsonl._codex_generation_transition_between(
+                            path_str, int(prior_accounting[1]), start_offset))
             if (
                 prev is not None and not truncated and not requalified
                 and prev_native_thread_id is not None
@@ -11223,6 +11237,23 @@ def sync_codex_conversations(
                 model=initial_model,
                 total_tokens=initial_total_tokens,
             )
+            if start_offset > 0 and not reset_file:
+                try:
+                    prior_accounting = conn.execute(
+                        "SELECT MAX(timestamp_utc),MAX(line_offset) FROM "
+                        "cache_db.codex_session_entries "
+                        "WHERE source_path=? AND line_offset<? ",
+                        (path_str, start_offset),
+                    ).fetchone()
+                except sqlite3.OperationalError:
+                    prior_accounting = None
+                if prior_accounting is not None and prior_accounting[0] is not None:
+                    state.last_accounting_timestamp = _parse_anchor_iso(
+                        prior_accounting[0])
+                if prior_accounting is not None and prior_accounting[1] is not None:
+                    state.generation_transition_pending = (
+                        _lib_jsonl._codex_generation_transition_between(
+                            path_str, int(prior_accounting[1]), start_offset))
             if initial_native and initial_root:
                 state.thread = _lib_jsonl.CodexThreadMetadata(
                     source_root_key=discovered.source_root_key,

package/bin/_lib_jsonl.py

@@ -381,6 +381,19 @@ class _CodexIterState:
     # watermark by construction, and the caller persists exactly it (replacing
     # the old reconstructed initial+Σ(per-turn) sum, which could diverge).
     total_tokens: int = 0
+    # #647: provider time of the last accepted accounting event. The caller
+    # seeds this from the retained row immediately before a delta cursor, and
+    # the iterator advances it on every accepted accounting record. A lower
+    # cumulative can start a new producer generation only when its timestamp
+    # advances this independent chronological watermark; copied or
+    # out-of-order history at a new byte offset therefore cannot lower the
+    # cumulative watermark and make the copied suffix count twice.
+    last_accounting_timestamp: dt.datetime | None = None
+    # A provider lifecycle record (turn_context/task_started) observed since
+    # the last accepted accounting row. Token-count re-emissions cannot set
+    # this bit themselves, so it is the producer-transition evidence required
+    # before a restart-shaped lower cumulative may replace the watermark.
+    generation_transition_pending: bool = False
     # #279 S2 F1 parse-health counters — per-iterator-call; sync_codex_cache
     # folds them into CodexIngestStats after each file drains. Reason
     # vocabulary: info-non-dict / no-last-token-usage / bad-timestamp /
@@ -869,6 +882,57 @@ def _reject_nonfinite_json_constant(value: str) -> None:
     raise ValueError(f"non-finite JSON constant: {value}")
 
 
+def _codex_generation_transition_between(
+    path_str: str, after_offset: int, before_offset: int,
+) -> bool:
+    """Return whether a producer lifecycle boundary exists in this byte gap.
+
+    ``after_offset`` is the physical row of the last retained accounting
+    event, so that row is skipped. ``before_offset`` is a durable resume cursor
+    and is never consumed. This reconstructs the one bit of parser state a
+    metadata-only or budgeted pass can leave between the last accounting row
+    and the next token event without adding another cache schema column.
+    Malformed or unreadable evidence fails closed.
+    """
+    if after_offset < 0 or before_offset <= after_offset:
+        return False
+    try:
+        with open(path_str, "rb") as fh:
+            fh.seek(after_offset)
+            fh.readline()  # skip the retained accounting record itself
+            while fh.tell() < before_offset:
+                line_offset = fh.tell()
+                line = fh.readline()
+                if not line or not line.endswith(b"\n"):
+                    return False
+                if fh.tell() > before_offset:
+                    return False
+                try:
+                    obj = json.loads(
+                        line.decode("utf-8"),
+                        parse_constant=_reject_nonfinite_json_constant,
+                    )
+                except (UnicodeDecodeError, json.JSONDecodeError, ValueError, TypeError):
+                    continue
+                if not isinstance(obj, dict) or not _json_value_is_finite(obj):
+                    continue
+                payload = (
+                    obj.get("payload")
+                    if isinstance(obj.get("payload"), dict)
+                    else {}
+                )
+                if obj.get("type") == "turn_context" or (
+                    obj.get("type") == "event_msg"
+                    and payload.get("type") == "task_started"
+                ):
+                    return True
+                if fh.tell() <= line_offset:  # defensive progress invariant
+                    return False
+    except OSError:
+        return False
+    return False
+
+
 def _seed_codex_iter_state(
     state: _CodexIterState, initial_session_id: str | None,
     initial_model: str | None, initial_total_tokens: int,
@@ -934,6 +998,11 @@ def _accounting_from_record(
             and state.thread.parent_thread_id is not None):
         return None, last_total_tokens, filename_session_id_warned
 
+    timestamp = _parse_codex_timestamp(obj.get("timestamp"))
+    if timestamp is None:
+        _codex_skip(state, "bad-timestamp")
+        return None, last_total_tokens, filename_session_id_warned
+
     total_token_usage = info.get("total_token_usage")
     if isinstance(total_token_usage, dict):
         try:
@@ -941,14 +1010,33 @@ def _accounting_from_record(
         except (TypeError, ValueError):
             cumulative = 0
         if cumulative <= last_total_tokens:
-            return None, last_total_tokens, filename_session_id_warned
+            # A continued Codex producer can append to the same rollout while
+            # restarting its cumulative counter at zero.  The first record of
+            # that new generation is self-originating: its cumulative total is
+            # exactly the complete provider-native last-turn total. A distinct
+            # producer lifecycle record must have occurred since the last
+            # accepted accounting row, and this event must also advance the
+            # retained maximum timestamp. Token-count re-emissions cannot
+            # manufacture the lifecycle evidence, even when they carry fresh
+            # timestamps. Equal totals remain duplicates, and arbitrary or
+            # non-monotonic lower totals remain noise.
+            try:
+                last_usage_total = int(last_token_usage.get("total_tokens") or 0)
+            except (TypeError, ValueError):
+                last_usage_total = 0
+            starts_generation = (
+                state.generation_transition_pending
+                and cumulative < last_total_tokens
+                and cumulative > 0
+                and cumulative == last_usage_total
+                and state.last_accounting_timestamp is not None
+                and timestamp > state.last_accounting_timestamp
+            )
+            if not starts_generation:
+                return None, last_total_tokens, filename_session_id_warned
     else:
         cumulative = None
 
-    timestamp = _parse_codex_timestamp(obj.get("timestamp"))
-    if timestamp is None:
-        _codex_skip(state, "bad-timestamp")
-        return None, last_total_tokens, filename_session_id_warned
     session_id = state.session_id
     if session_id is None:
         session_id = filename_uuid
@@ -982,6 +1070,12 @@ def _accounting_from_record(
     if cumulative is not None:
         state.total_tokens = cumulative
         last_total_tokens = cumulative
+    if (
+        state.last_accounting_timestamp is None
+        or timestamp > state.last_accounting_timestamp
+    ):
+        state.last_accounting_timestamp = timestamp
+    state.generation_transition_pending = False
     return entry, last_total_tokens, filename_session_id_warned
 
 
@@ -1076,6 +1170,9 @@ def _iter_codex_fused_records_with_offsets(
             model = _codex_string(payload.get("model"))
             if model is not None:
                 state.model = model.strip()
+            state.generation_transition_pending = True
+        elif obj.get("type") == "event_msg" and payload.get("type") == "task_started":
+            state.generation_transition_pending = True
 
         event = _event_from_record(
             obj, path_str, line_offset, source_root_key, state.thread

package/bin/_lib_pricing.py

@@ -53,7 +53,7 @@ def _chip_for_model(name: str) -> str:
 # Date the embedded pricing snapshots below were last verified against
 # vendor sources. Bump whenever CLAUDE_MODEL_PRICING / CODEX_MODEL_PRICING
 # is synced. Read by `pricing-check` + the release pre-flight staleness nudge.
-PRICING_SNAPSHOT_DATE = "2026-08-13"
+PRICING_SNAPSHOT_DATE = "2026-08-25"
 PRICING_STALENESS_DAYS = 60  # release pre-flight WARNs past this age
 
 # Canonical machine-readable pricing source (Claude values + Codex values).
@@ -73,6 +73,22 @@ LITELLM_PRICES_URL = (
 # currently mirrors successor Mythos 5's lower $10/$50 rate onto the Preview
 # identifier. Retained Preview rows therefore keep the explicit historical
 # rate rather than being rewritten to the successor's rate.
+#
+# gpt-5.6-sol (#643): OpenAI's pricing page states that "GPT-5.6 Sol's
+# promotional pricing is available at least through November 21, 2026" and
+# publishes no post-promotional price, so LiteLLM's $4/$20 per MTok rate is
+# time-boxed. This table is date-blind and roughly half the retained Sol rows
+# predate the promotion, so the pre-promotional $5/$30 card is kept and the
+# promotion is suppressed here. `expires` is what stops the divergence
+# ossifying: `stale_allowlist_entries` only fires if LiteLLM reverts, so a
+# promotion made permanent would otherwise never surface.
+#
+# gpt-5.6 (#643): a model-only entry, which suppresses `missing_from_us` rather
+# than a value drift. OpenAI lists `gpt-5.6` as an alias of `gpt-5.6-sol`, so
+# CODEX_MODEL_ALIASES resolves it instead of duplicating the rate card.
+# `diff_pricing` keys on raw table membership and is deliberately NOT
+# alias-aware, so the omission needs this entry. It is self-policing: it goes
+# stale automatically if upstream drops `gpt-5.6` or we restore a direct card.
 PRICING_DRIFT_ALLOWLIST: list[dict] = [
     {
         "model": "claude-mythos-preview",
@@ -90,6 +106,39 @@ PRICING_DRIFT_ALLOWLIST: list[dict] = [
         "cache_creation_input_token_cost",
         "cache_read_input_token_cost",
     )
+] + [
+    {
+        "model": "gpt-5.6-sol",
+        "field": field,
+        "expires": "2026-11-21",
+        "reason": (
+            "OpenAI's pricing page guarantees GPT-5.6 Sol's promotional "
+            "$4/$20 per MTok rate only 'at least through November 21, 2026' "
+            "and publishes no post-promotional price. This table is "
+            "date-blind, so the pre-promotional $5/$30 card is kept rather "
+            "than adopting a rate that would have to be reverted by hand "
+            "when the promotion ends (#643)."
+        ),
+    }
+    for field in (
+        "input_cost_per_token",
+        "cache_read_input_token_cost",
+        "output_cost_per_token",
+        "input_cost_per_token_above_272k_tokens",
+        "cache_read_input_token_cost_above_272k_tokens",
+        "output_cost_per_token_above_272k_tokens",
+    )
+] + [
+    {
+        "model": "gpt-5.6",
+        "reason": (
+            "OpenAI lists gpt-5.6 as an alias of gpt-5.6-sol, so "
+            "CODEX_MODEL_ALIASES resolves it to Sol's card and this table "
+            "carries no duplicate entry. `diff_pricing` is deliberately not "
+            "alias-aware, so the intentional omission is suppressed here "
+            "(#643)."
+        ),
+    },
 ]
 
 # Anthropic API pricing snapshot:
@@ -398,10 +447,11 @@ _unknown_model_warnings: set[str] = set()
 # Codex (OpenAI) API pricing snapshot:
 # - Source: https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json
 # - Captured: 2026-07-19 — the last FULL Codex sync. PRICING_SNAPSHOT_DATE has
-#   since moved for three targeted syncs (2026-07-24, the Claude-side opus-5
-#   sync; 2026-07-31, the gpt-5.6-terra/-luna correction logged below; and
-#   2026-08-13, the Claude-side Sonnet/Mythos sync above). Codex values outside
-#   the one Codex correction were NOT re-verified on those days.
+#   since moved for four targeted syncs (2026-07-24, the Claude-side opus-5
+#   sync; 2026-07-31, the gpt-5.6-terra/-luna correction logged below;
+#   2026-08-13, the Claude-side Sonnet/Mythos sync above; and 2026-08-25, the
+#   gpt-5.6-cyber addition logged below). Codex values outside those two Codex
+#   corrections were NOT re-verified on those days.
 # - As of the 2026-07-19 sync this carries every openai-provider
 #   gpt-5* model the LiteLLM snapshot lists, so `pricing-check`'s scope finds
 #   nothing missing. Models absent from this table still fall back to `gpt-5`
@@ -425,6 +475,21 @@ _unknown_model_warnings: set[str] = set()
 #   the vendor lists these as standard ongoing prices with no promotional or
 #   expiring annotation, so the durable rate is the cut rate. gpt-5.6 and
 #   gpt-5.6-sol were not repriced and are unchanged.
+#   2026-08-25 (#643): added gpt-5.6-cyber at OpenAI's published $12.50 input /
+#   $1.25 cached input / $75.00 output per MTok, with LiteLLM's above-272k tier
+#   ($25.00 / $2.50 / $112.50 per MTok). The vendor page shows dashes in the
+#   long-context columns, but max_input_tokens is 400,000, so a turn above the
+#   272,000 threshold is reachable and pricing it at the base rate would be
+#   knowingly wrong; LiteLLM's tier ratios match every other gpt-5.6 member.
+#   Removed the duplicated gpt-5.6 card and aliased that identifier to
+#   gpt-5.6-sol, which OpenAI lists it as an alias of. gpt-5.6-sol's own values
+#   are UNCHANGED: LiteLLM now carries OpenAI's promotional $4/$20 per MTok
+#   rate, which the vendor guarantees only "at least through November 21, 2026"
+#   and publishes no successor for. That promotion is suppressed in
+#   PRICING_DRIFT_ALLOWLIST with expires 2026-11-21 instead of being written
+#   into this date-blind table, because roughly half the retained Sol rows
+#   predate it. The accepted cost is that while the promotion runs, Sol
+#   reporting is high by 25% on input and 50% on output.
 #
 # Billing rules:
 # - reasoning_output_tokens is billed at the *output* rate (matches
@@ -518,19 +583,15 @@ CODEX_MODEL_PRICING: dict[str, dict[str, Any]] = {
         "output_cost_per_token_above_272k_tokens": 4.5e-05,
     },
     # ── gpt-5.6 family (LiteLLM openai-provider entries) ──
-    # Exact model_prices_and_context_window.json values; each carries the
-    # above-272k tier (max_input_tokens 1050000). gpt-5.6 and gpt-5.6-sol keep
-    # gpt-5.5's rate card from the 2026-07-10 sync; -terra and -luna carry
-    # OpenAI's 2026-07-30 post-cut rates (#441) and no longer track gpt-5.4's
-    # card or any other model's.
-    "gpt-5.6": {
-        "input_cost_per_token": 5e-06,
-        "cache_read_input_token_cost": 5e-07,
-        "output_cost_per_token": 3e-05,
-        "input_cost_per_token_above_272k_tokens": 1e-05,
-        "cache_read_input_token_cost_above_272k_tokens": 1e-06,
-        "output_cost_per_token_above_272k_tokens": 4.5e-05,
-    },
+    # Every member carries the above-272k tier, but the context windows differ:
+    # -sol, -terra and -luna are max_input_tokens 922,000 and -cyber is 400,000.
+    # gpt-5.6-sol keeps gpt-5.5's rate card from the 2026-07-10 sync and is
+    # deliberately HELD there while OpenAI's promotion runs — see the
+    # gpt-5.6-sol block in PRICING_DRIFT_ALLOWLIST (#643). -terra and -luna
+    # carry OpenAI's 2026-07-30 post-cut rates (#441) and no longer track
+    # gpt-5.4's card or any other model's. -cyber carries its own launch rates.
+    # The bare `gpt-5.6` identifier is OpenAI's alias of -sol and has NO card
+    # here; CODEX_MODEL_ALIASES resolves it.
     "gpt-5.6-sol": {
         "input_cost_per_token": 5e-06,
         "cache_read_input_token_cost": 5e-07,
@@ -555,6 +616,16 @@ CODEX_MODEL_PRICING: dict[str, dict[str, Any]] = {
         "cache_read_input_token_cost_above_272k_tokens": 4e-08,
         "output_cost_per_token_above_272k_tokens": 1.8e-06,
     },
+    # No cache_creation field: the Codex cost kernel never reads one, so
+    # carrying LiteLLM's would only give `diff_pricing` a value to compare.
+    "gpt-5.6-cyber": {
+        "input_cost_per_token": 1.25e-05,
+        "cache_read_input_token_cost": 1.25e-06,
+        "output_cost_per_token": 7.5e-05,
+        "input_cost_per_token_above_272k_tokens": 2.5e-05,
+        "cache_read_input_token_cost_above_272k_tokens": 2.5e-06,
+        "output_cost_per_token_above_272k_tokens": 1.125e-04,
+    },
     # ── Issue #123: full gpt-5.x LiteLLM sync (2026-05-30 snapshot) ──
     # Exact model_prices_and_context_window.json values for every
     # openai-provider gpt-5* model `pricing-check`'s scope flags but the
@@ -740,11 +811,16 @@ CODEX_LEGACY_FALLBACK_MODEL = "gpt-5"
 # drift retains one source of truth per card. OpenAI's live pricing page states
 # that ``daybreak-blue-latest`` currently points to ``gpt-5.6-sol`` and inherits
 # the underlying model's pricing; Codex emits the prefixed runtime identifier
-# retained below. ``codex-auto-review`` is the hidden Guardian model and maps to
-# the model current when it appeared, covering every retained event observed
-# for issue #535.
+# retained below. OpenAI's models page lists the bare ``gpt-5.6`` identifier as
+# an alias of ``gpt-5.6-sol`` too, so it resolves here rather than duplicating
+# Sol's rates (#643) — its intentional absence from CODEX_MODEL_PRICING is
+# covered by a model-only PRICING_DRIFT_ALLOWLIST entry.
+# ``codex-auto-review`` is the hidden Guardian model and maps to the model
+# current when it appeared, covering every retained event observed for issue
+# #535.
 CODEX_MODEL_ALIASES: dict[str, str] = {
     "codex-auto-review": "gpt-5.5",
+    "gpt-5.6": "gpt-5.6-sol",
     "gpt-daybreak-blue-latest": "gpt-5.6-sol",
 }
 

package/package.json

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