glaip-sdk 0.7.26__py3-none-any.whl → 0.7.28__py3-none-any.whl

glaip_sdk/cli/slash/tui/remote_runs_app.py

@@ -1,7 +1,7 @@
 """Textual UI for the /runs command.
 
-This module provides a lightweight Textual application that mirrors the remote
-run browser experience using rich widgets (DataTable, modals, footer hints).
+This module provides a Harlequin layout screen for browsing remote runs with
+an always-visible detail pane and transcript panel.
 
 Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
@@ -14,30 +14,43 @@ import json
 import logging
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any
+from datetime import UTC, datetime
+from typing import Any, cast
 
+from rich.syntax import Syntax
+from rich.table import Table
 from rich.text import Text
-
-from textual.app import App, ComposeResult
+from textual import events
+from textual._context import NoActiveAppError
+from textual.app import App, ComposeResult, ScreenStackError
 from textual.binding import Binding
-from textual.containers import Horizontal, Vertical
+from textual.containers import Horizontal
 from textual.coordinate import Coordinate
-from textual.reactive import ReactiveError
-from textual.screen import ModalScreen
-from textual.widgets import DataTable, Footer, Header, RichLog, Static
+from textual.screen import Screen
+from textual.widgets import DataTable, Footer, Input, RichLog, Static, TextArea
 
+from glaip_sdk.cli.slash.tui.background_tasks import BackgroundTaskMixin
 from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter
 from glaip_sdk.cli.slash.tui.context import TUIContext
 from glaip_sdk.cli.slash.tui.indicators import PulseIndicator
+from glaip_sdk.cli.slash.tui.layouts.harlequin import HarlequinScreen
 from glaip_sdk.cli.slash.tui.loading import hide_loading_indicator, show_loading_indicator
-from glaip_sdk.cli.slash.tui.toast import ClipboardToastMixin, Toast, ToastBus, ToastContainer, ToastHandlerMixin
+from glaip_sdk.cli.slash.tui.toast import ClipboardToastMixin, ToastBus, ToastHandlerMixin
 
 logger = logging.getLogger(__name__)
 
-RUNS_TABLE_ID = "runs"
+RUNS_TABLE_ID = "runs-table"
+RUNS_FILTER_ID = "runs-filter"
 RUNS_LOADING_ID = "runs-loading"
-RUNS_TABLE_SELECTOR = f"#{RUNS_TABLE_ID}"
+RUNS_STATUS_ID = "runs-status"
+RUNS_DETAIL_META_ID = "runs-detail-meta"
+RUNS_DETAIL_INPUT_ID = "runs-detail-input"
+RUNS_DETAIL_TRANSCRIPT_ID = "runs-detail-transcript"
 RUNS_LOADING_SELECTOR = f"#{RUNS_LOADING_ID}"
+RUNS_SELECT_FIRST_MESSAGE = "Select a run first."
+RUNS_DETAIL_LOG_MESSAGE = "Failed to load run detail %s: %s"
+RUNS_RUN_JSON_LABEL = "Run JSON"
+TRANSCRIPT_ASYNC_THRESHOLD = 50
 
 
 @dataclass
@@ -71,7 +84,7 @@ def run_remote_runs_textual(
     Returns:
         Tuple of (page, limit, cursor_index) after the UI exits.
     """
