rich_presenter.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# oc_ui/terminal/rich_presenter.py
 
"""
Rich-based presenter for OC Chat (Phase 1.A — skeleton).
 
Purpose
-------
Implements the :class:`~oc_ui.presenter_base.Presenter` contract
using the `rich <https://rich.readthedocs.io/>`_ library. This first
slice (PR 1.A) ships:
 
* Styled welcome banner via ``rich.panel.Panel``.
* Pretty tables for ``/models``, ``/session list``, ``/help`` via
  ``rich.table.Table`` — auto column-widths, overflow handling,
  borders.
* Consistent colour theme for info/error/compressed/turn-summary
  lines.
* No streaming overlay yet — :meth:`turn` is a no-op contextmanager
  and :meth:`show_reasoning` / :meth:`show_content` print each chunk
  via ``Console.print(end="")``. Live streaming + Markdown post-commit
  arrive in PR 1.B.
 
To enable, install the optional dep::
 
    pip install -e .[rich]
 
Then run::
 
    python OC Chat.py --ui rich
 
If ``rich`` is missing, ``oc_chat.main`` lazy-imports this module and
falls back to :class:`~oc_ui.terminal.presenter.ConsolePresenter`
with a warning.
 
Responsibilities
----------------
- :class:`RichPresenter` — concrete :class:`Presenter` backed by
  ``rich.console.Console``.
- Themed output via :class:`rich.panel.Panel` and
  :class:`rich.table.Table` for the structured commands.
- Plain ``Console.print`` fallback for streaming chunks pending
  the PR 1.B Live overlay.
 
Diagnostics
-----------
Domain: OC_UI.TERMINAL
Levels:
    L2 — lifecycle events
    L3 — semantic details
    L4 — deep tracing
 
Contracts
---------
- Importing this module without ``rich`` installed raises
  :class:`ImportError`; ``main.py`` is responsible for the optional-
  dep gate.
- Theme colours are taken from one ``rich.theme.Theme`` instance so
  callers can override centrally.
- Behavioural parity with :class:`ConsolePresenter` for any non-
  streaming hook — the rich version only adds visual polish.
 
Dependencies
------------
- oc_diagnostics (structured debug logging via _dbg)
- rich.console (terminal rendering — panels, tables, syntax highlighting)
- rich.live (terminal rendering — panels, tables, syntax highlighting)
- rich.markdown (terminal rendering — panels, tables, syntax highlighting)
- rich.padding (terminal rendering — panels, tables, syntax highlighting)
- rich.panel (terminal rendering — panels, tables, syntax highlighting)
- rich.status (terminal rendering — panels, tables, syntax highlighting)
- rich.table (terminal rendering — panels, tables, syntax highlighting)
- rich.text (terminal rendering — panels, tables, syntax highlighting)
- oc_ui.presenter_base (Presenter ABC contract)
- oc_ui.terminal._render (RenderBatcher for batched Live refreshes while streaming)
- oc_ui.terminal.activity (plan_progress_from_result for the plan progress line under planner results)
- oc_ui.terminal.diffview (mutation argument pairing and the diff model for write_file and edit_file results)
- oc_ui.terminal.statusline (StatusBarState and status line rendering for the Live status bar)
- oc_ui.terminal.turn_layout (turn indent, rule composition and answer box titles)
- oc_chat.core.commands (lazy; _fmt_tokens_display for the session list table)
- oc_chat.core.config (lazy; REASONING_EFFORT_LEVELS for the welcome panel)
- oc_chat.core.formatting (lazy; format_duration for the turn summary)
- oc_chat.core.iteration_stat (lazy; iteration_stat_human_line for the answer box bottom border and stats line)
- oc_chat.core.persistence (lazy; save_tool_artifact for spilling long tool results to a file)
- oc_chat.core.session (lazy; ChatSession type hint for bind_session and show_welcome)
- oc_chat.core.tool_activity (lazy; TOOL_ACTIVITY snapshot of the in-flight tool call for the status bar)
- oc_ui.terminal.presenter (lazy; ConsolePresenter._fmt_turn_cost for the shared turn cost segment)
- rich.spinner (animated spinners for the waiting indicator and dispatch chrome)
"""
from __future__ import annotations
 
import json
from contextlib import contextmanager
from datetime import datetime
from typing import TYPE_CHECKING, Callable, Iterator
 
from oc_diagnostics import _dbg
 
if TYPE_CHECKING:
    from oc_chat.core.session import ChatSession
 
import os
 
from rich.console import Console, Group, RenderableType
from rich.live import Live
from rich.markdown import Markdown
from rich.padding import Padding
from rich.panel import Panel
from rich.spinner import Spinner
from rich.status import Status
from rich.table import Table
from rich.text import Text
 
from oc_ui.presenter_base import INTERRUPT_NOTICES, Presenter, SpinnerHandle
from oc_ui.terminal.activity import plan_progress_from_result
from oc_ui.terminal.diffview import (
    DiffRender,
    MutationArgsLedger,
    build_mutation_diff,
    diff_footer_line,
    diff_header_line,
    summarize_mutation_call,
)
from oc_ui.terminal.statusline import (
    StatusBarState,
    busy_hint_text,
    busy_label_with_activity,
    busy_width_left,
    render_status_line,
)
from oc_ui.terminal.turn_layout import (
    ANSWER_BOX_TITLE,
    REASONING_TITLE,
    TURN_INDENT,
    compose_rule,
    rule_fits,
    running_total_text,
    start_rule_label,
    turn_end_rule_segments,
    turn_rule_label,
)
from ._render import RenderBatcher
 
# How big a tool-result string must be before we spill it to a file
# instead of dumping it to scrollback.  Configurable per-session via
# ``meta.json[ui][tool_spill_chars]``.
DEFAULT_TOOL_SPILL_CHARS = 4000
 
 
# ─── Theme ────────────────────────────────────────────────────────────────────
# A single source of truth for colour choices.  PR 1.D will make this
# user-configurable via /ui theme; for PR 1.A the values are baked in.
_THEME = {
    "rule":        "dim cyan",
    "turn_label":  "dim",
    "waiting":     "italic dim cyan",
    "reasoning":   "dim italic cyan",
    "content":     "default",
    "tool_call":   "yellow",
    "tool_result": "green",
    "tool_error":  "red",
    "info":        "dim",
    "error":       "bold red",
    "warning":     "yellow",
    "compressed":  "dim",
    "summary":     "dim",
    "panel_border": "cyan",
    "panel_title":  "bold cyan",
    # Plan 188 T1 — diff view. Rich honours NO_COLOR natively, so these degrade
    # to plain text without a separate code path.
    "diff_add":    "green",
    "diff_del":    "red",
    "diff_hunk":   "cyan",
    "diff_header": "dim",
}
 
 
#: Rule-segment tag → theme key (plan 218 P3). The fill keeps the rule's
#: colour; the label keeps the rule TITLE's colour (they were one style
#: pre-218); the absorbed stats and the running total keep the summary
#: colour the standalone stats line and the rprompt already used. Moving
#: text into a new position must never repaint it.
_RULE_TAG_STYLES = {
    "fill": "rule",
    "label": "rule",
    "stats": "summary",
    "trailer": "summary",
}
 
 
def build_answer_panel(body: RenderableType, subtitle: str = "") -> Panel:
    """Build the plan-218 answer box.
 
    P1 element 2/3: ``Assistant Answer:`` is cut into the TOP border
    (left-aligned — the session box's own title-in-border mechanic, just
    anchored left per the operator's mock) and the per-iteration metadata
    line is cut into the BOTTOM border, so the numbers that describe the
    answer are attached to the answer instead of floating under it.
 
    Every style token is borrowed from the session box
    (:meth:`RichPresenter.show_welcome`) rather than invented: same
    ``panel_border`` colour, same default box, same ``(1, 2)`` padding.
    P3 — no new colours.
 
    *subtitle* is the metadata string; empty renders a plain bottom
    border (a turn whose iteration stats are suppressed still closes its
    box — it just closes it without numbers).
    """
    return Panel(
        body,
        title=ANSWER_BOX_TITLE,
        title_align="left",
        subtitle=subtitle or None,
        border_style=_THEME["panel_border"],
        padding=(1, 2),
    )
 
 
class _StatusBarLive:
    """Time-aware Live-region renderable for the D3 status bar + D4 hint line.
 
    Rich's ``Live`` auto-refresh (``refresh_per_second`` / ``auto_refresh``,
    both left at their existing values per the D3 pin) re-renders whatever
    renderable object is currently stored by calling its ``__rich_console__``
    afresh on every tick — but a plain ``rich.text.Text`` bakes its string in
    at construction time, so re-rendering the SAME ``Text`` object forever
    reproduces the SAME string (the "never ticks" hazard). This class defers
    every computation into ``__rich_console__`` itself so each Rich render
    pass — not just each explicit ``Live.update()`` call — reads a fresh
    :class:`~oc_ui.terminal.statusline.StatusBarState` snapshot and a fresh
    elapsed duration. Reusable as the trailing element of both the streaming
    Live group (regime b) and the dispatch-chrome Live group (regime c) —
    "one renderable definition, three hosts" per the plan.
    """
 
    def __init__(self, presenter: "RichPresenter") -> None:
        self._presenter = presenter
 
    def _busy_label_with_activity(self, state, width: int) -> "str | None":
        """The presenter's busy label, plus the in-flight tool call (plan 279 P4).
 
        Read fresh on every render pass, exactly as the status snapshot and the
        busy label already are, so the tool's elapsed time ticks for the same
        reason the turn timer does. With no call in flight this returns the busy
        label untouched and the bar renders byte-identically to the pre-279 one.
 
        The tail is budgeted from what the bar has SPARE once the label and
        duration are laid out, so it can only ever occupy space no state segment
        wanted — it is the first thing to shrink and the first to go.
        """
        from oc_chat.core.tool_activity import TOOL_ACTIVITY
 
        busy_label = self._presenter._busy_label
        activity = TOOL_ACTIVITY.snapshot()
        if activity is None:
            return busy_label
        label = busy_label or activity.name
        elapsed_ms = activity.elapsed_ms()
        base = busy_label_with_activity(label, elapsed_ms, None, width)
        return busy_label_with_activity(
            label, elapsed_ms, activity.last_line, busy_width_left(state, base, width))
 
    def __rich_console__(self, console, options):
        presenter = self._presenter
        if presenter._status_provider is None:
            return
        state = presenter._status_provider()
        if state is None:
            return
        busy_label = self._busy_label_with_activity(state, console.width)
        _segments, line = render_status_line(state, busy_label, console.width)
        # D3 pin: "never wrap" — render_status_line already drops segments to
        # fit target_width, but the always-on core (model/name/busy/turn/
        # session) can still overflow a very narrow console; no_wrap +
        # ellipsis crops instead of letting Rich word-wrap to a second line.
        yield Text(line, style=_THEME["summary"], no_wrap=True, overflow="ellipsis")
        yield Text(busy_hint_text(busy=True), style=_THEME["info"],
                   no_wrap=True, overflow="ellipsis")
 
 
