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

klaude_code/tui/input/completers.py

@@ -219,6 +219,14 @@ class _ComboCompleter(Completer):
         document: Document,
         complete_event,  # type: ignore[override]
     ) -> Iterable[Completion]:
+        # Bash mode: disable all completions.
+        # A command is considered bash mode only when the first character is `!` (or full-width `！`).
+        try:
+            if document.text.startswith(("!", "！")):
+                return
+        except Exception:
+            pass
+
         # Try slash command completion first (only on first line)
         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)

klaude_code/tui/input/key_bindings.py

@@ -76,6 +76,9 @@ def create_key_bindings(
     term_program = os.environ.get("TERM_PROGRAM", "").lower()
     swallow_next_control_j = False
 
+    def _is_bash_mode_text(text: str) -> bool:
+        return text.startswith(("!", "！"))
+
     def _data_requests_newline(data: str) -> bool:
         """Return True when incoming key data should insert a newline.
 
@@ -374,6 +377,33 @@ def create_key_bindings(
         buf = event.current_buffer
         doc = buf.document  # type: ignore
 
+        # Normalize a leading full-width exclamation mark to ASCII so that:
+        # - UI echo shows `!cmd` consistently
+        # - history stores `!cmd` (not `！cmd`)
+        # - bash-mode detection is stable
+        try:
+            current_text = buf.text  # type: ignore[reportUnknownMemberType]
+            cursor_pos = int(buf.cursor_position)  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            current_text = ""
+            cursor_pos = 0
+
+        if current_text.startswith("！"):
+            normalized = "!" + current_text[1:]
+            if normalized != current_text:
+                with contextlib.suppress(Exception):
+                    buf.text = normalized  # type: ignore[reportUnknownMemberType]
+                    buf.cursor_position = min(cursor_pos, len(normalized))  # type: ignore[reportUnknownMemberType]
+                current_text = normalized
+
+        # Bash mode: if there is no command after `!` (ignoring only space/tab),
+        # ignore Enter but keep the input text as-is.
+        if _is_bash_mode_text(current_text):
+            after_bang = current_text[1:]
+            command = after_bang.lstrip(" \t")
+            if command == "":
+                return
+
         data = getattr(event, "data", "")
         if isinstance(data, str) and _data_requests_newline(data):
             _insert_newline(event)
@@ -393,7 +423,13 @@ def create_key_bindings(
         # When completions are visible, Enter accepts the current selection.
         # This aligns with common TUI completion UX: navigation doesn't modify
         # the buffer, and Enter/Tab inserts the selected option.
-        if not _should_submit_instead_of_accepting_completion(buf) and _accept_current_completion(buf):
+        #
+        # Bash mode disables completions entirely, so always prefer submitting.
+        if (
+            not _is_bash_mode_text(current_text)
+            and not _should_submit_instead_of_accepting_completion(buf)
+            and _accept_current_completion(buf)
+        ):
             return
 
         # Before submitting, expand any folded paste markers so that:

klaude_code/tui/input/prompt_toolkit.py

@@ -62,12 +62,13 @@ COMPLETION_SELECTED_LIGHT_BG = "ansigreen"
 COMPLETION_SELECTED_UNKNOWN_BG = "ansigreen"
 COMPLETION_MENU = "ansibrightblack"
 INPUT_PROMPT_STYLE = "ansimagenta bold"
+INPUT_PROMPT_BASH_STYLE = "ansigreen bold"
 PLACEHOLDER_TEXT_STYLE_DARK_BG = "fg:#5a5a5a"
 PLACEHOLDER_TEXT_STYLE_LIGHT_BG = "fg:#7a7a7a"
 PLACEHOLDER_TEXT_STYLE_UNKNOWN_BG = "fg:#8a8a8a"
-PLACEHOLDER_SYMBOL_STYLE_DARK_BG = "bg:#2a2a2a fg:#5a5a5a"
-PLACEHOLDER_SYMBOL_STYLE_LIGHT_BG = "bg:#e6e6e6 fg:#7a7a7a"
-PLACEHOLDER_SYMBOL_STYLE_UNKNOWN_BG = "bg:#2a2a2a fg:#8a8a8a"
+PLACEHOLDER_SYMBOL_STYLE_DARK_BG = "fg:ansiblue"
+PLACEHOLDER_SYMBOL_STYLE_LIGHT_BG = "fg:ansiblue"
+PLACEHOLDER_SYMBOL_STYLE_UNKNOWN_BG = "fg:ansiblue"
 
 
 # ---------------------------------------------------------------------------
@@ -244,6 +245,7 @@ class PromptToolkitInput(InputProviderABC):
         get_current_llm_config: Callable[[], llm_param.LLMConfigParameter | None] | None = None,
         command_info_provider: Callable[[], list[CommandInfo]] | None = None,
     ):
+        self._prompt_text = prompt
         self._status_provider = status_provider
         self._pre_prompt = pre_prompt
         self._post_prompt = post_prompt
@@ -296,11 +298,11 @@ class PromptToolkitInput(InputProviderABC):
             completion_selected = COMPLETION_SELECTED_UNKNOWN_BG
 
         return PromptSession(
+            # Use a stable prompt string; we override the style dynamically in prompt_async.
             [(INPUT_PROMPT_STYLE, prompt)],
             history=FileHistory(str(history_path)),
             multiline=True,
             cursor=CursorShape.BLINKING_BEAM,
-            prompt_continuation=[(INPUT_PROMPT_STYLE, "  ")],
             key_bindings=kb,
             completer=ThreadedCompleter(create_repl_completer(command_info_provider=self._command_info_provider)),
             complete_while_typing=True,
@@ -340,6 +342,25 @@ class PromptToolkitInput(InputProviderABC):
             ),
         )
 
+    def _is_bash_mode_active(self) -> bool:
+        try:
+            text = self._session.default_buffer.text
+            return text.startswith(("!", "！"))
+        except Exception:
+            return False
+
+    def _get_prompt_message(self) -> FormattedText:
+        style = INPUT_PROMPT_BASH_STYLE if self._is_bash_mode_active() else INPUT_PROMPT_STYLE
+        return FormattedText([(style, self._prompt_text)])
+
+    def _bash_mode_toolbar_fragments(self) -> StyleAndTextTuples:
+        if not self._is_bash_mode_active():
+            return []
+        return [
+            ("fg:ansigreen", " bash mode"),
+            ("fg:ansibrightblack", " (type ! at start; backspace first char to exit)"),
+        ]
+
     def _setup_model_picker(self) -> None:
         """Initialize the model picker overlay and attach it to the layout."""
         model_picker = SelectOverlay[str](
@@ -600,18 +621,32 @@ class PromptToolkitInput(InputProviderABC):
             display_text = f"Debug log: {debug_log_path}"
             text_style = "fg:ansibrightblack"
 
+        bash_frags = self._bash_mode_toolbar_fragments()
+        bash_plain = "".join(frag[1] for frag in bash_frags)
+
         if display_text:
             left_text = " " + display_text
             try:
                 terminal_width = shutil.get_terminal_size().columns
-                padding = " " * max(0, terminal_width - len(left_text))
             except (OSError, ValueError):
+                terminal_width = 0
+
+            if terminal_width > 0 and bash_plain:
+                # Keep the right-side bash mode hint visible by truncating the left side if needed.
+                reserved = len(bash_plain)
+                max_left = max(0, terminal_width - reserved)
+                if len(left_text) > max_left:
+                    left_text = left_text[: max_left - 1] + "…" if max_left >= 2 else ""
+                padding = " " * max(0, terminal_width - len(left_text) - reserved)
+            else:
                 padding = ""
 
-            toolbar_text = left_text + padding
-            return FormattedText([(text_style, toolbar_text)])
+            return FormattedText([(text_style, left_text + padding), *bash_frags])
 
-        # Show shortcut hints when nothing else to display
+        # Show shortcut hints when nothing else to display.
+        # In bash mode, prefer showing only the bash hint (no placeholder shortcuts).
+        if bash_frags:
+            return FormattedText([("fg:default", " "), *bash_frags])
         return self._render_shortcut_hints()
 
     # -------------------------------------------------------------------------
@@ -632,29 +667,20 @@ class PromptToolkitInput(InputProviderABC):
         return FormattedText(
             [
                 (text_style, " "),
-                (symbol_style, " @ "),
-                (text_style, " "),
-                (text_style, "files"),
-                (text_style, " • "),
-                (symbol_style, " $ "),
-                (text_style, " "),
-                (text_style, "skills"),
-                (text_style, " • "),
-                (symbol_style, " / "),
-                (text_style, " "),
-                (text_style, "commands"),
-                (text_style, " • "),
-                (symbol_style, " ctrl-l "),
-                (text_style, " "),
-                (text_style, "models"),
-                (text_style, " • "),
-                (symbol_style, " ctrl-t "),
-                (text_style, " "),
-                (text_style, "think"),
-                (text_style, " • "),
-                (symbol_style, " ctrl-v "),
-                (text_style, " "),
-                (text_style, "paste image"),
+                (symbol_style, "@"),
+                (text_style, " files • "),
+                (symbol_style, "$"),
+                (text_style, " skills • "),
+                (symbol_style, "/"),
+                (text_style, " commands • "),
+                (symbol_style, "!"),
+                (text_style, " shell • "),
+                (symbol_style, "ctrl-l"),
+                (text_style, " models • "),
+                (symbol_style, "ctrl-t"),
+                (text_style, " think • "),
+                (symbol_style, "ctrl-v"),
+                (text_style, " paste image"),
             ]
         )
 
@@ -680,6 +706,7 @@ class PromptToolkitInput(InputProviderABC):
             # proper styling instead of showing raw escape codes.
             with patch_stdout(raw=True):
                 line: str = await self._session.prompt_async(
+                    message=self._get_prompt_message,
                     bottom_toolbar=self._get_bottom_toolbar,
                 )
             if self._post_prompt is not None:

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,
@@ -245,7 +248,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()
@@ -392,6 +395,37 @@ 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
@@ -563,6 +597,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 +691,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:
@@ -664,7 +725,6 @@ class DisplayStateMachine:
                     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,7 @@ 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) 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 +384,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 +485,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 +592,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 +717,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 +735,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 +748,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):