klaude-code 2.1.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

klaude_code/tui/command/sub_agent_model_cmd.py

@@ -0,0 +1,190 @@
+"""Command for changing sub-agent models."""
+
+from __future__ import annotations
+
+import asyncio
+
+from prompt_toolkit.styles import Style
+
+from klaude_code.config.config import load_config
+from klaude_code.config.sub_agent_model_helper import SubAgentModelHelper, SubAgentModelInfo
+from klaude_code.protocol import commands, events, message, model, op
+from klaude_code.tui.terminal.selector import SelectItem, build_model_select_items, select_one
+
+from .command_abc import Agent, CommandABC, CommandResult
+
+SELECT_STYLE = Style(
+    [
+        ("instruction", "ansibrightblack"),
+        ("pointer", "ansigreen"),
+        ("highlighted", "ansigreen"),
+        ("text", "ansibrightblack"),
+        ("question", "bold"),
+        ("meta", "fg:ansibrightblack"),
+        ("msg", ""),
+    ]
+)
+
+USE_DEFAULT_BEHAVIOR = "__default__"
+
+
+def _build_sub_agent_select_items(
+    sub_agents: list[SubAgentModelInfo],
+    helper: SubAgentModelHelper,
+    main_model_name: str,
+) -> list[SelectItem[str]]:
+    """Build SelectItem list for sub-agent selection."""
+    items: list[SelectItem[str]] = []
+    max_name_len = max(len(sa.profile.name) for sa in sub_agents) if sub_agents else 0
+
+    for sa in sub_agents:
+        name = sa.profile.name
+
+        if sa.configured_model:
+            model_display = sa.configured_model
+        else:
+            behavior = helper.describe_empty_model_config_behavior(name, main_model_name=main_model_name)
+            model_display = f"({behavior.description})"
+
+        title = [
+            ("class:msg", f"{name:<{max_name_len}}"),
+            ("class:meta", f"  current: {model_display}\n"),
+        ]
+        items.append(SelectItem(title=title, value=name, search_text=name))
+
+    return items
+
+
+def _select_sub_agent_sync(
+    sub_agents: list[SubAgentModelInfo],
+    helper: SubAgentModelHelper,
+    main_model_name: str,
+) -> str | None:
+    """Synchronous sub-agent type selection."""
+    items = _build_sub_agent_select_items(sub_agents, helper, main_model_name)
+    if not items:
+        return None
+
+    try:
+        result = select_one(
+            message="Select sub-agent to configure:",
+            items=items,
+            pointer="->",
+            style=SELECT_STYLE,
+            use_search_filter=False,
+        )
+        return result if isinstance(result, str) else None
+    except KeyboardInterrupt:
+        return None
+
+
+def _select_model_for_sub_agent_sync(
+    helper: SubAgentModelHelper,
+    sub_agent_type: str,
+    main_model_name: str,
+) -> str | None:
+    """Synchronous model selection for a sub-agent."""
+    models = helper.get_selectable_models(sub_agent_type)
+
+    default_behavior = helper.describe_empty_model_config_behavior(sub_agent_type, main_model_name=main_model_name)
+
+    inherit_item = SelectItem[str](
+        title=[
+            ("class:msg", "(Use default behavior)"),
+            ("class:meta", f"  -> {default_behavior.description}\n"),
+        ],
+        value=USE_DEFAULT_BEHAVIOR,
+        search_text="default unset",
+    )
+    model_items = build_model_select_items(models)
+    all_items = [inherit_item, *model_items]
+
+    try:
+        result = select_one(
+            message=f"Select model for {sub_agent_type}:",
+            items=all_items,
+            pointer="->",
+            style=SELECT_STYLE,
+            use_search_filter=True,
+        )
+        return result if isinstance(result, str) else None
+    except KeyboardInterrupt:
+        return None
+
+
+class SubAgentModelCommand(CommandABC):
+    """Configure models for sub-agents (Task, Explore, WebAgent, ImageGen)."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.SUB_AGENT_MODEL
+
+    @property
+    def summary(self) -> str:
+        return "Change sub-agent models"
+
+    @property
+    def is_interactive(self) -> bool:
+        return True
+
+    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
+        config = load_config()
+        helper = SubAgentModelHelper(config)
+        main_model_name = agent.get_llm_client().model_name
+
+        sub_agents = helper.get_available_sub_agents()
+        if not sub_agents:
+            return CommandResult(
+                events=[
+                    events.DeveloperMessageEvent(
+                        session_id=agent.session.id,
+                        item=message.DeveloperMessage(
+                            parts=message.text_parts_from_str("No sub-agents available"),
+                            ui_extra=model.build_command_output_extra(self.name),
+                        ),
+                    )
+                ]
+            )
+
+        selected_sub_agent = await asyncio.to_thread(_select_sub_agent_sync, sub_agents, helper, main_model_name)
+        if selected_sub_agent is None:
+            return CommandResult(
+                events=[
+                    events.DeveloperMessageEvent(
+                        session_id=agent.session.id,
+                        item=message.DeveloperMessage(
+                            parts=message.text_parts_from_str("(cancelled)"),
+                            ui_extra=model.build_command_output_extra(self.name),
+                        ),
+                    )
+                ]
+            )
+
+        selected_model = await asyncio.to_thread(
+            _select_model_for_sub_agent_sync, helper, selected_sub_agent, main_model_name
+        )
+        if selected_model is None:
+            return CommandResult(
+                events=[
+                    events.DeveloperMessageEvent(
+                        session_id=agent.session.id,
+                        item=message.DeveloperMessage(
+                            parts=message.text_parts_from_str("(cancelled)"),
+                            ui_extra=model.build_command_output_extra(self.name),
+                        ),
+                    )
+                ]
+            )
+
+        model_name: str | None = None if selected_model == USE_DEFAULT_BEHAVIOR else selected_model
+
+        return CommandResult(
+            operations=[
+                op.ChangeSubAgentModelOperation(
+                    session_id=agent.session.id,
+                    sub_agent_type=selected_sub_agent,
+                    model_name=model_name,
+                    save_as_default=True,
+                )
+            ]
+        )

klaude_code/tui/components/bash_syntax.py

@@ -3,7 +3,7 @@
 import re
 from typing import Any
 
-from pygments.lexers import BashLexer  # pyright: ignore[reportUnknownVariableType]
+from pygments.lexers.shell import BashLexer  # pyright: ignore[reportMissingTypeStubs, reportUnknownVariableType]
 from pygments.token import Token
 from rich.text import Text
 

klaude_code/tui/components/common.py

@@ -106,7 +106,7 @@ def truncate_head(
     text = text.expandtabs(TAB_EXPAND_WIDTH)
     lines = [line for line in text.split("\n") if line.strip()]
 
-    out = Text()
+    out = Text(overflow="fold")
     if base_style is not None:
         out.style = base_style
 

klaude_code/tui/components/developer.py

@@ -5,7 +5,6 @@ from rich.text import Text
 
 from klaude_code.protocol import commands, events, message, model
 from klaude_code.tui.components.common import create_grid, truncate_middle
-from klaude_code.tui.components.rich.markdown import NoInsetMarkdown
 from klaude_code.tui.components.rich.theme import ThemeKey
 from klaude_code.tui.components.tools import render_path
 
@@ -142,12 +141,8 @@ def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
 
     content = message.join_text_parts(e.item.parts)
     match command_output.command_name:
-        case commands.CommandName.HELP:
-            return Padding.indent(Text.from_markup(content or ""), level=2)
         case commands.CommandName.STATUS:
             return _render_status_output(command_output)
-        case commands.CommandName.RELEASE_NOTES:
-            return Padding.indent(NoInsetMarkdown(content or ""), level=2)
         case commands.CommandName.FORK_SESSION:
             return _render_fork_session_output(command_output)
         case _:
@@ -178,14 +173,14 @@ def _format_cost(cost: float | None, currency: str = "USD") -> str:
 def _render_fork_session_output(command_output: model.CommandOutput) -> RenderableType:
     """Render fork session output with usage instructions."""
     if not isinstance(command_output.ui_extra, model.SessionIdUIExtra):
-        return Padding.indent(Text("(no session id)", style=ThemeKey.METADATA), level=2)
+        return Padding.indent(Text("(no session id)", style=ThemeKey.TOOL_RESULT), level=2)
 
     grid = Table.grid(padding=(0, 1))
     session_id = command_output.ui_extra.session_id
-    grid.add_column(style=ThemeKey.METADATA, overflow="fold")
+    grid.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
 
-    grid.add_row(Text("Session forked. Resume command copied to clipboard:", style=ThemeKey.METADATA))
-    grid.add_row(Text(f"  klaude --resume-by-id {session_id}", style=ThemeKey.METADATA_BOLD))
+    grid.add_row(Text("Session forked. Resume command copied to clipboard:", style=ThemeKey.TOOL_RESULT))
+    grid.add_row(Text(f"  klaude --resume-by-id {session_id}", style=ThemeKey.TOOL_RESULT_BOLD))
 
     return Padding.indent(grid, level=2)
 
@@ -193,24 +188,24 @@ def _render_fork_session_output(command_output: model.CommandOutput) -> Renderab
 def _render_status_output(command_output: model.CommandOutput) -> RenderableType:
     """Render session status with total cost and per-model breakdown."""
     if not isinstance(command_output.ui_extra, model.SessionStatusUIExtra):
-        return Text("(no status data)", style=ThemeKey.METADATA)
+        return Text("(no status data)", style=ThemeKey.TOOL_RESULT)
 
     status = command_output.ui_extra
     usage = status.usage
 
     table = Table.grid(padding=(0, 2))
-    table.add_column(style=ThemeKey.METADATA, overflow="fold")
-    table.add_column(style=ThemeKey.METADATA, overflow="fold")
+    table.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
+    table.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
 
     # Total cost line
     table.add_row(
-        Text("Total cost:", style=ThemeKey.METADATA_BOLD),
-        Text(_format_cost(usage.total_cost, usage.currency), style=ThemeKey.METADATA_BOLD),
+        Text("Total cost:", style=ThemeKey.TOOL_RESULT_BOLD),
+        Text(_format_cost(usage.total_cost, usage.currency), style=ThemeKey.TOOL_RESULT_BOLD),
     )
 
     # Per-model breakdown
     if status.by_model:
-        table.add_row(Text("Usage by model:", style=ThemeKey.METADATA_BOLD), "")
+        table.add_row(Text("Usage by model:", style=ThemeKey.TOOL_RESULT_BOLD), "")
         for meta in status.by_model:
             model_label = meta.model_name
             if meta.provider:

klaude_code/tui/components/metadata.py

@@ -1,24 +1,12 @@
-from importlib.metadata import PackageNotFoundError, version
-
 from rich.console import Group, RenderableType
 from rich.padding import Padding
 from rich.text import Text
 
 from klaude_code.const import DEFAULT_MAX_TOKENS
-from klaude_code.log import is_debug_enabled
 from klaude_code.protocol import events, model
 from klaude_code.tui.components.common import create_grid
-from klaude_code.tui.components.rich.quote import Quote
 from klaude_code.tui.components.rich.theme import ThemeKey
-from klaude_code.ui.common import format_model_params, format_number
-
-
-def _get_version() -> str:
-    """Get the current version of klaude-code."""
-    try:
-        return version("klaude-code")
-    except PackageNotFoundError:
-        return "unknown"
+from klaude_code.ui.common import format_number
 
 
 def _render_task_metadata_block(
@@ -188,60 +176,10 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
             ("Σ ", ThemeKey.METADATA_DIM),
             ("total ", ThemeKey.METADATA_DIM),
             (currency_symbol, ThemeKey.METADATA_DIM),
-            (f"{total_cost:.4f}", ThemeKey.METADATA_BOLD),
+            (f"{total_cost:.4f}", ThemeKey.METADATA),
         )
         grid = create_grid()
         grid.add_row(Text(" ", style=ThemeKey.METADATA_DIM), total_line)
         renderables.append(Padding(grid, (0, 0, 0, 2)))
 
     return Group(*renderables)
-
-
-def render_welcome(e: events.WelcomeEvent) -> RenderableType:
-    """Render the welcome panel with model info and settings.
-
-    Args:
-        e: The welcome event.
-    """
-    debug_mode = is_debug_enabled()
-
-    panel_content = Text()
-
-    if e.show_klaude_code_info:
-        # First line: Klaude Code version
-        klaude_code_style = ThemeKey.WELCOME_DEBUG_TITLE if debug_mode else ThemeKey.WELCOME_HIGHLIGHT_BOLD
-        panel_content.append_text(Text("Klaude Code", style=klaude_code_style))
-        panel_content.append_text(Text(f" v{_get_version()}", style=ThemeKey.WELCOME_INFO))
-        panel_content.append_text(Text("\n"))
-
-    # Model line: model @ provider · params...
-    panel_content.append_text(
-        Text.assemble(
-            (str(e.llm_config.model), ThemeKey.WELCOME_HIGHLIGHT),
-            (" @ ", ThemeKey.WELCOME_INFO),
-            (e.llm_config.provider_name, ThemeKey.WELCOME_INFO),
-        )
-    )
-
-    # Use format_model_params for consistent formatting
-    param_strings = format_model_params(e.llm_config)
-
-    # Render config items with tree-style prefixes
-    for i, param_str in enumerate(param_strings):
-        is_last = i == len(param_strings) - 1
-        prefix = "└─ " if is_last else "├─ "
-        panel_content.append_text(
-            Text.assemble(
-                ("\n", ThemeKey.WELCOME_INFO),
-                (prefix, ThemeKey.LINES),
-                (param_str, ThemeKey.WELCOME_INFO),
-            )
-        )
-
-    border_style = ThemeKey.WELCOME_DEBUG_BORDER if debug_mode else ThemeKey.LINES
-
-    if e.show_klaude_code_info:
-        groups = ["", Quote(panel_content, style=border_style, prefix="▌ "), ""]
-    else:
-        groups = [Quote(panel_content, style=border_style, prefix="▌ "), ""]
-    return Group(*groups)

klaude_code/tui/components/rich/cjk_wrap.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import unicodedata
 from collections.abc import Callable
+from typing import Any, cast
 
 
 def _is_cjk_char(ch: str) -> bool:
@@ -222,7 +223,7 @@ def install_rich_cjk_wrap_patch() -> bool:
 
         return break_positions
 
-    _wrap.divide_line = divide_line_patched  # pyright: ignore[reportPrivateImportUsage]
-    _text.divide_line = divide_line_patched  # pyright: ignore[reportPrivateImportUsage]
+    cast(Any, _wrap).divide_line = divide_line_patched  # pyright: ignore[reportPrivateImportUsage]
+    cast(Any, _text).divide_line = divide_line_patched  # pyright: ignore[reportPrivateImportUsage]
     _rich_cjk_wrap_patch_installed = True
     return True

klaude_code/tui/components/rich/status.py

@@ -263,6 +263,53 @@ def _breathing_style(console: Console, base_style: Style, intensity: float) -> S
     return base_style + Style(color=breathing_color)
 
 
+def truncate_left(text: Text, max_cells: int, *, console: Console, ellipsis: str = "…") -> Text:
+    """Left-truncate Text to fit within max_cells.
+
+    Keeps the rightmost part of the text and prepends an ellipsis when truncation occurs.
+    Uses cell width so wide characters are handled reasonably.
+    """
+
+    max_cells = max(0, int(max_cells))
+    if max_cells == 0:
+        return Text("")
+
+    if cell_len(text.plain) <= max_cells:
+        return text
+
+    ellipsis_cells = cell_len(ellipsis)
+    if max_cells <= ellipsis_cells:
+        # Not enough space to show any meaningful suffix.
+        clipped = Text(ellipsis, style=text.style)
+        clipped.truncate(max_cells, overflow="crop", pad=False)
+        return clipped
+
+    suffix_budget = max_cells - ellipsis_cells
+    plain = text.plain
+
+    suffix_cells = 0
+    start_index = len(plain)
+    for i in range(len(plain) - 1, -1, -1):
+        ch_cells = cell_len(plain[i])
+        if suffix_cells + ch_cells > suffix_budget:
+            break
+        suffix_cells += ch_cells
+        start_index = i
+        if suffix_cells == suffix_budget:
+            break
+
+    if start_index >= len(plain):
+        return Text(ellipsis, style=text.style)
+
+    suffix = text[start_index:]
+    try:
+        ellipsis_style = suffix.get_style_at_offset(console, 0)
+    except Exception:
+        ellipsis_style = suffix.style or text.style
+
+    return Text.assemble(Text(ellipsis, style=ellipsis_style), suffix)
+
+
 class ShimmerStatusText:
     """Renderable status line with shimmer effect on the main text and hint.
 
