klaude-code 1.2.22__py3-none-any.whl → 1.2.23__py3-none-any.whl

klaude_code/ui/modes/repl/completers.py

@@ -1,13 +1,15 @@
-"""REPL completion handlers for @ file paths and / slash commands.
+"""REPL completion handlers for @ file paths, / slash commands, and $ skills.
 
 This module provides completers for the REPL input:
 - _SlashCommandCompleter: Completes slash commands on the first line
+- _SkillCompleter: Completes skill names on the first line with $ prefix
 - _AtFilesCompleter: Completes @path segments using fd or ripgrep
-- _ComboCompleter: Combines both completers with priority logic
+- _ComboCompleter: Combines all completers with priority logic
 
 Public API:
 - create_repl_completer(): Factory function to create the combined completer
 - AT_TOKEN_PATTERN: Regex pattern for @token matching (used by key bindings)
+- SKILL_TOKEN_PATTERN: Regex pattern for $skill matching (used by key bindings)
 """
 
 from __future__ import annotations
@@ -34,6 +36,9 @@ from klaude_code.trace.log import DebugType, log_debug
 # single logical token.
 AT_TOKEN_PATTERN = re.compile(r'(^|\s)@(?P<frag>"[^"]*"|[^\s]*)$')
 
+# Pattern to match $skill or ¥skill token for skill completion (used by key bindings).
+SKILL_TOKEN_PATTERN = re.compile(r"^[$¥](?P<frag>\S*)$")
+
 
 def create_repl_completer() -> Completer:
     """Create and return the combined REPL completer.
@@ -121,12 +126,102 @@ class _SlashCommandCompleter(Completer):
         return bool(self._SLASH_TOKEN_RE.search(text_before))
 
 
+class _SkillCompleter(Completer):
+    """Complete skill names at the beginning of the first line.
+
+    Behavior:
+    - Only triggers when cursor is on first line and text matches $ or ¥...
+    - Shows available skills with descriptions
+    - Inserts trailing space after completion
+    """
+
+    _SKILL_TOKEN_RE = SKILL_TOKEN_PATTERN
+
+    def get_completions(
+        self,
+        document: Document,
+        complete_event,  # type: ignore[override]
+    ) -> Iterable[Completion]:
+        # Only complete on first line
+        if document.cursor_position_row != 0:
+            return
+
+        text_before = document.current_line_before_cursor
+        m = self._SKILL_TOKEN_RE.search(text_before)
+        if not m:
+            return
+
+        frag = m.group("frag").lower()
+        # Get the prefix character ($ or ¥)
+        prefix_char = text_before[0]
+        token_start = len(text_before) - len(f"{prefix_char}{m.group('frag')}")
+        start_position = token_start - len(text_before)  # negative offset
+
+        # Get available skills from SkillTool
+        skills = self._get_available_skills()
+        if not skills:
+            return
+
+        # Filter skills that match the fragment (case-insensitive)
+        matched: list[tuple[str, str, str]] = []  # (name, description, location)
+        for name, desc, location in skills:
+            if frag in name.lower() or frag in desc.lower():
+                matched.append((name, desc, location))
+
+        if not matched:
+            return
+
+        # Calculate max width for alignment
+        max_name_len = max(len(name) for name, _, _ in matched)
+        align_width = max(max_name_len, 20) + 2
+
+        for name, desc, location in matched:
+            # Format: name  [location]  description
+            # Align location tags (max length is "project" = 7, plus brackets = 9)
+            padding_name = " " * (align_width - len(name))
+            location_tag = f"[{location}]".ljust(9)
+
+            # Using HTML for formatting: bold skill name, cyan location tag, gray description
+            display_text = HTML(
+                f"<b>{name}</b>{padding_name}<style color='ansicyan'>{location_tag}</style> "
+                f"<style color='ansibrightblack'>{desc}</style>"
+            )
+            completion_text = f"${name} "
+            yield Completion(
+                text=completion_text,
+                start_position=start_position,
+                display=display_text,
+            )
+
+    def _get_available_skills(self) -> list[tuple[str, str, str]]:
+        """Get available skills from skill module.
+
+        Returns:
+            List of (name, description, location) tuples
+        """
+        try:
+            # Import here to avoid circular imports
+            from klaude_code.skill import get_available_skills
+
+            return get_available_skills()
+        except Exception:
+            return []
+
+    def is_skill_context(self, document: Document) -> bool:
+        """Check if current context is a skill completion."""
+        if document.cursor_position_row != 0:
+            return False
+        text_before = document.current_line_before_cursor
+        return bool(self._SKILL_TOKEN_RE.search(text_before))
+
+
 class _ComboCompleter(Completer):
