cctally 1.82.0 → 1.83.0

package/bin/_lib_rederive.py

@@ -0,0 +1,395 @@
+"""Pure correction-plan kernel for journal rederivation.
+
+Task B of #372 deliberately separates two responsibilities:
+
+* eager code replays retained truth through the current derivation hooks in a
+  scratch index and produces the desired effective events; and
+* this module compares those events with Task A's ``EffectiveSelection`` and
+  renders a deterministic, auditable correction plan.
+
+No filesystem, SQLite, provider, alert, or journal operation belongs here.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import hashlib
+import json
+from collections.abc import Iterable, Mapping
+
+
+FAMILY = "claude-usage"
+
+
+class RederiveError(RuntimeError):
+    """Base error for a plan that cannot be produced truthfully."""
+
+
+class RederiveDataGap(RederiveError):
+    """Required retained source data is absent or too old for current logic."""
+
+
+class RederiveConflict(RederiveError):
+    """The desired event set is internally inconsistent."""
+
+
+@dataclasses.dataclass(frozen=True)
+class KindClassification:
+    mode: str
+    reason: str
+
+
+_EVT_CLASSIFICATIONS = {
+    "snapshot_accept": KindClassification(
+        "rederived", "accepted Claude usage observation"),
+    "weekly_cost_snapshot": KindClassification(
+        "rederived", "as-of-bounded Claude cache cost"),
+    "weekly_credit_effects": KindClassification(
+        "rederived", "record-credit destructive effects"),
+    "week_reset": KindClassification(
+        "rederived", "Claude weekly reset or credit decision"),
+    "five_hour_credit": KindClassification(
+        "rederived", "Claude five-hour credit decision"),
+    "five_hour_block_close": KindClassification(
+        "rederived", "closed Claude five-hour projection"),
+    "percent_milestone": KindClassification(
+        "rederived", "dependent Claude weekly milestone"),
+    "five_hour_milestone": KindClassification(
+        "rederived", "dependent Claude five-hour milestone"),
+    "budget": KindClassification(
+        "re_materialized_projection",
+        "historical budget config is not journaled; stale Claude latches retire"),
+    "projected": KindClassification(
+        "re_materialized_projection",
+        "historical alert config is not journaled; stale Claude latches retire"),
+    "project_budget": KindClassification(
+        "re_materialized_projection",
+        "historical project budgets are not journaled; stale latches retire"),
+    "quota_alert_arming": KindClassification(
+        "retained", "Codex quota lifecycle state is outside claude-usage"),
+}
+
+_OP_CLASSIFICATIONS = {
+    "weekly_credit_floor": KindClassification(
+        "retained_input", "operator credit truth is replayed into scratch"),
+    "account_observe": KindClassification(
+        "retained_input", "account ownership truth is replayed into scratch"),
+    "account_label": KindClassification(
+        "retained_input", "operator account labels are replayed into scratch"),
+    "accounts_cutover": KindClassification(
+        "retained_input",
+        "legacy Claude ownership normalizes unstamped journal history"),
+    "sync_week": KindClassification(
+        "retained_input", "operator cost-sync request is re-executed in scratch"),
+}
+
+
+def _is_owned_event(record: Mapping) -> bool:
+    payload = record.get("payload") or {}
+    kind = payload.get("kind")
+    classification = _EVT_CLASSIFICATIONS.get(kind)
+    if classification is None or classification.mode not in {
+        "rederived", "re_materialized_projection",
+    }:
+        return False
+    if kind == "budget":
+        return payload.get("vendor", "claude") == "claude"
+    if kind == "projected":
+        metric = str(payload.get("metric") or "")
+        return not metric.startswith("codex_")
+    return True
+
+
+@dataclasses.dataclass(frozen=True)
+class FamilyRegistryReport:
+    family: str
+    evt: Mapping[str, KindClassification]
+    op: Mapping[str, KindClassification]
+    unclassified_evt_kinds: tuple[str, ...]
+    unclassified_op_kinds: tuple[str, ...]
+
+    def classification_for_evt(self, kind: str) -> KindClassification:
+        return self.evt[kind]
+
+    def classification_for_op(self, kind: str) -> KindClassification:
+        return self.op[kind]
+
+
+def validate_family_registry(*, evt_kinds: set[str],
+                             op_kinds: set[str]) -> FamilyRegistryReport:
+    """Return the closure table and expose any newly-added unclassified kind."""
+    return FamilyRegistryReport(
+        family=FAMILY,
+        evt=dict(_EVT_CLASSIFICATIONS),
+        op=dict(_OP_CLASSIFICATIONS),
+        unclassified_evt_kinds=tuple(sorted(evt_kinds - _EVT_CLASSIFICATIONS.keys())),
+        unclassified_op_kinds=tuple(sorted(op_kinds - _OP_CLASSIFICATIONS.keys())),
+    )
+
+
+_SESSION_ENTRY_COLUMNS = frozenset({
+    "timestamp_utc",
+    "model",
+    "input_tokens",
+    "output_tokens",
+    "cache_create_tokens",
+    "cache_read_tokens",
+    "cache_create_1h_tokens",
+    "source_path",
+    "account_key",
+})
+_SESSION_FILE_COLUMNS = frozenset({"path", "session_id", "project_path"})
+
+
+def validate_claude_cache_contract(tables: Mapping[str, set[str]]) -> None:
+    """Fail before planning if current Claude cost inputs are not retained."""
+    if "session_entries" not in tables:
+        raise RederiveDataGap("missing cache.db table session_entries")
+    missing_entries = sorted(
+        _SESSION_ENTRY_COLUMNS - set(tables["session_entries"]))
+    if missing_entries:
+        raise RederiveDataGap(
+            "missing cache.db session_entries column(s): "
+            + ", ".join(missing_entries)
+        )
+    if "session_files" not in tables:
+        raise RederiveDataGap("missing cache.db table session_files")
+    missing_files = sorted(_SESSION_FILE_COLUMNS - set(tables["session_files"]))
+    if missing_files:
+        raise RederiveDataGap(
+            "missing cache.db session_files column(s): " + ", ".join(missing_files)
+        )
+
+
+def _canonical_bytes(value) -> bytes:
+    return json.dumps(
+        value, sort_keys=True, separators=(",", ":"), ensure_ascii=False,
+    ).encode("utf-8")
+
+
+def _sha256(value) -> str:
+    return "sha256:" + hashlib.sha256(_canonical_bytes(value)).hexdigest()
+
+
+def _semantic_event(record: Mapping) -> dict:
+    return {
+        "id": record.get("id"),
+        "at": record.get("at"),
+        "payload": record.get("payload") or {},
+    }
+
+
+def _preserve_non_derivable_state(
+    current_record: Mapping, desired_record: Mapping
+) -> Mapping:
+    """Carry durable state that scratch replay cannot truthfully reconstruct.
+
+    Percent-milestone ``alerted_at`` is the latch recorded when the first
+    crossing actually dispatched. Historical alert configuration is not
+    retained, so scratch replay deliberately runs with alerts disabled and
+    produces ``None``. Preserve the selected event's exact latch both when the
+    rest of the milestone is retained and when another field needs an audited
+    higher-revision correction (#410 Task B).
+    """
+    current_payload = current_record.get("payload") or {}
+    desired_payload = desired_record.get("payload") or {}
+    if (
+        current_payload.get("kind") != "percent_milestone"
+        or desired_payload.get("kind") != "percent_milestone"
+        or "alerted_at" not in current_payload
+    ):
+        return desired_record
+    merged = dict(desired_record)
+    merged_payload = dict(desired_payload)
+    merged_payload["alerted_at"] = current_payload["alerted_at"]
+    merged["payload"] = merged_payload
+    return merged
+
+
+@dataclasses.dataclass(frozen=True)
+class PlanAction:
+    disposition: str
+    event_id: str
+    revision: int
+    at: str
+    payload: "dict | None"
+    payload_hash: str
+
+    def to_dict(self) -> dict:
+        out = {
+            "disposition": self.disposition,
+            "eventId": self.event_id,
+            "revision": self.revision,
+            "at": self.at,
+            "payloadHash": self.payload_hash,
+        }
+        if self.payload is not None:
+            out["payload"] = self.payload
+        return out
+
+    def to_correction_action(self) -> dict:
+        if self.disposition == "tombstone":
+            return {
+                "action": "tombstone",
+                "id": self.event_id,
+                "rev": self.revision,
+                "at": self.at,
+                "payload": None,
+            }
+        return {
+            "action": "replace",
+            "id": self.event_id,
+            "rev": self.revision,
+            "at": self.at,
+            "payload": dict(self.payload or {}),
+        }
+
+
+@dataclasses.dataclass(frozen=True)
+class RederivePlan:
+    family: str
+    journal_high_water: "tuple[str, int] | None"
+    cache_fingerprint: str
+    config_fingerprint: str
+    counts: Mapping[str, int]
+    actions: tuple[PlanAction, ...]
+    retained_event_count: int
+
+    def _body(self) -> dict:
+        return {
+            "schemaVersion": 1,
+            "family": self.family,
+            "journalHighWater": (
+                None if self.journal_high_water is None else {
+                    "segment": self.journal_high_water[0],
+                    "offset": self.journal_high_water[1],
+                }
+            ),
+            "cacheFingerprint": self.cache_fingerprint,
+            "configFingerprint": self.config_fingerprint,
+            "counts": dict(self.counts),
+            "retainedEventCount": self.retained_event_count,
+            "payloadHashes": sorted(action.payload_hash for action in self.actions),
+            "actions": [action.to_dict() for action in self.actions],
+        }
+
+    @property
+    def plan_hash(self) -> str:
+        return _sha256(self._body())
+
+    def to_bytes(self) -> bytes:
+        body = self._body()
+        body["planHash"] = self.plan_hash
+        return _canonical_bytes(body)
+
+    def to_correction_actions(self) -> list[dict]:
+        return [action.to_correction_action() for action in self.actions]
+
+
+def _desired_by_id(events: Iterable[Mapping]) -> dict[str, Mapping]:
+    desired = {}
+    for event in events:
+        event_id = event.get("id")
+        if not isinstance(event_id, str) or not event_id:
+            raise RederiveConflict("desired event is missing a non-empty id")
+        if not _is_owned_event(event):
+            continue
+        prior = desired.get(event_id)
+        if prior is not None and _semantic_event(prior) != _semantic_event(event):
+            raise RederiveConflict(f"divergent desired event id {event_id}")
+        desired[event_id] = event
+    return desired
+
+
+def build_claude_usage_plan(*, selection, desired_events: Iterable[Mapping],
+                            journal_high_water: "tuple[str, int] | None",
+                            cache_fingerprint: str,
+                            config_fingerprint: str,
+                            conflicted_event_ids=frozenset()) -> RederivePlan:
+    """Diff current effective events against one scratch-derived desired set.
+
+    ``conflicted_event_ids`` (#374) names the event ids this family owns whose
+    same-revision group the selector QUARANTINED at the winning revision. They
+    force a ``supersede`` at ``selected.rev + 1`` **even when the provisional
+    winner already equals the desired state** — without that, the equality
+    branch below returns ``retain`` and the rev-0 conflict survives in the
+    append-only journal forever, which is precisely the case the first design
+    called already-correct. The resulting correction is a semantic no-op in
+    content and a revision advance in effect, and the revision advance is what
+    suppresses the rev-0 group under the selector's revision filter."""
+    conflicted_event_ids = frozenset(conflicted_event_ids or ())
+    desired = _desired_by_id(desired_events)
+    current = {
+        event_id: selected.record
+        for event_id, selected in selection.by_id.items()
+        if selected.status == "active"
+        and selected.record is not None
+        and _is_owned_event(selected.record)
+    }
+    retained_event_count = sum(
+        1 for selected in selection.by_id.values()
+        if selected.status == "active"
+        and selected.record is not None
+        and not _is_owned_event(selected.record)
+    )
+    counts = {"retain": 0, "supersede": 0, "tombstone": 0, "add": 0}
+    actions: list[PlanAction] = []
+
+    for event_id in sorted(set(current) | set(desired)):
+        current_record = current.get(event_id)
+        desired_record = desired.get(event_id)
+        selected = selection.by_id.get(event_id)
+        if current_record is not None and desired_record is not None:
+            desired_record = _preserve_non_derivable_state(
+                current_record, desired_record
+            )
+            if (
+                _semantic_event(current_record) == _semantic_event(desired_record)
+                and event_id not in conflicted_event_ids
+            ):
+                counts["retain"] += 1
+                continue
+            revision = int(selected.rev) + 1
+            disposition = "supersede"
+            at = str(desired_record["at"])
+            payload = dict(desired_record.get("payload") or {})
+        elif current_record is not None:
+            revision = int(selected.rev) + 1
+            disposition = "tombstone"
+            at = str(current_record["at"])
+            payload = None
+        else:
+            if selected is not None:
+                # A formerly-tombstoned id must advance rather than attempt rev 0.
+                revision = int(selected.rev) + 1
+            else:
+                revision = 0
+            disposition = "add"
+            at = str(desired_record["at"])
+            payload = dict(desired_record.get("payload") or {})
+        counts[disposition] += 1
+        action_shape = {
+            "disposition": disposition,
+            "eventId": event_id,
+            "revision": revision,
+            "at": at,
+            "payload": payload,
+        }
+        actions.append(PlanAction(
+            disposition=disposition,
+            event_id=event_id,
+            revision=revision,
+            at=at,
+            payload=payload,
+            payload_hash=_sha256(action_shape),
+        ))
+
+    return RederivePlan(
+        family=FAMILY,
+        journal_high_water=journal_high_water,
+        cache_fingerprint=cache_fingerprint,
+        config_fingerprint=config_fingerprint,
+        counts=counts,
+        actions=tuple(actions),
+        retained_event_count=retained_event_count,
+    )

package/bin/_lib_share.py

@@ -1160,6 +1160,9 @@ _SVG_TABLE_MIN_COL_W = 24
 _SVG_AVG_GLYPH_WIDTH_FRACTION = 0.6
 _SVG_WRAP_BREAK_CHARS = (" ", "/", "-", "_")
 _SVG_ELLIPSIS = "…"
+_SVG_NOTE_FONT = 11
+_SVG_NOTE_LINE_H = 16
+_SVG_NOTE_GAP = 14
 
 
 def _svg_text_width(text: str, font_size: float) -> float:
@@ -1236,6 +1239,25 @@ def _wrap_for_width(text: str, content_w: float, font_size: float) -> list[str]:
     return lines or [_SVG_ELLIPSIS]
 
 
+def _render_svg_notes(
+    snap: "ShareSnapshot", *, palette: dict, x: float, y: float, width: float,
+) -> tuple[str, float]:
+    """Render deterministic, wrapped artifact notes and return body + height."""
+    lines: list[str] = []
+    for note in snap.notes:
+        lines.extend(_wrap_for_width(note, width, _SVG_NOTE_FONT))
+    if not lines:
+        return "", 0.0
+    body = svg_group([
+        svg_text(
+            x, y + ((idx + 1) * _SVG_NOTE_LINE_H), line,
+            font_size=_SVG_NOTE_FONT, fill=palette["ref_warn"],
+        )
+        for idx, line in enumerate(lines)
+    ])
+    return body, float(len(lines) * _SVG_NOTE_LINE_H)
+
+
 def _svg_table_anchor_and_x(align: str, col_x: float, col_w: float,
                              pad_x: float) -> tuple[str, float]:
     """Map `ColumnSpec.align` to SVG text-anchor + x-coordinate."""
@@ -1429,9 +1451,26 @@ def _render_svg(snap: ShareSnapshot, *, palette: dict,
     content_w = max(_SVG_WIDTH, table_w)
 
     table_block_h = (_SVG_TABLE_GAP + table_h) if has_table else 0
+    note_block_h = 0.0
+    note_svg = ""
+    if include_chrome and snap.notes:
+        note_y = (
+            _SVG_PADDING + header_h + chart_h + table_block_h + _SVG_NOTE_GAP
+        )
+        note_svg, note_h = _render_svg_notes(
+            snap,
+            palette=palette,
+            x=_SVG_PADDING,
+            y=note_y,
+            width=_SVG_WIDTH,
+        )
+        note_block_h = _SVG_NOTE_GAP + note_h
 
     if include_chrome:
-        height = header_h + chart_h + table_block_h + _SVG_FOOTER_H + (_SVG_PADDING * 2)
+        height = (
+            header_h + chart_h + table_block_h + note_block_h
+            + _SVG_FOOTER_H + (_SVG_PADDING * 2)
+        )
     else:
         height = chart_h + table_block_h + (_SVG_PADDING * 2)
 
@@ -1464,8 +1503,14 @@ def _render_svg(snap: ShareSnapshot, *, palette: dict,
     if has_table:
         pieces.append(table_svg)
 
+    if note_svg:
+        pieces.append(note_svg)
+
     if include_chrome:
-        footer_y = _SVG_PADDING + header_h + chart_h + table_block_h + _SVG_FOOTER_BASELINE
+        footer_y = (
+            _SVG_PADDING + header_h + chart_h + table_block_h + note_block_h
+            + _SVG_FOOTER_BASELINE
+        )
         pieces.append(_render_svg_footer(
             snap, palette=palette,
             x=_SVG_PADDING, y=footer_y,
@@ -1581,6 +1626,16 @@ def _render_html_fragment(snap: ShareSnapshot, *, palette: dict, branding: bool)
         f'{_format_generated_at_iso(snap.generated_at)}</div>'
     )
     table_html = _render_html_table(snap, palette) if snap.columns else ""
+    notes_html = (
+        f'<aside aria-label="Data notes" '
+        f'style="margin-top:14px;padding:8px 10px;border-left:3px solid {palette["ref_warn"]};'
+        f'color:{palette["fg"]};font-size:13px">'
+        + "".join(
+            f'<div>{_xml_escape(note)}</div>' for note in snap.notes
+        )
+        + "</aside>"
+        if snap.notes else ""
+    )
     if branding:
         # "Generated by cctally" stays as a single plain-text substring so HTML
         # consumers can grep for the branding marker uniformly with the SVG
@@ -1598,6 +1653,7 @@ def _render_html_fragment(snap: ShareSnapshot, *, palette: dict, branding: bool)
         f'<header>{title_html}{source_html}{availability_html}{subtitle_html}{timestamp_html}</header>'
         f'{chart_html}'
         f'{table_html}'
+        f'{notes_html}'
         f'{footer_html}'
     )
 

package/bin/cctally

@@ -343,6 +343,7 @@ _SEMVER_RE = _lib_semver._SEMVER_RE
 _lib_pricing = _load_sibling("_lib_pricing")
 TIERED_THRESHOLD = _lib_pricing.TIERED_THRESHOLD
 CLAUDE_MODEL_PRICING = _lib_pricing.CLAUDE_MODEL_PRICING
+CLAUDE_FAST_MULTIPLIER_OVERRIDES = _lib_pricing.CLAUDE_FAST_MULTIPLIER_OVERRIDES
 CODEX_TIERED_THRESHOLD = _lib_pricing.CODEX_TIERED_THRESHOLD
 CODEX_MODEL_PRICING = _lib_pricing.CODEX_MODEL_PRICING
 CODEX_LEGACY_FALLBACK_MODEL = _lib_pricing.CODEX_LEGACY_FALLBACK_MODEL
@@ -353,6 +354,11 @@ _resolve_codex_pricing = _lib_pricing._resolve_codex_pricing
 _is_codex_fallback = _lib_pricing._is_codex_fallback
 _resolve_model_pricing = _lib_pricing._resolve_model_pricing
 _calculate_entry_cost = _lib_pricing._calculate_entry_cost
+_claude_fast_multiplier = _lib_pricing._claude_fast_multiplier
+# #195: the single construction point for every cost-feeding usage dict,
+# plus the derived 1-hour cache-write multiplier.
+claude_usage_dict = _lib_pricing.claude_usage_dict
+CACHE_WRITE_1H_MULTIPLIER = _lib_pricing.CACHE_WRITE_1H_MULTIPLIER
 _warn_unknown_codex_model = _lib_pricing._warn_unknown_codex_model
 _calculate_codex_entry_cost = _lib_pricing._calculate_codex_entry_cost
 _codex_fast_multiplier = _lib_pricing._codex_fast_multiplier
@@ -493,6 +499,14 @@ _apply_overlap_clamp_to_subweeks = _lib_subscription_weeks._apply_overlap_clamp_
 _apply_reset_events_to_subweeks = _lib_subscription_weeks._apply_reset_events_to_subweeks
 _compute_subscription_weeks = _lib_subscription_weeks._compute_subscription_weeks
 
+# Codex quota-pool classification (#373).  A pure leaf: stdlib only, no
+# cctally imports, so `_lib_jsonl` can consume it without dragging in the
+# quota kernel.  Loaded BEFORE `_lib_jsonl`, which imports from it.
+_lib_codex_pools = _load_sibling("_lib_codex_pools")
+codex_model_scoped_quota_pool = _lib_codex_pools.codex_model_scoped_quota_pool
+is_model_scoped_codex_quota = _lib_codex_pools.is_model_scoped_codex_quota
+codex_history_is_model_scoped = _lib_codex_pools.codex_history_is_model_scoped
+
 _lib_jsonl = _load_sibling("_lib_jsonl")
 UsageEntry = _lib_jsonl.UsageEntry
 CodexEntry = _lib_jsonl.CodexEntry
@@ -969,6 +983,9 @@ _run_pending_migrations = _cctally_db._run_pending_migrations
 _recover_version_ahead = _cctally_db._recover_version_ahead
 _log_migration_error = _cctally_db._log_migration_error
 _clear_migration_error_log_entries = _cctally_db._clear_migration_error_log_entries
+_reconcile_durable_applied_migration_errors = (
+    _cctally_db._reconcile_durable_applied_migration_errors
+)
 _render_migration_error_banner = _cctally_db._render_migration_error_banner
 _BANNER_SUPPRESSED_COMMANDS = _cctally_db._BANNER_SUPPRESSED_COMMANDS
 _print_migration_error_banner_if_needed = _cctally_db._print_migration_error_banner_if_needed
@@ -1115,6 +1132,20 @@ _derive_week_from_payload = _cctally_record._derive_week_from_payload
 insert_usage_snapshot = _cctally_record.insert_usage_snapshot
 _saved_dict_from_usage_row = _cctally_record._saved_dict_from_usage_row
 
+# #372 Task B: side-effect-free Claude usage rederive planner. Loaded after the
+# record sibling so its scratch adapter can reuse the registered ingest hooks.
+_lib_rederive = _load_sibling("_lib_rederive")
+_cctally_rederive = _load_sibling("_cctally_rederive")
+plan_claude_usage_rederive = _cctally_rederive.plan_claude_usage
+read_rederive_journal_prefix = _cctally_rederive.read_rederive_journal_prefix
+preview_db_rederive = _cctally_rederive.preview_db_rederive
+apply_db_rederive = _cctally_rederive.apply_db_rederive
+cmd_db_rederive = _cctally_rederive.cmd_db_rederive
+
+# #402 Task B: preview-first append-only structural protocol acknowledgement.
+_cctally_journal_repair = _load_sibling("_cctally_journal_repair")
+cmd_db_journal_repair = _cctally_journal_repair.cmd_db_journal_repair
+
 # Phase F #21: ``bin/_cctally_update.py`` is loaded eagerly per spec §4.8
 # carve-out — ``tests/test_update.py`` reaches into ~30 symbols via
 # ``ns["X"]`` direct-dict reads and ``monkeypatch.setitem(ns, "X", …)``
@@ -2018,15 +2049,23 @@ def _usage_entry_from_joined(je) -> "UsageEntry":
     drop the fast-tier flag and render ``<model>`` where the normal path
     renders ``<model>-fast``. ``je.usage_extra`` is ``{"speed": …}`` or
     ``None``, so the merge never shadows the token integers.
+
+    #195: the dict is built by ``claude_usage_dict``, NOT by hand. This is a
+    cost-feeding usage dict — ``_fold_entry`` prices from ``entry.usage`` —
+    so a hand-rolled literal here silently drops the cache-write TTL split
+    and under-prices the whole ``daily -i`` / ``daily -p`` branch (and makes
+    ``--debug`` report phantom pricing mismatches). ``getattr`` keeps the
+    adapter tolerant of the duck-typed joined-entry stand-ins that a couple
+    of call sites synthesize.
     """
-    usage = {
-        "input_tokens": je.input_tokens,
-        "output_tokens": je.output_tokens,
-        "cache_creation_input_tokens": je.cache_creation_tokens,
-        "cache_read_input_tokens": je.cache_read_tokens,
-    }
-    if je.usage_extra:
-        usage.update(je.usage_extra)
+    usage = claude_usage_dict(   # #195 chokepoint
+        input_tokens=je.input_tokens,
+        output_tokens=je.output_tokens,
+        cache_creation_tokens=je.cache_creation_tokens,
+        cache_read_tokens=je.cache_read_tokens,
+        cache_1h_tokens=getattr(je, "cache_1h_tokens", None),
+        speed=getattr(je, "speed", None),
+    )
     return UsageEntry(
         timestamp=je.timestamp,
         model=je.model,
@@ -3401,6 +3440,15 @@ def _post_command_update_hooks(command: str | None, args) -> None:
         # no-mutation contract (test_pricing_check_offline_does_not_mutate_
         # fresh_home) requires skipping the whole hook.
         return
+    if (
+        command == "db"
+        and getattr(args, "db_action", None) == "journal-repair"
+    ):
+        # `db journal-repair` preview has the same literal no-mutation contract
+        # as doctor/pricing-check. In particular, do not create config/update/
+        # telemetry state after the preview handler has proved the journal
+        # prefix without writing.
+        return
     if command == "repair-symlinks":
         return
     if command == "__preview":