cctally 1.77.0 → 1.78.0

package/CHANGELOG.md

@@ -5,6 +5,21 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.78.0] - 2026-07-21
+
+### Changed
+- Dashboard Codex Daily, Weekly, and Monthly details now retain native Input, Cached input, Output, Reasoning, and Total counters; Codex Weekly uses reset-cycle vocabulary, All Weekly uses neutral provider-period wording, and partial-metadata projects with the same basename remain collision-safe without exposing identities. (#329)
+- Dashboard Codex session, project, and quota-block details now use bounded native hierarchies, localized timestamps, retained quota progression, and accessible prompt expansion across desktop and mobile. (#325)
+- Dashboard All-mode Claude project and session rows now open the same useful detail hierarchy and cross-navigation as the canonical Claude views while keeping native session IDs and source paths private. (#325)
+- Dashboard All-mode Forecast and Cache Report cards and details now compose separate, provider-labelled Claude and Codex reports with provider-local values, confidence, and degraded or unavailable reasons instead of presenting Codex-only data under an All heading. (#324)
+- Dashboard All-mode Weekly and `$ / 1% Trend` views now keep Claude and Codex quota histories in separate provider-labelled sections and series, while explicitly combining only compatible cost totals. (#324)
+
+### Fixed
+- Dashboard narrow layouts now keep degraded source status readable, hide the optional Codex five-hour slot when no native 300-minute window is reported, label real All-mode five-hour rows by provider, and bound unavailable combined-total warnings without losing their accessible detail. (#329)
+- Dashboard source-wide freshness and read-model warnings now reach Daily and Projects without hiding the fixed ten-card board; Current Usage and Share stay bound to the source that opened them, and All shows separate Claude and Codex current-cycle sections instead of silently falling back to Claude. (#328)
+- Dashboard HTTP and live-event JSON now convert non-finite numeric values to `null` at one strict outbound boundary, so missing Doctor freshness markers no longer emit browser-invalid `Infinity` tokens and the full Doctor report opens normally. (#327)
+- Claude 5-hour and 7-day usage now receive one account-wide authoritative OAuth confirmation per 30-second status-line cycle, so a stale Claude Code `rate_limits` payload can no longer leave dashboard milestones behind for up to five minutes. The confirmation is detached from rendering, shares the existing hook throttle lock, and preserves `Retry-After` plus exponential `429` backoff.
+
 ## [1.77.0] - 2026-07-21
 
 ### Added

package/bin/_cctally_core.py

@@ -252,9 +252,11 @@ def _real_prod_data_dir() -> pathlib.Path:
 # Internal (no config UI — YAGNI, spec §Out of scope); test injection only.
 # Spec 2026-07-17-usage-statusline-fallback-design.
 #
-# OAUTH_BACKFILL_STALE_SECONDS: the OAuth poll only backfills once the
-#   selected-freshness marker is at least this stale. The 30-second statusline
-#   transport tick does not run OAuth.
+# STATUSLINE_OAUTH_POLL_SECONDS: the account-wide authoritative confirmation
+#   cadence driven by Claude Code's 30-second statusline timer. Keep it below
+#   the timer so scheduling jitter does not skip every other tick.
+# OAUTH_BACKFILL_STALE_SECONDS: the matching selected-freshness gate shared by
+#   statusline-driven and hook-driven automatic OAuth refreshes.
 # OAUTH_BACKOFF_BASE_SECONDS / OAUTH_BACKOFF_CAP_SECONDS: the headerless
 #   exponential 429 backoff (base * 2**consecutive_429, capped).
 STATUSLINE_CANDIDATE_TTL_SECONDS = 90
@@ -270,7 +272,8 @@ STATUSLINE_TOMBSTONE_DOCUMENT_MAX_BYTES = 1024
 # session waits on a long subagent (event-driven updates go quiet then). MUST
 # Add-when-absent only; a user-set value is never mutated.
 STATUSLINE_REFRESH_INTERVAL_DEFAULT = 30
-OAUTH_BACKFILL_STALE_SECONDS = 300.0
+STATUSLINE_OAUTH_POLL_SECONDS = 25.0
+OAUTH_BACKFILL_STALE_SECONDS = STATUSLINE_OAUTH_POLL_SECONDS
 OAUTH_BACKOFF_BASE_SECONDS = 60.0
 OAUTH_BACKOFF_CAP_SECONDS = 3600.0
 

package/bin/_cctally_dashboard.py

@@ -356,6 +356,10 @@ from _lib_blocks import _group_entries_into_blocks
 # #279 S2 F3: stdlib-logging chokepoint — server errors reach stderr via
 # the real log_error override below (leaf import, no cycle).
 import _lib_log
+from _lib_dashboard_json import (
+    encode_dashboard_json,
+    encode_dashboard_json_bytes,
+)
 from _cctally_config import save_config, _load_config_unlocked
 from _cctally_db import _render_migration_error_banner
 from _cctally_cache import (
@@ -800,12 +804,20 @@ def _codex_partial_source_detail(snapshot, row: Mapping, *, resource: str,
     return detail
 
 
-def _source_safe_claude_session_detail(detail, *, key: str) -> dict[str, Any]:
+def _source_safe_claude_session_detail(
+    detail, *, key: str, project_key: str | None = None, label: str | None = None,
+) -> dict[str, Any]:
     """Adapt the existing Claude session detail builder to S4's safe route."""
     payload = _session_detail_to_envelope(detail)
     return {
         "detail_kind": "claude_session",
         "key": key,
+        "label": label or "Claude session",
+        "project_label": payload["project_label"],
+        "project_key": (
+            dashboard_resource_key("project", "claude", project_key)
+            if project_key else None
+        ),
         "started_utc": payload["started_utc"],
         "last_activity_utc": payload["last_activity_utc"],
         "duration_min": payload["duration_min"],
@@ -817,20 +829,32 @@ def _source_safe_claude_session_detail(detail, *, key: str) -> dict[str, Any]:
         "cache_hit_pct": payload["cache_hit_pct"],
         "cost_per_model": payload["cost_per_model"],
         "cost_total_usd": payload["cost_total_usd"],
+        "privacy_note": (
+            "Native session identity and source files are withheld to preserve "
+            "opaque identity. Cache rebuild history belongs to the private "
+            "conversation-detail surface and is intentionally not exposed by "
+            "this qualified accounting route."
+        ),
     }
 
 
-def _source_safe_claude_project_detail(detail: Mapping, *, key: str) -> dict[str, Any]:
+def _source_safe_claude_project_detail(
+    detail: Mapping, *, key: str, label: str,
+) -> dict[str, Any]:
     """Drop legacy raw bucket/session identifiers from a Claude project drill."""
     return {
         "detail_kind": "claude_project",
         "key": key,
+        "label": label,
         "window_weeks": detail.get("window_weeks"),
         "window_cost_usd": detail.get("window_cost_usd"),
         "window_attributed_pct": detail.get("window_attributed_pct"),
         "models": detail.get("models", []),
         "sessions": [
             {
+                "key": dashboard_resource_key(
+                    "session", "claude", item.get("session_id"),
+                ),
                 "started_at": item.get("started_at"),
                 "last_activity_at": item.get("last_activity_at"),
                 "primary_model": item.get("primary_model"),
@@ -859,13 +883,73 @@ def _source_safe_claude_block_detail(detail: Mapping, *, key: str) -> dict[str,
     }
 
 
-def _claude_session_id_for_source_key(snapshot, key: str) -> str | None:
+def _claude_session_row_for_source_key(snapshot, key: str):
     for row in getattr(snapshot, "sessions", ()) or ():
         session_id = getattr(row, "session_id", None)
         if isinstance(session_id, str) and session_id and (
             dashboard_resource_key("session", "claude", session_id) == key
         ):
-            return session_id
+            return row
+    return None
+
+
+def _claude_session_id_for_source_key(snapshot, key: str) -> str | None:
+    """Resolve a qualified session key without exposing its native identity.
+
+    The published source bundle contains the bounded dashboard rows.  A project
+    drill can legitimately link to a recent session outside that panel slice,
+    so fall back to the compact ``session_files`` identity index and compare
+    opaque hashes.  This never scans transcript entries or returns a raw ID to
+    the client.
+    """
+    row = _claude_session_row_for_source_key(snapshot, key)
+    if row is not None:
+        return getattr(row, "session_id", None)
+    try:
+        conn = open_cache_db()
+    except (sqlite3.DatabaseError, OSError):
+        return None
+    try:
+        rows = conn.execute(
+            "SELECT DISTINCT session_id FROM session_files "
+            "WHERE session_id IS NOT NULL AND session_id <> '' "
+            "ORDER BY session_id"
+        )
+        for (session_id,) in rows:
+            if (
+                isinstance(session_id, str)
+                and dashboard_resource_key(
+                    "session", "claude", session_id,
+                ) == key
+            ):
+                return session_id
+    except sqlite3.Error:
+        return None
+    finally:
+        conn.close()
+    return None
+
+
+def _claude_project_key_for_path(snapshot, project_path: object) -> str | None:
+    """Map one private project path back to its public display key."""
+    if not isinstance(project_path, str) or not project_path:
+        return None
+    env = getattr(snapshot, "projects_envelope", None)
+    if not isinstance(env, Mapping):
+        return None
+    candidates: list[object] = []
+    current = env.get("current_week")
+    if isinstance(current, Mapping):
+        candidates.extend(current.get("rows") or ())
+    trend = env.get("trend")
+    if isinstance(trend, Mapping):
+        candidates.extend(trend.get("projects") or ())
+    for row in candidates:
+        if not isinstance(row, Mapping) or row.get("bucket_path") != project_path:
+            continue
+        project_key = row.get("key")
+        if isinstance(project_key, str) and project_key:
+            return project_key
     return None
 
 
@@ -906,19 +990,39 @@ def _claude_block_start_for_source_key(snapshot, key: str) -> dt.datetime | None
     return None
 
 
-def _build_claude_source_detail(snapshot, *, resource: str, key: str) -> dict[str, Any]:
+def _build_claude_source_detail(
+    snapshot, *, resource: str, key: str, row: Mapping,
+    window_weeks: int = 4,
+) -> dict[str, Any]:
     """Map a bounded legacy row to its existing, cache-only detail builder."""
     now_utc = getattr(snapshot, "generated_at", None) or _command_as_of()
     if resource == "session":
-        session_id = _claude_session_id_for_source_key(snapshot, key)
-        if session_id is None:
+        session_row = _claude_session_row_for_source_key(snapshot, key)
+        session_id = (
+            getattr(session_row, "session_id", None)
+            if session_row is not None
+            else _claude_session_id_for_source_key(snapshot, key)
+        )
+        if not isinstance(session_id, str) or not session_id:
             raise SourceResourceNotFound()
         detail = sys.modules["cctally"]._tui_build_session_detail(
             session_id, now_utc=now_utc,
         )
         if detail is None:
             raise SourceResourceNotFound()
-        return _source_safe_claude_session_detail(detail, key=key)
+        project_key = (
+            getattr(session_row, "project_key", None)
+            if session_row is not None
+            else _claude_project_key_for_path(
+                snapshot, getattr(detail, "project_path", None),
+            )
+        )
+        return _source_safe_claude_session_detail(
+            detail,
+            key=key,
+            project_key=project_key,
+            label=str(row.get("title") or row.get("label") or "Claude session"),
+        )
 
     if resource == "project":
         project_key = _claude_project_key_for_source_key(snapshot, key)
@@ -932,7 +1036,7 @@ def _build_claude_source_detail(snapshot, *, resource: str, key: str) -> dict[st
             detail = _project_detail_for_window(
                 conn,
                 project_key=project_key,
-                weeks_back=1,
+                weeks_back=window_weeks,
                 now_utc=now_utc,
                 current_week=getattr(snapshot, "current_week", None),
                 projects_envelope=getattr(snapshot, "projects_envelope", None),
@@ -947,7 +1051,9 @@ def _build_claude_source_detail(snapshot, *, resource: str, key: str) -> dict[st
             conn.close()
         if detail is None:
             raise SourceResourceNotFound()
-        return _source_safe_claude_project_detail(detail, key=key)
+        return _source_safe_claude_project_detail(
+            detail, key=key, label=project_key,
+        )
 
     start_at = _claude_block_start_for_source_key(snapshot, key)
     if start_at is None:
@@ -984,7 +1090,7 @@ def _build_claude_source_detail(snapshot, *, resource: str, key: str) -> dict[st
 
 
 def build_source_detail(*, snapshot, source: str, resource: str,
-                        key: str) -> dict[str, Any]:
+                        key: str, window_weeks: int = 4) -> dict[str, Any]:
     """Resolve one qualified opaque key to a provider-native read-only detail.
 
     The frozen published bundle is the first bounded key index.  Claude then
@@ -992,9 +1098,24 @@ def build_source_detail(*, snapshot, source: str, resource: str,
     the native S1-S3 adapter detail without a Claude fallback or a rollout
     parse.  Every branch preserves the generic handler errors above it.
     """
-    row = source_detail_lookup(snapshot.source_bundle, source, resource, key)
+    try:
+        row = source_detail_lookup(snapshot.source_bundle, source, resource, key)
+    except SourceResourceNotFound:
+        # A Claude project drill can expose a recent session outside the
+        # dashboard panel's bounded published slice.  The provider adapter
+        # resolves that opaque key against session_files below; all other
+        # resources retain the strict frozen-bundle membership gate.
+        if source != "claude" or resource != "session":
+            raise
+        row = {}
     if source == "claude":
-        return _build_claude_source_detail(snapshot, resource=resource, key=key)
+        return _build_claude_source_detail(
+            snapshot,
+            resource=resource,
+            key=key,
+            row=row,
+            window_weeks=window_weeks,
+        )
     try:
         detail = _build_codex_source_detail(snapshot, resource=resource, key=key)
         if resource == "session":
@@ -3934,7 +4055,7 @@ def _handle_get_project_detail_impl(handler, *,
     except (TypeError, ValueError):
         weeks = None
     if weeks not in {1, 4, 8, 12}:
-        body = json.dumps({"error": "invalid weeks param"}).encode("utf-8")
+        body = encode_dashboard_json_bytes({"error": "invalid weeks param"})
         handler.send_response(400)
         handler.send_header("Content-Type", "application/json; charset=utf-8")
         handler.send_header("Content-Length", str(len(body)))
@@ -3977,9 +4098,9 @@ def _handle_get_project_detail_impl(handler, *,
         )
     except Exception as exc:
         handler.log_error("/api/project failed: %r", exc)
-        body = json.dumps(
+        body = encode_dashboard_json_bytes(
             {"error": "project detail failed"}
-        ).encode("utf-8")
+        )
         handler.send_response(500)
         handler.send_header("Content-Type", "application/json; charset=utf-8")
         handler.send_header("Content-Length", str(len(body)))
@@ -3987,16 +4108,16 @@ def _handle_get_project_detail_impl(handler, *,
         handler.wfile.write(body)
         return
     if detail is None:
-        body = json.dumps(
+        body = encode_dashboard_json_bytes(
             {"error": "project not found", "key": project_key},
-        ).encode("utf-8")
+        )
         handler.send_response(404)
         handler.send_header("Content-Type", "application/json; charset=utf-8")
         handler.send_header("Content-Length", str(len(body)))
         handler.end_headers()
         handler.wfile.write(body)
         return
-    body = json.dumps(detail, ensure_ascii=False).encode("utf-8")
+    body = encode_dashboard_json_bytes(detail, ensure_ascii=False)
     handler.send_response(200)
     handler.send_header("Content-Type", "application/json; charset=utf-8")
     handler.send_header("Content-Length", str(len(body)))
@@ -4456,7 +4577,9 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
         _respond_json plus an explicit Allow header.
         """
         if self.path.split("?", 1)[0] == "/api/settings":
-            encoded = json.dumps({"error": "method not allowed"}).encode("utf-8")
+            encoded = encode_dashboard_json_bytes(
+                {"error": "method not allowed"}
+            )
             self.send_response(405)
             self.send_header("Allow", "POST")
             self.send_header("Content-Type", "application/json")
@@ -5689,7 +5812,7 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
     # ---- helpers ----
 
     def _respond_json(self, status: int, body: dict) -> None:
-        encoded = json.dumps(body).encode("utf-8")
+        encoded = encode_dashboard_json_bytes(body)
         self.send_response(status)
         self.send_header("Content-Type", "application/json")
         self.send_header("Content-Length", str(len(encoded)))
@@ -5760,7 +5883,7 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
             # transcriptsEnabled=false, never enabled-then-403 (the pass-2 P2
             # finding) — one predicate, two consumers, desync impossible.
             env["transcriptsEnabled"] = visible
-            body = json.dumps(env, ensure_ascii=False).encode("utf-8")
+            body = encode_dashboard_json_bytes(env, ensure_ascii=False)
             self.send_response(200)
             self.send_header("Content-Type", "application/json; charset=utf-8")
             self.send_header("Content-Length", str(len(body)))
@@ -5795,9 +5918,9 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
                 runtime_bind=type(self).cctally_host,
             )
             report = _ld.run_checks(state)
-            body = json.dumps(
+            body = encode_dashboard_json_bytes(
                 _ld.serialize_json(report), ensure_ascii=False,
-            ).encode("utf-8")
+            )
             self.send_response(200)
             self.send_header("Content-Type", "application/json; charset=utf-8")
             self.send_header("Content-Length", str(len(body)))
@@ -5845,9 +5968,9 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
         if detail is None:
             self.send_error(404, "session not found")
             return
-        body = json.dumps(
+        body = encode_dashboard_json_bytes(
             _session_detail_to_envelope(detail), ensure_ascii=False
-        ).encode("utf-8")
+        )
         self.send_response(200)
         self.send_header("Content-Type", "application/json; charset=utf-8")
         self.send_header("Content-Length", str(len(body)))
@@ -5894,14 +6017,28 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
                 "error": "source capability unavailable",
             })
             return
-        try:
-            snap = self.snapshot_ref.get()
-            detail = build_source_detail(
-                snapshot=snap,
-                source=source,
-                resource=resource,
-                key=key,
+        detail_kwargs = {
+            "source": source,
+            "resource": resource,
+            "key": key,
+        }
+        if resource == "project":
+            query = _urlparse.parse_qs(
+                _urlparse.urlsplit(self.path).query,
+                keep_blank_values=True,
             )
+            raw_weeks = query.get("weeks")
+            if raw_weeks is not None:
+                if len(raw_weeks) != 1 or raw_weeks[0] not in {"1", "4", "8", "12"}:
+                    self._respond_json(400, {
+                        "code": "source_capability_unavailable",
+                        "error": "source capability unavailable",
+                    })
+                    return
+                detail_kwargs["window_weeks"] = int(raw_weeks[0])
+        try:
+            detail_kwargs["snapshot"] = self.snapshot_ref.get()
+            detail = build_source_detail(**detail_kwargs)
         except SourceResourceNotFound:
             self._respond_json(404, {
                 "code": "source_resource_not_found",
@@ -6049,7 +6186,7 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
         try:
             start_at = parse_iso_datetime(decoded, "start_at")
         except ValueError:
-            body = json.dumps({"error": "invalid start_at"}).encode("utf-8")
+            body = encode_dashboard_json_bytes({"error": "invalid start_at"})
             self.send_response(400)
             self.send_header("Content-Type", "application/json; charset=utf-8")
             self.send_header("Content-Length", str(len(body)))
@@ -6097,7 +6234,7 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
                 None,
             )
             if target is None:
-                body = json.dumps({"error": "block not found"}).encode("utf-8")
+                body = encode_dashboard_json_bytes({"error": "block not found"})
                 self.send_response(404)
                 self.send_header("Content-Type", "application/json; charset=utf-8")
                 self.send_header("Content-Length", str(len(body)))
@@ -6127,7 +6264,7 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
             self.log_error("/api/block failed: %r", exc)
             self.send_error(500, "block detail failed")
             return
-        body = json.dumps(detail, ensure_ascii=False).encode("utf-8")
+        body = encode_dashboard_json_bytes(detail, ensure_ascii=False)
         self.send_response(200)
         self.send_header("Content-Type", "application/json; charset=utf-8")
         self.send_header("Content-Length", str(len(body)))
@@ -6189,7 +6326,9 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
                 env["transcriptsEnabled"] = transcripts_enabled
                 msg = (
                     "event: update\n"
-                    + "data: " + json.dumps(env, ensure_ascii=False) + "\n\n"
+                    + "data: "
+                    + encode_dashboard_json(env, ensure_ascii=False)
+                    + "\n\n"
                 )
                 self.wfile.write(msg.encode("utf-8"))
                 self.wfile.flush()
@@ -6387,7 +6526,7 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
         try:
             for ev in worker.stream(run_id):
                 ev_type = ev.get("type", "message")
-                ev_data = json.dumps(
+                ev_data = encode_dashboard_json(
                     {k: v for k, v in ev.items() if k != "type"},
                     ensure_ascii=False,
                 )

package/bin/_cctally_dashboard_conversation.py

@@ -38,7 +38,6 @@ edits — the forwarders hit ``sys.modules["_cctally_dashboard"]`` at call time
 """
 from __future__ import annotations
 
-import json
 import re
 import socket
 import sqlite3
@@ -51,6 +50,7 @@ from _cctally_cache import (
     sync_codex_conversations,
     _codex_provider_roots,
 )
+from _lib_dashboard_json import encode_dashboard_json
 
 # Live-tail watch-loop tuning — used ONLY by _handle_get_conversation_events_impl
 # below, so moved here with the events handler (spec §4.1 / §6).
@@ -709,7 +709,8 @@ def _run_conversation_events_stream(
     import time as _time
     watch = sys.modules["cctally"]._load_sibling("_lib_conversation_watch")
     tail_frame = (
-        "event: tail\ndata: " + json.dumps(tail_data) + "\n\n").encode("utf-8")
+        "event: tail\ndata: " + encode_dashboard_json(tail_data) + "\n\n"
+    ).encode("utf-8")
 
     if passive:
         # Frozen-data contract: no ingest, no emit. Keep-alive only.

package/bin/_cctally_dashboard_sources.py

@@ -49,7 +49,10 @@ from _lib_jsonl import CodexEntry, codex_model_scoped_quota_pool
 from _lib_fmt import stable_sum
 from _lib_aggregators import _aggregate_codex_buckets
 from _lib_five_hour import _FIVE_HOUR_JITTER_FLOOR_SECONDS
-from _lib_source_analytics import build_codex_project_result
+from _lib_source_analytics import (
+    build_codex_project_result,
+    collision_safe_project_label_map,
+)
 from _lib_view_models import (
     CodexWeeklyView,
     build_codex_daily_view,
@@ -1783,12 +1786,17 @@ def _partial_projects_wire(
             model_totals[field] += value
             session_totals[field] += value
 
+    label_map = collision_safe_project_label_map(
+        (f"{root_key}\0{project_key}", str(group["label"]))
+        for (root_key, project_key), group in groups.items()
+    )
     rows = []
     for (root_key, _project_key), group in groups.items():
+        internal_identity = f"{root_key}\0{group['project_key']}"
         rows.append({
             "key": dashboard_resource_key("project", "codex", root_key, group["project_key"]),
             "source": "codex",
-            "label": group["label"],
+            "label": label_map[internal_identity],
             "session_count": len(group["sessions"]),
             "first_seen": group["first_seen"].astimezone(UTC).isoformat(),
             "last_seen": group["last_seen"].astimezone(UTC).isoformat(),

package/bin/_cctally_doctor.py

@@ -27,6 +27,7 @@ import argparse
 import datetime as dt
 import fcntl
 import json
+import math
 import pathlib
 import shutil
 import sqlite3
@@ -35,6 +36,7 @@ import sys
 import _cctally_core
 import _lib_changelog
 from _cctally_core import _now_utc, eprint, now_utc_iso, parse_iso_datetime
+from _lib_dashboard_json import encode_dashboard_json
 
 
 def _cctally():
@@ -53,11 +55,25 @@ def _gather_statusline_pipeline(c, *, now_utc: dt.datetime) -> dict:
         "tombstones": {"fiveHour": "absent", "sevenDay": "absent"},
     }
     try:
-        result["transport_age_seconds"] = c._statusline_transport_age_seconds()
+        age = c._statusline_transport_age_seconds()
+        result["transport_age_seconds"] = (
+            age
+            if isinstance(age, (int, float))
+            and not isinstance(age, bool)
+            and math.isfinite(float(age))
+            else None
+        )
     except Exception:
         pass
     try:
-        result["selected_age_seconds"] = c._statusline_observe_age_seconds()
+        age = c._statusline_observe_age_seconds()
+        result["selected_age_seconds"] = (
+            age
+            if isinstance(age, (int, float))
+            and not isinstance(age, bool)
+            and math.isfinite(float(age))
+            else None
+        )
     except Exception:
         pass
     try:
@@ -943,7 +959,7 @@ def cmd_doctor(args: argparse.Namespace) -> int:
     state = c.doctor_gather_state(deep=True)
     report = _lib_doctor.run_checks(state)
     if getattr(args, "json", False):
-        print(json.dumps(
+        print(encode_dashboard_json(
             _lib_doctor.serialize_json(report), indent=2, sort_keys=True,
         ))
     else: