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

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,32 +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))
-        arguments_column = Text(
-            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
-            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
-        )
-    grid.add_row(tool_name_column, arguments_column)
-    return grid
-
-
-def render_multi_edit_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
-    tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("MultiEdit", ThemeKey.TOOL_NAME))
-    try:
-        json_dict = json.loads(arguments)
-        file_path = json_dict.get("file_path")
-        edits = json_dict.get("edits", [])
-        arguments_column = Text.assemble(
-            render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH),
-            Text(" - "),
-            Text(f"{len(edits)}", ThemeKey.TOOL_PARAM_BOLD),
-            Text(" updates", ThemeKey.TOOL_PARAM_FILE_PATH),
-        )
-    except json.JSONDecodeError:
+        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,
@@ -221,7 +217,7 @@ def render_multi_edit_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)
@@ -237,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],
@@ -251,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)
@@ -300,63 +304,9 @@ def _extract_mermaid_link(
     return None
 
 
-def render_memory_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
-    command_display_names: dict[str, str] = {
-        "view": "View",
-        "create": "Create",
-        "str_replace": "Replace",
-        "insert": "Insert",
-        "delete": "Delete",
-        "rename": "Rename",
-    }
-
-    try:
-        payload: dict[str, str] = json.loads(arguments)
-    except json.JSONDecodeError:
-        tool_name_column = Text.assemble(("★", ThemeKey.TOOL_MARK), " ", ("Memory", ThemeKey.TOOL_NAME))
-        summary = Text(
-            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
-            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
-        )
-        grid.add_row(tool_name_column, summary)
-        return grid
-
-    command = payload.get("command", "")
-    display_name = command_display_names.get(command, command.title())
-    tool_name_column = Text.assemble(("★", ThemeKey.TOOL_MARK), " ", (f"{display_name} Memory", ThemeKey.TOOL_NAME))
-
-    summary = Text("", ThemeKey.TOOL_PARAM)
-    path = payload.get("path")
-    old_path = payload.get("old_path")
-    new_path = payload.get("new_path")
-
-    if command == "rename" and old_path and new_path:
-        summary = Text.assemble(
-            Text(old_path, ThemeKey.TOOL_PARAM_FILE_PATH),
-            Text(" -> ", ThemeKey.TOOL_PARAM),
-            Text(new_path, ThemeKey.TOOL_PARAM_FILE_PATH),
-        )
-    elif command == "insert" and path:
-        insert_line = payload.get("insert_line")
-        summary = Text(path, ThemeKey.TOOL_PARAM_FILE_PATH)
-        if insert_line is not None:
-            summary.append(f" line {insert_line}", ThemeKey.TOOL_PARAM)
-    elif command == "view" and path:
-        view_range = payload.get("view_range")
-        summary = Text(path, ThemeKey.TOOL_PARAM_FILE_PATH)
-        if view_range and isinstance(view_range, list) and len(view_range) >= 2:
-            summary.append(f" {view_range[0]}:{view_range[1]}", ThemeKey.TOOL_PARAM)
-    elif path:
-        summary = Text(path, ThemeKey.TOOL_PARAM_FILE_PATH)
-
-    grid.add_row(tool_name_column, summary)
-    return grid
-
-
 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:
@@ -396,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)
@@ -417,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)
@@ -494,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
 
