glaip-sdk 0.0.7__py3-none-any.whl → 0.6.5b6__py3-none-any.whl

glaip_sdk/utils/rendering/renderer/base.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 import json
 import logging
-from dataclasses import dataclass
+from datetime import datetime, timezone
 from time import monotonic
 from typing import Any
 
@@ -16,52 +16,64 @@ from rich.console import Console as RichConsole
 from rich.console import Group
 from rich.live import Live
 from rich.markdown import Markdown
+from rich.spinner import Spinner
 from rich.text import Text
 
+from glaip_sdk.icons import ICON_AGENT, ICON_AGENT_STEP, ICON_DELEGATE, ICON_TOOL_STEP
 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
+RUNNING_STATUS_HINTS = {"running", "started", "pending", "working"}
+ARGS_VALUE_MAX_LEN = 160
 
-@dataclass
-class RendererState:
-    """Internal state for the renderer."""
-
-    buffer: list[str] = None
-    final_text: str = ""
-    streaming_started_at: float | None = None
-    printed_final_panel: bool = False
-    finalizing_ui: bool = False
-
-    def __post_init__(self) -> None:
-        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__(
@@ -70,6 +82,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.
 
@@ -77,7 +91,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
@@ -85,19 +102,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
@@ -105,11 +139,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:
@@ -118,7 +153,24 @@ class RichStreamRenderer:
 
         # Set up initial state
         self._started_at = monotonic()
-        self.stream_processor.streaming_started_at = self._started_at
+        try:
+            self.state.meta = json.loads(json.dumps(meta))
+        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)
@@ -138,7 +190,7 @@ class RichStreamRenderer:
 
     def _build_header_parts(self, meta: dict[str, Any]) -> list[str]:
         """Build header text parts from metadata."""
-        parts: list[str] = ["🤖"]
+        parts: list[str] = [ICON_AGENT]
         agent_name = meta.get("agent_name", "agent")
         if agent_name:
             parts.append(agent_name)
@@ -169,583 +221,535 @@ 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="yellow",
-                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.start_stream_timer(timestamp)
+        self.stream_processor.streaming_started_at = timestamp
+        self._started_at = timestamp
 
     def on_event(self, ev: dict[str, Any]) -> None:
         """Handle streaming events from the backend."""
-        # Reset event tracking
+        received_at = self._resolve_received_timestamp(ev)
+        self._capture_event(ev, received_at)
         self.stream_processor.reset_event_tracking()
 
-        # Track streaming start time
-        if self.state.streaming_started_at is None:
-            self.state.streaming_started_at = monotonic()
+        self._sync_stream_start(ev, received_at)
 
-        # Extract event metadata
         metadata = self.stream_processor.extract_event_metadata(ev)
-        kind = metadata["kind"]
-        context_id = metadata["context_id"]
-        content = metadata["content"]
 
-        # Render debug event panel if verbose mode is enabled
-        if self.verbose:
-            render_debug_event(ev, self.console, self.state.streaming_started_at)
+        self._maybe_render_debug(ev, received_at)
+        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"))
+        if received_at is None:
+            received_at = datetime.now(timezone.utc)
+
+        if self.state.streaming_started_event_ts is None:
+            self.state.streaming_started_event_ts = received_at
+
+        return received_at
+
+    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:
+            baseline = monotonic()
+            self._ensure_streaming_started_baseline(baseline)
+        elif getattr(self.stream_processor, "streaming_started_at", None) is None:
+            self._ensure_streaming_started_baseline(baseline)
+
+        if ev.get("status") == "streaming_started":
+            self.state.streaming_started_event_ts = received_at
+            self._ensure_streaming_started_baseline(monotonic())
+
+    def _maybe_render_debug(
+        self, ev: dict[str, Any], received_at: datetime
+    ) -> None:  # pragma: no cover - guard rails for verbose mode
+        """Render debug view when verbose mode is enabled."""
+        if not self.verbose:
+            return
 
