cctally 1.8.1 → 1.9.0

package/bin/_cctally_setup.py

@@ -242,10 +242,22 @@ def _setup_local_bin_dir() -> pathlib.Path:
 @dataclasses.dataclass
 class _SetupSymlinkResult:
     name: str
-    status: str   # "created" | "already" | "replaced" | "failed"
+    status: str   # "created" | "already" | "replaced" | "failed" | "removed-stale"
     detail: str = ""
 
 
+# Symlink names cctally USED to install but no longer does. We keep
+# cleaning them up for one major-version's worth of upgraders so
+# `~/.local/bin/` doesn't accumulate dangling symlinks pointing at
+# scripts the current cctally checkout doesn't ship. Removal is
+# conservative: we only unlink symlinks whose `readlink()` target's
+# basename matches the stale name — a user's hand-rolled symlink with
+# the same name pointing elsewhere is left alone.
+_SETUP_STALE_SYMLINK_NAMES = (
+    "cctally-release",  # Removed in v1.9.0; release tooling went private.
+)
+
+
 def _setup_resolve_symlink_source(repo_root: pathlib.Path, name: str) -> pathlib.Path:
     """Resolve the symlink target for a given PATH-name.
 
@@ -326,6 +338,148 @@ def _setup_create_symlinks(
     return results
 
 
+def _setup_cleanup_stale_symlinks(
+    dst_dir: pathlib.Path,
+) -> list[_SetupSymlinkResult]:
+    """Unlink stale `cctally-*` symlinks left over from prior versions.
+
+    For each entry in :data:`_SETUP_STALE_SYMLINK_NAMES`, removes the
+    matching symlink in ``dst_dir`` when its readlink target basename
+    matches the stale name AND the target points at a "retired" cctally
+    install — meaning either (a) the target is *dangling* (no longer
+    resolves to a real file, e.g. an old checkout that was deleted) OR
+    (b) the target lives under a *foreign* cctally install root
+    (Homebrew keg, npm ``node_modules/cctally/``), i.e. an install root
+    other than the one currently running ``cctally setup``.
+
+    The foreign-root clause is what handles the common upgrade path:
+    after ``brew upgrade cctally`` or ``npm i -g cctally@<new>``, the
+    *prior* keg / module dir often lingers on disk until ``brew
+    cleanup`` (or the next npm install GC), so a legacy
+    ``~/.local/bin/cctally-release`` symlink from a pre-v1.9.0 ``cctally
+    setup`` still resolves to an existing file under the *old* install
+    root. The dangling-only predicate would skip it, leaving the retired
+    command on PATH; the foreign-root check retires it instead.
+
+    Both clauses still preserve the maintainer's intentional manual
+    link to the *current* checkout's still-shipped retired tooling
+    (e.g. ``~/.local/bin/cctally-release ->
+    <cctally-dev>/bin/cctally-release``) — that target is neither
+    dangling nor foreign, so it's left alone. Likewise a hand-rolled
+    link pointing somewhere unrelated (``~/scripts/...``) survives.
+
+    Returns a list of :class:`_SetupSymlinkResult` entries for the
+    actions taken (so callers can fold them into install output).
+    """
+    results: list[_SetupSymlinkResult] = []
+    repo_root = _setup_resolve_repo_root()
+    for name in _SETUP_STALE_SYMLINK_NAMES:
+        dst = dst_dir / name
+        if not _setup_symlink_is_retired(dst, name, repo_root):
+            continue
+        try:
+            dst.unlink()
+            results.append(
+                _SetupSymlinkResult(name, "removed-stale", "stale (from prior version)")
+            )
+        except OSError as exc:
+            results.append(
+                _SetupSymlinkResult(name, "failed", f"unlink failed: {exc}")
+            )
+    return results
+
+
+# Path tokens that identify a "foreign" cctally install root — i.e. a
+# directory tree managed by a different distribution channel (or a
+# different version of the same channel) than the one currently running
+# ``cctally setup``. A symlink whose target sits under one of these is
+# almost certainly a legacy auto-installed link from a prior version
+# whose install root the current run does NOT manage. Pre-resolved (no
+# trailing slash) so substring matching works on either UNIX or
+# resolved forms.
+_SETUP_FOREIGN_INSTALL_ROOT_TOKENS = (
+    # Homebrew keeps every installed version under
+    # ``<prefix>/Cellar/cctally/<version>/``. A target inside any of
+    # these directories points at a brew install — either the current
+    # one (when ``cctally setup`` runs from a brew install — possible
+    # but rare) or an older keg still on disk pending ``brew cleanup``.
+    "/Cellar/cctally/",
+    # npm globals land at ``<prefix>/lib/node_modules/cctally/``; npm
+    # locals at ``<project>/node_modules/cctally/``. Either way the
+    # ``/node_modules/cctally/`` segment is the discriminator. pnpm and
+    # yarn variants keep the segment, so this catches them too.
+    "/node_modules/cctally/",
+)
+
+
+def _setup_symlink_is_retired(
+    dst: pathlib.Path, name: str, repo_root: pathlib.Path,
+) -> bool:
+    """Detection predicate for retired auto-symlinks at install time.
+
+    Returns True iff ``dst`` is a symlink, its readlink target basename
+    matches ``name``, AND the target points at a "retired" cctally
+    install — i.e. one the current ``cctally setup`` run does not
+    manage. Two retirement classes:
+
+      1. **Dangling target** — readlink target does not resolve to an
+         existing filesystem entry. Covers the deleted-checkout case.
+      2. **Foreign install root** — target path contains one of
+         :data:`_SETUP_FOREIGN_INSTALL_ROOT_TOKENS` (``/Cellar/cctally/``
+         or ``/node_modules/cctally/``) AND that token does NOT also
+         appear in the current ``repo_root``. The second clause is what
+         keeps the (rare) case of running ``cctally setup`` *from* an
+         npm/brew install correctly — a symlink at the same install root
+         is NOT foreign, so it's left to the active-symlinks loop in
+         :func:`_setup_install` / :func:`_setup_uninstall`.
+
+    Targets that exist but live outside any recognized install root
+    (e.g. a maintainer's manual link to ``<checkout>/bin/cctally-release``
+    or a hand-rolled link at ``~/scripts/cctally-release``) are
+    preserved — they're either explicit operator setups or genuine
+    user-managed scripts that happen to share the name.
+
+    Shared by the cleanup site (``_setup_cleanup_stale_symlinks``) and
+    the read-only detection site (``_setup_detect_stale_symlinks``) so
+    ``--status`` and ``setup`` agree on what they call "stale".
+    """
+    if not dst.is_symlink():
+        return False
+    try:
+        target = os.readlink(dst)
+    except OSError:
+        return False
+    if pathlib.Path(target).name != name:
+        # User-managed symlink that happens to share the name; leave alone.
+        return False
+    # Resolve target relative to the symlink's parent so relative
+    # readlinks (rare for cctally setup-installed links, but possible
+    # for hand-rolled ones) classify correctly. Use lexists()-style
+    # check via Path.exists() — broken links return False, which is
+    # the "dangling, treat as stale" branch we want.
+    target_path = pathlib.Path(target)
+    if not target_path.is_absolute():
+        target_path = dst.parent / target_path
+    try:
+        target_exists = target_path.exists()
+    except OSError:
+        # Permission errors etc. — be conservative and don't remove.
+        return False
+    if not target_exists:
+        return True
+    # Target exists — retire only if it lives under a *foreign* install
+    # root (a different brew keg / npm module dir than the one running
+    # this setup). Compare against ``repo_root`` so a setup running
+    # *from* an npm/brew install doesn't classify its own siblings as
+    # foreign — that's the active-symlinks loop's job.
+    target_str = str(target_path)
+    repo_root_str = str(repo_root)
+    for token in _SETUP_FOREIGN_INSTALL_ROOT_TOKENS:
+        if token in target_str and token not in repo_root_str:
+            return True
+    return False
+
+
 def _setup_path_includes_local_bin() -> bool:
     local_bin = str(_setup_local_bin_dir())
     return local_bin in os.environ.get("PATH", "").split(os.pathsep)
@@ -816,12 +970,38 @@ def _setup_compute_symlink_state(
     return out
 
 
+def _setup_detect_stale_symlinks(dst_dir: pathlib.Path) -> list[str]:
+    """Return names of stale-but-still-present cctally symlinks in ``dst_dir``.
+
+    Mirrors :func:`_setup_cleanup_stale_symlinks` detection (without
+    removing): a symlink is "stale" when its name appears in
+    :data:`_SETUP_STALE_SYMLINK_NAMES`, its readlink target basename
+    matches that name, AND the target is "retired" — either dangling
+    OR pointing at a foreign cctally install root (see
+    :func:`_setup_symlink_is_retired`). Routing through the same
+    predicate keeps ``--status`` and ``setup`` in lockstep so a
+    manually-maintained link to a still-shipped retired tool
+    (``~/.local/bin/cctally-release -> <checkout>/bin/cctally-release``)
+    is neither reported as stale nor removed, while a legacy link left
+    over from a pre-v1.9.0 brew/npm install (target still resolves into
+    the old keg / ``node_modules`` tree) IS retired.
+    """
+    found: list[str] = []
+    repo_root = _setup_resolve_repo_root()
+    for name in _SETUP_STALE_SYMLINK_NAMES:
+        dst = dst_dir / name
+        if _setup_symlink_is_retired(dst, name, repo_root):
+            found.append(name)
+    return found
+
+
 def _setup_status(args: argparse.Namespace) -> int:
     c = _cctally()
     repo_root = _setup_resolve_repo_root()
     dst_dir = _setup_local_bin_dir()
     sym_state = _setup_compute_symlink_state(repo_root, dst_dir)
     sym_ok = sum(1 for _, s in sym_state if s == "ok")
+    stale_syms = _setup_detect_stale_symlinks(dst_dir)
     on_path = _setup_path_includes_local_bin()
     try:
         settings = c._load_claude_settings()
@@ -842,6 +1022,7 @@ def _setup_status(args: argparse.Namespace) -> int:
             "install": {
                 "symlinks_present": sym_ok,
                 "symlinks_total": len(c.SETUP_SYMLINK_NAMES),
+                "symlinks_stale": stale_syms,
                 "path_includes": on_path,
             },
             "hooks": {ev: hook_counts[ev] for ev in c.SETUP_HOOK_EVENTS},
@@ -869,6 +1050,11 @@ def _setup_status(args: argparse.Namespace) -> int:
     out.append("Install")
     sym_marker = "✓" if sym_ok == len(c.SETUP_SYMLINK_NAMES) else "✗"
     out.append(f"  Symlinks       {sym_ok}/{len(c.SETUP_SYMLINK_NAMES)} present at {dst_dir}/  {sym_marker}")
+    if stale_syms:
+        out.append(
+            f"  Stale symlinks {len(stale_syms)} from prior version: {', '.join(stale_syms)}  ⚠"
+        )
+        out.append("                 run `cctally setup` to remove")
     out.append(f"  PATH includes  {'yes' if on_path else 'no'}                                   "
                f"{'✓' if on_path else '⚠'}")
     out.append(f"Hooks ({c.CLAUDE_SETTINGS_PATH})")
@@ -950,6 +1136,50 @@ def _setup_uninstall(args: argparse.Namespace) -> int:
                     sym_removed += 1
                 except OSError as exc:
                     eprint(f"setup: failed to remove {dst}: {exc}")
+    # Also clean up legacy symlinks that older cctally versions used to
+    # install but the current version no longer manages (see
+    # :data:`_SETUP_STALE_SYMLINK_NAMES`). Without this loop, an
+    # upgrader who ran ``cctally setup`` on a prior version and now runs
+    # ``cctally setup --uninstall`` would keep e.g.
+    # ``~/.local/bin/cctally-release`` on PATH.
+    #
+    # Two removal predicates compose here:
+    #   1. ``target == _setup_resolve_symlink_source(repo_root, name)``
+    #      — the legacy auto-installed link points at *this* install
+    #      root's binary (the common case for git-checkout upgraders
+    #      who ran ``cctally setup`` on a prior version, then ``git
+    #      pull``ed; symmetric with how the active-symlink loop above
+    #      treats user-pointed `cctally` itself).
+    #   2. ``_setup_symlink_is_retired`` — target is dangling OR lives
+    #      under a *foreign* cctally install root (old brew keg /
+    #      ``node_modules/cctally/`` left behind by ``brew upgrade``
+    #      or ``npm i -g cctally@<new>``). Without this, the common
+    #      brew/npm upgrade-then-uninstall path leaves the legacy
+    #      symlink in place because the prior keg's binary still
+    #      exists on disk (``target != expected``).
+    #
+    # A maintainer's hand-rolled link pointing somewhere unrelated
+    # (``~/scripts/...``) is preserved by both predicates.
+    for name in _SETUP_STALE_SYMLINK_NAMES:
+        dst = dst_dir / name
+        if not dst.is_symlink():
+            continue
+        try:
+            target = pathlib.Path(os.readlink(dst))
+        except OSError:
+            continue
+        expected = _setup_resolve_symlink_source(repo_root, name)
+        should_remove = (
+            target == expected
+            or _setup_symlink_is_retired(dst, name, repo_root)
+        )
+        if not should_remove:
+            continue
+        try:
+            dst.unlink()
+            sym_removed += 1
+        except OSError as exc:
+            eprint(f"setup: failed to remove {dst}: {exc}")
     out.append(f"Removed {sym_removed} symlinks from {dst_dir}/")
 
     legacy = _setup_detect_legacy_snippet()
@@ -1336,6 +1566,13 @@ def _setup_install(args: argparse.Namespace) -> int:
         eprint(f"setup: {exc}")
         return 1
 
+    # Clean up symlinks left behind by prior cctally versions whose
+    # subcommand surface has changed (e.g. v1.9.0 retired
+    # `cctally-release` when release tooling went private). Only unlinks
+    # symlinks whose target's basename matches the stale name; never
+    # disturbs a user's hand-rolled symlink sharing the name.
+    stale_results = _setup_cleanup_stale_symlinks(dst_dir)
+
     sym_results = _setup_create_symlinks(repo_root, dst_dir)
     failed = [r for r in sym_results if r.status == "failed"]
     if failed:
@@ -1354,6 +1591,16 @@ def _setup_install(args: argparse.Namespace) -> int:
         detail_parts.append(f"{repl_count} re-pointed")
     detail = ", ".join(detail_parts) or "no changes"
     out.append(f"✓ Symlinks at {dst_dir}/: {len(sym_results)}/{len(sym_results)} ({detail})")
+    removed_stale = [r for r in stale_results if r.status == "removed-stale"]
+    failed_stale = [r for r in stale_results if r.status == "failed"]
+    if removed_stale:
+        out.append(
+            "✓ Cleaned up stale symlink(s) from prior version: "
+            + ", ".join(r.name for r in removed_stale)
+        )
+    for r in failed_stale:
+        out.append(f"⚠ Could not remove stale {r.name}: {r.detail}")
+        warnings += 1
 
     if not _setup_path_includes_local_bin():
         warnings += 1

package/bin/_cctally_tui.py

@@ -329,6 +329,10 @@ def _dashboard_build_blocks_panel(*args, **kwargs):
     return sys.modules["cctally"]._dashboard_build_blocks_panel(*args, **kwargs)
 
 
+def _dashboard_build_blocks_view(*args, **kwargs):
+    return sys.modules["cctally"]._dashboard_build_blocks_view(*args, **kwargs)
+
+
 def _dashboard_build_daily_panel(*args, **kwargs):
     return sys.modules["cctally"]._dashboard_build_daily_panel(*args, **kwargs)
 
@@ -822,27 +826,15 @@ from _lib_view_models import (  # noqa: E402
 )
 
 
-@dataclass
-class BlocksPanelRow:
-    """One row of the dashboard's Blocks panel.
-
-    Subset of the `Block` dataclass — drops token counts (panel is
-    cost-driven; tokens belong to a future modal), drops `entries_count`
-    / `is_gap` / `burn_rate` / `projection` (panel doesn't render them),
-    and pre-formats `label` server-side for the local-tz "HH:MM MMM DD"
-    display.
-    """
-    start_at: str          # ISO-8601 UTC
-    end_at: str            # ISO-8601 UTC, start_at + 5h
-    anchor: str            # 'recorded' | 'heuristic'
-    is_active: bool        # now_utc < end_at AND entries_count > 0
-    cost_usd: float
-    models: list[dict[str, Any]]   # ModelCostRow shape, sorted desc by cost
-    label: str             # "HH:MM MMM DD" in local tz, e.g. "14:00 Apr 26"
-
-
-# DailyPanelRow + TuiSessionRow moved to bin/_lib_view_models.py — re-export.
-from _lib_view_models import DailyPanelRow, TuiSessionRow  # noqa: E402
+# BlocksPanelRow + DailyPanelRow + TuiSessionRow moved to
+# bin/_lib_view_models.py — re-exported here so historical
+# ``from _cctally_tui import BlocksPanelRow`` (or ``ns["BlocksPanelRow"]``
+# direct-dict reads in tests) keep resolving.
+from _lib_view_models import (  # noqa: E402
+    BlocksPanelRow,
+    DailyPanelRow,
+    TuiSessionRow,
+)
 
 
 @dataclass
@@ -1043,7 +1035,32 @@ class DataSnapshot:
     monthly_total_tokens: int = 0
     weekly_total_cost_usd: float = 0.0
     weekly_total_tokens: int = 0
+    # Blocks domain (issue #56). ``BlocksPanelRow`` doesn't carry token
+    # columns, so the cost total alone preserves the structural
+    # ``total === sum(visible rows).cost_usd`` invariant; ``blocks_total_tokens``
+    # is sourced from the same ``BlocksView`` build so both scalars
+    # come from a single typed pass.
+    blocks_total_cost_usd: float = 0.0
+    blocks_total_tokens: int = 0
     trend_avg_dollars_per_pct: float | None = None
+    # Trend modal median (issue #59). Sourced from
+    # ``build_trend_view``'s ``median_dpp_non_current_4w`` field — the
+    # last-4-non-current dpp median TrendModal.tsx used to compute
+    # client-side. Populated by the sync thread off the 12-row history
+    # build (NOT the 8-row panel build); the dashboard envelope adapter
+    # emits this as ``trend.history_median_dpp``. ``None`` for fixture
+    # modules that construct ``DataSnapshot`` positionally without
+    # going through ``_tui_build_snapshot``; the React modal keeps a
+    # client-side fallback for that case.
+    trend_history_median_dpp: float | None = None
+    # Forecast domain (issue #57). ``ForecastView`` wraps
+    # ``ForecastOutput`` and surfaces the per-method projection /
+    # verdict / header-routing / budget fields the dashboard envelope
+    # adapter used to re-derive inline. Field is ``None`` for fixture
+    # modules that construct ``DataSnapshot`` directly without going
+    # through ``_tui_build_snapshot``; the envelope adapter falls
+    # back to the legacy inline routing in that case.
+    forecast_view: Any | None = None
 
     @classmethod
     def synthesize_for_marketing(cls, *, as_of_iso: str) -> "DataSnapshot":
@@ -1426,11 +1443,32 @@ def _tui_build_forecast(
     *,
     skip_sync: bool = False,
 ):
-    """Call into existing forecast internals. Returns a ForecastOutput or None."""
-    inputs = _load_forecast_inputs(conn, now_utc, skip_sync=skip_sync)
-    if inputs is None:
-        return None
-    return _compute_forecast(inputs, [100, 90])
+    """Build the TUI/dashboard sync-thread forecast.
+
+    Issue #57: routes through ``build_forecast_view`` (the kernel-pattern
+    wrapper) and unwraps to a ``ForecastOutput`` for backward-compat with
+    every existing ``snap.forecast`` consumer (TUI panels, envelope
+    adapter, share builder). Use ``_tui_build_forecast_view`` when the
+    full view is needed (e.g. ``snap.forecast_view`` population).
+    """
+    view = _tui_build_forecast_view(conn, now_utc, skip_sync=skip_sync)
+    return view.output if view is not None else None
+
+
+def _tui_build_forecast_view(
+    conn: sqlite3.Connection,
+    now_utc: dt.datetime,
+    *,
+    skip_sync: bool = False,
+):
+    """Build the ``ForecastView`` (issue #57). Returns ``None`` only on
+    error in callers — the empty-state View is constructed by the
+    builder itself with ``output=None`` + ``verdict="LOW CONF"``.
+    """
+    c = _cctally()
+    return c.build_forecast_view(
+        conn, now_utc=now_utc, targets=(100, 90), skip_sync=skip_sync,
+    )
 
 
 def _tui_build_trend(
@@ -1470,9 +1508,46 @@ def _tui_build_weekly_history(
     than parameterising the call site keeps the snapshot fields
     semantically distinct (panel data vs. modal data) and avoids
     accidental cross-contamination.
+
+    Issue #59: list-returning shim kept for back-compat with the
+    public re-export at ``bin/cctally:13871``. New callers (the sync
+    thread populating ``snap.weekly_history`` + the modal-median
+    scalar) should prefer ``_tui_build_weekly_history_view`` so they
+    pick up the pre-computed ``median_dpp_non_current_4w`` scalar
+    without re-deriving.
+    """
+    return list(
+        _tui_build_weekly_history_view(
+            conn, now_utc, skip_sync=skip_sync, count=count,
+            display_tz=display_tz,
+        ).rows
+    )
+
+
+def _tui_build_weekly_history_view(
+    conn: sqlite3.Connection,
+    now_utc: dt.datetime,
+    *,
+    skip_sync: bool = False,                # noqa: ARG001 — unused today, kept for API symmetry
+    count: int = 12,
+    display_tz: "ZoneInfo | None" = None,
+):
+    """Build the full ``TrendView`` for the dashboard Trend modal
+    (issue #59).
+
+    Wraps ``build_trend_view`` with the 12-row default the modal
+    consumes. The returned ``TrendView`` carries the
+    ``median_dpp_non_current_4w`` pre-computed scalar so the sync
+    thread can populate ``DataSnapshot.trend_history_median_dpp``
+    without re-running the median derivation client-side. The 8-row
+    panel call (``_tui_build_trend``) goes through the same
+    ``build_trend_view`` kernel; both builds carry their own median
+    field but only the 12-row build's value reaches the envelope
+    (``trend.history_median_dpp``).
     """
-    return _tui_build_trend(
-        conn, now_utc, skip_sync=skip_sync, count=count, display_tz=display_tz,
+    c = _cctally()
+    return c.build_trend_view(
+        conn, now_utc=now_utc, n=max(1, count), display_tz=display_tz,
     )
 
 
@@ -1651,8 +1726,14 @@ def _tui_build_snapshot(
             cw = _tui_build_current_week(conn, now_utc, skip_sync=skip_sync)
         except Exception as exc:
             errors.append(f"current-week: {exc}")
+        fc_view = None
         try:
-            fc = _tui_build_forecast(conn, now_utc, skip_sync=skip_sync)
+            # Issue #57: build the ForecastView once so we capture both
+            # the legacy ``ForecastOutput`` (for ``snap.forecast``, which
+            # the many TUI panel consumers still read) and the surface
+            # fields the envelope adapter used to re-derive inline.
+            fc_view = _tui_build_forecast_view(conn, now_utc, skip_sync=skip_sync)
+            fc = fc_view.output if fc_view is not None else None
         except Exception as exc:
             errors.append(f"forecast: {exc}")
         # Trend: source from build_trend_view so we capture the 3-sample
@@ -1685,10 +1766,19 @@ def _tui_build_snapshot(
                 milestones = _tui_build_percent_milestones(conn)
         except Exception as exc:
             errors.append(f"milestones: {exc}")
+        history: list = []
+        history_median_dpp: "float | None" = None
         try:
-            history = _tui_build_weekly_history(
+            # Issue #59: build the full TrendView so we capture the
+            # pre-computed 4-week-median-non-current scalar alongside
+            # the row list; the dashboard envelope adapter surfaces
+            # the scalar as ``trend.history_median_dpp`` so
+            # TrendModal.tsx stops re-deriving it client-side.
+            history_view = _tui_build_weekly_history_view(
                 conn, now_utc, skip_sync=skip_sync, display_tz=_build_display_tz,
             )
+            history = list(history_view.rows)
+            history_median_dpp = history_view.median_dpp_non_current_4w
         except Exception as exc:
             errors.append(f"weekly-history: {exc}")
         # ---- v2.1 additions: dashboard Weekly / Monthly panels ----
@@ -1742,15 +1832,25 @@ def _tui_build_snapshot(
         except Exception as exc:
             errors.append(f"monthly-periods: {exc}")
         # ---- v2.2 additions: dashboard Blocks / Daily panels ----
+        # Issue #56: build the BlocksView once and read both rows
+        # (presentation) and totals (envelope scalars) from the same
+        # pass. ``_dashboard_build_blocks_view`` is the view-returning
+        # counterpart to ``_dashboard_build_blocks_panel`` (which is
+        # kept as a thin shim for monkeypatch surfaces).
+        blocks_total_cost_usd = 0.0
+        blocks_total_tokens = 0
         try:
             if cw is not None:
-                blocks_panel = _dashboard_build_blocks_panel(
+                _blocks_view = _dashboard_build_blocks_view(
                     conn, now_utc,
                     week_start_at=cw.week_start_at,
                     week_end_at=cw.week_end_at,
                     skip_sync=skip_sync,
                     display_tz=_build_display_tz,
                 )
+                blocks_panel = list(_blocks_view.rows)
+                blocks_total_cost_usd = _blocks_view.total_cost_usd
+                blocks_total_tokens = _blocks_view.total_tokens
         except Exception as exc:
             errors.append(f"blocks-panel: {exc}")
         # Sync-thread view-model totals (Bundle 1 / spec §6.6):
@@ -1818,7 +1918,11 @@ def _tui_build_snapshot(
             monthly_total_tokens=monthly_total_tokens,
             weekly_total_cost_usd=weekly_total_cost_usd,
             weekly_total_tokens=weekly_total_tokens,
+            blocks_total_cost_usd=blocks_total_cost_usd,
+            blocks_total_tokens=blocks_total_tokens,
             trend_avg_dollars_per_pct=trend_avg_dpp,
+            trend_history_median_dpp=history_median_dpp,
+            forecast_view=fc_view,
         )
     finally:
         conn.close()
@@ -2218,6 +2322,16 @@ class _TuiSyncThread:
                 self._ref.set(snap)
             except Exception as exc:
                 # Don't crash the thread on unexpected errors — surface in UI.
+                # Carry every additive view-model scalar through verbatim so
+                # the prior frame's panel rows and their envelope totals stay
+                # consistent. Bundle 1 / #56 / #57 / #59 each added envelope
+                # scalars the React panels now trust over a client-side
+                # ``rows.reduce``; without preserving them here, a sync crash
+                # leaves populated rows next to a ``$0.00`` footer (the
+                # dataclass defaults kick in for any field not explicitly
+                # passed). The structural-equality invariant
+                # ``total === sum(visible rows).cost_usd`` must survive a
+                # crash recovery, not just the happy path.
                 prev = self._ref.get()
                 self._ref.set(DataSnapshot(
                     current_week=prev.current_week,
@@ -2233,6 +2347,17 @@ class _TuiSyncThread:
                     monthly_periods=prev.monthly_periods,
                     blocks_panel=prev.blocks_panel,
                     daily_panel=prev.daily_panel,
+                    daily_total_cost_usd=prev.daily_total_cost_usd,
+                    daily_total_tokens=prev.daily_total_tokens,
+                    monthly_total_cost_usd=prev.monthly_total_cost_usd,
+                    monthly_total_tokens=prev.monthly_total_tokens,
+                    weekly_total_cost_usd=prev.weekly_total_cost_usd,
+                    weekly_total_tokens=prev.weekly_total_tokens,
+                    blocks_total_cost_usd=prev.blocks_total_cost_usd,
+                    blocks_total_tokens=prev.blocks_total_tokens,
+                    trend_avg_dollars_per_pct=prev.trend_avg_dollars_per_pct,
+                    trend_history_median_dpp=prev.trend_history_median_dpp,
+                    forecast_view=prev.forecast_view,
                 ))
             # Wait up to interval, or until forced.
             for _ in range(int(max(1, self._interval * 10))):

package/bin/_cctally_update.py

@@ -116,10 +116,16 @@ What stays in bin/cctally:
   write surface in cmd_dashboard works unchanged; moved code
   reads via ``c.X``.
 - ``eprint``, ``_now_utc`` (used by moved code via shim/accessor),
-  ``_release_read_latest_release_version`` (stays in cctally per
-  spec §6.7 — 6+ external callers, file I/O over CHANGELOG.md),
+  ``_release_read_latest_release_version`` (impl moved to
+  ``_lib_changelog._read_latest_changelog_version``; cctally
+  re-exports the historical name. The shim below routes through
+  ``sys.modules['cctally']`` so test ``monkeypatch.setitem(ns, ...)``
+  on the historical name still overrides the 5 internal callers
+  here),
   ``_release_parse_semver`` / ``_release_semver_sort_key`` (lives
-  in ``_lib_semver`` and re-exported by cctally),
+  in ``_lib_semver``; shims below route directly to that module —
+  the cctally re-exports were removed in the release-command split
+  privatization),
   ``load_config`` (lives in ``_cctally_config``; re-exported),
   ``_BANNER_SUPPRESSED_COMMANDS`` (lives in ``_cctally_db``;
   re-exported by cctally — composed with the update-only
@@ -210,17 +216,35 @@ def load_config(*args, **kwargs):
 
 
 def _release_read_latest_release_version(*args, **kwargs):
+    """Back-compat shim. The implementation now lives in
+    ``bin/_lib_changelog._read_latest_changelog_version``; ``bin/cctally``
+    re-exports it under the historical name. This shim routes through
+    the ``cctally`` namespace (not directly to ``_lib_changelog``) so
+    that ``monkeypatch.setitem(ns, "_release_read_latest_release_version", ...)``
+    in tests/test_update.py + tests/test_release_internals.py overrides
+    the 5+ internal callers in this module. New code should call
+    ``_lib_changelog._read_latest_changelog_version`` directly.
+    """
     return sys.modules["cctally"]._release_read_latest_release_version(
         *args, **kwargs
     )
 
 
+# The semver shims now resolve via ``_lib_semver`` directly — the
+# cctally re-exports (``_release_parse_semver`` / ``_release_semver_sort_key``)
+# were removed in the release-command split privatization. Kept as
+# call-time shims (vs. module-top ``from _lib_semver import ...``) so
+# tests can still ``monkeypatch.setitem(ns, "_release_parse_semver", ...)``
+# on this module's namespace if needed; the bare-name lookup inside this
+# module resolves here, not at the import site.
 def _release_parse_semver(*args, **kwargs):
-    return sys.modules["cctally"]._release_parse_semver(*args, **kwargs)
+    import _lib_semver
+    return _lib_semver._release_parse_semver(*args, **kwargs)
 
 
 def _release_semver_sort_key(*args, **kwargs):
-    return sys.modules["cctally"]._release_semver_sort_key(*args, **kwargs)
+    import _lib_semver
+    return _lib_semver._release_semver_sort_key(*args, **kwargs)
 
 
 def _normalize_alerts_enabled_value(*args, **kwargs):