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

klaude_code/ui/modes/repl/event_handler.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from rich.cells import cell_len
 from rich.rule import Rule
 from rich.text import Text
 
@@ -10,13 +11,48 @@ from klaude_code.protocol import events
 from klaude_code.ui.core.stage_manager import Stage, StageManager
 from klaude_code.ui.modes.repl.renderer import REPLRenderer
 from klaude_code.ui.renderers.assistant import ASSISTANT_MESSAGE_MARK
-from klaude_code.ui.renderers.thinking import normalize_thinking_content
+from klaude_code.ui.renderers.thinking import THINKING_MESSAGE_MARK, normalize_thinking_content
 from klaude_code.ui.rich.markdown import MarkdownStream, ThinkingMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 from klaude_code.ui.terminal.notifier import Notification, NotificationType, TerminalNotifier
 from klaude_code.ui.terminal.progress_bar import OSC94States, emit_osc94
 
 
+def extract_last_bold_header(text: str) -> str | None:
+    """Extract the latest complete bold header ("**...**") from text.
+
+    We treat a bold segment as a "header" only if it appears at the beginning
+    of a line (ignoring leading whitespace). This avoids picking up incidental
+    emphasis inside paragraphs.
+
+    Returns None if no complete bold segment is available yet.
+    """
+
+    last: str | None = None
+    i = 0
+    while True:
+        start = text.find("**", i)
+        if start < 0:
+            break
+
+        line_start = text.rfind("\n", 0, start) + 1
+        if text[line_start:start].strip():
+            i = start + 2
+            continue
+
+        end = text.find("**", start + 2)
+        if end < 0:
+            break
+
+        inner = " ".join(text[start + 2 : end].split())
+        if inner and "\n" not in inner:
+            last = inner
+
+        i = end + 2
+
+    return last
+
+
 @dataclass
 class ActiveStream:
     """Active streaming state containing buffer and markdown renderer.
@@ -117,7 +153,7 @@ class ActivityState:
             for name, count in self._tool_calls.items():
                 if not first:
                     activity_text.append(", ")
-                activity_text.append(Text(name, style=ThemeKey.SPINNER_STATUS_TEXT_BOLD))
+                activity_text.append(Text(name, style=ThemeKey.STATUS_TEXT_BOLD))
                 if count > 1:
                     activity_text.append(f" x {count}")
                 first = False
@@ -130,8 +166,9 @@ class ActivityState:
 class SpinnerStatusState:
     """Multi-layer spinner status state management.
 
-    Composed of two independent layers:
-    - base_status: Set by TodoChange, persistent within a turn
+    Layers:
+    - todo_status: Set by TodoChange (preferred when present)
+    - reasoning_status: Derived from Thinking/ThinkingDelta bold headers
     - activity: Current activity (composing or tool_calls), mutually exclusive
     - context_percent: Context usage percentage, updated during task execution
 
@@ -142,25 +179,31 @@ class SpinnerStatusState:
     - Context percent is appended at the end if available
     """
 
-    DEFAULT_STATUS = "Thinking …"
-
     def __init__(self) -> None:
-        self._base_status: str | None = None
+        self._todo_status: str | None = None
+        self._reasoning_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._todo_status = None
+        self._reasoning_status = None
         self._activity.reset()
         self._context_percent = None
 
-    def set_base_status(self, status: str | None) -> None:
+    def set_todo_status(self, status: str | None) -> None:
         """Set base status from TodoChange."""
-        self._base_status = status
+        self._todo_status = status
+
+    def set_reasoning_status(self, status: str | None) -> None:
+        """Set reasoning-derived base status from ThinkingDelta bold headers."""
+        self._reasoning_status = status
 
     def set_composing(self, composing: bool) -> None:
         """Set composing state when assistant is streaming."""
+        if composing:
+            self._reasoning_status = None
         self._activity.set_composing(composing)
 
     def add_tool_call(self, tool_name: str) -> None:
@@ -187,8 +230,10 @@ class SpinnerStatusState:
         """Get current spinner status as rich Text (without context)."""
         activity_text = self._activity.get_activity_text()
 
-        if self._base_status:
-            result = Text(self._base_status)
+        base_status = self._todo_status or self._reasoning_status
+
+        if base_status:
+            result = Text(base_status, style=ThemeKey.STATUS_TEXT_BOLD)
             if activity_text:
                 result.append(" | ")
                 result.append_text(activity_text)
@@ -196,7 +241,7 @@ class SpinnerStatusState:
             activity_text.append(" …")
             result = activity_text
         else:
-            result = Text(self.DEFAULT_STATUS)
+            result = Text(const.STATUS_DEFAULT_TEXT, style=ThemeKey.STATUS_TEXT)
 
         return result
 
@@ -220,7 +265,6 @@ class DisplayEventHandler:
         self.stage_manager = StageManager(
             finish_assistant=self._finish_assistant_stream,
             finish_thinking=self._finish_thinking_stream,
-            on_enter_thinking=self._print_thinking_prefix,
         )
 
     async def consume_event(self, event: events.Event) -> None:
@@ -311,6 +355,10 @@ class DisplayEventHandler:
             await self._finish_thinking_stream()
         else:
             # Non-streaming path (history replay or models without delta support)
+            reasoning_status = extract_last_bold_header(normalize_thinking_content(event.content))
+            if reasoning_status:
+                self.spinner_status.set_reasoning_status(reasoning_status)
+                self._update_spinner()
             await self.stage_manager.enter_thinking_stage()
             self.renderer.display_thinking(event.content)
 
@@ -320,23 +368,28 @@ class DisplayEventHandler:
 
         first_delta = not self.thinking_stream.is_active
         if first_delta:
-            self.renderer.console.push_theme(self.renderer.themes.thinking_markdown_theme)
             mdstream = MarkdownStream(
                 mdargs={
                     "code_theme": self.renderer.themes.code_theme,
-                    "style": self.renderer.console.get_style(ThemeKey.THINKING),
+                    "style": ThemeKey.THINKING,
                 },
                 theme=self.renderer.themes.thinking_markdown_theme,
                 console=self.renderer.console,
-                spinner=self.renderer.spinner_renderable(),
+                live_sink=self.renderer.set_stream_renderable,
+                mark=THINKING_MESSAGE_MARK,
+                mark_style=ThemeKey.THINKING,
                 left_margin=const.MARKDOWN_LEFT_MARGIN,
                 markdown_class=ThinkingMarkdown,
             )
             self.thinking_stream.start(mdstream)
-            self.renderer.spinner_stop()
 
         self.thinking_stream.append(event.content)
 
+        reasoning_status = extract_last_bold_header(normalize_thinking_content(self.thinking_stream.buffer))
+        if reasoning_status:
+            self.spinner_status.set_reasoning_status(reasoning_status)
+            self._update_spinner()
+
         if first_delta and self.thinking_stream.mdstream is not None:
             self.thinking_stream.mdstream.update(normalize_thinking_content(self.thinking_stream.buffer))
 
@@ -359,17 +412,13 @@ class DisplayEventHandler:
                 mdargs={"code_theme": self.renderer.themes.code_theme},
                 theme=self.renderer.themes.markdown_theme,
                 console=self.renderer.console,
-                spinner=self.renderer.spinner_renderable(),
+                live_sink=self.renderer.set_stream_renderable,
                 mark=ASSISTANT_MESSAGE_MARK,
                 left_margin=const.MARKDOWN_LEFT_MARGIN,
             )
             self.assistant_stream.start(mdstream)
         self.assistant_stream.append(event.content)
         if first_delta and self.assistant_stream.mdstream is not None:
-            # Stop spinner and immediately start MarkdownStream's Live
-            # to avoid flicker. The update() call starts the Live with
-            # the spinner embedded, providing seamless transition.
-            self.renderer.spinner_stop()
             self.assistant_stream.mdstream.update(self.assistant_stream.buffer)
         await self.stage_manager.transition_to(Stage.ASSISTANT)
         await self._flush_assistant_buffer(self.assistant_stream)
@@ -415,7 +464,7 @@ class DisplayEventHandler:
 
     def _on_todo_change(self, event: events.TodoChangeEvent) -> None:
         active_form_status_text = self._extract_active_form_text(event)
-        self.spinner_status.set_base_status(active_form_status_text if active_form_status_text else None)
+        self.spinner_status.set_todo_status(active_form_status_text if active_form_status_text else None)
         # Clear tool calls when todo changes, as the tool execution has advanced
         self.spinner_status.clear_for_new_turn()
         self._update_spinner()
@@ -433,7 +482,6 @@ class DisplayEventHandler:
             self.spinner_status.reset()
             self.renderer.spinner_stop()
             self.renderer.console.print(Rule(characters="-", style=ThemeKey.LINES))
-            self.renderer.print()
         await self.stage_manager.transition_to(Stage.WAITING)
         self._maybe_notify_task_finish(event)
 
@@ -469,14 +517,14 @@ class DisplayEventHandler:
             mdstream.update(self.assistant_stream.buffer, final=True)
             self.assistant_stream.finish()
 
-    def _print_thinking_prefix(self) -> None:
-        self.renderer.display_thinking_prefix()
-
     def _update_spinner(self) -> None:
         """Update spinner text from current status state."""
+        status_text = self.spinner_status.get_status()
+        context_text = self.spinner_status.get_context_text()
+        status_text = self._truncate_spinner_status_text(status_text, right_text=context_text)
         self.renderer.spinner_update(
-            self.spinner_status.get_status(),
-            self.spinner_status.get_context_text(),
+            status_text,
+            context_text,
         )
 
     async def _flush_assistant_buffer(self, state: StreamState) -> None:
@@ -497,7 +545,6 @@ class DisplayEventHandler:
             assert mdstream is not None
             mdstream.update(normalize_thinking_content(self.thinking_stream.buffer), final=True)
             self.thinking_stream.finish()
-            self.renderer.console.pop_theme()
             self.renderer.print()
             self.renderer.spinner_start()
 
@@ -534,35 +581,28 @@ class DisplayEventHandler:
                     status_text = todo.active_form
                 if len(todo.content) > 0:
                     status_text = todo.content
-        status_text = status_text.replace("\n", "")
-        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)
+        return status_text.replace("\n", " ").strip()
+
+    def _truncate_spinner_status_text(self, status_text: Text, *, right_text: Text | None) -> Text:
+        """Truncate spinner status to a single line based on terminal width.
+
+        Rich wraps based on terminal cell width (CJK chars count as 2). Use
+        cell-aware truncation to prevent the status from wrapping into two lines.
         """
+
         terminal_width = self.renderer.console.size.width
 
-        # Base reserved space: spinner + context + status hint
-        reserved_space = 12 + len(const.STATUS_HINT_TEXT)
+        # BreathingSpinner renders as a 2-column Table.grid(padding=1):
+        # 1 cell for glyph + 1 cell of padding between columns (collapsed).
+        spinner_prefix_cells = 2
 
-        # 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)
+        hint_cells = cell_len(const.STATUS_HINT_TEXT)
+        right_cells = cell_len(right_text.plain) if right_text is not None else 0
 
-        max_length = max(10, terminal_width - reserved_space)
-        return max_length
+        max_main_cells = terminal_width - spinner_prefix_cells - hint_cells - right_cells - 1
+        # rich.text.Text.truncate behaves unexpectedly for 0; clamp to at least 1.
+        max_main_cells = max(1, max_main_cells)
 
-    def _truncate_status_text(self, text: str, max_length: int) -> str:
-        if len(text) <= max_length:
-            return text
-        truncated = text[:max_length]
-        return truncated + "…"
+        truncated = status_text.copy()
+        truncated.truncate(max_main_cells, overflow="ellipsis", pad=False)
+        return truncated

klaude_code/ui/modes/repl/input_prompt_toolkit.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import shutil
 from collections.abc import AsyncIterator, Callable
 from pathlib import Path
@@ -33,7 +34,9 @@ class REPLStatusSnapshot(NamedTuple):
     update_message: str | None = None
 
 
-COMPLETION_SELECTED = "#5869f7"
+COMPLETION_SELECTED_DARK_BG = "#8b9bff"
+COMPLETION_SELECTED_LIGHT_BG = "#5869f7"
+COMPLETION_SELECTED_UNKNOWN_BG = "#7080f0"
 COMPLETION_MENU = "ansibrightblack"
 INPUT_PROMPT_STYLE = "ansimagenta bold"
 PLACEHOLDER_TEXT_STYLE_DARK_BG = "fg:#5a5a5a italic"
@@ -49,8 +52,12 @@ class PromptToolkitInput(InputProviderABC):
         self,
         prompt: str = USER_MESSAGE_MARK,
         status_provider: Callable[[], REPLStatusSnapshot] | None = None,
+        pre_prompt: Callable[[], None] | None = None,
+        post_prompt: Callable[[], None] | None = None,
     ):  # ▌
         self._status_provider = status_provider
+        self._pre_prompt = pre_prompt
+        self._post_prompt = post_prompt
         self._is_light_terminal_background = is_light_terminal_background(timeout=0.2)
 
         project = str(Path.cwd()).strip("/").replace("/", "-")
@@ -66,11 +73,19 @@ class PromptToolkitInput(InputProviderABC):
             at_token_pattern=AT_TOKEN_PATTERN,
         )
 
+        # Select completion selected color based on terminal background
+        if self._is_light_terminal_background is True:
+            completion_selected = COMPLETION_SELECTED_LIGHT_BG
+        elif self._is_light_terminal_background is False:
+            completion_selected = COMPLETION_SELECTED_DARK_BG
+        else:
+            completion_selected = COMPLETION_SELECTED_UNKNOWN_BG
+
         self._session: PromptSession[str] = PromptSession(
             [(INPUT_PROMPT_STYLE, prompt)],
             history=FileHistory(str(history_path)),
             multiline=True,
-            cursor=CursorShape.BEAM,
+            cursor=CursorShape.BLINKING_BEAM,
             prompt_continuation=[(INPUT_PROMPT_STYLE, "  ")],
             key_bindings=kb,
             completer=ThreadedCompleter(create_repl_completer()),
@@ -86,8 +101,8 @@ class PromptToolkitInput(InputProviderABC):
                     "scrollbar.button": "bg:default",
                     "completion-menu.completion": f"bg:default fg:{COMPLETION_MENU}",
                     "completion-menu.meta.completion": f"bg:default fg:{COMPLETION_MENU}",
-                    "completion-menu.completion.current": f"noreverse bg:default fg:{COMPLETION_SELECTED} bold",
-                    "completion-menu.meta.completion.current": f"bg:default fg:{COMPLETION_SELECTED} bold",
+                    "completion-menu.completion.current": f"noreverse bg:default fg:{completion_selected} bold",
+                    "completion-menu.meta.completion.current": f"bg:default fg:{completion_selected} bold",
                 }
             ),
         )
@@ -192,8 +207,14 @@ class PromptToolkitInput(InputProviderABC):
     @override
     async def iter_inputs(self) -> AsyncIterator[UserInputPayload]:
         while True:
+            if self._pre_prompt is not None:
+                with contextlib.suppress(Exception):
+                    self._pre_prompt()
             with patch_stdout():
                 line: str = await self._session.prompt_async(placeholder=self._render_input_placeholder())
+            if self._post_prompt is not None:
+                with contextlib.suppress(Exception):
+                    self._post_prompt()
 
             # Extract images referenced in the input text
             images = extract_images_from_text(line)

klaude_code/ui/modes/repl/renderer.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
+import contextlib
 from collections.abc import Iterator
 from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import Any
 
-from rich import box
-from rich.box import Box
-from rich.console import Console
+from rich.console import Console, Group, RenderableType
+from rich.padding import Padding
 from rich.spinner import Spinner
-from rich.status import Status
 from rich.style import Style, StyleType
 from rich.text import Text
 
+from klaude_code import const
 from klaude_code.protocol import events, model
 from klaude_code.ui.renderers import assistant as r_assistant
 from klaude_code.ui.renderers import developer as r_developer
@@ -24,14 +24,16 @@ from klaude_code.ui.renderers import tools as r_tools
 from klaude_code.ui.renderers import user_input as r_user_input
 from klaude_code.ui.renderers.common import truncate_display
 from klaude_code.ui.rich import status as r_status
+from klaude_code.ui.rich.live import CropAboveLive, SingleLine
 from klaude_code.ui.rich.quote import Quote
-from klaude_code.ui.rich.status import ShimmerStatusText
+from klaude_code.ui.rich.status import BreathingSpinner, ShimmerStatusText
 from klaude_code.ui.rich.theme import ThemeKey, get_theme
 
 
 @dataclass
 class SessionStatus:
     color: Style | None = None
+    color_index: int | None = None
     sub_agent_state: model.SubAgentState | None = None
 
 
@@ -42,10 +44,18 @@ class REPLRenderer:
         self.themes = get_theme(theme)
         self.console: Console = Console(theme=self.themes.app_theme)
         self.console.push_theme(self.themes.markdown_theme)
-        self._spinner: Status = self.console.status(
-            ShimmerStatusText("Thinking …", ThemeKey.SPINNER_STATUS_TEXT),
-            spinner=r_status.spinner_name(),
-            spinner_style=ThemeKey.SPINNER_STATUS,
+        self._bottom_live: CropAboveLive | None = None
+        self._stream_renderable: RenderableType | None = None
+        self._stream_max_height: int = 0
+        self._stream_last_height: int = 0
+        self._stream_last_width: int = 0
+        self._spinner_visible: bool = False
+
+        self._status_text: ShimmerStatusText = ShimmerStatusText(const.STATUS_DEFAULT_TEXT)
+        self._status_spinner: Spinner = BreathingSpinner(
+            r_status.spinner_name(),
+            text=SingleLine(self._status_text),
+            style=ThemeKey.STATUS_SPINNER,
         )
 
         self.session_map: dict[str, SessionStatus] = {}
@@ -57,7 +67,9 @@ class REPLRenderer:
             sub_agent_state=sub_agent_state,
         )
         if sub_agent_state is not None:
-            session_status.color = self.pick_sub_agent_color()
+            color, color_index = self.pick_sub_agent_color()
+            session_status.color = color
+            session_status.color_index = color_index
         self.session_map[session_id] = session_status
 
     def is_sub_agent_session(self, session_id: str) -> bool:
@@ -70,12 +82,12 @@ class REPLRenderer:
             return
         self.sub_agent_color_index = (self.sub_agent_color_index + 1) % palette_size
 
-    def pick_sub_agent_color(self) -> Style:
+    def pick_sub_agent_color(self) -> tuple[Style, int]:
         self._advance_sub_agent_color_index()
         palette = self.themes.sub_agent_colors
         if not palette:
-            return Style()
-        return palette[self.sub_agent_color_index]
+            return Style(), 0
+        return palette[self.sub_agent_color_index], self.sub_agent_color_index
 
     def get_session_sub_agent_color(self, session_id: str) -> Style:
         status = self.session_map.get(session_id)
@@ -83,8 +95,12 @@ class REPLRenderer:
             return status.color
         return Style()
 
-    def box_style(self) -> Box:
-        return box.ROUNDED
+    def get_session_sub_agent_background(self, session_id: str) -> Style:
+        status = self.session_map.get(session_id)
+        backgrounds = self.themes.sub_agent_backgrounds
+        if status and status.color_index is not None and backgrounds:
+            return backgrounds[status.color_index]
+        return Style()
 
     @contextmanager
     def session_print_context(self, session_id: str) -> Iterator[None]:
@@ -114,7 +130,7 @@ class REPLRenderer:
     def display_tool_call_result(self, e: events.ToolResultEvent) -> None:
         if r_tools.is_sub_agent_tool(e.tool_name):
             return
-        renderable = r_tools.render_tool_result(e)
+        renderable = r_tools.render_tool_result(e, code_theme=self.themes.code_theme)
         if renderable is not None:
             self.print(renderable)
 
@@ -152,7 +168,6 @@ 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)
@@ -196,7 +211,7 @@ class REPLRenderer:
             self.print()
 
     def display_welcome(self, event: events.WelcomeEvent) -> None:
-        self.print(r_metadata.render_welcome(event, box_style=self.box_style()))
+        self.print(r_metadata.render_welcome(event))
 
     def display_user_message(self, event: events.UserMessageEvent) -> None:
         self.print(r_user_input.render_user_input(event.content))
@@ -229,12 +244,21 @@ class REPLRenderer:
 
     def display_task_finish(self, event: events.TaskFinishEvent) -> None:
         if self.is_sub_agent_session(event.session_id):
+            session_status = self.session_map.get(event.session_id)
+            description = (
+                session_status.sub_agent_state.sub_agent_desc
+                if session_status and session_status.sub_agent_state
+                else None
+            )
+            panel_style = self.get_session_sub_agent_background(event.session_id)
             with self.session_print_context(event.session_id):
                 self.print(
                     r_sub_agent.render_sub_agent_result(
                         event.task_result,
                         code_theme=self.themes.code_theme,
                         has_structured_output=event.has_structured_output,
+                        description=description,
+                        panel_style=panel_style,
                     )
                 )
 
@@ -249,25 +273,95 @@ class REPLRenderer:
             )
         )
 
-    def display_thinking_prefix(self) -> None:
-        self.print(r_thinking.thinking_prefix())
-
     # -------------------------------------------------------------------------
     # Spinner control methods
     # -------------------------------------------------------------------------
 
     def spinner_start(self) -> None:
         """Start the spinner animation."""
-        self._spinner.start()
+        self._spinner_visible = True
+        self._ensure_bottom_live_started()
+        self._refresh_bottom_live()
 
     def spinner_stop(self) -> None:
         """Stop the spinner animation."""
-        self._spinner.stop()
+        self._spinner_visible = False
+        self._refresh_bottom_live()
 
     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))
+        self._status_text = ShimmerStatusText(status_text, right_text)
+        self._status_spinner.update(text=SingleLine(self._status_text), style=ThemeKey.STATUS_SPINNER)
+        self._refresh_bottom_live()
 
     def spinner_renderable(self) -> Spinner:
         """Return the spinner's renderable for embedding in other components."""
