klaude-code 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

klaude_code/tui/components/developer.py

@@ -0,0 +1,231 @@
+from rich.console import Group, RenderableType
+from rich.padding import Padding
+from rich.table import Table
+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
+
+REMINDER_BULLET = "  ⧉"
+
+
+def get_command_output(item: message.DeveloperMessage) -> model.CommandOutput | None:
+    if not item.ui_extra:
+        return None
+    for ui_item in item.ui_extra.items:
+        if isinstance(ui_item, model.CommandOutputUIItem):
+            return ui_item.output
+    return None
+
+
+def need_render_developer_message(e: events.DeveloperMessageEvent) -> bool:
+    if not e.item.ui_extra:
+        return False
+    return any(not isinstance(ui_item, model.CommandOutputUIItem) for ui_item in e.item.ui_extra.items)
+
+
+def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
+    """Render developer message details into a single group.
+
+    Includes: memory paths, external file changes, todo reminder, @file operations.
+    Command output is excluded; render it separately via `render_command_output`.
+    """
+    parts: list[RenderableType] = []
+
+    if e.item.ui_extra:
+        for ui_item in e.item.ui_extra.items:
+            match ui_item:
+                case model.MemoryLoadedUIItem() as item:
+                    grid = create_grid()
+                    grid.add_row(
+                        Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
+                        Text.assemble(
+                            ("Load memory ", ThemeKey.REMINDER),
+                            Text(", ", ThemeKey.REMINDER).join(
+                                render_path(mem.path, ThemeKey.REMINDER_BOLD) for mem in item.files
+                            ),
+                        ),
+                    )
+                    parts.append(grid)
+                case model.ExternalFileChangesUIItem() as item:
+                    grid = create_grid()
+                    for file_path in item.paths:
+                        grid.add_row(
+                            Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
+                            Text.assemble(
+                                ("Read ", ThemeKey.REMINDER),
+                                render_path(file_path, ThemeKey.REMINDER_BOLD),
+                                (" after external changes", ThemeKey.REMINDER),
+                            ),
+                        )
+                    parts.append(grid)
+                case model.TodoReminderUIItem() as item:
+                    match item.reason:
+                        case "not_used_recently":
+                            text = "Todo hasn't been updated recently"
+                        case "empty":
+                            text = "Todo list is empty"
+                        case _:
+                            text = "Todo reminder"
+                    grid = create_grid()
+                    grid.add_row(
+                        Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
+                        Text(text, ThemeKey.REMINDER),
+                    )
+                    parts.append(grid)
+                case model.AtFileOpsUIItem() as item:
+                    grid = create_grid()
+                    grouped: dict[tuple[str, str | None], list[str]] = {}
+                    for op in item.ops:
+                        key = (op.operation, op.mentioned_in)
+                        grouped.setdefault(key, []).append(op.path)
+
+                    for (operation, mentioned_in), paths in grouped.items():
+                        path_texts = Text(", ", ThemeKey.REMINDER).join(
+                            render_path(p, ThemeKey.REMINDER_BOLD) for p in paths
+                        )
+                        if mentioned_in:
+                            grid.add_row(
+                                Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
+                                Text.assemble(
+                                    (f"{operation} ", ThemeKey.REMINDER),
+                                    path_texts,
+                                    (" mentioned in ", ThemeKey.REMINDER),
+                                    render_path(mentioned_in, ThemeKey.REMINDER_BOLD),
+                                ),
+                            )
+                        else:
+                            grid.add_row(
+                                Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
+                                Text.assemble(
+                                    (f"{operation} ", ThemeKey.REMINDER),
+                                    path_texts,
+                                ),
+                            )
+                    parts.append(grid)
+                case model.UserImagesUIItem() as item:
+                    grid = create_grid()
+                    count = item.count
+                    grid.add_row(
+                        Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
+                        Text(
+                            f"Attached {count} image{'s' if count > 1 else ''}",
+                            style=ThemeKey.REMINDER,
+                        ),
+                    )
+                    parts.append(grid)
+                case model.SkillActivatedUIItem() as item:
+                    grid = create_grid()
+                    grid.add_row(
+                        Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
+                        Text.assemble(
+                            ("Activated skill ", ThemeKey.REMINDER),
+                            (item.name, ThemeKey.REMINDER_BOLD),
+                        ),
+                    )
+                    parts.append(grid)
+                case model.CommandOutputUIItem():
+                    # Rendered via render_command_output
+                    pass
+
+    return Group(*parts) if parts else Text("")
+
+
+def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
+    """Render developer command output content."""
+    command_output = get_command_output(e.item)
+    if not command_output:
+        return Text("")
+
+    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 _:
+            content = content or "(no content)"
+            style = ThemeKey.TOOL_RESULT if not command_output.is_error else ThemeKey.ERROR
+            return Padding.indent(truncate_middle(content, base_style=style), level=2)
+
+
+def _format_tokens(tokens: int) -> str:
+    """Format token count with K/M suffix for readability."""
+    if tokens >= 1_000_000:
+        return f"{tokens / 1_000_000:.2f}M"
+    if tokens >= 1_000:
+        return f"{tokens / 1_000:.1f}K"
+    return str(tokens)
+
+
+def _format_cost(cost: float | None, currency: str = "USD") -> str:
+    """Format cost with currency symbol."""
+    if cost is None:
+        return "-"
+    symbol = "¥" if currency == "CNY" else "$"
+    if cost < 0.01:
+        return f"{symbol}{cost:.4f}"
+    return f"{symbol}{cost:.2f}"
+
+
+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)
+
+    grid = Table.grid(padding=(0, 1))
+    session_id = command_output.ui_extra.session_id
+    grid.add_column(style=ThemeKey.METADATA, 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))
+
+    return Padding.indent(grid, level=2)
+
+
+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)
+
+    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")
+
+    # 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),
+    )
+
+    # Per-model breakdown
+    if status.by_model:
+        table.add_row(Text("Usage by model:", style=ThemeKey.METADATA_BOLD), "")
+        for meta in status.by_model:
+            model_label = meta.model_name
+            if meta.provider:
+                model_label = f"{meta.model_name} ({meta.provider.lower().replace(' ', '-')})"
+
+            if meta.usage:
+                usage_detail = (
+                    f"{_format_tokens(meta.usage.input_tokens)} input, "
+                    f"{_format_tokens(meta.usage.output_tokens)} output, "
+                    f"{_format_tokens(meta.usage.cached_tokens)} cache read, "
+                    f"{_format_tokens(meta.usage.reasoning_tokens)} thinking, "
+                    f"({_format_cost(meta.usage.total_cost, meta.usage.currency)})"
+                )
+            else:
+                usage_detail = "(no usage data)"
+            table.add_row(f"{model_label}:", usage_detail)
+
+    return Padding.indent(table, level=2)