-    app = RemoteRunsTextualApp(
+    app = _HarlequinRunsApp(
         initial_page,
         cursor_idx,
         callbacks,
@@ -79,263 +92,129 @@ def run_remote_runs_textual(
         agent_id=agent_id,
         ctx=ctx,
     )
-    app.run()
-    current_page = getattr(app, "current_page", initial_page)
-    return current_page.page, current_page.limit, app.cursor_index
+    # Enable mouse capture for scrolling within the detail panes.
+    app.run(mouse=True)
+    try:
+        screen = app.screen
+    except ScreenStackError:
+        screen = None
+    if isinstance(screen, RunsHarlequinScreen):
+        current_page = screen.current_page
+        cursor_index = screen.cursor_index
+        limit = getattr(screen, "_limit", current_page.limit)
+    else:
+        current_page = getattr(app, "current_page", None) or initial_page
+        cursor_index = getattr(app, "cursor_index", None)
+        if cursor_index is None:
+            cursor_index = cursor_idx
+        limit = current_page.limit
+    return current_page.page, limit, cursor_index
+
+
+class RunsHarlequinScreen(ToastHandlerMixin, ClipboardToastMixin, BackgroundTaskMixin, HarlequinScreen):
+    """Harlequin layout screen for browsing remote runs."""
 
+    BINDINGS = [
+        Binding("left", "page_left", "Prev page", priority=True),
+        Binding("right", "page_right", "Next page", priority=True),
+        Binding("pageup", "transcript_page_up", "Transcript Up", priority=True),
+        Binding("pagedown", "transcript_page_down", "Transcript Down", priority=True),
+        Binding("c", "copy_run_id", "Copy Run ID", priority=True, show=False),
+        Binding("i", "copy_input", "Copy Input", priority=True, show=False),
+        Binding("t", "copy_transcript", "Copy Transcript", priority=True, show=False),
+        Binding("C", "copy_detail_json", "Copy Run JSON", priority=True, show=False),
+        Binding("e", "export_run", "Export", priority=True),
+        Binding("/", "focus_filter", "Filter", priority=True),
+        Binding("q", "app_exit", "Quit", priority=True),
+    ]
 
-class RunDetailScreen(ToastHandlerMixin, ClipboardToastMixin, ModalScreen[None]):
-    """Modal screen displaying run metadata and output timeline."""
+    @staticmethod
+    def _copy_hint(key: str) -> Text:
+        # Use bold yellow to make hints stand out without complex animation
+        return Text(f"(copy: {key})", style="bold yellow reverse")
 
     CSS = """
-    Screen { layout: vertical; layers: base toasts; }
+    RunsHarlequinScreen {
+        layers: base toasts;
+    }
+
     #toast-container {
-        width: 100%;
+        width: auto;
         height: auto;
         dock: top;
         align: right top;
         layer: toasts;
     }
-    """
-
-    BINDINGS = [
-        Binding("escape", "dismiss", "Close", priority=True),
-        Binding("q", "dismiss_modal", "Close", priority=True),
-        Binding("up", "scroll_up", "Up"),
-        Binding("down", "scroll_down", "Down"),
-        Binding("pageup", "page_up", "PgUp"),
-        Binding("pagedown", "page_down", "PgDn"),
-        Binding("c", "copy_run_id", "Copy ID"),
-        Binding("C", "copy_detail_json", "Copy JSON"),
-        Binding("e", "export_detail", "Export"),
-    ]
-
-    def __init__(
-        self,
-        detail: Any,
-        on_export: Callable[[Any], None] | None = None,
-        ctx: TUIContext | None = None,
-    ) -> None:
-        """Initialize the run detail screen."""
-        super().__init__()
-        self.detail = detail
-        self._on_export = on_export
-        self._ctx = ctx
-        self._clip_cache: ClipboardAdapter | None = None
-        self._local_toasts: ToastBus | None = None
-
-    def compose(self) -> ComposeResult:
-        """Render metadata and events."""
-        meta_text = Text()
-
-        def add_meta(label: str, value: Any | None, value_style: str | None = None) -> None:
-            if value in (None, ""):
-                return
-            if len(meta_text) > 0:
-                meta_text.append("\n")
-            meta_text.append(f"{label}: ", style="bold cyan")
-            meta_text.append(str(value), style=value_style)
-
-        add_meta("Run ID", self.detail.id)
-        add_meta("Agent ID", getattr(self.detail, "agent_id", "-"))
-        add_meta("Type", getattr(self.detail, "run_type", "-"), "bold yellow")
-        status_value = getattr(self.detail, "status", "-")
-        add_meta("Status", status_value, self._status_style(status_value))
-        add_meta("Started", getattr(self.detail, "started_at", None))
-        add_meta("Completed", getattr(self.detail, "completed_at", None))
-        duration = self.detail.duration_formatted() if getattr(self.detail, "duration_formatted", None) else None
-        add_meta("Duration", duration, "bold")
-
-        main_content = Vertical(
-            Static(meta_text, id="detail-meta"),
-            RichLog(id="detail-events", wrap=False),
-        )
-        yield main_content
-        yield ToastContainer(Toast(), id="toast-container")
-        yield Footer()
-
-    def on_mount(self) -> None:
-        """Populate and focus the log."""
-        self._ensure_toast_bus()
-        log = self.query_one("#detail-events", RichLog)
-        log.can_focus = True
-        log.write(Text("Events", style="bold"))
-        for chunk in getattr(self.detail, "output", []):
-            event_type = chunk.get("event_type", "event")
-            status = chunk.get("status", "-")
-            timestamp = chunk.get("received_at") or "-"
-            header = Text()
-            header.append(timestamp, style="cyan")
-            header.append(" ")
-            header.append(event_type, style=self._event_type_style(event_type))
-            header.append(" ")
-            header.append("[")
-            header.append(status, style=self._status_style(status))
-            header.append("]")
-            log.write(header)
-
-            payload = Text(json.dumps(chunk, indent=2, ensure_ascii=False), style="dim")
-            log.write(payload)
-            log.write(Text(""))
-        log.focus()
-
-    def _log(self) -> RichLog:
-        return self.query_one("#detail-events", RichLog)
-
-    def action_copy_run_id(self) -> None:
-        """Copy the run id to the clipboard."""
-        run_id = getattr(self.detail, "id", None)
-        if not run_id:
-            self._announce_status("Run ID unavailable.")
-            return
-        self._copy_to_clipboard(str(run_id), label="Run ID")
-
-    def action_copy_detail_json(self) -> None:
-        """Copy the run detail JSON to the clipboard."""
-        payload = self._detail_json_payload()
-        if payload is None:
-            return
-        self._copy_to_clipboard(payload, label="Run JSON")
 
-    def _detail_json_payload(self) -> str | None:
-        detail = self.detail
-        if detail is None:
-            self._announce_status("Run detail unavailable.")
-            return None
-        if isinstance(detail, str):
-            return detail
-        if isinstance(detail, dict):
-            payload = detail
-        elif hasattr(detail, "model_dump"):
-            payload = detail.model_dump(mode="json")
-        elif hasattr(detail, "dict"):
-            payload = detail.dict()
-        else:
-            payload = getattr(detail, "__dict__", {"value": detail})
-        try:
-            return json.dumps(payload, indent=2, ensure_ascii=False, default=str)
-        except Exception as exc:
-            self._announce_status(f"Failed to serialize run detail: {exc}")
-            return None
-
-    def _append_copy_fallback(self, text: str) -> None:
-        try:
-            log = self._log()
-        except Exception:
-            self._announce_status(text)
-            return
-        log.write(Text(text))
-        log.write(Text(""))
-
-    def _ensure_toast_bus(self) -> None:
-        """Ensure toast bus is initialized and connected to message handler."""
-        if self._local_toasts is not None:
-            return  # pragma: no cover - early return when already initialized
-
-        def _notify(m: ToastBus.Changed) -> None:
-            self.post_message(m)
-
-        self._local_toasts = ToastBus(on_change=_notify)
-
-    @staticmethod
-    def _status_style(status: str | None) -> str:
-        """Return a Rich style name for the status pill."""
-        if not status:
-            return "dim"
-        normalized = str(status).lower()
-        if normalized in {"success", "succeeded", "completed", "ok"}:
-            return "green"
-        if normalized in {"failed", "error", "errored", "cancelled"}:
-            return "red"
-        if normalized in {"running", "in_progress", "queued"}:
-            return "yellow"
-        return "cyan"
-
-    @staticmethod
-    def _event_type_style(event_type: str | None) -> str:
-        """Return a highlight color for the event type label."""
-        if not event_type:
-            return "white"
-        normalized = str(event_type).lower()
-        if "error" in normalized or "fail" in normalized:
-            return "red"
-        if "status" in normalized:
-            return "magenta"
-        if "tool" in normalized:
-            return "yellow"
-        if "stream" in normalized:
-            return "cyan"
-        return "green"
+    #harlequin-container {
+        height: 100%;
+    }
 
-    def action_dismiss_modal(self) -> None:
-        """Allow q binding to close the modal like Esc."""
-        self.dismiss(None)
+    #left-pane {
+        width: 50%;
+        min-width: 38;
+        padding: 1;
+    }
 
-    def action_scroll_up(self) -> None:
-        """Scroll the log view up."""
-        self._log().action_scroll_up()
+    #right-pane {
+        width: 50%;
+        padding: 1;
+    }
 
-    def action_scroll_down(self) -> None:
-        """Scroll the log view down."""
-        self._log().action_scroll_down()
+    .pane-title {
+        color: $warning;
+        text-style: bold;
+        padding-bottom: 1;
+    }
 
-    def action_page_up(self) -> None:
-        """Scroll the log view up one page."""
-        self._log().action_page_up()
+    .section-title {
+        color: $warning;
+        text-style: bold;
+        padding-top: 1;
+        padding-bottom: 1;
+    }
 
-    def action_page_down(self) -> None:
-        """Scroll the log view down one page."""
-        self._log().action_page_down()
+    .detail-block {
+        padding-bottom: 1;
+    }
 
-    def action_export_detail(self) -> None:
-        """Trigger export from the detail modal."""
-        if self._on_export is None:
-            self._announce_status("Export unavailable in this terminal mode.")
-            return
-        try:
-            self._on_export(self.detail)
-        except Exception as exc:  # pragma: no cover - defensive
-            self._announce_status(f"Export failed: {exc}")
+    .detail-input {
+        border: solid $secondary;
+        padding: 1;
+        margin-bottom: 1;
+        height: 8;
+        min-height: 3;
+        overflow-y: auto;
+    }
 
-    def _announce_status(self, message: str) -> None:
-        """Send status text to the parent app when available."""
-        try:
-            app = self.app
-        except AttributeError:
-            return
-        update_status = getattr(app, "_update_status", None)
-        if callable(update_status):
-            update_status(message, append=True)
+    .step-list {
+        border: solid $secondary;
+        padding: 1;
+        height: 1fr;
+        overflow-y: auto;
+    }
 
+    .status-bar {
+        height: 3;
+        align: left middle;
+        padding-top: 1;
+        margin-bottom: 1;
+    }
 
-class RemoteRunsTextualApp(ToastHandlerMixin, App[None]):
-    """Textual application for browsing remote runs."""
+    .status-line {
+        color: $text-muted;
+    }
 
-    CSS = f"""
-    #toast-container {{
-        width: 100%;
-        height: auto;
-        dock: top;
-        align: right top;
-        layer: toasts;
-    }}
-    #{RUNS_LOADING_ID} {{
-        width: auto;
-        display: none;
-    }}
-    #status-bar {{
+    .filter-input {
         height: 3;
-        padding: 0 1;
-    }}
-    """
+        margin: 0 1;
+        border: solid $accent;
+    }
 
