klaude-code 1.2.23__py3-none-any.whl → 1.2.25__py3-none-any.whl

klaude_code/ui/renderers/sub_agent.py

@@ -1,6 +1,7 @@
 import json
 from typing import Any, cast
 
+from rich import box
 from rich.console import Group, RenderableType
 from rich.json import JSON
 from rich.panel import Panel
@@ -58,10 +59,22 @@ def render_sub_agent_call(e: model.SubAgentState, style: Style | None = None) ->
 
 
 def render_sub_agent_result(
-    result: str, *, code_theme: str, style: Style | None = None, has_structured_output: bool = False
+    result: str,
+    *,
+    code_theme: str,
+    style: Style | None = None,
+    has_structured_output: bool = False,
+    description: str | None = None,
+    panel_style: Style | None = None,
 ) -> RenderableType:
     stripped_result = result.strip()
 
+    # Add markdown heading if description is provided
+    if description:
+        stripped_result = f"# {description}\n\n{stripped_result}"
+
+    result_panel_style = panel_style or ThemeKey.SUB_AGENT_RESULT_PANEL
+
     # Use rich JSON for structured output
     if has_structured_output:
         try:
@@ -73,7 +86,9 @@ def render_sub_agent_result(
                     ),
                     JSON(stripped_result),
                 ),
+                box=box.SIMPLE,
                 border_style=ThemeKey.LINES,
+                style=result_panel_style,
             )
         except json.JSONDecodeError:
             # Fall back to markdown if not valid JSON
