klaude-code 1.2.11__py3-none-any.whl → 1.2.13__py3-none-any.whl

klaude_code/protocol/llm_param.py

@@ -28,7 +28,7 @@ class Thinking(BaseModel):
     """
 
     # OpenAI Reasoning Style
-    reasoning_effort: Literal["high", "medium", "low", "minimal", "none"] | None = None
+    reasoning_effort: Literal["high", "medium", "low", "minimal", "none", "xhigh"] | None = None
     reasoning_summary: Literal["auto", "concise", "detailed"] | None = None
 
     # Claude/Gemini Thinking Style
@@ -138,12 +138,4 @@ class LLMCallParameter(LLMConfigModelParameter):
     input: list[ConversationItem]
     system: str | None = None
     tools: list[ToolSchema] | None = None
-
-    stream: Literal[True] = True  # Always True
-
-    # OpenAI Responses
-    include: list[str] | None = None
-    store: bool = True
-    previous_response_id: str | None = None
-
     session_id: str | None = None

klaude_code/protocol/model.py

@@ -20,9 +20,7 @@ class Usage(BaseModel):
     output_tokens: int = 0
 
     # Context window tracking
-    context_token: int | None = None  # Peak total_tokens seen (for context usage display)
-    context_delta: int | None = None  # Context growth since last task (for cache ratio calculation)
-    last_turn_output_token: int | None = None  # Context growth since last task (for cache ratio calculation)
+    context_size: int | None = None  # Peak total_tokens seen (for context usage display)
     context_limit: int | None = None  # Model's context limit
     max_tokens: int | None = None  # Max output tokens for this request
 
@@ -55,12 +53,12 @@ class Usage(BaseModel):
         """Context usage percentage computed from context_token / (context_limit - max_tokens)."""
         if self.context_limit is None or self.context_limit <= 0:
             return None
-        if self.context_token is None:
+        if self.context_size is None:
             return None
         effective_limit = self.context_limit - (self.max_tokens or const.DEFAULT_MAX_TOKENS)
         if effective_limit <= 0:
             return None
-        return (self.context_token / effective_limit) * 100
+        return (self.context_size / effective_limit) * 100
 
 
 class TodoItem(BaseModel):
@@ -298,6 +296,12 @@ class AssistantMessageDelta(BaseModel):
     created_at: datetime = Field(default_factory=datetime.now)
 
 
+class ReasoningTextDelta(BaseModel):
+    response_id: str | None = None
+    content: str
+    created_at: datetime = Field(default_factory=datetime.now)
+
+
 class StreamErrorItem(BaseModel):
     error: str
     created_at: datetime = Field(default_factory=datetime.now)
@@ -394,7 +398,7 @@ MessageItem = (
 )
 
 
-StreamItem = AssistantMessageDelta
+StreamItem = AssistantMessageDelta | ReasoningTextDelta
 
 ConversationItem = (
     StartItem

klaude_code/protocol/sub_agent.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from klaude_code.protocol import tools
 

klaude_code/session/export.py

@@ -194,18 +194,11 @@ def _render_single_metadata(
             input_stat += f"({_format_cost(u.input_cost, u.currency)})"
         parts.append(f'<span class="metadata-stat">{input_stat}</span>')
 
-        # Cached with cost and cache ratio
+        # Cached with cost
         if u.cached_tokens > 0:
             cached_stat = f"cached: {_format_token_count(u.cached_tokens)}"
             if u.cache_read_cost is not None:
                 cached_stat += f"({_format_cost(u.cache_read_cost, u.currency)})"
-            # Cache ratio: (cached + context_delta - last_turn_output) / input tokens
-            # Shows how much of the input was cached (not new context growth)
-            if u.input_tokens > 0:
-                context_delta = u.context_delta or 0
-                last_turn_output_token = u.last_turn_output_token or 0
-                cache_ratio = (u.cached_tokens + context_delta - last_turn_output_token) / u.input_tokens * 100
-                cached_stat += f"[{cache_ratio:.0f}%]"
             parts.append(f'<span class="metadata-stat">{cached_stat}</span>')
 
         # Output with cost

klaude_code/session/selector.py

@@ -10,6 +10,11 @@ from .session import Session
 
 
 def resume_select_session() -> str | None:
+    # Column widths
+    UPDATED_AT_WIDTH = 16
+    MSG_COUNT_WIDTH = 3
+    MODEL_WIDTH = 25
+    FIRST_MESSAGE_WIDTH = 50
     sessions = Session.list_sessions()
     if not sessions:
         log("No sessions found for this project.")
@@ -31,20 +36,20 @@ def resume_select_session() -> str | None:
             model_display = s.model_name or "N/A"
 
             title = [
-                ("class:d", f"{_fmt(s.updated_at):<16} "),
-                ("class:b", f"{msg_count_display:>3}  "),
+                ("class:d", f"{_fmt(s.updated_at):<{UPDATED_AT_WIDTH}} "),
+                ("class:b", f"{msg_count_display:>{MSG_COUNT_WIDTH}}  "),
                 (
                     "class:t",
-                    f"{model_display[:29] + '…' if len(model_display) > 29 else model_display:<30}  ",
+                    f"{model_display[: MODEL_WIDTH - 1] + '…' if len(model_display) > MODEL_WIDTH else model_display:<{MODEL_WIDTH}}  ",
                 ),
                 (
                     "class:t",
-                    f"{first_user_message.strip().replace('\n', ' ↩ '):<50}",
+                    f"{first_user_message.strip().replace('\n', ' ↩ '):<{FIRST_MESSAGE_WIDTH}}",
                 ),
             ]
             choices.append(questionary.Choice(title=title, value=s.id))
         return questionary.select(
-            message=f"{' Updated at':<17} {'Msg':>3}  {'Model':<30}  {'First message':<50}",
+            message=f"{' Updated at':<{UPDATED_AT_WIDTH + 1}} {'Msg':>{MSG_COUNT_WIDTH}}  {'Model':<{MODEL_WIDTH}}  {'First message':<{FIRST_MESSAGE_WIDTH}}",
             choices=choices,
             pointer="→",
             instruction="↑↓ to move",
@@ -63,8 +68,8 @@ def resume_select_session() -> str | None:
             msg_count_display = "N/A" if s.messages_count == -1 else str(s.messages_count)
             model_display = s.model_name or "N/A"
             print(
-                f"{i}. {_fmt(s.updated_at)}  {msg_count_display:>3} "
-                f"{model_display[:29] + '…' if len(model_display) > 29 else model_display:<30} {s.id}  {s.work_dir}"
+                f"{i}. {_fmt(s.updated_at)}  {msg_count_display:>{MSG_COUNT_WIDTH}} "
+                f"{model_display[: MODEL_WIDTH - 1] + '…' if len(model_display) > MODEL_WIDTH else model_display:<{MODEL_WIDTH}} {s.id}  {s.work_dir}"
             )
         try:
             raw = input("Select a session number: ").strip()

klaude_code/session/session.py

@@ -261,12 +261,10 @@ class Session(BaseModel):
             return False
         if prev_item is None:
             return True
-        if isinstance(
+        return isinstance(
             prev_item,
             model.UserMessageItem | model.ToolResultItem | model.DeveloperMessageItem,
-        ):
-            return True
-        return False
+        )
 
     def get_history_item(self) -> Iterable[events.HistoryItemEvent]:
         prev_item: model.ConversationItem | None = None

klaude_code/trace/__init__.py

@@ -1,3 +1,3 @@
 from .log import DebugType, is_debug_enabled, log, log_debug, logger, set_debug_logging
 
-__all__ = ["log", "log_debug", "logger", "set_debug_logging", "DebugType", "is_debug_enabled"]
+__all__ = ["DebugType", "is_debug_enabled", "log", "log_debug", "logger", "set_debug_logging"]

klaude_code/trace/log.py

@@ -1,7 +1,7 @@
 import logging
+from collections.abc import Iterable
 from enum import Enum
 from logging.handlers import RotatingFileHandler
-from typing import Iterable
 
 from rich.console import Console
 from rich.logging import RichHandler

klaude_code/ui/__init__.py

@@ -73,19 +73,14 @@ def create_exec_display(debug: bool = False, stream_json: bool = False) -> Displ
 
 
 __all__ = [
-    # Abstract interfaces
+    "DebugEventDisplay",
     "DisplayABC",
+    "ExecDisplay",
     "InputProviderABC",
-    # Display mode implementations
+    "PromptToolkitInput",
     "REPLDisplay",
-    "ExecDisplay",
     "StreamJsonDisplay",
-    "DebugEventDisplay",
-    # Input implementations
-    "PromptToolkitInput",
-    # Factory functions
+    "TerminalNotifier",
     "create_default_display",
     "create_exec_display",
-    # Supporting types
-    "TerminalNotifier",
 ]

klaude_code/ui/core/stage_manager.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Awaitable, Callable
 from enum import Enum
-from typing import Awaitable, Callable
 
 
 class Stage(Enum):
@@ -19,10 +19,12 @@ class StageManager:
         self,
         *,
         finish_assistant: Callable[[], Awaitable[None]],
+        finish_thinking: Callable[[], Awaitable[None]],
         on_enter_thinking: Callable[[], None],
     ):
         self._stage = Stage.WAITING
         self._finish_assistant = finish_assistant
+        self._finish_thinking = finish_thinking
         self._on_enter_thinking = on_enter_thinking
 
     @property
@@ -49,7 +51,8 @@ class StageManager:
         self._stage = Stage.WAITING
 
     async def _leave_current_stage(self) -> None:
-        if self._stage == Stage.ASSISTANT:
+        if self._stage == Stage.THINKING:
+            await self._finish_thinking()
+        elif self._stage == Stage.ASSISTANT:
             await self.finish_assistant()
-        elif self._stage != Stage.WAITING:
-            self._stage = Stage.WAITING
+        self._stage = Stage.WAITING

klaude_code/ui/modes/repl/__init__.py

@@ -9,7 +9,7 @@ if TYPE_CHECKING:
     from klaude_code.core.agent import Agent
 
 
-def build_repl_status_snapshot(agent: "Agent | None", update_message: str | None) -> REPLStatusSnapshot:
+def build_repl_status_snapshot(agent: Agent | None, update_message: str | None) -> REPLStatusSnapshot:
     """Build a status snapshot for the REPL bottom toolbar.
 
     Aggregates model name, context usage, and basic call counts from the

klaude_code/ui/modes/repl/completers.py

@@ -81,9 +81,9 @@ class _SlashCommandCompleter(Completer):
         # Get available commands
         commands = get_commands()
 
-        # Filter commands that match the fragment
+        # Filter commands that match the fragment (preserve registration order)
         matched: list[tuple[str, object, str]] = []
-        for cmd_name, cmd_obj in sorted(commands.items(), key=lambda x: str(x[1].name)):
+        for cmd_name, cmd_obj in commands.items():
             if cmd_name.startswith(frag):
                 hint = " [args]" if cmd_obj.support_addition_params else ""
                 matched.append((cmd_name, cmd_obj, hint))
@@ -103,7 +103,7 @@ class _SlashCommandCompleter(Completer):
 
             # Using HTML for formatting: bold command name, normal hint, gray summary
             display_text = HTML(
-                f"<b>{cmd_name}</b>{hint}{padding}<style color='ansibrightblack'>— {cmd_obj.summary}</style>"  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+                f"<b>{cmd_name}</b>{hint}{padding}<style color='ansibrightblack'>{cmd_obj.summary}</style>"  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
             )
             completion_text = f"/{cmd_name} "
             yield Completion(
@@ -133,10 +133,9 @@ class _ComboCompleter(Completer):
         complete_event,  # type: ignore[override]
     ) -> Iterable[Completion]:
         # Try slash command completion first (only on first line)
