klaude-code 2.9.1__py3-none-any.whl → 2.10.1__py3-none-any.whl

klaude_code/tui/components/metadata.py

@@ -34,8 +34,8 @@ def _render_task_metadata_block(
     content = Text()
     if metadata.provider is not None:
         content.append_text(Text(metadata.provider.lower().replace(" ", "-"), style=ThemeKey.METADATA))
-        content.append_text(Text("/", style=ThemeKey.METADATA_DIM))
-    content.append_text(Text(metadata.model_name, style=ThemeKey.METADATA_BOLD))
+        content.append_text(Text("/", style=ThemeKey.METADATA))
+    content.append_text(Text(metadata.model_name, style=ThemeKey.METADATA))
     if metadata.description:
         content.append_text(Text(" ", style=ThemeKey.METADATA)).append_text(
             Text(metadata.description, style=ThemeKey.METADATA_ITALIC)
@@ -47,18 +47,21 @@ def _render_task_metadata_block(
     if metadata.usage is not None:
         # Tokens: ↑37k ◎5k ↓907 ∿45k ⌗ 100
         token_text = Text()
-        token_text.append("↑", style=ThemeKey.METADATA_DIM)
-        token_text.append(format_number(metadata.usage.input_tokens), style=ThemeKey.METADATA)
+        input_tokens = max(metadata.usage.input_tokens - metadata.usage.cached_tokens, 0)
+        output_tokens = max(metadata.usage.output_tokens - metadata.usage.reasoning_tokens, 0)
+
+        token_text.append("↑", style=ThemeKey.METADATA)
+        token_text.append(format_number(input_tokens), style=ThemeKey.METADATA)
         if metadata.usage.cached_tokens > 0:
-            token_text.append(" ◎", style=ThemeKey.METADATA_DIM)
+            token_text.append(" ◎", style=ThemeKey.METADATA)
             token_text.append(format_number(metadata.usage.cached_tokens), style=ThemeKey.METADATA)
-        token_text.append(" ↓", style=ThemeKey.METADATA_DIM)
-        token_text.append(format_number(metadata.usage.output_tokens), style=ThemeKey.METADATA)
+        token_text.append(" ↓", style=ThemeKey.METADATA)
+        token_text.append(format_number(output_tokens), style=ThemeKey.METADATA)
         if metadata.usage.reasoning_tokens > 0:
-            token_text.append(" ∿", style=ThemeKey.METADATA_DIM)
+            token_text.append(" ∿", style=ThemeKey.METADATA)
             token_text.append(format_number(metadata.usage.reasoning_tokens), style=ThemeKey.METADATA)
         if metadata.usage.image_tokens > 0:
-            token_text.append(" ⊡", style=ThemeKey.METADATA_DIM)
+            token_text.append(" ⊡", style=ThemeKey.METADATA)
             token_text.append(format_number(metadata.usage.image_tokens), style=ThemeKey.METADATA)
         parts.append(token_text)
 
@@ -66,7 +69,7 @@ def _render_task_metadata_block(
     if metadata.usage is not None and metadata.usage.total_cost is not None:
         parts.append(
             Text.assemble(
-                (currency_symbol, ThemeKey.METADATA_DIM),
+                (currency_symbol, ThemeKey.METADATA),
                 (f"{metadata.usage.total_cost:.4f}", ThemeKey.METADATA),
             )
         )
@@ -79,9 +82,9 @@ def _render_task_metadata_block(
             parts.append(
                 Text.assemble(
                     (context_size, ThemeKey.METADATA),
-                    ("/", ThemeKey.METADATA_DIM),
+                    ("/", ThemeKey.METADATA),
                     (effective_limit_str, ThemeKey.METADATA),
-                    (f"({metadata.usage.context_usage_percent:.1f}%)", ThemeKey.METADATA_DIM),
+                    (f"({metadata.usage.context_usage_percent:.1f}%)", ThemeKey.METADATA),
                 )
             )
 
@@ -90,7 +93,7 @@ def _render_task_metadata_block(
             parts.append(
                 Text.assemble(
                     (f"{metadata.usage.throughput_tps:.1f}", ThemeKey.METADATA),
-                    ("tps", ThemeKey.METADATA_DIM),
+                    ("tps", ThemeKey.METADATA),
                 )
             )
 
@@ -101,7 +104,7 @@ def _render_task_metadata_block(
             parts.append(
                 Text.assemble(
                     (ftl_str, ThemeKey.METADATA),
-                    ("-ftl", ThemeKey.METADATA_DIM),
+                    ("-ftl", ThemeKey.METADATA),
                 )
             )
 
@@ -110,7 +113,7 @@ def _render_task_metadata_block(
         parts.append(
             Text.assemble(
                 (f"{metadata.task_duration_s:.1f}", ThemeKey.METADATA),
-                ("s", ThemeKey.METADATA_DIM),
+                ("s", ThemeKey.METADATA),
             )
         )
 
@@ -120,13 +123,13 @@ def _render_task_metadata_block(
         parts.append(
             Text.assemble(
                 (str(metadata.turn_count), ThemeKey.METADATA),
-                (suffix, ThemeKey.METADATA_DIM),
+                (suffix, ThemeKey.METADATA),
             )
         )
 
     if parts:
-        content.append_text(Text(" ", style=ThemeKey.METADATA_DIM))
-        content.append_text(Text(" ", style=ThemeKey.METADATA_DIM).join(parts))
+        content.append_text(Text(" ", style=ThemeKey.METADATA))
+        content.append_text(Text(" ", style=ThemeKey.METADATA).join(parts))
 
     grid.add_row(mark, content)
     return grid
@@ -138,14 +141,14 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
 
     has_sub_agents = len(e.metadata.sub_agent_task_metadata) > 0
     # Use an extra space for the main agent mark to align with two-character marks (├─, └─)
-    main_mark_text = "✓"
+    main_mark_text = "●"
     main_mark = Text(main_mark_text, style=ThemeKey.METADATA)
 
     renderables.append(_render_task_metadata_block(e.metadata.main_agent, mark=main_mark, show_context_and_time=True))
 
     # Render each sub-agent metadata block
     for meta in e.metadata.sub_agent_task_metadata:
-        sub_mark = Text("  └", style=ThemeKey.METADATA_DIM)
+        sub_mark = Text("  └", style=ThemeKey.METADATA)
         renderables.append(_render_task_metadata_block(meta, mark=sub_mark, show_context_and_time=True))
 
     # Add total cost line when there are sub-agents
@@ -162,11 +165,11 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
 
         currency_symbol = "¥" if currency == "CNY" else "$"
         total_line = Text.assemble(
-            ("  └", ThemeKey.METADATA_DIM),
-            (" Σ ", ThemeKey.METADATA_DIM),
-            ("total ", ThemeKey.METADATA_DIM),
-            (currency_symbol, ThemeKey.METADATA_DIM),
-            (f"{total_cost:.4f}", ThemeKey.METADATA_DIM),
+            ("  └", ThemeKey.METADATA),
+            (" Σ ", ThemeKey.METADATA),
+            ("total ", ThemeKey.METADATA),
+            (currency_symbol, ThemeKey.METADATA),
+            (f"{total_cost:.4f}", ThemeKey.METADATA),
         )
 
         renderables.append(total_line)

klaude_code/tui/components/rich/code_panel.py

@@ -14,12 +14,12 @@ from rich.style import StyleType
 if TYPE_CHECKING:
     from rich.console import Console, ConsoleOptions, RenderResult
 
-# Box drawing characters
-TOP_LEFT = "┌"  # ┌
-TOP_RIGHT = "┐"  # ┐
-BOTTOM_LEFT = "└"  # └
-BOTTOM_RIGHT = "┘"  # ┘
-HORIZONTAL = "─"  # ─
+# Box drawing characters (rounded corners)
+TOP_LEFT = "╭"
+TOP_RIGHT = "╮"
+BOTTOM_LEFT = "╰"
+BOTTOM_RIGHT = "╯"
+HORIZONTAL = "─"
 
 
 class CodePanel(JupyterMixin):
@@ -32,10 +32,10 @@ class CodePanel(JupyterMixin):
         >>> console.print(CodePanel(Syntax(code, "python")))
 
     Renders as:
-        ┌──────────────────────────┐
+        ╭──────────────────────────╮
         code line 1
         code line 2
-        └──────────────────────────┘
+        ╰──────────────────────────╯
     """
 
     def __init__(
@@ -44,7 +44,9 @@ class CodePanel(JupyterMixin):
         *,
         border_style: StyleType = "none",
         expand: bool = False,
-        padding: int = 1,
+        padding: int = 0,
+        title: str | None = None,
+        title_style: StyleType = "none",
     ) -> None:
         """Initialize the CodePanel.
 
@@ -52,12 +54,16 @@ class CodePanel(JupyterMixin):
             renderable: A console renderable object.
             border_style: The style of the border. Defaults to "none".
             expand: If True, expand to fill available width. Defaults to False.
-            padding: Left/right padding for content. Defaults to 1.
+            padding: Left/right padding for content. Defaults to 0.
+            title: Optional title to display in the top border. Defaults to None.
+            title_style: The style of the title. Defaults to "none".
         """
         self.renderable = renderable
         self.border_style = border_style
         self.expand = expand
         self.padding = padding
+        self.title = title
+        self.title_style = title_style
 
     @staticmethod
     def _measure_max_line_cells(lines: list[list[Segment]]) -> int:
@@ -93,11 +99,20 @@ class CodePanel(JupyterMixin):
         new_line = Segment.line()
         pad_segment = Segment(" " * pad) if pad > 0 else None
 
-        # Top border: ┌───...───┐
-        top_border = (
-            TOP_LEFT + (HORIZONTAL * (border_width - 2)) + TOP_RIGHT if border_width >= 2 else HORIZONTAL * border_width
-        )
-        yield Segment(top_border, border_style)
+        # Top border: ╭───...───╮ or ╭ title ───...───╮
+        if self.title and border_width >= len(self.title) + 4:
+            title_part = f" {self.title} "
+            title_style = console.get_style(self.title_style)
+            remaining = border_width - 2 - len(title_part)
+            yield Segment(TOP_LEFT, border_style)
+            yield Segment(title_part, title_style)
+            yield Segment((HORIZONTAL * remaining) + TOP_RIGHT, border_style)
+        elif border_width >= 2:
+            top_border = TOP_LEFT + (HORIZONTAL * (border_width - 2)) + TOP_RIGHT
+            yield Segment(top_border, border_style)
+        else:
+            top_border = HORIZONTAL * border_width
+            yield Segment(top_border, border_style)
         yield new_line
 
         # Content lines with padding
@@ -109,7 +124,7 @@ class CodePanel(JupyterMixin):
                 yield pad_segment
             yield new_line
 
-        # Bottom border: └───...───┘
+        # Bottom border: ╰───...───╯
         bottom_border = (
             BOTTOM_LEFT + (HORIZONTAL * (border_width - 2)) + BOTTOM_RIGHT
             if border_width >= 2

klaude_code/tui/components/rich/markdown.py

@@ -22,12 +22,10 @@ from rich.text import Text
 from rich.theme import Theme
 
 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
 
 _THINKING_HTML_BLOCK_RE = re.compile(
     r"\A\s*<thinking>\s*\n?(?P<body>.*?)(?:\n\s*)?</thinking>\s*\Z",
@@ -91,10 +89,15 @@ class ThinkingHTMLBlock(MarkdownElement):
 
 
 class NoInsetCodeBlock(CodeBlock):
-    """A code block with syntax highlighting and no padding."""
+    """A code block with syntax highlighting using markdown fence style."""
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         code = str(self.text).rstrip()
+        lang = self.lexer_name if self.lexer_name != "text" else ""
+        fence_style = console.get_style("markdown.code.fence", default="none")
+        fence_title_style = console.get_style("markdown.code.fence.title", default="none")
+
+        yield Text.assemble(("```", fence_style), (lang, fence_title_style))
         syntax = Syntax(
             code,
             self.lexer_name,
@@ -102,16 +105,21 @@ class NoInsetCodeBlock(CodeBlock):
             word_wrap=True,
             padding=(0, 0),
         )
-        yield CodePanel(syntax, border_style="markdown.code.border")
+        yield syntax
+        yield Text("```", style=fence_style)
 
 
 class ThinkingCodeBlock(CodeBlock):
-    """A code block for thinking content that uses grey styling instead of syntax highlighting."""
+    """A code block for thinking content that uses simple ``` delimiters."""
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         code = str(self.text).rstrip()
-        text = Text(code, "markdown.code.block")
-        yield CodePanel(text, border_style="markdown.code.border")
+        fence_style = "markdown.code.fence"
+        code_style = "markdown.code.block"
+        lang = self.lexer_name if self.lexer_name != "text" else ""
+        yield Text(f"```{lang}", style=fence_style)
+        yield Text(code, style=code_style)
+        yield Text("```", style=fence_style)
 
 
 class Divider(MarkdownElement):
@@ -289,7 +297,7 @@ class MarkdownStream:
         mark: str | None = None,
         mark_style: StyleType | None = None,
         left_margin: int = 0,
-        right_margin: int = MARKDOWN_RIGHT_MARGIN,
+        right_margin: int = 0,
         markdown_class: Callable[..., Markdown] | None = None,
         image_callback: Callable[[str], None] | None = None,
     ) -> None:
@@ -325,10 +333,10 @@ class MarkdownStream:
 
         self.theme = theme
         self.console = console
-        self.mark: str | None = mark
-        self.mark_style: StyleType | None = mark_style
-
         self.left_margin: int = max(left_margin, 0)
+        # Default mark "•" when left_margin >= 2 and no mark specified
+        self.mark: str | None = mark if mark is not None else ("•" if self.left_margin >= 2 else None)
+        self.mark_style: StyleType | None = mark_style
 
         self.right_margin: int = max(right_margin, 0)
         self.markdown_class: Callable[..., Markdown] = markdown_class or NoInsetMarkdown
@@ -395,25 +403,12 @@ class MarkdownStream:
             return 0
 
         top_level: list[Token] = [token for token in tokens if token.level == 0 and token.map is not None]
-        if not top_level:
+        if len(top_level) < 2:
             return 0
 
         last = top_level[-1]
         assert last.map is not None
 
-        # Lists are a special case: markdown-it-py treats the whole list as one
-        # top-level block, which would keep the entire list in the live area
-        # until the list ends.
-        #
-        # For streaming UX, we want all but the final list item to be eligible
-        # for stabilization, leaving only the *last* item in the live area.
-        if last.type in {"bullet_list_open", "ordered_list_open"}:
-            stable_line = self._compute_list_item_boundary(tokens, last)
-            return max(stable_line, 0)
-
-        if len(top_level) < 2:
-            return 0
-
         # When the buffer ends mid-line, markdown-it-py can temporarily classify
         # some lines as a thematic break (hr). For example, a trailing "- --"
         # parses as an hr, but appending a non-hr character ("- --0") turns it
@@ -430,59 +425,6 @@ class MarkdownStream:
         start_line = last.map[0]
         return max(start_line, 0)
 
-    def _compute_list_item_boundary(self, tokens: list[Token], list_open: Token) -> int:
-        """Return the start line of the last list item in a list.
-
-        This allows stabilizing all list items except the final one.
-        """
-
-        if list_open.map is None:
-            return 0
-
-        list_start, list_end = list_open.map
-        item_level = list_open.level + 1
-
-        last_item_start: int | None = None
-        for token in tokens:
-            if token.type != "list_item_open":
-                continue
-            if token.level != item_level:
-                continue
-            if token.map is None:
-                continue
-            start_line = token.map[0]
-            if start_line < list_start or start_line >= list_end:
-                continue
-            last_item_start = start_line
-
-        return last_item_start if last_item_start is not None else list_start
-
-    def _stable_boundary_continues_list(self, text: str, stable_line: int, *, final: bool) -> bool:
-        """Whether the stable/live split point is inside the final top-level list."""
-
-        if final:
-            return False
-        if stable_line <= 0:
-            return False
-
-        try:
-            tokens = self._parser.parse(text)
-        except Exception:
-            return False
-
-        top_level: list[Token] = [token for token in tokens if token.level == 0 and token.map is not None]
-        if not top_level:
-            return False
-
-        last = top_level[-1]
-        if last.type not in {"bullet_list_open", "ordered_list_open"}:
-            return False
-        if last.map is None:
-            return False
-
-        list_start, list_end = last.map
-        return list_start < stable_line < list_end
-
     def split_blocks(self, text: str, *, min_stable_line: int = 0, final: bool = False) -> tuple[str, str, int]:
         """Split full markdown into stable and live sources.
 
@@ -512,14 +454,7 @@ class MarkdownStream:
             return "", text, 0
         return stable_source, live_source, stable_line
 
-    def render_stable_ansi(
-        self,
-        stable_source: str,
-        *,
-        has_live_suffix: bool,
-        final: bool,
-        continues_list: bool = False,
-    ) -> tuple[str, list[str]]:
+    def render_stable_ansi(self, stable_source: str, *, has_live_suffix: bool, final: bool) -> tuple[str, list[str]]:
         """Render stable prefix to ANSI, preserving inter-block spacing.
 
         Returns:
@@ -529,14 +464,10 @@ class MarkdownStream:
             return "", []
 
         render_source = stable_source
-        if not final and has_live_suffix and not continues_list:
+        if not final and has_live_suffix:
             render_source = self._append_nonfinal_sentinel(stable_source)
 
         lines, images = self._render_markdown_to_lines(render_source, apply_mark=True)
-
-        if continues_list:
-            while lines and not lines[-1].strip():
-                lines.pop()
         return "".join(lines), images
 
     def _append_nonfinal_sentinel(self, stable_source: str) -> str:
@@ -590,12 +521,17 @@ class MarkdownStream:
 
         collected_images = getattr(markdown, "collected_images", [])
 
-        # Split rendered output into lines, strip trailing spaces, and apply left margin.
         lines = output.splitlines(keepends=True)
-        indent_prefix = " " * self.left_margin if self.left_margin > 0 else ""
+        use_mark = apply_mark and bool(self.mark) and self.left_margin >= 2
+
+        # Fast path: no margin, no mark -> just rstrip each line
+        if self.left_margin == 0 and not use_mark:
+            processed_lines = [line.rstrip() + "\n" if line.endswith("\n") else line.rstrip() for line in lines]
+            return processed_lines, list(collected_images)
+
+        indent_prefix = " " * self.left_margin
         processed_lines: list[str] = []
         mark_applied = False
-        use_mark = apply_mark and bool(self.mark) and self.left_margin >= 2
 
         # Pre-render styled mark if needed
         styled_mark: str | None = None
@@ -616,7 +552,7 @@ class MarkdownStream:
             if use_mark and not mark_applied and stripped:
                 stripped = f"{styled_mark} {stripped}"
                 mark_applied = True
-            elif indent_prefix:
+            else:
                 stripped = indent_prefix + stripped
 
             if line.endswith("\n"):
@@ -648,8 +584,6 @@ class MarkdownStream:
             final=final,
         )
 
-        continues_list = self._stable_boundary_continues_list(text, stable_line, final=final) and bool(live_source)
-
         start = time.time()
 
         stable_chunk_to_print: str | None = None
@@ -657,10 +591,7 @@ class MarkdownStream:
         stable_changed = final or stable_line > self._stable_source_line_count
         if stable_changed and stable_source:
             stable_ansi, collected_images = self.render_stable_ansi(
-                stable_source,
-                has_live_suffix=bool(live_source),
-                final=final,
-                continues_list=continues_list,
+                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) :]
@@ -678,33 +609,34 @@ class MarkdownStream:
 
         live_text_to_set: Text | None = None
         if not final and MARKDOWN_STREAM_LIVE_REPAINT_ENABLED and self._live_sink is not None:
-            if continues_list and self._stable_rendered_lines:
-                full_lines, _ = self._render_markdown_to_lines(text, apply_mark=True)
-                skip = min(len(self._stable_rendered_lines), len(full_lines))
-                live_text_to_set = Text.from_ansi("".join(full_lines[skip:]))
-            else:
-                apply_mark = not self._stable_rendered_lines
-                live_lines, _ = self._render_markdown_to_lines(live_source, apply_mark=apply_mark)
-
-                if self._stable_rendered_lines:
-                    stable_trailing_blank = 0
-                    for line in reversed(self._stable_rendered_lines):
+            # Only update live area after we have rendered at least one stable block
+            if not self._stable_rendered_lines:
+                return
+            # When nothing is stable yet, we still want to show incremental output.
+            # Apply the mark only for the first (all-live) frame so it stays anchored
+            # to the first visible line of the full message.
+            apply_mark_to_live = stable_line == 0
+            live_lines, _ = self._render_markdown_to_lines(live_source, apply_mark=apply_mark_to_live)
+
+            if self._stable_rendered_lines:
+                stable_trailing_blank = 0
+                for line in reversed(self._stable_rendered_lines):
+                    if line.strip():
+                        break
+                    stable_trailing_blank += 1
+
+                if stable_trailing_blank > 0:
+                    live_leading_blank = 0
+                    for line in live_lines:
                         if line.strip():
                             break
-                        stable_trailing_blank += 1
-
-                    if stable_trailing_blank > 0:
-                        live_leading_blank = 0
-                        for line in live_lines:
-                            if line.strip():
-                                break
-                            live_leading_blank += 1
+                        live_leading_blank += 1
 
-                        drop = min(stable_trailing_blank, live_leading_blank)
-                        if drop > 0:
-                            live_lines = live_lines[drop:]
+                    drop = min(stable_trailing_blank, live_leading_blank)
+                    if drop > 0:
+                        live_lines = live_lines[drop:]
 
-                live_text_to_set = Text.from_ansi("".join(live_lines))
+            live_text_to_set = Text.from_ansi("".join(live_lines))
 
         with self._synchronized_output():
             # Update/clear live area first to avoid blank padding when stable block appears

klaude_code/tui/components/rich/theme.py

@@ -39,6 +39,7 @@ class Palette:
     red_background: str
     grey_background: str
     yellow_background: str
+    user_message_background: str
 
 
 LIGHT_PALETTE = Palette(
@@ -73,6 +74,7 @@ LIGHT_PALETTE = Palette(
     red_background="#f9ecec",
     grey_background="#f0f0f0",
     yellow_background="#f9f9ec",
+    user_message_background="#f0f0f0",
 )
 
 DARK_PALETTE = Palette(
@@ -107,6 +109,7 @@ DARK_PALETTE = Palette(
     red_background="#3d1f23",
     grey_background="#2a2d30",
     yellow_background="#3d3a1a",
+    user_message_background="#2a2d30",
 )
 
 
@@ -116,6 +119,7 @@ class ThemeKey(str, Enum):
 
     # CODE
     CODE_BACKGROUND = "code_background"
+    CODE_PANEL_TITLE = "code_panel.title"
 
     # PANEL
     SUB_AGENT_RESULT_PANEL = "panel.sub_agent_result"
@@ -258,18 +262,18 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.ERROR_DIM.value: "dim " + palette.red,
                 ThemeKey.INTERRUPT.value: palette.red,
                 # USER_INPUT
-                ThemeKey.USER_INPUT.value: palette.magenta,
-                ThemeKey.USER_INPUT_PROMPT.value: "bold " + palette.magenta,
-                ThemeKey.USER_INPUT_AT_PATTERN.value: palette.purple,
-                ThemeKey.USER_INPUT_SLASH_COMMAND.value: "bold " + palette.blue,
-                ThemeKey.USER_INPUT_SKILL.value: "bold " + palette.green,
+                ThemeKey.USER_INPUT.value: f"{palette.magenta} on {palette.user_message_background}",
+                ThemeKey.USER_INPUT_PROMPT.value: f"bold {palette.magenta} on {palette.user_message_background}",
+                ThemeKey.USER_INPUT_AT_PATTERN.value: f"{palette.purple} on {palette.user_message_background}",
+                ThemeKey.USER_INPUT_SLASH_COMMAND.value: f"bold {palette.blue} on {palette.user_message_background}",
+                ThemeKey.USER_INPUT_SKILL.value: f"bold {palette.green} on {palette.user_message_background}",
                 # ASSISTANT
                 ThemeKey.ASSISTANT_MESSAGE_MARK.value: "bold",
                 # METADATA
-                ThemeKey.METADATA.value: palette.lavender,
-                ThemeKey.METADATA_DIM.value: "dim " + palette.lavender,
-                ThemeKey.METADATA_BOLD.value: "bold " + palette.lavender,
-                ThemeKey.METADATA_ITALIC.value: "italic " + palette.lavender,
+                ThemeKey.METADATA.value: palette.grey1,
+                ThemeKey.METADATA_DIM.value: "dim " + palette.grey1,
+                ThemeKey.METADATA_BOLD.value: "bold " + palette.grey1,
+                ThemeKey.METADATA_ITALIC.value: "italic " + palette.grey1,
                 # STATUS
                 ThemeKey.STATUS_SPINNER.value: palette.blue,
                 ThemeKey.STATUS_TEXT.value: palette.blue,
@@ -347,7 +351,9 @@ def get_theme(theme: str | None = None) -> Themes:
                 # it is used while rendering assistant output.
                 "markdown.thinking": "italic " + palette.grey2,
                 "markdown.thinking.tag": palette.grey2,
-                "markdown.code.border": palette.grey3,
+                "markdown.code.border": palette.grey2,
+                "markdown.code.fence": palette.grey2,
+                "markdown.code.fence.title": palette.grey1,
                 # Used by ThinkingMarkdown when rendering `<thinking>` blocks.
                 "markdown.code.block": palette.grey1,
                 "markdown.h1": "bold reverse " + palette.black,
@@ -362,6 +368,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.link_url": "underline " + palette.blue,
                 "markdown.table.border": palette.grey2,
                 "markdown.checkbox.checked": palette.green,
+                "markdown.block_quote": palette.cyan,
             }
         ),
         thinking_markdown_theme=Theme(
@@ -371,8 +378,10 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.THINKING_BOLD.value: "italic " + palette.grey1,
                 "markdown.strong": "italic " + palette.grey1,
                 "markdown.code": palette.grey1 + " italic on " + palette.code_background,
-                "markdown.code.block": palette.grey1,
-                "markdown.code.border": palette.grey3,
+                "markdown.code.block": palette.grey2,
+                "markdown.code.fence": palette.grey2,
+                "markdown.code.fence.title": palette.grey1,
+                "markdown.code.border": palette.grey2,
                 "markdown.thinking.tag": palette.grey2 + " dim",
                 "markdown.h1": "bold reverse",
                 "markdown.h1.border": palette.grey3,
@@ -385,6 +394,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.link_url": "underline " + palette.blue,
                 "markdown.table.border": palette.grey2,
                 "markdown.checkbox.checked": palette.green,
+                "markdown.block_quote": palette.grey1,
             }
         ),
         code_theme=palette.code_theme,

klaude_code/tui/components/thinking.py

@@ -26,38 +26,3 @@ def normalize_thinking_content(content: str) -> str:
     text = text.replace("**\n\n", "**  \n")
 
     return text
-
-
-def extract_last_bold_header(text: str) -> str | None:
-    """Extract the latest complete bold header ("**…**") from text.
-
-    We treat a bold segment as a "header" only if it appears at the beginning
-    of a line (ignoring leading whitespace). This avoids picking up incidental
-    emphasis inside paragraphs.
-
-    Returns None if no complete bold segment is available yet.
-    """
-
-    last: str | None = None
-    i = 0
-    while True:
-        start = text.find("**", i)
-        if start < 0:
-            break
-
-        line_start = text.rfind("\n", 0, start) + 1
-        if text[line_start:start].strip():
-            i = start + 2
-            continue
-
-        end = text.find("**", start + 2)
-        if end < 0:
-            break
-
-        inner = " ".join(text[start + 2 : end].split())
-        if inner and "\n" not in inner:
-            last = inner
-
-        i = end + 2
-
-    return last