@@ -504,14 +454,12 @@ _TOOL_ACTIVE_FORM: dict[str, str] = {
     tools.BASH: "Bashing",
     tools.APPLY_PATCH: "Patching",
     tools.EDIT: "Editing",
-    tools.MULTI_EDIT: "Editing",
     tools.READ: "Reading",
     tools.WRITE: "Writing",
     tools.TODO_WRITE: "Planning",
     tools.UPDATE_PLAN: "Planning",
     tools.SKILL: "Skilling",
     tools.MERMAID: "Diagramming",
-    tools.MEMORY: "Memorizing",
     tools.WEB_FETCH: "Fetching Web",
     tools.WEB_SEARCH: "Searching Web",
     tools.REPORT_BACK: "Reporting",
@@ -552,22 +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.MULTI_EDIT:
-            return render_multi_edit_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.MEMORY:
-            return render_memory_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:
@@ -578,9 +522,9 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
             return render_generic_tool_call(e.tool_name, e.arguments)
 
 
-def _extract_diff_text(ui_extra: model.ToolResultUIExtra | None) -> str | None:
-    if isinstance(ui_extra, model.DiffTextUIExtra):
-        return ui_extra.diff_text
+def _extract_diff(ui_extra: model.ToolResultUIExtra | None) -> model.DiffUIExtra | None:
+    if isinstance(ui_extra, model.DiffUIExtra):
+        return ui_extra
     return None
 
 
@@ -604,28 +548,30 @@ def render_tool_result(e: events.ToolResultEvent) -> RenderableType | None:
     if truncation_info:
         return Group(render_truncation_info(truncation_info), render_generic_tool_result(e.result))
 
-    diff_text = _extract_diff_text(e.ui_extra)
+    diff_ui = _extract_diff(e.ui_extra)
 
     match e.tool_name:
         case tools.READ:
             return None
-        case tools.EDIT | tools.MULTI_EDIT | tools.WRITE:
-            return Padding.indent(r_diffs.render_diff(diff_text or ""), level=2)
-        case tools.MEMORY:
-            if diff_text:
-                return Padding.indent(r_diffs.render_diff(diff_text), level=2)
-            elif len(e.result.strip()) > 0:
-                return render_generic_tool_result(e.result)
-            return None
+        case tools.EDIT | tools.WRITE:
+            return Padding.indent(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""), level=2)
+        case tools.APPLY_PATCH:
+            if diff_ui:
+                return Padding.indent(r_diffs.render_structured_diff(diff_ui, show_file_name=True), level=2)
+            if len(e.result.strip()) == 0:
+                return render_generic_tool_result("(no content)")
+            return render_generic_tool_result(e.result)
         case tools.TODO_WRITE | tools.UPDATE_PLAN:
             return render_todo(e)
         case tools.MERMAID:
             return render_mermaid_tool_result(e)
-        case _:
-            if e.tool_name in (tools.BASH, tools.APPLY_PATCH) and e.result.startswith("diff --git"):
+        case tools.BASH:
+            if e.result.startswith("diff --git"):
                 return r_diffs.render_diff_panel(e.result, show_file_name=True)
-            if e.tool_name == tools.APPLY_PATCH and diff_text:
-                return Padding.indent(r_diffs.render_diff(diff_text, show_file_name=True), level=2)
+            if len(e.result.strip()) == 0:
+                return render_generic_tool_result("(no content)")
+            return render_generic_tool_result(e.result)
+        case _:
             if len(e.result.strip()) == 0:
                 return render_generic_tool_result("(no content)")
             return render_generic_tool_result(e.result)

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

klaude_code/ui/rich/markdown.py

@@ -9,7 +9,7 @@ from typing import Any, ClassVar
 
 from rich.console import Console, ConsoleOptions, Group, RenderableType, RenderResult
 from rich.live import Live
-from rich.markdown import CodeBlock, Heading, Markdown
+from rich.markdown import CodeBlock, Heading, Markdown, MarkdownElement
 from rich.rule import Rule
 from rich.spinner import Spinner
 from rich.style import Style
@@ -45,6 +45,14 @@ class ThinkingCodeBlock(CodeBlock):
         yield CodePanel(text, border_style="markdown.code.border")
 
 
+class Divider(MarkdownElement):
+    """A horizontal rule with an extra blank line below."""
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        style = console.get_style("markdown.hr", default="none")
+        yield Rule(style=style, characters="-")
+
+
 class LeftHeading(Heading):
     """A heading class that renders left-justified."""
 
@@ -69,6 +77,7 @@ class NoInsetMarkdown(Markdown):
         "fence": NoInsetCodeBlock,
         "code_block": NoInsetCodeBlock,
         "heading_open": LeftHeading,
+        "hr": Divider,
     }
 
 
@@ -80,6 +89,7 @@ class ThinkingMarkdown(Markdown):
         "fence": ThinkingCodeBlock,
         "code_block": ThinkingCodeBlock,
         "heading_open": LeftHeading,
+        "hr": Divider,
     }
 
 
@@ -98,7 +108,8 @@ class MarkdownStream:
         console: Console | None = None,
         spinner: Spinner | None = None,
         mark: str | None = None,
-        indent: int = 0,
+        left_margin: int = 0,
+        right_margin: int = const.MARKDOWN_RIGHT_MARGIN,
         markdown_class: Callable[..., Markdown] | None = None,
     ) -> None:
         """Initialize the markdown stream.
@@ -107,8 +118,9 @@ class MarkdownStream:
             mdargs (dict, optional): Additional arguments to pass to rich Markdown renderer
             theme (Theme, optional): Theme for rendering markdown
             console (Console, optional): External console to use for rendering
-            mark (str | None, optional): Marker shown before the first non-empty line when indent >= 2
-            indent (int, optional): Number of spaces to indent all rendered lines on the left
+            mark (str | None, optional): Marker shown before the first non-empty line when left_margin >= 2
+            left_margin (int, optional): Number of columns to reserve on the left side
+            right_margin (int, optional): Number of columns to reserve on the right side
             markdown_class: Markdown class to use for rendering (defaults to NoInsetMarkdown)
         """
         self.printed: list[str] = []  # Stores lines that have already been printed