-        return self._spinner.renderable
+        return self._status_spinner
+
+    def set_stream_renderable(self, renderable: RenderableType | None) -> None:
+        """Set the current streaming renderable displayed above the status line."""
+
+        if renderable is None:
+            self._stream_renderable = None
+            self._stream_max_height = 0
+            self._stream_last_height = 0
+            self._stream_last_width = 0
+            self._refresh_bottom_live()
+            return
+
+        self._ensure_bottom_live_started()
+        self._stream_renderable = renderable
+
+        height = len(self.console.render_lines(renderable, self.console.options, pad=False))
+        self._stream_last_height = height
+        self._stream_last_width = self.console.size.width
+        self._stream_max_height = max(self._stream_max_height, height)
+        self._refresh_bottom_live()
+
+    def _ensure_bottom_live_started(self) -> None:
+        if self._bottom_live is not None:
+            return
+        self._bottom_live = CropAboveLive(
+            Text(""),
+            console=self.console,
+            refresh_per_second=30,
+            transient=True,
+            redirect_stdout=False,
+            redirect_stderr=False,
+        )
+        self._bottom_live.start()
+
+    def _bottom_renderable(self) -> RenderableType:
+        stream = self._stream_renderable
+        if stream is not None:
+            current_width = self.console.size.width
+            if self._stream_last_width != current_width:
+                height = len(self.console.render_lines(stream, self.console.options, pad=False))
+                self._stream_last_height = height
+                self._stream_last_width = current_width
+                self._stream_max_height = max(self._stream_max_height, height)
+            else:
+                height = self._stream_last_height
+
+            pad_lines = max(self._stream_max_height - height, 0)
+            if pad_lines:
+                stream = Padding(stream, (0, 0, pad_lines, 0))
+
+        stream_part: RenderableType = stream if stream is not None else Group()
+        gap_part: RenderableType = Text("") if self._spinner_visible else Group()
+        status_part: RenderableType = SingleLine(self._status_spinner) if self._spinner_visible else Group()
+        return Group(stream_part, gap_part, status_part)
+
+    def _refresh_bottom_live(self) -> None:
+        if self._bottom_live is None:
+            return
+        self._bottom_live.update(self._bottom_renderable(), refresh=True)
+
+    def stop_bottom_live(self) -> None:
+        if self._bottom_live is None:
+            return
+        with contextlib.suppress(Exception):
+            # Avoid cursor restore when stopping right before prompt_toolkit.
+            self._bottom_live.transient = False
+            self._bottom_live.stop()
+        self._bottom_live = None