@@ -322,12 +369,11 @@ class _StatusLeftText:
         # If the hint itself can't fit, fall back to truncating the combined text.
         if max_width <= hint_cells:
             combined = Text.assemble(main_text, hint_text)
-            combined.truncate(max(1, max_width), overflow="ellipsis", pad=False)
-            yield combined
+            yield truncate_left(combined, max(1, max_width), console=console)
             return
 
         main_budget = max_width - hint_cells
-        main_text.truncate(max(1, main_budget), overflow="ellipsis", pad=False)
+        main_text = truncate_left(main_text, max(1, main_budget), console=console)
         yield Text.assemble(main_text, hint_text)
 
 

klaude_code/tui/components/rich/theme.py

@@ -191,6 +191,7 @@ class ThemeKey(str, Enum):
     WELCOME_HIGHLIGHT_BOLD = "welcome.highlight.bold"
     WELCOME_HIGHLIGHT = "welcome.highlight"
     WELCOME_INFO = "welcome.info"
+    WELCOME_INFO_BOLD = "welcome.info.bold"
     # WELCOME DEBUG
     WELCOME_DEBUG_TITLE = "welcome.debug.title"
     WELCOME_DEBUG_BORDER = "welcome.debug.border"
@@ -250,8 +251,8 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.USER_INPUT.value: palette.magenta,
                 ThemeKey.USER_INPUT_PROMPT.value: "bold " + palette.magenta,
                 ThemeKey.USER_INPUT_AT_PATTERN.value: palette.purple,
