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

klaude_code/ui/renderers/tools.py

@@ -2,8 +2,10 @@ import json
 from pathlib import Path
 from typing import Any, cast
 
+from rich import box
 from rich.console import Group, RenderableType
 from rich.padding import Padding
+from rich.panel import Panel
 from rich.text import Text
 
 from klaude_code import const
@@ -11,8 +13,27 @@ from klaude_code.protocol import events, model, tools
 from klaude_code.protocol.sub_agent import is_sub_agent_tool as _is_sub_agent_tool
 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.markdown import NoInsetMarkdown
 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 +51,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 +81,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 +124,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 +181,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 +206,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 +220,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 +236,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 +268,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 +309,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 +349,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 +370,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 +447,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 +503,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:
@@ -503,7 +531,23 @@ def _extract_diff(ui_extra: model.ToolResultUIExtra | None) -> model.DiffUIExtra
     return None
 
 
-def render_tool_result(e: events.ToolResultEvent) -> RenderableType | None:
+def _extract_markdown_doc(ui_extra: model.ToolResultUIExtra | None) -> model.MarkdownDocUIExtra | None:
+    if isinstance(ui_extra, model.MarkdownDocUIExtra):
+        return ui_extra
+    return None
+
+
+def render_markdown_doc(md_ui: model.MarkdownDocUIExtra, *, code_theme: str) -> RenderableType:
+    """Render markdown document content in a panel."""
+    return Panel.fit(
+        NoInsetMarkdown(md_ui.content, code_theme=code_theme),
+        box=box.SIMPLE,
+        border_style=ThemeKey.LINES,
+        style=ThemeKey.WRITE_MARKDOWN_PANEL,
+    )
+
+
+def render_tool_result(e: events.ToolResultEvent, *, code_theme: str = "monokai") -> RenderableType | None:
     """Unified entry point for rendering tool results.
 
     Returns a Rich Renderable or None if the tool result should not be rendered.
@@ -524,11 +568,16 @@ def render_tool_result(e: events.ToolResultEvent) -> RenderableType | None:
         return Group(render_truncation_info(truncation_info), render_generic_tool_result(e.result))
 
     diff_ui = _extract_diff(e.ui_extra)
+    md_ui = _extract_markdown_doc(e.ui_extra)
 
     match e.tool_name:
         case tools.READ:
             return None
-        case tools.EDIT | tools.WRITE:
+        case tools.EDIT:
+            return Padding.indent(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""), level=2)
+        case tools.WRITE:
+            if md_ui:
+                return Padding.indent(render_markdown_doc(md_ui, code_theme=code_theme), level=2)
             return Padding.indent(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""), level=2)
         case tools.APPLY_PATCH:
             if diff_ui:

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,10 +9,10 @@ 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, HorizontalRule, Markdown
+from rich.markdown import CodeBlock, Heading, Markdown, MarkdownElement
 from rich.rule import Rule
 from rich.spinner import Spinner
-from rich.style import Style
+from rich.style import Style, StyleType
 from rich.syntax import Syntax
 from rich.text import Text
 from rich.theme import Theme
@@ -45,12 +45,12 @@ class ThinkingCodeBlock(CodeBlock):
         yield CodePanel(text, border_style="markdown.code.border")
 
 
-class SpacedHorizontalRule(HorizontalRule):
+class Divider(MarkdownElement):
     """A horizontal rule with an extra blank line below."""
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
-        yield from super().__rich_console__(console, options)
-        yield Text()
+        style = console.get_style("markdown.hr", default="none")
+        yield Rule(style=style, characters="-")
 
 
 class LeftHeading(Heading):
@@ -64,7 +64,7 @@ class LeftHeading(Heading):
             yield h1_text
         elif self.tag == "h2":
             text.stylize(Style(bold=True, underline=False))
-            yield Rule(title=text, characters="-", style="markdown.h2.border", align="left")
+            yield Rule(title=text, characters="·", style="markdown.h2.border", align="left")
         else:
             yield text
 
@@ -77,7 +77,7 @@ class NoInsetMarkdown(Markdown):
         "fence": NoInsetCodeBlock,
         "code_block": NoInsetCodeBlock,
         "heading_open": LeftHeading,
-        "hr": SpacedHorizontalRule,
+        "hr": Divider,
     }
 
 
@@ -89,7 +89,7 @@ class ThinkingMarkdown(Markdown):
         "fence": ThinkingCodeBlock,
         "code_block": ThinkingCodeBlock,
         "heading_open": LeftHeading,
-        "hr": SpacedHorizontalRule,
+        "hr": Divider,
     }
 
 
@@ -108,7 +108,9 @@ class MarkdownStream:
         console: Console | None = None,
         spinner: Spinner | None = None,
         mark: str | None = None,
-        indent: int = 0,
+        mark_style: StyleType | None = None,
+        left_margin: int = 0,
+        right_margin: int = const.MARKDOWN_RIGHT_MARGIN,
         markdown_class: Callable[..., Markdown] | None = None,
     ) -> None:
         """Initialize the markdown stream.
@@ -117,8 +119,10 @@ 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
+            mark_style (StyleType | None, optional): Style to apply to the mark
+            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
@@ -140,7 +144,11 @@ class MarkdownStream:
         self.console = console
         self.spinner: Spinner | None = spinner
         self.mark: str | None = mark
-        self.indent: int = max(indent, 0)
+        self.mark_style: StyleType | None = mark_style
+
+        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
@@ -160,15 +168,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(
@@ -182,19 +190,31 @@ 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
+
+        # Pre-render styled mark if needed
+        styled_mark: str | None = None
+        if use_mark and self.mark:
+            if self.mark_style:
+                mark_text = Text(self.mark, style=self.mark_style)
+                mark_buffer = io.StringIO()
+                mark_console = Console(file=mark_buffer, force_terminal=True, theme=self.theme)
+                mark_console.print(mark_text, end="")
+                styled_mark = mark_buffer.getvalue()
+            else:
+                styled_mark = self.mark
 
         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}"
+                stripped = f"{styled_mark} {stripped}"
                 mark_applied = True
             elif indent_prefix:
                 stripped = indent_prefix + stripped

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))
@@ -181,9 +169,19 @@ class ShimmerStatusText:
     Supports optional right-aligned text that stays fixed at the right edge.
     """
 
-    def __init__(self, main_text: str | Text, main_style: ThemeKey, right_text: Text | None = None) -> None:
-        self._main_text = main_text if isinstance(main_text, Text) else Text(main_text)
-        self._main_style = main_style
+    def __init__(
+        self,
+        main_text: str | Text,
+        right_text: Text | None = None,
+        main_style: ThemeKey = ThemeKey.STATUS_TEXT,
+    ) -> None:
+        if isinstance(main_text, Text):
+            text = main_text.copy()
+            if not text.style:
+                text.style = str(main_style)
+            self._main_text = text
+        else:
+            self._main_text = Text(main_text, style=main_style)
         self._hint_text = Text(const.STATUS_HINT_TEXT)
         self._hint_style = ThemeKey.STATUS_HINT
         self._right_text = right_text
@@ -205,13 +203,11 @@ class ShimmerStatusText:
     def _render_left_text(self, console: Console) -> Text:
         """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))
 
         # 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
+            base_style = self._main_text.get_style_at_offset(console, index)
             style = _shimmer_style(console, base_style, intensity)
             result.append(ch, style=style)