glaip-sdk 0.0.20__py3-none-any.whl → 0.7.7__py3-none-any.whl

glaip_sdk/utils/rendering/renderer/base.py

@@ -8,12 +8,11 @@ from __future__ import annotations
 
 import json
 import logging
-from dataclasses import dataclass, field
+import sys
 from datetime import datetime, timezone
 from time import monotonic
 from typing import Any
 
-from rich.align import Align
 from rich.console import Console as RichConsole
 from rich.console import Group
 from rich.live import Live
@@ -25,78 +24,57 @@ from glaip_sdk.icons import ICON_AGENT, ICON_AGENT_STEP, ICON_DELEGATE, ICON_TOO
 from glaip_sdk.rich_components import AIPPanel
 from glaip_sdk.utils.rendering.formatting import (
     format_main_title,
-    get_spinner_char,
     is_step_finished,
+    normalise_display_label,
 )
 from glaip_sdk.utils.rendering.models import RunStats, Step
-from glaip_sdk.utils.rendering.renderer.config import RendererConfig
-from glaip_sdk.utils.rendering.renderer.debug import render_debug_event
-from glaip_sdk.utils.rendering.renderer.panels import (
-    create_final_panel,
-    create_main_panel,
-    create_tool_panel,
-)
-from glaip_sdk.utils.rendering.renderer.progress import (
+from glaip_sdk.utils.rendering.layout.panels import create_main_panel
+from glaip_sdk.utils.rendering.layout.progress import (
+    build_progress_footer,
     format_elapsed_time,
-    format_tool_title,
     format_working_indicator,
-    get_spinner,
+    get_spinner_char,
     is_delegation_tool,
 )
+from glaip_sdk.utils.rendering.layout.summary import render_summary_panels
+from glaip_sdk.utils.rendering.layout.transcript import (
+    DEFAULT_TRANSCRIPT_THEME,
+    TranscriptSnapshot,
+    build_final_panel,
+    build_transcript_snapshot,
+    build_transcript_view,
+    extract_query_from_meta,
+    format_final_panel_title,
+)
+from glaip_sdk.utils.rendering.renderer.config import RendererConfig
+from glaip_sdk.utils.rendering.renderer.debug import render_debug_event
 from glaip_sdk.utils.rendering.renderer.stream import StreamProcessor
-from glaip_sdk.utils.rendering.steps import StepManager
+from glaip_sdk.utils.rendering.renderer.thinking import ThinkingScopeController
+from glaip_sdk.utils.rendering.renderer.tool_panels import ToolPanelController
+from glaip_sdk.utils.rendering.renderer.transcript_mode import TranscriptModeMixin
+from glaip_sdk.utils.rendering.state import (
+    RendererState,
+    TranscriptBuffer,
+    coerce_received_at,
+    truncate_display,
+)
+from glaip_sdk.utils.rendering.steps import (
+    StepManager,
+    format_step_label,
+)
+from glaip_sdk.utils.rendering.timing import coerce_server_time
+
+_NO_STEPS_TEXT = Text("No steps yet", style="dim")
 
 # Configure logger
 logger = logging.getLogger("glaip_sdk.run_renderer")
 
 # Constants
-LESS_THAN_1MS = "[<1ms]"
-
-
-def _coerce_received_at(value: Any) -> datetime | None:
-    """Coerce a received_at value to an aware datetime if possible."""
-    if value is None:
-        return None
-
-    if isinstance(value, datetime):
-        return value if value.tzinfo else value.replace(tzinfo=timezone.utc)
-
-    if isinstance(value, str):
-        try:
-            normalised = value.replace("Z", "+00:00")
-            dt = datetime.fromisoformat(normalised)
-        except ValueError:
-            return None
-        return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)
-
-    return None
+RUNNING_STATUS_HINTS = {"running", "started", "pending", "working"}
+ARGS_VALUE_MAX_LEN = 160
 
 
-@dataclass
-class RendererState:
-    """Internal state for the renderer."""
-
-    buffer: list[str] | None = None
-    final_text: str = ""
-    streaming_started_at: float | None = None
-    printed_final_output: bool = False
-    finalizing_ui: bool = False
-    final_duration_seconds: float | None = None
-    final_duration_text: str | None = None
-    events: list[dict[str, Any]] = field(default_factory=list)
-    meta: dict[str, Any] = field(default_factory=dict)
-    streaming_started_event_ts: datetime | None = None
-
-    def __post_init__(self) -> None:
-        """Initialize renderer state after dataclass creation.
-
-        Ensures buffer is initialized as an empty list if not provided.
-        """
-        if self.buffer is None:
-            self.buffer = []
-
-
-class RichStreamRenderer:
+class RichStreamRenderer(TranscriptModeMixin):
     """Live, modern terminal renderer for agent execution with rich visual output."""
 
     def __init__(
@@ -105,6 +83,8 @@ class RichStreamRenderer:
         *,
         cfg: RendererConfig | None = None,
         verbose: bool = False,
+        transcript_buffer: TranscriptBuffer | None = None,
+        callbacks: dict[str, Any] | None = None,
     ) -> None:
         """Initialize the renderer.
 
@@ -112,7 +92,10 @@ class RichStreamRenderer:
             console: Rich console instance
             cfg: Renderer configuration
             verbose: Whether to enable verbose mode
+            transcript_buffer: Optional transcript buffer for capturing output
+            callbacks: Optional dictionary of callback functions
         """
+        super().__init__()
         self.console = console or RichConsole()
         self.cfg = cfg or RendererConfig()
         self.verbose = verbose
@@ -120,19 +103,36 @@ class RichStreamRenderer:
         # Initialize components
         self.stream_processor = StreamProcessor()
         self.state = RendererState()
+        if transcript_buffer is not None:
+            self.state.buffer = transcript_buffer
+
+        self._callbacks = callbacks or {}
 
         # Initialize step manager and other state
-        self.steps = StepManager()
+        self.steps = StepManager(max_steps=self.cfg.summary_max_steps)
         # Live display instance (single source of truth)
         self.live: Live | None = None
+        self._step_spinners: dict[str, Spinner] = {}
+        self._last_steps_panel_template: Any | None = None
 
-        # Context and tool tracking
-        self.context_order: list[str] = []
-        self.context_parent: dict[str, str] = {}
-        self.tool_order: list[str] = []
-        self.context_panels: dict[str, list[str]] = {}
-        self.context_meta: dict[str, dict[str, Any]] = {}
-        self.tool_panels: dict[str, dict[str, Any]] = {}
+        # Tool tracking and thinking scopes
+        self._step_server_start_times: dict[str, float] = {}
+        self.tool_controller = ToolPanelController(
+            steps=self.steps,
+            stream_processor=self.stream_processor,
+            console=self.console,
+            cfg=self.cfg,
+            step_server_start_times=self._step_server_start_times,
+            output_prefix="**Output:**\n",
+        )
+        self.thinking_controller = ThinkingScopeController(
+            self.steps,
+            step_server_start_times=self._step_server_start_times,
+        )
+        self._root_agent_friendly: str | None = None
+        self._root_agent_step_id: str | None = None
+        self._root_query: str | None = None
+        self._root_query_attached: bool = False
 
         # Timing
         self._started_at: float | None = None
@@ -140,11 +140,12 @@ class RichStreamRenderer:
         # Header/text
         self.header_text: str = ""
         # Track per-step server start times for accurate elapsed labels
-        self._step_server_start_times: dict[str, float] = {}
-
         # Output formatting constants
         self.OUTPUT_PREFIX: str = "**Output:**\n"
 
+        self._final_transcript_snapshot: TranscriptSnapshot | None = None
+        self._final_transcript_renderables: tuple[list[Any], list[Any]] | None = None
+
     def on_start(self, meta: dict[str, Any]) -> None:
         """Handle renderer start event."""
         if self.cfg.live:
@@ -158,6 +159,20 @@ class RichStreamRenderer:
         except Exception:
             self.state.meta = dict(meta)
 
+        meta_payload = meta or {}
+        self.steps.set_root_agent(meta_payload.get("agent_id"))
+        self._root_agent_friendly = self._humanize_agent_slug(meta_payload.get("agent_name"))
+        self._root_query = truncate_display(
+            meta_payload.get("input_message")
+            or meta_payload.get("query")
+            or meta_payload.get("message")
+            or (meta_payload.get("meta") or {}).get("input_message")
+            or ""
+        )
+        if not self._root_query:
+            self._root_query = None
+        self._root_query_attached = False
+
         # Print compact header and user request (parity with old renderer)
         self._render_header(meta)
         self._render_user_query(meta)
@@ -207,24 +222,66 @@ class RichStreamRenderer:
         except Exception:
             logger.exception("Failed to print header fallback")
 
+    def _build_user_query_panel(self, query: str) -> AIPPanel:
+        """Create the panel used to display the user request."""
+        return AIPPanel(
+            Markdown(f"**Query:** {query}"),
+            title="User Request",
+            border_style="#d97706",
+            padding=(0, 1),
+        )
+
     def _render_user_query(self, meta: dict[str, Any]) -> None:
         """Render the user query panel."""
-        query = meta.get("input_message") or meta.get("query") or meta.get("message")
+        query = extract_query_from_meta(meta)
         if not query:
             return
+        self.console.print(self._build_user_query_panel(query))
+
+    def _render_summary_static_sections(self) -> None:
+        """Re-render header and user query when returning to summary mode."""
+        meta = getattr(self.state, "meta", None)
+        if meta:
+            self._render_header(meta)
+        elif self.header_text and not self._render_header_rule():
+            self._render_header_fallback()
 
-        self.console.print(
-            AIPPanel(
-                Markdown(f"**Query:** {query}"),
-                title="User Request",
-                border_style="#d97706",
-                padding=(0, 1),
-            )
-        )
+        query = extract_query_from_meta(meta) or self._root_query
+        if query:
+            self.console.print(self._build_user_query_panel(query))
+
+    def _render_summary_after_transcript_toggle(self) -> None:
+        """Render the summary panel after leaving transcript mode."""
+        if self.state.finalizing_ui:
+            self._render_final_summary_panels()
+        elif self.live:
+            self._refresh_live_panels()
+        else:
+            self._render_static_summary_panels()
+
+    def _render_final_summary_panels(self) -> None:
+        """Render a static summary and disable live mode for final output."""
+        self.cfg.live = False
+        self.live = None
+        self._render_static_summary_panels()
+
+    def _render_static_summary_panels(self) -> None:
+        """Render the steps and main panels in a static (non-live) layout."""
+        summary_window = self._summary_window_size()
+        window_arg = summary_window if summary_window > 0 else None
+        status_overrides = self._build_step_status_overrides()
+        for renderable in render_summary_panels(
+            self.state,
+            self.steps,
+            summary_window=window_arg,
+            include_query_panel=False,
+            step_status_overrides=status_overrides,
+        ):
+            self.console.print(renderable)
 
     def _ensure_streaming_started_baseline(self, timestamp: float) -> None:
         """Synchronize streaming start state across renderer components."""
-        self.state.streaming_started_at = timestamp
+        self.state.start_stream_timer(timestamp)
         self.stream_processor.streaming_started_at = timestamp
         self._started_at = timestamp
 
@@ -237,14 +294,16 @@ class RichStreamRenderer:
         self._sync_stream_start(ev, received_at)
 
         metadata = self.stream_processor.extract_event_metadata(ev)
-        self.stream_processor.update_timing(metadata["context_id"])
 
         self._maybe_render_debug(ev, received_at)
-        self._dispatch_event(ev, metadata)
+        try:
+            self._dispatch_event(ev, metadata)
+        finally:
+            self.stream_processor.update_timing(metadata.get("context_id"))
 
     def _resolve_received_timestamp(self, ev: dict[str, Any]) -> datetime:
         """Return the timestamp an event was received, normalising inputs."""
-        received_at = _coerce_received_at(ev.get("received_at"))
+        received_at = coerce_received_at(ev.get("received_at"))
         if received_at is None:
             received_at = datetime.now(timezone.utc)
 
@@ -253,9 +312,7 @@ class RichStreamRenderer:
 
         return received_at
 
-    def _sync_stream_start(
-        self, ev: dict[str, Any], received_at: datetime | None
-    ) -> None:
+    def _sync_stream_start(self, ev: dict[str, Any], received_at: datetime | None) -> None:
         """Ensure renderer and stream processor share a streaming baseline."""
         baseline = self.state.streaming_started_at
         if baseline is None:
@@ -275,12 +332,14 @@ class RichStreamRenderer:
         if not self.verbose:
             return
 
+        self._ensure_transcript_header()
         render_debug_event(
             ev,
             self.console,
             received_ts=received_at,
             baseline_ts=self.state.streaming_started_event_ts,
         )
+        self._print_transcript_hint()
 
     def _dispatch_event(self, ev: dict[str, Any], metadata: dict[str, Any]) -> None:
         """Route events to the appropriate renderer handlers."""
@@ -291,10 +350,13 @@ class RichStreamRenderer:
             self._handle_status_event(ev)
         elif kind == "content":
             self._handle_content_event(content)
+        elif kind == "token":
+            # Token events should stream content incrementally with immediate console output
+            self._handle_token_event(content)
         elif kind == "final_response":
             self._handle_final_response_event(content, metadata)
         elif kind in {"agent_step", "agent_thinking_step"}:
-            self._handle_agent_step_event(ev)
+            self._handle_agent_step_event(ev, metadata)
         else:
             self._ensure_live()
 
@@ -307,61 +369,170 @@ class RichStreamRenderer:
     def _handle_content_event(self, content: str) -> None:
         """Handle content streaming events."""
         if content:
-            self.state.buffer.append(content)
+            self.state.append_transcript_text(content)
             self._ensure_live()
 
-    def _handle_final_response_event(
-        self, content: str, metadata: dict[str, Any]
-    ) -> None:
+    def _handle_token_event(self, content: str) -> None:
+        """Handle token streaming events - print immediately for real-time streaming."""
+        if content:
+            self.state.append_transcript_text(content)
+            # Print token content directly to stdout for immediate visibility when not verbose
+            # This bypasses Rich's Live display which has refresh rate limitations
+            if not self.verbose:
+                try:
+                    # Mark that we're streaming tokens directly to prevent Live display from starting
+                    self._streaming_tokens_directly = True
+                    # Stop Live display if active to prevent it from intercepting stdout
+                    # and causing each token to appear on a new line
+                    if self.live is not None:
+                        self._stop_live_display()
+                    # Write directly to stdout - tokens will stream on the same line
+                    # since we're bypassing Rich's console which adds newlines
+                    sys.stdout.write(content)
+                    sys.stdout.flush()
+                except Exception:
+                    # Fallback to live display if direct write fails
+                    self._ensure_live()
+            else:
+                # In verbose mode, use normal live display (debug panels handle the output)
+                self._ensure_live()
+
+    def _handle_final_response_event(self, content: str, metadata: dict[str, Any]) -> None:
         """Handle final response events."""
         if content:
-            self.state.buffer.append(content)
-            self.state.final_text = content
+            self.state.append_transcript_text(content)
+            self.state.set_final_output(content)
 
             meta_payload = metadata.get("metadata") or {}
-            self._update_final_duration(meta_payload.get("time"))
+            final_time = coerce_server_time(meta_payload.get("time"))
+            self._update_final_duration(final_time)
+            self.thinking_controller.close_active_scopes(final_time)
+            self._finish_running_steps()
+            self.tool_controller.finish_all_panels()
+            self._normalise_finished_icons()
 
-            self._ensure_live()
-            self._print_final_panel_if_needed()
+        self._ensure_live()
+        self._print_final_panel_if_needed()
 
-    def _handle_agent_step_event(self, ev: dict[str, Any]) -> None:
+    def _normalise_finished_icons(self) -> None:
+        """Ensure finished steps release any running spinners."""
+        for step in self.steps.by_id.values():
+            if getattr(step, "status", None) != "running":
+                self._step_spinners.pop(step.step_id, None)
+
+    def _handle_agent_step_event(self, ev: dict[str, Any], metadata: dict[str, Any]) -> None:
         """Handle agent step events."""
-        # Extract tool information
-        (
+        # Extract tool information using stream processor
+        tool_calls_result = self.stream_processor.parse_tool_calls(ev)
+        tool_name, tool_args, tool_out, tool_calls_info = tool_calls_result
+
+        payload = metadata.get("metadata") or {}
+
+        tracked_step: Step | None = None
+        try:
+            tracked_step = self.steps.apply_event(ev)
+        except ValueError:
+            logger.debug("Malformed step event skipped", exc_info=True)
+        else:
+            self._record_step_server_start(tracked_step, payload)
+            self.thinking_controller.update_timeline(
+                tracked_step,
+                payload,
+                enabled=self.cfg.render_thinking,
+            )
+            self._maybe_override_root_agent_label(tracked_step, payload)
+            self._maybe_attach_root_query(tracked_step)
+
+        # Track tools and sub-agents for transcript/debug context
+        self.stream_processor.track_tools_and_agents(tool_name, tool_calls_info, is_delegation_tool)
+
+        # Handle tool execution
+        self.tool_controller.handle_agent_step(
+            ev,
             tool_name,
             tool_args,
             tool_out,
             tool_calls_info,
-        ) = self.stream_processor.parse_tool_calls(ev)
-
-        # Track tools and sub-agents
-        self.stream_processor.track_tools_and_agents(
-            tool_name, tool_calls_info, is_delegation_tool
+            tracked_step=tracked_step,
         )
 
-        # Handle tool execution
-        self._handle_agent_step(ev, tool_name, tool_args, tool_out, tool_calls_info)
-
         # Update live display
         self._ensure_live()
 
+    def _maybe_attach_root_query(self, step: Step | None) -> None:
+        """Attach the user query to the root agent step for display."""
+        if not step or self._root_query_attached or not self._root_query or step.kind != "agent" or step.parent_id:
+            return
+
+        args = dict(getattr(step, "args", {}) or {})
+        args.setdefault("query", self._root_query)
+        step.args = args
+        self._root_query_attached = True
+
+    def _record_step_server_start(self, step: Step | None, payload: dict[str, Any]) -> None:
+        """Store server-provided start times for elapsed calculations."""
+        if not step:
+            return
+        server_time = payload.get("time")
+        if not isinstance(server_time, (int, float)):
+            return
+        self._step_server_start_times.setdefault(step.step_id, float(server_time))
+
+    def _maybe_override_root_agent_label(self, step: Step | None, payload: dict[str, Any]) -> None:
+        """Ensure the root agent row uses the human-friendly name and shows the ID."""
+        if not step or step.kind != "agent" or step.parent_id:
+            return
+        friendly = self._root_agent_friendly or self._humanize_agent_slug((payload or {}).get("agent_name"))
+        if not friendly:
+            return
+        agent_identifier = step.name or step.step_id
+        if not agent_identifier:
+            return
+        step.display_label = normalise_display_label(f"{ICON_AGENT} {friendly} ({agent_identifier})")
+        if not self._root_agent_step_id:
+            self._root_agent_step_id = step.step_id
+
+    # Thinking scope management is handled by ThinkingScopeController.
+
+    def _apply_root_duration(self, duration_seconds: float | None) -> None:
+        """Propagate the final run duration to the root agent step."""
+        if duration_seconds is None or not self._root_agent_step_id:
+            return
+        root_step = self.steps.by_id.get(self._root_agent_step_id)
+        if not root_step:
+            return
+        try:
+            duration_ms = max(0, int(round(float(duration_seconds) * 1000)))
+        except Exception:
+            return
+        root_step.duration_ms = duration_ms
+        root_step.duration_source = root_step.duration_source or "run"
+        root_step.status = "finished"
+
+    @staticmethod
+    def _humanize_agent_slug(value: Any) -> str | None:
+        """Convert a slugified agent name into Title Case."""
+        if not isinstance(value, str):
+            return None
+        cleaned = value.replace("_", " ").replace("-", " ").strip()
+        if not cleaned:
+            return None
+        parts = [part for part in cleaned.split() if part]
+        return " ".join(part[:1].upper() + part[1:] for part in parts)
+
     def _finish_running_steps(self) -> None:
         """Mark any running steps as finished to avoid lingering spinners."""
         for st in self.steps.by_id.values():
             if not is_step_finished(st):
-                st.finish(None)
+                self._mark_incomplete_step(st)
 
-    def _finish_tool_panels(self) -> None:
-        """Mark unfinished tool panels as finished."""
-        try:
-            items = list(self.tool_panels.items())
-        except Exception:  # pragma: no cover - defensive guard
-            logger.exception("Failed to iterate tool panels during cleanup")
-            return
-
-        for _sid, meta in items:
-            if meta.get("status") != "finished":
-                meta["status"] = "finished"
+    def _mark_incomplete_step(self, step: Step) -> None:
+        """Mark a lingering step as incomplete/warning with unknown duration."""
+        step.status = "finished"
+        step.duration_unknown = True
+        if step.duration_ms is None:
+            step.duration_ms = 0
+        step.duration_source = step.duration_source or "unknown"
 
     def _stop_live_display(self) -> None:
         """Stop live display and clean up."""
@@ -372,53 +543,150 @@ class RichStreamRenderer:
         if self.state.printed_final_output:
             return
 
-        body = (self.state.final_text or "".join(self.state.buffer) or "").strip()
+        body = (self.state.final_text or self.state.buffer.render() or "").strip()
         if not body:
             return
 
+        if getattr(self, "_transcript_mode_enabled", False):
+            return
+
+        # When verbose=False and tokens were streamed directly, skip final panel
+        # The user's script will print the final result, avoiding duplication
+        if not self.verbose and getattr(self, "_streaming_tokens_directly", False):
+            # Add a newline after streaming tokens for clean separation
+            try:
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+            except Exception:
+                pass
+            self.state.printed_final_output = True
+            return
+
         if self.verbose:
-            final_panel = create_final_panel(
-                body,
+            panel = build_final_panel(
+                self.state,
                 title=self._final_panel_title(),
-                theme=self.cfg.theme,
             )
-            self.console.print(final_panel)
+            if panel is None:
+                return
+            self.console.print(panel)
             self.state.printed_final_output = True
 
+    def finalize(self) -> tuple[list[Any], list[Any]]:
+        """Compose the final transcript renderables."""
+        return self._compose_final_transcript()
+
+    def _compose_final_transcript(self) -> tuple[list[Any], list[Any]]:
+        """Build the transcript snapshot used for final summaries."""
+        summary_window = self._summary_window_size()
+        summary_window = summary_window if summary_window > 0 else None
+        snapshot = build_transcript_snapshot(
+            self.state,
+            self.steps,
+            query_text=extract_query_from_meta(self.state.meta),
+            meta=self.state.meta,
+            summary_window=summary_window,
+            step_status_overrides=self._build_step_status_overrides(),
+        )
+        header, body = build_transcript_view(snapshot)
+        self._final_transcript_snapshot = snapshot
+        self._final_transcript_renderables = (header, body)
+        return header, body
+
+    def _render_final_summary(self, header: list[Any], body: list[Any]) -> None:
+        """Print the composed transcript summary for non-live renders."""
+        renderables = list(header) + list(body)
+        for renderable in renderables:
+            try:
+                self.console.print(renderable)
+                self.console.print()
+            except Exception:
+                pass
+
     def on_complete(self, stats: RunStats) -> None:
         """Handle completion event."""
         self.state.finalizing_ui = True
 
-        if isinstance(stats, RunStats):
+        self._handle_stats_duration(stats)
+        self.thinking_controller.close_active_scopes(self.state.final_duration_seconds)
+        self._cleanup_ui_elements()
+        self._finalize_display()
+        self._print_completion_message()
+
+    def _handle_stats_duration(self, stats: RunStats) -> None:
+        """Handle stats processing and duration calculation."""
+        if not isinstance(stats, RunStats):
+            return
+
+        duration = None
+        try:
+            if stats.finished_at is not None and stats.started_at is not None:
+                duration = max(0.0, float(stats.finished_at) - float(stats.started_at))
+        except Exception:
             duration = None
-            try:
-                if stats.finished_at is not None and stats.started_at is not None:
-                    duration = max(
-                        0.0, float(stats.finished_at) - float(stats.started_at)
-                    )
-            except Exception:
-                duration = None
 
-            if duration is not None:
-                self._update_final_duration(duration, overwrite=True)
+        if duration is not None:
+            self._update_final_duration(duration, overwrite=True)
 
+    def _cleanup_ui_elements(self) -> None:
+        """Clean up running UI elements."""
         # Mark any running steps as finished to avoid lingering spinners
         self._finish_running_steps()
 
         # Mark unfinished tool panels as finished
-        self._finish_tool_panels()
+        self.tool_controller.finish_all_panels()
+
+    def _finalize_display(self) -> None:
+        """Finalize live display and render final output."""
+        # When verbose=False and tokens were streamed directly, skip live display updates
+        # to avoid showing duplicate final result
+        if not self.verbose and getattr(self, "_streaming_tokens_directly", False):
+            # Just add a newline after streaming tokens for clean separation
+            try:
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+            except Exception:
+                pass
+            self._stop_live_display()
+            self.state.printed_final_output = True
+            return
 
         # Final refresh
         self._ensure_live()
 
+        header, body = self.finalize()
+
         # Stop live display
         self._stop_live_display()
 
         # Render final output based on configuration
-        self._print_final_panel_if_needed()
+        if self.cfg.live:
+            self._print_final_panel_if_needed()
+        else:
+            self._render_final_summary(header, body)
+
+    def _print_completion_message(self) -> None:
+        """Print completion message based on current mode."""
+        if self._transcript_mode_enabled:
+            try:
+                self.console.print(
+                    "[dim]Run finished. Press Ctrl+T to return to the summary view or stay here to inspect events. "
+                    "Use the post-run viewer for export.[/dim]"
+                )
+            except Exception:
+                pass
+        else:
+            # No transcript toggle in summary mode; nothing to print here.
+            return
 
     def _ensure_live(self) -> None:
         """Ensure live display is updated."""
+        if getattr(self, "_transcript_mode_enabled", False):
+            return
+        # When verbose=False, don't start Live display if we're streaming tokens directly
+        # This prevents Live from intercepting stdout and causing tokens to appear on separate lines
+        if not self.verbose and getattr(self, "_streaming_tokens_directly", False):
+            return
         if not self._ensure_live_stack():
             return
 
@@ -426,6 +694,12 @@ class RichStreamRenderer:
 
         if self.live:
             self._refresh_live_panels()
+            if (
+                not self._transcript_mode_enabled
+                and not self.state.finalizing_ui
+                and not self._summary_hint_printed_once
+            ):
+                self._print_summary_hint(force=True)
 
     def _ensure_live_stack(self) -> bool:
         """Guarantee the console exposes the internal live stack Rich expects."""
@@ -465,15 +739,19 @@ class RichStreamRenderer:
         if not self.live:
             return
 
-        main_panel = self._render_main_panel()
-        steps_renderable = self._render_steps_text()
+        steps_body = self._render_steps_text()
+        template_panel = getattr(self, "_last_steps_panel_template", None)
+        if template_panel is None:
+            template_panel = self._resolve_steps_panel()
         steps_panel = AIPPanel(
-            steps_renderable,
-            title="Steps",
-            border_style="blue",
+            steps_body,
+            title=getattr(template_panel, "title", "Steps"),
+            border_style=getattr(template_panel, "border_style", "blue"),
+            padding=getattr(template_panel, "padding", (0, 1)),
         )
-        tool_panels = self._render_tool_panels()
-        panels = self._build_live_panels(main_panel, steps_panel, tool_panels)
+
+        main_panel = self._render_main_panel()
+        panels = self._build_live_panels(main_panel, steps_panel)
 
         self.live.update(Group(*panels))
 
@@ -481,40 +759,28 @@ class RichStreamRenderer:
         self,
         main_panel: Any,
         steps_panel: Any,
-        tool_panels: list[Any],
     ) -> list[Any]:
         """Assemble the panel order for the live display."""
         if self.verbose:
-            return [main_panel, steps_panel, *tool_panels]
+            return [main_panel, steps_panel]
 
-        panels: list[Any] = [steps_panel]
-        if tool_panels:
-            panels.extend(tool_panels)
-        panels.append(main_panel)
-        return panels
+        return [steps_panel, main_panel]
 
     def _render_main_panel(self) -> Any:
         """Render the main content panel."""
-        body = "".join(self.state.buffer).strip()
+        body = self.state.buffer.render().strip()
+        theme = DEFAULT_TRANSCRIPT_THEME
         if not self.verbose:
-            final_content = (self.state.final_text or "").strip()
-            if final_content:
-                title = self._final_panel_title()
-                return create_final_panel(
-                    final_content,
-                    title=title,
-                    theme=self.cfg.theme,
-                )
+            panel = build_final_panel(self.state, theme=theme)
+            if panel is not None:
+                return panel
         # Dynamic title with spinner + elapsed/hints
         title = self._format_enhanced_main_title()
-        return create_main_panel(body, title, self.cfg.theme)
+        return create_main_panel(body, title, theme)
 
     def _final_panel_title(self) -> str:
         """Compose title for the final result panel including duration."""
-        title = "Final Result"
-        if self.state.final_duration_text:
-            title = f"{title} · {self.state.final_duration_text}"
-        return title
+        return format_final_panel_title(self.state)
 
     def apply_verbosity(self, verbose: bool) -> None:
         """Update verbose behaviour at runtime."""
@@ -522,8 +788,6 @@ class RichStreamRenderer:
             return
 
         self.verbose = verbose
-        self.cfg.style = "debug" if verbose else "pretty"
-
         desired_live = not verbose
         if desired_live != self.cfg.live:
             self.cfg.live = desired_live
@@ -535,459 +799,16 @@ class RichStreamRenderer:
         if self.cfg.live:
             self._ensure_live()
 
-    # ------------------------------------------------------------------
-    # Transcript helpers
-    # ------------------------------------------------------------------
-    def _capture_event(
-        self, ev: dict[str, Any], received_at: datetime | None = None
-    ) -> None:
-        """Capture a deep copy of SSE events for transcript replay."""
-        try:
-            captured = json.loads(json.dumps(ev))
-        except Exception:
-            captured = ev
-
-        if received_at is not None:
-            try:
-                captured["received_at"] = received_at.isoformat()
-            except Exception:
-                try:
-                    captured["received_at"] = str(received_at)
-                except Exception:
-                    captured["received_at"] = repr(received_at)
-
-        self.state.events.append(captured)
+    # Transcript helper implementations live in TranscriptModeMixin.
 
     def get_aggregated_output(self) -> str:
         """Return the concatenated assistant output collected so far."""
-        return ("".join(self.state.buffer or [])).strip()
+        return self.state.buffer.render().strip()
 
     def get_transcript_events(self) -> list[dict[str, Any]]:
         """Return captured SSE events."""
         return list(self.state.events)
 
-    def _maybe_insert_thinking_gap(
-        self, task_id: str | None, context_id: str | None
-    ) -> None:
-        """Insert thinking gap if needed."""
-        # Implementation would track thinking states
-        pass
-
-    def _ensure_tool_panel(
-        self, name: str, args: Any, task_id: str, context_id: str
-    ) -> str:
-        """Ensure a tool panel exists and return its ID."""
-        formatted_title = format_tool_title(name)
-        is_delegation = is_delegation_tool(name)
-        tool_sid = f"tool_{name}_{task_id}_{context_id}"
-
-        if tool_sid not in self.tool_panels:
-            self.tool_panels[tool_sid] = {
-                "title": formatted_title,
-                "status": "running",
-                "started_at": monotonic(),
-                "server_started_at": self.stream_processor.server_elapsed_time,
-                "chunks": [],
-                "args": args or {},
-                "output": None,
-                "is_delegation": is_delegation,
-            }
-            # Add Args section once
-            if args:
-                try:
-                    args_content = (
-                        "**Args:**\n```json\n"
-                        + json.dumps(args, indent=2)
-                        + "\n```\n\n"
-                    )
-                except Exception:
-                    args_content = f"**Args:**\n{args}\n\n"
-                self.tool_panels[tool_sid]["chunks"].append(args_content)
-            self.tool_order.append(tool_sid)
-
-        return tool_sid
-
-    def _start_tool_step(
-        self,
-        task_id: str,
-        context_id: str,
-        tool_name: str,
-        tool_args: Any,
-        _tool_sid: str,
-    ) -> Step | None:
-        """Start or get a step for a tool."""
-        if is_delegation_tool(tool_name):
-            st = self.steps.start_or_get(
-                task_id=task_id,
-                context_id=context_id,
-                kind="delegate",
-                name=tool_name,
-                args=tool_args,
-            )
-        else:
-            st = self.steps.start_or_get(
-                task_id=task_id,
-                context_id=context_id,
-                kind="tool",
-                name=tool_name,
-                args=tool_args,
-            )
-
-        # Record server start time for this step if available
-        if st and self.stream_processor.server_elapsed_time is not None:
-            self._step_server_start_times[st.step_id] = (
-                self.stream_processor.server_elapsed_time
-            )
-
-        return st
-
-    def _process_additional_tool_calls(
-        self,
-        tool_calls_info: list[tuple[str, Any, Any]],
-        tool_name: str,
-        task_id: str,
-        context_id: str,
-    ) -> None:
-        """Process additional tool calls to avoid duplicates."""
-        for call_name, call_args, _ in tool_calls_info or []:
-            if call_name and call_name != tool_name:
-                self._process_single_tool_call(
-                    call_name, call_args, task_id, context_id
-                )
-
-    def _process_single_tool_call(
-        self, call_name: str, call_args: Any, task_id: str, context_id: str
-    ) -> None:
-        """Process a single additional tool call."""
-        self._ensure_tool_panel(call_name, call_args, task_id, context_id)
-
-        st2 = self._create_step_for_tool_call(call_name, call_args, task_id, context_id)
-
-        if self.stream_processor.server_elapsed_time is not None and st2:
-            self._step_server_start_times[st2.step_id] = (
-                self.stream_processor.server_elapsed_time
-            )
-
-    def _create_step_for_tool_call(
-        self, call_name: str, call_args: Any, task_id: str, context_id: str
-    ) -> Any:
-        """Create appropriate step for tool call."""
-        if is_delegation_tool(call_name):
-            return self.steps.start_or_get(
-                task_id=task_id,
-                context_id=context_id,
-                kind="delegate",
-                name=call_name,
-                args=call_args,
-            )
-        else:
-            return self.steps.start_or_get(
-                task_id=task_id,
-                context_id=context_id,
-                kind="tool",
-                name=call_name,
-                args=call_args,
-            )
-
-    def _detect_tool_completion(
-        self, metadata: dict, content: str
-    ) -> tuple[bool, str | None, Any]:
-        """Detect if a tool has completed and return completion info."""
-        tool_info = metadata.get("tool_info", {}) if isinstance(metadata, dict) else {}
-
-        if tool_info.get("status") == "finished" and tool_info.get("name"):
-            return True, tool_info.get("name"), tool_info.get("output")
-        elif content and isinstance(content, str) and content.startswith("Completed "):
-            # content like "Completed google_serper"
-            tname = content.replace("Completed ", "").strip()
-            if tname:
-                output = (
-                    tool_info.get("output") if tool_info.get("name") == tname else None
-                )
-                return True, tname, output
-        elif metadata.get("status") == "finished" and tool_info.get("name"):
-            return True, tool_info.get("name"), tool_info.get("output")
-
-        return False, None, None
-
-    def _get_tool_session_id(
-        self, finished_tool_name: str, task_id: str, context_id: str
-    ) -> str:
-        """Generate tool session ID."""
-        return f"tool_{finished_tool_name}_{task_id}_{context_id}"
-
-    def _calculate_tool_duration(self, meta: dict[str, Any]) -> float | None:
-        """Calculate tool duration from metadata."""
-        server_now = self.stream_processor.server_elapsed_time
-        server_start = meta.get("server_started_at")
-        dur = None
-
-        try:
-            if isinstance(server_now, (int, float)) and server_start is not None:
-                dur = max(0.0, float(server_now) - float(server_start))
-            else:
-                started_at = meta.get("started_at")
-                if started_at is not None:
-                    started_at_float = float(started_at)
-                    dur = max(0.0, float(monotonic()) - started_at_float)
-        except (TypeError, ValueError):
-            logger.exception("Failed to calculate tool duration")
-            return None
-
-        return dur
-
-    def _update_tool_metadata(self, meta: dict[str, Any], dur: float | None) -> None:
-        """Update tool metadata with duration information."""
-        if dur is not None:
-            meta["duration_seconds"] = dur
-            meta["server_finished_at"] = (
-                self.stream_processor.server_elapsed_time
-                if isinstance(self.stream_processor.server_elapsed_time, int | float)
-                else None
-            )
-            meta["finished_at"] = monotonic()
-
-    def _add_tool_output_to_panel(
-        self, meta: dict[str, Any], finished_tool_output: Any, finished_tool_name: str
-    ) -> None:
-        """Add tool output to panel metadata."""
-        if finished_tool_output is not None:
-            meta["chunks"].append(
-                self._format_output_block(finished_tool_output, finished_tool_name)
-            )
-            meta["output"] = finished_tool_output
-
-    def _mark_panel_as_finished(self, meta: dict[str, Any], tool_sid: str) -> None:
-        """Mark panel as finished and ensure visibility."""
-        if meta.get("status") != "finished":
-            meta["status"] = "finished"
-
-            dur = self._calculate_tool_duration(meta)
-            self._update_tool_metadata(meta, dur)
-
-        # Ensure this finished panel is visible in this frame
-        self.stream_processor.current_event_finished_panels.add(tool_sid)
-
-    def _finish_tool_panel(
-        self,
-        finished_tool_name: str,
-        finished_tool_output: Any,
-        task_id: str,
-        context_id: str,
-    ) -> None:
-        """Finish a tool panel and update its status."""
-        tool_sid = self._get_tool_session_id(finished_tool_name, task_id, context_id)
-        if tool_sid not in self.tool_panels:
-            return
-
-        meta = self.tool_panels[tool_sid]
-        self._mark_panel_as_finished(meta, tool_sid)
-        self._add_tool_output_to_panel(meta, finished_tool_output, finished_tool_name)
-
-    def _get_step_duration(
-        self, finished_tool_name: str, task_id: str, context_id: str
-    ) -> float | None:
-        """Get step duration from tool panels."""
-        tool_sid = f"tool_{finished_tool_name}_{task_id}_{context_id}"
-        return self.tool_panels.get(tool_sid, {}).get("duration_seconds")
-
-    def _finish_delegation_step(
-        self,
-        finished_tool_name: str,
-        finished_tool_output: Any,
-        task_id: str,
-        context_id: str,
-        step_duration: float | None,
-    ) -> None:
-        """Finish a delegation step."""
-        self.steps.finish(
-            task_id=task_id,
-            context_id=context_id,
-            kind="delegate",
-            name=finished_tool_name,
-            output=finished_tool_output,
-            duration_raw=step_duration,
-        )
-
-    def _finish_tool_step_type(
-        self,
-        finished_tool_name: str,
-        finished_tool_output: Any,
-        task_id: str,
-        context_id: str,
-        step_duration: float | None,
-    ) -> None:
-        """Finish a regular tool step."""
-        self.steps.finish(
-            task_id=task_id,
-            context_id=context_id,
-            kind="tool",
-            name=finished_tool_name,
-            output=finished_tool_output,
-            duration_raw=step_duration,
-        )
-
-    def _finish_tool_step(
-        self,
-        finished_tool_name: str,
-        finished_tool_output: Any,
-        task_id: str,
-        context_id: str,
-    ) -> None:
-        """Finish the corresponding step for a completed tool."""
-        step_duration = self._get_step_duration(finished_tool_name, task_id, context_id)
-
-        if is_delegation_tool(finished_tool_name):
-            self._finish_delegation_step(
-                finished_tool_name,
-                finished_tool_output,
-                task_id,
-                context_id,
-                step_duration,
-            )
-        else:
-            self._finish_tool_step_type(
-                finished_tool_name,
-                finished_tool_output,
-                task_id,
-                context_id,
-                step_duration,
-            )
-
-    def _should_create_snapshot(self, tool_sid: str) -> bool:
-        """Check if a snapshot should be created."""
-        return self.cfg.append_finished_snapshots and not self.tool_panels.get(
-            tool_sid, {}
-        ).get("snapshot_printed")
-
-    def _get_snapshot_title(self, meta: dict[str, Any], finished_tool_name: str) -> str:
-        """Get the title for the snapshot."""
-        adjusted_title = meta.get("title") or finished_tool_name
-
-        # Add elapsed time to title
-        dur = meta.get("duration_seconds")
-        if isinstance(dur, int | float):
-            elapsed_str = self._format_snapshot_duration(dur)
-            adjusted_title = f"{adjusted_title}  · {elapsed_str}"
-
-        return adjusted_title
-
-    def _format_snapshot_duration(self, dur: int | float) -> str:
-        """Format duration for snapshot title."""
-        try:
-            # Handle invalid types
-            if not isinstance(dur, (int, float)):
-                return "<1ms"
-
-            if dur >= 1:
-                return f"{dur:.2f}s"
-            elif int(dur * 1000) > 0:
-                return f"{int(dur * 1000)}ms"
-            else:
-                return "<1ms"
-        except (TypeError, ValueError, OverflowError):
-            return "<1ms"
-
-    def _clamp_snapshot_body(self, body_text: str) -> str:
-        """Clamp snapshot body to configured limits."""
-        max_lines = int(self.cfg.snapshot_max_lines or 0)
-        lines = body_text.splitlines()
-        if max_lines > 0 and len(lines) > max_lines:
-            lines = lines[:max_lines] + ["… (truncated)"]
-            body_text = "\n".join(lines)
-
-        max_chars = int(self.cfg.snapshot_max_chars or 0)
-        if max_chars > 0 and len(body_text) > max_chars:
-            suffix = "\n… (truncated)"
-            body_text = body_text[: max_chars - len(suffix)] + suffix
-
-        return body_text
-
-    def _create_snapshot_panel(
-        self, adjusted_title: str, body_text: str, finished_tool_name: str
-    ) -> Any:
-        """Create the snapshot panel."""
-        return create_tool_panel(
-            title=adjusted_title,
-            content=body_text or "(no output)",
-            status="finished",
-            theme=self.cfg.theme,
-            is_delegation=is_delegation_tool(finished_tool_name),
-        )
-
-    def _print_and_mark_snapshot(self, tool_sid: str, snapshot_panel: Any) -> None:
-        """Print snapshot and mark as printed."""
-        self.console.print(snapshot_panel)
-        self.tool_panels[tool_sid]["snapshot_printed"] = True
-
-    def _create_tool_snapshot(
-        self, finished_tool_name: str, task_id: str, context_id: str
-    ) -> None:
-        """Create and print a snapshot for a finished tool."""
-        tool_sid = f"tool_{finished_tool_name}_{task_id}_{context_id}"
-
-        if not self._should_create_snapshot(tool_sid):
-            return
-
-        meta = self.tool_panels[tool_sid]
-        adjusted_title = self._get_snapshot_title(meta, finished_tool_name)
-
-        # Compose body from chunks and clamp
-        body_text = "".join(meta.get("chunks") or [])
-        body_text = self._clamp_snapshot_body(body_text)
-
-        snapshot_panel = self._create_snapshot_panel(
-            adjusted_title, body_text, finished_tool_name
-        )
-
-        self._print_and_mark_snapshot(tool_sid, snapshot_panel)
-
-    def _handle_agent_step(
-        self,
-        event: dict[str, Any],
-        tool_name: str | None,
-        tool_args: Any,
-        _tool_out: Any,
-        tool_calls_info: list[tuple[str, Any, Any]],
-    ) -> None:
-        """Handle agent step event."""
-        metadata = event.get("metadata", {})
-        task_id = event.get("task_id")
-        context_id = event.get("context_id")
-        content = event.get("content", "")
-
-        # Create steps and panels for the primary tool
-        if tool_name:
-            tool_sid = self._ensure_tool_panel(
-                tool_name, tool_args, task_id, context_id
-            )
-            self._start_tool_step(task_id, context_id, tool_name, tool_args, tool_sid)
-
-        # Handle additional tool calls
-        self._process_additional_tool_calls(
-            tool_calls_info, tool_name, task_id, context_id
-        )
-
-        # Check for tool completion
-        (
-            is_tool_finished,
-            finished_tool_name,
-            finished_tool_output,
-        ) = self._detect_tool_completion(metadata, content)
-
-        if is_tool_finished and finished_tool_name:
-            self._finish_tool_panel(
-                finished_tool_name, finished_tool_output, task_id, context_id
-            )
-            self._finish_tool_step(
-                finished_tool_name, finished_tool_output, task_id, context_id
-            )
-            self._create_tool_snapshot(finished_tool_name, task_id, context_id)
-
-    def _spinner(self) -> str:
-        """Return spinner character."""
-        return get_spinner()
-
     def _format_working_indicator(self, started_at: float | None) -> str:
         """Format working indicator."""
         return format_working_indicator(
@@ -1030,9 +851,7 @@ class RichStreamRenderer:
 
     def _get_analysis_progress_info(self) -> dict[str, Any]:
         total_steps = len(self.steps.order)
-        completed_steps = sum(
-            1 for sid in self.steps.order if is_step_finished(self.steps.by_id[sid])
-        )
+        completed_steps = sum(1 for sid in self.steps.order if is_step_finished(self.steps.by_id[sid]))
         current_step = None
         for sid in self.steps.order:
             if not is_step_finished(self.steps.by_id[sid]):
@@ -1040,13 +859,11 @@ class RichStreamRenderer:
                 break
         # Prefer server elapsed time when available
         elapsed = 0.0
-        if isinstance(self.stream_processor.server_elapsed_time, int | float):
+        if isinstance(self.stream_processor.server_elapsed_time, (int, float)):
             elapsed = float(self.stream_processor.server_elapsed_time)
         elif self._started_at is not None:
             elapsed = monotonic() - self._started_at
-        progress_percent = (
-            int((completed_steps / total_steps) * 100) if total_steps else 0
-        )
+        progress_percent = int((completed_steps / total_steps) * 100) if total_steps else 0
         return {
             "total_steps": total_steps,
             "completed_steps": completed_steps,
@@ -1100,29 +917,42 @@ class RichStreamRenderer:
     def _format_step_status(self, step: Step) -> str:
         """Format step status with elapsed time or duration."""
         if is_step_finished(step):
-            if step.duration_ms is None:
-                return LESS_THAN_1MS
-            elif step.duration_ms >= 1000:
-                return f"[{step.duration_ms / 1000:.2f}s]"
-            elif step.duration_ms > 0:
-                return f"[{step.duration_ms}ms]"
-            return LESS_THAN_1MS
+            return self._format_finished_badge(step)
         else:
             # Calculate elapsed time for running steps
             elapsed = self._calculate_step_elapsed_time(step)
-            if elapsed >= 1:
+            if elapsed >= 0.1:
                 return f"[{elapsed:.2f}s]"
-            ms = int(elapsed * 1000)
-            return f"[{ms}ms]" if ms > 0 else LESS_THAN_1MS
+            ms = int(round(elapsed * 1000))
+            if ms <= 0:
+                return ""
+            return f"[{ms}ms]"
+
+    def _format_finished_badge(self, step: Step) -> str:
+        """Compose duration badge for finished steps including source tagging."""
+        if getattr(step, "duration_unknown", False) is True:
+            payload = "??s"
+        else:
+            duration_ms = step.duration_ms
+            if duration_ms is None:
+                payload = "<1ms"
+            elif duration_ms < 0:
+                payload = "<1ms"
+            elif duration_ms >= 100:
+                payload = f"{duration_ms / 1000:.2f}s"
+            elif duration_ms > 0:
+                payload = f"{duration_ms}ms"
+            else:
+                payload = "<1ms"
+
+        return f"[{payload}]"
 
     def _calculate_step_elapsed_time(self, step: Step) -> float:
         """Calculate elapsed time for a running step."""
         server_elapsed = self.stream_processor.server_elapsed_time
         server_start = self._step_server_start_times.get(step.step_id)
 
-        if isinstance(server_elapsed, int | float) and isinstance(
-            server_start, int | float
-        ):
+        if isinstance(server_elapsed, (int, float)) and isinstance(server_start, (int, float)):
             return max(0.0, float(server_elapsed) - float(server_start))
 
         try:
@@ -1136,6 +966,10 @@ class RichStreamRenderer:
             return step.name
         return "thinking..." if step.kind == "agent" else f"{step.kind} step"
 
+    def _resolve_step_label(self, step: Step) -> str:
+        """Return the display label for a step with sensible fallbacks."""
+        return format_step_label(step)
+
     def _check_parallel_tools(self) -> dict[tuple[str | None, str | None], list]:
         """Check for parallel running tools."""
         running_by_ctx: dict[tuple[str | None, str | None], list] = {}
@@ -1155,72 +989,77 @@ class RichStreamRenderer:
         key = (step.task_id, step.context_id)
         return len(running_by_ctx.get(key, [])) > 1
 
-    def _compose_step_renderable(
-        self,
-        step: Step,
-        running_by_ctx: dict[tuple[str | None, str | None], list],
-    ) -> Any:
-        """Compose a single renderable for the steps panel."""
-        finished = is_step_finished(step)
-        status_br = self._format_step_status(step)
-        display_name = self._get_step_display_name(step)
-
-        if (
-            not finished
-            and step.kind == "tool"
-            and self._is_parallel_tool(step, running_by_ctx)
-        ):
-            status_br = status_br.replace("]", " 🔄]")
-
-        icon = self._get_step_icon(step.kind)
-        text_line = Text(style="dim")
-        text_line.append(icon)
-        text_line.append(" ")
-        text_line.append(display_name)
-        if status_br:
-            text_line.append(" ")
-            text_line.append(status_br)
-        if finished:
-            text_line.append(" ✓")
-
-        if finished:
-            return text_line
-
-        spinner = Spinner("dots", text=text_line, style="dim")
-        return Align.left(spinner)
-
-    def _render_steps_text(self) -> Any:
-        """Render the steps panel content."""
-        if not (self.steps.order or self.steps.children):
-            return Text("No steps yet", style="dim")
-
-        running_by_ctx = self._check_parallel_tools()
-        renderables: list[Any] = []
+    def _build_step_status_overrides(self) -> dict[str, str]:
+        """Return status text overrides for steps (running duration badges)."""
+        overrides: dict[str, str] = {}
         for sid in self.steps.order:
-            line = self._compose_step_renderable(self.steps.by_id[sid], running_by_ctx)
-            renderables.append(line)
-
-        if not renderables:
-            return Text("No steps yet", style="dim")
-
-        return Group(*renderables)
-
-    def _should_skip_finished_panel(self, sid: str, status: str) -> bool:
-        """Check if a finished panel should be skipped."""
-        if status != "finished":
-            return False
+            step = self.steps.by_id.get(sid)
+            if not step:
+                continue
+            try:
+                status_text = self._format_step_status(step)
+            except Exception:
+                status_text = ""
+            if status_text:
+                overrides[sid] = status_text
+        return overrides
+
+    def _resolve_steps_panel(self) -> AIPPanel:
+        """Return the shared steps panel renderable generated by layout helpers."""
+        window_arg = self._summary_window_size()
+        window_arg = window_arg if window_arg > 0 else None
+        panels = render_summary_panels(
+            self.state,
+            self.steps,
+            summary_window=window_arg,
+            include_query_panel=False,
+            include_final_panel=False,
+            step_status_overrides=self._build_step_status_overrides(),
+        )
+        steps_panel = next((panel for panel in panels if getattr(panel, "title", "").lower() == "steps"), None)
+        panel_cls = AIPPanel if isinstance(AIPPanel, type) else None
+        if steps_panel is not None and (panel_cls is None or isinstance(steps_panel, panel_cls)):
+            return steps_panel
+        return AIPPanel(_NO_STEPS_TEXT.copy(), title="Steps", border_style="blue")
+
+    def _prepare_steps_renderable(self, *, include_progress: bool) -> tuple[AIPPanel, Any]:
+        """Return the template panel and content renderable for steps."""
+        panel = self._resolve_steps_panel()
+        self._last_steps_panel_template = panel
+        base_renderable: Any = getattr(panel, "renderable", panel)
+
+        if include_progress and not self.state.finalizing_ui:
+            footer = build_progress_footer(
+                state=self.state,
+                steps=self.steps,
+                started_at=self._started_at,
+                server_elapsed_time=self.stream_processor.server_elapsed_time,
+            )
+            if footer is not None:
+                if isinstance(base_renderable, Group):
+                    base_renderable = Group(*base_renderable.renderables, footer)
+                else:
+                    base_renderable = Group(base_renderable, footer)
+        return panel, base_renderable
+
+    def _build_steps_body(self, *, include_progress: bool) -> Any:
+        """Return the rendered steps body with optional progress footer."""
+        _, renderable = self._prepare_steps_renderable(include_progress=include_progress)
+        if isinstance(renderable, Group):
+            return renderable
+        return Group(renderable)
 
-        if getattr(self.cfg, "append_finished_snapshots", False):
-            return True
+    def _render_steps_text(self) -> Any:
+        """Return the rendered steps body used by transcript capture."""
+        return self._build_steps_body(include_progress=True)
 
-        return (
-            not self.state.finalizing_ui
-            and sid not in self.stream_processor.current_event_finished_panels
-        )
+    def _summary_window_size(self) -> int:
+        """Return the active window size for step display."""
+        if self.state.finalizing_ui:
+            return 0
+        return int(self.cfg.summary_display_window or 0)
 
-    def _update_final_duration(
-        self, duration: float | None, *, overwrite: bool = False
-    ) -> None:
+    def _update_final_duration(self, duration: float | None, *, overwrite: bool = False) -> None:
         """Store formatted duration for eventual final panels."""
         if duration is None:
             return
@@ -1238,193 +1077,6 @@ class RichStreamRenderer:
         if overwrite and existing is not None:
             duration_val = max(existing, duration_val)
 
-        self.state.final_duration_seconds = duration_val
-        self.state.final_duration_text = self._format_elapsed_time(duration_val)
-
-    def _calculate_elapsed_time(self, meta: dict[str, Any]) -> str:
-        """Calculate elapsed time string for running tools."""
-        server_elapsed = self.stream_processor.server_elapsed_time
-        server_start = meta.get("server_started_at")
-
-        if isinstance(server_elapsed, int | float) and isinstance(
-            server_start, int | float
-        ):
-            elapsed = max(0.0, float(server_elapsed) - float(server_start))
-        else:
-            elapsed = max(0.0, monotonic() - (meta.get("started_at") or 0.0))
-
-        return self._format_elapsed_time(elapsed)
-
-    def _format_elapsed_time(self, elapsed: float) -> str:
-        """Format elapsed time as a readable string."""
-        if elapsed >= 1:
-            return f"{elapsed:.2f}s"
-        elif int(elapsed * 1000) > 0:
-            return f"{int(elapsed * 1000)}ms"
-        else:
-            return "<1ms"
-
-    def _calculate_finished_duration(self, meta: dict[str, Any]) -> str | None:
-        """Calculate duration string for finished tools."""
-        dur = meta.get("duration_seconds")
-        if isinstance(dur, int | float):
-            return self._format_elapsed_time(dur)
-
-        try:
-            server_now = self.stream_processor.server_elapsed_time
-            server_start = meta.get("server_started_at")
-            if isinstance(server_now, int | float) and isinstance(
-                server_start, int | float
-            ):
-                dur = max(0.0, float(server_now) - float(server_start))
-            elif meta.get("started_at") is not None:
-                dur = max(0.0, float(monotonic() - meta.get("started_at")))
-        except Exception:
-            dur = None
-
-        return self._format_elapsed_time(dur) if isinstance(dur, int | float) else None
-
-    def _process_running_tool_panel(
-        self,
-        title: str,
-        meta: dict[str, Any],
-        body: str,
-        *,
-        include_spinner: bool = False,
-    ) -> tuple[str, str] | tuple[str, str, str | None]:
-        """Process a running tool panel."""
-        elapsed_str = self._calculate_elapsed_time(meta)
-        adjusted_title = f"{title}  · {elapsed_str}"
-        chip = f"⏱ {elapsed_str}"
-        spinner_message: str | None = None
-
-        if not body.strip():
-            body = ""
-            spinner_message = f"{title} running... {elapsed_str}"
-        else:
-            body = f"{body}\n\n{chip}"
-
-        if include_spinner:
-            return adjusted_title, body, spinner_message
-        return adjusted_title, body
-
-    def _process_finished_tool_panel(self, title: str, meta: dict[str, Any]) -> str:
-        """Process a finished tool panel."""
-        duration_str = self._calculate_finished_duration(meta)
-        return f"{title}  · {duration_str}" if duration_str else title
-
-    def _create_tool_panel_for_session(
-        self, sid: str, meta: dict[str, Any]
-    ) -> AIPPanel | None:
-        """Create a single tool panel for the session."""
-        title = meta.get("title") or "Tool"
-        status = meta.get("status") or "running"
-        chunks = meta.get("chunks") or []
-        is_delegation = bool(meta.get("is_delegation"))
-
-        if self._should_skip_finished_panel(sid, status):
-            return None
-
-        body = "".join(chunks)
-        adjusted_title = title
-
-        spinner_message: str | None = None
-
-        if status == "running":
-            adjusted_title, body, spinner_message = self._process_running_tool_panel(
-                title, meta, body, include_spinner=True
-            )
-        elif status == "finished":
-            adjusted_title = self._process_finished_tool_panel(title, meta)
-
-        return create_tool_panel(
-            title=adjusted_title,
-            content=body,
-            status=status,
-            theme=self.cfg.theme,
-            is_delegation=is_delegation,
-            spinner_message=spinner_message,
-        )
-
-    def _render_tool_panels(self) -> list[AIPPanel]:
-        """Render tool execution output panels."""
-        if not getattr(self.cfg, "show_delegate_tool_panels", False):
-            return []
-        panels: list[AIPPanel] = []
-        for sid in self.tool_order:
-            meta = self.tool_panels.get(sid) or {}
-            panel = self._create_tool_panel_for_session(sid, meta)
-            if panel:
-                panels.append(panel)
-
-        return panels
-
-    def _format_dict_or_list_output(self, output_value: dict | list) -> str:
-        """Format dict/list output as pretty JSON."""
-        try:
-            return (
-                self.OUTPUT_PREFIX
-                + "```json\n"
-                + json.dumps(output_value, indent=2)
-                + "\n```\n"
-            )
-        except Exception:
-            return self.OUTPUT_PREFIX + str(output_value) + "\n"
-
-    def _clean_sub_agent_prefix(self, output: str, tool_name: str | None) -> str:
-        """Clean sub-agent name prefix from output."""
-        if not (tool_name and is_delegation_tool(tool_name)):
-            return output
-
-        sub = tool_name
-        if tool_name.startswith("delegate_to_"):
-            sub = tool_name.replace("delegate_to_", "")
-        elif tool_name.startswith("delegate_"):
-            sub = tool_name.replace("delegate_", "")
-        prefix = f"[{sub}]"
-        if output.startswith(prefix):
-            return output[len(prefix) :].lstrip()
-
-        return output
-
-    def _format_json_string_output(self, output: str) -> str:
-        """Format string that looks like JSON."""
-        try:
-            parsed = json.loads(output)
-            return (
-                self.OUTPUT_PREFIX
-                + "```json\n"
-                + json.dumps(parsed, indent=2)
-                + "\n```\n"
-            )
-        except Exception:
-            return self.OUTPUT_PREFIX + output + "\n"
-
-    def _format_string_output(self, output: str, tool_name: str | None) -> str:
-        """Format string output with optional prefix cleaning."""
-        s = output.strip()
-        s = self._clean_sub_agent_prefix(s, tool_name)
-
-        # If looks like JSON, pretty print it
-        if (s.startswith("{") and s.endswith("}")) or (
-            s.startswith("[") and s.endswith("]")
-        ):
-            return self._format_json_string_output(s)
-
-        return self.OUTPUT_PREFIX + s + "\n"
-
-    def _format_other_output(self, output_value: Any) -> str:
-        """Format other types of output."""
-        try:
-            return self.OUTPUT_PREFIX + json.dumps(output_value, indent=2) + "\n"
-        except Exception:
-            return self.OUTPUT_PREFIX + str(output_value) + "\n"
-
-    def _format_output_block(self, output_value: Any, tool_name: str | None) -> str:
-        """Format an output value for panel display."""
-        if isinstance(output_value, dict | list):
-            return self._format_dict_or_list_output(output_value)
-        elif isinstance(output_value, str):
-            return self._format_string_output(output_value, tool_name)
-        else:
-            return self._format_other_output(output_value)
+        formatted = format_elapsed_time(duration_val)
+        self.state.mark_final_duration(duration_val, formatted=formatted)
+        self._apply_root_duration(duration_val)