-                ThemeKey.USER_INPUT_SLASH_COMMAND.value: "bold reverse " + palette.blue,
-                ThemeKey.USER_INPUT_SKILL.value: "bold reverse " + palette.green,
+                ThemeKey.USER_INPUT_SLASH_COMMAND.value: "bold " + palette.blue,
+                ThemeKey.USER_INPUT_SKILL.value: "bold " + palette.green,
                 # ASSISTANT
                 ThemeKey.ASSISTANT_MESSAGE_MARK.value: "bold",
                 # METADATA
@@ -307,6 +308,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.WELCOME_HIGHLIGHT_BOLD.value: "bold",
                 ThemeKey.WELCOME_HIGHLIGHT.value: palette.blue,
                 ThemeKey.WELCOME_INFO.value: palette.grey1,
+                ThemeKey.WELCOME_INFO_BOLD.value: "bold " + palette.grey1,
                 # WELCOME DEBUG
                 ThemeKey.WELCOME_DEBUG_TITLE.value: "bold " + palette.red,
                 ThemeKey.WELCOME_DEBUG_BORDER.value: palette.red,

klaude_code/tui/components/sub_agent.py

@@ -3,7 +3,7 @@ from typing import Any, cast
 
 from rich.console import Group, RenderableType
 from rich.json import JSON