@@ -130,7 +142,10 @@ class MarkdownStream:
         self.console = console
         self.spinner: Spinner | None = spinner
         self.mark: str | None = mark
-        self.indent: int = max(indent, 0)
+
+        self.left_margin: int = max(left_margin, 0)
+
+        self.right_margin: int = max(right_margin, 0)
         self.markdown_class: Callable[..., Markdown] = markdown_class or NoInsetMarkdown
 
     @property
@@ -150,15 +165,15 @@ class MarkdownStream:
         # Render the markdown to a string buffer
         string_io = io.StringIO()
 
-        # Determine console width and adjust for left indent so that
-        # the rendered content plus indent does not exceed the available width.
+        # Determine console width and adjust for left margin so that
+        # the rendered content plus margins does not exceed the available width.
         if self.console is not None:
             base_width = self.console.options.max_width
         else:
             probe_console = Console(theme=self.theme)
             base_width = probe_console.options.max_width
 
-        effective_width = max(base_width - self.indent, 1)
+        effective_width = max(base_width - self.left_margin - self.right_margin, 1)
 
         # Use external console for consistent theming, or create temporary one
         temp_console = Console(
@@ -172,17 +187,17 @@ class MarkdownStream:
         temp_console.print(markdown)
         output = string_io.getvalue()
 
-        # Split rendered output into lines, strip trailing spaces, and apply left indent.
+        # Split rendered output into lines, strip trailing spaces, and apply left margin.
         lines = output.splitlines(keepends=True)
-        indent_prefix = " " * self.indent if self.indent > 0 else ""
+        indent_prefix = " " * self.left_margin if self.left_margin > 0 else ""
         processed_lines: list[str] = []
         mark_applied = False
-        use_mark = bool(self.mark) and self.indent >= 2
+        use_mark = bool(self.mark) and self.left_margin >= 2
 
         for line in lines:
             stripped = line.rstrip()
 
-            # Apply mark to the first non-empty line only when indent is at least 2.
+            # Apply mark to the first non-empty line only when left_margin is at least 2.
             if use_mark and not mark_applied and stripped:
                 stripped = f"{self.mark} {stripped}"
                 mark_applied = True

klaude_code/ui/rich/status.py

@@ -22,18 +22,7 @@ BREATHING_SPINNER_NAME = "dots"
 
 # Alternating glyphs for the breathing spinner - switches at each "transparent" point
 _BREATHING_SPINNER_GLYPHS_BASE = [
-    "✦",
-    "✶",
-    "✲",
-    "◆",
-    "❖",
-    "✧",
-    "❋",
-    "✸",
-    "✻",
-    "◇",
-    "✴",
-    "✷",
+    "◉",
 ]
 
 # Shuffle glyphs on module load for variety across sessions
@@ -114,7 +103,6 @@ def _shimmer_style(console: Console, base_style: Style, intensity: float) -> Sty
 
     base_r, base_g, base_b = base_triplet
     bg_r, bg_g, bg_b = bg_triplet
-
     r = int(bg_r * alpha + base_r * (1.0 - alpha))
     g = int(bg_g * alpha + base_g * (1.0 - alpha))
     b = int(bg_b * alpha + base_b * (1.0 - alpha))
@@ -203,24 +191,21 @@ class ShimmerStatusText:
         yield table
 
     def _render_left_text(self, console: Console) -> Text:
-        """Render the left part with shimmer effect."""
+        """Render the left part with shimmer effect on main text only."""
         result = Text()
         main_style = console.get_style(str(self._main_style))
         hint_style = console.get_style(str(self._hint_style))
 
-        combined_text = self._main_text.plain + self._hint_text.plain
-        split_index = len(self._main_text.plain)
-
-        for index, (ch, intensity) in enumerate(_shimmer_profile(combined_text)):
-            if index < split_index:
-                # Get style from main_text, merge with main_style
-                char_style = self._main_text.get_style_at_offset(console, index)
-                base_style = main_style + char_style
-            else:
-                base_style = hint_style
+        # Apply shimmer only to main text
+        for index, (ch, intensity) in enumerate(_shimmer_profile(self._main_text.plain)):
+            char_style = self._main_text.get_style_at_offset(console, index)
+            base_style = main_style + char_style
             style = _shimmer_style(console, base_style, intensity)
             result.append(ch, style=style)
 
+        # Append hint text without shimmer
+        result.append(self._hint_text.plain, style=hint_style)
+
         return result