aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/ui/render/responsive.py

@@ -0,0 +1,75 @@
+"""Shared responsive layout primitives for structured terminal output."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import shutil
+from typing import Literal, Sequence
+
+
+StructuredLayout = Literal["stacked", "compact", "full"]
+
+
+@dataclass(frozen=True)
+class StackedRecord:
+    """One narrow-terminal record with a headline and readable detail rows."""
+
+    headline: str
+    lines: tuple[str, ...]
+
+
+def terminal_width(console=None, *, fallback: int = 80) -> int:
+    """Return a stable terminal width for real and recording consoles."""
+    try:
+        width = int(getattr(console, "width", 0) or 0)
+        if width > 0:
+            return width
+    except (TypeError, ValueError):
+        pass
+    return int(shutil.get_terminal_size((fallback, 24)).columns or fallback)
+
+
+def select_structured_layout(
+    width: int,
+    *,
+    stacked_below: int = 96,
+    full_at: int = 120,
+) -> StructuredLayout:
+    """Choose stacked cards, a reduced table, or the full table."""
+    if width < stacked_below:
+        return "stacked"
+    if width < full_at:
+        return "compact"
+    return "full"
+
+
+def structured_layout(
+    console=None,
+    *,
+    width: int | None = None,
+    stacked_below: int = 96,
+    full_at: int = 120,
+) -> StructuredLayout:
+    return select_structured_layout(
+        width if width is not None else terminal_width(console),
+        stacked_below=stacked_below,
+        full_at=full_at,
+    )
+
+
+def render_stacked_records(
+    console,
+    *,
+    title: str,
+    records: Sequence[StackedRecord],
+    footer: str = "",
+) -> None:
+    """Render narrow structured data without a wide table or panel border."""
+    console.print(f"[bold]{title}[/bold]")
+    for index, record in enumerate(records, start=1):
+        console.print(f"  [bold]#{index}  {record.headline}[/bold]")
+        for line in record.lines:
+            if str(line).strip():
+                console.print(f"      {line}")
+    if footer:
+        console.print(f"  [dim]{footer}[/dim]")

aria_code/ui/render/team.py

@@ -0,0 +1,367 @@
+"""Rendering helpers for /team output — table, verdict banner, adaptive widths."""
+
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from rich.console import Console
+
+# ── Signal → Rich style ──────────────────────────────────────────────────────
+
+SIGNAL_COLORS: dict[str, str] = {
+    "BUY":         "green",
+    "STRONG_BUY":  "bold green",
+    "SELL":        "red",
+    "STRONG_SELL": "bold red",
+    "HOLD":        "yellow",
+}
+
+# ── Verdict banner ────────────────────────────────────────────────────────────
+
+VERDICT_STYLE: dict[str, tuple[str, str]] = {
+    # Text glyphs, not emoji: "🔴" drew as an empty box in common terminal
+    # fonts, and the variation selector in "⚠️" threw the panel width off.
+    "HEALTHY":         ("green",      "✓ "),
+    "NEEDS_ATTENTION": ("yellow",     "! "),
+    "HIGH_RISK":       ("red",        "✗ "),
+    "STRONG_BUY":      ("bold green", "▲▲"),
+    "BUY":             ("green",      "▲ "),
+    "HOLD":            ("dim",        "─ "),
+    "SELL":            ("red",        "▼ "),
+    "STRONG_SELL":     ("bold red",   "▼▼"),
+}
+
+
+# ── Streaming agent tree (Claude Code-style nested ⏺ rendering) ────────────────
+
+AGENT_LABELS: dict[str, str] = {
+    "fundamental": "基本面", "technical": "技术面", "macro": "宏观",
+    "risk": "风险", "news": "新闻", "catalyst": "催化剂",
+    "sector": "行业", "sentiment": "情绪", "debate": "分歧调解",
+    "valuation": "估值", "quant": "量化", "synthesis": "综合",
+}
+
+
+def agent_label(name: str, lang: str = "zh") -> str:
+    if not str(lang).lower().startswith("zh"):
+        return (name or "?").replace("_", " ").title()
+    return AGENT_LABELS.get((name or "").lower(), name or "?")
+
+
+def render_agent_tree_root(console, sym: str, n_agents: int, lang: str = "zh") -> None:
+    """Print the root of the agent tree: ⏺ 多代理分析 SYM   N 个分析师并行"""
+    head = "多代理分析" if lang == "zh" else "Multi-agent analysis"
+    sub  = (f"{n_agents} 个分析师并行" if lang == "zh"
+            else f"{n_agents} analysts in parallel")
+    console.print(f"\n  [#C08050]⏺[/#C08050]  [bold]{head} {sym}[/bold]  [dim]{sub}[/dim]")
+
+
+def render_agent_node(console, name: str, signal: str | None,
+                      key_point: str | None, success: bool = True,
+                      error: str | None = None,
+                      degraded: bool = False, lang: str = "zh") -> None:
+    """Print one completed-agent leaf: ⎿ ⏺ 基本面  BUY  ROE 24%·PE 32 偏高 (Fundamental … in English)"""
+    zh = str(lang).lower().startswith("zh")
+    label = agent_label(name, lang)
+    if not success or error:
+        _err_label = ({
+            "timeout": "超时", "rate_limited": "数据源限流",
+            "no_data": "无数据", "": "失败",
+        } if zh else {
+            "timeout": "timed out", "rate_limited": "data source rate-limited",
+            "no_data": "no data", "": "failed",
+        }).get((error or "").lower(), error or ("失败" if zh else "failed"))
+        console.print(f"  [dim]⎿ ⏺ {label}  {_err_label}[/dim]")
+        return
+    sig   = (signal or "").upper()
+    color = SIGNAL_COLORS.get(sig, "dim")
+    sig_disp = f"[{color}]{sig}[/{color}]  " if sig else ""
+    kp = (key_point or "").strip().replace("\n", " ")
+    if len(kp) > 52:
+        kp = kp[:52] + "…"
+    if degraded:
+        tag = "降级" if zh else "degraded"
+        kp = f"{tag} · {kp}" if kp else (f"{tag}执行" if zh else tag)
+    console.print(
+        f"  [dim]⎿[/dim] [#C08050]⏺[/#C08050] [bold]{label}[/bold]  "
+        f"{sig_disp}[dim]{kp}[/dim]"
+    )
+
+
+def render_agent_synthesis_leaf(console, signal: str | None,
+                                confidence: float | None, elapsed: float | None,
+                                lang: str = "zh") -> None:
+    """Print the synthesis leaf: ⎿ 综合: ▲ BUY (置信 68%)  耗时 4.2s"""
+    sig = (signal or "").upper()
+    color, icon = VERDICT_STYLE.get(sig, ("dim", "●"))
+    zh = str(lang).lower().startswith("zh")
+    conf = (f"  [dim]{'置信' if zh else 'confidence'} {confidence:.0%}[/dim]" if confidence else "")
+    el   = (f"  [dim]{'耗时' if zh else 'took'} {elapsed:.1f}s[/dim]" if elapsed else "")
+    lab  = "综合" if zh else "Synthesis"
+    console.print(
+        f"  [dim]⎿[/dim] [bold]{lab}[/bold]  [{color}]{icon} {sig}[/{color}]{conf}{el}"
+    )
+
+
+def build_verdict_body(
+    verdict: str,
+    subtitle: str = "",
+    confidence: float | None = None,
+    lang: str = "zh",
+) -> str:
+    """Return a Rich markup string suitable for a Panel body."""
+    verdict_upper = verdict.upper()
+    style, icon = VERDICT_STYLE.get(verdict_upper, ("dim", "●"))
+    label = "置信度" if str(lang).lower().startswith("zh") else "confidence"
+    conf_str = f"  [dim]{label} {confidence:.0%}[/dim]" if confidence else ""
+    body = f"[{style}]{icon}  {verdict_upper}[/{style}]{conf_str}"
+    if subtitle:
+        body += f"\n[dim]{subtitle}[/dim]"
+    return body
+
+
+def render_verdict_banner(
+    verdict: str,
+    subtitle: str = "",
+    confidence: float | None = None,
+    *,
+    console: "Console | None" = None,
+    has_rich: bool = True,
+    lang: str = "zh",
+) -> None:
+    """Print a visually prominent verdict/signal result.
+
+    Falls back to a plain print when Rich is unavailable or *console* is None.
+    """
+    if not verdict:
+        return
+    verdict_upper = verdict.upper()
+
+    if not has_rich or console is None:
+        conf_str = f"  ({confidence:.0%})" if confidence else ""
+        sub_str  = f"  {subtitle}" if subtitle else ""
+        print(f"\n  {verdict_upper}{conf_str}{sub_str}\n")
+        return
+
+    try:
+        from rich import box as _rbox
+        from rich.panel import Panel
+        body = build_verdict_body(verdict_upper, subtitle, confidence, lang)
+        console.print(Panel(body, box=_rbox.SIMPLE, padding=(0, 2)))
+    except Exception:
+        conf_str = f"  ({confidence:.0%})" if confidence else ""
+        console.print(f"\n  {verdict_upper}{conf_str}\n")
+
+
+# ── Team table ────────────────────────────────────────────────────────────────
+
+@dataclass(frozen=True)
+class TeamTableRow:
+    agent: str
+    signal: str
+    confidence: str
+    key_point: str
+    success: bool
+    signal_color: str = "dim"
+    is_debate: bool = False
+    degraded: bool = False
+
+
+# Minimum usable terminal width before we drop the key_point column entirely.
+_KEY_POINT_MIN_TERMINAL = 72
+
+
+def calc_column_widths(terminal_width: int) -> tuple[int, int, int, int]:
+    """Return ``(agent_w, signal_w, conf_w, key_w)`` adaptive to *terminal_width*.
+
+    Column budget (chars used by content only, excluding Rich padding/borders):
+
+    +-----------+---------+-----------+--------------------+
+    | Agent     | Signal  | Conf      | Key point          |
+    +-----------+---------+-----------+--------------------+
+    Fixed overhead per row: ~7 chars (borders + padding × 4 cols).
+
+    Width tiers
+    -----------
+    ≥ 120 cols  full layout   14 | 10 | 7 | 38
+    ≥ 100 cols  medium        12 |  9 | 6 | 30
+    ≥  80 cols  compact       10 |  8 | 6 | 20
+    ≥  72 cols  tight          9 |  8 | 6 | 12
+    <  72 cols  no key col     9 |  8 | 6 |  0  (column omitted)
+    """
+    if terminal_width >= 120:
+        return (14, 10, 7, 38)
+    if terminal_width >= 100:
+        return (12,  9, 6, 30)
+    if terminal_width >= 80:
+        return (10,  8, 6, 20)
+    if terminal_width >= _KEY_POINT_MIN_TERMINAL:
+        return ( 9,  8, 6, 12)
+    return (9, 8, 6, 0)
+
+
+def truncate_cell(value: Any, width: int = 36) -> str:
+    text = str(value or "").strip().replace("\n", " ")
+    if width <= 0:
+        return ""
+    if width <= 1:
+        return text[:width]
+    if len(text) <= width:
+        return text
+    return text[: width - 1].rstrip() + "…"
+
+
+def team_mode_label(results: list[Any], use_full: bool = False) -> str:
+    non_debate = [r for r in results if getattr(r, "agent", None) != "debate"]
+    return f"{len(non_debate)}-agent {'完整分析' if use_full else '分析'}"
+
+
+_AGENT_DISPLAY = {
+    "fundamental": "fundmntl",
+    "synthesis":   "synthsis",
+    "catalyst":    "catalyst",
+}
+
+
+def build_team_table_rows(results: list[Any], key_width: int = 36) -> list[TeamTableRow]:
+    rows: list[TeamTableRow] = []
+    debate_rows: list[TeamTableRow] = []
+
+    for result in results:
+        agent      = str(getattr(result, "agent", "") or "")
+        agent      = _AGENT_DISPLAY.get(agent, agent)
+        success    = bool(getattr(result, "success", False))
+        raw_signal = str(getattr(result, "signal",  "") or "")
+        signal     = raw_signal or "N/A"
+        conf_val   = float(getattr(result, "confidence", 0.0) or 0.0)
+        confidence = f"{conf_val:.0%}" if success else "-"
+        degraded = bool(getattr(result, "degraded", False))
+        color      = SIGNAL_COLORS.get(raw_signal.upper(), "dim")
+
+        if agent == "debate":
+            debate_rows.append(TeamTableRow(
+                agent="debate",
+                signal=raw_signal or "ADJ",
+                confidence=confidence,
+                key_point="信号分歧调解",
+                success=success,
+                signal_color="orange1",
+                is_debate=True,
+            ))
+            continue
+
+        if success:
+            kpts      = getattr(result, "key_points", []) or []
+            key_point = truncate_cell(kpts[0] if kpts else "", key_width)
+            if degraded:
+                key_point = truncate_cell(f"降级 · {key_point}" if key_point else "降级执行", key_width)
+        else:
+            _raw_err = getattr(result, "error", None) or "failed"
+            _err_display = {
+                "stale_or_conflicting_price": "数据冲突 — 价格与行情不符",
+                "timeout":                    "分析超时",
+                "no_data":                    "数据不可用",
+                "agent_failed":               "Agent 执行失败",
+            }.get(_raw_err, _raw_err)
+            key_point = truncate_cell(_err_display, key_width)
+
+        rows.append(TeamTableRow(
+            agent=agent,
+            signal=signal,
+            confidence=confidence,
+            key_point=key_point,
+            success=success,
+            signal_color=color,
+            degraded=degraded,
+        ))
+
+    return rows + debate_rows
+
+
+def render_team_rows_plain(rows: list[TeamTableRow]) -> list[str]:
+    """Plain-text fallback (no Rich)."""
+    lines: list[str] = []
+    for row in rows:
+        icon = "DEG" if row.degraded else "OK" if row.success else "WARN"
+        lines.append(
+            f"  {icon} [{row.agent}] {row.signal} ({row.confidence}) {row.key_point}".rstrip()
+        )
+    return lines
+
+
+def render_team_table(
+    sym: str,
+    rows: list[TeamTableRow],
+    use_full: bool = False,
+    *,
+    console: "Console | None" = None,
+    terminal_width: int | None = None,
+    has_rich: bool = True,
+) -> None:
+    """Print the /team results table, adapting column widths to *terminal_width*.
+
+    Falls back to :func:`render_team_rows_plain` when Rich is unavailable.
+    """
+    if not has_rich or console is None:
+        for line in render_team_rows_plain(rows):
+            print(line)
+        return
+
+    try:
+        from rich import box as _rbox
+        from rich.table import Table as _Table
+    except ImportError:
+        for line in render_team_rows_plain(rows):
+            console.print(line)
+        return
+
+    # Determine terminal width from console if not supplied
+    if terminal_width is None:
+        terminal_width = getattr(console, "width", None) or shutil.get_terminal_size().columns
+
+    agent_w, signal_w, conf_w, key_w = calc_column_widths(terminal_width)
+    mode_label = team_mode_label(rows, use_full)  # rows already built; agent count approximate
+
+    tbl = _Table(
+        title=f"[bold]/team {sym}[/bold] · [dim]{mode_label}[/dim]",
+        box=_rbox.ROUNDED,
+        border_style="dim",
+        show_header=True,
+        header_style="bold dim",
+        padding=(0, 1),
+    )
+    tbl.add_column("Agent",  width=agent_w)
+    tbl.add_column("信号",   width=signal_w)
+    tbl.add_column("置信度", justify="right", width=conf_w)
+    if key_w > 0:
+        tbl.add_column("关键点", width=key_w)
+
+    for row in rows:
+        # Re-truncate key_point to the current adaptive width
+        kp = truncate_cell(row.key_point, key_w) if key_w > 0 else None
+
+        agent_cell = (
+            f"[orange1]{row.agent}[/orange1]"
+            if row.is_debate
+            else f"[dim]{row.agent}[/dim]"
+        )
+        key_cell = (
+            "[dim][orange1]信号分歧调解[/orange1][/dim]"
+            if row.is_debate
+            else f"[dim]{kp}[/dim]"
+        ) if key_w > 0 else None
+
+        cells = [
+            agent_cell,
+            f"[{row.signal_color}]{row.signal}[/{row.signal_color}]",
+            f"[dim]{row.confidence}[/dim]" if row.success else "[dim]—[/dim]",
+        ]
+        if key_cell is not None:
+            cells.append(key_cell)
+        tbl.add_row(*cells)
+
+    console.print()
+    console.print(tbl)

aria_code/ui/robot.py

@@ -0,0 +1,239 @@
+"""Aria robot mascot — the terminal rendition of the robot artwork.
+
+Drawn the way Claude Code draws its mascot: a few flat colours and Unicode
+quadrant blocks (▗▖▘▝▛▜▙▟), each character cell holding 2×2 sub-pixels. That
+keeps the robot small (4 rows × 9 columns, beside four lines of text) and its
+edges exact in any terminal and font, with no image and no blending.
+
+The grid is the artwork's own: 18 units wide × 16 tall (ear, body, ear; cap,
+screen, base, feet), each unit one sub-pixel across and half a sub-pixel down
+— which, with terminal cells twice as tall as wide, keeps the units square.
+Each eye is two quadrants (a square) and the two are identical,
+the cap corners ▛ ▜, the ears ▌ ▐, the four feet ▀. Colours are sampled from
+the artwork (docs/assets/aria-robot.png) on this grid; only the light-theme
+greys and body are deepened, where the artwork's would vanish against a
+white background. The orange seam between body and base is left out: at
+this size it would share a cell with two other colours, and a cell has two.
+
+Runtime state is shown by the compact status dot, not by the mascot.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import threading
+import time
+from enum import Enum
+
+
+class RobotState(Enum):
+    IDLE      = "idle"
+    THINKING  = "thinking"
+    STREAMING = "streaming"
+    ERROR     = "error"
+    DONE      = "done"
+
+
+# ── Shared mutable state (written by aria_cli, read by input_box) ─────────────
+_state      = RobotState.IDLE
+_state_lock = threading.Lock()
+_done_at: float | None = None  # timestamp when DONE state was set
+
+
+def set_robot_state(state: RobotState) -> None:
+    global _state, _done_at
+    with _state_lock:
+        _state = state
+        _done_at = time.monotonic() if state is RobotState.DONE else None
+
+
+def get_robot_state() -> RobotState:
+    with _state_lock:
+        # Auto-revert DONE → IDLE after 1.5 s
+        if _state is RobotState.DONE and _done_at is not None:
+            if time.monotonic() - _done_at > 1.5:
+                return RobotState.IDLE
+        return _state
+
+
+# Eye symbols per state. IDLE mirrors the mascot art: two matching square eyes.
+_EYES = {
+    RobotState.IDLE:      ("■", "■"),
+    RobotState.THINKING:  ("◐", "◑"),
+    RobotState.STREAMING: ("▸", "▸"),
+    RobotState.ERROR:     ("×", "×"),
+    RobotState.DONE:      ("✓", "✓"),
+}
+
+# Accent colour per state
+_COLOUR = {
+    RobotState.IDLE:      "#C08050",
+    RobotState.THINKING:  "#d29922",
+    RobotState.STREAMING: "#3fb950",
+    RobotState.ERROR:     "#f85149",
+    RobotState.DONE:      "#3fb950",
+}
+
+# Status text per state (used by status bar dot)
+_STATUS = {
+    RobotState.IDLE:      "",
+    RobotState.THINKING:  "thinking…",
+    RobotState.STREAMING: "generating…",
+    RobotState.ERROR:     "error",
+    RobotState.DONE:      "done",
+}
+
+# ── Theme-aware palette ───────────────────────────────────────────────────────
+# Colours sampled from the robot artwork. Roles name what a cell shows; each
+# resolves to a Rich style ("<fg> on <bg>").
+_COLOURS = {
+    "dark": {
+        "body":   "#F4EBE4",   # cream shell
+        "screen": "#0E0E0E",   # black screen
+        "eye":    "#FFFDF5",   # square eye, brighter than the shell
+        "ear":    "#B6ADA4",   # grey ear nub
+        "base":   "#B6ADA4",   # grey underside
+        "leg":    "#D5CCC3",   # light grey feet
+    },
+    "light": {
+        "body":   "#E6DDD0",   # deeper cream: the artwork's would vanish on white
+        "screen": "#0E0E0E",
+        "eye":    "#FFFDF5",
+        "ear":    "#9C948B",
+        "base":   "#9C948B",
+        "leg":    "#B8AFA6",
+    },
+}
+
+
+def _palette(theme: str) -> dict:
+    c = _COLOURS[theme]
+    return {
+        "body":        c["body"],
+        "body_screen": f"{c['body']} on {c['screen']}",
+        "eye":         f"{c['eye']} on {c['screen']}",
+        "screen":      f"on {c['screen']}",
+        "ear_body":    f"{c['ear']} on {c['body']}",
+        "base":        c["base"],
+        "base_leg":    f"{c['base']} on {c['leg']}",
+    }
+
+
+_PALETTES = {theme: _palette(theme) for theme in _COLOURS}
+
+_theme_cache: str | None = None
+
+
+def _resolve_theme() -> str:
+    pref = os.environ.get("ARIA_THEME", "").strip().lower()
+    if pref in ("light", "dark"):
+        return pref
+    if sys.platform == "darwin":
+        try:
+            import subprocess
+            r = subprocess.run(
+                ["defaults", "read", "-g", "AppleInterfaceStyle"],
+                capture_output=True, text=True, timeout=1,
+            )
+            # `defaults` prints "Dark" in dark mode and errors (non-zero) in light.
+            return "dark" if (r.returncode == 0 and "dark" in r.stdout.lower()) else "light"
+        except Exception:
+            pass
+    # xterm-style COLORFGBG ("fg;bg"): bg 0-6/8 → dark, 7/9-15 → light.
+    cfb = os.environ.get("COLORFGBG", "")
+    if ";" in cfb:
+        try:
+            bg = int(cfb.split(";")[-1])
+            return "light" if (bg == 7 or bg >= 9) else "dark"
+        except Exception:
+            pass
+    return "dark"
+
+
+def detect_theme() -> str:
+    """Return 'light' or 'dark' for the mascot, auto-detected once and cached.
+
+    Order: ``ARIA_THEME`` env override → macOS system appearance → ``COLORFGBG``
+    → default dark.
+    """
+    global _theme_cache
+    if _theme_cache is None:
+        _theme_cache = _resolve_theme()
+    return _theme_cache
+
+
+# 9 columns × 4 rows; each cell is (palette-role, glyphs).
+_MASCOT_TEMPLATE = [
+    [("body", "▗"), ("body_screen", "▛▀▀▀▀▀▜"), ("body", "▖")],                       # cap, screen top
+    [("ear_body", "▌"), ("body_screen", "▌"), ("eye", "▗▖"), ("screen", " "),          # ears, two matching eyes
+     ("eye", "▗▖"), ("body_screen", "▐"), ("ear_body", "▐")],
+    [("body", "▐"), ("body_screen", "▙▄▄▄▄▄▟"), ("body", "▌")],                       # screen bottom, body
+    [("base", "▝"), ("base_leg", "▀"), ("base", "▀"), ("base_leg", "▀"), ("base", "▀"),  # base and four feet
+     ("base_leg", "▀"), ("base", "▀"), ("base_leg", "▀"), ("base", "▘")],
+]
+
+ROBOT_ROW_COUNT = len(_MASCOT_TEMPLATE)
+
+
+def _resolve_eyes(state: RobotState, tick: int) -> tuple[str, str]:
+    el, er = _EYES[state]
+    if state is RobotState.IDLE:
+        if tick % 24 in (0, 1):
+            el, er = "·", "·"
+    elif state is RobotState.THINKING:
+        frames = (("◐", "◑"), ("◓", "◒"), ("◑", "◐"), ("◒", "◓"))
+        el, er = frames[tick % len(frames)]
+    elif state is RobotState.STREAMING:
+        el = er = "▸" if (tick % 4) < 2 else "▹"
+    return el, er
+
+
+def get_robot_row(tick: int, row: int) -> list:
+    """Return (style, text) fragments for one robot row, themed.
+
+    Rows: cap and screen top; ears and two eyes; screen bottom and body;
+    base and four feet. Roles follow the active light/dark theme
+    (see detect_theme()).
+    """
+    del tick
+    pal = _PALETTES[detect_theme()]
+    return [(pal[key] if key else "", text) for key, text in _MASCOT_TEMPLATE[row]]
+
+
+def get_robot_frame(tick: int) -> list:
+    """Legacy single-fragment list (not split by row). Use get_robot_row() instead."""
+    out = []
+    for r in range(ROBOT_ROW_COUNT):
+        out += get_robot_row(tick, r)
+    return out
+
+
+def get_status_dot(tick: int) -> list:
+    """Compact inline indicator for the status bar — one animated glyph + state label.
+
+    IDLE:      •               (copper, slow blink)
+    THINKING:  ◐  thinking…   (yellow spinner)
+    STREAMING: ▶  generating… (green pulse)
+    ERROR:     ✕  error        (red)
+    DONE:      ✓  done         (green, brief)
+    """
+    state = get_robot_state()
+    col   = _COLOUR[state]
+    if detect_theme() == "light":
+        col = {
+            RobotState.IDLE:      "#9A6700",
+            RobotState.THINKING:  "#9A6700",
+            RobotState.STREAMING: "#1A7F37",
+            RobotState.ERROR:     "#CF222E",
+            RobotState.DONE:      "#1A7F37",
+        }[state]
+    el, _ = _resolve_eyes(state, tick)
+    if state is RobotState.IDLE:
+        el = "•"
+    label = _STATUS[state]
+
+    frags: list = [(f"bold {col}", el)]
+    if label:
+        frags.append((col, f" {label}"))
+    return frags