-        # Update timing
-        self.stream_processor.update_timing(context_id)
+        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()
 
-        # Handle different event types
-        if kind == "status":
-            # Status events
-            status = ev.get("status")
-            if status == "streaming_started":
-                self.state.streaming_started_at = monotonic()
-            return
+    def _dispatch_event(self, ev: dict[str, Any], metadata: dict[str, Any]) -> None:
+        """Route events to the appropriate renderer handlers."""
+        kind = metadata["kind"]
+        content = metadata["content"]
 
+        if kind == "status":
+            self._handle_status_event(ev)
         elif kind == "content":
-            # Content streaming events
-            if content:
-                self.state.buffer.append(content)
-                self._ensure_live()
-            return
-
+            self._handle_content_event(content)
         elif kind == "final_response":
-            # Final response events
-            if content:
-                self.state.buffer.append(content)
-                self.state.final_text = content
-                self._ensure_live()
+            self._handle_final_response_event(content, metadata)
+        elif kind in {"agent_step", "agent_thinking_step"}:
+            self._handle_agent_step_event(ev, metadata)
+        else:
+            self._ensure_live()
 
-                # In verbose mode, show the final result in a panel
-                if self.verbose and content and content.strip():
-                    final_panel = create_final_panel(content, theme=self.cfg.theme)
-                    self.console.print(final_panel)
-                    self.state.printed_final_panel = True
+    def _handle_status_event(self, ev: dict[str, Any]) -> None:
+        """Handle status events."""
+        status = ev.get("status")
+        if status == "streaming_started":
             return
 
-        elif kind in {"agent_step", "agent_thinking_step"}:
-            # Agent step events
-            # Note: Thinking gaps are primarily a visual aid. Keep minimal here.
-
-            # Extract tool information
-            (
-                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
-            )
+    def _handle_content_event(self, content: str) -> None:
+        """Handle content streaming events."""
+        if content:
+            self.state.append_transcript_text(content)
+            self._ensure_live()
+
+    def _handle_final_response_event(self, content: str, metadata: dict[str, Any]) -> None:
+        """Handle final response events."""
+        if content:
+            self.state.append_transcript_text(content)
+            self.state.set_final_output(content)
+
+            meta_payload = metadata.get("metadata") or {}
+            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()
+
+    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 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 {}
 
-            # Handle tool execution
-            self._handle_agent_step(ev, tool_name, tool_args, tool_out, tool_calls_info)
+        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,
+            tracked_step=tracked_step,
+        )
 
         # Update live display
         self._ensure_live()
 
-    def _finish_running_steps(self) -> None:
-        """Mark any running steps as finished to avoid lingering spinners."""
-        for st in list(self.steps.by_id.values()):
-            if not is_step_finished(st):
-                st.finish(None)
+    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
 
-    def _finish_tool_panels(self) -> None:
-        """Mark unfinished tool panels as finished."""
+        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:
-            items = list(self.tool_panels.items())
-        except Exception:  # pragma: no cover - defensive guard
-            logger.exception("Failed to iterate tool panels during cleanup")
+            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)
 
-        for _sid, meta in items:
-            if meta.get("status") != "finished":
-                meta["status"] = "finished"
+    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):
+                self._mark_incomplete_step(st)
+
+    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."""
         self._shutdown_live()
 
     def _print_final_panel_if_needed(self) -> None:
-        """Print final result panel if verbose mode and content available."""
-        if self.verbose and not self.state.printed_final_panel:
-            body = ("".join(self.state.buffer) or "").strip()
-            if body:
-                final_panel = create_final_panel(body, theme=self.cfg.theme)
-                self.console.print(final_panel)
-                self.state.printed_final_panel = True
-
-    def on_complete(self, _stats: RunStats) -> None:
+        """Print final result when configuration requires it."""
+        if self.state.printed_final_output:
+            return
+
+        body = (self.state.final_text or self.state.buffer.render() or "").strip()
+        if not body:
+            return
+
+        if getattr(self, "_transcript_mode_enabled", False):
+            return
+
+        if self.verbose:
+            panel = build_final_panel(
+                self.state,
+                title=self._final_panel_title(),
+            )
+            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
 
+        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
+
+        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."""
         # Final refresh
         self._ensure_live()
 
