klaude-code 1.2.29__tar.gz → 1.2.30__tar.gz

{klaude_code-1.2.29 → klaude_code-1.2.30}/PKG-INFO

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

{klaude_code-1.2.29 → klaude_code-1.2.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.2.29"
+version = "1.2.30"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/command/__init__.py

@@ -36,6 +36,7 @@ def ensure_commands_loaded() -> None:
     from .model_cmd import ModelCommand
     from .refresh_cmd import RefreshTerminalCommand
     from .release_notes_cmd import ReleaseNotesCommand
+    from .resume_cmd import ResumeCommand
     from .status_cmd import StatusCommand
     from .terminal_setup_cmd import TerminalSetupCommand
     from .thinking_cmd import ThinkingCommand
@@ -47,6 +48,7 @@ def ensure_commands_loaded() -> None:
     register(ThinkingCommand())
     register(ModelCommand())
     register(ForkSessionCommand())
+    register(ResumeCommand())
     load_prompt_commands()
     register(StatusCommand())
     register(HelpCommand())
@@ -70,6 +72,7 @@ def __getattr__(name: str) -> object:
         "ModelCommand": "model_cmd",
         "RefreshTerminalCommand": "refresh_cmd",
         "ReleaseNotesCommand": "release_notes_cmd",
+        "ResumeCommand": "resume_cmd",
         "StatusCommand": "status_cmd",
         "TerminalSetupCommand": "terminal_setup_cmd",
         "ThinkingCommand": "thinking_cmd",

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/command/clear_cmd.py

@@ -15,4 +15,7 @@ class ClearCommand(CommandABC):
 
     async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
         del user_input  # unused
-        return CommandResult(operations=[op.ClearSessionOperation(session_id=agent.session.id)])
+        return CommandResult(
+            operations=[op.ClearSessionOperation(session_id=agent.session.id)],
+            persist_user_input=False,
+        )

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/command/command_abc.py

@@ -42,6 +42,10 @@ class CommandResult(BaseModel):
     ) = None  # List of UI events to display immediately
     operations: list[op.Operation] | None = None
 
+    # Persistence controls: some slash commands are UI/control actions and should not be written to session history.
+    persist_user_input: bool = True
+    persist_events: bool = True
+
 
 class CommandABC(ABC):
     """Abstract base class for slash commands."""

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/command/fork_session_cmd.py

@@ -24,7 +24,7 @@ class ForkSessionCommand(CommandABC):
                     command_output=model.CommandOutput(command_name=self.name),
                 ),
             )
-            return CommandResult(events=[event])
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
 
         new_session = agent.session.fork()
         await new_session.wait_for_flush()
@@ -39,4 +39,4 @@ class ForkSessionCommand(CommandABC):
                 ),
             ),
         )
-        return CommandResult(events=[event])
+        return CommandResult(events=[event], persist_user_input=False, persist_events=False)

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/command/model_cmd.py

@@ -1,9 +1,43 @@
 import asyncio
 
+import questionary
+
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.config.select_model import select_model_from_config
 from klaude_code.protocol import commands, events, model, op
 
+SELECT_STYLE = questionary.Style(
+    [
+        ("instruction", "ansibrightblack"),
+        ("pointer", "ansicyan"),
+        ("highlighted", "ansicyan"),
+        ("text", "ansibrightblack"),
+    ]
+)
+
+
+def _confirm_change_default_model_sync(selected_model: str) -> bool:
+    choices: list[questionary.Choice] = [
+        questionary.Choice(title="No (session only)", value=False),
+        questionary.Choice(title="Yes (save as default)", value=True),
+    ]
+
+    try:
+        # Add a blank line between the model selector and this confirmation prompt.
+        questionary.print("")
+        result = questionary.select(
+            message=f"Save '{selected_model}' as default model (main_model)?",
+            choices=choices,
+            pointer="→",
+            instruction="Use arrow keys to move, Enter to select",
+            use_jk_keys=False,
+            style=SELECT_STYLE,
+        ).ask()
+    except KeyboardInterrupt:
+        return False
+
+    return bool(result)
+
 
 class ModelCommand(CommandABC):
     """Display or change the model configuration."""