-from rich.style import Style, StyleType
+from rich.style import Style
 from rich.text import Text
 
 from klaude_code.const import SUB_AGENT_RESULT_MAX_LINES
@@ -79,65 +79,44 @@ def _extract_agent_id_footer(text: str) -> tuple[str, str | None]:
 def render_sub_agent_result(
     result: str,
     *,
-    code_theme: str,
-    style: StyleType | None = None,
     has_structured_output: bool = False,
     description: str | None = None,
 ) -> RenderableType:
     stripped_result = result.strip()
-
-    # Extract agentId footer for separate styling
     main_content, agent_id_footer = _extract_agent_id_footer(stripped_result)
     stripped_result = main_content.strip()
 
-    # Use rich JSON for structured output
+    elements: list[RenderableType] = []
+    if description:
+        elements.append(Text(f"---\n{description}", style=ThemeKey.TOOL_RESULT))
+
+    # Try structured JSON output first
+    use_text_rendering = True
     if has_structured_output:
         try:
-            group_elements: list[RenderableType] = [
-                Text(
-                    "use /export to view full output",
-                    style=ThemeKey.TOOL_RESULT,
-                ),
-                JSON(stripped_result),
-            ]
-            if description:
-                group_elements.insert(0, Text(f"\n{description}", style=style or ""))
-            if agent_id_footer:
-                group_elements.append(Text(agent_id_footer, style=ThemeKey.SUB_AGENT_FOOTER))
-            return Group(*group_elements)
+            elements.append(Text("use /export to view full output", style=ThemeKey.TOOL_RESULT_TRUNCATED))
+            elements.append(JSON(stripped_result))
+            use_text_rendering = False
         except json.JSONDecodeError:
-            # Fall back to markdown if not valid JSON
             pass
 
-    if not stripped_result:
-        return Text()
-
-    lines = stripped_result.splitlines()
-    if len(lines) > SUB_AGENT_RESULT_MAX_LINES:
-        hidden_count = len(lines) - SUB_AGENT_RESULT_MAX_LINES
-        tail_text = "\n".join(lines[-SUB_AGENT_RESULT_MAX_LINES:])
-        truncated_elements: list[RenderableType] = []
-        # Add description heading separately so it won't be truncated
-        if description:
-            truncated_elements.append(Text(f"---\n{description}", style=style or ""))
-        truncated_elements.append(
-            Text(
-                f"( … more {hidden_count} lines)",
-                style=ThemeKey.TOOL_RESULT_TRUNCATED,
-            )
-        )
-        truncated_elements.append(Text(tail_text, style=style or ""))
-        if agent_id_footer:
-            truncated_elements.append(Text(agent_id_footer, style=ThemeKey.SUB_AGENT_FOOTER))
-        return Group(*truncated_elements)
+    # Text rendering (either fallback or non-structured)
+    if use_text_rendering:
+        if not stripped_result:
+            return Text()
+
+        lines = stripped_result.splitlines()
+        if len(lines) > SUB_AGENT_RESULT_MAX_LINES:
+            hidden_count = len(lines) - SUB_AGENT_RESULT_MAX_LINES
+            elements.append(Text(f"( ... more {hidden_count} lines)", style=ThemeKey.TOOL_RESULT_TRUNCATED))
+            elements.append(Text("\n".join(lines[-SUB_AGENT_RESULT_MAX_LINES:]), style=ThemeKey.TOOL_RESULT))
+        else:
+            elements.append(Text(stripped_result, style=ThemeKey.TOOL_RESULT))
 