-        if document.cursor_position_row == 0:
-            if self._slash_completer.is_slash_command_context(document):
-                yield from self._slash_completer.get_completions(document, complete_event)
-                return
+        if document.cursor_position_row == 0 and self._slash_completer.is_slash_command_context(document):
+            yield from self._slash_completer.get_completions(document, complete_event)
+            return
 
         # Fall back to @ file completion
         yield from self._at_completer.get_completions(document, complete_event)

klaude_code/ui/modes/repl/display.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 from typing import override
 
 from klaude_code.protocol import events
@@ -53,8 +54,6 @@ class REPLDisplay(DisplayABC):
     async def stop(self) -> None:
         await self.event_handler.stop()
         # Ensure any active spinner is stopped so Rich restores the cursor.
-        try:
+        # Spinner may already be stopped or not started; ignore.
+        with contextlib.suppress(Exception):
             self.renderer.spinner_stop()
-        except Exception:
-            # Spinner may already be stopped or not started; ignore.
-            pass

klaude_code/ui/modes/repl/event_handler.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
-from typing import Awaitable, Callable
 
 from rich.text import Text
 
@@ -10,6 +10,7 @@ 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.rich.markdown import MarkdownStream
+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
 from klaude_code.ui.utils.debouncer import Debouncer
@@ -41,7 +42,7 @@ class StreamState:
     This design ensures buffer and mdstream are always in sync.
     """
 
-    def __init__(self, interval: float, flush_handler: Callable[["StreamState"], Awaitable[None]]):
+    def __init__(self, interval: float, flush_handler: Callable[[StreamState], Awaitable[None]]):
         self._active: ActiveStream | None = None
         self._flush_handler = flush_handler
         self.debouncer = Debouncer(interval=interval, callback=self._debounced_flush)
@@ -199,10 +200,14 @@ class DisplayEventHandler:
         self.assistant_stream = StreamState(
             interval=1 / const.UI_REFRESH_RATE_FPS, flush_handler=self._flush_assistant_buffer
         )
+        self.thinking_stream = StreamState(
+            interval=1 / const.UI_REFRESH_RATE_FPS, flush_handler=self._flush_thinking_buffer
+        )
         self.spinner_status = SpinnerStatusState()
 
         self.stage_manager = StageManager(
             finish_assistant=self._finish_assistant_stream,
+            finish_thinking=self._finish_thinking_stream,
             on_enter_thinking=self._print_thinking_prefix,
         )
 
@@ -222,6 +227,8 @@ class DisplayEventHandler:
                 self._on_turn_start(e)
             case events.ThinkingEvent() as e:
                 await self._on_thinking(e)
+            case events.ThinkingDeltaEvent() as e:
+                await self._on_thinking_delta(e)
             case events.AssistantMessageDeltaEvent() as e:
                 await self._on_assistant_delta(e)
             case events.AssistantMessageEvent() as e:
@@ -252,6 +259,8 @@ class DisplayEventHandler:
     async def stop(self) -> None:
         await self.assistant_stream.debouncer.flush()
         self.assistant_stream.debouncer.cancel()
+        await self.thinking_stream.debouncer.flush()
+        self.thinking_stream.debouncer.cancel()
 
     # ─────────────────────────────────────────────────────────────────────────────
     # Private event handlers
@@ -285,8 +294,41 @@ class DisplayEventHandler:
     async def _on_thinking(self, event: events.ThinkingEvent) -> None:
         if self.renderer.is_sub_agent_session(event.session_id):
             return
+        # If streaming was active, finalize it
+        if self.thinking_stream.is_active:
+            await self._finish_thinking_stream()
+        else:
+            # Non-streaming path (history replay or models without delta support)
+            await self.stage_manager.enter_thinking_stage()
+            self.renderer.display_thinking(event.content)
+
+    async def _on_thinking_delta(self, event: events.ThinkingDeltaEvent) -> None:
+        if self.renderer.is_sub_agent_session(event.session_id):
+            return
+
+        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),
+                },
+                theme=self.renderer.themes.thinking_markdown_theme,
+                console=self.renderer.console,
+                spinner=self.renderer.spinner_renderable(),
+                indent=2,
+            )
+            self.thinking_stream.start(mdstream)
+            self.renderer.spinner_stop()
+
+        self.thinking_stream.append(event.content)
+
+        if first_delta and self.thinking_stream.mdstream is not None:
+            self.thinking_stream.mdstream.update(self.thinking_stream.buffer)
+
         await self.stage_manager.enter_thinking_stage()
-        self.renderer.display_thinking(event.content)
+        self.thinking_stream.debouncer.schedule()
 
     async def _on_assistant_delta(self, event: events.AssistantMessageDeltaEvent) -> None:
         if self.renderer.is_sub_agent_session(event.session_id):
@@ -419,6 +461,22 @@ class DisplayEventHandler:
             assert mdstream is not None
             mdstream.update(state.buffer)
 
+    async def _flush_thinking_buffer(self, state: StreamState) -> None:
+        if state.is_active:
+            mdstream = state.mdstream
+            assert mdstream is not None
+            mdstream.update(state.buffer)
+
+    async def _finish_thinking_stream(self) -> None:
+        if self.thinking_stream.is_active:
+            self.thinking_stream.debouncer.cancel()
+            mdstream = self.thinking_stream.mdstream
+            assert mdstream is not None
+            mdstream.update(self.thinking_stream.buffer, final=True)
+            self.thinking_stream.finish()
+            self.renderer.console.pop_theme()
+            self.renderer.spinner_start()
+
     def _maybe_notify_task_finish(self, event: events.TaskFinishEvent) -> None:
         if self.notifier is None:
             return
@@ -453,10 +511,10 @@ 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=100)
+        return self._truncate_status_text(status_text, max_length=50)
 
     def _truncate_status_text(self, text: str, max_length: int) -> str:
         if len(text) <= max_length:
             return text
         truncated = text[:max_length]
-        return truncated + "..."
+        return truncated + "…"

klaude_code/ui/modes/repl/key_bindings.py

@@ -6,6 +6,7 @@ with dependencies injected to avoid circular imports.
 
 from __future__ import annotations
 
+import contextlib
 import re
 from collections.abc import Callable
 from typing import cast
@@ -35,10 +36,8 @@ def create_key_bindings(
         """Paste image from clipboard as [Image #N]."""
         tag = capture_clipboard_tag()
         if tag:
-            try:
+            with contextlib.suppress(Exception):
                 event.current_buffer.insert_text(tag)  # pyright: ignore[reportUnknownMemberType]
-            except Exception:
-                pass
 
     @kb.add("enter")
     def _(event):  # type: ignore

klaude_code/ui/modes/repl/renderer.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import Any, Iterator
+from typing import Any
 
 from rich import box
 from rich.box import Box

klaude_code/ui/renderers/diffs.py

@@ -73,10 +73,7 @@ def render_diff(diff_text: str, show_file_name: bool = False) -> RenderableType:
         if line.startswith("--- "):
             raw = line[4:].strip()
             if raw != "/dev/null":
-                if raw.startswith(("a/", "b/")):
-                    from_file_name = raw[2:]
-                else:
-                    from_file_name = raw
+                from_file_name = raw[2:] if raw.startswith(("a/", "b/")) else raw
             continue
 
         # Parse file name from diff headers

klaude_code/ui/renderers/metadata.py

@@ -77,17 +77,6 @@ def _render_task_metadata_block(
             ]
             if metadata.usage.cache_read_cost is not None:
                 cached_parts.append((f"({currency_symbol}{metadata.usage.cache_read_cost:.4f})", ThemeKey.METADATA_DIM))
-            # Cache ratio: (content + cached - last turn output) / input tokens, this might caclulate over 100% if system prompt is cached in first turn
-            # Shows how much of the input was cached (not new context growth)
-            if show_context_and_time and metadata.usage.input_tokens > 0:
-                context_delta = metadata.usage.context_delta or 0
-                last_turn_output_token = metadata.usage.last_turn_output_token or 0
-                cache_ratio = (
-                    (metadata.usage.cached_tokens + context_delta - last_turn_output_token)
-                    / metadata.usage.input_tokens
-                    * 100
-                )
-                cached_parts.append((f"[{cache_ratio:.0f}%]", ThemeKey.METADATA_DIM))
             parts2.append(Text.assemble(*cached_parts))
 
         # Output
@@ -129,7 +118,7 @@ def _render_task_metadata_block(
     if metadata.usage is not None:
         # Context (only for main agent)
         if show_context_and_time and metadata.usage.context_usage_percent is not None:
-            context_size = format_number(metadata.usage.context_token or 0)
+            context_size = format_number(metadata.usage.context_size or 0)
             parts3.append(
                 Text.assemble(
                     ("context", ThemeKey.METADATA_DIM),

klaude_code/ui/rich/markdown.py

@@ -1,6 +1,7 @@
 # copy from https://github.com/Aider-AI/aider/blob/main/aider/mdstream.py
 from __future__ import annotations
 
+import contextlib
 import io
 import time
 from typing import Any, ClassVar
@@ -183,10 +184,9 @@ class MarkdownStream:
     def __del__(self) -> None:
         """Destructor to ensure Live display is properly cleaned up."""
         if self.live:
-            try:
+            # Ignore any errors during cleanup
+            with contextlib.suppress(Exception):
                 self.live.stop()
-            except Exception:
-                pass  # Ignore any errors during cleanup
 
     def update(self, text: str, final: bool = False) -> None:
         """Update the displayed markdown content.

klaude_code/ui/rich/searchable_text.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Iterable, List, Sequence, Tuple
+from collections.abc import Iterable, Sequence
 
 
 class SearchableFormattedText:
@@ -16,8 +16,8 @@ class SearchableFormattedText:
       concatenating the text parts of the fragments.
     """
 
-    def __init__(self, fragments: Sequence[Tuple[str, str]], plain: str | None = None):
-        self._fragments: List[Tuple[str, str]] = list(fragments)
+    def __init__(self, fragments: Sequence[tuple[str, str]], plain: str | None = None):
+        self._fragments: list[tuple[str, str]] = list(fragments)
         if plain is None:
             plain = "".join(text for _, text in self._fragments)
         self._plain = plain
@@ -25,7 +25,7 @@ class SearchableFormattedText:
     # Recognized by prompt_toolkit's to_formatted_text(value)
     def __pt_formatted_text__(
         self,
-    ) -> Iterable[Tuple[str, str]]:  # pragma: no cover - passthrough
+    ) -> Iterable[tuple[str, str]]:  # pragma: no cover - passthrough
         return self._fragments
 
     # Provide a human-readable representation.
@@ -45,7 +45,7 @@ class SearchableFormattedText:
         return self._plain
 
 
-class SearchableFormattedList(list[Tuple[str, str]]):
+class SearchableFormattedList(list[tuple[str, str]]):
     """
     List variant compatible with questionary's expected ``Choice.title`` type.
 
@@ -54,7 +54,7 @@ class SearchableFormattedList(list[Tuple[str, str]]):
     - Provides ``.lower()``/``.upper()`` returning the plain text for search filtering.
     """
 
-    def __init__(self, fragments: Sequence[Tuple[str, str]], plain: str | None = None):
+    def __init__(self, fragments: Sequence[tuple[str, str]], plain: str | None = None):
         super().__init__(fragments)
         if plain is None:
             plain = "".join(text for _, text in fragments)

klaude_code/ui/rich/status.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import math
 import time
 
@@ -233,8 +234,6 @@ class BreathingSpinner(RichSpinner):
 
 # Monkey-patch Rich's Status module to use the breathing spinner implementation
 # for the configured spinner name, while preserving default behavior elsewhere.
-try:
+# Best-effort patch; if it fails we silently fall back to default spinner.
+with contextlib.suppress(Exception):
     rich_status.Spinner = BreathingSpinner  # type: ignore[assignment]
-except Exception:
-    # Best-effort patch; if it fails we silently fall back to default spinner.
-    pass

klaude_code/ui/rich/theme.py

@@ -153,10 +153,7 @@ class Themes:
 
 
 def get_theme(theme: str | None = None) -> Themes:
-    if theme == "light":
-        palette = LIGHT_PALETTE
-    else:
-        palette = DARK_PALETTE
+    palette = LIGHT_PALETTE if theme == "light" else DARK_PALETTE
     return Themes(
         app_theme=Theme(
             styles={