+        header, body = self.finalize()
+
         # Stop live display
         self._stop_live_display()
 
-        # Print final panel if needed
-        self._print_final_panel_if_needed()
+        # Render final output based on configuration
+        if self.cfg.live:
+            self._print_final_panel_if_needed()
+        else:
+            self._render_final_summary(header, body)
 
-    def _ensure_live(self) -> None:
-        """Ensure live display is updated."""
-        # Lazily create Live if needed
-        if self.live is None and self.cfg.live:
+    def _print_completion_message(self) -> None:
+        """Print completion message based on current mode."""
+        if self._transcript_mode_enabled:
             try:
-                self.live = Live(
-                    console=self.console,
-                    refresh_per_second=1 / self.cfg.refresh_debounce,
-                    transient=not self.cfg.persist_live,
+                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]"
                 )
-                self.live.start()
             except Exception:
-                self.live = None
-
-        if self.live:
-            panels = [self._render_main_panel()]
-            steps_renderable = self._render_steps_text()
-            panels.append(
-                AIPPanel(
-                    steps_renderable,
-                    title="Steps",
-                    border_style="blue",
-                )
-            )
-            panels.extend(self._render_tool_panels())
-            self.live.update(Group(*panels))
-
-    def _render_main_panel(self) -> Any:
-        """Render the main content panel."""
-        body = "".join(self.state.buffer).strip()
-        # Dynamic title with spinner + elapsed/hints
-        title = self._format_enhanced_main_title()
-        return create_main_panel(body, title, self.cfg.theme)
-
-    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,
-            )
+                pass
         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
+            # No transcript toggle in summary mode; nothing to print here.
+            return
 
-    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._ensure_tool_panel(call_name, call_args, task_id, context_id)
-                if is_delegation_tool(call_name):
-                    st2 = self.steps.start_or_get(
-                        task_id=task_id,
-                        context_id=context_id,
-                        kind="delegate",
-                        name=call_name,
-                        args=call_args,
-                    )
-                else:
-                    st2 = self.steps.start_or_get(
-                        task_id=task_id,
-                        context_id=context_id,
-                        kind="tool",
-                        name=call_name,
-                        args=call_args,
-                    )
-                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 _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")
+    def _ensure_live(self) -> None:
+        """Ensure live display is updated."""
+        if getattr(self, "_transcript_mode_enabled", False):
+            return
+        if not self._ensure_live_stack():
+            return
 
-        return False, None, None
+        self._start_live_if_needed()
 
-    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}"
+        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 _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
+    def _ensure_live_stack(self) -> bool:
+        """Guarantee the console exposes the internal live stack Rich expects."""
+        live_stack = getattr(self.console, "_live_stack", None)
+        if isinstance(live_stack, list):
+            return True
 
         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)
+            self.console._live_stack = []  # type: ignore[attr-defined]
+            return True
+        except Exception:
+            # If the console forbids attribute assignment we simply skip the live
+            # update for this cycle and fall back to buffered printing.
+            logger.debug(
+                "Console missing _live_stack; skipping live UI initialisation",
+                exc_info=True,
             )
-            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)
+            return False
 
-    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:
+    def _start_live_if_needed(self) -> None:
+        """Create and start a Live instance when configuration allows."""
+        if self.live is not None or not self.cfg.live:
             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,
+        try:
+            self.live = Live(
+                console=self.console,
+                refresh_per_second=1 / self.cfg.refresh_debounce,
+                transient=not self.cfg.persist_live,
             )
+            self.live.start()
+        except Exception:
+            self.live = None
 
-    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 _refresh_live_panels(self) -> None:
+        """Render panels and push them to the active Live display."""
+        if not self.live:
+            return
 
