cctally 1.9.0 → 1.10.0

package/bin/_cctally_tui.py

@@ -1061,6 +1061,16 @@ class DataSnapshot:
     # through ``_tui_build_snapshot``; the envelope adapter falls
     # back to the legacy inline routing in that case.
     forecast_view: Any | None = None
+    # Projects panel + modal envelope block (spec §5.2 /
+    # 2026-05-19-projects-panel-design.md). Populated on the sync
+    # thread by ``_build_projects_envelope`` (per-tick DB-touching
+    # aggregation that runs alongside the existing per-panel builds);
+    # the dashboard's pure ``snapshot_to_envelope`` reads this back
+    # unchanged and assigns it to ``envelope["projects"]``. ``None``
+    # on first tick before sync completes — the TS envelope mirror
+    # declares ``ProjectsEnvelope | null`` and the client renders the
+    # panel-empty state until the next tick replaces it.
+    projects_envelope: dict | None = None
 
     @classmethod
     def synthesize_for_marketing(cls, *, as_of_iso: str) -> "DataSnapshot":
@@ -1612,6 +1622,95 @@ class TuiSessionDetail:
     cost_total_usd: float
 
 
+def _tui_build_session_detail_indexed(
+    session_id: str,
+    range_start: dt.datetime,
+    range_end: dt.datetime,
+) -> Any | None:
+    """Indexed direct lookup for one session by id.
+
+    Walks ``session_files`` (indexed by ``session_id`` — migration
+    ``idx_session_files_session_id``) for the 1-3 source_paths the
+    session lives in, then fetches ONLY the entries from those paths
+    in the supplied range. Aggregates the filtered list and returns
+    the single matching ``ClaudeSessionUsage`` row.
+
+    Returns ``None`` on three indistinguishable misses (the caller's
+    fallback path handles them all):
+
+    1. session_files row hasn't been backfilled yet for this id
+       (CLAUDE.md "session_files is populated lazily" — first run
+       after deploy).
+    2. cache DB unavailable (open / lock contention).
+    3. session_id is genuinely unknown.
+
+    Falling back uniformly preserves correctness without distinguishing
+    the cases; if the slow path also misses, the modal renders 404.
+    """
+    c = _cctally()
+    open_cache_db = c.open_cache_db
+    _JoinedClaudeEntry = c._JoinedClaudeEntry
+    try:
+        conn = open_cache_db()
+    except (sqlite3.DatabaseError, OSError):
+        return None
+    try:
+        # 1) Source paths for this session id (indexed lookup).
+        rows = conn.execute(
+            "SELECT path FROM session_files WHERE session_id = ?",
+            (session_id,),
+        ).fetchall()
+        if not rows:
+            return None
+        paths = [r[0] for r in rows]
+        # 2) Entries restricted to those paths in the range. Typical
+        # path-count is 1-3 (resume across files), well below SQLite's
+        # 999 parameter cap.
+        start_iso = range_start.astimezone(dt.timezone.utc).isoformat()
+        end_iso = range_end.astimezone(dt.timezone.utc).isoformat()
+        placeholders = ",".join("?" * len(paths))
+        cur = conn.execute(
+            f"SELECT se.timestamp_utc, se.model, "
+            f"  se.input_tokens, se.output_tokens, "
+            f"  se.cache_create_tokens, se.cache_read_tokens, "
+            f"  se.source_path, sf.session_id, sf.project_path, "
+            f"  se.cost_usd_raw "
+            f"FROM session_entries se "
+            f"LEFT JOIN session_files sf ON sf.path = se.source_path "
+            f"WHERE se.timestamp_utc >= ? AND se.timestamp_utc <= ? "
+            f"  AND se.source_path IN ({placeholders}) "
+            f"ORDER BY se.timestamp_utc ASC",
+            [start_iso, end_iso, *paths],
+        )
+        entries = [
+            _JoinedClaudeEntry(
+                timestamp=dt.datetime.fromisoformat(row[0]),
+                model=row[1],
+                input_tokens=row[2],
+                output_tokens=row[3],
+                cache_creation_tokens=row[4],
+                cache_read_tokens=row[5],
+                source_path=row[6],
+                session_id=row[7],
+                project_path=row[8],
+                cost_usd=row[9],
+            )
+            for row in cur
+        ]
+        if not entries:
+            return None
+        sessions = _aggregate_claude_sessions(entries)
+        for s in sessions:
+            if s.session_id == session_id:
+                return s
+        return None
+    finally:
+        try:
+            conn.close()
+        except sqlite3.Error:
+            pass
+
+
 def _tui_build_session_detail(
     session_id: str,
     *,
@@ -1619,19 +1718,34 @@ def _tui_build_session_detail(
 ) -> TuiSessionDetail | None:
     """Look up one session by ID; return None if not found.
 
-    Reuses the same `get_claude_session_entries` + `_aggregate_claude_sessions`
-    pipeline as `_tui_build_sessions` but filters down to the matching ID.
-    Bounded scan window matches the panel builder (365 days).
+    Fast path: ``_tui_build_session_detail_indexed`` reads
+    ``session_files`` by id, scopes the entries SELECT to the matching
+    source_paths, and aggregates only those rows — turning the lookup
+    from "build every session in 365 days" into an indexed direct
+    fetch (~3000× fewer rows on real DBs).
+
+    Slow-path fallback: when the indexed lookup misses (session_files
+    not yet backfilled, cache unavailable, or genuinely unknown), the
+    legacy bulk-fetch + linear scan still runs so the modal renders
+    consistently with the panel's session list during the lazy-
+    backfill window.
     """
     now_utc = now_utc or dt.datetime.now(dt.timezone.utc)
     range_start = now_utc - dt.timedelta(days=365)
-    entries = get_claude_session_entries(range_start, now_utc, skip_sync=True)
-    sessions = _aggregate_claude_sessions(entries)
-    match: Any | None = None
-    for s in sessions:
-        if s.session_id == session_id:
-            match = s
-            break
+    match: Any | None = _tui_build_session_detail_indexed(
+        session_id, range_start, now_utc,
+    )
+    if match is None:
+        # Fall back to the bulk-aggregate path. Same shape as before,
+        # used only when the index lookup couldn't conclude.
+        entries = get_claude_session_entries(
+            range_start, now_utc, skip_sync=True,
+        )
+        sessions = _aggregate_claude_sessions(entries)
+        for s in sessions:
+            if s.session_id == session_id:
+                match = s
+                break
     if match is None:
         return None
     duration_min = (match.last_activity - match.first_activity).total_seconds() / 60.0
@@ -1896,6 +2010,109 @@ def _tui_build_snapshot(
             fh_milestones = _tui_build_five_hour_milestones(conn, win_key)
         except Exception as exc:
             errors.append(f"five-hour-milestones: {exc}")
+        # ---- Projects panel + modal envelope (spec §5.2, plan Task 1) -----
+        # Per-tick aggregation lives on the sync thread; the dashboard's
+        # pure ``snapshot_to_envelope`` reads ``snap.projects_envelope``
+        # back unchanged. Errors are recorded on ``last_sync_error`` —
+        # the client renders the panel-empty state when the field is
+        # None (first tick, or sub-build failure).
+        #
+        # ATTACH cache.db onto the open stats conn so
+        # ``_build_projects_envelope`` (which reads ``session_entries`` +
+        # ``session_files`` + ``weekly_usage_snapshots`` off one conn —
+        # the test contract per tests/test_projects_envelope.py) sees
+        # all three tables. ATTACH/DETACH is cheap and scoped to this
+        # sub-build; no schema migration / lock acquisition is needed.
+        projects_envelope_block: dict | None = None
+        try:
+            c = _cctally()
+            cache_db_path = c.CACHE_DB_PATH
+            conn.execute(
+                "ATTACH DATABASE ? AS cache_db",
+                (str(cache_db_path),),
+            )
+            # session_entries / session_files live in cache.db; the
+            # builder reads them via raw SQL keyed by the unqualified
+            # table names. SQLite's name resolution prefers the `main`
+            # schema, so create temporary views in `main` that point
+            # at the attached schema's tables. Aliasing via VIEWs keeps
+            # the builder portable: unit tests pass one conn carrying
+            # both schemas; production wiring uses an attached cache.
+            conn.execute(
+                "CREATE TEMP VIEW IF NOT EXISTS session_entries AS "
+                "SELECT * FROM cache_db.session_entries"
+            )
+            conn.execute(
+                "CREATE TEMP VIEW IF NOT EXISTS session_files AS "
+                "SELECT * FROM cache_db.session_files"
+            )
+            projects_envelope_block = c._build_projects_envelope(
+                conn,
+                now_utc=now_utc,
+                current_week=cw,
+                weeks_back=12,
+            )
+        except Exception as exc:
+            errors.append(f"projects-envelope: {exc}")
+        finally:
+            try:
+                conn.execute("DROP VIEW IF EXISTS session_entries")
+                conn.execute("DROP VIEW IF EXISTS session_files")
+            except Exception:
+                pass
+            try:
+                conn.execute("DETACH DATABASE cache_db")
+            except Exception:
+                pass
+        # Late-bind disambiguated `project_key` onto each SessionsPanel
+        # row so the SessionsPanel → ProjectsModal cross-nav (spec §4.1)
+        # routes by the same identity the Projects envelope emits.
+        # Cheap dict-lookup per row; no second aggregation pass.
+        #
+        # `key_by_bucket_path` is indexed by git-root bucket_path (the
+        # envelope builder calls `_resolve_project_key(..., "git-root")`
+        # in `_build_projects_envelope`), but `srow.project_path` is the
+        # raw cwd from `_aggregate_claude_sessions` — typically a
+        # subdirectory of the repo root for monorepo sessions. We must
+        # resolve each cwd through the same production resolver so the
+        # lookup hits; otherwise `project_key` stays None and the
+        # cross-nav button degrades to plain text.
+        if projects_envelope_block is not None:
+            try:
+                key_by_bucket_path: dict[str, str] = {}
+                for r in projects_envelope_block.get(
+                    "current_week", {}
+                ).get("rows", []):
+                    bp = r.get("bucket_path")
+                    k = r.get("key")
+                    if bp and k:
+                        key_by_bucket_path[bp] = k
+                for r in projects_envelope_block.get(
+                    "trend", {}
+                ).get("projects", []):
+                    bp = r.get("bucket_path")
+                    k = r.get("key")
+                    if bp and k and bp not in key_by_bucket_path:
+                        key_by_bucket_path[bp] = k
+                _resolve = _cctally()._resolve_project_key
+                resolver_cache: dict = {}
+                annotated: list[TuiSessionRow] = []
+                for srow in sessions:
+                    pkey = None
+                    if srow.project_path:
+                        bp = _resolve(
+                            srow.project_path, "git-root", resolver_cache,
+                        ).bucket_path
+                        pkey = key_by_bucket_path.get(bp)
+                    if pkey is None:
+                        annotated.append(srow)
+                    else:
+                        annotated.append(
+                            dataclasses.replace(srow, project_key=pkey)
+                        )
+                sessions = annotated
+            except Exception as exc:
+                errors.append(f"projects-cross-nav-bind: {exc}")
         return DataSnapshot(
             current_week=cw,
             forecast=fc,
@@ -1923,6 +2140,7 @@ def _tui_build_snapshot(
             trend_avg_dollars_per_pct=trend_avg_dpp,
             trend_history_median_dpp=history_median_dpp,
             forecast_view=fc_view,
+            projects_envelope=projects_envelope_block,
         )
     finally:
         conn.close()

package/bin/_lib_share_templates.py

@@ -37,6 +37,9 @@ SHARE_CAPABLE_PANELS: frozenset[str] = frozenset({
     "blocks",
     "forecast",
     "sessions",
+    # Projects panel + modal (spec 2026-05-19-projects-panel-design.md).
+    # 9th share-capable panel — three templates land in this module.
+    "projects",
 })
 
 
@@ -1552,6 +1555,176 @@ def _build_sessions_detail(*, panel_data, options):
     )
 
 
+# --- Projects panel + modal builders (spec §7.6) ---
+#
+# The three Projects-panel templates share a single internal kernel so
+# the table / chart / KPI layout stays consistent across archetypes:
+# only the "what's emphasized" shape differs (recap = top-N table,
+# visual = chart-forward, detail = full table + chart). All three
+# consume `panel_data` from `_build_projects_share_panel_data` in
+# `bin/_cctally_dashboard.py`, NOT `_build_project_snapshot` directly —
+# that kernel takes `ProjectKey` objects, but the dashboard envelope
+# emits already-disambiguated string `key`s. Both paths end up at the
+# same column shape: `Project | $ Cost | % Used | Sessions`.
+
+_PROJECTS_TABLE_COLUMNS = (
+    _LS.ColumnSpec(key="project", label="Project", align="left"),
+    _LS.ColumnSpec(key="cost",    label="$ Cost",  align="right", emphasis=True),
+    _LS.ColumnSpec(key="used",    label="% Used",  align="right"),
+    _LS.ColumnSpec(key="sessions", label="Sessions", align="right"),
+)
+
+
+def _projects_rows_for_template(rows: list[dict], cap: int) -> tuple:
+    """Build `Row` tuple for the Projects table from the dashboard
+    panel_data row shape.
+
+    `rows` is a list of dicts {key, bucket_path, cost_usd,
+    attributed_pct, sessions_count} (post-disambiguation, sorted by
+    caller). `cap` truncates to top-N by caller order. Mirrors
+    `_build_project_snapshot`'s row layout in bin/cctally:11774 but
+    with string keys (no ProjectKey objects).
+    """
+    out: list = []
+    for r in (rows or [])[:cap]:
+        attr = r.get("attributed_pct")
+        out.append(_LS.Row(cells={
+            "project":  _LS.ProjectCell(label=str(r["key"])),
+            "cost":     _LS.MoneyCell(usd=float(r["cost_usd"])),
+            "used":     (
+                _LS.PercentCell(float(attr)) if attr is not None
+                else _LS.TextCell("—")
+            ),
+            "sessions": _LS.TextCell(str(int(r.get("sessions_count", 0) or 0))),
+        }))
+    return tuple(out)
+
+
+def _projects_chart_for_template(rows: list[dict], cap: int):
+    """Build the HorizontalBarChart for the Projects share artifact.
+    Cap=12 mirrors `_build_project_snapshot` (bin/cctally:11813).
+    """
+    if not rows:
+        return None
+    points = []
+    for r in rows[:cap]:
+        label = str(r["key"])
+        cost = float(r["cost_usd"])
+        points.append(_LS.ChartPoint(
+            x_label=label,
+            x_value=cost,
+            y_value=cost,
+            project_label=label,
+        ))
+    return _LS.HorizontalBarChart(
+        points=tuple(points), x_label="$", cap=cap,
+    )
+
+
+def _projects_period(panel_data: dict, options: dict):
+    start = panel_data["period_start"]
+    end = panel_data["period_end"]
+    weeks = int(panel_data.get("window_weeks", 1) or 1)
+    label = "This week" if weeks == 1 else f"Last {weeks} weeks"
+    return _period(start, end, label=label,
+                   display_tz=_display_tz(options))
+
+
+def _projects_subtitle(options: dict, total_rows: int) -> str:
+    reveal = options.get("reveal_projects", True)
+    return " · ".join([
+        f"{total_rows} project{'' if total_rows == 1 else 's'}",
+        "real projects" if reveal else "projects anonymized",
+    ])
+
+
+def _build_projects_recap(*, panel_data, options):
+    """Projects recap — top-N table + KPI strip + HBar chart.
+
+    Mirrors `weekly-recap`'s balanced shape (table + chart + KPIs).
+    Top-N defaults to 5 (matches the panel's top-5 rows from spec §2.3).
+    """
+    rows = panel_data.get("rows") or []
+    cap = int(options.get("top_n", 5))
+    total = float(panel_data.get("total_cost_usd", 0.0) or 0.0)
+    return _LS.ShareSnapshot(
+        cmd="projects",
+        title=f"Projects recap — top {min(cap, len(rows))}",
+        subtitle=_projects_subtitle(options, len(rows)),
+        period=_projects_period(panel_data, options),
+        columns=_PROJECTS_TABLE_COLUMNS,
+        rows=_projects_rows_for_template(rows, cap),
+        chart=_projects_chart_for_template(rows, cap=12),
+        totals=_kpi_strip(
+            ("$ spent", f"${total:,.2f}"),
+            ("Projects", str(len(rows))),
+        ),
+        notes=(),
+        generated_at=_utc_now(),
+        version=_release_version(),
+    )
+
+
+def _build_projects_visual(*, panel_data, options):
+    """Projects visual — chart-forward HBar of top-12 projects by cost.
+
+    Mirrors `weekly-visual` / `current-week-visual` — chart-led, no
+    table. Spec §7.6 routes the visual archetype to a HorizontalBarChart
+    of the top-12 projects.
+    """
+    rows = panel_data.get("rows") or []
+    cap_chart = 12
+    total = float(panel_data.get("total_cost_usd", 0.0) or 0.0)
+    return _LS.ShareSnapshot(
+        cmd="projects",
+        title=f"Projects — top {min(cap_chart, len(rows))} by cost",
+        subtitle=_projects_subtitle(options, len(rows)),
+        period=_projects_period(panel_data, options),
+        columns=_PROJECTS_TABLE_COLUMNS,
+        rows=(),                                  # visual archetype: empty table
+        chart=_projects_chart_for_template(rows, cap=cap_chart),
+        totals=_kpi_strip(
+            ("$ spent", f"${total:,.2f}"),
+            ("Projects", str(len(rows))),
+        ),
+        notes=(),
+        generated_at=_utc_now(),
+        version=_release_version(),
+    )
+
+
+def _build_projects_detail(*, panel_data, options):
+    """Projects detail — full table + chart. Closest fit to today's CLI
+    `cctally project --format` output (spec §7.6 routes detail here).
+
+    Default top_n=50 means "all rows" for typical caches.
+    """
+    rows = panel_data.get("rows") or []
+    cap = int(options.get("top_n", 50))
+    total = float(panel_data.get("total_cost_usd", 0.0) or 0.0)
+    notes: tuple[str, ...] = ()
+    if len(rows) > 12:
+        notes = (
+            f"Showing top 12 in chart; table includes all {len(rows)}.",
+        )
+    return _LS.ShareSnapshot(
+        cmd="projects",
+        title=f"Projects detail — {len(rows)} project{'' if len(rows) == 1 else 's'}",
+        subtitle=_projects_subtitle(options, len(rows)),
+        period=_projects_period(panel_data, options),
+        columns=_PROJECTS_TABLE_COLUMNS,
+        rows=_projects_rows_for_template(rows, cap),
+        chart=_projects_chart_for_template(rows, cap=12),
+        totals=_kpi_strip(
+            ("$ spent",  f"${total:,.2f}"),
+            ("Projects", str(len(rows))),
+        ),
+        notes=notes,
+        generated_at=_utc_now(),
+        version=_release_version(),
+    )
+
+
 # --- Register Recap templates ---
 
 _RECAP = (
@@ -1587,6 +1760,11 @@ _RECAP = (
                   description="Top-N sessions table + total",
                   default_options={"top_n": 15, "show_chart": False, "show_table": True},
                   builder=_build_sessions_recap),
+    # Projects panel + modal (spec §7.6).
+    ShareTemplate(id="projects-recap", panel="projects", label="Recap",
+                  description="Top-N projects table + total + HBar chart",
+                  default_options={"top_n": 5, "show_chart": True, "show_table": True},
+                  builder=_build_projects_recap),
 )
 
 SHARE_TEMPLATES = SHARE_TEMPLATES + _RECAP
@@ -1627,6 +1805,11 @@ _VISUAL = (
                   description="Horizontal bar of top-N sessions by cost",
                   default_options={"top_n": 8, "show_chart": True, "show_table": False},
                   builder=_build_sessions_visual),
+    # Projects panel + modal (spec §7.6).
+    ShareTemplate(id="projects-visual", panel="projects", label="Visual",
+                  description="Chart-forward HBar of top-12 projects by cost",
+                  default_options={"top_n": 12, "show_chart": True, "show_table": False},
+                  builder=_build_projects_visual),
 )
 
 
@@ -1665,6 +1848,13 @@ _DETAIL = (
                   description="Top-50 sessions with full columns",
                   default_options={"top_n": 50, "show_chart": False, "show_table": True},
                   builder=_build_sessions_detail),
+    # Projects panel + modal (spec §7.6). Default top_n=50 means "all
+    # rows" for typical caches; matches today's CLI `cctally project
+    # --format` table shape.
+    ShareTemplate(id="projects-detail", panel="projects", label="Detail",
+                  description="Full projects table + HBar chart (top-12)",
+                  default_options={"top_n": 50, "show_chart": True, "show_table": True},
+                  builder=_build_projects_detail),
 )
 
 SHARE_TEMPLATES = SHARE_TEMPLATES + _VISUAL + _DETAIL

