klaude-code 1.2.15__py3-none-any.whl → 1.2.17__py3-none-any.whl

klaude_code/ui/modes/repl/event_handler.py

@@ -121,7 +121,7 @@ class ActivityState:
             for name, count in self._tool_calls.items():
                 if not first:
                     activity_text.append(", ")
-                activity_text.append(name, style="bold")
+                activity_text.append(name)
                 if count > 1:
                     activity_text.append(f" x {count}")
                 first = False
@@ -137,11 +137,13 @@ class SpinnerStatusState:
     Composed of two independent layers:
     - base_status: Set by TodoChange, persistent within a turn
     - activity: Current activity (composing or tool_calls), mutually exclusive
+    - context_percent: Context usage percentage, updated during task execution
 
     Display logic:
     - If activity: show base + activity (if base exists) or activity + "..."
     - Elif base_status: show base_status
     - Else: show "Thinking …"
+    - Context percent is appended at the end if available
     """
 
     DEFAULT_STATUS = "Thinking …"
@@ -149,11 +151,13 @@ class SpinnerStatusState:
     def __init__(self) -> None:
         self._base_status: str | None = None
         self._activity = ActivityState()
+        self._context_percent: float | None = None
 
     def reset(self) -> None:
         """Reset all layers."""
         self._base_status = None
         self._activity.reset()
+        self._context_percent = None
 
     def set_base_status(self, status: str | None) -> None:
         """Set base status from TodoChange."""
@@ -175,8 +179,16 @@ class SpinnerStatusState:
         """Clear activity state for a new turn."""
         self._activity.reset()
 
+    def set_context_percent(self, percent: float) -> None:
+        """Set context usage percentage."""
+        self._context_percent = percent
+
+    def get_activity_text(self) -> Text | None:
+        """Get current activity text. Returns None if idle."""
+        return self._activity.get_activity_text()
+
     def get_status(self) -> Text:
-        """Get current spinner status as rich Text."""
+        """Get current spinner status as rich Text (without context)."""
         activity_text = self._activity.get_activity_text()
 
         if self._base_status:
@@ -184,11 +196,19 @@ class SpinnerStatusState:
             if activity_text:
                 result.append(" | ")
                 result.append_text(activity_text)
-            return result
-        if activity_text:
+        elif activity_text:
             activity_text.append(" …")
-            return activity_text
-        return Text(self.DEFAULT_STATUS)
+            result = activity_text
+        else:
+            result = Text(self.DEFAULT_STATUS)
+
+        return result
+
+    def get_context_text(self) -> Text | None:
+        """Get context usage text for right-aligned display."""
+        if self._context_percent is None:
+            return None
+        return Text(f"{self._context_percent:.1f}%", style=ThemeKey.METADATA_DIM)
 
 
 class DisplayEventHandler:
@@ -243,6 +263,8 @@ class DisplayEventHandler:
                 self._on_task_metadata(e)
             case events.TodoChangeEvent() as e:
                 self._on_todo_change(e)
+            case events.ContextUsageEvent() as e:
+                self._on_context_usage(e)
             case events.TurnEndEvent():
                 pass
             case events.ResponseMetadataEvent():
@@ -377,6 +399,7 @@ class DisplayEventHandler:
         self.spinner_status.set_composing(False)
         self._update_spinner()
         await self.stage_manager.transition_to(Stage.WAITING)
+        self.renderer.print()
         self.renderer.spinner_start()
 
     def _on_tool_call_start(self, event: events.TurnToolCallStartEvent) -> None:
@@ -407,6 +430,12 @@ class DisplayEventHandler:
         self.spinner_status.clear_for_new_turn()
         self._update_spinner()
 
+    def _on_context_usage(self, event: events.ContextUsageEvent) -> None:
+        if self.renderer.is_sub_agent_session(event.session_id):
+            return
+        self.spinner_status.set_context_percent(event.context_percent)
+        self._update_spinner()
+
     async def _on_task_finish(self, event: events.TaskFinishEvent) -> None:
         self.renderer.display_task_finish(event)
         if not self.renderer.is_sub_agent_session(event.session_id):
@@ -454,7 +483,10 @@ class DisplayEventHandler:
 
     def _update_spinner(self) -> None:
         """Update spinner text from current status state."""
-        self.renderer.spinner_update(self.spinner_status.get_status())
+        self.renderer.spinner_update(
+            self.spinner_status.get_status(),
+            self.spinner_status.get_context_text(),
+        )
 
     async def _flush_assistant_buffer(self, state: StreamState) -> None:
         if state.is_active:
@@ -476,6 +508,7 @@ class DisplayEventHandler:
             mdstream.update(self.thinking_stream.buffer, final=True)
             self.thinking_stream.finish()
             self.renderer.console.pop_theme()
+            self.renderer.print()
             self.renderer.spinner_start()
 
     def _maybe_notify_task_finish(self, event: events.TaskFinishEvent) -> None:
@@ -512,7 +545,31 @@ class DisplayEventHandler:
                 if len(todo.content) > 0:
                     status_text = todo.content
         status_text = status_text.replace("\n", "")
-        return self._truncate_status_text(status_text, max_length=50)
+        max_length = self._calculate_base_status_max_length()
+        return self._truncate_status_text(status_text, max_length=max_length)
+
+    def _calculate_base_status_max_length(self) -> int:
+        """Calculate max length for base_status based on terminal width.
+
+        Reserve space for:
+        - Spinner glyph + space + context text: 2 chars + context text length 10 chars
+        - " | " separator: 3 chars (only if activity text present)
+        - Activity text: actual length (only if present)
+        - Status hint text (esc to interrupt)
+        """
+        terminal_width = self.renderer.console.size.width
+
+        # Base reserved space: spinner + context + status hint
+        reserved_space = 12 + len(const.STATUS_HINT_TEXT)
+
+        # Add space for activity text if present
+        activity_text = self.spinner_status.get_activity_text()
+        if activity_text:
+            # " | " separator + actual activity text length
+            reserved_space += 3 + len(activity_text.plain)
+
+        max_length = max(10, terminal_width - reserved_space)
+        return max_length
 
     def _truncate_status_text(self, text: str, max_length: int) -> str:
         if len(text) <= max_length:

klaude_code/ui/modes/repl/renderer.py

@@ -50,7 +50,7 @@ class REPLRenderer:
 
         self.session_map: dict[str, SessionStatus] = {}
         self.current_sub_agent_color: Style | None = None
-        self.subagent_color_index = 0
+        self.sub_agent_color_index = 0
 
     def register_session(self, session_id: str, sub_agent_state: model.SubAgentState | None = None) -> None:
         session_status = SessionStatus(
@@ -66,16 +66,16 @@ class REPLRenderer:
     def _advance_sub_agent_color_index(self) -> None:
         palette_size = len(self.themes.sub_agent_colors)
         if palette_size == 0:
-            self.subagent_color_index = 0
+            self.sub_agent_color_index = 0
             return
-        self.subagent_color_index = (self.subagent_color_index + 1) % palette_size
+        self.sub_agent_color_index = (self.sub_agent_color_index + 1) % palette_size
 
     def pick_sub_agent_color(self) -> Style:
         self._advance_sub_agent_color_index()
         palette = self.themes.sub_agent_colors
         if not palette:
             return Style()
-        return palette[self.subagent_color_index]
+        return palette[self.sub_agent_color_index]
 
     def get_session_sub_agent_color(self, session_id: str) -> Style:
         status = self.session_map.get(session_id)
@@ -100,9 +100,9 @@ class REPLRenderer:
         if self.current_sub_agent_color:
             if objects:
                 content = objects[0] if len(objects) == 1 else objects
-                self.console.print(Quote(content, style=self.current_sub_agent_color))
+                self.console.print(Quote(content, style=self.current_sub_agent_color), overflow="ellipsis")
             return
-        self.console.print(*objects, style=style, end=end)
+        self.console.print(*objects, style=style, end=end, overflow="ellipsis")
 
     def display_tool_call(self, e: events.ToolCallEvent) -> None:
         if r_tools.is_sub_agent_tool(e.tool_name):
@@ -152,6 +152,7 @@ class REPLRenderer:
                     case events.ThinkingEvent() as e:
                         if is_sub_agent:
                             continue
+                        self.display_thinking_prefix()
                         self.display_thinking(e.content)
                     case events.DeveloperMessageEvent() as e:
                         self.display_developer_message(e)
@@ -233,6 +234,7 @@ class REPLRenderer:
                     r_sub_agent.render_sub_agent_result(
                         event.task_result,
                         code_theme=self.themes.code_theme,
+                        has_structured_output=event.has_structured_output,
                     )
                 )
 
@@ -262,9 +264,9 @@ class REPLRenderer:
         """Stop the spinner animation."""
         self._spinner.stop()
 
-    def spinner_update(self, status_text: str | Text) -> None:
-        """Update the spinner status text."""
-        self._spinner.update(ShimmerStatusText(status_text, ThemeKey.SPINNER_STATUS_TEXT))
+    def spinner_update(self, status_text: str | Text, right_text: Text | None = None) -> None:
+        """Update the spinner status text with optional right-aligned text."""
+        self._spinner.update(ShimmerStatusText(status_text, ThemeKey.SPINNER_STATUS_TEXT, right_text))
 
     def spinner_renderable(self) -> Spinner:
         """Return the spinner's renderable for embedding in other components."""