-    """Combined completer that handles both @ file paths and / slash commands."""
+    """Combined completer that handles @ file paths, / slash commands, and $ skills."""
 
     def __init__(self) -> None:
         self._at_completer = _AtFilesCompleter()
         self._slash_completer = _SlashCommandCompleter()
+        self._skill_completer = _SkillCompleter()
 
     def get_completions(
         self,
@@ -138,6 +233,11 @@ class _ComboCompleter(Completer):
             yield from self._slash_completer.get_completions(document, complete_event)
             return
 
+        # Try skill completion (only on first line with $ prefix)
+        if document.cursor_position_row == 0 and self._skill_completer.is_skill_context(document):
+            yield from self._skill_completer.get_completions(document, complete_event)
+            return
+
         # Fall back to @ file completion
         yield from self._at_completer.get_completions(document, complete_event)
 

klaude_code/ui/modes/repl/event_handler.py

@@ -2,12 +2,14 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from rich.rule import Rule
 from rich.text import Text
 
 from klaude_code import const
 from klaude_code.protocol import events
 from klaude_code.ui.core.stage_manager import Stage, StageManager
 from klaude_code.ui.modes.repl.renderer import REPLRenderer
+from klaude_code.ui.renderers.assistant import ASSISTANT_MESSAGE_MARK
 from klaude_code.ui.renderers.thinking import normalize_thinking_content
 from klaude_code.ui.rich.markdown import MarkdownStream, ThinkingMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
@@ -327,7 +329,7 @@ class DisplayEventHandler:
                 theme=self.renderer.themes.thinking_markdown_theme,
                 console=self.renderer.console,
                 spinner=self.renderer.spinner_renderable(),
-                indent=2,
+                left_margin=const.MARKDOWN_LEFT_MARGIN,
                 markdown_class=ThinkingMarkdown,
             )
             self.thinking_stream.start(mdstream)
@@ -358,8 +360,8 @@ class DisplayEventHandler:
                 theme=self.renderer.themes.markdown_theme,
                 console=self.renderer.console,
                 spinner=self.renderer.spinner_renderable(),
-                mark="➤",
-                indent=2,
+                mark=ASSISTANT_MESSAGE_MARK,
+                left_margin=const.MARKDOWN_LEFT_MARGIN,
             )
             self.assistant_stream.start(mdstream)
         self.assistant_stream.append(event.content)
@@ -430,6 +432,8 @@ class DisplayEventHandler:
             emit_osc94(OSC94States.HIDDEN)
             self.spinner_status.reset()
             self.renderer.spinner_stop()
+            self.renderer.console.print(Rule(characters="-", style=ThemeKey.LINES))
+            self.renderer.print()
         await self.stage_manager.transition_to(Stage.WAITING)
         self._maybe_notify_task_finish(event)
 

klaude_code/ui/modes/repl/input_prompt_toolkit.py

@@ -7,6 +7,7 @@ from typing import NamedTuple, override
 
 from prompt_toolkit import PromptSession
 from prompt_toolkit.completion import ThreadedCompleter
+from prompt_toolkit.cursor_shapes import CursorShape
 from prompt_toolkit.formatted_text import FormattedText
 from prompt_toolkit.history import FileHistory
 from prompt_toolkit.patch_stdout import patch_stdout
@@ -17,6 +18,8 @@ from klaude_code.ui.core.input import InputProviderABC
 from klaude_code.ui.modes.repl.clipboard import capture_clipboard_tag, copy_to_clipboard, extract_images_from_text
 from klaude_code.ui.modes.repl.completers import AT_TOKEN_PATTERN, create_repl_completer
 from klaude_code.ui.modes.repl.key_bindings import create_key_bindings
+from klaude_code.ui.renderers.user_input import USER_MESSAGE_MARK
+from klaude_code.ui.terminal.color import is_light_terminal_background
 from klaude_code.ui.utils.common import get_current_git_branch, show_path_with_tilde
 
 