-    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) or 60
-        lines = body_text.splitlines()
-        if len(lines) > max_lines:
-            lines = lines[:max_lines] + ["… (truncated)"]
-        body_text = "\n".join(lines)
-
-        max_chars = int(self.cfg.snapshot_max_chars or 0) or 4000
-        if len(body_text) > max_chars:
-            body_text = body_text[: max_chars - 12] + "\n… (truncated)"
-
-        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),
+        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_body,
+            title=getattr(template_panel, "title", "Steps"),
+            border_style=getattr(template_panel, "border_style", "blue"),
+            padding=getattr(template_panel, "padding", (0, 1)),
         )
 
-    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
+        main_panel = self._render_main_panel()
+        panels = self._build_live_panels(main_panel, steps_panel)
 
-    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}"
+        self.live.update(Group(*panels))
 
-        if not self._should_create_snapshot(tool_sid):
-            return
+    def _build_live_panels(
+        self,
+        main_panel: Any,
+        steps_panel: Any,
+    ) -> list[Any]:
+        """Assemble the panel order for the live display."""
+        if self.verbose:
+            return [main_panel, steps_panel]
 
-        meta = self.tool_panels[tool_sid]
-        adjusted_title = self._get_snapshot_title(meta, finished_tool_name)
+        return [steps_panel, main_panel]
 
-        # Compose body from chunks and clamp
-        body_text = "".join(meta.get("chunks") or [])
-        body_text = self._clamp_snapshot_body(body_text)
+    def _render_main_panel(self) -> Any:
+        """Render the main content panel."""
+        body = self.state.buffer.render().strip()
+        theme = DEFAULT_TRANSCRIPT_THEME
+        if not self.verbose:
+            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, theme)
 
-        snapshot_panel = self._create_snapshot_panel(
-            adjusted_title, body_text, finished_tool_name
-        )
+    def _final_panel_title(self) -> str:
+        """Compose title for the final result panel including duration."""
+        return format_final_panel_title(self.state)
 
-        self._print_and_mark_snapshot(tool_sid, snapshot_panel)
+    def apply_verbosity(self, verbose: bool) -> None:
+        """Update verbose behaviour at runtime."""
+        if self.verbose == verbose:
+            return
 
-    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)
+        self.verbose = verbose
+        desired_live = not verbose
+        if desired_live != self.cfg.live:
+            self.cfg.live = desired_live
+            if not desired_live:
+                self._shutdown_live()
+            else:
+                self._ensure_live()
 
-        # Handle additional tool calls
-        self._process_additional_tool_calls(
-            tool_calls_info, tool_name, task_id, context_id
-        )
+        if self.cfg.live:
+            self._ensure_live()
 
-        # Check for tool completion
-        (
-            is_tool_finished,
-            finished_tool_name,
-            finished_tool_output,
-        ) = self._detect_tool_completion(metadata, content)
+    # Transcript helper implementations live in TranscriptModeMixin.
 
-        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 get_aggregated_output(self) -> str:
+        """Return the concatenated assistant output collected so far."""
+        return self.state.buffer.render().strip()
 
-    def _spinner(self) -> str:
-        """Return spinner character."""
-        return get_spinner()
+    def get_transcript_events(self) -> list[dict[str, Any]]:
+        """Return captured SSE events."""
+        return list(self.state.events)
 
     def _format_working_indicator(self, started_at: float | None) -> str:
         """Format working indicator."""
@@ -760,6 +764,11 @@ class RichStreamRenderer:
         self._shutdown_live()
 
     def __del__(self) -> None:
+        """Destructor that ensures live rendering is properly shut down.
+
+        This is a safety net to prevent resource leaks if the renderer
+        is not explicitly stopped.
+        """
         # Destructors must never raise
         try:
             self._shutdown_live(reset_attr=False)
@@ -784,9 +793,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]):
@@ -794,13 +801,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,
@@ -844,39 +849,52 @@ class RichStreamRenderer:
     def _get_step_icon(self, step_kind: str) -> str:
         """Get icon for step kind."""
         if step_kind == "tool":