klaude_code/ui/renderers/developer.py

@@ -67,13 +67,24 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
     if e.item.at_files:
         grid = create_grid()
         for at_file in e.item.at_files:
-            grid.add_row(
-                Text("  +", style=ThemeKey.REMINDER),
-                Text.assemble(
-                    (f"{at_file.operation} ", ThemeKey.REMINDER),
-                    render_path(at_file.path, ThemeKey.REMINDER_BOLD),
-                ),
-            )
+            if at_file.mentioned_in:
+                grid.add_row(
+                    Text("  +", style=ThemeKey.REMINDER),
+                    Text.assemble(
+                        (f"{at_file.operation} ", ThemeKey.REMINDER),
+                        render_path(at_file.path, ThemeKey.REMINDER_BOLD),
+                        (" mentioned in ", ThemeKey.REMINDER),
+                        render_path(at_file.mentioned_in, ThemeKey.REMINDER_BOLD),
+                    ),
+                )
+            else:
+                grid.add_row(
+                    Text("  +", style=ThemeKey.REMINDER),
+                    Text.assemble(
+                        (f"{at_file.operation} ", ThemeKey.REMINDER),
+                        render_path(at_file.path, ThemeKey.REMINDER_BOLD),
+                    ),
+                )
         parts.append(grid)
 
     if uic := e.item.user_image_count:

klaude_code/ui/renderers/metadata.py

@@ -59,20 +59,32 @@ def _render_task_metadata_block(
     parts: list[Text] = []
 
     if metadata.usage is not None:
-        # Tokens: ↑37k c5k ↓907 r45k
-        token_parts: list[tuple[str, str]] = [
-            ("↑", ThemeKey.METADATA_DIM),
-            (format_number(metadata.usage.input_tokens), ThemeKey.METADATA),
+        # Tokens: ↑ 37k cache 5k ↓ 907 think 45k
+        token_parts: list[Text] = [
+            Text.assemble(
+                ("↑ ", ThemeKey.METADATA_DIM), (format_number(metadata.usage.input_tokens), ThemeKey.METADATA)
+            )
         ]
         if metadata.usage.cached_tokens > 0:
-            token_parts.append((" c", ThemeKey.METADATA_DIM))
-            token_parts.append((format_number(metadata.usage.cached_tokens), ThemeKey.METADATA))
-        token_parts.append((" ↓", ThemeKey.METADATA_DIM))
-        token_parts.append((format_number(metadata.usage.output_tokens), ThemeKey.METADATA))
+            token_parts.append(
+                Text.assemble(
+                    Text("cache ", style=ThemeKey.METADATA_DIM),
+                    Text(format_number(metadata.usage.cached_tokens), style=ThemeKey.METADATA),
+                )
+            )
+        token_parts.append(
+            Text.assemble(
+                ("↓ ", ThemeKey.METADATA_DIM), (format_number(metadata.usage.output_tokens), ThemeKey.METADATA)
+            )
+        )
         if metadata.usage.reasoning_tokens > 0:
-            token_parts.append((" r", ThemeKey.METADATA_DIM))
-            token_parts.append((format_number(metadata.usage.reasoning_tokens), ThemeKey.METADATA))
-        parts.append(Text.assemble(*token_parts))
+            token_parts.append(
+                Text.assemble(
+                    ("think ", ThemeKey.METADATA_DIM),
+                    (format_number(metadata.usage.reasoning_tokens), ThemeKey.METADATA),
+                )
+            )
+        parts.append(Text(" · ").join(token_parts))
 
     # Cost
     if metadata.usage is not None and metadata.usage.total_cost is not None:
@@ -141,7 +153,7 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
     for meta in sorted_items:
         renderables.append(_render_task_metadata_block(meta, is_sub_agent=True, show_context_and_time=False))
 
-    return Padding(Group(*renderables), (0, 0, 0, 1))
+    return Group(*renderables)
 
 
 def render_welcome(e: events.WelcomeEvent, *, box_style: Box | None = None) -> RenderableType:

klaude_code/ui/renderers/sub_agent.py

@@ -1,6 +1,8 @@
 import json
+from typing import Any, cast
 
 from rich.console import Group, RenderableType
+from rich.json import JSON
 from rich.panel import Panel
 from rich.style import Style
 from rich.text import Text
@@ -12,20 +14,71 @@ from klaude_code.ui.rich.markdown import NoInsetMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 
 
+def _compact_schema_value(value: dict[str, Any]) -> str | list[Any] | dict[str, Any]:
+    """Convert a JSON Schema value to compact representation."""
+    value_type = value.get("type", "any").lower()
+    desc = value.get("description", "")
+
+    if value_type == "object":
+        props = value.get("properties", {})
+        return {k: _compact_schema_value(v) for k, v in props.items()}
+    elif value_type == "array":
+        items = value.get("items", {})
+        # If items have no description, use the array's description
+        if desc and not items.get("description"):
+            items = {**items, "description": desc}
+        return [_compact_schema_value(items)]
+    else:
+        if desc:
+            return f"{value_type} // {desc}"
+        return value_type
+
+
+def _compact_schema(schema: dict[str, Any]) -> dict[str, Any] | list[Any] | str:
+    """Convert JSON Schema to compact representation for display."""
+    return _compact_schema_value(schema)
+
+
 def render_sub_agent_call(e: model.SubAgentState, style: Style | None = None) -> RenderableType:
     """Render sub-agent tool call header and prompt body."""
     desc = Text(
         f" {e.sub_agent_desc} ",
         style=Style(color=style.color if style else None, bold=True, reverse=True),
     )
-    return Group(
+    elements: list[RenderableType] = [
         Text.assemble((e.sub_agent_type, ThemeKey.TOOL_NAME), " ", desc),
         Text(e.sub_agent_prompt, style=style or ""),
-    )
+    ]
+    if e.output_schema:
+        elements.append(Text("\nExpected Output Format JSON:", style=style or ""))
+        compact = _compact_schema(e.output_schema)
+        schema_text = json.dumps(compact, ensure_ascii=False, indent=2)
+        elements.append(JSON(schema_text))
+    return Group(*elements)
 
 
-def render_sub_agent_result(result: str, *, code_theme: str, style: Style | None = None) -> RenderableType:
+def render_sub_agent_result(
+    result: str, *, code_theme: str, style: Style | None = None, has_structured_output: bool = False
+) -> RenderableType:
     stripped_result = result.strip()
+
+    # Use rich JSON for structured output
+    if has_structured_output:
+        try:
+            return Panel.fit(
+                Group(
+                    Text(
+                        "use /export to view full output",
+                        style=ThemeKey.TOOL_RESULT,
+                    ),
+                    JSON(stripped_result),
+                ),
+                border_style=ThemeKey.LINES,
+            )
+        except json.JSONDecodeError:
+            # Fall back to markdown if not valid JSON
+            pass
+
     lines = stripped_result.splitlines()
     if len(lines) > const.SUB_AGENT_RESULT_MAX_LINES:
         hidden_count = len(lines) - const.SUB_AGENT_RESULT_MAX_LINES
@@ -53,6 +106,7 @@ def build_sub_agent_state_from_tool_call(e: events.ToolCallEvent) -> model.SubAg
         return None
     description = profile.name
     prompt = ""
+    output_schema: dict[str, Any] | None = None
     if e.arguments:
         try:
             payload: dict[str, object] = json.loads(e.arguments)
@@ -64,8 +118,14 @@ def build_sub_agent_state_from_tool_call(e: events.ToolCallEvent) -> model.SubAg
         prompt_value = payload.get("prompt") or payload.get("task")
         if isinstance(prompt_value, str):
             prompt = prompt_value.strip()
+        # Extract output_schema if profile supports it
+        if profile.output_schema_arg:
+            schema_value = payload.get(profile.output_schema_arg)
+            if isinstance(schema_value, dict):
+                output_schema = cast(dict[str, Any], schema_value)
     return model.SubAgentState(
         sub_agent_type=profile.name,
         sub_agent_desc=description,
         sub_agent_prompt=prompt,
+        output_schema=output_schema,
     )

klaude_code/ui/renderers/thinking.py

@@ -16,7 +16,7 @@ def _normalize_thinking_content(content: str) -> str:
         content.rstrip()
         .replace("**\n\n", "**  \n")
         .replace("\\n\\n\n\n", "")  # Weird case of Gemini 3
-        .replace("****", "**\n\n**")  # remove extra newlines after bold titles
+        .replace("****", "**\n\n**")  # Remove extra newlines after bold titles
     )
 
 

klaude_code/ui/renderers/tools.py

@@ -7,7 +7,7 @@ from rich.padding import Padding
 from rich.text import Text
 
 from klaude_code import const
-from klaude_code.protocol import events, model
+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
@@ -186,14 +186,7 @@ def render_write_tool_call(arguments: str) -> RenderableType:
     try:
         json_dict = json.loads(arguments)
         file_path = json_dict.get("file_path")
-        op_label = "Create"
-        if isinstance(file_path, str):
-            abs_path = Path(file_path)
-            if not abs_path.is_absolute():
-                abs_path = (Path().cwd() / abs_path).resolve()
-            if abs_path.exists():
-                op_label = "Overwrite"
-        tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", (op_label, ThemeKey.TOOL_NAME))
+        tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("Write", ThemeKey.TOOL_NAME))
         arguments_column = render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
     except json.JSONDecodeError:
         tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("Write", ThemeKey.TOOL_NAME))
