klaude-code 1.2.7__py3-none-any.whl → 1.2.9__py3-none-any.whl

klaude_code/ui/modes/repl/event_handler.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import Awaitable, Callable
 
 from rich.text import Text
@@ -14,34 +15,130 @@ from klaude_code.ui.terminal.progress_bar import OSC94States, emit_osc94
 from klaude_code.ui.utils.debouncer import Debouncer
 
 
+@dataclass
+class ActiveStream:
+    """Active streaming state containing buffer and markdown renderer.
+
+    This represents an active streaming session where content is being
+    accumulated in a buffer and rendered via MarkdownStream.
+    When streaming ends, this object is replaced with None.
+    """
+
+    buffer: str
+    mdstream: MarkdownStream
+
+    def append(self, content: str) -> None:
+        self.buffer += content
+
+
 class StreamState:
+    """Manages assistant message streaming state.
+
+    The streaming state is either:
+    - None: No active stream
+    - ActiveStream: Active streaming with buffer and markdown renderer
+
+    This design ensures buffer and mdstream are always in sync.
+    """
+
     def __init__(self, interval: float, flush_handler: Callable[["StreamState"], Awaitable[None]]):
-        self.buffer: str = ""
-        self.mdstream: MarkdownStream | None = None
+        self._active: ActiveStream | None = None
         self._flush_handler = flush_handler
         self.debouncer = Debouncer(interval=interval, callback=self._debounced_flush)
 
     async def _debounced_flush(self) -> None:
         await self._flush_handler(self)
 
+    @property
+    def is_active(self) -> bool:
+        return self._active is not None
+
+    @property
+    def buffer(self) -> str:
+        return self._active.buffer if self._active else ""
+
+    @property
+    def mdstream(self) -> MarkdownStream | None:
+        return self._active.mdstream if self._active else None
+
+    def start(self, mdstream: MarkdownStream) -> None:
+        """Start a new streaming session."""
+        self._active = ActiveStream(buffer="", mdstream=mdstream)
+
     def append(self, content: str) -> None:
-        self.buffer += content
+        """Append content to the buffer."""
+        if self._active:
+            self._active.append(content)
+
+    def finish(self) -> None:
+        """End the current streaming session."""
+        self._active = None
+
+
+class ActivityState:
+    """Represents the current activity state for spinner display.
+
+    This is a discriminated union where the state is either:
+    - None (thinking/idle)
+    - Composing (assistant is streaming text)
+    - ToolCalls (one or more tool calls in progress)
+
+    Composing and ToolCalls are mutually exclusive - when tool calls start,
+    composing state is automatically cleared.
+    """
+
+    def __init__(self) -> None:
+        self._composing: bool = False
+        self._tool_calls: dict[str, int] = {}
+
+    @property
+    def is_composing(self) -> bool:
+        return self._composing and not self._tool_calls
+
+    @property
+    def has_tool_calls(self) -> bool:
+        return bool(self._tool_calls)
+
+    def set_composing(self, composing: bool) -> None:
+        self._composing = composing
+
+    def add_tool_call(self, tool_name: str) -> None:
+        self._tool_calls[tool_name] = self._tool_calls.get(tool_name, 0) + 1
 
-    def clear(self) -> None:
-        self.buffer = ""
+    def clear_tool_calls(self) -> None:
+        self._tool_calls = {}
+
+    def reset(self) -> None:
+        self._composing = False
+        self._tool_calls = {}
+
+    def get_activity_text(self) -> Text | None:
+        """Get activity text for display. Returns None if idle/thinking."""
+        if self._tool_calls:
+            activity_text = Text()
+            first = True
+            for name, count in self._tool_calls.items():
+                if not first:
+                    activity_text.append(", ")
+                activity_text.append(name, style="bold")
+                if count > 1:
+                    activity_text.append(f" x {count}")
+                first = False
+            return activity_text
+        if self._composing:
+            return Text("Composing")
+        return None
 
 
 class SpinnerStatusState:
     """Multi-layer spinner status state management.
 
-    Layers (from low to high priority):
+    Composed of two independent layers:
     - base_status: Set by TodoChange, persistent within a turn
-    - composing: True when assistant is streaming text
-    - tool_calls: Accumulated from ToolCallStart, cleared at turn start
+    - activity: Current activity (composing or tool_calls), mutually exclusive
 
     Display logic:
-    - If tool_calls: show base + tool_calls (composing is hidden)
-    - Elif composing: show base + "Composing"
+    - If activity: show base + activity (if base exists) or activity + "..."
     - Elif base_status: show base_status
     - Else: show "Thinking …"
     """
@@ -50,14 +147,12 @@ class SpinnerStatusState:
 
     def __init__(self) -> None:
         self._base_status: str | None = None
-        self._composing: bool = False
-        self._tool_calls: dict[str, int] = {}
+        self._activity = ActivityState()
 
     def reset(self) -> None:
         """Reset all layers."""
         self._base_status = None
-        self._composing = False
-        self._tool_calls = {}
+        self._activity.reset()
 
     def set_base_status(self, status: str | None) -> None:
         """Set base status from TodoChange."""
@@ -65,37 +160,23 @@ class SpinnerStatusState:
 
     def set_composing(self, composing: bool) -> None:
         """Set composing state when assistant is streaming."""
-        self._composing = composing
+        self._activity.set_composing(composing)
 
     def add_tool_call(self, tool_name: str) -> None:
         """Add a tool call to the accumulator."""
-        self._tool_calls[tool_name] = self._tool_calls.get(tool_name, 0) + 1
+        self._activity.add_tool_call(tool_name)
 
     def clear_tool_calls(self) -> None:
-        """Clear tool calls and composing state."""
-        self._tool_calls = {}
+        """Clear tool calls."""
+        self._activity.clear_tool_calls()
 
     def clear_for_new_turn(self) -> None:
-        """Clear tool calls and composing state for a new turn."""
-        self._tool_calls = {}
-        self._composing = False
+        """Clear activity state for a new turn."""
+        self._activity.reset()
 
     def get_status(self) -> Text:
         """Get current spinner status as rich Text."""
-        # Build activity text (tool_calls or composing)
-        activity_text: Text | None = None
-        if self._tool_calls:
-            activity_text = Text()
-            first = True
-            for name, count in self._tool_calls.items():
-                if not first:
-                    activity_text.append(", ")
-                activity_text.append(name, style="bold")
-                if count > 1:
-                    activity_text.append(f" × {count}")
-                first = False
-        elif self._composing:
-            activity_text = Text("Composing")
+        activity_text = self._activity.get_activity_text()
 
         if self._base_status:
             result = Text(self._base_status)
@@ -151,12 +232,14 @@ class DisplayEventHandler:
                 await self._on_tool_call(e)
             case events.ToolResultEvent() as e:
                 await self._on_tool_result(e)
-            case events.ResponseMetadataEvent() as e:
-                self._on_response_metadata(e)
+            case events.TaskMetadataEvent() as e:
+                self._on_task_metadata(e)
             case events.TodoChangeEvent() as e:
                 self._on_todo_change(e)
             case events.TurnEndEvent():
                 pass
+            case events.ResponseMetadataEvent():
+                pass  # Internal event, not displayed
             case events.TaskFinishEvent() as e:
                 await self._on_task_finish(e)
             case events.InterruptEvent() as e:
@@ -212,12 +295,12 @@ class DisplayEventHandler:
             return
         if len(event.content.strip()) == 0 and self.stage_manager.current_stage != Stage.ASSISTANT:
             return
-        first_delta = self.assistant_stream.mdstream is None
+        first_delta = not self.assistant_stream.is_active
         if first_delta:
             self.spinner_status.set_composing(True)
             self.spinner_status.clear_tool_calls()
             self._update_spinner()
-            self.assistant_stream.mdstream = MarkdownStream(
+            mdstream = MarkdownStream(
                 mdargs={"code_theme": self.renderer.themes.code_theme},
                 theme=self.renderer.themes.markdown_theme,
                 console=self.renderer.console,
@@ -225,6 +308,7 @@ class DisplayEventHandler:
                 mark="➤",
                 indent=2,
             )
+            self.assistant_stream.start(mdstream)
         self.assistant_stream.append(event.content)
         if first_delta and self.assistant_stream.mdstream is not None:
             # Stop spinner and immediately start MarkdownStream's Live
@@ -239,13 +323,14 @@ class DisplayEventHandler:
         if self.renderer.is_sub_agent_session(event.session_id):
             return
         await self.stage_manager.transition_to(Stage.ASSISTANT)
-        if self.assistant_stream.mdstream is not None:
+        if self.assistant_stream.is_active:
             self.assistant_stream.debouncer.cancel()
-            self.assistant_stream.mdstream.update(event.content.strip(), final=True)
+            mdstream = self.assistant_stream.mdstream
+            assert mdstream is not None
+            mdstream.update(event.content.strip(), final=True)
         else:
             self.renderer.display_assistant_message(event.content)
-        self.assistant_stream.clear()
-        self.assistant_stream.mdstream = None
+        self.assistant_stream.finish()
         self.spinner_status.set_composing(False)
         self._update_spinner()
         await self.stage_manager.transition_to(Stage.WAITING)
@@ -269,8 +354,8 @@ class DisplayEventHandler:
         await self.stage_manager.transition_to(Stage.TOOL_RESULT)
         self.renderer.display_tool_call_result(event)
 
-    def _on_response_metadata(self, event: events.ResponseMetadataEvent) -> None:
-        self.renderer.display_response_metadata(event)
+    def _on_task_metadata(self, event: events.TaskMetadataEvent) -> None:
+        self.renderer.display_task_metadata(event)
 
     def _on_todo_change(self, event: events.TodoChangeEvent) -> None:
         active_form_status_text = self._extract_active_form_text(event)
@@ -314,11 +399,12 @@ class DisplayEventHandler:
     # ─────────────────────────────────────────────────────────────────────────────
 
     async def _finish_assistant_stream(self) -> None:
-        if self.assistant_stream.mdstream is not None:
+        if self.assistant_stream.is_active:
             self.assistant_stream.debouncer.cancel()
-            self.assistant_stream.mdstream.update(self.assistant_stream.buffer, final=True)
-            self.assistant_stream.mdstream = None
-            self.assistant_stream.clear()
+            mdstream = self.assistant_stream.mdstream
+            assert mdstream is not None
+            mdstream.update(self.assistant_stream.buffer, final=True)
+            self.assistant_stream.finish()
 
     def _print_thinking_prefix(self) -> None:
         self.renderer.display_thinking_prefix()
@@ -328,8 +414,10 @@ class DisplayEventHandler:
         self.renderer.spinner_update(self.spinner_status.get_status())
 
     async def _flush_assistant_buffer(self, state: StreamState) -> None:
-        if state.mdstream is not None:
-            state.mdstream.update(state.buffer)
+        if state.is_active:
+            mdstream = state.mdstream
+            assert mdstream is not None
+            mdstream.update(state.buffer)
 
     def _maybe_notify_task_finish(self, event: events.TaskFinishEvent) -> None:
         if self.notifier is None:
@@ -360,8 +448,19 @@ class DisplayEventHandler:
         status_text = ""
         for todo in todo_event.todos:
             if todo.status == "in_progress":
-                if len(todo.activeForm) > 0:
-                    status_text = todo.activeForm
+                if len(todo.active_form) > 0:
+                    status_text = todo.active_form
                 if len(todo.content) > 0:
                     status_text = todo.content
-        return status_text.replace("\n", "")
+        status_text = status_text.replace("\n", "")
+        return self._truncate_status_text(status_text, max_length=30)
+
+    def _truncate_status_text(self, text: str, max_length: int) -> str:
+        """Truncate text to max_length while preserving complete words."""
+        if len(text) <= max_length:
+            return text
+        truncated = text[:max_length]
+        last_space = truncated.rfind(" ")
+        if last_space > 0:
+            return truncated[:last_space] + "..."
+        return truncated + "..."

klaude_code/ui/modes/repl/renderer.py

@@ -184,12 +184,14 @@ class REPLRenderer:
                         self.display_tool_call(tool_call_event)
                     tool_call_dict.pop(tool_result_event.tool_call_id, None)
                     self.display_tool_call_result(tool_result_event)
-                case events.ResponseMetadataEvent() as metadata_event:
-                    self.print(r_metadata.render_response_metadata(metadata_event))
+                case events.TaskMetadataEvent() as metadata_event:
+                    self.print(r_metadata.render_task_metadata(metadata_event))
                     self.print()
                 case events.InterruptEvent():
                     self.print()
                     self.print(r_user_input.render_interrupt())
+                case events.ErrorEvent() as e:
+                    self.display_error(e)
 
     def display_developer_message(self, e: events.DeveloperMessageEvent) -> None:
         if not r_developer.need_render_developer_message(e):
@@ -231,9 +233,9 @@ class REPLRenderer:
             self.print(renderable)
             self.print()
 
-    def display_response_metadata(self, event: events.ResponseMetadataEvent) -> None:
+    def display_task_metadata(self, event: events.TaskMetadataEvent) -> None:
         with self.session_print_context(event.session_id):
-            self.print(r_metadata.render_response_metadata(event))
+            self.print(r_metadata.render_task_metadata(event))
             self.print()
 
     def display_task_finish(self, event: events.TaskFinishEvent) -> None:

klaude_code/ui/renderers/developer.py

@@ -7,6 +7,7 @@ from klaude_code.protocol import commands, events, model
 from klaude_code.ui.renderers import diffs as r_diffs
 from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.renderers.tools import render_path
+from klaude_code.ui.rich.markdown import NoInsetMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 from klaude_code.ui.utils.common import truncate_display
 
@@ -100,6 +101,8 @@ def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
             return Padding.indent(Text.from_markup(e.item.content or ""), level=2)
         case commands.CommandName.STATUS:
             return _render_status_output(e.item.command_output)
+        case commands.CommandName.RELEASE_NOTES:
+            return Padding.indent(NoInsetMarkdown(e.item.content or ""), level=2)
         case _:
             content = e.item.content or "(no content)"
             style = ThemeKey.TOOL_RESULT if not e.item.command_output.is_error else ThemeKey.ERROR
@@ -126,34 +129,41 @@ def _format_cost(cost: float | None, currency: str = "USD") -> str:
 
 
 def _render_status_output(command_output: model.CommandOutput) -> RenderableType:
-    """Render session status as a two-column table with sections."""
-    if not command_output.ui_extra or not command_output.ui_extra.session_status:
-        return Text("(no status data)", style=ThemeKey.TOOL_RESULT)
+    """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.session_status
+    status = command_output.ui_extra
     usage = status.usage
 
     table = Table.grid(padding=(0, 2))
-    table.add_column(style=ThemeKey.TOOL_RESULT, no_wrap=True)
-    table.add_column(style=ThemeKey.TOOL_RESULT, no_wrap=True)
-    # Token Usage section
-    table.add_row(Text("Token Usage", style="bold"), "")
-    table.add_row("Input Tokens", _format_tokens(usage.input_tokens))
-    if usage.cached_tokens > 0:
-        table.add_row("Cached Tokens", _format_tokens(usage.cached_tokens))
-    if usage.reasoning_tokens > 0:
-        table.add_row("Reasoning Tokens", _format_tokens(usage.reasoning_tokens))
-    table.add_row("Output Tokens", _format_tokens(usage.output_tokens))
-    table.add_row("Total Tokens", _format_tokens(usage.total_tokens))
-
-    # Cost section
-    if usage.total_cost is not None:
-        table.add_row("", "")  # Empty line
-        table.add_row(Text("Cost", style="bold"), "")
-        table.add_row("Input Cost", _format_cost(usage.input_cost, usage.currency))
-        if usage.cache_read_cost is not None and usage.cache_read_cost > 0:
-            table.add_row("Cache Read Cost", _format_cost(usage.cache_read_cost, usage.currency))
-        table.add_row("Output Cost", _format_cost(usage.output_cost, usage.currency))
-        table.add_row("Total Cost", _format_cost(usage.total_cost, usage.currency))
+    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/metadata.py

@@ -7,7 +7,7 @@ from rich.padding import Padding
 from rich.panel import Panel
 from rich.text import Text
 
-from klaude_code.protocol import events
+from klaude_code.protocol import events, model
 from klaude_code.trace import is_debug_enabled
 from klaude_code.ui.rich.theme import ThemeKey
 from klaude_code.ui.utils.common import format_number
@@ -21,18 +21,34 @@ def _get_version() -> str:
         return "unknown"
 
 
-def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
-    metadata = e.metadata
+def _render_task_metadata_block(
+    metadata: model.TaskMetadata,
+    *,
+    indent: int = 0,
+    show_context_and_time: bool = True,
+) -> list[RenderableType]:
+    """Render a single TaskMetadata block.
 
+    Args:
+        metadata: The TaskMetadata to render.
+        indent: Number of spaces to indent (0 for main, 2 for sub-agents).
+        show_context_and_time: Whether to show context usage percent and time.
+
+    Returns:
+        List of renderables for this metadata block.
+    """
     # Get currency symbol
     currency = metadata.usage.currency if metadata.usage else "USD"
     currency_symbol = "¥" if currency == "CNY" else "$"
 
     # Line 1: Model and Provider
-    model_text = Text()
-    model_text.append_text(Text("- ", style=ThemeKey.METADATA_BOLD)).append_text(
-        Text(metadata.model_name, style=ThemeKey.METADATA_BOLD)
+    prefix = (
+        Text(" " * indent + "• ", style=ThemeKey.METADATA_BOLD)
+        if indent == 0
+        else Text(" " * indent + "└ ", style=ThemeKey.METADATA_DIM)
     )
+    model_text = Text()
+    model_text.append_text(prefix).append_text(Text(metadata.model_name, style=ThemeKey.METADATA_BOLD))
     if metadata.provider is not None:
         model_text.append_text(Text("@", style=ThemeKey.METADATA)).append_text(
             Text(metadata.provider.lower().replace(" ", "-"), style=ThemeKey.METADATA)
@@ -41,7 +57,7 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
     renderables: list[RenderableType] = [model_text]
 
     # Line 2: Token consumption, Context, TPS, Cost
-    parts: list[Text] = []
+    parts2: list[Text] = []
 
     if metadata.usage is not None:
         # Input
@@ -51,7 +67,7 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
         ]
         if metadata.usage.input_cost is not None:
             input_parts.append((f"({currency_symbol}{metadata.usage.input_cost:.4f})", ThemeKey.METADATA_DIM))
-        parts.append(Text.assemble(*input_parts))
+        parts2.append(Text.assemble(*input_parts))
 
         # Cached
         if metadata.usage.cached_tokens > 0:
@@ -61,7 +77,7 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
             ]
             if metadata.usage.cache_read_cost is not None:
                 cached_parts.append((f"({currency_symbol}{metadata.usage.cache_read_cost:.4f})", ThemeKey.METADATA_DIM))
-            parts.append(Text.assemble(*cached_parts))
+            parts2.append(Text.assemble(*cached_parts))
 
         # Output
         output_parts: list[tuple[str, str]] = [
@@ -70,11 +86,11 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
         ]
         if metadata.usage.output_cost is not None:
             output_parts.append((f"({currency_symbol}{metadata.usage.output_cost:.4f})", ThemeKey.METADATA_DIM))
-        parts.append(Text.assemble(*output_parts))
+        parts2.append(Text.assemble(*output_parts))
 
         # Reasoning
         if metadata.usage.reasoning_tokens > 0:
-            parts.append(
+            parts2.append(
                 Text.assemble(
                     ("thinking", ThemeKey.METADATA_DIM),
                     (":", ThemeKey.METADATA_DIM),
@@ -85,14 +101,30 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
                 )
             )
 
-        # Context
-        if metadata.usage.context_usage_percent is not None:
-            parts.append(
+    # Cost
+    if metadata.usage is not None and metadata.usage.total_cost is not None:
+        parts2.append(
+            Text.assemble(
+                ("cost", ThemeKey.METADATA_DIM),
+                (":", ThemeKey.METADATA_DIM),
+                (f"{currency_symbol}{metadata.usage.total_cost:.4f}", ThemeKey.METADATA_DIM),
+            )
+        )
+    if parts2:
+        line2 = Text(" / ", style=ThemeKey.METADATA_DIM).join(parts2)
+        renderables.append(Padding(line2, (0, 0, 0, indent + 2)))
+
+    parts3: list[Text] = []
+    if metadata.usage is not None:
+        # Context (only for main agent)
+        if show_context_and_time and metadata.usage.context_usage_percent is not None:
+            context_size = format_number(metadata.usage.context_window_size or 0)
+            parts3.append(
                 Text.assemble(
                     ("context", ThemeKey.METADATA_DIM),
                     (":", ThemeKey.METADATA_DIM),
                     (
-                        f"{metadata.usage.context_usage_percent:.1f}%",
+                        f"{context_size}({metadata.usage.context_usage_percent:.1f}%)",
                         ThemeKey.METADATA_DIM,
                     ),
                 )
@@ -100,7 +132,7 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
 
         # TPS
         if metadata.usage.throughput_tps is not None:
-            parts.append(
+            parts3.append(
                 Text.assemble(
                     ("tps", ThemeKey.METADATA_DIM),
                     (":", ThemeKey.METADATA_DIM),
@@ -109,8 +141,8 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
             )
 
     # Duration
-    if metadata.task_duration_s is not None:
-        parts.append(
+    if show_context_and_time and metadata.task_duration_s is not None:
+        parts3.append(
             Text.assemble(
                 ("time", ThemeKey.METADATA_DIM),
                 (":", ThemeKey.METADATA_DIM),
@@ -118,19 +150,25 @@ def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
             )
         )
 
-    # Cost
-    if metadata.usage is not None and metadata.usage.total_cost is not None:
-        parts.append(
-            Text.assemble(
-                ("cost", ThemeKey.METADATA_DIM),
-                (":", ThemeKey.METADATA_DIM),
-                (f"{currency_symbol}{metadata.usage.total_cost:.4f}", ThemeKey.METADATA_DIM),
-            )
-        )
+    if parts3:
+        line2 = Text(" / ", style=ThemeKey.METADATA_DIM).join(parts3)
+        renderables.append(Padding(line2, (0, 0, 0, indent + 2)))
+
+    return renderables
+
+
+def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
+    """Render task metadata including main agent and sub-agents, aggregated by model+provider."""
+    renderables: list[RenderableType] = []
+
+    renderables.extend(_render_task_metadata_block(e.metadata.main, indent=0, show_context_and_time=True))
+
+    # Aggregate by (model_name, provider), sorted by total_cost descending
+    sorted_items = model.TaskMetadata.aggregate_by_model(e.metadata.sub_agent_task_metadata)
 
-    if parts:
-        line2 = Text("/", style=ThemeKey.METADATA_DIM).join(parts)
-        renderables.append(Padding(line2, (0, 0, 0, 2)))
+    # Render each aggregated model block
+    for meta in sorted_items:
+        renderables.extend(_render_task_metadata_block(meta, indent=2, show_context_and_time=False))
 
     return Group(*renderables)