-            return "⚙️"
+            return ICON_TOOL_STEP
         elif step_kind == "delegate":
-            return "🤝"
+            return ICON_DELEGATE
         elif step_kind == "agent":
-            return "🧠"
+            return ICON_AGENT_STEP
         return ""
 
     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 "[<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 "[<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 "[<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:
@@ -890,6 +908,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] = {}
@@ -900,212 +922,103 @@ class RichStreamRenderer:
                 running_by_ctx.setdefault(key, []).append(st)
         return running_by_ctx
 
-    def _render_steps_text(self) -> Text:
-        """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()
-        lines: list[str] = []
-
+    def _is_parallel_tool(
+        self,
+        step: Step,
+        running_by_ctx: dict[tuple[str | None, str | None], list],
+    ) -> bool:
+        """Return True if multiple tools are running in the same context."""
+        key = (step.task_id, step.context_id)
+        return len(running_by_ctx.get(key, [])) > 1
+
+    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:
-            st = self.steps.by_id[sid]
-            status_br = self._format_step_status(st)
-            display_name = self._get_step_display_name(st)
-            tail = " ✓" if is_step_finished(st) else ""
-
-            # Add parallel indicator for running tools
-            if st.kind == "tool" and not is_step_finished(st):
-                key = (st.task_id, st.context_id)
-                if len(running_by_ctx.get(key, [])) > 1:
-                    status_br = status_br.replace("]", " 🔄]")
-
-            icon = self._get_step_icon(st.kind)
-            lines.append(f"{icon} {display_name} {status_br}{tail}")
-
-        return Text("\n".join(lines), style="dim")
-
-    def _should_skip_finished_panel(self, sid: str, status: str) -> bool:
-        """Check if a finished panel should be skipped."""
-        if status != "finished":
-            return False
-
-        if getattr(self.cfg, "append_finished_snapshots", False):
-            return True
-
-        return (
-            not self.state.finalizing_ui
-            and sid not in self.stream_processor.current_event_finished_panels
-        )
-
-    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
-    ) -> tuple[str, str]:
-        """Process a running tool panel."""
-        elapsed_str = self._calculate_elapsed_time(meta)
-        adjusted_title = f"{title}  · {elapsed_str}"
-        chip = f"⏱ {elapsed_str}"
-
-        if not body:
-            body = chip
-        else:
-            body = f"{body}\n\n{chip}"
-
-        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
-
-        if status == "running":
-            adjusted_title, body = self._process_running_tool_panel(title, meta, body)
-        elif status == "finished":
-            adjusted_title = self._process_finished_tool_panel(title, meta)
-
-        return create_tool_panel(
-            title=adjusted_title,
-            content=body or "Processing...",
-            status=status,
-            theme=self.cfg.theme,
-            is_delegation=is_delegation,
+            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(),
         )
-
-    def _render_tool_panels(self) -> list[AIPPanel]:
-        """Render tool execution output panels."""
-        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"
+        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,
             )
-        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."""
+            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)
+
+    def _render_steps_text(self) -> Any:
+        """Return the rendered steps body used by transcript capture."""
+        return self._build_steps_body(include_progress=True)
+
+    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:
+        """Store formatted duration for eventual final panels."""
+        if duration is None:
+            return
+
         try:
-            parsed = json.loads(output)
-            return (
-                self.OUTPUT_PREFIX
-                + "```json\n"
-                + json.dumps(parsed, indent=2)
-                + "\n```\n"
-            )
+            duration_val = max(0.0, float(duration))
         except Exception:
-            return self.OUTPUT_PREFIX + output + "\n"
+            return
 
-    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)
+        existing = self.state.final_duration_seconds
 
-        # 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)
+        if not overwrite and existing is not None:
+            return
 
-        return self.OUTPUT_PREFIX + s + "\n"
+        if overwrite and existing is not None:
+            duration_val = max(existing, duration_val)
 
-    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)