@@ -435,35 +428,29 @@ def get_truncation_info(tr: events.ToolResultEvent) -> model.TruncationUIExtra |
     return _extract_truncation(tr.ui_extra)
 
 
-# Tool name to mark mapping
-_TOOL_MARKS: dict[str, str] = {
-    "Read": "←",
-    "Edit": "→",
-    "Write": "→",
-    "MultiEdit": "→",
-    "Bash": ">",
-    "apply_patch": "→",
-    "TodoWrite": "◎",
-    "update_plan": "◎",
-    "Mermaid": "⧉",
-    "Memory": "★",
-    "Skill": "◈",
-}
+def render_report_back_tool_call() -> RenderableType:
+    grid = create_grid()
+    tool_name_column = Text.assemble(("✔", ThemeKey.TOOL_MARK), " ", ("Report Back", ThemeKey.TOOL_NAME))
+    grid.add_row(tool_name_column, "")
+    return grid
+
 
 # Tool name to active form mapping (for spinner status)
 _TOOL_ACTIVE_FORM: dict[str, str] = {
-    "Bash": "Bashing",
-    "apply_patch": "Patching",
-    "Edit": "Editing",
-    "MultiEdit": "Editing",
-    "Read": "Reading",
-    "Write": "Writing",
-    "TodoWrite": "Planning",
-    "update_plan": "Planning",
-    "Skill": "Skilling",
-    "Mermaid": "Diagramming",
-    "Memory": "Memorizing",
-    "WebFetch": "Fetching",
+    tools.BASH: "Bashing",
+    tools.APPLY_PATCH: "Patching",
+    tools.EDIT: "Editing",
+    tools.MULTI_EDIT: "Editing",
+    tools.READ: "Reading",
+    tools.WRITE: "Writing",
+    tools.TODO_WRITE: "Planning",
+    tools.UPDATE_PLAN: "Planning",
+    tools.SKILL: "Skilling",
+    tools.MERMAID: "Diagramming",
+    tools.MEMORY: "Memorizing",
+    tools.WEB_FETCH: "Fetching Web",
+    tools.WEB_SEARCH: "Searching Web",
+    tools.REPORT_BACK: "Reporting",
 }
 
 