-    BINDINGS = [
-        Binding("q", "close_view", "Quit", priority=True),
-        Binding("escape", "close_view", "Quit", show=False, priority=True),
-        Binding("left", "page_left", "Prev page", priority=True),
-        Binding("right", "page_right", "Next page", priority=True),
-        Binding("enter", "open_detail", "Select Run", priority=True),
-    ]
+    #runs-table {
+        height: 1fr;
+    }
+    """
 
     def __init__(
         self,
@@ -346,441 +225,836 @@ class RemoteRunsTextualApp(ToastHandlerMixin, App[None]):
         agent_name: str | None = None,
         agent_id: str | None = None,
         ctx: TUIContext | None = None,
-    ):
-        """Initialize the remote runs Textual application.
-
-        Args:
-            initial_page: RunsPage instance to display initially.
-            cursor_idx: Initial cursor position in the table.
-            callbacks: Callback bundle for data operations.
-            agent_name: Optional agent name for display purposes.
-            agent_id: Optional agent ID for display purposes.
-            ctx: Shared TUI context.
-        """
-        super().__init__()
+    ) -> None:
+        """Initialize the Harlequin runs screen."""
+        super().__init__(ctx=ctx)
         self.current_page = initial_page
         self.cursor_index = max(0, min(cursor_idx, max(len(initial_page.data) - 1, 0)))
-        self.callbacks = callbacks
-        self.status_text = ""
-        self.current_rows = initial_page.data[:]
-        self.agent_name = (agent_name or "").strip()
-        self.agent_id = (agent_id or "").strip()
+        self._runs_callbacks = callbacks
+        self._agent_name = (agent_name or "").strip()
+        self._agent_id = (agent_id or "").strip()
         self._ctx = ctx
         self._clip_cache: ClipboardAdapter | None = None
-        self._active_export_tasks: set[asyncio.Task[None]] = set()
+        self._local_toasts: ToastBus | None = None
+        self._detail_cache: dict[str, Any] = {}
         self._page_loader_task: asyncio.Task[Any] | None = None
-        self._detail_loader_task: asyncio.Task[Any] | None = None
-        self._table_spinner_active = False
-
-    @property
-    def clipboard(self) -> str:
-        """Return clipboard text for Input paste actions."""
-        if self._ctx is not None:
-            adapter = self._ctx.clipboard
-            if adapter is None:
-                adapter = ClipboardAdapter(terminal=self._ctx.terminal)
-                self._ctx.clipboard = adapter
-            result = adapter.read()
-            if result.success:
-                return result.text
-        if self._ctx is None and self._clip_cache is None:
-            self._clip_cache = ClipboardAdapter(terminal=None)
-        if self._clip_cache is not None:
-            result = self._clip_cache.read()
-            if result.success:
-                return result.text
-        return super().clipboard
-
-    @clipboard.setter
-    def clipboard(self, value: str) -> None:
-        setter = App.clipboard.fset
-        if setter is not None:
-            setter(self, value)
+        self._detail_loader_task: asyncio.Task[None] | None = None
+        self._detail_loading_id: str | None = None
+        self._current_rows: list[Any] = initial_page.data[:]
+        self._visible_rows: list[Any] = []
+        self._filter_text = ""
+        self._limit = initial_page.limit
+        self._transcript_render_task: asyncio.Task[None] | None = None
+        self._transcript_render_token = 0
+        # Initial safe default, but we'll recalculate on mount/resize
+        self._preview_limit = 45
+        self._initial_load_complete = False
 
     def compose(self) -> ComposeResult:
-        """Build layout."""
-        yield Header()
-        yield ToastContainer(Toast(), id="toast-container")
-        table = DataTable(id=RUNS_TABLE_ID)  # pragma: no cover - mocked in tests
-        table.cursor_type = "row"  # pragma: no cover - mocked in tests
-        table.add_columns(  # pragma: no cover - mocked in tests
-            "Run UUID",
-            "Type",
-            "Status",
-            "Started (UTC)",
-            "Completed (UTC)",
-            "Duration",
-            "Input Preview",
+        """Compose the Harlequin layout and footer."""
+        yield from super().compose()
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Populate panes with run list and detail widgets."""
+        query_one = cast(Any, self).query_one
+        left_pane = query_one("#left-pane")
+        right_pane = query_one("#right-pane")
+
+        self._page_title = Static("Run History", classes="pane-title")
+        self._agent_label = Static(self._agent_context_label(), classes="section-title")
+        self._runs_table = DataTable(id=RUNS_TABLE_ID, cursor_type="row", zebra_stripes=True)
+        self._runs_table.add_column("St", width=4)
+        self._runs_table.add_column("Started (UTC)", width=13)
+        self._runs_table.add_column("Input")
+        self._filter_input = Input(placeholder="Filter input...", id=RUNS_FILTER_ID, classes="filter-input")
+        self._filter_input.display = False
+        self._loading_indicator = PulseIndicator(id=RUNS_LOADING_ID)
+        self._status_line = Static("", id=RUNS_STATUS_ID, classes="status-line")
+        self._status_bar = Horizontal(self._loading_indicator, self._status_line, classes="status-bar")
+
+        left_pane.mount(self._page_title)
+        left_pane.mount(self._agent_label)
+        left_pane.mount(self._runs_table)
+        left_pane.mount(self._filter_input)
+        left_pane.mount(self._status_bar)
+
+        self._detail_title = Static("Run Detail", classes="pane-title")
+        self._detail_meta = Static("", id=RUNS_DETAIL_META_ID, classes="detail-block")
+        self._input_title = Static(
+            Text.assemble("Input ", self._copy_hint("i")),
+            classes="section-title",
         )