klaude_code/ui/renderers/assistant.py

@@ -6,7 +6,7 @@ from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.markdown import NoInsetMarkdown
 
 # UI markers
-ASSISTANT_MESSAGE_MARK = "➤"
+ASSISTANT_MESSAGE_MARK = "◆"
 
 
 def render_assistant_message(content: str, *, code_theme: str) -> RenderableType | None:

klaude_code/ui/renderers/metadata.py

@@ -1,7 +1,6 @@
 from importlib.metadata import version
 
 from rich import box
-from rich.box import Box
 from rich.console import Group, RenderableType
 from rich.padding import Padding
 from rich.panel import Panel
@@ -165,11 +164,8 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
     return Group(*renderables)
 
 
-def render_welcome(e: events.WelcomeEvent, *, box_style: Box | None = None) -> RenderableType:
+def render_welcome(e: events.WelcomeEvent) -> RenderableType:
     """Render the welcome panel with model info and settings."""
-    if box_style is None:
-        box_style = box.ROUNDED
-
     debug_mode = is_debug_enabled()
 
     # First line: Klaude Code version
@@ -219,6 +215,6 @@ def render_welcome(e: events.WelcomeEvent, *, box_style: Box | None = None) -> R
 
     border_style = ThemeKey.WELCOME_DEBUG_BORDER if debug_mode else ThemeKey.LINES
     return Group(
-        Panel.fit(panel_content, border_style=border_style, box=box_style),
+        Panel.fit(panel_content, border_style=border_style, box=box.ROUNDED),
         "",  # empty line
     )