cctally 1.103.0 → 1.105.0

package/bin/_cctally_dashboard_envelope.py

@@ -824,6 +824,68 @@ def _source_bundle_to_envelope(bundle: object | None) -> dict:
         }
 
 
+#: How many rate-change events the envelope publishes. A metering-rate
+#: transition is rare — the maintainer's store holds one — so this is a
+#: bound rather than a page size, and a store holding more than a handful
+#: describes a detector that is misfiring rather than a busy account.
+METER_RATE_CHANGE_LIMIT = 20
+
+
+def _build_meter_rate_change_array(
+    conn: sqlite3.Connection, limit: int = METER_RATE_CHANGE_LIMIT,
+) -> list:
+    """The #661 S2 §6.1 non-threshold event family's wire rows.
+
+    A SEPARATE array from `alerts`, and deliberately so. Every member of
+    `AXIS_REGISTRY` is a numeric threshold axis: `AlertEntry` requires a
+    numeric `threshold`, its `id` is threshold-shaped, and `alert_row_owner`
+    raises on a seventh axis so that adding one without deciding its
+    ownership fails a test rather than shipping an invisible row. A rate
+    transition has neither a threshold nor a threshold-derived severity, so
+    it gets its own discriminated variant instead of being forced into that
+    union.
+
+    Each row carries the explicit severity, the old and new rates, the
+    effective instant, its OWNERSHIP (which provider tab renders it) and its
+    SCOPE (the account, decorated under R8 exactly as the alert rows are).
+    """
+    account_fields = _alert_account_resolver(conn)
+    try:
+        rows = conn.execute(
+            "SELECT provider, account_key, effective_from,"
+            "       previous_units_per_point, new_units_per_point, severity,"
+            "       detected_at_utc, created_at_utc"
+            "  FROM meter_rate_change_events"
+            " ORDER BY unixepoch(effective_from) DESC, id DESC"
+            " LIMIT ?", (int(limit),)).fetchall()
+    except sqlite3.Error:
+        # A store predating epoch 1011 has no such table, and the rebuild
+        # that creates it is deferred to a background worker. An empty array
+        # renders as "no change recorded", which is the truth on that store.
+        return []
+    out: list[dict] = []
+    for (provider, account_key, effective_from, previous, new, severity,
+         detected_at, created_at) in rows:
+        entry = {
+            # Opaque React key. It is never parsed — the same contract the
+            # alert `id` carries.
+            "id": f"meter_rate_change:{provider}:{account_key}:{effective_from}",
+            "family": "meter_rate_change",
+            "provider": str(provider),
+            "owner": str(provider),
+            "severity": str(severity or "info"),
+            "effective_from": str(effective_from),
+            "detected_at": str(detected_at or created_at or ""),
+            "recorded_at": str(created_at or ""),
+            "previous_units_per_point": (
+                None if previous is None else float(previous)),
+            "new_units_per_point": None if new is None else float(new),
+        }
+        entry.update(account_fields(str(provider), account_key))
+        out.append(entry)
+    return out
+
+
 def _build_alerts_envelope_array(
     conn: sqlite3.Connection,
     limit: int = 100,
@@ -1103,6 +1165,239 @@ def _sync_activity_envelope(activity: "dict | None") -> dict:
     }
 
 