@@ -32,16 +35,23 @@ class REPLStatusSnapshot(NamedTuple):
 
 COMPLETION_SELECTED = "#5869f7"
 COMPLETION_MENU = "ansibrightblack"
-INPUT_PROMPT_STYLE = "ansimagenta"
+INPUT_PROMPT_STYLE = "ansimagenta bold"
+PLACEHOLDER_TEXT_STYLE_DARK_BG = "fg:#5a5a5a italic"
+PLACEHOLDER_TEXT_STYLE_LIGHT_BG = "fg:#7a7a7a italic"
+PLACEHOLDER_TEXT_STYLE_UNKNOWN_BG = "fg:#8a8a8a italic"
+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"
 
 
 class PromptToolkitInput(InputProviderABC):
     def __init__(
         self,
-        prompt: str = "❯ ",
+        prompt: str = USER_MESSAGE_MARK,
         status_provider: Callable[[], REPLStatusSnapshot] | None = None,
     ):  # ▌
         self._status_provider = status_provider
+        self._is_light_terminal_background = is_light_terminal_background(timeout=0.2)
 
         project = str(Path.cwd()).strip("/").replace("/", "-")
         history_path = Path.home() / ".klaude" / "projects" / project / "input" / "input_history.txt"
@@ -60,6 +70,7 @@ class PromptToolkitInput(InputProviderABC):
             [(INPUT_PROMPT_STYLE, prompt)],
             history=FileHistory(str(history_path)),
             multiline=True,
+            cursor=CursorShape.BEAM,
             prompt_continuation=[(INPUT_PROMPT_STYLE, "  ")],
             key_bindings=kb,
             completer=ThreadedCompleter(create_repl_completer()),
@@ -144,6 +155,34 @@ class PromptToolkitInput(InputProviderABC):
         toolbar_text = left_text + padding + right_text
         return FormattedText([("#2c7eac", toolbar_text)])
 
