klaude-code 1.2.24__tar.gz → 1.2.25__tar.gz

{klaude_code-1.2.24 → klaude_code-1.2.25}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.24
+Version: 1.2.25
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
 Requires-Dist: ddgs>=9.9.3
 Requires-Dist: diff-match-patch>=20241021
+Requires-Dist: markdown-it-py>=4.0.0
 Requires-Dist: openai>=1.102.0
 Requires-Dist: pillow>=12.0.0
 Requires-Dist: prompt-toolkit>=3.0.52

{klaude_code-1.2.24 → klaude_code-1.2.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.2.24"
+version = "1.2.25"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -13,6 +13,7 @@ dependencies = [
     "chardet>=5.2.0",
     "ddgs>=9.9.3",
     "diff-match-patch>=20241021",
+    "markdown-it-py>=4.0.0",
     "openai>=1.102.0",
     "pillow>=12.0.0",
     "prompt-toolkit>=3.0.52",

{klaude_code-1.2.24 → klaude_code-1.2.25}/src/klaude_code/cli/runtime.py

@@ -265,7 +265,23 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
         )
 
     # Set up input provider for interactive mode
-    input_provider: ui.InputProviderABC = ui.PromptToolkitInput(status_provider=_status_provider)
+    def _stop_rich_bottom_ui() -> None:
+        display = components.display
+        if isinstance(display, ui.REPLDisplay):
+            display.renderer.spinner_stop()
+            display.renderer.stop_bottom_live()
+        elif (
+            isinstance(display, ui.DebugEventDisplay)
+            and display.wrapped_display
+            and isinstance(display.wrapped_display, ui.REPLDisplay)
+        ):
+            display.wrapped_display.renderer.spinner_stop()
+            display.wrapped_display.renderer.stop_bottom_live()
+
+    input_provider: ui.InputProviderABC = ui.PromptToolkitInput(
+        status_provider=_status_provider,
+        pre_prompt=_stop_rich_bottom_ui,
+    )
 
     # --- Custom Ctrl+C handler: double-press within 2s to exit, single press shows toast ---
     def _show_toast_once() -> None:

{klaude_code-1.2.24 → klaude_code-1.2.25}/src/klaude_code/command/thinking_cmd.py

@@ -56,6 +56,14 @@ def _is_gemini_flash_model(model_name: str | None) -> bool:
     return "gemini-3-flash" in model_name.lower()
 
 
+def should_auto_trigger_thinking(model_name: str | None) -> bool:
+    """Check if model should auto-trigger thinking selection on switch."""
+    if not model_name:
+        return False
+    model_lower = model_name.lower()
+    return "gpt-5" in model_lower or "gemini-3" in model_lower or "opus" in model_lower
+
+
 def _get_levels_for_responses(model_name: str | None) -> list[str]:
     """Get thinking levels for responses protocol."""
     if _is_codex_max_model(model_name):
@@ -69,7 +77,7 @@ def _get_levels_for_responses(model_name: str | None) -> list[str]:
     return RESPONSES_LEVELS
 
 
-def _format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
+def format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
     """Format the current thinking configuration for display."""
     thinking = config.thinking
     if not thinking:
@@ -164,6 +172,31 @@ def _select_anthropic_thinking_sync() -> llm_param.Thinking | None:
         return None
 
 
+async def select_thinking_for_protocol(config: llm_param.LLMConfigParameter) -> llm_param.Thinking | None:
+    """Select thinking configuration based on the LLM protocol.
+
+    Returns the selected Thinking config, or None if user cancelled.
+    """
+    protocol = config.protocol
+    model_name = config.model
+
+    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
+        return await asyncio.to_thread(_select_responses_thinking_sync, model_name)
+
+    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
+        return await asyncio.to_thread(_select_anthropic_thinking_sync)
+
+    if protocol == llm_param.LLMClientProtocol.OPENROUTER:
+        if _is_openrouter_model_with_reasoning_effort(model_name):
+            return await asyncio.to_thread(_select_responses_thinking_sync, model_name)
+        return await asyncio.to_thread(_select_anthropic_thinking_sync)
+
+    if protocol == llm_param.LLMClientProtocol.OPENAI:
+        return await asyncio.to_thread(_select_anthropic_thinking_sync)
+
+    return None
+
+
 class ThinkingCommand(CommandABC):
     """Configure model thinking/reasoning level."""
 
@@ -185,40 +218,16 @@ class ThinkingCommand(CommandABC):
             return self._no_change_result(agent, "No profile configured")
 
         config = agent.profile.llm_client.get_llm_config()
-        protocol = config.protocol
-        model_name = config.model
-
-        current = _format_current_thinking(config)
-
-        # Select new thinking configuration based on protocol
-        new_thinking: llm_param.Thinking | None = None
-
-        if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
-            new_thinking = await asyncio.to_thread(_select_responses_thinking_sync, model_name)
-
-        elif protocol == llm_param.LLMClientProtocol.ANTHROPIC:
-            new_thinking = await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-        elif protocol == llm_param.LLMClientProtocol.OPENROUTER:
-            if _is_openrouter_model_with_reasoning_effort(model_name):
-                new_thinking = await asyncio.to_thread(_select_responses_thinking_sync, model_name)
-            else:
-                new_thinking = await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-        elif protocol == llm_param.LLMClientProtocol.OPENAI:
-            # openai_compatible uses anthropic style
-            new_thinking = await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-        else:
-            return self._no_change_result(agent, f"Unsupported protocol: {protocol}")
+        current = format_current_thinking(config)
 
+        new_thinking = await select_thinking_for_protocol(config)
         if new_thinking is None:
             return self._no_change_result(agent, "(no change)")
 
         # Apply the new thinking configuration
         config.thinking = new_thinking
         agent.session.model_thinking = new_thinking
-        new_status = _format_current_thinking(config)
+        new_status = format_current_thinking(config)
 
         return CommandResult(
             events=[

{klaude_code-1.2.24 → klaude_code-1.2.25}/src/klaude_code/const.py

@@ -117,16 +117,14 @@ STATUS_DEFAULT_TEXT = "Thinking …"
 # Status shimmer animation
 # Horizontal padding used when computing shimmer band position
 STATUS_SHIMMER_PADDING = 10
-# Duration in seconds for one full shimmer sweep across the text
-STATUS_SHIMMER_SWEEP_SECONDS = 2
 # Half-width of the shimmer band in characters
 STATUS_SHIMMER_BAND_HALF_WIDTH = 5.0
 # Scale factor applied to shimmer intensity when blending colors
 STATUS_SHIMMER_ALPHA_SCALE = 0.7
 
-# Spinner breathing animation
-# Duration in seconds for one full breathe-in + breathe-out cycle
-# Keep in sync with STATUS_SHIMMER_SWEEP_SECONDS for visual consistency
+# Spinner breathing and shimmer animation period
+# Duration in seconds for one full breathe-in + breathe-out cycle (breathing)
+# and one full shimmer sweep across the text (shimmer)
 SPINNER_BREATH_PERIOD_SECONDS: float = 2.0
 
 

{klaude_code-1.2.24 → klaude_code-1.2.25}/src/klaude_code/core/executor.py

@@ -14,6 +14,11 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from klaude_code.command import dispatch_command
+from klaude_code.command.thinking_cmd import (
+    format_current_thinking,
+    select_thinking_for_protocol,
+    should_auto_trigger_thinking,
+)
 from klaude_code.config import load_config
 from klaude_code.core.agent import Agent, DefaultModelProfileProvider, ModelProfileProvider
 from klaude_code.core.manager import LLMClients, SubAgentManager
@@ -235,17 +240,55 @@ class ExecutorContext:
         agent.session.model_thinking = llm_config.thinking
 
         developer_item = model.DeveloperMessageItem(
-            content=f"switched to model: {operation.model_name}",
+            content=f"Switched to: {llm_config.model}",
             command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
         )
         agent.session.append_history([developer_item])
 
         await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
-        await self.emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
 
         if self._on_model_change is not None:
             self._on_model_change(llm_client.model_name)
 
+        if should_auto_trigger_thinking(llm_config.model):
+            thinking_op = op.ChangeThinkingOperation(session_id=operation.session_id)
+            await thinking_op.execute(handler=self)
+            # WelcomeEvent is already handled by the thinking change
+        else:
+            await self.emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
+
+    async def handle_change_thinking(self, operation: op.ChangeThinkingOperation) -> None:
+        """Handle a change thinking operation by prompting user to select thinking level."""
+        agent = await self._ensure_agent(operation.session_id)
+        if not agent.profile:
+            return
+
+        config = agent.profile.llm_client.get_llm_config()
+        current = format_current_thinking(config)
+
+        new_thinking = await select_thinking_for_protocol(config)
+
+        if new_thinking is None:
+            developer_item = model.DeveloperMessageItem(
+                content="(thinking unchanged)",
+                command_output=model.CommandOutput(command_name=commands.CommandName.THINKING),
+            )
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+            return
+
+        config.thinking = new_thinking
+        agent.session.model_thinking = new_thinking
+        new_status = format_current_thinking(config)
+
+        developer_item = model.DeveloperMessageItem(
+            content=f"Thinking changed: {current} -> {new_status}",
+            command_output=model.CommandOutput(command_name=commands.CommandName.THINKING),
+        )
+        agent.session.append_history([developer_item])
+
+        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+        await self.emit_event(events.WelcomeEvent(work_dir=str(agent.session.work_dir), llm_config=config))
+
     async def handle_clear_session(self, operation: op.ClearSessionOperation) -> None:
         agent = await self._ensure_agent(operation.session_id)
         new_session = Session.create(work_dir=agent.session.work_dir)

{klaude_code-1.2.24 → klaude_code-1.2.25}/src/klaude_code/protocol/op.py

@@ -25,6 +25,7 @@ class OperationType(Enum):
     USER_INPUT = "user_input"
     RUN_AGENT = "run_agent"
     CHANGE_MODEL = "change_model"
+    CHANGE_THINKING = "change_thinking"
     CLEAR_SESSION = "clear_session"
     EXPORT_SESSION = "export_session"
     INTERRUPT = "interrupt"
@@ -77,6 +78,16 @@ class ChangeModelOperation(Operation):
         await handler.handle_change_model(self)
 
 
+class ChangeThinkingOperation(Operation):
+    """Operation for changing the thinking/reasoning configuration."""
+
+    type: OperationType = OperationType.CHANGE_THINKING
+    session_id: str
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_change_thinking(self)
+
+
 class ClearSessionOperation(Operation):
     """Operation for clearing the active session and starting a new one."""
 

{klaude_code-1.2.24 → klaude_code-1.2.25}/src/klaude_code/protocol/op_handler.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING, Protocol
 if TYPE_CHECKING:
     from klaude_code.protocol.op import (
         ChangeModelOperation,
+        ChangeThinkingOperation,
         ClearSessionOperation,
         ExportSessionOperation,
         InitAgentOperation,
@@ -35,6 +36,10 @@ class OperationHandler(Protocol):
         """Handle a change model operation."""
         ...
 
+    async def handle_change_thinking(self, operation: ChangeThinkingOperation) -> None:
+        """Handle a change thinking operation."""
+        ...
+
     async def handle_clear_session(self, operation: ClearSessionOperation) -> None:
         """Handle a clear session operation."""
         ...

{klaude_code-1.2.24 → klaude_code-1.2.25}/src/klaude_code/ui/modes/repl/display.py

@@ -57,3 +57,5 @@ class REPLDisplay(DisplayABC):
         # Spinner may already be stopped or not started; ignore.
         with contextlib.suppress(Exception):
             self.renderer.spinner_stop()
+        with contextlib.suppress(Exception):
+            self.renderer.stop_bottom_live()

{klaude_code-1.2.24 → klaude_code-1.2.25}/src/klaude_code/ui/modes/repl/event_handler.py

@@ -368,22 +368,20 @@ 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)
 
@@ -414,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)
@@ -488,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)
 
@@ -552,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()
 

{klaude_code-1.2.24 → klaude_code-1.2.25}/src/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
@@ -51,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("/", "-")
@@ -80,7 +85,7 @@ class PromptToolkitInput(InputProviderABC):
             [(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()),
@@ -202,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-1.2.24 → klaude_code-1.2.25}/src/klaude_code/ui/modes/repl/renderer.py

@@ -1,13 +1,14 @@
 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.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
 
@@ -23,8 +24,9 @@ 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
 
 
@@ -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(const.STATUS_DEFAULT_TEXT),
-            spinner=r_status.spinner_name(),
-            spinner_style=ThemeKey.STATUS_SPINNER,
+        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] = {}
@@ -235,7 +245,11 @@ 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
+            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(
@@ -265,16 +279,89 @@ class REPLRenderer:
 
     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, 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-1.2.24 → klaude_code-1.2.25}/src/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-1.2.24 → klaude_code-1.2.25}/src/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]