@@ -44,7 +78,13 @@ class ModelCommand(CommandABC):
                     )
                 ]
             )
-
+        save_as_default = await asyncio.to_thread(_confirm_change_default_model_sync, selected_model)
         return CommandResult(
-            operations=[op.ChangeModelOperation(session_id=agent.session.id, model_name=selected_model)]
+            operations=[
+                op.ChangeModelOperation(
+                    session_id=agent.session.id,
+                    model_name=selected_model,
+                    save_as_default=save_as_default,
+                )
+            ]
         )

klaude_code-1.2.30/src/klaude_code/command/resume_cmd.py

@@ -0,0 +1,51 @@
+import asyncio
+
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model, op
+from klaude_code.session.selector import resume_select_session
+
+
+class ResumeCommand(CommandABC):
+    """Resume a previous session."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.RESUME
+
+    @property
+    def summary(self) -> str:
+        return "Resume a previous session"
+
+    @property
+    def is_interactive(self) -> bool:
+        return True
+
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
+
+        if agent.session.messages_count > 0:
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="Cannot resume: current session already has messages. Use `klaude -r` to start a new instance with session selection.",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        selected_session_id = await asyncio.to_thread(resume_select_session)
+        if selected_session_id is None:
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="(no session selected)",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        return CommandResult(
+            operations=[op.ResumeSessionOperation(target_session_id=selected_session_id)],
+            persist_user_input=False,
+            persist_events=False,
+        )

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/command/status_cmd.py

@@ -152,4 +152,4 @@ class StatusCommand(CommandABC):
             ),
         )
 
-        return CommandResult(events=[event])
+        return CommandResult(events=[event], persist_user_input=False, persist_events=False)

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/config/assets/builtin_config.yaml

@@ -53,6 +53,17 @@ provider_list:
   protocol: openrouter
   api_key: ${OPENROUTER_API_KEY}
   model_list:
+  - model_name: gpt-5-mini
+    model_params:
+      model: openai/gpt-5-mini
+      max_tokens: 128000
+      context_limit: 400000
+      thinking:
+        reasoning_effort: high
+      cost:
+        input: 0.25
+        output: 2.0
+        cache_read: 0.03
   - model_name: gpt-5.1-codex-max
     model_params:
       model: openai/gpt-5.1-codex-max

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/core/executor.py

@@ -203,13 +203,15 @@ class ExecutorContext:
             raise ValueError("Multiple RunAgentOperation results are not supported")
 
         persisted_user_input = run_ops[0].input if run_ops else user_input
-        agent.session.append_history(
-            [model.UserMessageItem(content=persisted_user_input.text, images=persisted_user_input.images)]
-        )
+
+        if result.persist_user_input:
+            agent.session.append_history(
+                [model.UserMessageItem(content=persisted_user_input.text, images=persisted_user_input.images)]
+            )
 
         if result.events:
             for evt in result.events:
-                if isinstance(evt, events.DeveloperMessageEvent):
+                if result.persist_events and isinstance(evt, events.DeveloperMessageEvent):
                     agent.session.append_history([evt.item])
                 await self.emit_event(evt)
 
@@ -237,12 +239,13 @@ class ExecutorContext:
         agent.session.model_config_name = operation.model_name
         agent.session.model_thinking = llm_config.thinking
 
-        # Save the selection as default main_model
-        config.main_model = operation.model_name
-        await config.save()
+        if operation.save_as_default:
+            config.main_model = operation.model_name
+            await config.save()
 
+        default_note = " (saved as default)" if operation.save_as_default else ""
         developer_item = model.DeveloperMessageItem(
-            content=f"Switched to: {llm_config.model}",
+            content=f"Switched to: {llm_config.model}{default_note}",
             command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
         )
         agent.session.append_history([developer_item])
@@ -305,6 +308,37 @@ class ExecutorContext:
         )
         await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
 
+    async def handle_resume_session(self, operation: op.ResumeSessionOperation) -> None:
+        target_session = Session.load(operation.target_session_id)
+        if (
+            target_session.model_thinking is not None
+            and target_session.model_name
+            and target_session.model_name == self.llm_clients.main.model_name
+        ):
+            self.llm_clients.main.get_llm_config().thinking = target_session.model_thinking
+
+        profile = self.model_profile_provider.build_profile(self.llm_clients.main)
+        from klaude_code.core.agent import Agent
+
+        agent = Agent(session=target_session, profile=profile)
+
+        async for evt in agent.replay_history():
+            await self.emit_event(evt)
+
+        await self.emit_event(
+            events.WelcomeEvent(
+                work_dir=str(target_session.work_dir),
+                llm_config=self.llm_clients.main.get_llm_config(),
+            )
+        )
+
+        self._agent = agent
+        log_debug(
+            f"Resumed session: {target_session.id}",
+            style="cyan",
+            debug_type=DebugType.EXECUTION,
+        )
+
     async def handle_export_session(self, operation: op.ExportSessionOperation) -> None:
         agent = await self._ensure_agent(operation.session_id)
         try:

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/core/task.py

@@ -238,12 +238,13 @@ class TaskExecutor:
                 return
 
             if turn is None or turn.task_finished:
-                # Sub-agent with empty result should retry instead of finishing
-                if ctx.sub_agent_state is not None and turn is not None and not turn.task_result.strip():
-                    yield events.ErrorEvent(
-                        error_message="Sub-agent returned empty result, retrying...",
-                        can_retry=True,
-                    )
+                # Empty result should retry instead of finishing
+                if turn is not None and not turn.task_result.strip():
+                    if ctx.sub_agent_state is not None:
+                        error_msg = "Sub-agent returned empty result, retrying..."
+                    else:
+                        error_msg = "Agent returned empty result, retrying..."
+                    yield events.ErrorEvent(error_message=error_msg, can_retry=True)
                     continue
                 break
 

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/core/tool/shell/bash_tool.py

@@ -334,7 +334,9 @@ class BashTool(ToolABC):
                 _best_effort_update_file_tracker(args.command)
                 return model.ToolResultItem(
                     status="success",
-                    output=output.strip(),
+                    # Preserve leading whitespace for tools like `nl -ba`.
+                    # Only trim trailing newlines to avoid adding an extra blank line in the UI.
+                    output=output.rstrip("\n"),
                 )
             else:
                 combined = ""
@@ -346,7 +348,8 @@ class BashTool(ToolABC):
                     combined = f"Command exited with code {rc}"
                 return model.ToolResultItem(
                     status="error",
-                    output=combined.strip(),
+                    # Preserve leading whitespace; only trim trailing newlines.
+                    output=combined.rstrip("\n"),
                 )
         except FileNotFoundError:
             return model.ToolResultItem(

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/protocol/commands.py

@@ -16,6 +16,7 @@ class CommandName(str, Enum):
     RELEASE_NOTES = "release-notes"
     THINKING = "thinking"
     FORK_SESSION = "fork-session"
+    RESUME = "resume"
     # PLAN and DOC are dynamically registered now, but kept here if needed for reference
     # or we can remove them if no code explicitly imports them.
     # PLAN = "plan"

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/protocol/op.py

@@ -27,6 +27,7 @@ class OperationType(Enum):
     CHANGE_MODEL = "change_model"
     CHANGE_THINKING = "change_thinking"
     CLEAR_SESSION = "clear_session"
+    RESUME_SESSION = "resume_session"
     EXPORT_SESSION = "export_session"
     INTERRUPT = "interrupt"
     INIT_AGENT = "init_agent"
@@ -73,6 +74,7 @@ class ChangeModelOperation(Operation):
     type: OperationType = OperationType.CHANGE_MODEL
     session_id: str
     model_name: str
+    save_as_default: bool = False
 
     async def execute(self, handler: OperationHandler) -> None:
         await handler.handle_change_model(self)
@@ -98,6 +100,16 @@ class ClearSessionOperation(Operation):
         await handler.handle_clear_session(self)
 
 
+class ResumeSessionOperation(Operation):
+    """Operation for resuming a different session."""
+
+    type: OperationType = OperationType.RESUME_SESSION
+    target_session_id: str
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_resume_session(self)
+
+
 class ExportSessionOperation(Operation):
     """Operation for exporting a session transcript to HTML."""
 

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/protocol/op_handler.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
         ExportSessionOperation,
         InitAgentOperation,
         InterruptOperation,
+        ResumeSessionOperation,
         RunAgentOperation,
         UserInputOperation,
     )
@@ -44,6 +45,10 @@ class OperationHandler(Protocol):
         """Handle a clear session operation."""
         ...
 
+    async def handle_resume_session(self, operation: ResumeSessionOperation) -> None:
+        """Handle a resume session operation."""
+        ...
+
     async def handle_export_session(self, operation: ExportSessionOperation) -> None:
         """Handle an export session operation."""
         ...

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/ui/renderers/common.py

@@ -24,6 +24,8 @@ def truncate_display(
 
     Applies `ThemeKey.TOOL_RESULT_TRUNCATED` style to truncation indicators.
     """
