perf(tui): cache rendered thinking-preview markdown across live ticks

The markdown render + regex parse for the thinking preview can run many times
per second on Live refresh ticks when no new content has arrived. Introduce
a cache key (the preview string) so markdown parsing only runs when the
pending thinking text actually changes, not on every spinner animation.

Includes tests verifying cache behavior and output equivalence.

Author: elkaix

src/pythinker_code/ui/shell/visualize/_blocks.py

@@ -651,6 +651,10 @@ def __init__(self, is_think: bool, *, show_thinking_stream: bool = False, paced:
         self._scrollback_renderable: RenderableType | None = None
         self._preview_text_cache_key: tuple[int, int, int, bool, str] | None = None
         self._preview_text_cache: str | None = None
+        # Rendered thinking-preview cache (legacy ``show_thinking_stream`` path):
+        # avoids re-running the markdown parse on every Live tick when unchanged.
+        self._thinking_render_cache_key: str | None = None
+        self._thinking_render_cache: RenderableType | None = None
         # Interactive prompt preamble row budget (``None`` = no limit; Rich Live).
         self._preview_row_budget: int | None = None
         self._last_commit_scan_len = 0
@@ -905,6 +909,8 @@ def _pending_text_for_final(self) -> str:
     def _invalidate_preview_cache(self) -> None:
         self._preview_text_cache_key = None
         self._preview_text_cache = None
+        self._thinking_render_cache_key = None
+        self._thinking_render_cache = None
 
     def _wrap_bullet(self, renderable: RenderableType) -> BulletColumns:
         """First call gets the ``•`` bullet; subsequent calls get a space."""
@@ -1151,8 +1157,8 @@ def _compose_thinking_stream(self) -> RenderableType:
         pending = self._pending_text()
         if not pending:
             return spinner
-        preview = self._build_preview(pending, max_lines=_THINKING_PREVIEW_LINES)
-        rendered_preview = _render_thinking_preview(preview)
+        preview = self._build_preview_cached(pending, max_lines=_THINKING_PREVIEW_LINES)
+        rendered_preview = self._render_thinking_preview_cached(preview)
         if rendered_preview is None:
             return spinner
         preview_style = tui_rich_style("thinking_text") + Style(italic=True)
@@ -1171,6 +1177,21 @@ def _compose_thinking_spinner(self) -> Text:
             width=self._layout_width(),
         )
 
+    def _render_thinking_preview_cached(self, preview: str) -> RenderableType | None:
+        """Render the thinking preview markdown, caching on the preview string.
+
+        Mirrors :meth:`_build_preview_cached` so the markdown parse only runs when
+        the preview content changes, not on every Live refresh tick driven by the
+        spinner animation. The cache is cleared by ``_invalidate_preview_cache``
+        on new content, width, or preview-budget changes.
+        """
+        if preview == self._thinking_render_cache_key:
+            return self._thinking_render_cache
+        rendered = _render_thinking_preview(preview)
+        self._thinking_render_cache_key = preview
+        self._thinking_render_cache = rendered
+        return rendered
+
     def _layout_width(self) -> int:
         width = current_console_width()
         if width != self._block_width:

tests/ui_and_conv/test_streaming_content_block.py

@@ -669,6 +669,49 @@ def test_stream_mode_status_includes_token_count(self):
         assert "Thinking" in plain
         assert "tokens" in plain
 
+    def test_stream_mode_reuses_rendered_preview_across_ticks(self, monkeypatch):
+        """The markdown render runs once per preview change, not per Live tick.
+
+        The Live area refreshes on the spinner's own animation cadence with no new
+        content; ``_render_thinking_preview`` (regex + markdown parse) must be
+        served from cache on those ticks and only recomputed when pending changes.
+        """
+        from pythinker_code.ui.shell.visualize import _blocks
+
+        calls: list[str] = []
+        original = _blocks._render_thinking_preview
+
+        def counting(preview: str):
+            calls.append(preview)
+            return original(preview)
+
+        monkeypatch.setattr(_blocks, "_render_thinking_preview", counting)
+
+        block = _ContentBlock(is_think=True, show_thinking_stream=True)
+        block.append("**first reasoning line**")
+        block.compose()
+        block.compose()  # unchanged pending -> served from cache
+        assert len(calls) == 1
+
+        block.append("\n**second reasoning line**")
+        block.compose()  # pending changed -> recompute
+        assert len(calls) == 2
+
+    def test_stream_mode_cached_preview_matches_uncached_render(self):
+        """Caching is behavior-preserving: composed output is byte-identical to a
+        fresh (uncached) render of the same reasoning content across ticks."""
+        block = _ContentBlock(is_think=True, show_thinking_stream=True)
+        block.append("**Preparing report generation**")
+
+        first = Console(record=True, width=120, color_system=None)
+        first.print(block.compose())
+        second = Console(record=True, width=120, color_system=None)
+        second.print(block.compose())  # cache hit
+        first_text = first.export_text()
+        assert first_text == second.export_text()
+        assert "Preparing report generation" in first_text
+        assert block._thinking_render_cache_key is not None
+
     def test_compact_mode_compose_final_returns_trace_line(self):
         from rich.text import Text