class RichPresenter(Presenter):
    """Rich-styled console presenter.
 
    Phase 1.A: feature-parity with :class:`ConsolePresenter` but rendered
    through ``rich.console.Console``.  The streaming loop still emits
    chunks one at a time via ``Console.print(end="")`` — Live will arrive
    in PR 1.B.
 
    *verbose* toggles per-iteration ``show_usage`` rendering.
    """
 
    def __init__(self, verbose: bool = False, console: Console | None = None,
                 fps: int = 15, code_theme: str = "monokai") -> None:
        func = "__init__"
        # ``soft_wrap=True`` lets Rich respect the user's terminal width
        # naturally.  Outside of the Live region, chunks are printed with
        # ``end=""`` so wrap decisions stay consistent.
        self._console = console or Console(soft_wrap=True, highlight=False)
        self.verbose = verbose
        self._fps = fps
        self._code_theme = code_theme
        self._reasoning_shown = False
        self._content_shown = False
        _dbg("OC_UI.TERMINAL", func, f"RichPresenter verbose={verbose} fps={fps}", 2)
        self._waiting_active = False
        self._turn_number = 0
        # Streaming state — set up by ``turn()`` and consumed by
        # ``show_reasoning`` / ``show_content``.
        self._live: Live | None = None
        self._content_buf = ""
        self._reasoning_buf = ""
        self._batcher: RenderBatcher | None = None
        # PR 1.C: tool spinner + artifact spilling.
        self._tool_status: Status | None = None
        # Bound by ``main()`` after session selection so the presenter
        # can write artifacts into the active session's directory.  None
        # means "skip spilling" — useful in tests.
        self._session_name: str | None = None
        # PR 1.C: reasoning visibility preference (mirrors meta.json[ui][show_reasoning]).
        # Default is "dim" (truncated, dim italic).  Env var overrides per-session.
        self._show_reasoning_pref: str = "dim"
        env_cot = os.getenv("OC_CHAT_SHOW_COT", "").strip().lower()
        if env_cot in ("0", "false", "hide", "no", "off"):
            self._show_reasoning_pref = "hide"
        elif env_cot in ("1", "true", "show", "expand"):
            self._show_reasoning_pref = "show"
        # Plan 147 D5: 'dim' tail line count (mirrors meta.json[ui][reasoning_tail]).
        # Literal default (matches commands.UI_REASONING_TAIL_DEFAULT) rather
        # than importing oc_chat.core.commands here, same as the existing
        # "show"/"dim"/"hide" literals above — avoids a module-load-time
        # dependency from oc_ui back into oc_chat.core. No env override:
        # OC_CHAT_SHOW_COT keeps its existing show|dim|hide-only grammar; the
        # tail is session-pref-only.
        self._reasoning_tail: int = 5
        # Plan 147 D1/D3/D4: the late-binding status-snapshot provider (set
        # via bind_status) and the presenter-owned current-activity label
        # (set by show_waiting / spinner_start, cleared by spinner_stop /
        # first-chunk). Neither is a StatusBarState field — see D1.
        self._status_provider: Callable[[], StatusBarState | None] | None = None
        self._busy_label: str | None = None
        # Plan 188 T1: pairs a mutation tool's call arguments with its result so
        # ``show_tool_result`` can render a diff instead of truncated JSON.
        self._mutation_args = MutationArgsLedger()
        # Plan 218: turn-scoped layout state. ``_in_turn`` gates the indent
        # (session-level chrome stays flush left); ``_answer_pending`` marks a
        # buffered answer whose box is waiting for the metadata that belongs
        # in its bottom border — see :meth:`_flush_answer_box`.
        self._in_turn = False
        self._answer_pending = False
 
    # ── PR 1.C hooks (called by main / commands.py) ───────────────────────
 
    def bind_session(self, session: ChatSession) -> None:
        """Inform the presenter which session is currently active.
 
        Call after :func:`oc_chat.core.startup._load_session_by_meta`
        / ``/session load`` / ``/session new`` so reasoning preferences
        and artifact paths are picked up.  Idempotent — safe to call
        on every turn.
        """
        func = "bind_session"
        self._session_name = getattr(session, "name", None)
        ui = getattr(session, "ui_prefs", {}) or {}
        pref = ui.get("show_reasoning")
        if pref in ("show", "dim", "hide"):
            self._show_reasoning_pref = pref
        # Plan 147 D5: reasoning_tail — a tampered/non-int/<1 persisted value
        # degrades to the default with a _dbg note, never a crash.
        tail = ui.get("reasoning_tail")
        if tail is not None:
            if isinstance(tail, bool) or not isinstance(tail, int) or tail < 1:
                _dbg("OC_UI.TERMINAL", func,
                     f"invalid persisted reasoning_tail={tail!r}; using default", 2, override=True)
            else:
                self._reasoning_tail = tail
 
    def bind_status(self, provider: Callable[[], StatusBarState | None]) -> None:
        """Register the late-binding status-snapshot provider (Plan 147 D1).
 
        Overrides the base no-op — the Live-region status bar (D3) and the
        :class:`~oc_ui.terminal.enhanced_presenter.EnhancedPresenter` fixed
        header both read ``self._status_provider()`` at render time.
        """
        self._status_provider = provider
 
    # ── Turn-scoped layout helpers (Plan 218) ─────────────────────────────
 
    def _now_ts(self) -> str:
        """Wall-clock ``HH:MM:SS`` for the rule labels.
 
        The single clock read behind every rule this presenter draws, so a
        scripted render (``oc_chat.scripts.render_turn_layout``) can pin it
        and produce a byte-reproducible capture.
        """
        return datetime.now().strftime("%H:%M:%S")
 
    def _turn_print(self, renderable: RenderableType) -> None:
        """Print a turn-scoped renderable, indented while a turn is open.
 
        Plan 218 P1 element 5 / W4: everything between the turn rules —
        the answer box, reasoning, tool calls and results, system lines —
        carries the three-space indent; the rules themselves and the
        status bar do not, so the turn body reads as contained.
 
        Plan 273: the padded renderable is printed with ``soft_wrap=False``.
        ``Padding`` renders its child at the padded width and then sets every
        line to that width, and this console is ``soft_wrap=True`` — under
        which Rich prints with ``no_wrap`` and ``overflow="ignore"`` and CROPS
        each line at the console width. Folding inside the indented width
        instead means a turn-body line longer than the terminal wraps and is
        never cut. Outside a turn nothing changes.
        """
        if self._in_turn:
            self._console.print(Padding(renderable, (0, 0, 0, len(TURN_INDENT))),
                                soft_wrap=False)
            return
        self._console.print(renderable)
 
    def _print_rule(self, label: "str | list[tuple[str, str]]",
                    trailer: str = "") -> None:
        """Render one composed rule line, each segment in its own style.
 
        ``no_wrap`` mirrors the status bar's never-wrap discipline: a rule
        that wrapped would read as two broken rules. Callers keep the line
        within the width by construction (see :func:`rule_fits`).
        """
        segments = compose_rule(label, self._console.width, trailer)
        self._console.print(Text.assemble(*[
            (text, _THEME[_RULE_TAG_STYLES.get(tag, "rule")])
            for text, tag in segments
        ]), no_wrap=True, crop=True)
 
    def _running_total(self) -> str:
        """The ``↻ total · turn / session`` trailer, or ``""`` when unknown.
 
        Read off the bound status snapshot, so the two numbers are the
        same ones the between-turns rprompt shows. The session figure adds
        the current turn because :meth:`~oc_ui.terminal.input.TurnStats.finish_turn`
        — which folds the turn into the session total — runs AFTER
        ``show_turn_summary``; without the addition the rule would report
        the session as it stood one turn ago. No provider bound (plain
        console in a test, a presenter with no session) renders NO
        trailer rather than a zero, on the same honesty rule plan 188 T4
        applied to cost.
        """
        func = "_running_total"
        if self._status_provider is None:
            return ""
        try:
            state = self._status_provider()
        except Exception as exc:
            # EXTERNAL_ERROR — a caller-supplied provider misbehaved; the
            # rule renders without its trailer rather than failing the turn.
            _dbg("OC_UI.TERMINAL", func,
                 f"EXTERNAL_ERROR: {type(exc).__name__}: {exc}", 2, override=True)
            return ""
        if state is None:
            return ""
        return running_total_text(state.turn_tokens,
                                  state.session_tokens + state.turn_tokens)
 
    def _flush_answer_box(self, stat: "IterationStat | None" = None,
                          error: str = "") -> None:
        """Commit the buffered answer as a CLOSED box.
 
        Plan 218 P2: the box is committed here rather than at ``turn()``
        exit because the metadata that belongs in its bottom border
        (``show_iteration_stat``) only arrives after the stream ends. The
        deferral is bounded — every other emitting hook flushes first — so
        the box can never be overtaken by output that logically follows it.
 
        *error* replaces the body with the failure text (the W2 path: the
        box still closes, and the partial answer is still dropped).
        """
        func = "_flush_answer_box"
        if not self._answer_pending:
            return
        self._answer_pending = False
 
        subtitle = ""
        if stat is not None:
            from oc_chat.core.iteration_stat import iteration_stat_human_line
            subtitle = iteration_stat_human_line(stat)
 
        if error:
            body = Text(error, style=_THEME["error"])
        else:
            body = Markdown(self._content_buf, code_theme=self._code_theme)
        try:
            self._turn_print(build_answer_panel(body, subtitle))
        except Exception as exc:
            # SYSTEM_ERROR — Markdown render failed (rare — malformed input);
            # fall back to plain styled Text so we never lose the answer AND
            # the box still closes (W2: no unclosed border on any path).
            _dbg("OC_UI.TERMINAL", func,
                 f"SYSTEM_ERROR: {type(exc).__name__}: {exc}", 1, override=True)
            self._turn_print(build_answer_panel(
                Text(self._content_buf, style=_THEME["content"]), subtitle))
 
    # ── Per-turn lifecycle ────────────────────────────────────────────────
 
    def show_session_start(self) -> None:
        """Draw the ``start @ <time>`` rule that opens the session (P1.1)."""
        self._console.print()
        self._print_rule(start_rule_label(self._now_ts()))
 
    @contextmanager
    def turn(self) -> Iterator[None]:
        """Open a ``rich.live.Live`` region for the duration of the turn.
 
        While the contextmanager is active, ``show_reasoning`` and
        ``show_content`` accumulate into per-turn buffers and trigger
        batched refreshes via :class:`~oc_ui.terminal._render.RenderBatcher`.
        On clean exit the Live region is cleared and the assistant
        content is **re-rendered once** as Markdown so code blocks get
        proper syntax highlighting and tables align cleanly.
 
        On exception the Live region is still torn down (transient=True)
        and the partial buffer is dropped to avoid leaving half-rendered
        Markdown in scrollback — but plan 218 P2/W2 adds that the answer
        BOX still closes, with the failure rendered inside it, so no
        border is ever left open.
        """
        func = "turn"
        # Plan 218: a previous iteration's box must never still be waiting
        # when a new one starts streaming.
        self._flush_answer_box()
        # Reset per-turn state.
        self._content_buf = ""
        self._reasoning_buf = ""
        self._batcher = RenderBatcher(fps=self._fps)
 
        # ``transient=True`` clears the Live render on exit so we can
        # commit the polished Markdown version below.  ``redirect_stderr``
        # is left at default — tool calls *outside* the streaming chunks
        # (e.g. show_tool_call) will print into the Live region naturally.
        live = Live(
            self._render_live(),
            console=self._console,
            refresh_per_second=self._fps,
            transient=True,
        )
        self._live = live
        live.__enter__()
        try:
            yield
            # Successful turn: clear Live, commit polished Markdown.
            self._commit_turn_to_scrollback()
        except Exception as e:
            # SYSTEM_ERROR — surface stream/render failure with override; partial
            # buffer is dropped to avoid half-rendered Markdown in scrollback.
            _dbg("OC_UI.TERMINAL", func, f"SYSTEM_ERROR: {type(e).__name__}: {e}", 1, override=True)
            # Plan 218 P2/W2 — close the box on the failure path too. The
            # partial answer stays dropped (that is what this except branch
            # has always been for); the error takes its place INSIDE the
            # box, so the bottom border still prints. A box is only closed
            # if one was opened — a failure before the first content chunk
            # never drew one.
            if self._content_buf:
                if self._live is not None:
                    self._live.stop()
                self._answer_pending = True
                self._flush_answer_box(error=f"{type(e).__name__}: {e}")
            raise
        finally:
            self._live = None
            live.__exit__(None, None, None)
            self._batcher = None
            if self._waiting_active:
                self._clear_waiting()
 
    # ── Live rendering helpers ────────────────────────────────────────────
 
    def _render_live(self) -> Group:
        """Build the renderable shown inside the Live region.
 
        A :class:`Group` of four regions (any of which may be empty):
        waiting indicator, reasoning, the answer box, status bar (D3/D4 —
        always last, "the bar is the last renderable in the Live group").
 
        Plan 218 P2 renders the answer inside its box AS IT STREAMS: the
        Live region redraws the box each frame, so the top border appears
        with the first chunk, the body grows line by line, and the bottom
        border tracks it down the screen — the "line-buffered box" the
        plan describes, and never a half-drawn border on screen. The
        metadata-bearing bottom border is committed once at turn end (see
        :meth:`_flush_answer_box`). Only the answer is boxed; reasoning,
        the spinner and the bar stay borderless as before, and everything
        except the bar carries the turn indent (W4).
 
        Reasoning visibility honours the ``ui[show_reasoning]`` pref:
        ``"hide"`` → buffer is consumed but never rendered; ``"dim"``
        (default) → only the last few lines are visible, dim italic;
        ``"show"`` → the whole buffer is rendered.
        """
        pad = (0, 0, 0, len(TURN_INDENT))
        elements = []
        if self._waiting_active and not self._content_buf and not self._reasoning_buf:
            elements.append(Padding(
                Spinner("dots", Text(" Thinking…", style=_THEME["waiting"])), pad))
        if self._reasoning_buf and self._show_reasoning_pref != "hide":
            visible_reasoning = self._reasoning_buf
            if self._show_reasoning_pref == "dim":
                # Truncate to the configurable tail (/ui reasoning dim N;
                # plan 147 D5) so long CoT doesn't push the answer off-screen.
                # The full text still reaches scrollback — see
                # _commit_turn_to_scrollback, which never truncates.
                lines = visible_reasoning.splitlines()
                if len(lines) > self._reasoning_tail:
                    hidden = len(lines) - self._reasoning_tail
                    visible_reasoning = (
                        f"… (+{hidden} lines — full CoT in scrollback; /ui reasoning show)\n"
                        + "\n".join(lines[-self._reasoning_tail:])
                    )
            elements.append(Padding(
                Text(REASONING_TITLE, style=_THEME["panel_title"]), pad))
            elements.append(Padding(
                Text(visible_reasoning, style=_THEME["reasoning"]), pad))
        if self._content_buf:
            if self._reasoning_buf and self._show_reasoning_pref != "hide":
                elements.append(Text(""))  # blank separator
            # Plain Text during streaming — Markdown is applied once at
            # commit time so we don't re-parse the whole buffer per chunk.
            elements.append(Padding(build_answer_panel(
                Text(self._content_buf, style=_THEME["content"])), pad))
        # D3/D4: the status bar + busy hint are chrome — never written into
        # scrollback (_commit_turn_to_scrollback below re-emits only the
        # reasoning/content buffers, never this Group).
        elements.append(_StatusBarLive(self))
        return Group(*elements) if elements else Text("")
 
    def _commit_turn_to_scrollback(self) -> None:
        """After a successful turn: clear Live, hand the answer to its box.
 
        Markdown rendering at commit time (rather than per chunk) is the
        key perf win flagged by reviewers — the whole document is parsed
        only once instead of every refresh. Plan 218 moves that one render
        into :meth:`_flush_answer_box`, which runs a beat later so the
        per-iteration metadata can land in the box's bottom border; the
        reasoning commit below is unchanged apart from its indent.
        """
        if self._live is None:
            return
        # Stop showing the transient Live render so we can print into the
        # scrollback without it being overwritten.
        self._live.stop()
        # Re-emit the reasoning header (dim) and the polished Markdown
        # version of the content into the real scrollback.  Honour the
        # reasoning preference: "hide" suppresses the commit too;
        # "dim" still commits the full text (the user can scroll back
        # for context — only the live region is truncated).
        if self._reasoning_buf and self._show_reasoning_pref != "hide":
            self._turn_print(Text(REASONING_TITLE, style=_THEME["panel_title"]))
            self._turn_print(Text(self._reasoning_buf.rstrip(),
                                  style=_THEME["reasoning"]))
            self._console.print()
        if self._content_buf:
            self._answer_pending = True
 
    def start_turn(self) -> None:
        """Print a styled rule + turn-number line."""
        self._flush_answer_box()
        self._reasoning_shown = False
        self._content_shown = False
        self._waiting_active = False
        self._turn_number += 1
        # Plan 188 T1: a tool call announced but never resulted (an exception
        # mid-dispatch) must not pair with a later call's result.
        self._mutation_args.clear()
 
        # Plan 218: the rule closes the previous region and opens the turn
        # body, so the indent starts AFTER it is drawn.
        self._in_turn = False
        self._console.print()  # leading blank line
        self._print_rule(turn_rule_label(self._turn_number, self._now_ts()))
        self._in_turn = True
 
    def end_turn(self) -> None:
        """Finalise the current turn (newline)."""
        self._flush_answer_box()
        if self._waiting_active:
            self._clear_waiting()
        self._in_turn = False
        self._console.print()
 
    # ── Streaming events ──────────────────────────────────────────────────
 
    def show_waiting(self) -> None:
        """Show a transient animated "Thinking…" spinner before the first chunk.
 
        Inside an active ``turn()`` Live region this is rendered as part
        of the Live :class:`Group`; outside (e.g. during tests that don't
        wrap the call) it falls back to a console print so output is
        still visible. Sets the presenter-owned busy label (D1/D4) shown
        in the status bar — cleared on the first chunk by
        :meth:`_clear_waiting`.
        """
        self._waiting_active = True
        self._busy_label = "waiting for response…"
        if self._live is not None:
            self._live.update(self._render_live())
        else:
            self._console.print(Text("⏳ Thinking…", style=_THEME["waiting"]),
                                end="")
 
    def _clear_waiting(self) -> None:
        """Erase the in-line waiting indicator (no-Live fallback only)."""
        self._busy_label = None
        if self._live is not None:
            # Live owns the render; just clear the flag and let the next
            # update() overwrite naturally.
            self._waiting_active = False
            self._live.update(self._render_live())
            return
        # No Live region: emit a CR + spaces to overwrite the line.
        self._console.file.write("\r" + " " * 20 + "\r")
        self._console.file.flush()
        self._waiting_active = False
 
    def show_reasoning(self, text: str) -> None:
        """Stream a reasoning chunk.
 
        Inside the Live region: append to ``_reasoning_buf`` and refresh
        when the batcher allows.  Outside: print immediately (legacy
        path used by tests that drive ``show_reasoning`` outside ``turn()``).
        """
        if self._waiting_active:
            self._clear_waiting()
        if self._live is not None:
            self._reasoning_buf += text
            assert self._batcher is not None  # paired with _live
            if self._batcher.should_flush(text):
                self._live.update(self._render_live())
            return
        # No-Live fallback (kept for parity with PR 1.A behaviour outside ``turn()``).
        if not self._reasoning_shown:
            self._turn_print(Text(REASONING_TITLE, style=_THEME["panel_title"]))
            self._reasoning_shown = True
        self._console.print(Text(text, style=_THEME["reasoning"]), end="")
 
    def show_content(self, text: str) -> None:
        """Stream an answer chunk.
 
        Same dual mode as :meth:`show_reasoning`: accumulate inside
        ``turn()``, print directly outside it. The no-Live fallback is
        deliberately left un-boxed: it exists for callers that drive
        ``show_content`` with no turn lifecycle at all, where there is no
        turn end at which a box could be closed — and plan 218's rule is
        that a box is never opened unless it can be closed.
        """
        if self._waiting_active:
            self._clear_waiting()
        if self._live is not None:
            self._content_buf += text
            assert self._batcher is not None
            if self._batcher.should_flush(text):
                self._live.update(self._render_live())
            return
        # No-Live fallback.
        if not self._content_shown:
            if self._reasoning_shown:
                self._console.print()
                self._console.print()
            self._turn_print(Text(ANSWER_BOX_TITLE, style="bold"))
            self._content_shown = True
        self._console.print(Text(text, style=_THEME["content"]), end="")
 
    # ── Tools ─────────────────────────────────────────────────────────────
 
    def show_tool_call(self, name: str, arguments: str) -> None:
        """Display a tool-call invocation."""
        func = "show_tool_call"
        self._flush_answer_box()
        if self._waiting_active:
            self._clear_waiting()
        try:
            args_pretty = json.dumps(json.loads(arguments or "{}"), ensure_ascii=False)
        except (json.JSONDecodeError, ValueError) as e:
            # VALIDATION_ERROR — model emitted non-JSON tool args; render raw string
            _dbg("OC_UI.TERMINAL", func, f"VALIDATION_ERROR: {type(e).__name__}: {e}", 3)
            args_pretty = arguments
        # Plan 188 T1: remember mutation-tool arguments for the diff render that
        # follows in show_tool_result, and elide the bulky payload here (the
        # diff below IS the content view). Both no-ops for every other tool.
        self._mutation_args.record(name, arguments)
        args_pretty = summarize_mutation_call(name, arguments) or args_pretty
        line = Text.assemble(
            ("[Tool call → ", _THEME["tool_call"]),
            (name, "bold " + _THEME["tool_call"]),
            ("(", _THEME["tool_call"]),
            (args_pretty, _THEME["tool_call"]),
            (")]", _THEME["tool_call"]),
        )
        self._console.print()
        self._turn_print(line)
 
    def show_tool_progress(self, name: str) -> None:
        """Start a ``rich.status.Status`` spinner indicating *name* is running.
 
        Stopped by the next :meth:`show_tool_result` call.  Inside the
        Live region we do *not* start a separate Status (the Live owns
        the screen); the announcement printed by :meth:`show_tool_call`
        is enough.  Outside Live, the spinner is genuinely useful.
        """
        if self._live is not None:
            return  # Live region already animates; double-spinner conflicts.
        if self._tool_status is not None:
            self._tool_status.stop()
        self._tool_status = Status(
            f"🔧 Running {name}…",
            spinner="dots",
            console=self._console,
        )
        self._tool_status.start()
 
    def _stop_tool_status(self) -> None:
        if self._tool_status is not None:
            self._tool_status.stop()
            self._tool_status = None
 
    def _render_diff(self, diff: DiffRender) -> None:
        """Print a :class:`DiffRender` as a colourised Rich group (plan 188 T1)."""
        elements: list[Text] = [
            Text(diff_header_line(diff), style=_THEME["diff_header"], no_wrap=False),
        ]
        _styles = {"add": _THEME["diff_add"], "del": _THEME["diff_del"],
                   "hunk": _THEME["diff_hunk"]}
        for line in diff.lines:
            elements.append(Text(line.text, style=_styles.get(line.kind, "")))
        footer = diff_footer_line(diff)
        if footer:
            elements.append(Text(footer, style=_THEME["diff_header"]))
        self._turn_print(Group(*elements))
 
    def show_tool_result(self, name: str, result: object) -> None:
        """Display a tool-call result.
 
        Plan 188 T1: an applied ``write_file`` / ``edit_file`` renders as a
        colourised unified diff instead of the truncated JSON line. Every
        other tool — and any mutation result that is an error, a gate block,
        or an unpaired call — keeps the legacy rendering (including the
        artifact spill below) exactly.
 
        Long results (> :data:`DEFAULT_TOOL_SPILL_CHARS` chars, or longer
        than the per-session ``ui[tool_spill_chars]`` override) are
        spilled to ``sessions/{name}/artifacts/...txt`` and only a
        one-line summary appears in scrollback.
        """
        func = "show_tool_result"
        self._flush_answer_box()
        self._stop_tool_status()
 
        if isinstance(result, dict) and result.get("requires_confirmation"):
            msg = result.get("message", str(result))
            self._turn_print(
                Text(f"[⏳ Confirmation required — {msg}]", style=_THEME["warning"])
            )
            return
 
        diff = build_mutation_diff(name, self._mutation_args.take(name), result)
        if diff is not None:
            self._render_diff(diff)
            return
 
        result_str = json.dumps(result, ensure_ascii=False)
        is_error = isinstance(result, dict) and "error" in result
        style = _THEME["tool_error"] if is_error else _THEME["tool_result"]
 
        # Spill long results to a file — keeps scrollback scannable and
        # matches the artifact convention in ``oc_chat/sessions/{name}/``.
        threshold = DEFAULT_TOOL_SPILL_CHARS
        if len(result_str) > threshold and self._session_name and not is_error:
            try:
                from oc_chat.core.persistence import save_tool_artifact
                path = save_tool_artifact(self._session_name, name, result_str)
                size_kb = len(result_str.encode("utf-8")) / 1024
                preview = result_str[:200].rstrip()
                self._turn_print(Text(
                    f"[{name} ← <output spilled, {size_kb:.1f} KB>]  "
                    f"↳ saved to {path.name}  (/open last to view)",
                    style=style,
                ))
                self._turn_print(Text(f"  preview: {preview}…",
                                      style=_THEME["info"]))
                return
            except Exception as e:
                # SYSTEM_ERROR — artifact write failed; fall through to truncated
                # inline display so the data isn't lost entirely.
                _dbg("OC_UI.TERMINAL", func, f"SYSTEM_ERROR: {type(e).__name__}: {e}", 1, override=True)
 
        if len(result_str) > 400:
            result_str = result_str[:400] + "…"
        # Prefix icon makes the success/error distinction visible without
        # relying on colour alone (a11y / colour-blind / NO_COLOR users).
        icon = "✗" if is_error else "✓"
        self._turn_print(Text(f"[{icon} {name} ← {result_str}]", style=style))
 
        # Plan 188 T2 — the plan lane: a planner tool just changed plan state,
        # so show the REPL's current progress underneath its result.
        progress = plan_progress_from_result(name, result)
        if progress:
            self.show_activity("plan", progress)
 
    # ── Activity lane (Plan 188 T2) ───────────────────────────────────────
 
    #: Tone → theme key. An unknown tone renders neutral (never raises).
    _ACTIVITY_TONES = {
        "info": "info", "ok": "tool_result",
        "warn": "warning", "error": "tool_error",
    }
 
    def show_activity(self, label: str, detail: str = "", *, tone: str = "info") -> None:
        """Render a compact one-line state update for a non-streaming lane."""
        self._flush_answer_box()
        style = _THEME.get(self._ACTIVITY_TONES.get(tone, "info"), _THEME["info"])
        self._turn_print(Text.assemble(
            (f"[{label}]", style),
            (f" {detail}" if detail else "", _THEME["info"]),
        ))
 
    # ── Two-stage Ctrl+C notice (Plan 188 T5) ─────────────────────────────
 
    def show_interrupt_notice(self, stage: str) -> None:
        """Announce a Ctrl+C stage on the stream this presenter owns.
 
        Called FROM THE SIGNAL HANDLER, so this must stay one short write.
        It goes to ``self._console.file`` rather than ``stderr`` because
        while a ``Live`` region is up Rich has swapped that stream for its
        own proxy, which parks the text above the live region instead of
        letting it be overwritten by the next refresh. This is the same
        direct-write idiom :meth:`_clear_waiting` already uses; deliberately
        NOT ``Console.print``, whose renderable pipeline is more work than a
        signal handler should do.
        """
        text = INTERRUPT_NOTICES.get(stage)
        if text is None:
            return
        self._console.file.write(text)
        self._console.file.flush()
 
    # ── Stats ─────────────────────────────────────────────────────────────
 
    def show_usage(self, usage: dict) -> None:
        """Per-iteration token usage — compact one-line format.
 
        Plan 134 C1: render only in ``--verbose`` mode. This gates the
        TERMINAL rendering only; structured emission/logging is unaffected
        (``react_loop`` still records usage, ``LoggingPresenter`` still tees
        the event to its JSONL before delegating here).
        """
        self._flush_answer_box()
        if not self.verbose:
            return
        prompt     = usage.get("prompt_tokens", 0)
        completion = usage.get("completion_tokens", 0)
        total      = usage.get("total_tokens", 0)
        cached = None
        if isinstance(usage.get("prompt_tokens_details"), dict):
            cached = usage["prompt_tokens_details"].get("cached_tokens")
 
        cached_str = ""
        if cached is not None:
            cached_str = f" · cache:{self._fmt_compact_tokens(cached)}"
 
        line = (
            f"  prompt:{self._fmt_compact_tokens(prompt)}"
            f" · completion:{self._fmt_compact_tokens(completion)}"
            f" · total:{self._fmt_compact_tokens(total)}"
            f"{cached_str}"
        )
        self._turn_print(Text(line, style=_THEME["summary"]))
 
    def show_iteration_stat(self, stat: "IterationStat") -> None:
        """Render the per-iteration stats — in the answer box's bottom border.
 
        Plan 218 P1 element 3: when this iteration produced an answer, the
        stat line IS the box's bottom border, so the numbers sit against
        the text they describe. An iteration that produced no answer (a
        pure tool-call round) has no box to close, so the line renders as
        before — just carrying the turn indent.
        """
        if self._answer_pending:
            self._flush_answer_box(stat=stat)
            return
        from oc_chat.core.iteration_stat import iteration_stat_human_line
        self._turn_print(Text(iteration_stat_human_line(stat),
                              style=_THEME["summary"]))
 
    @staticmethod
    def _fmt_compact_tokens(n: int) -> str:
        if n >= 1_000_000:
            return f"{n / 1_000_000:.2f}M"
        if n >= 1_000:
            return f"{n / 1_000:.1f}k"
        return str(n)
 
    def show_turn_summary(self, prompt: int, completion: int, total: int,
                          iterations: int, tool_calls: int,
                          prompt_cached: int | None = None, *,
                          cache_hit_pct: float | None = None,
                          cache_saved_tokens: int | None = None,
                          performance_stats: object = None,
                          model: str | None = None,
                          context_used_pct: float | None = None,
                          duration_ms: int | None = None,
                          turn_cost: object = None) -> None:
        """Print the end-of-turn rule, with the turn stats absorbed into it.
 
        Plan 218 P1 element 4: the stats string that used to occupy its own
        line under the rule is now the rule's own text, and the running
        total that used to appear only in the between-turns rprompt rides
        in the right-hand fill run. Wording and styling are unchanged —
        only the position is (P3).
 
        Plan 188 T4: the ``~$`` estimate is appended when *turn_cost* is
        present and omitted entirely when it is ``None``. Formatting is
        delegated to :meth:`ConsolePresenter._fmt_turn_cost` so the honesty
        markers are identical across presenters.
        """
        self._flush_answer_box()
        self._in_turn = False
 
        parts = [f"prompt:{self._fmt_compact_tokens(prompt)}"]
        parts.append(f"completion:{self._fmt_compact_tokens(completion)}")
        parts.append(f"total:{self._fmt_compact_tokens(total)}")
        if prompt_cached is not None and prompt_cached > 0:
            parts.append(f"cache:{self._fmt_compact_tokens(prompt_cached)}")
        # Plan 134 C2: honest labels — cache-hit ratio vs real context saturation.
        if cache_hit_pct is not None:
            parts.append(f"cache-hit:{cache_hit_pct:.0f}%")
        if context_used_pct is not None:
            _ctx = f"ctx:{context_used_pct:.0f}%"
            if model:
                _ctx += f" of {model}"
            parts.append(_ctx)
        if performance_stats is not None and not performance_stats.is_default():
            tps = performance_stats.tokens_per_second
            if tps is not None:
                parts.append(f"{performance_stats.eval_count}tok@{tps:.1f}tok/s")
        if duration_ms is not None:
            from oc_chat.core.formatting import format_duration
            parts.append(format_duration(duration_ms))
        stats = "  this turn: " + " \u00b7 ".join(parts)
        from oc_ui.terminal.presenter import ConsolePresenter
        stats += ConsolePresenter._fmt_turn_cost(turn_cost, verbose=self.verbose)
        ts = self._now_ts()
        absorbed = turn_end_rule_segments(self._turn_number, ts, stats)
        if rule_fits(absorbed, self._console.width):
            self._print_rule(absorbed, trailer=self._running_total())
            return
        # Terminal too narrow to absorb the stats — degrade to the pre-218
        # two-line form rather than wrap the rule or crop a gauge in half.
        self._print_rule(turn_end_rule_segments(self._turn_number, ts))
        self._console.print(Text(stats, style=_THEME["summary"]))
 
    def show_welcome(self, session: ChatSession) -> None:
        """Display the welcome banner inside a styled :class:`Panel`."""
        from oc_chat.core.config import REASONING_EFFORT_LEVELS
 
        body = Text.assemble(
            ("Model: ", "bold"),       (session.model, "cyan"), ("\n",),
            ("Reasoning effort: ", "bold"),
                (session.reasoning_effort, "cyan"),
                (f"  (options: {', '.join(REASONING_EFFORT_LEVELS)})", "dim"), ("\n\n",),
            ("Type ",), ("/help", "yellow"),
                (" for full command details and session subcommands.",),
        )
        self._console.print()
        self._console.print(Panel(
            body,
            title="OC Chat",
            border_style=_THEME["panel_border"],
            padding=(1, 2),
        ))
 
    def show_available_models(self, models: dict) -> None:
        """Display models as a styled :class:`rich.table.Table`."""
        table = Table(title="Available models", title_style=_THEME["panel_title"],
                      show_lines=False, show_edge=True)
        table.add_column("Name", style="cyan", no_wrap=True)
        table.add_column("Thinking", justify="center")
        table.add_column("Reasoning", justify="center")
        table.add_column("Tools", justify="center")
 
        for name, caps in models.items():
            table.add_row(
                name,
                _check(caps.get("supports_thinking")),
                _check(caps.get("supports_reasoning")),
                _check(caps.get("supports_tools", True)),
            )
        self._console.print()
        self._console.print(table)
 
    def show_session_list(self, sessions: list, current_name: str | None = None) -> None:
        """Display saved sessions as a styled :class:`rich.table.Table`."""
        if not sessions:
            self._console.print(Text("(no saved sessions)", style=_THEME["info"]))
            return
        from oc_chat.core.commands import _fmt_tokens_display
 
        table = Table(title="Saved sessions", title_style=_THEME["panel_title"],
                      show_lines=False)
        table.add_column("", width=1, no_wrap=True)        # current marker
        table.add_column("Name", style="cyan", overflow="fold")
        table.add_column("Model", overflow="ellipsis")
        table.add_column("Msgs", justify="right")
        table.add_column("Tools", justify="right")
        table.add_column("Tokens", justify="right")
        table.add_column("Last modified")
 
        for s in sessions:
            marker = "★" if s["name"] == current_name else ""
            stats = s["stats"]
            table.add_row(
                marker,
                s["name"],
                s["model"],
                str(stats.message_count),
                str(stats.tool_call_count),
                _fmt_tokens_display(stats),
                s["last_modified"],
            )
        self._console.print()
        self._console.print(table)
 
    def show_help(self, command_help: dict, tools: list[str] | None = None) -> None:
        """Render the help table(s) — commands and (optionally) agent tools."""
        cmd_table = Table(title="Slash commands", title_style=_THEME["panel_title"],
                          show_lines=False)
        cmd_table.add_column("Command", style="yellow", no_wrap=True)
        cmd_table.add_column("Description", overflow="fold")
 
        for verb, line in command_help.items():
            # COMMAND_HELP entries are formatted as "/verb <args>  - description".
            # Split on the first " - " to separate usage from description.
            if "  - " in line:
                usage, _, description = line.partition("  - ")
            else:
                usage, description = line, ""
            cmd_table.add_row(usage.rstrip(), description.strip())
 
        self._console.print()
        self._console.print(cmd_table)
 
        if tools:
            tool_table = Table(title="Agent tools (callable by the model)",
                               title_style=_THEME["panel_title"], show_lines=False)
            tool_table.add_column("Name", style="green", no_wrap=True)
            for name in tools:
                tool_table.add_row(name)
            self._console.print()
            self._console.print(tool_table)
 
    def show_compressed(self) -> None:
        """Notify the user that context compression occurred."""
        self._flush_answer_box()
        self._turn_print(
            Text("[Context compressed — older messages summarised]",
                 style=_THEME["compressed"])
        )
 
    def show_error(self, msg: str) -> None:
        """Display an error message in bold red."""
        self._flush_answer_box()
        self._console.print()
        self._turn_print(Text(f"Error: {msg}", style=_THEME["error"]))
 
    def show_info(self, msg: str) -> None:
        """Display an informational message."""
        self._flush_answer_box()
        self._console.print()
        self._turn_print(Text(msg, style=_THEME["info"]))
 
    # ── Progress spinner + dispatch chrome (Phase H.4 / Plan 147 D3-c/D4) ──
 
    def spinner_start(self, label: str) -> SpinnerHandle:
        """Start the dispatch-chrome Live display — the single busy-chrome
        owner outside the streaming Live region.
 
        Renders ``Group(spinner + label, status bar, hint line)`` via a
        small ``rich.live.Live`` — NOT ``rich.status.Status`` (which only
        ever shows one line) — so tool dispatch gets the same D3 bar +
        D4 hint as the streaming regime ("one renderable definition,
        three hosts"). Only ever called while ``self._live`` (the turn's
        streaming Live) is ``None`` — react_loop brackets dispatch strictly
        after ``turn()`` exits — so this never stacks a second live display
        on top of the streaming one (the single-live-display regression).
        """
        func = "spinner_start"
        _dbg("OC_UI.TERMINAL", func, f"label={label!r}", 4)
        self._busy_label = label
        live = Live(
            Group(Spinner("dots", Text(f" {label}", style=_THEME["waiting"])),
                 _StatusBarLive(self)),
            console=self._console,
            refresh_per_second=self._fps,
            transient=True,
        )
        live.start()
        return SpinnerHandle(status=live)
 
    def spinner_stop(self, handle: SpinnerHandle) -> None:
        """Stop the underlying dispatch-chrome ``Live``; idempotent on repeated calls."""
        func = "spinner_stop"
        if handle.status is None:
            return
        try:
            handle.status.stop()
        except Exception as exc:  # noqa: BLE001 — terminal teardown best-effort
            _dbg("OC_UI.TERMINAL", func, f"stop ignored: {type(exc).__name__}: {exc}", 3)
        handle.status = None
        self._busy_label = None
 
 
# ─── Helpers ──────────────────────────────────────────────────────────────────
 
def _check(flag) -> Text:
    """Return a styled ✓ / ✗ marker for boolean capability flags."""
    if flag:
        return Text("✓", style="green")
    return Text("✗", style="red")