@@ -490,7 +477,6 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
 
     Returns a Rich Renderable or None if the tool call should not be rendered.
     """
-    from klaude_code.protocol import tools
 
     if is_sub_agent_tool(e.tool_name):
         return None
@@ -518,6 +504,8 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
             return render_memory_tool_call(e.arguments)
         case tools.SKILL:
             return render_generic_tool_call(e.tool_name, e.arguments, "◈")
+        case tools.REPORT_BACK:
+            return render_report_back_tool_call()
         case _:
             return render_generic_tool_call(e.tool_name, e.arguments)
 
@@ -533,7 +521,6 @@ def render_tool_result(e: events.ToolResultEvent) -> RenderableType | None:
 
     Returns a Rich Renderable or None if the tool result should not be rendered.
     """
-    from klaude_code.protocol import tools
     from klaude_code.ui.renderers import errors as r_errors
 
     if is_sub_agent_tool(e.tool_name):

klaude_code/ui/rich/markdown.py

@@ -32,9 +32,9 @@ class NoInsetCodeBlock(CodeBlock):
             self.lexer_name,
             theme=self.theme,
             word_wrap=True,
-            padding=(0, 1),
+            padding=(0, 0),
         )
-        yield Panel.fit(syntax, padding=(0, 0), style="markdown.code.block", box=box.SIMPLE)
+        yield Panel.fit(syntax, padding=(0, 0), box=box.HORIZONTALS, border_style="markdown.code.border")
 
 
 class ThinkingCodeBlock(CodeBlock):