@@ -82,20 +97,28 @@ def render_sub_agent_result(
     lines = stripped_result.splitlines()
     if len(lines) > const.SUB_AGENT_RESULT_MAX_LINES:
         hidden_count = len(lines) - const.SUB_AGENT_RESULT_MAX_LINES
-        truncated_text = "\n".join(lines[-const.SUB_AGENT_RESULT_MAX_LINES :])
+        head_count = const.SUB_AGENT_RESULT_MAX_LINES // 2
+        tail_count = const.SUB_AGENT_RESULT_MAX_LINES - head_count
+        head_text = "\n".join(lines[:head_count])
+        tail_text = "\n".join(lines[-tail_count:])
         return Panel.fit(
             Group(
+                NoInsetMarkdown(head_text, code_theme=code_theme, style=style or ""),
                 Text(
-                    f"… more {hidden_count} lines — use /export to view full output",
-                    style=ThemeKey.TOOL_RESULT,
+                    f"\n… more {hidden_count} lines — use /export to view full output\n",
+                    style=ThemeKey.TOOL_RESULT_TRUNCATED,
                 ),
-                NoInsetMarkdown(truncated_text, code_theme=code_theme, style=style or ""),
+                NoInsetMarkdown(tail_text, code_theme=code_theme, style=style or ""),
             ),
+            box=box.SIMPLE,
             border_style=ThemeKey.LINES,
+            style=result_panel_style,
         )
     return Panel.fit(
         NoInsetMarkdown(stripped_result, code_theme=code_theme),
+        box=box.SIMPLE,
         border_style=ThemeKey.LINES,
+        style=result_panel_style,
     )
 
 

klaude_code/ui/renderers/thinking.py

@@ -4,12 +4,13 @@ from rich.console import RenderableType
 from rich.padding import Padding
 from rich.text import Text
 
+from klaude_code import const
+from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.markdown import ThinkingMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 
-
-def thinking_prefix() -> Text:
-    return Text.from_markup("[not italic]⸫[/not italic] Thinking …", style=ThemeKey.THINKING_BOLD)
+# UI markers
+THINKING_MESSAGE_MARK = "⠶"
 
 
 def normalize_thinking_content(content: str) -> str:
@@ -37,7 +38,7 @@ def normalize_thinking_content(content: str) -> str:
 
 
 def render_thinking(content: str, *, code_theme: str, style: str) -> RenderableType | None:
-    """Render thinking content as indented markdown.
+    """Render thinking content as markdown with left mark.
 
     Returns None if content is empty.
     Note: Caller should push thinking_markdown_theme before printing.
@@ -45,11 +46,16 @@ def render_thinking(content: str, *, code_theme: str, style: str) -> RenderableT
     if len(content.strip()) == 0:
         return None
 
-    return Padding.indent(
-        ThinkingMarkdown(
-            normalize_thinking_content(content),
-            code_theme=code_theme,
-            style=style,
+    grid = create_grid()
+    grid.add_row(
+        Text(THINKING_MESSAGE_MARK, style=ThemeKey.THINKING),
+        Padding(
+            ThinkingMarkdown(
+                normalize_thinking_content(content),
+                code_theme=code_theme,
+                style=style,
+            ),
+            (0, const.MARKDOWN_RIGHT_MARGIN, 0, 0),
         ),
-        level=2,
     )
+    return grid

klaude_code/ui/renderers/tools.py

@@ -2,8 +2,10 @@ import json
 from pathlib import Path
 from typing import Any, cast
 
+from rich import box
 from rich.console import Group, RenderableType
 from rich.padding import Padding
+from rich.panel import Panel
 from rich.text import Text
 
 from klaude_code import const
@@ -11,6 +13,7 @@ from klaude_code.protocol import events, model, tools
 from klaude_code.protocol.sub_agent import is_sub_agent_tool as _is_sub_agent_tool
 from klaude_code.ui.renderers import diffs as r_diffs
 from klaude_code.ui.renderers.common import create_grid, truncate_display
+from klaude_code.ui.rich.markdown import NoInsetMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 
 # Tool markers (Unicode symbols for UI display)
@@ -528,7 +531,23 @@ def _extract_diff(ui_extra: model.ToolResultUIExtra | None) -> model.DiffUIExtra
     return None
 
 
-def render_tool_result(e: events.ToolResultEvent) -> RenderableType | None:
+def _extract_markdown_doc(ui_extra: model.ToolResultUIExtra | None) -> model.MarkdownDocUIExtra | None:
+    if isinstance(ui_extra, model.MarkdownDocUIExtra):
+        return ui_extra
+    return None
+
+
+def render_markdown_doc(md_ui: model.MarkdownDocUIExtra, *, code_theme: str) -> RenderableType:
+    """Render markdown document content in a panel."""
+    return Panel.fit(
+        NoInsetMarkdown(md_ui.content, code_theme=code_theme),
+        box=box.SIMPLE,
+        border_style=ThemeKey.LINES,
+        style=ThemeKey.WRITE_MARKDOWN_PANEL,
+    )
+
+
+def render_tool_result(e: events.ToolResultEvent, *, code_theme: str = "monokai") -> RenderableType | None:
     """Unified entry point for rendering tool results.
 
     Returns a Rich Renderable or None if the tool result should not be rendered.
@@ -549,11 +568,16 @@ def render_tool_result(e: events.ToolResultEvent) -> RenderableType | None:
         return Group(render_truncation_info(truncation_info), render_generic_tool_result(e.result))
 
     diff_ui = _extract_diff(e.ui_extra)
+    md_ui = _extract_markdown_doc(e.ui_extra)
 
     match e.tool_name:
         case tools.READ:
             return None
-        case tools.EDIT | tools.WRITE:
+        case tools.EDIT:
+            return Padding.indent(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""), level=2)
+        case tools.WRITE:
+            if md_ui:
+                return Padding.indent(render_markdown_doc(md_ui, code_theme=code_theme), level=2)
             return Padding.indent(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""), level=2)
         case tools.APPLY_PATCH:
             if diff_ui:

klaude_code/ui/rich/code_panel.py

@@ -4,9 +4,10 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from rich.cells import cell_len
 from rich.console import ConsoleRenderable, RichCast
 from rich.jupyter import JupyterMixin
-from rich.measure import Measurement, measure_renderables
+from rich.measure import Measurement
 from rich.segment import Segment
 from rich.style import StyleType
 
@@ -58,17 +59,29 @@ class CodePanel(JupyterMixin):
         self.expand = expand
         self.padding = padding
 
+    @staticmethod
+    def _measure_max_line_cells(lines: list[list[Segment]]) -> int:
+        max_cells = 0
+        for line in lines:
+            plain = "".join(segment.text for segment in line).rstrip()
+            max_cells = max(max_cells, cell_len(plain))
+        return max_cells
+
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         border_style = console.get_style(self.border_style)
         max_width = options.max_width
         pad = self.padding
 
+        max_content_width = max(max_width - pad * 2, 1)
+
         # Measure the content width (account for padding)
         if self.expand:
-            content_width = max_width - pad * 2
+            content_width = max_content_width
         else:
-            content_width = console.measure(self.renderable, options=options.update(width=max_width - pad * 2)).maximum
-            content_width = min(content_width, max_width - pad * 2)
+            probe_options = options.update(width=max_content_width)
+            probe_lines = console.render_lines(self.renderable, probe_options, pad=False)
+            content_width = self._measure_max_line_cells(probe_lines)
+            content_width = max(1, min(content_width, max_content_width))
 
         # Render content lines
         child_options = options.update(width=content_width)
@@ -108,5 +121,11 @@ class CodePanel(JupyterMixin):
     def __rich_measure__(self, console: Console, options: ConsoleOptions) -> Measurement:
         if self.expand:
             return Measurement(options.max_width, options.max_width)
-        width = measure_renderables(console, options, [self.renderable]).maximum + self.padding * 2
+        max_width = options.max_width
+        max_content_width = max(max_width - self.padding * 2, 1)
+        probe_options = options.update(width=max_content_width)
+        probe_lines = console.render_lines(self.renderable, probe_options, pad=False)
+        content_width = self._measure_max_line_cells(probe_lines)
+        content_width = max(1, min(content_width, max_content_width))
+        width = content_width + self.padding * 2
         return Measurement(width, width)

klaude_code/ui/rich/live.py

@@ -63,3 +63,20 @@ class CropAboveLive(Live):
 
     def update(self, renderable: RenderableType, refresh: bool = True) -> None:  # type: ignore[override]
         super().update(CropAbove(renderable, style=self._crop_style), refresh=refresh)
+
+
+class SingleLine:
+    """Render only the first line of a renderable.
+
+    This is used to ensure dynamic UI elements (spinners / status) never wrap
+    to multiple lines, which would appear as a vertical "jump".
+    """
+
+    def __init__(self, renderable: RenderableType) -> None:
+        self.renderable = renderable
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        line_options = options.update(no_wrap=True, overflow="ellipsis", height=1)
+        lines = console.render_lines(self.renderable, line_options, pad=False)
+        if lines:
+            yield from lines[0]

klaude_code/ui/rich/markdown.py

@@ -7,12 +7,12 @@ import time
 from collections.abc import Callable
 from typing import Any, ClassVar
 
-from rich.console import Console, ConsoleOptions, Group, RenderableType, RenderResult
-from rich.live import Live
+from markdown_it import MarkdownIt
+from markdown_it.token import Token
+from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
 from rich.markdown import CodeBlock, Heading, Markdown, MarkdownElement
 from rich.rule import Rule
-from rich.spinner import Spinner
-from rich.style import Style
+from rich.style import Style, StyleType
 from rich.syntax import Syntax
 from rich.text import Text
 from rich.theme import Theme
@@ -64,7 +64,7 @@ class LeftHeading(Heading):
             yield h1_text
         elif self.tag == "h2":
             text.stylize(Style(bold=True, underline=False))
-            yield Rule(title=text, characters="-", style="markdown.h2.border", align="left")
+            yield Rule(title=text, characters="·", style="markdown.h2.border", align="left")
         else:
             yield text
 
@@ -94,20 +94,25 @@ class ThinkingMarkdown(Markdown):
 
 
 class MarkdownStream:
-    """Streaming markdown renderer that progressively displays content with a live updating window.
+    """Block-based streaming Markdown renderer.
 
-    Uses rich.console and rich.live to render markdown content with smooth scrolling
-    and partial updates. Maintains a sliding window of visible content while streaming
-    in new markdown text.
+    This renderer is optimized for terminal UX:
+
+    - Stable area: only prints *completed* Markdown blocks to scrollback (append-only).
+    - Live area: continuously repaints only the final *possibly incomplete* block.
+
+    Block boundaries are computed with `MarkdownIt("commonmark")` (token maps / top-level tokens).
+    Rendering is done with Rich Markdown (customizable via `markdown_class`).
     """
 
     def __init__(
         self,
+        console: Console,
         mdargs: dict[str, Any] | None = None,
         theme: Theme | None = None,
-        console: Console | None = None,
-        spinner: Spinner | None = None,
+        live_sink: Callable[[RenderableType | None], None] | None = None,
         mark: str | None = None,
+        mark_style: StyleType | None = None,
         left_margin: int = 0,
         right_margin: int = const.MARKDOWN_RIGHT_MARGIN,
         markdown_class: Callable[..., Markdown] | None = None,
@@ -119,29 +124,30 @@ class MarkdownStream:
             theme (Theme, optional): Theme for rendering markdown
             console (Console, optional): External console to use for rendering
             mark (str | None, optional): Marker shown before the first non-empty line when left_margin >= 2
+            mark_style (StyleType | None, optional): Style to apply to the mark
             left_margin (int, optional): Number of columns to reserve on the left side
             right_margin (int, optional): Number of columns to reserve on the right side
             markdown_class: Markdown class to use for rendering (defaults to NoInsetMarkdown)
         """
-        self.printed: list[str] = []  # Stores lines that have already been printed
+        self._stable_rendered_lines: list[str] = []
+        self._stable_source_line_count: int = 0
 
         if mdargs:
             self.mdargs: dict[str, Any] = mdargs
         else:
             self.mdargs = {}
 
-        # Defer Live creation until the first update.
-        self.live: Live | None = None
+        self._live_sink = live_sink
 
         # Streaming control
         self.when: float = 0.0  # Timestamp of last update
         self.min_delay: float = 1.0 / 20  # Minimum time between updates (20fps)
-        self.live_window: int = const.MARKDOWN_STREAM_LIVE_WINDOW
+        self._parser: MarkdownIt = MarkdownIt("commonmark")
 
         self.theme = theme
         self.console = console
-        self.spinner: Spinner | None = spinner
         self.mark: str | None = mark
+        self.mark_style: StyleType | None = mark_style
 
         self.left_margin: int = max(left_margin, 0)
 
@@ -151,9 +157,117 @@ class MarkdownStream:
     @property
     def _live_started(self) -> bool:
         """Check if Live display has been started (derived from self.live)."""
-        return self.live is not None
+        return self._live_sink is not None
+
+    def _get_base_width(self) -> int:
+        return self.console.options.max_width
+
+    def compute_candidate_stable_line(self, text: str) -> int:
+        """Return the start line of the last top-level block, or 0.
+
+        This value is not monotonic; callers should clamp it (e.g. with the
+        previous stable line) before using it to advance state.
+        """
+
+        try:
+            tokens = self._parser.parse(text)
+        except Exception:
+            return 0
+
+        top_level: list[Token] = [token for token in tokens if token.level == 0 and token.map is not None]
+        if len(top_level) < 2:
+            return 0
+
+        last = top_level[-1]
+        assert last.map is not None
+        start_line = last.map[0]
+        return max(start_line, 0)
+
+    def split_blocks(self, text: str, *, min_stable_line: int = 0, final: bool = False) -> tuple[str, str, int]:
+        """Split full markdown into stable and live sources.
+
+        Returns:
+            stable_source: Completed blocks (append-only)
+            live_source: Last (possibly incomplete) block
+            stable_line: Line index where live starts
+        """
+
+        lines = text.splitlines(keepends=True)
+        line_count = len(lines)
+
+        stable_line = line_count if final else self.compute_candidate_stable_line(text)
+
+        stable_line = min(stable_line, line_count)
+        stable_line = max(stable_line, min_stable_line)
+
+        stable_source = "".join(lines[:stable_line])
+        live_source = "".join(lines[stable_line:])
+        return stable_source, live_source, stable_line
+
+    def render_ansi(self, text: str, *, apply_mark: bool) -> str:
+        """Render markdown source to an ANSI string.
+
+        This is primarily intended for internal debugging and tests.
+        """
+
+        return "".join(self._render_markdown_to_lines(text, apply_mark=apply_mark))
+
+    def render_stable_ansi(self, stable_source: str, *, has_live_suffix: bool, final: bool) -> str:
+        """Render stable prefix to ANSI, preserving inter-block spacing."""
+
+        if not stable_source:
+            return ""
+
+        render_source = stable_source
+        if not final and has_live_suffix:
+            render_source = self._append_nonfinal_sentinel(stable_source)
+
+        return self.render_ansi(render_source, apply_mark=True)
+
+    @staticmethod
+    def normalize_live_ansi_for_boundary(*, stable_ansi: str, live_ansi: str) -> str:
+        """Normalize whitespace at the stable/live boundary.
+
+        Some Rich Markdown blocks (e.g. lists) render with a leading blank line.
+        If the stable prefix already renders a trailing blank line, rendering the
+        live suffix separately may introduce an extra blank line that wouldn't
+        appear when rendering the full document.
 
-    def _render_markdown_to_lines(self, text: str) -> list[str]:
+        This function removes leading blank lines from the live ANSI when the
+        stable ANSI already ends with a blank line.
+        """
+
+        stable_lines = stable_ansi.splitlines(keepends=True)
+        stable_ends_blank = bool(stable_lines) and not stable_lines[-1].strip()
+        if not stable_ends_blank:
+            return live_ansi
+
+        live_lines = live_ansi.splitlines(keepends=True)
+        while live_lines and not live_lines[0].strip():
+            live_lines.pop(0)
+        return "".join(live_lines)
+
+    def _append_nonfinal_sentinel(self, stable_source: str) -> str:
+        """Make Rich render stable content as if it isn't the last block.
+
+        Rich Markdown may omit trailing spacing for the last block in a document.
+        When we render only the stable prefix (without the live suffix), we still
+        need the *inter-block* spacing to match the full document.
+
+        A harmless HTML comment block causes Rich Markdown to emit the expected
+        spacing while rendering no visible content.
+        """
+
+        if not stable_source:
+            return stable_source
+
+        if stable_source.endswith("\n\n"):
+            return stable_source + "<!-- -->"
+        if stable_source.endswith("\n"):
+            return stable_source + "\n<!-- -->"
+        return stable_source + "\n\n<!-- -->"
+
+    def _render_markdown_to_lines(self, text: str, *, apply_mark: bool) -> list[str]:
         """Render markdown text to a list of lines.
 
         Args:
@@ -165,13 +279,8 @@ class MarkdownStream:
         # Render the markdown to a string buffer
         string_io = io.StringIO()
 
-        # Determine console width and adjust for left margin so that
-        # the rendered content plus margins does not exceed the available width.
-        if self.console is not None:
-            base_width = self.console.options.max_width
-        else:
-            probe_console = Console(theme=self.theme)
-            base_width = probe_console.options.max_width
+        # Keep width stable across frames to prevent reflow/jitter.
+        base_width = self._get_base_width()
 
         effective_width = max(base_width - self.left_margin - self.right_margin, 1)
 
@@ -192,14 +301,26 @@ class MarkdownStream:
         indent_prefix = " " * self.left_margin if self.left_margin > 0 else ""
         processed_lines: list[str] = []
         mark_applied = False
-        use_mark = bool(self.mark) and self.left_margin >= 2
+        use_mark = apply_mark and bool(self.mark) and self.left_margin >= 2
+
+        # Pre-render styled mark if needed
+        styled_mark: str | None = None
+        if use_mark and self.mark:
+            if self.mark_style:
+                mark_text = Text(self.mark, style=self.mark_style)
+                mark_buffer = io.StringIO()
+                mark_console = Console(file=mark_buffer, force_terminal=True, theme=self.theme)
+                mark_console.print(mark_text, end="")
+                styled_mark = mark_buffer.getvalue()
+            else:
+                styled_mark = self.mark
 
         for line in lines:
             stripped = line.rstrip()
 
             # Apply mark to the first non-empty line only when left_margin is at least 2.
             if use_mark and not mark_applied and stripped:
-                stripped = f"{self.mark} {stripped}"
+                stripped = f"{styled_mark} {stripped}"
                 mark_applied = True
             elif indent_prefix:
                 stripped = indent_prefix + stripped
@@ -212,102 +333,59 @@ class MarkdownStream:
 
     def __del__(self) -> None:
         """Destructor to ensure Live display is properly cleaned up."""
-        if self.live:
-            # Ignore any errors during cleanup
-            with contextlib.suppress(Exception):
-                self.live.stop()
+        if self._live_sink is None:
+            return
+        with contextlib.suppress(Exception):
+            self._live_sink(None)
 
     def update(self, text: str, final: bool = False) -> None:
-        """Update the displayed markdown content.
-
-        Args:
-            text (str): The markdown text received so far
-            final (bool): If True, this is the final update and we should clean up
+        """Update the display with the latest full markdown buffer."""
 
-        Splits the output into "stable" older lines and the "last few" lines
-        which aren't considered stable. They may shift around as new chunks
-        are appended to the markdown text.
-
-        The stable lines emit to the console above the Live window.
-        The unstable lines emit into the Live window so they can be repainted.
-
-        Markdown going to the console works better in terminal scrollback buffers.
-        The live window doesn't play nice with terminal scrollback.
-        """
-        if not self._live_started:
-            initial_content = self._live_renderable(Text(""), final=False)
-            # transient=False keeps final frame on screen after stop()
-            self.live = Live(
-                initial_content,
-                refresh_per_second=1.0 / self.min_delay,
-                console=self.console,
-            )
-            self.live.start()
-
-        if self.live is None:
+        if self._live_sink is None:
             return
 
         now = time.time()
-        # Throttle updates to maintain smooth rendering
         if not final and now - self.when < self.min_delay:
             return
         self.when = now
 
-        # Measure render time and adjust min_delay to maintain smooth rendering
-        start = time.time()
-        lines = self._render_markdown_to_lines(text)
-        render_time = time.time() - start
-
-        # Set min_delay to render time plus a small buffer
-        self.min_delay = min(max(render_time * 10, 1.0 / 20), 2)
-
-        num_lines = len(lines)
-
-        # Reserve last live_window lines for Live area to keep height stable
-        num_lines = max(num_lines - self.live_window, 0)
+        previous_stable_line = self._stable_source_line_count
 
-        # Print new stable lines above Live window
-        if num_lines > 0:
-            num_printed = len(self.printed)
-            to_append_count = num_lines - num_printed
+        stable_source, live_source, stable_line = self.split_blocks(
+            text,
+            min_stable_line=previous_stable_line,
+            final=final,
+        )
 
-            if to_append_count > 0:
-                append_chunk = lines[num_printed:num_lines]
-                append_chunk_text = Text.from_ansi("".join(append_chunk))
-                live = self.live
-                assert live is not None
-                live.console.print(append_chunk_text)
-                self.printed = lines[:num_lines]
+        start = time.time()
 
-        rest_lines = lines[num_lines:]
+        stable_changed = final or stable_line > self._stable_source_line_count
+        if stable_changed and stable_source:
+            stable_ansi = self.render_stable_ansi(stable_source, has_live_suffix=bool(live_source), final=final)
+            stable_lines = stable_ansi.splitlines(keepends=True)
+            new_lines = stable_lines[len(self._stable_rendered_lines) :]
+            if new_lines:
+                stable_chunk = "".join(new_lines)
+                self.console.print(Text.from_ansi(stable_chunk), end="\n")
+            self._stable_rendered_lines = stable_lines
+            self._stable_source_line_count = stable_line
+        elif final and not stable_source:
+            self._stable_rendered_lines = []
+            self._stable_source_line_count = stable_line
 
-        # Final: render remaining lines without spinner, then stop Live
         if final:
-            live = self.live
-            assert live is not None
-            rest = "".join(rest_lines)
-            rest_text = Text.from_ansi(rest)
-            final_renderable = self._live_renderable(rest_text, final=True)
-            live.update(final_renderable)
-            live.stop()
-            self.live = None
+            self._live_sink(None)
             return
 
-        rest = "".join(rest_lines)
-        rest = Text.from_ansi(rest)
-        live = self.live
-        assert live is not None
-        live_renderable = self._live_renderable(rest, final)
-        live.update(live_renderable)
+        apply_mark_live = self._stable_source_line_count == 0
+        live_lines = self._render_markdown_to_lines(live_source, apply_mark=apply_mark_live)
 
-    def _live_renderable(self, rest: Text, final: bool) -> RenderableType:
-        if final or not self.spinner:
-            return rest
-        else:
-            return Group(rest, Text(), self.spinner)
+        if self._stable_rendered_lines and not self._stable_rendered_lines[-1].strip():
+            while live_lines and not live_lines[0].strip():
+                live_lines.pop(0)
 
-    def find_minimal_suffix(self, text: str, match_lines: int = 50) -> None:
-        """
-        Splits text into chunks on blank lines "\n\n".
-        """
-        return None
+        live_text = Text.from_ansi("".join(live_lines))
+        self._live_sink(live_text)
+
+        elapsed = time.time() - start
+        self.min_delay = min(max(elapsed * 6, 1.0 / 30), 0.5)