package/bin/_lib_view_models.py

@@ -243,6 +243,20 @@ class TuiSessionRow:
     cache_hit_pct: float | None
     project_label: str           # basename of project_path
     session_id: str              # full session UUID (v2: needed for session-detail modal)
+    # Disambiguated display key (matches the Projects panel envelope's
+    # `current_week.rows[].key` / `trend.projects[].key`). Populated by
+    # the sync-thread builder after `_build_projects_envelope` runs so
+    # the SessionsPanel → ProjectsModal cross-nav (spec §4.1) routes by
+    # a stable identity. Defaults to ``None`` for fixture modules that
+    # construct ``TuiSessionRow`` positionally without the Bundle 6 /
+    # projects-panel additions; the client renders the cell as plain
+    # text in that case per spec §4.1 stopgap.
+    project_key: str | None = None
+    # Absolute project_path (NULL ⇒ ``(unknown)`` resolved upstream).
+    # Carried so the sync-thread builder can compute ``project_key``
+    # without re-reading ``session_files`` and so the share path can
+    # privacy-scrub via ``_lib_share._scrub``.
+    project_path: str | None = None
 
 
 # === Internal helpers ======================================================
@@ -1066,6 +1080,12 @@ def build_sessions_view(entries, *, now_utc, limit=None, display_tz=None):
                 _os.path.basename(s.project_path) or s.project_path
             ),
             session_id=s.session_id,