+#: How far two subscription-week anchors may drift and still count as the
+#: same reset domain. The week anchor is normalized to the hour to absorb
+#: Anthropic's reset jitter, so two hours is comfortably wider than the
+#: jitter and far narrower than the shortest interval a synthesized
+#: mid-week row could produce.
+_RESET_DOMAIN_TOLERANCE_SECONDS = 2 * 3600
+_SUBSCRIPTION_WEEK_SECONDS = 7 * 24 * 3600
+
+
+def _same_reset_domain(current_start, prior_start) -> bool:
+    """Whether two week anchors belong to the same reset domain.
+
+    Spec §10.1 requires the prior operand to share the current row's reset
+    domain. The rows carry no domain field, so it is derived from the one
+    thing they always carry: two anchors are in the same domain when they
+    are a whole number of subscription weeks apart. A row synthesized by
+    reset or credit handling sits at a fractional offset and is skipped
+    rather than silently used, which is exactly what that clause is for.
+    """
+    if current_start is None or prior_start is None:
+        return False
+    delta = (current_start - prior_start).total_seconds()
+    if delta <= 0:
+        return False
+    offset = delta % _SUBSCRIPTION_WEEK_SECONDS
+    return min(offset, _SUBSCRIPTION_WEEK_SECONDS - offset) <= \
+        _RESET_DOMAIN_TOLERANCE_SECONDS
+
+
+def _cause_presentation(code):
+    """The §8 presentation fields for one cause, or None for no cause.
+
+    ADDITIVE beside the machine `code`, which is unchanged and stays the
+    stable value a client keys on. A client that receives no presentation
+    fields — a new tab against an older server, which `execvp` makes
+    ordinary — derives the short token from the code itself through the same
+    named function this uses.
+    """
+    if not code:
+        return None
+    try:
+        copy = sys.modules["cctally"]._load_sibling("_lib_quota_copy")
+    except Exception:                                  # noqa: BLE001
+        return None
+    out = copy.presentation(code)
+    return out or None
+
+
+def _basis_presentation(basis):
+    """The shared two-register projection-basis copy, or None.
+
+    Separate from `_cause_presentation`: a basis describes a present figure's
+    provenance and never joins the withholding-cause vocabulary.
+    """
+    if not basis:
+        return None
+    try:
+        copy = sys.modules["cctally"]._load_sibling("_lib_quota_copy")
+    except Exception:                                  # noqa: BLE001
+        return None
+    out = copy.basis_presentation(basis)
+    return out or None
+
+
+def _forecast_quota_envelope(fc, cw, rate_change):
+    """Spec §10's optional typed `forecast.quota` object.
+
+    Additive, and deliberately does NOT bump `source_schema_version`: that
+    field describes the provider-source bundles, not this.
+
+    Every quantity here was already computed. The basis, the codes, the
+    corrected interval and the calibrated triple come off the forecast the
+    envelope is already serializing, and `rate_change` is the caller's cheap
+    calibration-file read. Nothing here opens a store.
+
+    NO PRESENTATION LATCH: this is rebuilt from the current forecast on
+    every refresh, so the surface switches with the shared selector rather
+    than presenting a model whose evidence has since been withheld.
+    """
+    if fc is None:
+        return None
+    inputs = getattr(fc, "inputs", None)
+    interval = getattr(inputs, "p_now_interval", None)
+    code = getattr(fc, "projection_code", None)
+    calibration_code = getattr(inputs, "calibrated_withheld_code", None)
+    consumption = getattr(inputs, "calibrated_consumption_pct", None)
+    consumption_interval = getattr(
+        inputs, "calibrated_consumption_interval", None)
+    observed = getattr(cw, "used_pct", None) if cw is not None else None
+    basis = getattr(fc, "projection_basis", None)
+    projection = getattr(fc, "week_avg_projection_pct", None)
+    headroom = getattr(inputs, "calibrated_headroom_pct", None)
+    # The calibrated view is published as a UNIT (#661 S2 review, D2).
+    #
+    # `select_projection_basis` reads ONLY `calibrated_projection_pct`, so a
+    # non-null projection beside a null modelled consumption would publish
+    # `basis: "calibrated"` over a number the model does not state — a modal
+    # reading "basis: model" above "modelled consumption: —". The invariant
+    # held until now only because `_calibrated_week_detail` sets the whole
+    # triple or none of it, which is the producer's discipline rather than a
+    # property of this serializer.
+    #
+    # WITHHELD rather than demoted. Demoting to `corrected-meter` would
+    # relabel a number the calibrated model produced, and the meter's own
+    # projection is not on this forecast to substitute, so there is nothing
+    # honest to publish. `withheld` is an already-rendered basis on the panel
+    # and in the modal, and it carries a cause.
+    # `projection is None` is included for completeness rather than because
+    # it is reachable: `select_projection_basis` reads `calibrated_projection_pct`,
+    # so a null projection does not yield this basis in the first place, and
+    # `bin/_lib_forecast.py` nulls the projection only on its WITHHELD branch.
+    # The argument that motivates the other two operands -- that the whole
+    # triple is the producer's discipline and not a property of this
+    # serializer -- applies to the projection identically, so leaving it out
+    # would make the guard state a narrower invariant than the one it means.
+    if basis == "calibrated" and (projection is None
+                                  or consumption is None
+                                  or headroom is None):
+        basis = "withheld"
+        projection = None
+        consumption = None
+        consumption_interval = None
+        headroom = None
+        code = code or "unavailable"
+        calibration_code = calibration_code or "unavailable"
+    return {
+        "basis":              basis,
+        "basis_presentation": _basis_presentation(basis),
+        "projection_pct":     projection,
+        "right_censored":     bool(getattr(fc, "right_censored", False)),
+        # The cause of a WITHHELD projection, and separately why the
+        # CALIBRATED basis was not reached. They are different questions and
+        # a surface that collapses them says nothing when it falls back.
+        "code":               code,
+        "code_presentation":  _cause_presentation(code),
+        "calibration_code":   calibration_code,
+        "calibration_code_presentation":
+            _cause_presentation(calibration_code),
+        # The corrected-meter interval a displayed reading denotes. `hi` is
+        # null at a right-censored 100, which is unbounded above.
+        "corrected_interval":
+            None if interval is None
+            else {"lo": interval[0], "hi": interval[1]},
+        "calibrated_consumption_pct": consumption,
+        "calibrated_consumption_interval":
+            None if not consumption_interval
+            else {"lo": consumption_interval[0],
+                  "hi": consumption_interval[1]},
+        "calibrated_headroom_pct": headroom,
+        "rate_change":        rate_change,
+        # Spec §10: the observed meter minus the modelled local quota,
+        # labelled as exactly that. It is a DIFFERENCE between two
+        # quantities and does not identify or estimate usage from another
+        # machine; the modal states that sentence, and it is null unless
+        # both sides exist.
+        "observed_minus_modelled_pct":
+            None if (observed is None or consumption is None)
+            else observed - consumption,
+    }
+
+
+def _header_rate_and_delta(current_rate, current_week_start, trend):
+    """`(dollar_per_pct, vs_last_week_delta)` from ONE current operand.
+
+    Spec §10.1, and the defect it closes: `header.dollar_per_pct` came from
+    `_tui_build_current_week` while `header.vs_last_week_delta` came from the
+    operand `build_trend_view` returned. Two computations, no guard, so the
+    hero could publish a week-over-week comparison on a screen stating no
+    `$ / 1%` at all.
+
+    Both values are computed here, from the header's own current operand,
+    before serialization — so the client never reconciles two differently
+    sourced "current" values. When the current rate is absent BOTH are null,
+    because a delta measured from an absent operand is not a delta.
+
+    The prior operand is the NEAREST COMPARABLE completed row, and
+    comparable is the exact list §10.1 gives. Provider and account scope are
+    properties of the whole snapshot, so every row in `trend` shares them by
+    construction; what has to be tested per row is the remaining three:
+
+      * a completed rather than current interval (`is_current` is False);
+      * a non-null rate on that row; and
+      * the same reset domain as the current week.
+
+    A row failing any of them is SKIPPED and the walk continues to the next
+    older row, rather than the delta being abandoned or the row being used.
+
+    NEAREST IS BY ANCHOR, not by list position. The walk used to be
+    `reversed(list(trend))`, which makes "nearest" mean "last in the list" and
+    rests the whole clause on `snap.trend` arriving ascending. That holds for
+    `build_trend_view` and for every committed fixture and was stated nowhere,
+    and `_same_reset_domain` accepts any positive whole-week multiple, so a
+    row twenty weeks back was as comparable as one week back. The candidates
+    are therefore ordered here, newest anchor first. A row carrying no anchor
+    sorts last and is skipped by the reset-domain test anyway.
+    """
+    if current_rate is None:
+        return None, None
+    # Only rows whose anchor is a `datetime` are sorted; anything else keeps
+    # list order after them. `sorted` compares the keys, so one naive anchor
+    # beside an aware one -- or a `str` anchor, which the sibling row type at
+    # `bin/_lib_view_models.py:174` carries -- would raise `TypeError` inside
+    # the dashboard's serialization path and surface as a 500 rather than a
+    # withheld figure. `build_trend_view` emits aware datetimes today, so the
+    # partition is a guard against a future producer, not a live defect.
+    # Ties keep list order, because `sorted` is stable: two rows sharing an
+    # anchor resolve to the earlier one in `trend`.
+    rows = list(trend or ())
+    anchored = [r for r in rows
+                if isinstance(getattr(r, "week_start_at", None), dt.datetime)]
+    unanchored = [r for r in rows
+                  if not isinstance(getattr(r, "week_start_at", None),
+                                    dt.datetime)]
+    aware = [r for r in anchored if r.week_start_at.tzinfo is not None]
+    naive = [r for r in anchored if r.week_start_at.tzinfo is None]
+    candidates = (
+        sorted(aware, key=lambda row: row.week_start_at, reverse=True)
+        + sorted(naive, key=lambda row: row.week_start_at, reverse=True)
+        + unanchored
+    )
+    for row in candidates:
+        if getattr(row, "is_current", False):
+            continue
+        prior_rate = getattr(row, "dollars_per_percent", None)
+        if prior_rate is None:
+            continue
+        if not _same_reset_domain(current_week_start,
+                                  getattr(row, "week_start_at", None)):
+            continue
+        return current_rate, current_rate - prior_rate
+    return current_rate, None
+
+
 def snapshot_to_envelope(snap: "DataSnapshot", *,
                          now_utc: "dt.datetime",
                          monotonic_now: "float | None" = None,
@@ -1256,17 +1551,13 @@ def snapshot_to_envelope(snap: "DataSnapshot", *,
         inputs = getattr(fc, "inputs", None)
         if inputs is not None:
             confidence = getattr(inputs, "confidence", None)
-        r_avg = getattr(fc, "r_avg", None)
-        r_recent = getattr(fc, "r_recent", None)
-        p_now = getattr(inputs, "p_now", None) if inputs is not None else None
-        rem_hrs = getattr(inputs, "remaining_hours", None) if inputs is not None else None
-        if p_now is not None and rem_hrs is not None and r_avg is not None:
-            fcast_pct = p_now + r_avg * rem_hrs
-        if (p_now is not None and rem_hrs is not None
-                and r_recent is not None):
-            p_final_recent = p_now + r_recent * rem_hrs
-            if fcast_pct is None or p_final_recent != fcast_pct:
-                recent_24h_pct = p_final_recent
+        # The ONE decomposition (#661 S2 spec section 3.3), so this legacy
+        # branch cannot answer the projection question differently from the
+        # View path above it — which is exactly what the `over` golden
+        # recorded before this call replaced the inline arithmetic.
+        from _lib_view_models import _forecast_projection_pcts
+
+        fcast_pct, recent_24h_pct = _forecast_projection_pcts(fc)
         if getattr(fc, "already_capped", False):
             verdict = "capped"
         elif getattr(fc, "projected_cap", False):
@@ -1474,6 +1765,11 @@ def snapshot_to_envelope(snap: "DataSnapshot", *,
     # the entire snapshot — fall back to safe defaults and rely on
     # `_warn_alerts_bad_config_once` for the user-visible signal.
     alerts_array = list(getattr(snap, "alerts", []) or [])
+    # #661 S2 §6.1. Precomputed at sync time beside `alerts`, so
+    # `snapshot_to_envelope` stays a pure renderer with no DB I/O on the
+    # dashboard hot path.
+    meter_rate_changes_array = list(
+        getattr(snap, "meter_rate_changes", []) or [])
     # #268 M4: reuse the precompute's config (or the fallback load_config()
     # resolved above) — the envelope used to call load_config() a SECOND time
     # here. Within one tick both reads returned the same file, so this is
@@ -1551,6 +1847,11 @@ def snapshot_to_envelope(snap: "DataSnapshot", *,
         # template itself).
         "notifier":           _alerts_cfg.get("notifier", "auto"),
         "command_configured": _alerts_cfg.get("command_template") is not None,
+        # #661 S2 §6.2: the metering-rate-change family's PUSH toggle. The
+        # events themselves are recorded whatever this says, so the client
+        # renders the history with no configuration; this mirror only tells
+        # Settings whether the OS popup is armed.
+        "rate_change_enabled": bool(_alerts_cfg.get("rate_change_enabled")),
     }
     # Dashboard render-prefs mirror (cache-failure-markers opt-out, spec §5).
     # Reuses the single `_cfg_for_alerts = load_config()` read above (no extra
@@ -1666,6 +1967,15 @@ def snapshot_to_envelope(snap: "DataSnapshot", *,
         (r for r in reversed(snap.trend) if r.is_current), None
     ) if snap.trend else None
 
+    # #661 S2 §10.1. BOTH header operands are decided here, together, from
+    # the header's own current rate. `_current_trend` is retained above
+    # because other blocks read it, but its `delta_dpp` is no longer what
+    # the header publishes: that field is computed against whichever row
+    # happened to precede the current one in the trend series, which is a
+    # different question from "the nearest comparable prior operand".
+    dollar_pp, header_delta = _header_rate_and_delta(
+        dollar_pp, week_start_at_utc, snap.trend)
+
     envelope = {
         "envelope_version": 2,
         # #278 Theme A: single additive first-paint hydration latch. True only
@@ -1718,9 +2028,7 @@ def snapshot_to_envelope(snap: "DataSnapshot", *,
             "dollar_per_pct":     dollar_pp,
             "forecast_pct":       header_fcast_pct,
             "forecast_verdict":   verdict,
-            "vs_last_week_delta": (
-                _current_trend.delta_dpp if _current_trend is not None else None
-            ),
+            "vs_last_week_delta": header_delta,
         },
 
         "current_week":
@@ -1804,6 +2112,12 @@ def snapshot_to_envelope(snap: "DataSnapshot", *,
                                                 else 2 if confidence == "low"
                                                 else 0),
                 "explain":                     sys.modules["cctally"]._build_forecast_json_payload(fc),
+                # #661 S2 §10. Optional, typed, and ADDITIVE: it sits under
+                # `forecast` because `ForecastEnvelope` is its semantic
+                # boundary, and it does not bump `source_schema_version`,
+                # which describes the provider-source bundles.
+                "quota":                       _forecast_quota_envelope(
+                    fc, cw, getattr(snap, "quota_rate_change", None)),
             },
 
         "trend":
@@ -1921,6 +2235,14 @@ def snapshot_to_envelope(snap: "DataSnapshot", *,
         "alerts":           alerts_array,
         "alerts_settings":  alerts_settings,
 
+        # #661 S2 §6.1: the non-threshold event family, in its OWN array
+        # rather than inside `alerts`. `AlertEntry` requires a numeric
+        # threshold and a rate transition has none, so mixing the two would
+        # either weaken that contract or ship a row every consumer skips.
+        # Additive optional — `envelope_version` stays at 2, and an older
+        # client simply does not read it.
+        "meter_rate_changes": meter_rate_changes_array,
+
         # Dashboard render-prefs mirror (cache-failure-markers opt-out, spec
         # §5). Additive optional, like alerts_settings — envelope_version
         # stays at 2. The client derives `markersEnabled` from this, defaulting

package/bin/_cctally_dashboard_perf.py

@@ -47,6 +47,7 @@ _TRACE_PATH = "/api/debug/backend/trace"
 _REPORTED_REGIMES = ("active", "idle")
 
 _REGIME_LABELS = {"active": "Codex-active", "idle": "Codex-idle"}
+COMBINED_BACKGROUND_CPU_CEILING = 0.75
 
 
 def _cctally():
@@ -202,6 +203,36 @@ def _mean_or_none(values):
     return int(sum(values) / len(values)) if values else None
 
 
+def _cpu_duty(rows):
+    paired = [
+        (int(row.get("cpu_ns") or 0), int(row["period_ns"]))
+        for row in rows or ()
+        if row.get("cpu_ns") is not None
+        and row.get("period_ns") is not None
+        and int(row["period_ns"]) > 0
+    ]
+    if not paired:
+        return None
+    return sum(cpu for cpu, _period in paired) / sum(
+        period for _cpu, period in paired)
+
+
+def summarise_combined_background_duty(tick: dict) -> dict:
+    """Conservative sum of each loop's same-span one-core duty."""
+    main = _cpu_duty(tick.get("records") or ())
+    conversations = _cpu_duty(tick.get("conversation_sync") or ())
+    combined = None if main is None or conversations is None else (
+        main + conversations)
+    return {
+        "main": main,
+        "conversation": conversations,
+        "combined": combined,
+        "ceiling": COMBINED_BACKGROUND_CPU_CEILING,
+        "withinCeiling": None if combined is None else (
+            combined <= COMBINED_BACKGROUND_CPU_CEILING),
+    }
+
+
 def _median(values):
     import statistics
 
@@ -265,6 +296,17 @@ def _render_conversation_sync(tick: dict) -> list:
         statuses[key] = statuses.get(key, 0) + 1
     detail = " · ".join(f"{k} {v}" for k, v in sorted(statuses.items()))
     lines.append(f"  {'status':<14} {detail}")
+    for provider in ("claude", "codex"):
+        modes: dict = {}
+        files = 0
+        for record in rows:
+            mode = record.get(f"{provider}_mode") or "not_observed"
+            modes[mode] = modes.get(mode, 0) + 1
+            files += max(0, int(record.get(f"{provider}_files") or 0))
+        mode_detail = " · ".join(
+            f"{mode} {count}" for mode, count in sorted(modes.items()))
+        lines.append(
+            f"  {provider:<14} {mode_detail} · files {files}")
     return lines
 
 
@@ -316,6 +358,23 @@ def render_dashboard_perf(payload: dict) -> str:
             f"over {len(builder)} tick(s)")
         lines.append(
             f"  whole tick     mean {_millis(_mean_or_none(duration))}")
+        cpu = [int(r.get("cpu_ns") or 0) for r in records]
+        lines.append(
+            f"  thread cpu     mean {_millis(_mean_or_none(cpu))}")
+        paired_cpu = [
+            (int(r.get("cpu_ns") or 0), int(r["period_ns"]))
+            for r in records
+            if r.get("cpu_ns") is not None
+            and r.get("period_ns") is not None
+            and int(r["period_ns"]) > 0
+        ]
+        if paired_cpu:
+            duty = sum(value for value, _period in paired_cpu) / sum(
+                period for _value, period in paired_cpu
+            )
+            lines.append(f"  cpu duty       {duty * 100:.1f}% of one core")
+        else:
+            lines.append("  cpu duty       no samples yet")
         # #583 S5 §2.4: the cache.db read pin, measured at its own BEGIN and
         # ROLLBACK boundaries. Reported separately from `builder` because it
         # is a SUBSET of builder time rather than a third exclusive half, and
@@ -331,6 +390,7 @@ def render_dashboard_perf(payload: dict) -> str:
             f"{'/cold' if newest.get('cold') else '/warm'} "
             f"ingest {_millis(newest.get('ingest_ns'))} "
             f"builder {_millis(newest.get('builder_ns'))} "
+            f"cpu {_millis(newest.get('cpu_ns'))} "
             f"pin {_millis(newest.get('cache_pin_ns', 0) or 0)} "
             f"total {_millis(newest.get('duration_ns'))}")
     else:
@@ -342,6 +402,15 @@ def render_dashboard_perf(payload: dict) -> str:
             f"total {_millis(standalone.get('duration_ns'))} "
             f"(the last build made outside a refresh tick)")
     lines.extend(_render_conversation_sync(tick))
+    combined = summarise_combined_background_duty(tick)
+    lines.extend(["", "Combined background work"])
+    if combined["combined"] is None:
+        lines.append("  duty           not jointly sampled")
+    else:
+        verdict = "within" if combined["withinCeiling"] else "over"
+        lines.append(
+            f"  duty           {combined['combined'] * 100:.1f}% of one core · "
+            f"ceiling {combined['ceiling'] * 100:.1f}% · {verdict}")
     lines.append("")
 
     counts = tick.get("dispatch_counts") or {}
@@ -359,6 +428,24 @@ def render_dashboard_perf(payload: dict) -> str:
     else:
         lines.append("Group A cache-open failures   none")
 
+    memory = payload.get("memory") or {}
+    if memory:
+        lines.append("")
+        lines.append("Retained process memory")
+        lines.append(
+            "  owned          "
+            f"{int(memory.get('ownerEstimatedBytes', 0)) / 1048576:.1f} MiB "
+            f"of {int(memory.get('ownerCeilingBytes', 0)) / 1048576:.1f} MiB")
+        lines.append(
+            "  process cap    "
+            f"{int(memory.get('processCeilingBytes', 0)) / 1048576:.0f} MiB")
+        for name, row in sorted((memory.get("owners") or {}).items()):
+            lines.append(
+                f"  {name:<22} "
+                f"{int(row.get('estimatedBytes', 0)) / 1048576:.1f}/"
+                f"{int(row.get('maxBytes', 0)) / 1048576:.1f} MiB · "
+                f"entries {int(row.get('entryCount', 0))}")
+
     applied = tracing.get("applied")
     requested = tracing.get("requested")
     applies_at = tracing.get("applies_at", "none")
@@ -374,6 +461,12 @@ def render_dashboard_perf(payload: dict) -> str:
     else:
         lines.append("  no phase tree stored — arm one with "
                      "`cctally dashboard-perf --trace on`")
+    if payload.get("ingest_phases") is not None:
+        ingest = payload["ingest_phases"]
+        lines.append(
+            f"  ingest tree {ingest.get('elapsed_ms', 0):.1f}ms, generated at "
+            f"{payload.get('ingest_generated_at')}"
+        )
     return "\n".join(lines) + "\n"