cctally 1.104.0 → 1.105.0

package/bin/_cctally_dashboard_conversation.py

@@ -42,6 +42,13 @@ import re
 import socket
 import sqlite3
 import sys
+import base64
+import collections
+import dataclasses
+import hashlib
+import secrets
+import threading
+import time
 
 from _cctally_cache import (
     open_cache_db,
@@ -51,7 +58,11 @@ from _cctally_cache import (
     sync_codex_conversations,
     _codex_provider_roots,
 )
-from _lib_dashboard_json import encode_dashboard_json
+from _lib_dashboard_json import (
+    encode_dashboard_json,
+    encode_dashboard_json_bytes_capped,
+)
+from _lib_retained_size import retained_size_bytes
 
 # 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).
@@ -61,6 +72,224 @@ _LIVE_TAIL_KEEPALIVE = 15.0         # idle keep-alive cadence (proxy guard)
 _LIVE_TAIL_FILE_RESET_EVERY = 10    # re-resolve the session file set every N cycles
 
 
+# #682 — progressive outline transport.  The canonical outline remains the
+# legacy endpoint body; an opt-in request gets a constant-size opaque transfer
+# ticket. The first bounded chunk request materializes the canonical body, so
+# the initial reader response never waits on or transfers the whole outline.
+# Keeping the cache process-local avoids a second durable transcript surface.
+_OUTLINE_TRANSFER_CHUNK = 192 * 1024
+_OUTLINE_TRANSFER_ITEM_CAP = 32 * 1024 * 1024
+_OUTLINE_TRANSFER_TOTAL_CAP = 64 * 1024 * 1024
+_OUTLINE_TRANSFER_COUNT_CAP = 128
+_OUTLINE_TRANSFER_TTL = 120.0
+_OUTLINE_TRANSFERS = collections.OrderedDict()
+_OUTLINE_TRANSFERS_BYTES = 0
+_OUTLINE_TRANSFERS_EVICTIONS = 0
+_OUTLINE_TRANSFERS_FALLBACKS = 0
+_OUTLINE_TRANSFERS_LOCK = threading.Lock()
+
+
+@dataclasses.dataclass
+class _OutlineTransferRecord:
+    created: float
+    builder: object
+    payload: bytes | None = None
+    digest: str | None = None
+    state: str = "pending"
+    cancelled: threading.Event = dataclasses.field(default_factory=threading.Event)
+    ready: threading.Event = dataclasses.field(default_factory=threading.Event)
+
+
+def _outline_transfer_estimated_bytes_locked() -> int:
+    return retained_size_bytes(
+        _OUTLINE_TRANSFERS, stop_after=_OUTLINE_TRANSFER_TOTAL_CAP)
+
+
+def outline_transfer_cache_stats():
+    with _OUTLINE_TRANSFERS_LOCK:
+        return {
+            "estimatedBytes": _outline_transfer_estimated_bytes_locked(),
+            "maxBytes": _OUTLINE_TRANSFER_TOTAL_CAP,
+            "payloadBytes": int(_OUTLINE_TRANSFERS_BYTES),
+            "entryCount": len(_OUTLINE_TRANSFERS),
+            "maxEntries": _OUTLINE_TRANSFER_COUNT_CAP,
+            "evictionCount": int(_OUTLINE_TRANSFERS_EVICTIONS),
+            "fallbackCount": int(_OUTLINE_TRANSFERS_FALLBACKS),
+        }
+
+
+def _drop_outline_transfer_locked(token):
+    """Remove one transfer and keep the materialized-byte count exact."""
+    global _OUTLINE_TRANSFERS_BYTES
+    record = _OUTLINE_TRANSFERS.pop(token, None)
+    if record is not None:
+        if record.payload is not None:
+            _OUTLINE_TRANSFERS_BYTES -= len(record.payload)
+        record.cancelled.set()
+        record.ready.set()
+    return record
+
+
+def _prune_outline_transfers_locked(now):
+    expired = [token for token, record in _OUTLINE_TRANSFERS.items()
+               if now - record.created > _OUTLINE_TRANSFER_TTL]
+    for token in expired:
+        _drop_outline_transfer_locked(token)
+
+
+def _store_outline_transfer(builder):
+    """Store a lazy canonical-body builder and return opaque metadata."""
+    global _OUTLINE_TRANSFERS_BYTES, _OUTLINE_TRANSFERS_EVICTIONS
+    now = time.monotonic()
+    token = secrets.token_urlsafe(24)
+    with _OUTLINE_TRANSFERS_LOCK:
+        _prune_outline_transfers_locked(now)
+        # A deterministic token factory in tests, or a vanishingly unlikely
+        # production collision, cancels the prior generation before replacement.
+        _drop_outline_transfer_locked(token)
+        _OUTLINE_TRANSFERS[token] = _OutlineTransferRecord(now, builder)
+        while _OUTLINE_TRANSFERS and (
+            len(_OUTLINE_TRANSFERS) > _OUTLINE_TRANSFER_COUNT_CAP
+            or _outline_transfer_estimated_bytes_locked()
+                > _OUTLINE_TRANSFER_TOTAL_CAP
+        ):
+            _drop_outline_transfer_locked(next(iter(_OUTLINE_TRANSFERS)))
+            _OUTLINE_TRANSFERS_EVICTIONS += 1
+    return {"token": token, "chunk_size": _OUTLINE_TRANSFER_CHUNK}
+
+
+def _claim_outline_transfer(token):
+    """Atomically claim a pending builder or join its in-flight generation."""
+    now = time.monotonic()
+    with _OUTLINE_TRANSFERS_LOCK:
+        _prune_outline_transfers_locked(now)
+        record = _OUTLINE_TRANSFERS.get(token)
+        if record is None:
+            return None
+        _OUTLINE_TRANSFERS.move_to_end(token)
+        if record.payload is not None:
+            return "ready", record, None
+        if record.state == "pending":
+            record.state = "building"
+            return "build", record, record.builder
+        return "wait", record, None
+
+
+def _outline_transfer_builder(token):
+    """Compatibility probe: claim one builder, ``False`` if joined/ready."""
+    claim = _claim_outline_transfer(token)
+    if claim is None:
+        return None
+    action, _record, builder = claim
+    return builder if action == "build" else False
+
+
+def _materialize_outline_transfer(token, payload, *, claim=None):
+    """Publish immutable canonical bytes into a still-live lazy transfer."""
+    global _OUTLINE_TRANSFERS_BYTES
+    global _OUTLINE_TRANSFERS_EVICTIONS, _OUTLINE_TRANSFERS_FALLBACKS
+    if len(payload) > _OUTLINE_TRANSFER_ITEM_CAP:
+        with _OUTLINE_TRANSFERS_LOCK:
+            current = _OUTLINE_TRANSFERS.get(token)
+            if current is not None and (claim is None or current is claim):
+                _drop_outline_transfer_locked(token)
+                _OUTLINE_TRANSFERS_FALLBACKS += 1
+        return "too_large"
+    now = time.monotonic()
+    digest = hashlib.sha256(payload).hexdigest()
+    with _OUTLINE_TRANSFERS_LOCK:
+        _prune_outline_transfers_locked(now)
+        record = _OUTLINE_TRANSFERS.get(token)
+        if record is None or (claim is not None and record is not claim):
+            return "expired"
+        if record.cancelled.is_set():
+            return "expired"
+        if record.payload is not None:
+            return "ready"
+        while (_OUTLINE_TRANSFERS and
+               _OUTLINE_TRANSFERS_BYTES + len(payload) > _OUTLINE_TRANSFER_TOTAL_CAP):
+            victim = next(
+                ((old_token, old_record)
+                 for old_token, old_record in _OUTLINE_TRANSFERS.items()
+                 if old_token != token),
+                None,
+            )
+            if victim is None:
+                break
+            old_token, _old_record = victim
+            _drop_outline_transfer_locked(old_token)
+            _OUTLINE_TRANSFERS_EVICTIONS += 1
+        record.payload = payload
+        record.digest = digest
+        record.builder = None
+        record.state = "ready"
+        _OUTLINE_TRANSFERS_BYTES += len(payload)
+        while (_OUTLINE_TRANSFERS
+               and _outline_transfer_estimated_bytes_locked()
+               > _OUTLINE_TRANSFER_TOTAL_CAP):
+            victim = next(
+                (old_token for old_token in _OUTLINE_TRANSFERS
+                 if old_token != token),
+                None,
+            )
+            if victim is None:
+                _drop_outline_transfer_locked(token)
+                _OUTLINE_TRANSFERS_FALLBACKS += 1
+                return "too_large"
+            _drop_outline_transfer_locked(victim)
+            _OUTLINE_TRANSFERS_EVICTIONS += 1
+        record.ready.set()
+    return "ready"
+
+
+def _cancel_outline_transfer(token, *, claim=None) -> bool:
+    """Cancel one exact transfer generation and wake every joined reader."""
+    with _OUTLINE_TRANSFERS_LOCK:
+        current = _OUTLINE_TRANSFERS.get(token)
+        if current is None or (claim is not None and current is not claim):
+            return False
+        _drop_outline_transfer_locked(token)
+        return True
+
+
+def _reject_outline_transfer_too_large(token, *, claim) -> bool:
+    """Drop one exact over-cap generation without allocating a sentinel body."""
+    global _OUTLINE_TRANSFERS_FALLBACKS
+    with _OUTLINE_TRANSFERS_LOCK:
+        current = _OUTLINE_TRANSFERS.get(token)
+        if current is None or current is not claim:
+            return False
+        _drop_outline_transfer_locked(token)
+        _OUTLINE_TRANSFERS_FALLBACKS += 1
+        return True
+
+
+def _read_outline_transfer(token, offset):
+    """Return one immutable chunk, or ``None`` when the token is gone."""
+    now = time.monotonic()
+    with _OUTLINE_TRANSFERS_LOCK:
+        _prune_outline_transfers_locked(now)
+        record = _OUTLINE_TRANSFERS.get(token)
+        if record is None:
+            return None
+        payload, digest = record.payload, record.digest
+        _OUTLINE_TRANSFERS.move_to_end(token)
+    if payload is None:
+        return None
+    if offset < 0 or offset > len(payload):
+        raise ValueError("offset out of range")
+    chunk = payload[offset:offset + _OUTLINE_TRANSFER_CHUNK]
+    next_offset = offset + len(chunk)
+    return {
+        "offset": offset,
+        "next_offset": next_offset,
+        "total": len(payload),
+        "sha256": digest,
+        "done": next_offset == len(payload),
+        "chunk": base64.b64encode(chunk).decode("ascii"),
+    }
+
+
 # Module-local forwarders for the two generic query-string helpers that STAY
 # in the dashboard (24 call sites in the moved handlers; the dashboard is fully
 # loaded before any handler runs, so the call-time reach is cycle-free).
@@ -450,7 +679,9 @@ def _parse_search_kind_impl(handler, q, valid=_CONV_SEARCH_KINDS):
         return None
     return kind
 
-def _run_conversation_query_impl(handler, kernel_call, log_label):
+def _run_conversation_query_impl(
+    handler, kernel_call, log_label, *, cancelled=None,
+):
     """Open conversations.db, run ``kernel_call(conn)``, close.
 
     Collapses the triplicated open-store → try/except/finally → 500
@@ -487,12 +718,25 @@ def _run_conversation_query_impl(handler, kernel_call, log_label):
                 handler._respond_json(400, {"error": "invalid account"})
                 return False, None
             scope_conversations_db_to_account(conn, account_vals[0])
+        if cancelled is not None:
+            conn.set_progress_handler(lambda: 1 if cancelled() else 0, 1000)
+            if cancelled():
+                return None, None
         body = kernel_call(conn)
+        if cancelled is not None and cancelled():
+            return None, None
     except Exception as exc:  # noqa: BLE001
+        if cancelled is not None and cancelled():
+            return None, None
         handler.log_error("%s failed: %r", log_label, exc)
         handler._respond_json(500, {"error": f"{type(exc).__name__}: {exc}"})
         return False, None
     finally:
+        if cancelled is not None:
+            try:
+                conn.set_progress_handler(None, 0)
+            except sqlite3.Error:
+                pass
         conn.close()
     return True, body
 
@@ -1261,6 +1505,12 @@ def _handle_get_conversation_outline_impl(handler, path: str) -> None:
     if not handler._require_transcripts_allowed():
         return
     import urllib.parse as _u
+    query = _u.parse_qs(_u.urlsplit(handler.path).query, keep_blank_values=True)
+    progressive_values = query.get("progressive")
+    if progressive_values is not None and progressive_values != ["1"]:
+        handler._respond_json(400, {"error": "invalid progressive param"})
+        return
+    progressive = progressive_values == ["1"]
     session_id = _u.unquote(path[len("/api/conversation/"):-len("/outline")])
     if not session_id:
         handler.send_error(404, "conversation not found")
@@ -1268,11 +1518,75 @@ def _handle_get_conversation_outline_impl(handler, path: str) -> None:
     if session_id.startswith("v1."):
         speed = _resolve_effective_speed()
         disp = _conversation_dispatch()
-        _serve_qualified_entity(
-            handler,
-            lambda conn: disp.neutral_outline(
-                conn, session_id, effective_speed=speed),
+        if not progressive:
+            ok, body = handler._run_conversation_query(
+                lambda conn: disp.neutral_outline(
+                    conn, session_id, effective_speed=speed),
+                "/api/conversation/outline")
+            if not ok:
+                return
+            _respond_qualified_json(handler, body)
+            return
+        ok, preflight = handler._run_conversation_query(
+            lambda conn: disp.neutral_events_preflight(conn, session_id),
             "/api/conversation/outline")
+        if not ok:
+            return
+        if (preflight or {}).get("status") != "ok":
+            _respond_qualified_json(handler, preflight)
+            return
+        account_values = query.get("account")
+        account_key = account_values[0] if account_values else None
+
+        def _build_qualified(transfer_handler, cancelled):
+            def _query(conn):
+                if account_key is not None:
+                    scope_conversations_db_to_account(conn, account_key)
+                return disp.neutral_outline(
+                    conn, session_id, effective_speed=speed)
+            return _run_conversation_query_impl(
+                transfer_handler,
+                _query,
+                "/api/conversation/outline-transfer",
+                cancelled=cancelled,
+            )
+
+        handler._respond_json(200, {
+            "progressive": 1,
+            "transfer": _store_outline_transfer(_build_qualified),
+        })
+        return
+    if progressive:
+        ok, exists = handler._run_conversation_query(
+            lambda conn: conn.execute(
+                "SELECT 1 FROM conversation_messages WHERE session_id=? LIMIT 1",
+                (session_id,),
+            ).fetchone() is not None,
+            "/api/conversation/outline")
+        if not ok:
+            return
+        if not exists:
+            handler.send_error(404, "conversation not found")
+            return
+
+        def _build_bare(transfer_handler, cancelled):
+            def _query(conn):
+                account_values = query.get("account")
+                if account_values:
+                    scope_conversations_db_to_account(conn, account_values[0])
+                return transfer_handler._conversation_query(
+                ).get_conversation_outline(conn, session_id)
+            return _run_conversation_query_impl(
+                transfer_handler,
+                _query,
+                "/api/conversation/outline-transfer",
+                cancelled=cancelled,
+            )
+
+        handler._respond_json(200, {
+            "progressive": 1,
+            "transfer": _store_outline_transfer(_build_bare),
+        })
         return
     ok, body = handler._run_conversation_query(
         lambda conn: handler._conversation_query().get_conversation_outline(conn, session_id),
@@ -1284,6 +1598,86 @@ def _handle_get_conversation_outline_impl(handler, path: str) -> None:
         return
     handler._respond_json(200, body)
 
+
+def _handle_get_conversation_outline_transfer_impl(handler, path: str) -> None:
+    """Serve one bounded chunk from an opaque, immutable outline transfer."""
+    if not handler._require_transcripts_allowed():
+        return
+    import urllib.parse as _u
+    token = _u.unquote(path[len("/api/conversation/outline-transfer/"):])
+    if not token or not re.fullmatch(r"[A-Za-z0-9_-]+", token):
+        handler._respond_json(410, {"error": "outline transfer expired"})
+        return
+    parsed = _u.parse_qs(_u.urlsplit(handler.path).query, keep_blank_values=True)
+    values = parsed.get("offset")
+    if values is None:
+        offset = 0
+    elif len(values) != 1 or not values[0].isascii() or not values[0].isdigit():
+        handler._respond_json(400, {"error": "invalid offset"})
+        return
+    else:
+        offset = int(values[0])
+    claim = _claim_outline_transfer(token)
+    if claim is None:
+        handler._respond_json(410, {"error": "outline transfer expired"})
+        return
+    action, record, builder = claim
+    if action == "build":
+        ok, full_body = builder(handler, record.cancelled.is_set)
+        if ok is None:
+            handler._respond_json(410, {"error": "outline transfer expired"})
+            return
+        if not ok:
+            _cancel_outline_transfer(token, claim=record)
+            return
+        if full_body is None:
+            _cancel_outline_transfer(token, claim=record)
+            handler._respond_json(410, {"error": "outline transfer expired"})
+            return
+        payload = encode_dashboard_json_bytes_capped(
+            full_body, max_bytes=_OUTLINE_TRANSFER_ITEM_CAP)
+        if payload is None:
+            _reject_outline_transfer_too_large(token, claim=record)
+            state = "too_large"
+        else:
+            state = _materialize_outline_transfer(token, payload, claim=record)
+        if state == "too_large":
+            handler._respond_json(
+                413, {"error": "outline exceeds progressive transfer limit"})
+            return
+        if state == "expired":
+            handler._respond_json(410, {"error": "outline transfer expired"})
+            return
+    elif action == "wait":
+        record.ready.wait(_OUTLINE_TRANSFER_TTL)
+        if record.cancelled.is_set() or record.payload is None:
+            handler._respond_json(410, {"error": "outline transfer expired"})
+            return
+    try:
+        body = _read_outline_transfer(token, offset)
+    except ValueError:
+        handler._respond_json(400, {"error": "offset out of range"})
+        return
+    if body is None:
+        handler._respond_json(410, {"error": "outline transfer expired"})
+        return
+    handler._respond_json(200, body)
+
+
+def _handle_delete_conversation_outline_transfer_impl(handler, path: str) -> None:
+    """Best-effort cancellation for a browser-abandoned progressive token."""
+    if not handler._require_transcripts_allowed():
+        return
+    import urllib.parse as _u
+    token = _u.unquote(path[len("/api/conversation/outline-transfer/"):])
+    if not token or not re.fullmatch(r"[A-Za-z0-9_-]+", token):
+        handler._respond_json(400, {"error": "invalid outline transfer token"})
+        return
+    _cancel_outline_transfer(token)
+    handler.send_response(204)
+    handler.send_header("Content-Length", "0")
+    handler.end_headers()
+
 def _handle_get_conversation_prompts_impl(handler, path: str) -> None:
     """``GET /api/conversation/<sid>/prompts`` — ordered main-thread human
     prompts + full text (#217 S7 F10, the session-comparison spine). Same

package/bin/_cctally_dashboard_envelope.py

@@ -1213,6 +1213,22 @@ def _cause_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.
 
@@ -1276,6 +1292,7 @@ def _forecast_quota_envelope(fc, cw, rate_change):
         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

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"