@@ -42,7 +42,7 @@ class ThinkingCodeBlock(CodeBlock):
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         code = str(self.text).rstrip()
-        text = Text("```\n" + code + "\n```")
+        text = Text(code, "markdown.code.block")
         yield text
 
 
@@ -52,7 +52,10 @@ class LeftHeading(Heading):
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         text = self.text
         text.justify = "left"  # Override justification
-        if self.tag == "h2":
+        if self.tag == "h1":
+            h1_text = text.assemble((" ", "markdown.h1"), text, (" ", "markdown.h1"))
+            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")
         else:
@@ -123,10 +126,6 @@ class MarkdownStream:
         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
-        # Track the maximum height the live window has ever reached
-        # so we only pad when it shrinks from a previous height,
-        # instead of always padding to live_window from the start.
-        self._live_window_seen_height: int = 0
 
         self.theme = theme
         self.console = console
@@ -221,18 +220,16 @@ class MarkdownStream:
         Markdown going to the console works better in terminal scrollback buffers.
         The live window doesn't play nice with terminal scrollback.
         """
-        # On the first call, start the Live renderer
         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()
-            # Note: self._live_started is now a property derived from self.live
 
-        # If live rendering isn't available (e.g., after a final update), stop.
         if self.live is None:
             return
 
@@ -252,61 +249,36 @@ class MarkdownStream:
 
         num_lines = len(lines)
 
-        # How many lines have "left" the live window and are now considered stable?
-        # Or if final, consider all lines to be stable.
-        if not final:
-            num_lines = max(num_lines - self.live_window, 0)
+        # Reserve last live_window lines for Live area to keep height stable
+        num_lines = max(num_lines - self.live_window, 0)
 
-        # If there is new stable content, append only the new part
-        # Update Live window to prevent visual duplication
-        if final or num_lines > 0:
-            # Lines to append to stable area
+        # Print new stable lines above Live window
+        if num_lines > 0:
             num_printed = len(self.printed)
             to_append_count = num_lines - num_printed
 
             if to_append_count > 0:
-                # Print new stable lines above Live window
                 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)  # Print above Live area
-
-                # Track printed stable lines
+                live.console.print(append_chunk_text)
                 self.printed = lines[:num_lines]
 
-        # Handle final update cleanup
+        rest_lines = lines[num_lines:]
+
+        # Final: render remaining lines without spinner, then stop Live
         if final:
             live = self.live
             assert live is not None
-            live.update(Text(""))
+            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
             return
 
-        # Update Live window to prevent timing issues
-        # with console.print above. We pad the live region
-        # so that its height stays stable when it shrinks
-        # from a previously reached height, avoiding spinner jitter.
-        rest_lines = lines[num_lines:]
-
-        if not final:
-            current_height = len(rest_lines)
-
-            # Update the maximum height we've seen so far for this live window.
-            if current_height > self._live_window_seen_height:
-                # Never exceed configured live_window, even if logic changes later.
-                self._live_window_seen_height = min(current_height, self.live_window)
-
-            target_height = min(self._live_window_seen_height, self.live_window)
-            if target_height > 0 and current_height < target_height:
-                # Pad only up to the maximum height we've seen so far.
-                # This keeps the Live region height stable without overshooting,
-                # which can cause the spinner to jump by a line.
-                pad_count = target_height - current_height
-                # Pad after the existing lines so spinner visually stays at the bottom.
-                rest_lines = rest_lines + ["\n"] * pad_count
-
         rest = "".join(rest_lines)
         rest = Text.from_ansi(rest)
         live = self.live