+            # `project_key` is populated downstream by `_tui_build_snapshot`
+            # after `_build_projects_envelope` runs (so the disambiguated
+            # display_key matches the Projects envelope exactly). Stash
+            # the absolute path here so that pass can map back without
+            # re-reading session_files.
+            project_path=s.project_path or None,
         ))
         total_cost += s.cost_usd
 

package/bin/cctally

@@ -766,6 +766,7 @@ _build_monthly_share_panel_data = _cctally_dashboard._build_monthly_share_panel_
 _build_forecast_share_panel_data = _cctally_dashboard._build_forecast_share_panel_data
 _build_blocks_share_panel_data = _cctally_dashboard._build_blocks_share_panel_data
 _build_sessions_share_panel_data = _cctally_dashboard._build_sessions_share_panel_data
+_build_projects_share_panel_data = _cctally_dashboard._build_projects_share_panel_data
 _SnapshotRef = _cctally_dashboard._SnapshotRef
 SSEHub = _cctally_dashboard.SSEHub
 STATIC_DIR = _cctally_dashboard.STATIC_DIR
@@ -781,6 +782,13 @@ _dashboard_build_blocks_view = _cctally_dashboard._dashboard_build_blocks_view
 _dashboard_build_daily_panel = _cctally_dashboard._dashboard_build_daily_panel
 _empty_dashboard_snapshot = _cctally_dashboard._empty_dashboard_snapshot
 _iso_z = _cctally_dashboard._iso_z
