klaude-code 2.9.1__py3-none-any.whl → 2.10.1__py3-none-any.whl

klaude_code/tui/machine.py

@@ -9,20 +9,23 @@ from klaude_code.const import (
     STATUS_COMPACTING_TEXT,
     STATUS_COMPOSING_TEXT,
     STATUS_DEFAULT_TEXT,
+    STATUS_RUNNING_TEXT,
     STATUS_SHOW_BUFFER_LENGTH,
     STATUS_THINKING_TEXT,
 )
 from klaude_code.protocol import events, model, tools
 from klaude_code.tui.commands import (
     AppendAssistant,
+    AppendBashCommandOutput,
     AppendThinking,
     EmitOsc94Error,
     EmitTmuxSignal,
     EndAssistantStream,
     EndThinkingStream,
     PrintBlankLine,
-    PrintRuleLine,
     RenderAssistantImage,
+    RenderBashCommandEnd,
+    RenderBashCommandStart,
     RenderCommand,
     RenderCommandOutput,
     RenderCompactionSummary,
@@ -47,7 +50,6 @@ from klaude_code.tui.commands import (
 )
 from klaude_code.tui.components.rich import status as r_status
 from klaude_code.tui.components.rich.theme import ThemeKey
-from klaude_code.tui.components.thinking import extract_last_bold_header, normalize_thinking_content
 from klaude_code.tui.components.tools import get_task_active_form, get_tool_active_form, is_sub_agent_tool
 
 # Tools that complete quickly and don't benefit from streaming activity display.
@@ -245,7 +247,7 @@ class SpinnerStatusState:
 
         if base_status:
             # Default "Thinking ..." uses normal style; custom headers use bold italic
-            is_default_reasoning = base_status == STATUS_THINKING_TEXT
+            is_default_reasoning = base_status in {STATUS_THINKING_TEXT, STATUS_RUNNING_TEXT}
             status_style = ThemeKey.STATUS_TEXT if is_default_reasoning else ThemeKey.STATUS_TEXT_BOLD_ITALIC
             if activity_text:
                 result = Text()
@@ -290,7 +292,6 @@ class _SessionState:
     assistant_stream_active: bool = False
     thinking_stream_active: bool = False
     assistant_char_count: int = 0
-    thinking_tail: str = ""
     task_active: bool = False
 
     @property
@@ -301,15 +302,6 @@ class _SessionState:
     def should_show_sub_agent_thinking_header(self) -> bool:
         return bool(self.sub_agent_state and self.sub_agent_state.sub_agent_type == tools.IMAGE_GEN)
 
-    @property
-    def should_extract_reasoning_header(self) -> bool:
-        """Gemini and GPT-5 models use markdown bold headers in thinking."""
-        return False  # Temporarily disabled for all models
-        if self.model_id is None:
-            return False
-        model_lower = self.model_id.lower()
-        return "gemini" in model_lower or "gpt-5" in model_lower
-
     def should_skip_tool_activity(self, tool_name: str) -> bool:
         """Check if tool activity should be skipped for non-streaming models."""
         if self.model_id is None:
@@ -332,6 +324,11 @@ class DisplayStateMachine:
         self._primary_session_id: str | None = None
         self._spinner = SpinnerStatusState()
 
+    def _reset_sessions(self) -> None:
+        self._sessions = {}
+        self._primary_session_id = None
+        self._spinner.reset()
+
     def _session(self, session_id: str) -> _SessionState:
         existing = self._sessions.get(session_id)
         if existing is not None:
@@ -364,7 +361,9 @@ class DisplayStateMachine:
         return self._spinner_update_commands()
 
     def begin_replay(self) -> list[RenderCommand]:
-        self._spinner.reset()
+        # Replay is a full rebuild of the terminal view; clear session state so primary-session
+        # routing is recalculated from the replayed TaskStartEvent.
+        self._reset_sessions()
         return [SpinnerStop(), PrintBlankLine()]
 
     def end_replay(self) -> list[RenderCommand]:
@@ -383,6 +382,13 @@ class DisplayStateMachine:
 
         match event:
             case events.WelcomeEvent() as e:
+                # WelcomeEvent marks (or reaffirms) the current interactive session.
+                # If the session id changes (e.g., /clear creates a new session), clear
+                # routing state so subsequent streamed events are not dropped.
+                if self._primary_session_id is not None and self._primary_session_id != e.session_id:
+                    self._reset_sessions()
+                    s = self._session(e.session_id)
+                self._primary_session_id = e.session_id
                 cmds.append(RenderWelcome(e))
                 return cmds
 
@@ -392,12 +398,48 @@ class DisplayStateMachine:
                 cmds.append(RenderUserMessage(e))
                 return cmds
 
+            case events.BashCommandStartEvent() as e:
+                if s.is_sub_agent:
+                    return []
+                if not is_replay:
+                    self._spinner.set_reasoning_status(STATUS_RUNNING_TEXT)
+                    cmds.append(TaskClockStart())
+                    cmds.append(SpinnerStart())
+                    cmds.extend(self._spinner_update_commands())
+
+                cmds.append(RenderBashCommandStart(e))
+                return cmds
+
+            case events.BashCommandOutputDeltaEvent() as e:
+                if s.is_sub_agent:
+                    return []
+                cmds.append(AppendBashCommandOutput(e))
+                return cmds
+
+            case events.BashCommandEndEvent() as e:
+                if s.is_sub_agent:
+                    return []
+                cmds.append(RenderBashCommandEnd(e))
+
+                if not is_replay:
+                    self._spinner.set_reasoning_status(None)
+                    cmds.append(TaskClockClear())
+                    cmds.append(SpinnerStop())
+                    cmds.extend(self._spinner_update_commands())
+
+                return cmds
+
             case events.TaskStartEvent() as e:
                 s.sub_agent_state = e.sub_agent_state
                 s.model_id = e.model_id
                 s.task_active = True
                 if not s.is_sub_agent:
-                    self._set_primary_if_needed(e.session_id)
+                    # Keep primary session tracking in sync even if the session id changes
+                    # during the process lifetime (e.g., /clear).
+                    if is_replay:
+                        self._set_primary_if_needed(e.session_id)
+                    else:
+                        self._primary_session_id = e.session_id
                     if not is_replay:
                         cmds.append(TaskClockStart())
 
@@ -453,9 +495,8 @@ class DisplayStateMachine:
                 if not self._is_primary(e.session_id):
                     return []
                 s.thinking_stream_active = True
-                s.thinking_tail = ""
                 # Ensure the status reflects that reasoning has started even
-                # before we receive any deltas (or a bold header).
+                # before we receive any deltas.
                 if not is_replay:
                     self._spinner.set_reasoning_status(STATUS_THINKING_TEXT)
                 cmds.append(StartThinkingStream(session_id=e.session_id))
@@ -473,16 +514,6 @@ class DisplayStateMachine:
                 if not self._is_primary(e.session_id):
                     return []
                 cmds.append(AppendThinking(session_id=e.session_id, content=e.content))
-
-                # Update reasoning status for spinner (based on bounded tail).
-                # Only extract headers for models that use markdown bold headers in thinking.
-                if not is_replay and s.should_extract_reasoning_header:
-                    s.thinking_tail = (s.thinking_tail + e.content)[-8192:]
-                    header = extract_last_bold_header(normalize_thinking_content(s.thinking_tail))
-                    if header:
-                        self._spinner.set_reasoning_status(header)
-                        cmds.extend(self._spinner_update_commands())
-
                 return cmds
 
             case events.ThinkingEndEvent() as e:
@@ -563,6 +594,31 @@ class DisplayStateMachine:
                     return []
                 if not self._is_primary(e.session_id):
                     return []
+
+                # Some providers/models may not emit fine-grained AssistantText* deltas.
+                # In that case, ResponseCompleteEvent.content is the only assistant text we get.
+                # Render it as a single assistant stream to avoid dropping the entire message.
+                content = e.content
+                if content.strip():
+                    # If we saw no streamed assistant text for this response, render from the final snapshot.
+                    if s.assistant_char_count == 0:
+                        if not s.assistant_stream_active:
+                            s.assistant_stream_active = True
+                            cmds.append(StartAssistantStream(session_id=e.session_id))
+                        cmds.append(AppendAssistant(session_id=e.session_id, content=content))
+                        s.assistant_char_count += len(content)
+
+                    # Ensure any active assistant stream is finalized.
+                    if s.assistant_stream_active:
+                        s.assistant_stream_active = False
+                        cmds.append(EndAssistantStream(session_id=e.session_id))
+                else:
+                    # If there is an active stream but the final snapshot has no text,
+                    # still finalize to flush any pending markdown rendering.
+                    if s.assistant_stream_active:
+                        s.assistant_stream_active = False
+                        cmds.append(EndAssistantStream(session_id=e.session_id))
+
                 if not is_replay:
                     self._spinner.set_composing(False)
                     cmds.append(SpinnerStart())
@@ -632,6 +688,8 @@ class DisplayStateMachine:
                 cmds.append(EndThinkingStream(e.session_id))
                 cmds.append(EndAssistantStream(e.session_id))
                 cmds.append(RenderTaskMetadata(e))
+                if is_replay:
+                    cmds.append(PrintBlankLine())
                 return cmds
 
             case events.TodoChangeEvent() as e:
@@ -660,11 +718,33 @@ class DisplayStateMachine:
             case events.TaskFinishEvent() as e:
                 s.task_active = False
                 cmds.append(RenderTaskFinish(e))
+
+                # Defensive: finalize any open streams so buffered markdown is flushed.
+                if s.thinking_stream_active:
+                    s.thinking_stream_active = False
+                    cmds.append(EndThinkingStream(session_id=e.session_id))
+                if s.assistant_stream_active:
+                    s.assistant_stream_active = False
+                    cmds.append(EndAssistantStream(session_id=e.session_id))
+
+                # Rare providers / edge cases may complete a turn without emitting any
+                # assistant deltas (or without the display consuming them). In that case,
+                # fall back to rendering the final task result to avoid a "blank" turn.
+                if (
+                    not is_replay
+                    and not s.is_sub_agent
+                    and not e.has_structured_output
+                    and s.assistant_char_count == 0
+                    and e.task_result.strip()
+                ):
+                    cmds.append(StartAssistantStream(session_id=e.session_id))
+                    cmds.append(AppendAssistant(session_id=e.session_id, content=e.task_result))
+                    cmds.append(EndAssistantStream(session_id=e.session_id))
+
                 if not s.is_sub_agent and not is_replay:
                     cmds.append(TaskClockClear())
                     self._spinner.reset()
                     cmds.append(SpinnerStop())
-                    cmds.append(PrintRuleLine())
                     cmds.append(EmitTmuxSignal())
                 return cmds
 

klaude_code/tui/renderer.py

@@ -18,6 +18,7 @@ from rich.text import Text
 
 from klaude_code.const import (
     MARKDOWN_LEFT_MARGIN,
+    MARKDOWN_RIGHT_MARGIN,
     MARKDOWN_STREAM_LIVE_REPAINT_ENABLED,
     STATUS_DEFAULT_TEXT,
     STREAM_MAX_HEIGHT_SHRINK_RESET_LINES,
@@ -25,6 +26,7 @@ from klaude_code.const import (
 from klaude_code.protocol import events, model, tools
 from klaude_code.tui.commands import (
     AppendAssistant,
+    AppendBashCommandOutput,
     AppendThinking,
     EmitOsc94Error,
     EmitTmuxSignal,
@@ -33,6 +35,8 @@ from klaude_code.tui.commands import (
     PrintBlankLine,
     PrintRuleLine,
     RenderAssistantImage,
+    RenderBashCommandEnd,
+    RenderBashCommandStart,
     RenderCommand,
     RenderCommandOutput,
     RenderCompactionSummary,
@@ -56,7 +60,6 @@ from klaude_code.tui.commands import (
     TaskClockClear,
     TaskClockStart,
 )
-from klaude_code.tui.components import assistant as c_assistant
 from klaude_code.tui.components import command_output as c_command_output
 from klaude_code.tui.components import developer as c_developer
 from klaude_code.tui.components import errors as c_errors
@@ -165,11 +168,29 @@ class TUICommandRenderer:
         self._assistant_stream = _StreamState()
         self._thinking_stream = _StreamState()
 
+        # Replay mode reuses the same event/state machine but does not need streaming UI.
+        # When enabled, we avoid bottom Live rendering and defer markdown rendering until
+        # the corresponding stream End event.
+        self._replay_mode: bool = False
+
+        self._bash_stream_active: bool = False
+        self._bash_last_char_was_newline: bool = True
+
         self._sessions: dict[str, _SessionStatus] = {}
         self._current_sub_agent_color: Style | None = None
         self._sub_agent_color_index = 0
         self._sub_agent_thinking_buffers: dict[str, str] = {}
 
+    def set_replay_mode(self, enabled: bool) -> None:
+        """Enable or disable replay rendering mode.
+
+        Replay mode is optimized for speed and stability:
+        - Avoid Rich Live / bottom status rendering.
+        - Defer markdown stream rendering until End events.
+        """
+
+        self._replay_mode = enabled
+
     # ---------------------------------------------------------------------
     # Session helpers
     # ---------------------------------------------------------------------
@@ -304,7 +325,9 @@ class TUICommandRenderer:
 
     def _bottom_renderable(self) -> RenderableType:
         stream_part: RenderableType = Group()
-        gap_part: RenderableType = Group()
+        # Keep a visible separation between the bottom status line (spinner)
+        # and the main terminal output.
+        gap_part: RenderableType = Text(" ") if (self._spinner_visible and self._bash_stream_active) else Group()
 
         if MARKDOWN_STREAM_LIVE_REPAINT_ENABLED:
             stream = self._stream_renderable
@@ -326,7 +349,11 @@ class TUICommandRenderer:
                 if pad_lines:
                     stream = Padding(stream, (0, 0, pad_lines, 0))
                 stream_part = stream
-                gap_part = Text("")
+                gap_part = (
+                    Text(" ")
+                    if (self._spinner_visible and (self._bash_stream_active or self._stream_renderable))
+                    else Group()
+                )
 
         status_part: RenderableType = SingleLine(self._status_spinner) if self._spinner_visible else Group()
         return Group(stream_part, gap_part, status_part)
@@ -361,17 +388,19 @@ class TUICommandRenderer:
             mark=c_thinking.THINKING_MESSAGE_MARK,
             mark_style=ThemeKey.THINKING,
             left_margin=MARKDOWN_LEFT_MARGIN,
+            right_margin=MARKDOWN_RIGHT_MARGIN,
             markdown_class=ThinkingMarkdown,
         )
 
     def _new_assistant_mdstream(self) -> MarkdownStream:
+        live_sink = None if self._replay_mode else self.set_stream_renderable
         return MarkdownStream(
             mdargs={"code_theme": self.themes.code_theme},
             theme=self.themes.markdown_theme,
             console=self.console,
-            live_sink=self.set_stream_renderable,
-            mark=c_assistant.ASSISTANT_MESSAGE_MARK,
+            live_sink=live_sink,
             left_margin=MARKDOWN_LEFT_MARGIN,
+            right_margin=MARKDOWN_RIGHT_MARGIN,
             image_callback=self.display_image,
         )
 
@@ -460,6 +489,66 @@ class TUICommandRenderer:
             self.print(c_command_output.render_command_output(e))
             self.print()
 
+    def display_bash_command_start(self, e: events.BashCommandStartEvent) -> None:
+        # The user input line already shows `!cmd`; bash output is streamed as it arrives.
+        # We keep minimal rendering here to avoid adding noise.
+        self._bash_stream_active = True
+        self._bash_last_char_was_newline = True
+        if self._spinner_visible:
+            self._refresh_bottom_live()
+
+    def display_bash_command_delta(self, e: events.BashCommandOutputDeltaEvent) -> None:
+        if not self._bash_stream_active:
+            self._bash_stream_active = True
+            if self._spinner_visible:
+                self._refresh_bottom_live()
+
+        content = e.content
+        if content == "":
+            return
+
+        # Rich Live refreshes periodically (even when the renderable doesn't change).
+        # If we print bash output without a trailing newline while Live is active,
+        # the next refresh can overwrite the partial line.
+        #
+        # To keep streamed bash output stable, temporarily stop the bottom Live
+        # during the print, and only resume it once the output is back at a
+        # line boundary (i.e. chunk ends with "\n").
+        if self._bottom_live is not None:
+            with contextlib.suppress(Exception):
+                self._bottom_live.stop()
+            self._bottom_live = None
+
+        try:
+            # Do not use Renderer.print() here because it forces overflow="ellipsis",
+            # which would truncate long command output lines.
+            self.console.print(Text(content, style=ThemeKey.TOOL_RESULT), end="", overflow="ignore")
+            self._bash_last_char_was_newline = content.endswith("\n")
+        finally:
+            # Resume the bottom Live only when we're not in the middle of a line,
+            # otherwise periodic refresh can clobber the partial line.
+            if self._bash_last_char_was_newline and self._spinner_visible:
+                self._ensure_bottom_live_started()
+                self._refresh_bottom_live()
+
+    def display_bash_command_end(self, e: events.BashCommandEndEvent) -> None:
+        # Stop the bottom Live before finalizing bash output to prevent a refresh
+        # from interfering with the final line(s) written to stdout.
+        if self._bottom_live is not None:
+            with contextlib.suppress(Exception):
+                self._bottom_live.stop()
+            self._bottom_live = None
+
+        # Leave a blank line before the next prompt:
+        # - If the command output already ended with a newline, print one more "\n".
+        # - Otherwise, print "\n\n" to end the line and add one empty line.
+        if self._bash_stream_active:
+            sep = "\n" if self._bash_last_char_was_newline else "\n\n"
+            self.console.print(Text(sep), end="", overflow="ignore")
+
+        self._bash_stream_active = False
+        self._bash_last_char_was_newline = True
+
     def display_welcome(self, event: events.WelcomeEvent) -> None:
         self.print(c_welcome.render_welcome(event))
 
@@ -507,7 +596,6 @@ class TUICommandRenderer:
         if self.is_sub_agent_session(event.session_id):
             return
         self.print(c_metadata.render_task_metadata(event))
-        self.print()
 
     def display_task_finish(self, event: events.TaskFinishEvent) -> None:
         if self.is_sub_agent_session(event.session_id):
@@ -633,6 +721,12 @@ class TUICommandRenderer:
                     self.display_developer_message(event)
                 case RenderCommandOutput(event=event):
                     self.display_command_output(event)
+                case RenderBashCommandStart(event=event):
+                    self.display_bash_command_start(event)
+                case AppendBashCommandOutput(event=event):
+                    self.display_bash_command_delta(event)
+                case RenderBashCommandEnd(event=event):
+                    self.display_bash_command_end(event)
                 case RenderTurnStart(event=event):
                     self.display_turn_start(event)
                 case StartThinkingStream(session_id=session_id):
@@ -645,11 +739,12 @@ class TUICommandRenderer:
                         if session_id in self._sub_agent_thinking_buffers:
                             self._sub_agent_thinking_buffers[session_id] += content
                     elif self._thinking_stream.is_active:
-                        first_delta = self._thinking_stream.buffer == ""
                         self._thinking_stream.append(content)
-                        if first_delta:
-                            self._thinking_stream.render(transform=c_thinking.normalize_thinking_content)
-                        self._flush_thinking()
+                        if not self._replay_mode:
+                            first_delta = self._thinking_stream.buffer == ""
+                            if first_delta:
+                                self._thinking_stream.render(transform=c_thinking.normalize_thinking_content)
+                            self._flush_thinking()
                 case EndThinkingStream(session_id=session_id):
                     if self.is_sub_agent_session(session_id):
                         buf = self._sub_agent_thinking_buffers.pop(session_id, "")
@@ -657,22 +752,25 @@ class TUICommandRenderer:
                             with self.session_print_context(session_id):
                                 self._render_sub_agent_thinking(buf)
                     else:
+                        had_content = bool(self._thinking_stream.buffer.strip())
                         finalized = self._thinking_stream.finalize(transform=c_thinking.normalize_thinking_content)
-                        if finalized:
+                        if finalized and had_content:
                             self.print()
-                case StartAssistantStream():
+                case StartAssistantStream(session_id=_):
                     if not self._assistant_stream.is_active:
                         self._assistant_stream.start(self._new_assistant_mdstream())
-                case AppendAssistant(content=content):
+                case AppendAssistant(session_id=_, content=content):
                     if self._assistant_stream.is_active:
-                        first_delta = self._assistant_stream.buffer == ""
                         self._assistant_stream.append(content)
-                        if first_delta:
-                            self._assistant_stream.render()
-                        self._flush_assistant()
-                case EndAssistantStream():
+                        if not self._replay_mode:
+                            first_delta = self._assistant_stream.buffer == ""
+                            if first_delta:
+                                self._assistant_stream.render()
+                            self._flush_assistant()
+                case EndAssistantStream(session_id=_):
+                    had_content = bool(self._assistant_stream.buffer.strip())
                     finalized = self._assistant_stream.finalize()
-                    if finalized:
+                    if finalized and had_content:
                         self.print()
                 case RenderThinkingHeader(session_id=session_id, header=header):
                     with self.session_print_context(session_id):

klaude_code/tui/runner.py

@@ -65,11 +65,27 @@ async def submit_user_input_payload(
 
     submission_id = uuid4().hex
 
+    # Normalize a leading full-width exclamation mark for consistent UI/history.
+    # (Bash mode is triggered only when the first character is `!`.)
+    text = user_input.text
+    if text.startswith("！"):
+        text = "!" + text[1:]
+        user_input = UserInputPayload(text=text, images=user_input.images)
+
     # Render the raw user input in the TUI even when it resolves to an event-only command.
     await executor.context.emit_event(
         events.UserMessageEvent(content=user_input.text, session_id=sid, images=user_input.images)
     )
 
+    # Bash mode: run a user-entered command without invoking the agent.
+    if user_input.text.startswith("!"):
+        command = user_input.text[1:].lstrip(" \t")
+        if command == "":
+            # Enter should be ignored in the input layer for this case; keep a guard here.
+            return None
+        bash_op = op.RunBashOperation(id=submission_id, session_id=sid, command=command)
+        return await executor.submit(bash_op)
+
     cmd_result = await dispatch_command(user_input, agent, submission_id=submission_id)
     operations: list[op.Operation] = list(cmd_result.operations or [])
 
@@ -304,6 +320,9 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             if is_interactive:
                 with _double_ctrl_c_to_exit_while_running():
                     await components.executor.wait_for(wait_id)
+                # Ensure all trailing events (e.g. final deltas / spinner stop) are rendered
+                # before handing control back to prompt_toolkit.
+                await components.event_queue.join()
                 continue
 
             async def _on_esc_interrupt() -> None:
@@ -313,6 +332,9 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             try:
                 with _double_ctrl_c_to_exit_while_running():
                     await components.executor.wait_for(wait_id)
+                # Ensure all trailing events (e.g. final deltas / spinner stop) are rendered
+                # before handing control back to prompt_toolkit.
+                await components.event_queue.join()
             finally:
                 stop_event.set()
                 with contextlib.suppress(Exception):

klaude_code/tui/terminal/notifier.py

@@ -64,9 +64,9 @@ class TerminalNotifier:
             return False
 
         output = resolve_stream(self.config.stream)
-        if not self._supports_osc9(output):
+        if not self._supports_notification(output):
             log_debug(
-                "Terminal notifier skipped: OSC 9 unsupported or not a TTY",
+                "Terminal notifier skipped: not a TTY",
                 debug_type=DebugType.TERMINAL,
             )
             return False
@@ -74,27 +74,26 @@ class TerminalNotifier:
         payload = self._render_payload(notification)
         return self._emit(payload, output)
 
-    def _render_payload(self, notification: Notification) -> str:
-        title = _compact(notification.title)
-        body = _compact(notification.body) if notification.body else None
-        if body:
-            return f"{title} - {body}"
-        return title
+    def _render_payload(self, notification: Notification) -> tuple[str, str]:
+        """Return (title, body) for OSC 777 notification."""
+        body = _compact(notification.body) if notification.body else _compact(notification.title)
+        return ("klaude", body)
 
-    def _emit(self, payload: str, output: TextIO) -> bool:
+    def _emit(self, payload: tuple[str, str], output: TextIO) -> bool:
         terminator = BEL if self.config.use_bel else ST
-        seq = f"\033]9;{payload}{terminator}"
+        title, body = payload
+        seq = f"\033]777;notify;{title};{body}{terminator}"
         try:
             output.write(seq)
             output.flush()
-            log_debug("Terminal notifier sent OSC 9 payload", debug_type=DebugType.TERMINAL)
+            log_debug("Terminal notifier sent OSC 777 payload", debug_type=DebugType.TERMINAL)
             return True
         except Exception as exc:
             log_debug(f"Terminal notifier send failed: {exc}", debug_type=DebugType.TERMINAL)
             return False
 
     @staticmethod
-    def _supports_osc9(stream: TextIO) -> bool:
+    def _supports_notification(stream: TextIO) -> bool:
         if sys.platform == "win32":
             return False
         if not getattr(stream, "isatty", lambda: False)():

klaude_code/tui/terminal/selector.py

@@ -111,7 +111,7 @@ def build_model_select_items(models: list[Any]) -> list[SelectItem[str]]:
             meta_str = " · ".join(meta_parts) if meta_parts else ""
             title: list[tuple[str, str]] = [
                 ("class:meta", f"{model_idx:>{num_width}}. "),
-                ("class:msg bold", first_line_prefix),
+                ("class:msg", first_line_prefix),
                 ("class:msg dim", " → "),
                 # Keep provider/model_id styling attribute-based (dim/bold) so that
                 # the selector's highlight color can still override uniformly.

klaude_code/ui/terminal/title.py

@@ -26,6 +26,8 @@ def update_terminal_title(model_name: str | None = None) -> None:
     """Update terminal title with folder name and optional model name."""
     folder_name = os.path.basename(os.getcwd())
     if model_name:
-        set_terminal_title(f"{folder_name}: klaude ✳ {model_name}")
+        # Strip provider suffix (e.g., opus@openrouter -> opus)
+        model_alias = model_name.split("@")[0]
+        set_terminal_title(f"klaude [{model_alias}] · {folder_name}")
     else:
-        set_terminal_title(f"{folder_name}: klaude")
+        set_terminal_title(f"klaude · {folder_name}")

{klaude_code-2.9.1.dist-info → klaude_code-2.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.9.1
+Version: 2.10.1
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0