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

klaude_code/tui/components/diffs.py

@@ -1,7 +1,7 @@
 from rich.console import RenderableType
 from rich.text import Text
 
-from klaude_code.const import DIFF_PREFIX_WIDTH
+from klaude_code.const import DIFF_PREFIX_WIDTH, TAB_EXPAND_WIDTH
 from klaude_code.protocol import model
 from klaude_code.tui.components.common import create_grid
 from klaude_code.tui.components.rich.theme import ThemeKey
@@ -74,7 +74,8 @@ def _render_structured_line(line: model.DiffLine) -> Text:
         return Text("")
     text = Text()
     for span in line.spans:
-        text.append(span.text, style=_span_style(line.kind, span.op))
+        content = span.text.expandtabs(TAB_EXPAND_WIDTH)
+        text.append(content, style=_span_style(line.kind, span.op))
     return text
 
 

klaude_code/tui/components/metadata.py

@@ -136,9 +136,6 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
     """Render task metadata including main agent and sub-agents."""
     renderables: list[RenderableType] = []
 
-    if e.cancelled:
-        renderables.append(Text())
-
     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 = "✓"

klaude_code/tui/components/rich/markdown.py

@@ -14,7 +14,6 @@ from rich import box
 from rich._loop import loop_first
 from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
 from rich.markdown import CodeBlock, Heading, ImageItem, ListItem, Markdown, MarkdownElement, TableElement
-from rich.rule import Rule
 from rich.segment import Segment
 from rich.style import Style, StyleType
 from rich.syntax import Syntax
@@ -120,7 +119,8 @@ class Divider(MarkdownElement):
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         style = console.get_style("markdown.hr", default="none")
-        yield Rule(style=style, characters="-")
+        width = min(options.max_width, 100)
+        yield Text("-" * width, style=style)
 
 
 class MarkdownTable(TableElement):
@@ -153,7 +153,8 @@ class LeftHeading(Heading):
             h1_text = text.assemble((" ", "markdown.h1"), text, (" ", "markdown.h1"))
             yield h1_text
         elif self.tag == "h2":
-            text.stylize(Style(bold=True, underline=False))
+            h2_style = console.get_style("markdown.h2", default="bold")
+            text.stylize(h2_style + Style(underline=False))
             yield text
         else:
             yield text
@@ -394,12 +395,25 @@ class MarkdownStream:
             return 0
 
         top_level: list[Token] = [token for token in tokens if token.level == 0 and token.map is not None]
-        if len(top_level) < 2:
+        if not top_level:
             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
@@ -416,6 +430,59 @@ 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.
 
@@ -445,7 +512,14 @@ 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) -> tuple[str, list[str]]:
+    def render_stable_ansi(
+        self,
+        stable_source: str,
+        *,
+        has_live_suffix: bool,
+        final: bool,
+        continues_list: bool = False,
+    ) -> tuple[str, list[str]]:
         """Render stable prefix to ANSI, preserving inter-block spacing.
 
         Returns:
@@ -455,10 +529,14 @@ class MarkdownStream:
             return "", []
 
         render_source = stable_source
-        if not final and has_live_suffix:
+        if not final and has_live_suffix and not continues_list:
             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:
@@ -570,6 +648,8 @@ 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
@@ -577,7 +657,10 @@ 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
+                stable_source,
+                has_live_suffix=bool(live_source),
+                final=final,
+                continues_list=continues_list,
             )
             stable_lines = stable_ansi.splitlines(keepends=True)
             new_lines = stable_lines[len(self._stable_rendered_lines) :]
@@ -595,30 +678,42 @@ 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:
-            apply_mark_live = self._stable_source_line_count == 0
-            live_lines, _ = self._render_markdown_to_lines(live_source, apply_mark=apply_mark_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 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):
                         if line.strip():
                             break
-                        live_leading_blank += 1
+                        stable_trailing_blank += 1
 
-                    drop = min(stable_trailing_blank, live_leading_blank)
-                    if drop > 0:
-                        live_lines = live_lines[drop:]
+                    if stable_trailing_blank > 0:
+                        live_leading_blank = 0
+                        for line in live_lines:
+                            if line.strip():
+                                break
+                            live_leading_blank += 1
 
-            live_text_to_set = Text.from_ansi("".join(live_lines))
+                        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))
 
         with self._synchronized_output():
+            # Update/clear live area first to avoid blank padding when stable block appears
+            if final:
+                if self._live_sink is not None:
+                    self._live_sink(None)
+            elif live_text_to_set is not None and self._live_sink is not None:
+                self._live_sink(live_text_to_set)
+
             if stable_chunk_to_print:
                 self.console.print(Text.from_ansi(stable_chunk_to_print), end="\n")
 
@@ -626,13 +721,5 @@ class MarkdownStream:
                 for img_path in new_images:
                     self._image_callback(img_path)
 
-            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/tui/components/rich/status.py

@@ -277,7 +277,7 @@ def truncate_left(text: Text, max_cells: int, *, console: Console, ellipsis: str
     if cell_len(text.plain) <= max_cells:
         return text
 
-    ellipsis_cells = cell_len(ellipsis)
+    ellipsis_cells = cell_len(ellipsis) + 1  # +1 for trailing space
     if max_cells <= ellipsis_cells:
         # Not enough space to show any meaningful suffix.
         clipped = Text(ellipsis, style=text.style)
@@ -307,7 +307,7 @@ def truncate_left(text: Text, max_cells: int, *, console: Console, ellipsis: str
     except Exception:
         ellipsis_style = suffix.style or text.style
 
-    return Text.assemble(Text(ellipsis, style=ellipsis_style), suffix)
+    return Text.assemble(Text(ellipsis + " ", style=ellipsis_style), suffix)
 
 
 class ShimmerStatusText:

klaude_code/tui/components/rich/theme.py

@@ -21,6 +21,7 @@ class Palette:
     grey_green: str
     purple: str
     lavender: str
+    black: str
     diff_add: str
     diff_add_char: str
     diff_remove: str
@@ -55,6 +56,7 @@ LIGHT_PALETTE = Palette(
     grey_green="#96a096",
     purple="#5f5fb7",
     lavender="#7878b0",
+    black="#101827",
     diff_add="#2e5a32 on #dafbe1",
     diff_add_char="#2e5a32 on #aceebb",
     diff_remove="#82071e on #ffecec",
@@ -88,6 +90,7 @@ DARK_PALETTE = Palette(
     grey_green="#6d8672",
     purple="#afbafe",
     lavender="#9898b8",
+    black="white",
     diff_add="#c8e6c9 on #1b3928",
     diff_add_char="#c8e6c9 on #2d6b42",
     diff_remove="#ffcdd2 on #3d1f23",
@@ -301,9 +304,9 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.BASH_HEREDOC_DELIMITER.value: "bold " + palette.grey1,
                 # THINKING
                 ThemeKey.THINKING.value: "italic " + palette.grey2,
-                ThemeKey.THINKING_BOLD.value: "bold italic " + palette.grey1,
+                ThemeKey.THINKING_BOLD.value: "italic " + palette.grey1,
                 # COMPACTION
-                ThemeKey.COMPACTION_SUMMARY.value: "italic " + palette.grey1,
+                ThemeKey.COMPACTION_SUMMARY.value: palette.grey1,
                 # TODO_ITEM
                 ThemeKey.TODO_EXPLANATION.value: palette.grey1 + " italic",
                 ThemeKey.TODO_PENDING_MARK.value: "bold " + palette.grey1,
@@ -347,9 +350,9 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.code.border": palette.grey3,
                 # Used by ThinkingMarkdown when rendering `<thinking>` blocks.
                 "markdown.code.block": palette.grey1,
-                "markdown.h1": "bold reverse",
+                "markdown.h1": "bold reverse " + palette.black,
                 "markdown.h1.border": palette.grey3,
-                "markdown.h2": "bold underline",
+                "markdown.h2": "bold underline " + palette.black,
                 "markdown.h3": "bold " + palette.grey1,
                 "markdown.h4": "bold " + palette.grey2,
                 "markdown.hr": palette.grey3,
@@ -365,7 +368,8 @@ def get_theme(theme: str | None = None) -> Themes:
             styles={
                 # THINKING (used for left-side mark in thinking output)
                 ThemeKey.THINKING.value: "italic " + palette.grey2,
-                ThemeKey.THINKING_BOLD.value: "bold italic " + palette.grey1,
+                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,
@@ -379,7 +383,6 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.item.number": palette.grey2,
                 "markdown.link": "underline " + palette.blue,
                 "markdown.link_url": "underline " + palette.blue,
-                "markdown.strong": "bold italic " + palette.grey1,
                 "markdown.table.border": palette.grey2,
                 "markdown.checkbox.checked": palette.green,
             }

klaude_code/tui/components/tools.py

@@ -10,8 +10,10 @@ from rich.text import Text
 
 from klaude_code.const import (
     BASH_OUTPUT_PANEL_THRESHOLD,
+    DIFF_PREFIX_WIDTH,
     INVALID_TOOL_CALL_MAX_LENGTH,
     QUERY_DISPLAY_TRUNCATE_LENGTH,
+    TAB_EXPAND_WIDTH,
     URL_TRUNCATE_MAX_LENGTH,
     WEB_SEARCH_DEFAULT_MAX_RESULTS,
 )
@@ -387,6 +389,24 @@ def render_generic_tool_result(result: str, *, is_error: bool = False) -> Render
     return text
 
 
+def render_read_preview(ui_extra: model.ReadPreviewUIExtra) -> RenderableType:
+    """Render read preview with line numbers aligned to diff style."""
+    grid = create_grid()
+    grid.padding = (0, 0)
+
+    for line in ui_extra.lines:
+        prefix = f"{line.line_no:>{DIFF_PREFIX_WIDTH}}  "
+        content = line.content.expandtabs(TAB_EXPAND_WIDTH)
+        grid.add_row(Text(prefix, ThemeKey.TOOL_RESULT), Text(content, ThemeKey.TOOL_RESULT))
+
+    if ui_extra.remaining_lines > 0:
+        remaining_prefix = f"{'⋮':>{DIFF_PREFIX_WIDTH}}  "
+        remaining_text = Text(f"(more {ui_extra.remaining_lines} lines)", ThemeKey.TOOL_RESULT_TRUNCATED)
+        grid.add_row(Text(remaining_prefix, ThemeKey.TOOL_RESULT_TRUNCATED), remaining_text)
+
+    return grid
+
+
 def _extract_mermaid_link(
     ui_extra: model.ToolResultUIExtra | None,
 ) -> model.MermaidLinkUIExtra | None:
@@ -678,6 +698,8 @@ def render_tool_result(
 
     match e.tool_name:
         case tools.READ:
+            if isinstance(e.ui_extra, model.ReadPreviewUIExtra):
+                return wrap(render_read_preview(e.ui_extra))
             return None
         case tools.EDIT:
             return wrap(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""))

klaude_code/tui/components/user_input.py

@@ -3,6 +3,7 @@ import re
 from rich.console import Group, RenderableType
 from rich.text import Text
 
+from klaude_code.const import TAB_EXPAND_WIDTH
 from klaude_code.skill import get_available_skills
 from klaude_code.tui.components.common import create_grid
 from klaude_code.tui.components.rich.theme import ThemeKey
@@ -82,6 +83,7 @@ def render_user_input(content: str) -> RenderableType:
     lines = content.strip().split("\n")
     renderables: list[RenderableType] = []
     for i, line in enumerate(lines):
+        line = line.expandtabs(TAB_EXPAND_WIDTH)
         # Handle slash command on first line
         if i == 0 and line.startswith("/"):
             splits = line.split(" ", maxsplit=1)

klaude_code/tui/machine.py

@@ -32,7 +32,6 @@ from klaude_code.tui.commands import (
     RenderTaskFinish,
     RenderTaskMetadata,
     RenderTaskStart,
-    RenderThinkingHeader,
     RenderToolCall,
     RenderToolResult,
     RenderTurnStart,
@@ -68,25 +67,6 @@ FAST_TOOLS: frozenset[str] = frozenset(
 )
 
 
-@dataclass
-class SubAgentThinkingHeaderState:
-    buffer: str = ""
-    last_header: str | None = None
-
-    def append_and_extract_new_header(self, content: str) -> str | None:
-        self.buffer += content
-
-        max_chars = 8192
-        if len(self.buffer) > max_chars:
-            self.buffer = self.buffer[-max_chars:]
-
-        header = extract_last_bold_header(normalize_thinking_content(self.buffer))
-        if header and header != self.last_header:
-            self.last_header = header
-            return header
-        return None
-
-
 class ActivityState:
     """Tracks composing/tool activity for spinner display."""
 
@@ -110,7 +90,10 @@ class ActivityState:
 
     def add_sub_agent_tool_call(self, tool_call_id: str, tool_name: str) -> None:
         if tool_call_id in self._sub_agent_tool_calls_by_id:
-            return
+            old_tool_name = self._sub_agent_tool_calls_by_id[tool_call_id]
+            self._sub_agent_tool_calls[old_tool_name] = self._sub_agent_tool_calls.get(old_tool_name, 0) - 1
+            if self._sub_agent_tool_calls[old_tool_name] <= 0:
+                self._sub_agent_tool_calls.pop(old_tool_name, None)
         self._sub_agent_tool_calls_by_id[tool_call_id] = tool_name
         self._sub_agent_tool_calls[tool_name] = self._sub_agent_tool_calls.get(tool_name, 0) + 1
 
@@ -303,7 +286,6 @@ class SpinnerStatusState:
 class _SessionState:
     session_id: str
     sub_agent_state: model.SubAgentState | None = None
-    sub_agent_thinking_header: SubAgentThinkingHeaderState | None = None
     model_id: str | None = None
     assistant_stream_active: bool = False
     thinking_stream_active: bool = False
@@ -418,8 +400,6 @@ class DisplayStateMachine:
                     self._set_primary_if_needed(e.session_id)
                     if not is_replay:
                         cmds.append(TaskClockStart())
-                else:
-                    s.sub_agent_thinking_header = SubAgentThinkingHeaderState()
 
                 if not is_replay:
                     cmds.append(SpinnerStart())
@@ -465,7 +445,11 @@ class DisplayStateMachine:
 
             case events.ThinkingStartEvent() as e:
                 if s.is_sub_agent:
-                    return []
+                    if not s.should_show_sub_agent_thinking_header:
+                        return []
+                    s.thinking_stream_active = True
+                    cmds.append(StartThinkingStream(session_id=e.session_id))
+                    return cmds
                 if not self._is_primary(e.session_id):
                     return []
                 s.thinking_stream_active = True
@@ -483,11 +467,7 @@ class DisplayStateMachine:
                 if s.is_sub_agent:
                     if not s.should_show_sub_agent_thinking_header:
                         return []
-                    if s.sub_agent_thinking_header is None:
-                        s.sub_agent_thinking_header = SubAgentThinkingHeaderState()
-                    header = s.sub_agent_thinking_header.append_and_extract_new_header(e.content)
-                    if header:
-                        cmds.append(RenderThinkingHeader(session_id=e.session_id, header=header))
+                    cmds.append(AppendThinking(session_id=e.session_id, content=e.content))
                     return cmds
 
                 if not self._is_primary(e.session_id):
@@ -507,7 +487,11 @@ class DisplayStateMachine:
 
             case events.ThinkingEndEvent() as e:
                 if s.is_sub_agent:
-                    return []
+                    if not s.should_show_sub_agent_thinking_header:
+                        return []
+                    s.thinking_stream_active = False
+                    cmds.append(EndThinkingStream(session_id=e.session_id))
+                    return cmds
                 if not self._is_primary(e.session_id):
                     return []
                 s.thinking_stream_active = False
@@ -603,14 +587,11 @@ class DisplayStateMachine:
                 # Skip activity state for fast tools on non-streaming models (e.g., Gemini)
                 # to avoid flash-and-disappear effect
                 if not is_replay and not s.should_skip_tool_activity(e.tool_name):
-                    if e.tool_name == tools.TASK:
-                        pass
+                    tool_active_form = get_tool_active_form(e.tool_name)
+                    if is_sub_agent_tool(e.tool_name):
+                        self._spinner.add_sub_agent_tool_call(e.tool_call_id, tool_active_form)
                     else:
-                        tool_active_form = get_tool_active_form(e.tool_name)
-                        if is_sub_agent_tool(e.tool_name):
-                            self._spinner.add_sub_agent_tool_call(e.tool_call_id, tool_active_form)
-                        else:
-                            self._spinner.add_tool_call(tool_active_form)
+                        self._spinner.add_tool_call(tool_active_form)
 
                 if not is_replay:
                     cmds.extend(self._spinner_update_commands())
@@ -679,15 +660,12 @@ class DisplayStateMachine:
             case events.TaskFinishEvent() as e:
                 s.task_active = False
                 cmds.append(RenderTaskFinish(e))
-                if not s.is_sub_agent:
-                    if not is_replay:
-                        cmds.append(TaskClockClear())
-                        self._spinner.reset()
-                        cmds.append(SpinnerStop())
-                        cmds.append(PrintRuleLine())
-                        cmds.append(EmitTmuxSignal())
-                else:
-                    s.sub_agent_thinking_header = None
+                if not s.is_sub_agent and not is_replay:
+                    cmds.append(TaskClockClear())
+                    self._spinner.reset()
+                    cmds.append(SpinnerStop())
+                    cmds.append(PrintRuleLine())
+                    cmds.append(EmitTmuxSignal())
                 return cmds
 
             case events.InterruptEvent() as e:

klaude_code/tui/renderer.py

@@ -67,7 +67,7 @@ from klaude_code.tui.components import thinking as c_thinking
 from klaude_code.tui.components import tools as c_tools
 from klaude_code.tui.components import user_input as c_user_input
 from klaude_code.tui.components import welcome as c_welcome
-from klaude_code.tui.components.common import truncate_head
+from klaude_code.tui.components.common import create_grid, truncate_head
 from klaude_code.tui.components.rich import status as r_status
 from klaude_code.tui.components.rich.live import CropAboveLive, SingleLine
 from klaude_code.tui.components.rich.markdown import MarkdownStream, NoInsetMarkdown, ThinkingMarkdown
@@ -168,6 +168,7 @@ class TUICommandRenderer:
         self._sessions: dict[str, _SessionStatus] = {}
         self._current_sub_agent_color: Style | None = None
         self._sub_agent_color_index = 0
+        self._sub_agent_thinking_buffers: dict[str, str] = {}
 
     # ---------------------------------------------------------------------
     # Session helpers
@@ -325,8 +326,7 @@ class TUICommandRenderer:
                 if pad_lines:
                     stream = Padding(stream, (0, 0, pad_lines, 0))
                 stream_part = stream
-
-            gap_part = Text("") if self._spinner_visible else Group()
+                gap_part = Text("")
 
         status_part: RenderableType = SingleLine(self._status_spinner) if self._spinner_visible else Group()
         return Group(stream_part, gap_part, status_part)
@@ -381,6 +381,19 @@ class TUICommandRenderer:
     def _flush_assistant(self) -> None:
         self._assistant_stream.render()
 
+    def _render_sub_agent_thinking(self, content: str) -> None:
+        """Render sub-agent thinking content as a single block."""
+        normalized = c_thinking.normalize_thinking_content(content)
+        if not normalized.strip():
+            return
+        md = ThinkingMarkdown(normalized, code_theme=self.themes.code_theme, style=ThemeKey.THINKING)
+        self.console.push_theme(self.themes.thinking_markdown_theme)
+        grid = create_grid()
+        grid.add_row(Text(c_thinking.THINKING_MESSAGE_MARK, style=ThemeKey.THINKING), md)
+        self.print(grid)
+        self.console.pop_theme()
+        self.print()
+
     # ---------------------------------------------------------------------
     # Event-specific rendering helpers
     # ---------------------------------------------------------------------
@@ -534,9 +547,9 @@ class TUICommandRenderer:
         )
         self.console.print(
             Rule(
-                Text("Context Compact", style=ThemeKey.COMPACTION_SUMMARY),
+                Text("Context Compacted", style=ThemeKey.COMPACTION_SUMMARY),
                 characters="=",
-                style=ThemeKey.COMPACTION_SUMMARY,
+                style=ThemeKey.LINES,
             )
         )
         self.print()
@@ -622,20 +635,31 @@ class TUICommandRenderer:
                     self.display_command_output(event)
                 case RenderTurnStart(event=event):
                     self.display_turn_start(event)
-                case StartThinkingStream():
-                    if not self._thinking_stream.is_active:
+                case StartThinkingStream(session_id=session_id):
+                    if self.is_sub_agent_session(session_id):
+                        self._sub_agent_thinking_buffers[session_id] = ""
+                    elif not self._thinking_stream.is_active:
                         self._thinking_stream.start(self._new_thinking_mdstream())
-                case AppendThinking(content=content):
-                    if self._thinking_stream.is_active:
+                case AppendThinking(session_id=session_id, content=content):
+                    if self.is_sub_agent_session(session_id):
+                        if session_id in self._sub_agent_thinking_buffers:
+                            self._sub_agent_thinking_buffers[session_id] += content
+                    elif self._thinking_stream.is_active:
                         first_delta = self._thinking_stream.buffer == ""
                         self._thinking_stream.append(content)
                         if first_delta:
                             self._thinking_stream.render(transform=c_thinking.normalize_thinking_content)
                         self._flush_thinking()
-                case EndThinkingStream():
-                    finalized = self._thinking_stream.finalize(transform=c_thinking.normalize_thinking_content)
-                    if finalized:
-                        self.print()
+                case EndThinkingStream(session_id=session_id):
+                    if self.is_sub_agent_session(session_id):
+                        buf = self._sub_agent_thinking_buffers.pop(session_id, "")
+                        if buf.strip():
+                            with self.session_print_context(session_id):
+                                self._render_sub_agent_thinking(buf)
+                    else:
+                        finalized = self._thinking_stream.finalize(transform=c_thinking.normalize_thinking_content)
+                        if finalized:
+                            self.print()
                 case StartAssistantStream():
                     if not self._assistant_stream.is_active:
                         self._assistant_stream.start(self._new_assistant_mdstream())