+# Projects panel + modal (spec 2026-05-19-projects-panel-design.md).
+# Re-export so the sync-thread builder at `_cctally_tui._tui_build_snapshot`
+# can reach the dashboard sibling's aggregator via `c = _cctally()`.
+_build_projects_envelope = _cctally_dashboard._build_projects_envelope
+_projects_reset_memo = _cctally_dashboard._projects_reset_memo
+_project_detail_for_window = _cctally_dashboard._project_detail_for_window
+_handle_get_project_detail_impl = _cctally_dashboard._handle_get_project_detail_impl
 _select_current_block_for_envelope = _cctally_dashboard._select_current_block_for_envelope
 _build_alerts_envelope_array = _cctally_dashboard._build_alerts_envelope_array
 snapshot_to_envelope = _cctally_dashboard.snapshot_to_envelope
@@ -12442,6 +12450,7 @@ _tui_build_trend = _cctally_tui._tui_build_trend
 _tui_build_weekly_history = _cctally_tui._tui_build_weekly_history
 _tui_build_sessions = _cctally_tui._tui_build_sessions
 _tui_build_session_detail = _cctally_tui._tui_build_session_detail
+_tui_build_session_detail_indexed = _cctally_tui._tui_build_session_detail_indexed
 _tui_build_snapshot = _cctally_tui._tui_build_snapshot
 _tui_empty_snapshot = _cctally_tui._tui_empty_snapshot
 # Key reader + dispatcher + sync thread base class