+    def _render_input_placeholder(self) -> FormattedText:
+        if self._is_light_terminal_background is True:
+            text_style = PLACEHOLDER_TEXT_STYLE_LIGHT_BG
+            symbol_style = PLACEHOLDER_SYMBOL_STYLE_LIGHT_BG
+        elif self._is_light_terminal_background is False:
+            text_style = PLACEHOLDER_TEXT_STYLE_DARK_BG
+            symbol_style = PLACEHOLDER_SYMBOL_STYLE_DARK_BG
+        else:
+            text_style = PLACEHOLDER_TEXT_STYLE_UNKNOWN_BG
+            symbol_style = PLACEHOLDER_SYMBOL_STYLE_UNKNOWN_BG
+
+        return FormattedText(
+            [
+                (text_style, " " * 10),
+                (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"),
+            ]
+        )
+
     async def start(self) -> None:
         pass
 
@@ -154,7 +193,7 @@ class PromptToolkitInput(InputProviderABC):
     async def iter_inputs(self) -> AsyncIterator[UserInputPayload]:
         while True:
             with patch_stdout():
-                line: str = await self._session.prompt_async()
+                line: str = await self._session.prompt_async(placeholder=self._render_input_placeholder())
 
             # Extract images referenced in the input text
             images = extract_images_from_text(line)

klaude_code/ui/renderers/assistant.py

@@ -1,8 +1,13 @@
 from rich.console import RenderableType
+from rich.padding import Padding
 
+from klaude_code import const
 from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.markdown import NoInsetMarkdown
 
+# UI markers
+ASSISTANT_MESSAGE_MARK = "➤"
+
 
 def render_assistant_message(content: str, *, code_theme: str) -> RenderableType | None:
     """Render assistant message for replay history display.
@@ -15,7 +20,7 @@ def render_assistant_message(content: str, *, code_theme: str) -> RenderableType
 
     grid = create_grid()
     grid.add_row(
-        "•",
-        NoInsetMarkdown(stripped, code_theme=code_theme),
+        ASSISTANT_MESSAGE_MARK,
+        Padding(NoInsetMarkdown(stripped, code_theme=code_theme), (0, const.MARKDOWN_RIGHT_MARGIN, 0, 0)),
     )
     return grid

klaude_code/ui/renderers/developer.py

@@ -17,6 +17,7 @@ def need_render_developer_message(e: events.DeveloperMessageEvent) -> bool:
         or e.item.todo_use
         or e.item.at_files
         or e.item.user_image_count
+        or e.item.skill_name
     )
 
 
@@ -93,6 +94,17 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
         )
         parts.append(grid)
 
+    if sn := e.item.skill_name:
+        grid = create_grid()
+        grid.add_row(
+            Text("  +", style=ThemeKey.REMINDER),
+            Text.assemble(
+                ("Activated skill ", ThemeKey.REMINDER),
+                (sn, ThemeKey.REMINDER_BOLD),
+            ),
+        )
+        parts.append(grid)
+
     return Group(*parts) if parts else Text("")
 
 

klaude_code/ui/renderers/diffs.py

@@ -208,7 +208,7 @@ def render_diff_panel(
     diff_text: str,
     *,
     show_file_name: bool = True,
-    heading: str = "Git Diff",
+    heading: str = "DIFF",
     indent: int = 2,
 ) -> RenderableType:
     lines = diff_text.splitlines()

klaude_code/ui/renderers/metadata.py

@@ -45,7 +45,7 @@ def _render_task_metadata_block(
     currency_symbol = "¥" if currency == "CNY" else "$"
 
     # First column: mark only
-    mark = Text("└", style=ThemeKey.METADATA_DIM) if is_sub_agent else Text("•", style=ThemeKey.METADATA_BOLD)
+    mark = Text("└", style=ThemeKey.METADATA_DIM) if is_sub_agent else Text("⇅", style=ThemeKey.METADATA)
 
     # Second column: model@provider / tokens / cost / ...
     content = Text()
@@ -151,7 +151,9 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
     """Render task metadata including main agent and sub-agents, aggregated by model+provider."""
     renderables: list[RenderableType] = []
 
-    renderables.append(_render_task_metadata_block(e.metadata.main, is_sub_agent=False, show_context_and_time=True))
+    renderables.append(
+        _render_task_metadata_block(e.metadata.main_agent, is_sub_agent=False, show_context_and_time=True)
+    )
 
     # Aggregate by (model_name, provider), sorted by total_cost descending
     sorted_items = model.TaskMetadata.aggregate_by_model(e.metadata.sub_agent_task_metadata)

klaude_code/ui/renderers/thinking.py

@@ -9,7 +9,7 @@ from klaude_code.ui.rich.theme import ThemeKey
 
 
 def thinking_prefix() -> Text:
-    return Text.from_markup("[not italic]⸫[/not italic] Thinking …", style=ThemeKey.THINKING)
+    return Text.from_markup("[not italic]⸫[/not italic] Thinking …", style=ThemeKey.THINKING_BOLD)
 
 
 def normalize_thinking_content(content: str) -> str:

klaude_code/ui/renderers/tools.py

@@ -13,6 +13,24 @@ from klaude_code.ui.renderers import diffs as r_diffs
 from klaude_code.ui.renderers.common import create_grid, truncate_display
 from klaude_code.ui.rich.theme import ThemeKey
 
+# Tool markers (Unicode symbols for UI display)
+MARK_GENERIC = "⚒"
+MARK_BASH = "→"
+MARK_PLAN = "▪"
+MARK_READ = "←"
+MARK_EDIT = "±"
+MARK_WRITE = "+"
+MARK_MERMAID = "⧉"
+MARK_WEB_FETCH = "←"
+MARK_WEB_SEARCH = ""
+MARK_DONE = "✔"
+MARK_SKILL = "✪"
+
+# Todo status markers
+MARK_TODO_PENDING = "▢"
+MARK_TODO_IN_PROGRESS = "◉"
+MARK_TODO_COMPLETED = "✔"
+
 
 def is_sub_agent_tool(tool_name: str) -> bool:
     return _is_sub_agent_tool(tool_name)
@@ -30,7 +48,7 @@ def render_path(path: str, style: str, is_directory: bool = False) -> Text:
     return Text(path, style=style)
 
 
-def render_generic_tool_call(tool_name: str, arguments: str, markup: str = "•") -> RenderableType:
+def render_generic_tool_call(tool_name: str, arguments: str, markup: str = MARK_GENERIC) -> RenderableType:
     grid = create_grid()
 
     tool_name_column = Text.assemble((markup, ThemeKey.TOOL_MARK), " ", (tool_name, ThemeKey.TOOL_NAME))
@@ -60,7 +78,7 @@ def render_generic_tool_call(tool_name: str, arguments: str, markup: str = "•"
 
 def render_bash_tool_call(arguments: str) -> RenderableType:
     grid = create_grid()
-    tool_name_column = Text.assemble((">", ThemeKey.TOOL_MARK), " ", ("Bash", ThemeKey.TOOL_NAME))
+    tool_name_column = Text.assemble((MARK_BASH, ThemeKey.TOOL_MARK), " ", ("Bash", ThemeKey.TOOL_NAME))
 
     try:
         payload_raw: Any = json.loads(arguments) if arguments else {}
@@ -103,7 +121,7 @@ def render_bash_tool_call(arguments: str) -> RenderableType:
 
 def render_update_plan_tool_call(arguments: str) -> RenderableType:
     grid = create_grid()
-    tool_name_column = Text.assemble(("◎", ThemeKey.TOOL_MARK), " ", ("Update Plan", ThemeKey.TOOL_NAME))
+    tool_name_column = Text.assemble((MARK_PLAN, ThemeKey.TOOL_MARK), " ", ("Update Plan", ThemeKey.TOOL_NAME))
     explanation_column = Text("")
 
     if arguments:
@@ -160,13 +178,13 @@ def render_read_tool_call(arguments: str) -> RenderableType:
                 style=ThemeKey.INVALID_TOOL_CALL_ARGS,
             )
         )
-    grid.add_row(Text("←", ThemeKey.TOOL_MARK), render_result)
+    grid.add_row(Text(MARK_READ, ThemeKey.TOOL_MARK), render_result)
     return grid
 
 
 def render_edit_tool_call(arguments: str) -> RenderableType:
     grid = create_grid()
-    tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("Edit", ThemeKey.TOOL_NAME))
+    tool_name_column = Text.assemble((MARK_EDIT, ThemeKey.TOOL_MARK), " ", ("Edit", ThemeKey.TOOL_NAME))
     try:
         json_dict = json.loads(arguments)
         file_path = json_dict.get("file_path")
@@ -185,10 +203,10 @@ def render_write_tool_call(arguments: str) -> RenderableType:
     try:
         json_dict = json.loads(arguments)
         file_path = json_dict.get("file_path")
-        tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("Write", ThemeKey.TOOL_NAME))
+        tool_name_column = Text.assemble((MARK_WRITE, ThemeKey.TOOL_MARK), " ", ("Write", ThemeKey.TOOL_NAME))
         arguments_column = render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
     except json.JSONDecodeError:
-        tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("Write", ThemeKey.TOOL_NAME))
+        tool_name_column = Text.assemble((MARK_WRITE, ThemeKey.TOOL_MARK), " ", ("Write", ThemeKey.TOOL_NAME))
         arguments_column = Text(
             arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
             style=ThemeKey.INVALID_TOOL_CALL_ARGS,
@@ -199,7 +217,7 @@ def render_write_tool_call(arguments: str) -> RenderableType:
 
 def render_apply_patch_tool_call(arguments: str) -> RenderableType:
     grid = create_grid()
-    tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("Apply Patch", ThemeKey.TOOL_NAME))
+    tool_name_column = Text.assemble((MARK_EDIT, ThemeKey.TOOL_MARK), " ", ("Apply Patch", ThemeKey.TOOL_NAME))
 
     try:
         payload = json.loads(arguments)
@@ -215,9 +233,27 @@ def render_apply_patch_tool_call(arguments: str) -> RenderableType:
     arguments_column = Text("", ThemeKey.TOOL_PARAM)
 
     if isinstance(patch_content, str):
-        lines = [line for line in patch_content.splitlines() if line and not line.startswith("*** Begin Patch")]
-        if lines:
-            arguments_column = Text(lines[0][: const.INVALID_TOOL_CALL_MAX_LENGTH], ThemeKey.TOOL_PARAM)
+        update_count = 0
+        add_count = 0
+        delete_count = 0
+        for line in patch_content.splitlines():
+            if line.startswith("*** Update File:"):
+                update_count += 1
+            elif line.startswith("*** Add File:"):
+                add_count += 1
+            elif line.startswith("*** Delete File:"):
+                delete_count += 1
+
+        parts: list[str] = []
+        if update_count > 0:
+            parts.append(f"Update File × {update_count}" if update_count > 1 else "Update File")
+        if add_count > 0:
+            parts.append(f"Add File × {add_count}" if add_count > 1 else "Add File")
+        if delete_count > 0:
+            parts.append(f"Delete File × {delete_count}" if delete_count > 1 else "Delete File")
+
+        if parts:
+            arguments_column = Text(", ".join(parts), ThemeKey.TOOL_PARAM)
     else:
         arguments_column = Text(
             str(patch_content)[: const.INVALID_TOOL_CALL_MAX_LENGTH],
@@ -229,34 +265,24 @@ def render_apply_patch_tool_call(arguments: str) -> RenderableType:
 
 
 def render_todo(tr: events.ToolResultEvent) -> RenderableType:
-    if not isinstance(tr.ui_extra, model.TodoListUIExtra):
-        return Text.assemble(
-            ("  ✘", ThemeKey.ERROR_BOLD),
-            " ",
-            Text("(no content)" if tr.ui_extra is None else "(invalid ui_extra)", style=ThemeKey.ERROR),
-        )
-
+    assert isinstance(tr.ui_extra, model.TodoListUIExtra)
     ui_extra = tr.ui_extra.todo_list
     todo_grid = create_grid()
     for todo in ui_extra.todos:
         is_new_completed = todo.content in ui_extra.new_completed
         match todo.status:
             case "pending":
-                mark = "▢"
+                mark = MARK_TODO_PENDING
                 mark_style = ThemeKey.TODO_PENDING_MARK
                 text_style = ThemeKey.TODO_PENDING
             case "in_progress":
-                mark = "◉"
+                mark = MARK_TODO_IN_PROGRESS
                 mark_style = ThemeKey.TODO_IN_PROGRESS_MARK
                 text_style = ThemeKey.TODO_IN_PROGRESS
             case "completed":
-                mark = "✔"
+                mark = MARK_TODO_COMPLETED
                 mark_style = ThemeKey.TODO_NEW_COMPLETED_MARK if is_new_completed else ThemeKey.TODO_COMPLETED_MARK
                 text_style = ThemeKey.TODO_NEW_COMPLETED if is_new_completed else ThemeKey.TODO_COMPLETED
-            case _:
-                mark = "?"
-                mark_style = ThemeKey.TODO_PENDING_MARK
-                text_style = ThemeKey.TODO_PENDING
         text = Text(todo.content)
         text.stylize(text_style)
         todo_grid.add_row(Text(mark, style=mark_style), text)
@@ -280,7 +306,7 @@ def _extract_mermaid_link(
 
 def render_mermaid_tool_call(arguments: str) -> RenderableType:
     grid = create_grid()
-    tool_name_column = Text.assemble(("⧉", ThemeKey.TOOL_MARK), " ", ("Mermaid", ThemeKey.TOOL_NAME))
+    tool_name_column = Text.assemble((MARK_MERMAID, ThemeKey.TOOL_MARK), " ", ("Mermaid", ThemeKey.TOOL_NAME))
     summary = Text("", ThemeKey.TOOL_PARAM)
 
     try:
@@ -320,7 +346,7 @@ def _truncate_url(url: str, max_length: int = 400) -> str:
 
 def render_web_fetch_tool_call(arguments: str) -> RenderableType:
     grid = create_grid()
-    tool_name_column = Text.assemble(("↓", ThemeKey.TOOL_MARK), " ", ("Fetch", ThemeKey.TOOL_NAME))
+    tool_name_column = Text.assemble((MARK_WEB_FETCH, ThemeKey.TOOL_MARK), " ", ("Fetch", ThemeKey.TOOL_NAME))
 
     try:
         payload: dict[str, str] = json.loads(arguments)
@@ -341,7 +367,7 @@ def render_web_fetch_tool_call(arguments: str) -> RenderableType:
 
 def render_web_search_tool_call(arguments: str) -> RenderableType:
     grid = create_grid()
-    tool_name_column = Text.assemble(("◉", ThemeKey.TOOL_MARK), " ", ("Search", ThemeKey.TOOL_NAME))
+    tool_name_column = Text.assemble((MARK_WEB_SEARCH, ThemeKey.TOOL_MARK), " ", ("Web Search", ThemeKey.TOOL_NAME))
 
     try:
         payload: dict[str, Any] = json.loads(arguments)
@@ -418,7 +444,7 @@ def get_truncation_info(tr: events.ToolResultEvent) -> model.TruncationUIExtra |
 
 def render_report_back_tool_call() -> RenderableType:
     grid = create_grid()
-    tool_name_column = Text.assemble(("✔", ThemeKey.TOOL_MARK), " ", ("Report Back", ThemeKey.TOOL_NAME))
+    tool_name_column = Text.assemble((MARK_DONE, ThemeKey.TOOL_MARK), " ", ("Report Back", ThemeKey.TOOL_NAME))
     grid.add_row(tool_name_column, "")
     return grid
 
@@ -474,19 +500,18 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
             return render_edit_tool_call(e.arguments)
         case tools.WRITE:
             return render_write_tool_call(e.arguments)
-
         case tools.BASH:
             return render_bash_tool_call(e.arguments)
         case tools.APPLY_PATCH:
             return render_apply_patch_tool_call(e.arguments)
         case tools.TODO_WRITE:
-            return render_generic_tool_call("Update Todos", "", "◎")
+            return render_generic_tool_call("Update Todos", "", MARK_PLAN)
         case tools.UPDATE_PLAN:
             return render_update_plan_tool_call(e.arguments)
         case tools.MERMAID:
             return render_mermaid_tool_call(e.arguments)
         case tools.SKILL:
-            return render_generic_tool_call(e.tool_name, e.arguments, "◈")
+            return render_generic_tool_call(e.tool_name, e.arguments, MARK_SKILL)
         case tools.REPORT_BACK:
             return render_report_back_tool_call()
         case tools.WEB_FETCH:

klaude_code/ui/renderers/user_input.py

@@ -4,6 +4,7 @@ from rich.console import Group, RenderableType
 from rich.text import Text
 
 from klaude_code.command import is_slash_command_name
+from klaude_code.skill import get_available_skills
 from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.theme import ThemeKey
 
@@ -12,6 +13,11 @@ from klaude_code.ui.rich.theme import ThemeKey
 # patterns such as foo@bar.com as file references.
 AT_FILE_RENDER_PATTERN = re.compile(r'(?<!\S)@("([^"]+)"|\S+)')
 
+# Match $skill or ¥skill pattern at the beginning of the first line
+SKILL_RENDER_PATTERN = re.compile(r"^[$¥](\S+)")
+
+USER_MESSAGE_MARK = "❯ "
+
 
 def render_at_pattern(
     text: str,
@@ -38,15 +44,24 @@ def render_at_pattern(
     return result
 
 
+def _is_valid_skill_name(name: str) -> bool:
+    """Check if a skill name is valid (exists in loaded skills)."""
+    short = name.split(":")[-1] if ":" in name else name
+    available_skills = get_available_skills()
+    return any(skill_name in (name, short) for skill_name, _, _ in available_skills)
+
+
 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 $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)
 
@@ -54,6 +69,7 @@ def render_user_input(content: str) -> RenderableType:
             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),
                     " ",
@@ -62,13 +78,27 @@ def render_user_input(content: str) -> RenderableType:
                 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(
+                    (skill_token, ThemeKey.USER_INPUT_SKILL),
+                    render_at_pattern(rest) if rest else Text(""),
+                )
+                renderables.append(line_text)
+                continue
+
         renderables.append(line_text)
     grid = create_grid()
     grid.padding = (0, 0)
     mark = (
-        Text("❯ ", style=ThemeKey.USER_INPUT_PROMPT)
+        Text(USER_MESSAGE_MARK, style=ThemeKey.USER_INPUT_PROMPT)
         if not has_command
-        else Text("  ", style=ThemeKey.USER_INPUT_SLASH_COMMAND)
+        else Text("  ", style=command_style or ThemeKey.USER_INPUT_SLASH_COMMAND)
     )
     grid.add_row(mark, Group(*renderables))
     return grid