-    # No truncation needed - add description heading if provided
-    if description:
-        stripped_result = f"\n# {description}\n\n{stripped_result}"
-    normal_elements: list[RenderableType] = [Text(stripped_result)]
     if agent_id_footer:
-        normal_elements.append(Text(agent_id_footer, style=ThemeKey.SUB_AGENT_FOOTER))
-    return Group(*normal_elements)
+        elements.append(Text(agent_id_footer, style=ThemeKey.SUB_AGENT_FOOTER))
+
+    return Group(*elements)
 
 
 def build_sub_agent_state_from_tool_call(e: events.ToolCallEvent) -> model.SubAgentState | None:

klaude_code/tui/components/user_input.py

@@ -4,7 +4,6 @@ from rich.console import Group, RenderableType
 from rich.text import Text
 
 from klaude_code.skill import get_available_skills
-from klaude_code.tui.command import is_slash_command_name
 from klaude_code.tui.components.common import create_grid
 from klaude_code.tui.components.rich.theme import ThemeKey
 
@@ -54,35 +53,28 @@ def _is_valid_skill_name(name: str) -> bool:
 def render_user_input(content: str) -> RenderableType:
     """Render a user message as a group of quoted lines with styles.
 
-    - Highlights slash command on the first line if recognized
+    - Highlights slash command token on the first line
     - Highlights $skill pattern on the first line if recognized
     - Highlights @file patterns in all lines
     """
     lines = content.strip().split("\n")
     renderables: list[RenderableType] = []
-    has_command = False
-    command_style: str | None = None
     for i, line in enumerate(lines):
         line_text = render_at_pattern(line)
 
         if i == 0 and line.startswith("/"):
             splits = line.split(" ", maxsplit=1)
-            if is_slash_command_name(splits[0][1:]):
-                has_command = True
-                command_style = ThemeKey.USER_INPUT_SLASH_COMMAND
-                line_text = Text.assemble(
-                    (f"{splits[0]}", ThemeKey.USER_INPUT_SLASH_COMMAND),
-                    " ",
-                    render_at_pattern(splits[1]) if len(splits) > 1 else Text(""),
-                )
-                renderables.append(line_text)
-                continue
+            line_text = Text.assemble(
+                (splits[0], ThemeKey.USER_INPUT_SLASH_COMMAND),
+                " ",
+                render_at_pattern(splits[1]) if len(splits) > 1 else Text(""),
+            )
+            renderables.append(line_text)
+            continue
 
         if i == 0 and (line.startswith("$") or line.startswith("¥")):
             m = SKILL_RENDER_PATTERN.match(line)
             if m and _is_valid_skill_name(m.group(1)):
-                has_command = True
-                command_style = ThemeKey.USER_INPUT_SKILL
                 skill_token = m.group(0)  # e.g. "$skill-name"
                 rest = line[len(skill_token) :]
                 line_text = Text.assemble(
@@ -95,11 +87,7 @@ def render_user_input(content: str) -> RenderableType:
         renderables.append(line_text)
     grid = create_grid()
     grid.padding = (0, 0)
-    mark = (
-        Text(USER_MESSAGE_MARK, style=ThemeKey.USER_INPUT_PROMPT)
-        if not has_command
-        else Text("  ", style=command_style or ThemeKey.USER_INPUT_SLASH_COMMAND)
-    )
+    mark = Text(USER_MESSAGE_MARK, style=ThemeKey.USER_INPUT_PROMPT)
     grid.add_row(mark, Group(*renderables))
     return grid