+    # Expand tabs to spaces to ensure correct alignment when Rich applies padding.
+    text = text.expandtabs(8)
 
     if max_lines <= 0:
         truncated_lines = text.split("\n")

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/ui/renderers/mermaid_viewer.py

@@ -50,8 +50,7 @@ def ensure_viewer_file(*, code: str, link: str, tool_call_id: str) -> Path | Non
 
 
 def build_viewer(*, code: str, link: str, tool_call_id: str) -> Path | None:
-    """Create a local Mermaid viewer HTML file.
-    """
+    """Create a local Mermaid viewer HTML file."""
 
     if not code:
         return None

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/ui/renderers/metadata.py

@@ -97,6 +97,7 @@ def _render_task_metadata_block(
             context_size = format_number(metadata.usage.context_size or 0)
             parts.append(
                 Text.assemble(
+                    ("context ", ThemeKey.METADATA_DIM),
                     (context_size, ThemeKey.METADATA),
                     (f" ({metadata.usage.context_usage_percent:.1f}%)", ThemeKey.METADATA_DIM),
                 )

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/ui/renderers/thinking.py

@@ -10,7 +10,7 @@ from klaude_code.ui.rich.markdown import ThinkingMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 
 # UI markers
-THINKING_MESSAGE_MARK = "⸫"
+THINKING_MESSAGE_MARK = "∴"
 
 
 def normalize_thinking_content(content: str) -> str:

{klaude_code-1.2.29 → klaude_code-1.2.30}/src/klaude_code/ui/renderers/tools.py

@@ -1,7 +1,10 @@
 import json
+import re
 from pathlib import Path
 from typing import Any, cast
 
+from pygments.lexers import BashLexer  # pyright: ignore[reportUnknownVariableType]
+from pygments.token import Token
 from rich import box
 from rich.console import Group, RenderableType
 from rich.padding import Padding
@@ -15,6 +18,7 @@ from klaude_code.protocol.sub_agent import is_sub_agent_tool as _is_sub_agent_to
 from klaude_code.ui.renderers import diffs as r_diffs
 from klaude_code.ui.renderers import mermaid_viewer as r_mermaid_viewer
 from klaude_code.ui.renderers.common import create_grid, truncate_display
+from klaude_code.ui.rich.code_panel import CodePanel
 from klaude_code.ui.rich.markdown import NoInsetMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 
@@ -36,6 +40,86 @@ MARK_TODO_PENDING = "▢"
 MARK_TODO_IN_PROGRESS = "◉"
 MARK_TODO_COMPLETED = "✔"
 
+# Token types for bash syntax highlighting
+_BASH_STRING_TOKENS = frozenset(
+    {
+        Token.Literal.String,
+        Token.Literal.String.Double,
+        Token.Literal.String.Single,
+        Token.Literal.String.Backtick,
+        Token.Literal.String.Escape,
+        Token.Literal.String.Heredoc,
+        Token.Comment,
+        Token.Comment.Single,
+        Token.Comment.Hashbang,
+    }
+)
+
+_BASH_OPERATOR_TOKENS = frozenset(
+    {
+        Token.Operator,
+        Token.Punctuation,
+    }
+)
+
+# Operators that start a new command context (next non-whitespace token is a command)
+_BASH_COMMAND_STARTERS = frozenset({"&&", "||", "|", ";", "&"})
+
+# Commands that have subcommands (e.g., git commit, docker run)
+_SUBCOMMAND_COMMANDS = frozenset({
+    # Version control
+    "git", "jj", "hg", "svn",
+    # Container & orchestration
+    "docker", "docker-compose", "podman", "kubectl", "helm",
+    # Package managers
+    "npm", "yarn", "pnpm", "cargo", "uv", "pip", "poetry", "brew", "apt", "apt-get", "dnf", "yum", "pacman",
+    # Cloud CLIs
+    "aws", "gcloud", "az",
+    # Language tools
+    "go", "rustup", "python", "ruby",
+    # Other common tools
+    "gh", "systemctl", "launchctl", "supervisorctl",
+})
+
+_BASH_LEXER: Any = BashLexer(ensurenl=False)  # pyright: ignore[reportUnknownVariableType]
+
+# Regex to match heredoc: << [-]? [space]? ['"]? DELIMITER ['"]? [extra] \n body \n DELIMITER
+# Groups: (<<-?) (space) (quote) (delimiter) (quote) (extra on first line) (body) (end delimiter)
+_HEREDOC_PATTERN = re.compile(
+    r"^(<<-?)(\s*)(['\"]?)(\w+)\3([^\n]*)(\n.*\n)(\4)$",
+    re.DOTALL,
+)
+
+
+def _append_heredoc(result: Text, token_value: str) -> None:
+    """Append heredoc token with delimiter highlighting."""
+    match = _HEREDOC_PATTERN.match(token_value)
+    if match:
+        operator, space, quote, delimiter, extra, body, end_delimiter = match.groups()
+        # << or <<-
+        result.append(operator, style=ThemeKey.BASH_OPERATOR)
+        # Optional space
+        if space:
+            result.append(space)
+        # Opening quote
+        if quote:
+            result.append(quote, style=ThemeKey.BASH_HEREDOC_DELIMITER)
+        # Delimiter name (e.g., EOF)
+        result.append(delimiter, style=ThemeKey.BASH_HEREDOC_DELIMITER)
+        # Closing quote
+        if quote:
+            result.append(quote, style=ThemeKey.BASH_HEREDOC_DELIMITER)
+        # Extra content on first line (e.g., "> file.py")
+        if extra:
+            result.append(extra, style=ThemeKey.BASH_ARGUMENT)
+        # Body content
+        result.append(body, style=ThemeKey.BASH_STRING)
+        # End delimiter
+        result.append(end_delimiter, style=ThemeKey.BASH_HEREDOC_DELIMITER)
+    else:
+        # Fallback: couldn't parse heredoc structure
+        result.append(token_value, style=ThemeKey.BASH_STRING)
+
 
 def is_sub_agent_tool(tool_name: str) -> bool:
     return _is_sub_agent_tool(tool_name)
@@ -81,6 +165,65 @@ def render_generic_tool_call(tool_name: str, arguments: str, markup: str = MARK_
     return grid
 
 
+def _highlight_bash_command(command: str) -> Text:
+    """Apply bash syntax highlighting to a command string, returning Rich Text.
+
+    Styling:
+    - Command names (first token after line start or operators): bold green
+    - Subcommands (for commands like git, docker): bold green
+    - Arguments: green
+    - Operators (&&, ||, |, ;): dim green
+    - Strings and comments: green
+    """
+    result = Text()
+    token_type: Any
+    token_value: str
+
+    # Track whether next non-whitespace token is a command
+    expect_command = True
+    # Track whether next non-flag token is a subcommand
+    expect_subcommand = False
+
+    for token_type, token_value in _BASH_LEXER.get_tokens(command):
+        # Determine style based on token type and context
+        if token_type in _BASH_STRING_TOKENS:
+            # Check if this is a heredoc (starts with <<)
+            if token_value.startswith("<<"):
+                _append_heredoc(result, token_value)
+            else:
+                result.append(token_value, style=ThemeKey.BASH_STRING)
+            expect_subcommand = False
+        elif token_type in _BASH_OPERATOR_TOKENS:
+            result.append(token_value, style=ThemeKey.BASH_OPERATOR)
+            # After command-starting operators, next token is a command
+            if token_value in _BASH_COMMAND_STARTERS:
+                expect_command = True
+                expect_subcommand = False
+        elif token_type in (Token.Text.Whitespace,):
+            result.append(token_value)
+        elif token_type == Token.Name.Builtin:
+            # Built-in commands are always commands
+            result.append(token_value, style=ThemeKey.BASH_COMMAND)
+            expect_command = False
+            expect_subcommand = token_value in _SUBCOMMAND_COMMANDS
+        elif expect_command and token_value.strip():
+            # First non-whitespace token in command context
+            result.append(token_value, style=ThemeKey.BASH_COMMAND)
+            expect_command = False
+            expect_subcommand = token_value in _SUBCOMMAND_COMMANDS
+        elif expect_subcommand and token_value.strip() and not token_value.startswith("-"):
+            # Subcommand: non-flag token after a command that has subcommands
+            result.append(token_value, style=ThemeKey.BASH_COMMAND)
+            expect_subcommand = False
+        else:
+            # Regular arguments (including flags, which reset subcommand expectation)
+            result.append(token_value, style=ThemeKey.BASH_ARGUMENT)
+            if token_value.strip():
+                expect_subcommand = False
+
+    return result
+
+
 def render_bash_tool_call(arguments: str) -> RenderableType:
     grid = create_grid()
     tool_name_column = Text.assemble((MARK_BASH, ThemeKey.TOOL_MARK), " ", ("Bash", ThemeKey.TOOL_NAME))
@@ -105,22 +248,43 @@ def render_bash_tool_call(arguments: str) -> RenderableType:
 
     payload: dict[str, object] = cast(dict[str, object], payload_raw)
 
-    summary = Text("", ThemeKey.TOOL_PARAM)
     command = payload.get("command")
     timeout_ms = payload.get("timeout_ms")
 
+    # Build the command display with optional timeout suffix
     if isinstance(command, str) and command.strip():
-        summary.append(command.strip(), style=ThemeKey.TOOL_PARAM)
-
-    if isinstance(timeout_ms, int):
-        if summary:
-            summary.append(" ")
-        if timeout_ms >= 1000 and timeout_ms % 1000 == 0:
-            summary.append(f"{timeout_ms // 1000}s", style=ThemeKey.TOOL_TIMEOUT)
-        else:
-            summary.append(f"{timeout_ms}ms", style=ThemeKey.TOOL_TIMEOUT)
+        cmd_str = command.strip()
+        line_count = len(cmd_str.splitlines())
+
+        highlighted = _highlight_bash_command(cmd_str)
+
+        # For commands > 10 lines, use CodePanel for better display
+        if line_count > 10:
+            code_panel = CodePanel(highlighted, border_style=ThemeKey.LINES)
+            if isinstance(timeout_ms, int):
+                if timeout_ms >= 1000 and timeout_ms % 1000 == 0:
+                    timeout_text = Text(f"{timeout_ms // 1000}s", style=ThemeKey.TOOL_TIMEOUT)
+                else:
+                    timeout_text = Text(f"{timeout_ms}ms", style=ThemeKey.TOOL_TIMEOUT)
+                grid.add_row(tool_name_column, Group(code_panel, timeout_text))
+            else:
+                grid.add_row(tool_name_column, code_panel)
+            return grid
+        if isinstance(timeout_ms, int):
+            if timeout_ms >= 1000 and timeout_ms % 1000 == 0:
+                highlighted.append(f" {timeout_ms // 1000}s", style=ThemeKey.TOOL_TIMEOUT)
+            else:
+                highlighted.append(f" {timeout_ms}ms", style=ThemeKey.TOOL_TIMEOUT)
+        grid.add_row(tool_name_column, highlighted)
+    else:
+        summary = Text("", ThemeKey.TOOL_PARAM)
+        if isinstance(timeout_ms, int):
+            if timeout_ms >= 1000 and timeout_ms % 1000 == 0:
+                summary.append(f"{timeout_ms // 1000}s", style=ThemeKey.TOOL_TIMEOUT)
+            else:
+                summary.append(f"{timeout_ms}ms", style=ThemeKey.TOOL_TIMEOUT)
+        grid.add_row(tool_name_column, summary)
 
-    grid.add_row(tool_name_column, summary)
     return grid