-        yield table  # pragma: no cover - interactive UI, tested via integration
-        yield Horizontal(  # pragma: no cover - interactive UI, tested via integration
-            PulseIndicator(id=RUNS_LOADING_ID),
-            Static(id="status"),
-            id="status-bar",
+        self._input_body = TextArea(
+            "",
+            id=RUNS_DETAIL_INPUT_ID,
+            read_only=True,
+            show_line_numbers=False,
+            classes="detail-input",
         )
-        yield Footer()  # pragma: no cover - interactive UI, tested via integration
-
-    def _ensure_toast_bus(self) -> None:
-        if self._ctx is None or self._ctx.toasts is not None:
-            return
-
-        def _notify(m: ToastBus.Changed) -> None:
-            self.post_message(m)
+        self._input_body.can_focus = True
+        self._transcript_title = Static(
+            Text.assemble("Transcript ", self._copy_hint("t")),
+            classes="section-title",
+        )
+        self._transcript_log = RichLog(id=RUNS_DETAIL_TRANSCRIPT_ID, wrap=False, classes="step-list")
+        self._transcript_log.can_focus = True
 
-        self._ctx.toasts = ToastBus(on_change=_notify)
+        right_pane.mount(self._detail_title)
+        right_pane.mount(self._detail_meta)
+        right_pane.mount(self._input_title)
+        right_pane.mount(self._input_body)
+        right_pane.mount(self._transcript_title)
+        right_pane.mount(self._transcript_log)
 
-    def on_mount(self) -> None:
-        """Render the initial page."""
         self._ensure_toast_bus()
-        self._hide_loading()
-        self._render_page(self.current_page)
-
-    def _render_page(self, runs_page: Any) -> None:
-        """Populate table rows for a RunsPage."""
-        table = self.query_one(RUNS_TABLE_SELECTOR, DataTable)
-        table.clear()
-        self.current_rows = runs_page.data[:]
-        for run in self.current_rows:
-            table.add_row(
-                str(run.id),
-                str(run.run_type).title(),
-                str(run.status).upper(),
-                run.started_at.strftime("%Y-%m-%d %H:%M:%S") if run.started_at else "—",
-                run.completed_at.strftime("%Y-%m-%d %H:%M:%S") if run.completed_at else "—",
-                run.duration_formatted(),
-                run.input_preview(),
-            )
-        if self.current_rows:
-            self.cursor_index = max(0, min(self.cursor_index, len(self.current_rows) - 1))
-            table.focus()
-            table.cursor_coordinate = Coordinate(self.cursor_index, 0)
-        self.current_page = runs_page
-        total_pages = max(1, (runs_page.total + runs_page.limit - 1) // runs_page.limit)
-        agent_display = self.agent_name or "Runs"
-        header = f"{agent_display} • Page {runs_page.page}/{total_pages} • Page size={runs_page.limit}"
-        try:
-            self.sub_title = header
-        except ReactiveError:
-            # App not fully initialized (common in tests), skip setting sub_title
-            logger.debug("Cannot set sub_title: app not fully initialized")
-        self._clear_status()
-
-    def _agent_context_label(self) -> str:
-        """Return a descriptive label for the active agent."""
-        name = self.agent_name
-        identifier = self.agent_id
-        if name and identifier:
-            return f"Agent: {name} ({identifier})"
-        if name:
-            return f"Agent: {name}"
-        if identifier:
-            return f"Agent: {identifier}"
-        return "Agent runs"
-
-    def _update_status(self, message: str, *, append: bool = False) -> None:
-        """Update the footer status text."""
         try:
-            static = self.query_one("#status", Static)
-        except (AttributeError, RuntimeError) as e:
-            # App not fully initialized (common in tests), just update status_text
-            logger.debug("Cannot update status widget: app not fully initialized (%s)", type(e).__name__)
-            if append:
-                self.status_text = f"{self.status_text}\n{message}"
-            else:
-                self.status_text = message
+            app = self.app
+        except NoActiveAppError:
+            app = None
+        if app is not None:
+            self._calculate_preview_limit(app.size.width)
+            self.call_after_refresh(self._check_dynamic_page_size)
+        self._render_page()
+
+    def on_resize(self, event: events.Resize) -> None:
+        """Recalculate layout limits on resize."""
+        self._calculate_preview_limit(event.size.width)
+        self._calculate_page_size(event.size.height)
+        self._render_page()
+
+    def _check_dynamic_page_size(self) -> None:
+        """Check if we need to reload with a better page size on startup."""
+        if self._initial_load_complete:
             return
-        if append:
-            self.status_text = f"{self.status_text}\n{message}"
-        else:
-            self.status_text = message
-        static.update(self.status_text)
-
-    def _clear_status(self) -> None:
-        """Clear any status message."""
-        self.status_text = ""
-        try:
-            static = self.query_one("#status", Static)
-            static.update("")
-        except (AttributeError, RuntimeError) as e:
-            # App not fully initialized (common in tests), skip widget update
-            logger.debug("Cannot clear status widget: app not fully initialized (%s)", type(e).__name__)
-
-    def on_data_table_row_highlighted(self, event: DataTable.RowHighlighted) -> None:  # pragma: no cover - UI hook
-        """Track cursor position when DataTable selection changes."""
-        self.cursor_index = getattr(event, "cursor_row", self.cursor_index)
-
-    def _handle_table_click(self, row: int | None) -> None:
-        if row is None:
+        self._initial_load_complete = True
+        app = getattr(self, "app", None)
+        if app:
+            self._calculate_page_size(app.size.height, reload_if_needed=True)
+
+    def _calculate_preview_limit(self, screen_width: int) -> None:
+        """Calculate input preview limit to avoid horizontal scrolling."""
+        if screen_width <= 0:
             return
-        table = self.query_one(RUNS_TABLE_SELECTOR, DataTable)
-        self.cursor_index = row
-        try:
-            table.cursor_coordinate = Coordinate(row, 0)
-        except Exception:
+        # Left pane is 50%. Fixed cols use roughly 4+13+margins ~= 23 chars.
+        # We leave a buffer for borders and scrollbars (~4 chars).
+        # Calculation: (screen_width / 2) - 23 - 4
+        left_pane_width = screen_width // 2
+        available = left_pane_width - 27
+        # Ensure a reasonable minimum (e.g. 20 chars) and maximum (e.g. 150)
+        self._preview_limit = max(20, min(available, 150))
+
+    def _calculate_page_size(self, screen_height: int, reload_if_needed: bool = False) -> None:
+        """Calculate optimal page size based on height."""
+        if screen_height <= 0:
+            return
+        # Overhead: Title(2) + Agent(3) + Filter(0 or 3) + Status(3) + Header(1) + Borders/Pad(~2)
+        # Total overhead approx 11-14 lines.
+        overhead = 12
+        available_lines = max(1, screen_height - overhead)
+
+        if available_lines != self._limit:
+            self._limit = available_lines
+            if reload_if_needed and available_lines > self.current_page.limit:
+                self._queue_page_load(self.current_page.page, "Adjusting view...", "Failed to adjust view.")
+
+    def on_key(self, event: events.Key) -> None:
+        """Route left/right navigation to paging instead of table scroll."""
+        filter_input = getattr(self, "_filter_input", None)
+        if event.key == "left" and (filter_input is None or not filter_input.has_focus):
+            self.action_page_left()
+            event.stop()
+        if event.key == "right" and (filter_input is None or not filter_input.has_focus):
+            self.action_page_right()
+            event.stop()
+        if event.key == "escape" and filter_input is not None:
+            if filter_input.has_focus or filter_input.display:
+                self.action_clear_filter()
+                event.stop()
+
+    def on_mouse_scroll_up(self, event: events.MouseScrollUp) -> None:
+        """Let standard scrolling happen."""
+        pass
+
+    def on_mouse_scroll_down(self, event: events.MouseScrollDown) -> None:
+        """Let standard scrolling happen."""
+        pass
+
+    def on_mouse_down(self, event: events.MouseDown) -> None:
+        """Let standard click focus happen."""
+        pass
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Filter rows as user types."""
+        if event.input.id != RUNS_FILTER_ID:
             return
-        self.action_open_detail()
+        self._filter_text = event.value.strip().lower()
+        self._render_page()
 
-    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:  # pragma: no cover - UI hook
-        """Handle row selection event from DataTable."""
-        self._handle_table_click(getattr(event, "cursor_row", None))
+    def on_data_table_row_highlighted(self, event: DataTable.RowHighlighted) -> None:
+        """Update the detail pane when selection changes."""
+        if event.data_table.id != RUNS_TABLE_ID:
+            return
+        self.cursor_index = event.cursor_row
+        self._render_detail(event.cursor_row)
 
-    def on_data_table_cell_selected(self, event: DataTable.CellSelected) -> None:  # pragma: no cover - UI hook
-        """Handle cell selection event from DataTable."""
-        row = getattr(event.coordinate, "row", None) if event.coordinate else None
-        self._handle_table_click(row)
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        """Show detail when a row is selected."""
+        if event.data_table.id != RUNS_TABLE_ID:
+            return
+        self.cursor_index = event.cursor_row
+        self._render_detail(event.cursor_row)
 
     def action_page_left(self) -> None:
-        """Navigate to the previous page."""
+        """Move to the previous page."""
         if not self.current_page.has_prev:
-            self._update_status("Already at the first page.", append=True)
+            self._set_status("Already on the first page.")
             return
         target_page = max(1, self.current_page.page - 1)
-        self._queue_page_load(
-            target_page,
-            loading_message="Loading previous page…",
-            failure_message="Failed to load previous page.",
-        )
+        self._queue_page_load(target_page, "Loading previous page...", "Failed to load previous page.")
 
     def action_page_right(self) -> None:
-        """Navigate to the next page."""
+        """Move to the next page."""
         if not self.current_page.has_next:
-            self._update_status("This is the last page.", append=True)
+            self._set_status("This is the last page.")
             return
         target_page = self.current_page.page + 1
-        self._queue_page_load(
-            target_page,
-            loading_message="Loading next page…",
-            failure_message="Failed to load next page.",
-        )
+        self._queue_page_load(target_page, "Loading next page...", "Failed to load next page.")
 
-    def _selected_run(self) -> Any | None:
-        """Return the currently highlighted run."""
-        if not self.current_rows:
-            return None
-        if self.cursor_index < 0 or self.cursor_index >= len(self.current_rows):
-            return None
-        return self.current_rows[self.cursor_index]
+    def action_transcript_page_up(self) -> None:
+        """Scroll the transcript up one page."""
+        self._transcript_log.action_page_up()
+
+    def action_transcript_page_down(self) -> None:
+        """Scroll the transcript down one page."""
+        self._transcript_log.action_page_down()
 
-    def action_open_detail(self) -> None:
-        """Open detail modal for the selected run."""
-        run = self._selected_run()
-        if not run:
-            self._update_status("No run selected.", append=True)
+    def action_focus_filter(self) -> None:
+        """Focus the filter input."""
+        if not hasattr(self, "_filter_input"):  # pragma: no cover - defensive
             return
-        if self._detail_loader_task and not self._detail_loader_task.done():
-            self._update_status("Already loading run detail. Please wait…", append=True)
+        self._filter_input.display = True
+        self._filter_input.focus()
+
+    def action_clear_filter(self) -> None:
+        """Clear filter and return focus to table."""
+        if not hasattr(self, "_filter_input"):  # pragma: no cover - defensive
             return
-        run_id = str(run.id)
-        self._show_loading("Loading run detail…", table_spinner=False, footer_message=False)
-        self._queue_detail_load(run_id)
+        if self._filter_input.has_focus or self._filter_input.display:
+            self._filter_input.value = ""
+            self._filter_text = ""
+            self._filter_input.display = False
+            if hasattr(self, "_runs_table"):
+                self._runs_table.focus()
+            self._render_page()
+
+    def action_app_exit(self) -> None:
+        """Exit the parent app."""
+        app = getattr(self, "app", None)
+        if app is not None:
+            app.exit()
 
-    async def action_export_run(self) -> None:
-        """Export the selected run via callback."""
-        run = self._selected_run()
-        if not run:
-            self._update_status("No run selected.", append=True)
+    def action_copy_run_id(self) -> None:
+        """Copy the run id to the clipboard."""
+        run = self._current_run()
+        if run is None:
+            self._set_status(RUNS_SELECT_FIRST_MESSAGE)
+            return
+        self._copy_to_clipboard(str(run.id), label="Run ID")
+
+    def action_copy_input(self) -> None:
+        """Copy the full input to the clipboard."""
+        run = self._current_run()
+        if run is None:
+            self._set_status(RUNS_SELECT_FIRST_MESSAGE)
             return
-        detail = self.callbacks.fetch_detail(str(run.id))
+        text = getattr(run, "input", "") or ""
+        if not text:
+            self._set_status("No input to copy.")
+            return
+        self._copy_to_clipboard(str(text), label="Input")
+
+    def action_copy_transcript(self) -> None:
+        """Copy the transcript to the clipboard."""
+        run = self._current_run()
+        if run is None:
+            self._set_status(RUNS_SELECT_FIRST_MESSAGE)
+            return
+        run_id = str(run.id)
+        detail = self._detail_cache.get(run_id)
         if detail is None:
-            self._update_status("Failed to load run detail for export.", append=True)
+            self._set_status("Transcript not loaded.")
             return
-        self._queue_export_job(str(run.id), detail)
 
-    def action_close_view(self) -> None:
-        """Handle quit bindings by closing detail views first, otherwise exiting."""
-        try:
-            if isinstance(self.screen, RunDetailScreen):
-                self.pop_screen()
-                self._clear_status()
-                return
-        except (AttributeError, RuntimeError) as e:
-            # App not fully initialized (common in tests), skip screen check
-            logger.debug("Cannot check screen state: app not fully initialized (%s)", type(e).__name__)
-        self.exit()
-
-    def _queue_page_load(self, target_page: int, *, loading_message: str, failure_message: str) -> None:
-        """Show a loading indicator and fetch a page after the next refresh."""
-        limit = self.current_page.limit
-        self._show_loading(loading_message, footer_message=False)
+        output = getattr(detail, "output", []) or []
+        if not output:
+            self._set_status("No transcript to copy.")
+            return
 
-        if self._page_loader_task and not self._page_loader_task.done():
-            self._update_status("Already loading a page. Please wait…", append=True)
+        if self._should_async_transcript(output):
+            self._set_status("Preparing transcript...")
+            try:
+                self.track_task(self._copy_transcript_async(list(output)))
+            except RuntimeError:
+                payload = json.dumps(output, indent=2, ensure_ascii=False, default=str)
+                self._copy_to_clipboard(payload, label="Transcript")
             return
 
-        loader_coro = self._load_page_async(target_page, limit, failure_message)
         try:
-            task = asyncio.create_task(loader_coro, name="remote-runs-fetch")
-        except RuntimeError:
-            logger.debug("No running event loop; loading page synchronously.")
-            loader_coro.close()
-            self._load_page_sync(target_page, limit, failure_message)
+            payload = json.dumps(output, indent=2, ensure_ascii=False, default=str)
+            self._copy_to_clipboard(payload, label="Transcript")
+        except Exception as exc:
+            self._set_status(f"Failed to serialize transcript: {exc}")
+
+    def action_copy_detail_json(self) -> None:
+        """Copy the run detail JSON to the clipboard."""
+        run = self._current_run()
+        if run is None:
+            self._set_status(RUNS_SELECT_FIRST_MESSAGE)
+            return
+        detail = self._get_or_load_detail(str(run.id))
+        if detail is None:
+            self._set_status("Run detail unavailable.")
+            return
+        output = self._detail_output(detail)
+        if self._should_async_transcript(output):
+            self._set_status("Preparing run JSON...")
+            try:
+                self.track_task(self._copy_detail_json_async(detail))
+            except RuntimeError:
+                payload = self._detail_json_payload(detail)
+                if payload is None:
+                    return
+                self._copy_to_clipboard(payload, label=RUNS_RUN_JSON_LABEL)
             return
-        except Exception:
-            loader_coro.close()
-            raise
-        task.add_done_callback(self._on_page_loader_done)
-        self._page_loader_task = task
+        payload = self._detail_json_payload(detail)
+        if payload is None:
+            return
+        self._copy_to_clipboard(payload, label=RUNS_RUN_JSON_LABEL)
 
-    def _queue_detail_load(self, run_id: str) -> None:
-        """Fetch run detail asynchronously with spinner feedback."""
-        loader_coro = self._load_detail_async(run_id)
+    def action_export_run(self) -> None:
+        """Export the selected run via callback."""
+        run = self._current_run()
+        if run is None:
+            self._set_status(RUNS_SELECT_FIRST_MESSAGE)
+            return
+        run_id = str(run.id)
+        detail = self._get_or_load_detail(run_id)
+        if detail is None:
+            self._set_status("Failed to load run detail for export.")
+            return
+        self._queue_export_job(run_id, detail)
+
+    def _render_page(self) -> None:
+        """Render the run list and refresh the detail pane."""
+        self._runs_table.clear()
+        self._current_rows = self.current_page.data[:]
+        self._visible_rows = [run for run in self._current_rows if self._matches_filter(run)]
+        for run in self._visible_rows:
+            self._runs_table.add_row(
+                Text(self._status_label(str(run.status)), style=self._status_style(str(run.status))),
+                self._format_started(getattr(run, "started_at", None)),
+                self._input_preview(run),
+            )
+
+        if self._visible_rows:
+            self.cursor_index = max(0, min(self.cursor_index, len(self._visible_rows) - 1))
+            self._runs_table.cursor_coordinate = Coordinate(self.cursor_index, 0)
+            if not self._filter_input.has_focus:
+                self._runs_table.focus()
+            self._render_detail(self.cursor_index)
+        else:
+            self._clear_detail()
+
+        total_pages = max(1, (self.current_page.total + self.current_page.limit - 1) // self.current_page.limit)
+        filter_suffix = f" | Filter: '{self._filter_text}'" if self._filter_text else ""
+        page_title = (
+            "Run History "
+            f"(Page {self.current_page.page}/{total_pages} | "
+            f"Page size={self.current_page.limit}{filter_suffix})"
+        )
+        self._page_title.update(page_title)
+        self._set_status("")
+
+    def _render_detail(self, row_index: int) -> None:
+        """Render the detail pane for the selected row."""
+        run = self._get_row(row_index)
+        if run is None:
+            self._clear_detail()
+            return
+        run_id = str(run.id)
+        detail = self._detail_cache.get(run_id)
+
+        detail_table = Table.grid(padding=(0, 1))
+        detail_table.add_column(style="bold cyan", no_wrap=True)
+        detail_table.add_column()
+        detail_table.add_row("Run ID", Text.assemble(run_id, " ", self._copy_hint("c")))
+        detail_table.add_row("Agent ID", str(getattr(run, "agent_id", "-")))
+        detail_table.add_row("Type", str(getattr(run, "run_type", "-")).title())
+        status_value = str(getattr(run, "status", "-")).upper()
+        detail_table.add_row("Status", Text(status_value, style=self._status_style(status_value)))
+        detail_table.add_row("Started (UTC)", self._format_timestamp(getattr(run, "started_at", None)))
+        detail_table.add_row("Completed (UTC)", self._format_timestamp(getattr(run, "completed_at", None)))
+        detail_table.add_row("Duration", self._format_duration(getattr(run, "duration_formatted", None)))
+        self._detail_meta.update(detail_table)
+        self._update_input_body(getattr(run, "input", None) or "-")
+
+        if detail is not None:
+            self._update_transcript(detail)
+        else:
+            self._update_transcript(None)
+            self._queue_detail_load(run_id)
+
+    def _clear_detail(self) -> None:
+        """Clear the detail pane when no rows are visible."""
+        self._detail_meta.update("No runs available.")
+        self._update_input_body("")
+        self._update_transcript(None)
+
+    def _update_input_body(self, text: str) -> None:
+        self._input_body.text = text or ""
+
+    def _queue_page_load(self, page: int, loading_message: str, failure_message: str) -> None:
+        if self._page_loader_task and not self._page_loader_task.done():
+            self._set_status("Already loading a page. Please wait.")
+            return
+        self._show_loading(loading_message, footer_message=False)
         try:
-            task = asyncio.create_task(loader_coro, name=f"remote-runs-detail-{run_id}")
+            task = self.track_task(self._load_page_async(page, self._limit, failure_message))
+            self._page_loader_task = task
         except RuntimeError:
-            logger.debug("No running event loop; loading run detail synchronously.")
-            loader_coro.close()
-            self._load_detail_sync(run_id)
-            return
-        except Exception:
-            loader_coro.close()
-            raise
-        task.add_done_callback(self._on_detail_loader_done)
-        self._detail_loader_task = task
+            self._load_page_sync(page, self._limit, failure_message)
 
     async def _load_page_async(self, page: int, limit: int, failure_message: str) -> None:
-        """Fetch the requested page in the background to keep the UI responsive."""
         try:
-            new_page = await asyncio.to_thread(self.callbacks.fetch_page, page, limit)
-        except Exception as exc:  # pragma: no cover - defensive logging for unexpected errors
-            logger.exception("Failed to fetch remote runs page %s: %s", page, exc)
+            new_page = await asyncio.to_thread(self._runs_callbacks.fetch_page, page, limit)
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.exception("Failed to fetch runs page %s: %s", page, exc)
             new_page = None
         finally:
+            self._page_loader_task = None
             self._hide_loading()
 
         if new_page is None:
-            self._update_status(failure_message)
+            self._set_status(failure_message)
             return
-        self._render_page(new_page)
+        self.current_page = new_page
+        self._limit = new_page.limit
+        self.cursor_index = 0
+        self._render_page()
 
     def _load_page_sync(self, page: int, limit: int, failure_message: str) -> None:
-        """Fallback for fetching a page when asyncio isn't active (tests)."""
         try:
-            new_page = self.callbacks.fetch_page(page, limit)
-        except Exception as exc:  # pragma: no cover - defensive logging for unexpected errors
-            logger.exception("Failed to fetch remote runs page %s: %s", page, exc)
+            new_page = self._runs_callbacks.fetch_page(page, limit)
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.exception("Failed to fetch runs page %s: %s", page, exc)
             new_page = None
         finally:
+            self._page_loader_task = None
             self._hide_loading()
 
         if new_page is None:
-            self._update_status(failure_message)
-            return
-        self._render_page(new_page)
-
-    def _on_page_loader_done(self, task: asyncio.Task[Any]) -> None:
-        """Reset loader state and surface unexpected failures."""
-        self._page_loader_task = None
-        if task.cancelled():
+            self._set_status(failure_message)
             return
-        exc = task.exception()
-        if exc:
-            logger.debug("Page loader encountered an error: %s", exc)
+        self.current_page = new_page
+        self._limit = new_page.limit
+        self.cursor_index = 0
+        self._render_page()
 
-    def _on_detail_loader_done(self, task: asyncio.Task[Any]) -> None:
-        """Reset state for the detail fetch task."""
-        self._detail_loader_task = None
-        if task.cancelled():
+    def _queue_detail_load(self, run_id: str) -> None:
+        if self._detail_loading_id == run_id and self._detail_loader_task and not self._detail_loader_task.done():
             return
-        exc = task.exception()
-        if exc:
-            logger.debug("Detail loader encountered an error: %s", exc)
+        self._detail_loading_id = run_id
+        self._show_loading("Loading run detail...", footer_message=False)
+        try:
+            task = self.track_task(self._load_detail_async(run_id))
+            self._detail_loader_task = task
+        except RuntimeError:
+            self._load_detail_sync(run_id)
 
     async def _load_detail_async(self, run_id: str) -> None:
-        """Retrieve run detail via background thread."""
         try:
-            detail = await asyncio.to_thread(self.callbacks.fetch_detail, run_id)
-        except Exception as exc:  # pragma: no cover - defensive logging for unexpected errors
-            logger.exception("Failed to load run detail %s: %s", run_id, exc)
+            detail = await asyncio.to_thread(self._runs_callbacks.fetch_detail, run_id)
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.exception(RUNS_DETAIL_LOG_MESSAGE, run_id, exc)
             detail = None
         finally:
+            self._detail_loader_task = None
             self._hide_loading()
-        self._present_run_detail(detail)
+        self._handle_detail_loaded(run_id, detail)
 
     def _load_detail_sync(self, run_id: str) -> None:
-        """Synchronous fallback for fetching run detail."""
         try:
-            detail = self.callbacks.fetch_detail(run_id)
-        except Exception as exc:  # pragma: no cover - defensive logging for unexpected errors
-            logger.exception("Failed to load run detail %s: %s", run_id, exc)
+            detail = self._runs_callbacks.fetch_detail(run_id)
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.exception(RUNS_DETAIL_LOG_MESSAGE, run_id, exc)
             detail = None
         finally:
+            self._detail_loader_task = None
             self._hide_loading()
-        self._present_run_detail(detail)
+        self._handle_detail_loaded(run_id, detail)
 
-    def _present_run_detail(self, detail: Any | None) -> None:
-        """Push the detail modal or surface an error."""
+    def _handle_detail_loaded(self, run_id: str, detail: Any | None) -> None:
+        self._detail_loading_id = None
         if detail is None:
-            self._update_status("Failed to load run detail.", append=True)
+            self._set_status("Failed to load run detail.")
             return
-        self.push_screen(RunDetailScreen(detail, on_export=self.queue_export_from_detail, ctx=self._ctx))
-        self._update_status("Detail view: ↑/↓ scroll · PgUp/PgDn · q/Esc close · c copy ID · C copy JSON · e export")
-
-    def queue_export_from_detail(self, detail: Any) -> None:
-        """Start an export from the detail modal."""
-        run_id = getattr(detail, "id", None)
-        if not run_id:
-            self._update_status("Cannot export run without an identifier.", append=True)
-            return
-        self._queue_export_job(str(run_id), detail)
+        self._detail_cache[run_id] = detail
+        selected = self._current_run()
+        if selected and str(selected.id) == run_id:
+            self._update_transcript(detail)
+
+    def _get_or_load_detail(self, run_id: str) -> Any | None:
+        detail = self._detail_cache.get(run_id)
+        if detail is not None:
+            return detail
+        try:
+            detail = self._runs_callbacks.fetch_detail(run_id)
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.exception(RUNS_DETAIL_LOG_MESSAGE, run_id, exc)
+            detail = None
+        if detail is not None:
+            self._detail_cache[run_id] = detail
+            self._update_transcript(detail)
+        return detail
 
     def _queue_export_job(self, run_id: str, detail: Any) -> None:
-        """Schedule the export coroutine so it can suspend cleanly."""
-
-        async def runner() -> None:
+        async def runner() -> None:  # pragma: no cover - defensive
             await self._perform_export(run_id, detail)
 
         try:
-            self.run_worker(runner(), name="export-run", exclusive=True)
-        except Exception:
-            # Store task to prevent premature garbage collection
-            export_task = asyncio.create_task(runner())
-            # Keep reference to prevent GC (task will complete on its own)
-            self._active_export_tasks.add(export_task)
-            export_task.add_done_callback(self._active_export_tasks.discard)
+            run_worker = getattr(cast(Any, self), "run_worker", None)
+            if callable(run_worker):
+                run_worker(runner(), name="export-run", exclusive=True)
+            else:
+                raise AttributeError("run_worker not available")
+        except Exception:  # pragma: no cover - defensive
+            self.track_task(runner())
 
     async def _perform_export(self, run_id: str, detail: Any) -> None:
-        """Execute the export callback with suspend mode."""
         try:
-            with self.suspend():
-                success = bool(self.callbacks.export_run(run_id, detail))
+            app = getattr(self, "app", None)
+            if app is None:
+                success = bool(self._runs_callbacks.export_run(run_id, detail))
+            else:
+                with app.suspend():
+                    success = bool(self._runs_callbacks.export_run(run_id, detail))
         except Exception as exc:  # pragma: no cover - defensive
             logger.exception("Export failed: %s", exc)
-            self._update_status(f"Export failed: {exc}", append=True)
+            self._set_status(f"Export failed: {exc}")
             return
 
         if success:
-            self._update_status("Export complete (see slash console for path).", append=True)
+            self._set_status("Export complete (see slash console for path).")
         else:
-            self._update_status("Export cancelled.", append=True)
+            self._set_status("Export cancelled.")
 
-    def _show_loading(
-        self,
-        message: str | None = None,
-        *,
-        table_spinner: bool = True,
-        footer_message: bool = True,
-    ) -> None:
-        """Display the loading indicator with an optional status message."""
+    def _show_loading(self, message: str | None = None, *, footer_message: bool = True) -> None:
         show_loading_indicator(
             self,
             RUNS_LOADING_SELECTOR,
             message=message,
-            set_status=self._update_status if footer_message else None,
+            set_status=self._set_status if footer_message else None,
         )
-        self._set_table_loading(table_spinner)
-        self._table_spinner_active = table_spinner
 
     def _hide_loading(self) -> None:
-        """Hide the loading indicator."""
         hide_loading_indicator(self, RUNS_LOADING_SELECTOR)
-        if self._table_spinner_active:
-            self._set_table_loading(False)
-            self._table_spinner_active = False
 
-    def _set_table_loading(self, is_loading: bool) -> None:
-        """Toggle the DataTable loading shimmer."""
+    def _ensure_toast_bus(self) -> None:
+        def _notify(message: ToastBus.Changed) -> None:  # pragma: no cover - defensive
+            # Post to self (Screen) so ToastHandlerMixin.on_toast_bus_changed can handle it.
+            self.post_message(message)
+
+        if self._local_toasts is not None:
+            self._local_toasts.subscribe(_notify)
+            return
+
+        if self._ctx and self._ctx.toasts is not None:  # pragma: no cover - defensive
+            self._local_toasts = self._ctx.toasts  # pragma: no cover - defensive
+            self._local_toasts.subscribe(_notify)  # pragma: no cover - defensive
+            return  # pragma: no cover - defensive
+        self._local_toasts = ToastBus(on_change=_notify)
+        if self._ctx:
+            self._ctx.toasts = self._local_toasts
+
+    def _announce_status(self, message: str) -> None:
+        self._set_status(message)
+
+    def _append_copy_fallback(self, text: str) -> None:
+        self._transcript_log.write(Text(text))
+        self._transcript_log.write(Text(""))
+
+    def _set_status(self, message: str) -> None:
+        self._status_line.update(message)
+
+    def _should_async_transcript(self, output: Any) -> bool:
+        if not isinstance(output, list):
+            return False
+        return len(output) > TRANSCRIPT_ASYNC_THRESHOLD
+
+    @staticmethod
+    def _detail_output(detail: Any) -> Any:
+        if isinstance(detail, dict):
+            return detail.get("output")
+        return getattr(detail, "output", None)
+
+    @staticmethod
+    def _serialize_transcript(output: list[Any]) -> list[str]:
+        return [json.dumps(chunk, indent=2, ensure_ascii=False, default=str) for chunk in output]
+
+    async def _render_transcript_async(self, output: list[Any], token: int) -> None:
         try:
-            table = self.query_one(RUNS_TABLE_SELECTOR, DataTable)
-            table.loading = is_loading
-        except (AttributeError, RuntimeError) as e:
-            logger.debug("Cannot toggle table loading state: %s", type(e).__name__)
+            rendered = await asyncio.to_thread(self._serialize_transcript, output)
+        except Exception as exc:
+            self.call_after_refresh(self._render_transcript_error, token, exc)
+            return
+        self.call_after_refresh(self._apply_transcript_render, token, rendered)
+
+    def _apply_transcript_render(self, token: int, rendered: list[str]) -> None:
+        if token != self._transcript_render_token:
+            return
+        self._transcript_log.clear()
+        if not rendered:
+            self._transcript_log.write("No transcript available.")
+            return
+        for json_str in rendered:
+            self._transcript_log.write(Syntax(json_str, "json", theme="monokai", word_wrap=True))
+            self._transcript_log.write("")
+
+    def _render_transcript_error(self, token: int, exc: Exception) -> None:
+        if token != self._transcript_render_token:
+            return
+        self._transcript_log.clear()
+        self._transcript_log.write(f"Failed to render transcript: {exc}")
+
+    def _update_transcript(self, detail: Any | None) -> None:
+        self._transcript_log.clear()
+        self._transcript_render_token += 1
+        token = self._transcript_render_token
+        if detail is None:
+            self._transcript_log.write("Loading transcript...")
+            return
+        output = self._detail_output(detail)
+        if not output:
+            self._transcript_log.write("No transcript available.")
+            return
+        if self._should_async_transcript(output):
+            self._transcript_log.write("Rendering transcript...")
+            try:
+                self._transcript_render_task = self.track_task(self._render_transcript_async(list(output), token))
+            except RuntimeError:
+                rendered = self._serialize_transcript(list(output))
+                self._apply_transcript_render(token, rendered)
+            return
+        for chunk in output:
+            json_str = json.dumps(chunk, indent=2, ensure_ascii=False, default=str)
+            self._transcript_log.write(Syntax(json_str, "json", theme="monokai", word_wrap=True))
+            self._transcript_log.write("")
+
+    async def _copy_transcript_async(self, output: list[Any]) -> None:
+        try:
+            payload = await asyncio.to_thread(json.dumps, output, indent=2, ensure_ascii=False, default=str)
+        except Exception as exc:
+            self.call_after_refresh(self._set_status, f"Failed to serialize transcript: {exc}")
+            return
+        self.call_after_refresh(lambda: self._copy_to_clipboard(payload, label="Transcript"))
+
+    async def _copy_detail_json_async(self, detail: Any) -> None:
+        payload, error = self._detail_payload(detail)
+        if error:
+            self.call_after_refresh(self._set_status, error)
+            return
+        if isinstance(payload, str):
+            self.call_after_refresh(lambda: self._copy_to_clipboard(payload, label=RUNS_RUN_JSON_LABEL))
+            return
+        try:
+            json_payload = await asyncio.to_thread(
+                json.dumps,
+                payload,
+                indent=2,
+                ensure_ascii=False,
+                default=str,
+            )
+        except Exception as exc:
+            self.call_after_refresh(self._set_status, f"Failed to serialize run detail: {exc}")
+            return
+        self.call_after_refresh(lambda: self._copy_to_clipboard(json_payload, label=RUNS_RUN_JSON_LABEL))
+
+    def _detail_payload(self, detail: Any | None) -> tuple[Any | None, str | None]:
+        if detail is None:
+            return None, "Run detail unavailable."
+        if isinstance(detail, str):
+            return detail, None
+        if isinstance(detail, dict):
+            return detail, None
+        if hasattr(detail, "model_dump"):
+            return detail.model_dump(mode="json"), None
+        if hasattr(detail, "dict"):
+            return detail.dict(), None
+        return getattr(detail, "__dict__", {"value": detail}), None
+
+    def _detail_json_payload(self, detail: Any | None) -> str | None:
+        payload, error = self._detail_payload(detail)
+        if error:
+            self._set_status(error)
+            return None
+        if isinstance(payload, str):
+            return payload
+        try:
+            return json.dumps(payload, indent=2, ensure_ascii=False, default=str)
+        except Exception as exc:
+            self._set_status(f"Failed to serialize run detail: {exc}")
+            return None
+
+    def _format_timestamp(self, value: datetime | None) -> str:
+        if value is None:
+            return "-"
+        try:
+            return value.strftime("%Y-%m-%d %H:%M:%S")
+        except Exception:  # pragma: no cover - defensive
+            return str(value)
+
+    def _format_started(self, value: datetime | None) -> str:
+        if value is None:
+            return "-"
+        try:
+            # Short format: "Jan 02 14:30" (Mon DD HH:MM)
+            # This avoids year (redundant for recent) and TZ noise in the table
+            if value.tzinfo:
+                value = value.astimezone(UTC)
+            return value.strftime("%b %d %H:%M")
+        except Exception:  # pragma: no cover - defensive
+            return str(value)
+
+    def _format_duration(self, formatter: Any) -> str:
+        if callable(formatter):
+            try:
+                value = formatter()
+            except Exception:  # pragma: no cover - defensive
+                value = None
+        else:
+            value = None
+        if not value:
+            return "-"
+        return str(value).replace("\u2014", "-")
+
+    def _agent_context_label(self) -> str:
+        if self._agent_name and self._agent_id:
+            return f"Agent: {self._agent_name} ({self._agent_id})"
+        if self._agent_name:
+            return f"Agent: {self._agent_name}"
+        if self._agent_id:
+            return f"Agent: {self._agent_id}"
+        return "Agent runs"
+
+    def _input_preview(self, run: Any) -> str:
+        text = getattr(run, "input", None) or ""
+        # Strip common prefixes to increase information density
+        text = str(text).replace("Execute the ", "").replace(" tool with", "")
+
+        # Try to parse "tool_name: args" pattern without regex to avoid backtracking.
+        parts = text.split(None, 1)
+        if len(parts) == 2:
+            tool, args = parts
+            if tool and args:
+                text = f"{tool}: {args}"
+
+        # Reduce whitespace
+        preview = " ".join(text.split())
+        if not preview:
+            return "-"
+        if len(preview) > self._preview_limit:
+            return preview[: self._preview_limit - 3] + "..."
+        return preview
+
+    def _matches_filter(self, run: Any) -> bool:
+        if not self._filter_text:
+            return True
+        haystack = " ".join(
+            [
+                str(getattr(run, "input", "")),
+                str(getattr(run, "run_type", "")),
+                str(getattr(run, "status", "")),
+            ]
+        ).lower()
+        return self._filter_text in haystack
+
+    def _get_row(self, row_index: int) -> Any | None:
+        if not self._visible_rows:
+            return None
+        row_index = max(0, min(row_index, len(self._visible_rows) - 1))
+        return self._visible_rows[row_index]
+
+    def _current_run(self) -> Any | None:
+        if not self._visible_rows:
+            return None
+        return self._get_row(self.cursor_index)
+
+    @staticmethod
+    def _status_label(status: str | None) -> str:
+        if not status:
+            return "-"
+        normalized = str(status).strip().lower()
+        if normalized in {"ok", "success", "completed", "succeeded"}:
+            return "✔"
+        if normalized in {"running", "in_progress"}:
+            return "⟳"
+        if normalized in {"failed", "error", "errored"}:
+            return "✖"
+        if normalized in {"aborted", "cancelled", "canceled"}:
+            return "⊘"
+        return normalized[:3].upper()
+
+    @staticmethod
+    def _status_style(status: str | None) -> str:
+        if not status:
+            return "dim"
+        normalized = str(status).strip().lower()
+        if normalized in {"ok", "success", "completed", "succeeded"}:
+            return "green"
+        if normalized in {"running", "in_progress", "run"}:
+            return "yellow"
+        if normalized in {"failed", "error", "errored", "err", "aborted", "cancelled", "canceled", "abt"}:
+            return "red"
+        return "cyan"
+
+
+class _HarlequinRunsApp(App[None]):
+    """App wrapper that hosts the Harlequin runs screen."""
+
+    def __init__(
+        self,
+        initial_page: Any,
+        cursor_idx: int,
+        callbacks: RemoteRunsTUICallbacks,
+        *,
+        agent_name: str | None = None,
+        agent_id: str | None = None,
+        ctx: TUIContext | None = None,
+    ) -> None:
+        super().__init__()
+        self._initial_page = initial_page
+        self._initial_cursor = cursor_idx
+        self._callbacks = callbacks
+        self._agent_name = agent_name
+        self._agent_id = agent_id
+        self._ctx = ctx
+        self.current_page = initial_page
+        self.cursor_index = cursor_idx
+
+    def on_mount(self) -> None:
+        screen = RunsHarlequinScreen(
+            self._initial_page,
+            self._initial_cursor,
+            self._callbacks,
+            agent_name=self._agent_name,
+            agent_id=self._agent_id,
+            ctx=self._ctx,
+        )
+        self.push_screen(cast(Screen, screen))
+
+    def on_screen_resume(self, event: Any) -> None:  # pragma: no cover - UI hook
+        screen = getattr(event, "screen", None)
+        if isinstance(screen, RunsHarlequinScreen):
+            self.current_page = screen.current_page
+            self.cursor_index = screen.cursor_index