cctally 1.100.0 → 1.102.0

package/bin/_cctally_record.py

@@ -173,8 +173,8 @@ import re
 import sqlite3
 import sys
 import time
-from dataclasses import dataclass
-from typing import Any
+from dataclasses import dataclass, field
+from typing import Any, Iterable
 
 
 def _cctally():
@@ -902,8 +902,13 @@ def maybe_record_milestone(
                     # Filter by reset_event_id so a credited week's
                     # alert payload reads the post-credit row, not a
                     # stale pre-credit row at the same (week, threshold).
+                    # `week_start_at` comes from the row rather than the
+                    # local variable for the same reason `cumulative_cost_usd`
+                    # does: it is the value persisted on insert, so the alert
+                    # states the week the milestone actually recorded.
                     row = conn.execute(
-                        "SELECT cumulative_cost_usd FROM percent_milestones "
+                        "SELECT cumulative_cost_usd, week_start_at "
+                        "FROM percent_milestones "
                         "WHERE week_start_date = ? AND percent_threshold = ? "
                         "  AND reset_event_id = ? AND account_key = ?",
                         (week_start_date, pct, reset_event_id, account_key),
@@ -916,6 +921,7 @@ def maybe_record_milestone(
                             threshold=pct,
                             crossed_at_utc=crossed_at,
                             week_start_date=week_start_date,
+                            week_start_at=row["week_start_at"],
                             cumulative_cost_usd=cum,
                             dollars_per_percent=dpp,
                             account_key=account_key,
@@ -1503,11 +1509,12 @@ def _weekly_pct_week_avg_projection(conn, now_utc):
     binds the fired value to forecast's ``week_avg_projection_pct`` within
     1e-9, so the two MUST share the formula by construction.
 
-    LOW CONF mirrors the displayed forecast confidence: the binary
-    ``_assess_forecast_confidence(elapsed_hours, p_now, len(samples))`` plus the
-    ``no_sample_ge_24h`` clause ``_load_forecast_inputs`` appends — so a thin
-    early-week window that forecast renders ``LOW CONF`` never fires a
-    projected alert.
+    LOW CONF mirrors the displayed forecast confidence: ONE call to
+    ``_assess_forecast_confidence(elapsed_hours, p_now, len(samples),
+    has_sample_ge_24h=…)``, whose fourth trigger ``no_sample_ge_24h`` moved
+    inside the predicate with #620 S2 E3 — so a thin early-week window that
+    forecast renders ``LOW CONF`` never fires a projected alert, and glue no
+    longer appends a reason of its own.
 
     Deliberately does NOT call ``_sum_cost_for_range`` (the weekly-% projection
     needs no spend; the forecast kernel's ``week_avg_projection_pct`` is also
@@ -1528,15 +1535,14 @@ def _weekly_pct_week_avg_projection(conn, now_utc):
     r_avg = p_now / elapsed_hours if elapsed_hours > 0 else 0.0
     projected_pct = p_now + r_avg * remaining_hours
 
-    # Confidence: same predicate + the same no_sample_ge_24h augmentation that
-    # _load_forecast_inputs applies, so this LOW CONF gate == forecast's.
+    # Confidence comes from the predicate in one call, fourth trigger
+    # included, so this LOW CONF gate == forecast's and glue no longer
+    # downgrades a confidence the predicate returned (#620 S2 E3).
+    target_24h = now_utc - dt.timedelta(hours=24)
     confidence, _reasons = _assess_forecast_confidence(
-        elapsed_hours, p_now, len(samples)
+        elapsed_hours, p_now, len(samples),
+        has_sample_ge_24h=any(s[0] <= target_24h for s in samples),
     )
-    target_24h = now_utc - dt.timedelta(hours=24)
-    has_sample_ge_24h = any(s[0] <= target_24h for s in samples)
-    if not has_sample_ge_24h:
-        confidence = "low"
     return (projected_pct, confidence == "low")
 
 
@@ -1876,6 +1882,112 @@ def maybe_record_projected_alert(
                 eprint(f"[projected-alert] payload build failed: {build_exc}")
 
 
+@dataclass
+class PricedEntry:
+    """One accounting entry after pricing, as the block fold consumes it.
+
+    The canonical priced record: the fields `fold_block_totals` reads and
+    nothing else. `_compute_block_totals` builds these from
+    `_JoinedClaudeEntry` rows it has already priced; the diagnosis
+    (#620 S2) builds them from its own half-open account-scoped window.
+    """
+    model: str
+    project_path: str | None
+    input_tokens: int
+    output_tokens: int
+    cache_creation_tokens: int
+    cache_read_tokens: int
+    cost_usd: float
+
+
+@dataclass
+class BlockBucket:
+    """One model or project bucket inside a block's totals."""
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_create_tokens: int = 0
+    cache_read_tokens: int = 0
+    cost_usd: float = 0.0
+    entry_count: int = 0
+
+    def as_legacy_dict(self) -> dict[str, Any]:
+        return {
+            "input_tokens": self.input_tokens,
+            "output_tokens": self.output_tokens,
+            "cache_create_tokens": self.cache_create_tokens,
+            "cache_read_tokens": self.cache_read_tokens,
+            "cost_usd": self.cost_usd,
+            "entry_count": self.entry_count,
+        }
+
+
+@dataclass
+class BlockTotals:
+    """The summed result of `fold_block_totals`."""
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_create_tokens: int = 0
+    cache_read_tokens: int = 0
+    cost_usd: float = 0.0
+    entry_count: int = 0
+    by_model: dict[str, BlockBucket] = field(default_factory=dict)
+    by_project: dict[str, BlockBucket] = field(default_factory=dict)
+
+    def as_legacy_dict(self) -> dict[str, Any]:
+        """The exact dict `_compute_block_totals` has always returned.
+
+        Key order is preserved because callers and fixture builders read
+        this dict directly, and `entry_count` is deliberately absent at the
+        top level: it exists on the dataclass for the diagnosis, and adding
+        it here would change a shape every existing caller sees.
+        """
+        return {
+            "input_tokens": self.input_tokens,
+            "output_tokens": self.output_tokens,
+            "cache_create_tokens": self.cache_create_tokens,
+            "cache_read_tokens": self.cache_read_tokens,
+            "cost_usd": self.cost_usd,
+            "by_model": {k: v.as_legacy_dict() for k, v in self.by_model.items()},
+            "by_project": {k: v.as_legacy_dict() for k, v in self.by_project.items()},
+        }
+
+
+def fold_block_totals(entries: "Iterable[PricedEntry]") -> BlockTotals:
+    """Sum priced entries into block totals plus model and project buckets.
+
+    Pure: it opens nothing, prices nothing, and reads no clock. Summation
+    follows the iteration order of `entries`, and bucket insertion order
+    follows first appearance, both of which the callers observe.
+
+    A NULL `project_path` buckets under `(unknown)` so the reconcile
+    invariant `SUM(child.cost) == parent.total` continues to hold. The
+    JSONL-fallback loader always populates `project_path`, so `(unknown)`
+    only appears on the cache-backed path during the brief `session_files`
+    lazy-backfill window.
+    """
+    totals = BlockTotals()
+    for entry in entries:
+        totals.input_tokens += entry.input_tokens
+        totals.output_tokens += entry.output_tokens
+        totals.cache_create_tokens += entry.cache_creation_tokens
+        totals.cache_read_tokens += entry.cache_read_tokens
+        totals.cost_usd += entry.cost_usd
+        totals.entry_count += 1
+
+        for key, bucket_dict in (
+            (entry.model, totals.by_model),
+            (entry.project_path or "(unknown)", totals.by_project),
+        ):
+            b = bucket_dict.setdefault(key, BlockBucket())
+            b.input_tokens += entry.input_tokens
+            b.output_tokens += entry.output_tokens
+            b.cache_create_tokens += entry.cache_creation_tokens
+            b.cache_read_tokens += entry.cache_read_tokens
+            b.cost_usd += entry.cost_usd
+            b.entry_count += 1
+    return totals
+
+
 def _compute_block_totals(
     block_start_at: dt.datetime,
     range_end: dt.datetime,
@@ -1901,64 +2013,32 @@ def _compute_block_totals(
                                      cost_usd, entry_count}]
       by_project: dict[project_path_or_'(unknown)' -> same shape]
     """
-    totals: dict[str, Any] = {
-        "input_tokens": 0,
-        "output_tokens": 0,
-        "cache_create_tokens": 0,
-        "cache_read_tokens": 0,
-        "cost_usd": 0.0,
-        "by_model": {},
-        "by_project": {},
-    }
-    for entry in get_claude_session_entries(
-        block_start_at, range_end, skip_sync=skip_sync,
-    ):
-        usage = claude_usage_dict(   # #195 chokepoint
-            input_tokens=entry.input_tokens,
-            output_tokens=entry.output_tokens,
-            cache_creation_tokens=entry.cache_creation_tokens,
-            cache_read_tokens=entry.cache_read_tokens,
-            cache_1h_tokens=getattr(entry, "cache_1h_tokens", None),
-            speed=getattr(entry, "speed", None),
-        )
-        cost = _calculate_entry_cost(
-            entry.model, usage, mode="auto", cost_usd=entry.cost_usd,
-        )
-
-        totals["input_tokens"]        += entry.input_tokens
-        totals["output_tokens"]       += entry.output_tokens
-        totals["cache_create_tokens"] += entry.cache_creation_tokens
-        totals["cache_read_tokens"]   += entry.cache_read_tokens
-        totals["cost_usd"]            += cost
-
-        # Bucket by model and by project_path. NULL project_path → sentinel
-        # so reconcile invariant SUM(child.cost) == parent.total holds.
-        # Note: the JSONL-fallback path (_direct_parse_claude_session_entries)
-        # always populates project_path = cwd (never NULL); '(unknown)' only
-        # appears on the cache-backed path during the brief session_files
-        # lazy-backfill window.
-        for key, bucket_dict in (
-            (entry.model, totals["by_model"]),
-            (entry.project_path or "(unknown)", totals["by_project"]),
+    def _priced():
+        for entry in get_claude_session_entries(
+            block_start_at, range_end, skip_sync=skip_sync,
         ):
-            b = bucket_dict.setdefault(
-                key,
-                {
-                    "input_tokens": 0,
-                    "output_tokens": 0,
-                    "cache_create_tokens": 0,
-                    "cache_read_tokens": 0,
-                    "cost_usd": 0.0,
-                    "entry_count": 0,
-                },
+            usage = claude_usage_dict(   # #195 chokepoint
+                input_tokens=entry.input_tokens,
+                output_tokens=entry.output_tokens,
+                cache_creation_tokens=entry.cache_creation_tokens,
+                cache_read_tokens=entry.cache_read_tokens,
+                cache_1h_tokens=getattr(entry, "cache_1h_tokens", None),
+                speed=getattr(entry, "speed", None),
             )
-            b["input_tokens"]        += entry.input_tokens
-            b["output_tokens"]       += entry.output_tokens
-            b["cache_create_tokens"] += entry.cache_creation_tokens
-            b["cache_read_tokens"]   += entry.cache_read_tokens
-            b["cost_usd"]            += cost
-            b["entry_count"]         += 1
-    return totals
+            cost = _calculate_entry_cost(
+                entry.model, usage, mode="auto", cost_usd=entry.cost_usd,
+            )
+            yield PricedEntry(
+                model=entry.model,
+                project_path=entry.project_path,
+                input_tokens=entry.input_tokens,
+                output_tokens=entry.output_tokens,
+                cache_creation_tokens=entry.cache_creation_tokens,
+                cache_read_tokens=entry.cache_read_tokens,
+                cost_usd=cost,
+            )
+
+    return fold_block_totals(_priced()).as_legacy_dict()
 
 
 def maybe_update_five_hour_block(

package/bin/_cctally_refresh.py

@@ -918,6 +918,58 @@ def cmd_refresh_usage(args: argparse.Namespace) -> int:
 # Hook-tick OAuth refresh path
 # =========================================================================
 
+def _hook_tick_oauth_skip_status(c, *, throttle_seconds: float) -> str | None:
+    """Return the automatic-refresh suppression reason under selected lock."""
+    now_epoch = int(time.time())
+    needs_repair = c._authoritative_repair_required(now_epoch=now_epoch)
+    obs_age = c._statusline_observe_age_seconds()
+    if (not needs_repair
+            and obs_age < float(_cctally_core.OAUTH_BACKFILL_STALE_SECONDS)):
+        return f"skipped(statusline-fresh:{int(obs_age)}s)"
+    backoff_remaining = c._oauth_backoff_remaining_seconds()
+    if backoff_remaining > 0:
+        return f"skipped(backoff:{int(backoff_remaining)}s)"
+    age_s = c._newest_snapshot_age_seconds()
+    if age_s is not None and age_s < throttle_seconds:
+        return f"skipped(fresh:{int(age_s)}s)"
+    return None
+
+
+def _hook_tick_parse_oauth_payload(c, api):
+    """Validate one OAuth response outside the selected-state lock."""
+    try:
+        seven = api["seven_day"]
+        seven_pct = c._normalize_percent(float(seven["utilization"]))
+        seven_resets_epoch = _iso_to_epoch(seven["resets_at"])
+    except (TypeError, ValueError, KeyError):
+        return None
+    five = api.get("five_hour") if isinstance(api.get("five_hour"), dict) else None
+    five_pct: float | None = None
+    five_resets_epoch: int | None = None
+    if (five is not None and "utilization" in five
+            and isinstance(five.get("resets_at"), str)):
+        try:
+            five_pct = c._normalize_percent(float(five["utilization"]))
+            five_resets_epoch = _iso_to_epoch(five["resets_at"])
+        except (TypeError, ValueError):
+            five_pct = None
+            five_resets_epoch = None
+    record_args = argparse.Namespace(
+        percent=seven_pct,
+        resets_at=str(seven_resets_epoch),
+        five_hour_percent=five_pct,
+        five_hour_resets_at=(
+            str(five_resets_epoch) if five_resets_epoch is not None else None
+        ),
+        source="api",
+    )
+    axes = {"sevenDay", *({"fiveHour"} if five_pct is not None else set())}
+    parts = [f"7d={int(round(seven_pct))}"]
+    if five_pct is not None:
+        parts.append(f"5h={int(round(five_pct))}")
+    return record_args, axes, parts
+
+
 def _hook_tick_oauth_refresh(
     timeout_seconds: float = 5.0,
     throttle_seconds: float | None = None,
@@ -950,115 +1002,75 @@ def _hook_tick_oauth_refresh(
             throttle_seconds = float(_get_oauth_usage_config(c.load_config())["throttle_seconds"])
         except OauthUsageConfigError:
             throttle_seconds = float(c.HOOK_TICK_DEFAULT_THROTTLE_SECONDS)
-    # The automatic writer takes the selected-state lock *before* rechecking
-    # its suppression conditions.  A concurrent publisher can otherwise make
-    # this tick issue an unnecessary OAuth request between the initial gate
-    # and the request itself.
-    # #583 S2: the nudge is deferred out of the critical section. This frame
-    # owns the lock across the OAuth fetch AND the authoritative record, so
-    # `_authoritative_record_usage` cannot release it — the deferral has to
-    # reach the frame that acquired it. The nudge is a loopback POST with a
-    # multi-second timeout and this lock is an `fcntl.flock` every cctally
-    # process contends on, so one unresponsive listener would otherwise stall
-    # every other process's selected-state writes at status-line cadence.
-    deferred = []
+    # Check freshness under the selected-state lock, release it for the
+    # potentially five-second network request, then recheck after reacquiring
+    # before publication. A concurrent winner can therefore suppress this
+    # response without the high-cadence hook holding the cross-process flock
+    # during network I/O.
     try:
         with c._selected_state_lock():
-            out = _hook_tick_oauth_refresh_locked(
-                c,
-                token=token,
-                timeout_seconds=timeout_seconds,
-                throttle_seconds=throttle_seconds,
-                nudge_sink=lambda: deferred.append(1),
+            skipped = _hook_tick_oauth_skip_status(
+                c, throttle_seconds=throttle_seconds,
             )
     except OSError:
         return "err(record-usage=exc)", None
-    if deferred:
-        c._nudge_dashboard_repaint()
-    return out
-
-
-def _hook_tick_oauth_refresh_locked(
-    c,
-    *,
-    token: str,
-    timeout_seconds: float,
-    throttle_seconds: float,
-    nudge_sink=None,
-) -> tuple[str, dict | None]:
-    """Automatic OAuth path with the selected-state lock already held.
+    if skipped is not None:
+        return skipped, None
 
-    ``nudge_sink`` records that a dashboard nudge is warranted; the caller
-    fires it after releasing the lock (#583 S2).
-    """
-    # Backfill gate: an inflight/invalid tombstone bypasses only selected-age
-    # suppression so a later authoritative result can repair it.  The normal
-    # throttle and 429 deadline continue to bound OAuth traffic.
-    now_epoch = int(time.time())
-    needs_repair = c._authoritative_repair_required(now_epoch=now_epoch)
-    obs_age = c._statusline_observe_age_seconds()
-    if (not needs_repair
-            and obs_age < float(_cctally_core.OAUTH_BACKFILL_STALE_SECONDS)):
-        return f"skipped(statusline-fresh:{int(obs_age)}s)", None
-    backoff_remaining = c._oauth_backoff_remaining_seconds()
-    if backoff_remaining > 0:
-        return f"skipped(backoff:{int(backoff_remaining)}s)", None
-    age_s = c._newest_snapshot_age_seconds()
-    if age_s is not None and age_s < throttle_seconds:
-        return f"skipped(fresh:{int(age_s)}s)", None
     try:
         api = c._fetch_oauth_usage(token=token, timeout_seconds=timeout_seconds)
     except RefreshUsageRateLimitError as exc:
-        c._oauth_backoff_register_429(
-            retry_after_deadline=getattr(exc, "retry_after_deadline", None),
-            now=time.time(),
-        )
+        try:
+            with c._selected_state_lock():
+                c._oauth_backoff_register_429(
+                    retry_after_deadline=getattr(
+                        exc, "retry_after_deadline", None,
+                    ),
+                    now=time.time(),
+                )
+        except OSError:
+            return "err(record-usage=exc)", None
         return "err(rate-limit)", None
     except RefreshUsageNetworkError:
         return "err(network)", None
     except RefreshUsageMalformedError:
         return "err(parse)", None
-    seven = api["seven_day"]
-    try:
-        seven_pct = c._normalize_percent(float(seven["utilization"]))
-        seven_resets_epoch = _iso_to_epoch(seven["resets_at"])
-    except (TypeError, ValueError, KeyError):
+
+    parsed = _hook_tick_parse_oauth_payload(c, api)
+    if parsed is None:
         return "err(parse)", None
-    five = api.get("five_hour") if isinstance(api.get("five_hour"), dict) else None
-    five_pct: float | None = None
-    five_resets_epoch: int | None = None
-    if (five is not None and "utilization" in five
-            and isinstance(five.get("resets_at"), str)):
-        try:
-            five_pct = c._normalize_percent(float(five["utilization"]))
-            five_resets_epoch = _iso_to_epoch(five["resets_at"])
-        except (TypeError, ValueError):
-            five_pct = None
-            five_resets_epoch = None
-    record_args = argparse.Namespace(
-        percent=seven_pct,
-        resets_at=str(seven_resets_epoch),
-        five_hour_percent=five_pct,
-        five_hour_resets_at=str(five_resets_epoch) if five_resets_epoch is not None else None,
-        source="api",
-    )
-    authoritative = c._authoritative_record_usage(
-        record_args,
-        {"sevenDay", *({"fiveHour"} if five_pct is not None else set())},
-        lock_held=True,
-        nudge_sink=nudge_sink,
-    )
-    if authoritative.status != "ok":
-        reason = authoritative.reason or ""
-        if reason.startswith("exit "):
-            return f"err(record-usage={reason[5:]})", None
+    record_args, axes, parts = parsed
+
+    # #583 S2: the nudge remains deferred until after the publication lock is
+    # released. The sink contract is now enforced by the authority kernel, so
+    # every lock-owning caller has to make the deferral explicit.
+    deferred = []
+    try:
+        with c._selected_state_lock():
+            skipped = _hook_tick_oauth_skip_status(
+                c,
+                throttle_seconds=throttle_seconds,
+            )
+            if skipped is not None:
+                return skipped, None
+            authoritative = c._authoritative_record_usage(
+                record_args,
+                axes,
+                lock_held=True,
+                nudge_sink=lambda: deferred.append(1),
+            )
+            if authoritative.status != "ok":
+                reason = authoritative.reason or ""
+                if reason.startswith("exit "):
+                    return f"err(record-usage={reason[5:]})", None
+                return "err(record-usage=exc)", None
+            # A success reaches shared backoff only after tombstones, control,
+            # and freshness are authoritative under this same lock.
+            c._oauth_backoff_reset()
+    except OSError:
         return "err(record-usage=exc)", None
-    # Success is acknowledged to the shared OAuth backoff only after the
-    # authoritative writer has published tombstones, control, and freshness.
-    c._oauth_backoff_reset()
-    parts = [f"7d={int(round(seven_pct))}"]
-    if five_pct is not None:
-        parts.append(f"5h={int(round(five_pct))}")
+    if deferred:
+        c._nudge_dashboard_repaint()
     return f"ok({','.join(parts)})", api
 
 

package/bin/_cctally_share.py

@@ -949,7 +949,7 @@ def _build_forecast_snapshot(
     projected_low_pct: float,
     projected_high_pct: float,
     days_remaining: float,
-    dollars_per_percent: float,
+    dollars_per_percent: "float | None",
     dollars_per_percent_source: str,
     low_conf: bool,
     notes: tuple[str, ...] = (),
@@ -1038,6 +1038,13 @@ def _build_forecast_snapshot(
             f"{projected_low_pct:.1f}% — {projected_high_pct:.1f}%"
         )
     dpp_source_label = dollars_per_percent_source.replace("_", " ")
+    # #620 S1 D5: a withheld rate renders as the same `n/a` the report trend
+    # table already uses for an absent $/1%. Forcing it through MoneyCell
+    # would print $0.00, which is the fabrication this contract removes.
+    dpp_cell = (
+        _lib_share.TextCell("n/a") if dollars_per_percent is None
+        else _lib_share.MoneyCell(float(dollars_per_percent))
+    )
     snap_rows = (
         _lib_share.Row(cells={
             "metric": _lib_share.TextCell("Current %"),
@@ -1053,7 +1060,7 @@ def _build_forecast_snapshot(
         }),
         _lib_share.Row(cells={
             "metric": _lib_share.TextCell(f"$ / 1% ({dpp_source_label})"),
-            "value": _lib_share.MoneyCell(float(dollars_per_percent)),
+            "value": dpp_cell,
         }),
     )
     # Caller-provided `notes` (e.g., empty-data path's clearer message)

package/bin/_cctally_source_analytics.py

@@ -1140,6 +1140,14 @@ def _run_claude_json_adapter(args: object, command: str) -> SourceResult[dict[st
     captured: list[dict[str, object]] = []
     claude_args._source_result_sink = captured.append
     exit_code = handler(claude_args)
+    # Every Claude handler resolves the display zone onto its own namespace,
+    # and ``claude_args`` is a copy, so that resolution never reached the
+    # caller. The all-source terminal report needs the SAME zone the handler
+    # used or its week windows and capture timestamps would render in a
+    # different zone from `report --source claude` (#620 S1 D7). Reading it
+    # back off the copy is exact by construction; re-deriving it here would
+    # be a second resolution that can disagree with the first.
+    args._claude_resolved_tz = getattr(claude_args, "_resolved_tz", None)
     if exit_code != 0 or len(captured) != 1:
         return SourceResult("claude", "unavailable", None)
     payload = captured[0]
@@ -1951,8 +1959,15 @@ def _render_codex_terminal(
     return "\n".join(lines)
 
 
-def _render_claude_terminal(command: str, result: SourceResult) -> str:
-    """Render an all-source Claude section without changing legacy CLI paths."""
+def _render_claude_terminal(
+    command: str, result: SourceResult, *, tz: object = None,
+) -> str:
+    """Render an all-source Claude section without changing legacy CLI paths.
+
+    ``tz`` is the display zone the Claude handler itself resolved, captured
+    by ``_run_claude_json_adapter``; it reaches only the report renderer
+    (#620 S1 D7), which formats week windows and capture timestamps.
+    """
     title = _TERMINAL_TITLES.get(command, "Analytics Report")
     lines = [f"Claude {title}"]
     if result.status == "unavailable":
@@ -1962,11 +1977,29 @@ def _render_claude_terminal(command: str, result: SourceResult) -> str:
     if command == "diff" and isinstance(result.data, dict):
         _append_diff_terminal(lines, result.data)
         return "\n".join(lines)
+    if command == "report" and isinstance(result.data, dict):
+        # #620 S1 D7: render the real report. `_legacy_claude_totals` reads a
+        # `totals` object this payload does not have, so it returned (0, 0)
+        # and the section collapsed to `Data available.` — no current-week
+        # table, no trend table, no `$ / 1%` column — while `report` on its
+        # own printed all of it. The renderer is the SAME pure function
+        # `cmd_report` calls, so the two cannot diverge.
+        c = _cctally()
+        lines.append(c.render_report_terminal(result.data, tz=tz))
+        return "\n".join(lines)
     cost, tokens = _legacy_claude_totals(result.data)
     if cost or tokens:
         lines.append(f"Total: {_terminal_amount(cost)} · {_terminal_tokens(tokens)}")
     else:
-        lines.append("Data available.")
+        # #620 S1 D7: a POPULATED result whose compatible cost and token
+        # totals are both exactly zero. `Data available.` said nothing about
+        # what was available or where to see it. State what is absent, and
+        # name the command that shows the detail this section cannot.
+        lines.append(
+            "No compatible cost or token total for Claude in this result. "
+            f"Run `cctally {command} --source claude` for the full Claude "
+            "detail."
+        )
     return "\n".join(lines)
 
 
@@ -2055,7 +2088,10 @@ def _emit_source_result(
                 and result.status == "unavailable"
             )
             sections = [
-                _render_claude_terminal(command, claude),
+                _render_claude_terminal(
+                    command, claude,
+                    tz=getattr(args, "_claude_resolved_tz", None),
+                ),
                 _render_codex_terminal(
                     command, result, diff=diff,
                     include_unavailable_diagnostic=not project_degradation,

package/bin/_cctally_statusline.py

@@ -1008,8 +1008,15 @@ def _authoritative_record_usage(
     selected-state writes. This frame owns the lock only on the
     ``lock_held=False`` path, so that is the only path that can fire the
     deferred nudge itself; a caller passing ``lock_held=True`` owns the lock
-    and must supply its own sink, or the nudge stays inside its section.
+    and must supply its own sink. The fail-closed guard below enforces that
+    contract before any tombstone or journal write begins.
     """
+    if lock_held and nudge_dashboard and nudge_sink is None:
+        return _AuthoritativeRecordResult(
+            "record_failed",
+            "lock_held authoritative record requires nudge_sink",
+        )
+
     if not lock_held:
         deferred = []
         try: