Run screen

def render(self) -> Text:
    """Compose the row content as a Rich Text line.

    Returns:
        Text: An icon, the phase label, and an optional progress
        counter, separated by a space.
    """
    icon = _PHASE_ICONS.get(self._phase.status, "?")
    suffix = f"  {self._phase.progress}" if self._phase.progress else ""
    return Text.from_markup(f"{icon}  {self._phase.label}{suffix}")

def update_phase(self, phase: Phase) -> None:
    """Replace the row's contents and CSS class with ``phase``.

    Args:
        phase (Phase): The new phase data; only fields whose values
            differ from the previous render trigger a refresh.
    """
    if phase == self._phase:
        return
    self._phase = phase
    self.remove_class("-pending", "-running", "-done")
    self.add_class(f"-{phase.status}")
    self.refresh()

def compose(self) -> ComposeResult:
    """Build the screen layout.

    Yields:
        ComposeResult: Header panel, sidebar with one
        :class:`PhaseRow` per pipeline phase, the messages
        :class:`RichLog`, and a status footer.
    """
    yield Static(
        make_run_header_panel(
            ticker=self.params.ticker, trade_date=self.params.date, config=self._config
        ),
        id="run-header",
    )
    with Horizontal(id="run-body"):
        with Vertical(id="phase-sidebar"):
            yield Static("Phases", id="phase-sidebar-title")
            for phase in self._initial_phases():
                yield PhaseRow(phase)
        yield RichLog(
            id="messages", wrap=True, markup=False, highlight=False, auto_scroll=True
        )
    yield Static("Initialising...", id="run-status")

def on_mount(self) -> None:
    """Cache widget references and kick off the pipeline worker."""
    self._log = self.query_one("#messages", RichLog)
    self._status = self.query_one("#run-status", Static)
    self.run_pipeline()

def action_quit_screen(self) -> None:
    """Exit the app, returning the final decision (or None) to ``run_tui``."""
    self.app.exit(self._final_decision)

@work(thread=True, exclusive=True)
def run_pipeline(self) -> None:
    """Run :meth:`TradingAgentsGraph.propagate` on a worker thread.

    Constructs a :class:`MessageRenderer` whose ``emit`` defers each
    Rich renderable to the Textual event loop, and an ``on_state``
    hook that recomputes the sidebar phase list from the latest
    :class:`AgentState` snapshot. All UI mutations are routed
    through :meth:`App.call_from_thread` via :meth:`_safe_call` so
    the worker unwinds quietly when the user quits mid-run; a
    broken hook can never abort a paid LLM call once it has
    started.
    """
    log = self._log
    if log is None:
        raise RuntimeError("run_pipeline invoked before on_mount cached the RichLog")

    def emit(renderable: object) -> None:
        self._safe_call(log.write, renderable)

    renderer = MessageRenderer(emit=emit)

    def on_state(state: AgentState) -> None:
        self._safe_call(self._update_phases_from_state, state)

    self._safe_call(self._set_status, "Running pipeline...")

    try:
        ta = TradingAgentsGraph(
            debug=self.params.debug,
            config=self._config,
            selected_analysts=self.params.selected_analysts,
        )
        _, decision = ta.propagate(
            self.params.ticker, self.params.date, on_message=renderer, on_state=on_state
        )
    except Exception as exc:
        logger.exception("TUI pipeline run failed")
        self._safe_call(self._on_error, exc)
        return

    self._safe_call(self._on_done, decision)