klaude_code/{ui/renderers → tui/components}/diffs.py

@@ -6,8 +6,8 @@ from rich.text import Text
 
 from klaude_code.const import DIFF_PREFIX_WIDTH, MAX_DIFF_LINES
 from klaude_code.protocol import model
-from klaude_code.ui.renderers.common import create_grid
-from klaude_code.ui.rich.theme import ThemeKey
+from klaude_code.tui.components.common import create_grid
+from klaude_code.tui.components.rich.theme import ThemeKey
 
 
 def _make_diff_prefix(line: str, new_ln: int | None, width: int) -> tuple[str, int | None]:

klaude_code/{ui/renderers → tui/components}/errors.py

@@ -1,8 +1,8 @@
 from rich.console import RenderableType
 from rich.text import Text
 
-from klaude_code.ui.renderers.common import create_grid
-from klaude_code.ui.rich.theme import ThemeKey
+from klaude_code.tui.components.common import create_grid
+from klaude_code.tui.components.rich.theme import ThemeKey
 
 
 def render_error(error_msg: Text) -> RenderableType:

klaude_code/{ui/renderers → tui/components}/metadata.py

@@ -1,17 +1,16 @@
 from importlib.metadata import PackageNotFoundError, version
 
-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.const import DEFAULT_MAX_TOKENS
+from klaude_code.log import is_debug_enabled
 from klaude_code.protocol import events, model
-from klaude_code.trace import is_debug_enabled
-from klaude_code.ui.renderers.common import create_grid
-from klaude_code.ui.rich.theme import ThemeKey
-from klaude_code.ui.utils.common import format_model_params, format_number
+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:
@@ -100,7 +99,7 @@ def _render_task_metadata_block(
             )
         )
     if metadata.usage is not None:
-        # Context (only for main agent)
+        # Context usage
         if show_context_and_time and metadata.usage.context_usage_percent is not None:
             context_size = format_number(metadata.usage.context_size or 0)
             # Calculate effective limit (same as Usage.context_usage_percent)
@@ -170,7 +169,7 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
 
     # Render each sub-agent metadata block
     for meta in e.metadata.sub_agent_task_metadata:
-        renderables.append(_render_task_metadata_block(meta, is_sub_agent=True, show_context_and_time=False))
+        renderables.append(_render_task_metadata_block(meta, is_sub_agent=True, show_context_and_time=True))
 
     # Add total cost line when there are sub-agents
     if e.metadata.sub_agent_task_metadata:
@@ -199,17 +198,29 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
 
 
 def render_welcome(e: events.WelcomeEvent) -> RenderableType:
-    """Render the welcome panel with model info and settings."""
+    """Render the welcome panel with model info and settings.
+
+    Args:
+        e: The welcome event.
+    """
     debug_mode = is_debug_enabled()
 
-    # First line: Klaude Code version
-    klaude_code_style = ThemeKey.WELCOME_DEBUG_TITLE if debug_mode else ThemeKey.WELCOME_HIGHLIGHT_BOLD
-    panel_content = Text.assemble(
-        ("Klaude Code", klaude_code_style),
-        (f" v{_get_version()}\n", ThemeKey.WELCOME_INFO),
-        (str(e.llm_config.model), ThemeKey.WELCOME_HIGHLIGHT),
-        (" @ ", ThemeKey.WELCOME_INFO),
-        (e.llm_config.provider_name, ThemeKey.WELCOME_INFO),
+    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
@@ -228,7 +239,9 @@ def render_welcome(e: events.WelcomeEvent) -> RenderableType:
         )
 
     border_style = ThemeKey.WELCOME_DEBUG_BORDER if debug_mode else ThemeKey.LINES
-    return Group(
-        Panel.fit(panel_content, border_style=border_style, box=box.ROUNDED),
-        "",  # empty line
-    )
+
+    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/{ui → tui/components}/rich/markdown.py

@@ -18,8 +18,13 @@ from rich.table import Table
 from rich.text import Text
 from rich.theme import Theme
 
-from klaude_code.const import MARKDOWN_RIGHT_MARGIN, MARKDOWN_STREAM_LIVE_REPAINT_ENABLED, UI_REFRESH_RATE_FPS
-from klaude_code.ui.rich.code_panel import CodePanel
+from klaude_code.const import (
+    MARKDOWN_RIGHT_MARGIN,
+    MARKDOWN_STREAM_LIVE_REPAINT_ENABLED,
+    MARKDOWN_STREAM_SYNCHRONIZED_OUTPUT_ENABLED,
+    UI_REFRESH_RATE_FPS,
+)
+from klaude_code.tui.components.rich.code_panel import CodePanel
 
 
 class NoInsetCodeBlock(CodeBlock):
@@ -56,7 +61,13 @@ class Divider(MarkdownElement):
 
 class MarkdownTable(TableElement):
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
-        table = Table(box=box.MARKDOWN, border_style=console.get_style("markdown.table.border"))
+        # rich.box.MARKDOWN intentionally includes a blank top/bottom edge row. Rather than
+        # post-processing rendered segments, disable outer edges to avoid emitting those rows.
+        table = Table(
+            box=box.MARKDOWN,
+            show_edge=False,
+            border_style=console.get_style("markdown.table.border"),
+        )
 
         if self.header is not None and self.header.row is not None:
             for column in self.header.row.cells:
@@ -67,27 +78,7 @@ class MarkdownTable(TableElement):
                 row_content = [element.content for element in row.cells]
                 table.add_row(*row_content)
 
-        # Render table and strip top/bottom blank lines that MARKDOWN box adds
-        segments = list(console.render(table, options))
-
-        # Skip leading blank line (before first newline)
-        first_newline_idx = next((i for i, s in enumerate(segments) if s.text == "\n"), None)
-        if first_newline_idx is not None:
-            first_line = "".join(s.text for s in segments[:first_newline_idx])
-            if not first_line.strip():
-                segments = segments[first_newline_idx + 1 :]
-
-        # Skip trailing blank line (after last newline)
-        while len(segments) >= 2 and segments[-1].text == "\n":
-            prev_newline = next((i for i in range(len(segments) - 2, -1, -1) if segments[i].text == "\n"), None)
-            if prev_newline is not None:
-                between = "".join(s.text for s in segments[prev_newline + 1 : -1])
-                if not between.strip():
-                    segments = segments[: prev_newline + 1]
-                    continue
-            break
-
-        yield from segments
+        yield table
 
 
 class LeftHeading(Heading):
@@ -201,6 +192,52 @@ class MarkdownStream:
     def _get_base_width(self) -> int:
         return self.console.options.max_width
 
+    def _should_use_synchronized_output(self) -> bool:
+        if not MARKDOWN_STREAM_SYNCHRONIZED_OUTPUT_ENABLED:
+            return False
+        if self._live_sink is None:
+            return False
+        console_file = getattr(self.console, "file", None)
+        if console_file is None:
+            return False
+        isatty = getattr(console_file, "isatty", None)
+        if isatty is None:
+            return False
+        return bool(isatty())
+
+    @contextlib.contextmanager
+    def _synchronized_output(self) -> Any:
+        """Batch terminal updates to reduce flicker.
+
+        Uses xterm's "Synchronized Output" mode (DECSET/DECRST 2026). Terminals that
+        don't support it will typically ignore the escape codes.
+        """
+
+        if not self._should_use_synchronized_output():
+            yield
+            return
+
+        console_file = self.console.file
+        enabled = False
+        try:
+            console_file.write("\x1b[?2026h")
+            flush = getattr(console_file, "flush", None)
+            if flush is not None:
+                flush()
+            enabled = True
+        except Exception:
+            pass
+
+        try:
+            yield
+        finally:
+            if enabled:
+                with contextlib.suppress(Exception):
+                    console_file.write("\x1b[?2026l")
+                    flush = getattr(console_file, "flush", None)
+                    if flush is not None:
+                        flush()
+
     def compute_candidate_stable_line(self, text: str) -> int:
         """Return the start line of the last top-level block, or 0.
 
@@ -427,26 +464,22 @@ class MarkdownStream:
 
         start = time.time()
 
+        stable_chunk_to_print: str | None = None
         stable_changed = final or stable_line > self._stable_source_line_count
         if stable_changed and stable_source:
             stable_ansi = self.render_stable_ansi(stable_source, has_live_suffix=bool(live_source), final=final)
             stable_lines = stable_ansi.splitlines(keepends=True)
             new_lines = stable_lines[len(self._stable_rendered_lines) :]
             if new_lines:
-                stable_chunk = "".join(new_lines)
-                self.console.print(Text.from_ansi(stable_chunk), end="\n")
+                stable_chunk_to_print = "".join(new_lines)
             self._stable_rendered_lines = stable_lines
             self._stable_source_line_count = stable_line
         elif final and not stable_source:
             self._stable_rendered_lines = []
             self._stable_source_line_count = stable_line
 
-        if final:
-            if self._live_sink is not None:
-                self._live_sink(None)
-            return
-
-        if MARKDOWN_STREAM_LIVE_REPAINT_ENABLED and self._live_sink is not None:
+        live_text_to_set: Text | None = None
+        if not final and MARKDOWN_STREAM_LIVE_REPAINT_ENABLED and self._live_sink is not None:
             apply_mark_live = self._stable_source_line_count == 0
             live_lines = self._render_markdown_to_lines(live_source, apply_mark=apply_mark_live)
 
@@ -468,8 +501,19 @@ class MarkdownStream:
                     if drop > 0:
                         live_lines = live_lines[drop:]
 
-            live_text = Text.from_ansi("".join(live_lines))
-            self._live_sink(live_text)
+            live_text_to_set = Text.from_ansi("".join(live_lines))
+
+        with self._synchronized_output():
+            if stable_chunk_to_print:
+                self.console.print(Text.from_ansi(stable_chunk_to_print), end="\n")
+
+            if final:
+                if self._live_sink is not None:
+                    self._live_sink(None)
+                return
+
+            if live_text_to_set is not None and self._live_sink is not None:
+                self._live_sink(live_text_to_set)
 
         elapsed = time.time() - start
         self.min_delay = min(max(elapsed * 6, 1.0 / 30), 0.5)

klaude_code/{ui → tui/components}/rich/status.py

@@ -23,8 +23,8 @@ from klaude_code.const import (
     STATUS_SHIMMER_BAND_HALF_WIDTH,
     STATUS_SHIMMER_PADDING,
 )
-from klaude_code.ui.rich.theme import ThemeKey
-from klaude_code.ui.terminal.color import get_last_terminal_background_rgb
+from klaude_code.tui.components.rich.theme import ThemeKey
+from klaude_code.tui.terminal.color import get_last_terminal_background_rgb
 
 # Use an existing Rich spinner name; BreathingSpinner overrides its rendering
 BREATHING_SPINNER_NAME = "dots"

klaude_code/{ui → tui/components}/rich/theme.py

@@ -53,7 +53,7 @@ LIGHT_PALETTE = Palette(
     grey2="#93a4b1",
     grey3="#c4ced4",
     grey_green="#96a096",
-    purple="#5f5fd7",
+    purple="#5f5fb7",
     lavender="#5f87af",
     diff_add="#2e5a32 on #dafbe1",
     diff_add_char="#2e5a32 on #aceebb",
@@ -93,7 +93,7 @@ DARK_PALETTE = Palette(
     diff_remove="#ffcdd2 on #3d1f23",
     diff_remove_char="#ffcdd2 on #7a3a42",
     code_theme="ansi_dark",
-    code_background="#2f3440",
+    code_background="#1a1f2a",
     green_background="#23342c",
     blue_grey_background="#313848",
     cyan_background="#1a3333",
@@ -110,6 +110,9 @@ DARK_PALETTE = Palette(
 class ThemeKey(str, Enum):
     LINES = "lines"
 
+    # CODE
+    CODE_BACKGROUND = "code_background"
+
     # PANEL
     SUB_AGENT_RESULT_PANEL = "panel.sub_agent_result"
     WRITE_MARKDOWN_PANEL = "panel.write_markdown"
@@ -135,6 +138,7 @@ class ThemeKey(str, Enum):
     STATUS_TEXT = "spinner.status.text"
     STATUS_TEXT_BOLD = "spinner.status.text.bold"
     STATUS_TEXT_BOLD_ITALIC = "spinner.status.text.bold_italic"
+    STATUS_TOAST = "spinner.status.toast"
     # STATUS
     STATUS_HINT = "status.hint"
     # USER_INPUT
@@ -224,6 +228,8 @@ def get_theme(theme: str | None = None) -> Themes:
         app_theme=Theme(
             styles={
                 ThemeKey.LINES.value: palette.grey3,
+                # CODE
+                ThemeKey.CODE_BACKGROUND.value: f"on {palette.code_background}",
                 # PANEL
                 ThemeKey.SUB_AGENT_RESULT_PANEL.value: f"on {palette.blue_grey_background}",
                 ThemeKey.WRITE_MARKDOWN_PANEL.value: f"on {palette.green_background}",
@@ -257,10 +263,11 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.STATUS_TEXT.value: palette.blue,
                 ThemeKey.STATUS_TEXT_BOLD.value: "bold " + palette.blue,
                 ThemeKey.STATUS_TEXT_BOLD_ITALIC.value: "bold italic " + palette.blue,
+                ThemeKey.STATUS_TOAST.value: "bold " + palette.yellow,
                 ThemeKey.STATUS_HINT.value: palette.grey2,
                 # REMINDER
                 ThemeKey.REMINDER.value: palette.grey1,
-                ThemeKey.REMINDER_BOLD.value: "bold " + palette.grey1,
+                ThemeKey.REMINDER_BOLD.value: palette.grey1,
                 # TOOL
                 ThemeKey.INVALID_TOOL_CALL_ARGS.value: palette.yellow,
                 ThemeKey.TOOL_NAME.value: "bold",
@@ -268,9 +275,9 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.TOOL_PARAM.value: palette.green,
                 ThemeKey.TOOL_PARAM_BOLD.value: "bold " + palette.green,
                 ThemeKey.TOOL_RESULT.value: palette.grey_green,
-                ThemeKey.TOOL_RESULT_TREE_PREFIX.value: palette.grey_green + " dim",
+                ThemeKey.TOOL_RESULT_TREE_PREFIX.value: palette.grey3 + " dim",
                 ThemeKey.TOOL_RESULT_BOLD.value: "bold " + palette.grey_green,
-                ThemeKey.TOOL_RESULT_TRUNCATED.value: palette.grey1,
+                ThemeKey.TOOL_RESULT_TRUNCATED.value: palette.grey1 + " dim",
                 ThemeKey.TOOL_MARK.value: "bold",
                 ThemeKey.TOOL_APPROVED.value: palette.green + " bold reverse",
                 ThemeKey.TOOL_REJECTED.value: palette.red + " bold reverse",