aru-code 0.47.0__tar.gz → 0.48.0__tar.gz

{aru_code-0.47.0/aru_code.egg-info → aru_code-0.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.47.0
+Version: 0.48.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT

aru_code-0.48.0/aru/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.48.0"

{aru_code-0.47.0 → aru_code-0.48.0}/aru/runner.py

@@ -695,8 +695,14 @@ async def run_agent_capture(agent, message: str, session=None, lightweight: bool
             sink.exit()
         except Exception:
             pass
-        from rich.markup import escape
-        console.print(f"[red]Error: {escape(str(e))}[/red]")
+        # Route via the sink so the message reaches the right surface:
+        # REPL → Rich console; TUI → ChatPane system message (Textual
+        # hijacks stderr/stdout, so ``console.print`` would be invisible).
+        try:
+            sink.on_error(str(e))
+        except Exception:
+            from rich.markup import escape
+            console.print(f"[red]Error: {escape(str(e))}[/red]")
 
     # Final guard: if a plan is active and the agent ended its turn with
     # pending steps (without stalling), mark the session so the next turn's

{aru_code-0.47.0 → aru_code-0.48.0}/aru/session.py

@@ -565,7 +565,19 @@ class Session:
         self._live_cache_write_added = 0
 
     def _get_pricing(self) -> tuple[float, float, float, float]:
-        """Get per-million-token pricing for the current model."""
+        """Get per-million-token pricing for the current model.
+
+        Free models (e.g. OpenRouter `:free` variants like
+        `openrouter/minimax/minimax-m2.5:free`) report no cost. Detected by
+        the literal token "free" in the model ref or id — covers the `:free`
+        suffix convention plus any future provider that adopts the same
+        naming. None of the major paid models contain "free" in their id,
+        so false positives are negligible.
+        """
+        ref = (self.model_ref or "").lower()
+        mid = (self.model_id or "").lower()
+        if "free" in ref or "free" in mid:
+            return (0.0, 0.0, 0.0, 0.0)
         model_id = self.model_id
         # Try exact match, then prefix match, then fallback
         for prefix, pricing in MODEL_PRICING.items():

{aru_code-0.47.0 → aru_code-0.48.0}/aru/sinks.py

@@ -238,6 +238,11 @@ class RichLiveSink:
         else:
             target.print(message)
 
+    def on_error(self, message: str) -> None:
+        from rich.markup import escape
+        target = self._live.console if self._live is not None else self.console
+        target.print(f"[red]Error: {escape(message)}[/red]")
+
     def on_stream_finished(self, *, final_content: str) -> None:
         # Nothing to do here — runner flushes trailing markdown after exit()
         # using the accumulated content + display._flushed_len.

{aru_code-0.47.0 → aru_code-0.48.0}/aru/streaming.py

@@ -121,6 +121,14 @@ class StreamSink(Protocol):
         """Best-effort sideband user message (warnings etc.)."""
         ...
 
+    def on_error(self, message: str) -> None:
+        """Terminal error — runner caught an exception from the agent run.
+
+        REPL renders via Rich console; TUI must route to the ChatPane so
+        the user actually sees it (Textual hijacks stderr/stdout).
+        """
+        ...
+
     def on_stream_finished(self, *, final_content: str) -> None:
         """Run finished — sink may render any trailing markdown."""
         ...

{aru_code-0.47.0 → aru_code-0.48.0}/aru/tui/app.py

@@ -877,22 +877,76 @@ class AruApp(App):
         if session is None:
             self._push_chat("No session.", "model")
             return
+        from aru.providers import (
+            MODEL_ALIASES,
+            get_provider,
+            list_providers,
+            resolve_model_ref,
+        )
+
+        config = self.config
+        config_aliases = (getattr(config, "model_aliases", None) or {}) if config else {}
+
         body = body.strip()
         if not body:
-            current = getattr(session, "model_ref", "?")
-            self._push_chat(
-                f"Current model: {current}\n"
-                f"Usage: /model <provider/name>  (e.g. /model anthropic/claude-sonnet-4-5)",
-                "model",
-            )
+            lines = [
+                f"Current model: {session.model_display} ({session.model_id})",
+                "",
+            ]
+            if config_aliases:
+                lines.append("Model aliases (aru.json):")
+                for alias, ref in config_aliases.items():
+                    lines.append(f"  {alias} → {ref}")
+                lines.append("")
+            lines.append("Built-in aliases:")
+            for alias, ref in MODEL_ALIASES.items():
+                lines.append(f"  {alias} → {ref}")
+            lines.append("")
+            lines.append("Providers:")
+            for pkey, pconfig in list_providers().items():
+                dflt = pconfig.default_model or "—"
+                lines.append(f"  {pkey} ({pconfig.name}) — default: {dflt}")
+            lines.append("")
+            lines.append("Usage: /model <provider/name>  (e.g. /model anthropic/claude-sonnet-4-5, /model minimax)")
+            self._push_chat("\n".join(lines), "model")
             return
+
         try:
-            session.model_ref = body
+            arg_lower = body.lower()
+            resolved_ref = config_aliases.get(arg_lower, arg_lower) if config_aliases else arg_lower
+            provider_key, _ = resolve_model_ref(resolved_ref)
+            if get_provider(provider_key) is None:
+                available = ", ".join(sorted(list_providers().keys()))
+                self._push_chat(
+                    f"Unknown provider '{provider_key}'. Available: {available}",
+                    "model",
+                )
+                return
+            # Normalize to the fully-qualified ref so model_display + create_model
+            # see the right provider/model pair.
+            session.model_ref = resolved_ref if "/" in resolved_ref else (
+                MODEL_ALIASES.get(resolved_ref, resolved_ref)
+            )
             if self.ctx is not None:
                 self.ctx.model_id = session.model_id
+                small_ref = config_aliases.get("small")
+                if not small_ref:
+                    sp_key, _ = resolve_model_ref(session.model_ref)
+                    _small_defaults = {
+                        "anthropic": "anthropic/claude-haiku-4-5",
+                        "openai": "openai/gpt-4o-mini",
+                        "groq": "groq/llama-3.1-8b-instant",
+                        "deepseek": "deepseek/deepseek-chat",
+                        "ollama": "ollama/llama3.1",
+                    }
+                    small_ref = _small_defaults.get(sp_key, session.model_ref)
+                self.ctx.small_model_ref = small_ref
             status = self.query_one(StatusPane)
             status._refresh_from_session()
-            self._push_chat(f"Model switched to: {body}", "model")
+            self._push_chat(
+                f"Switched to {session.model_display} ({session.model_id})",
+                "model",
+            )
         except Exception as exc:
             self._push_chat(f"model switch failed: {exc}", "model")
 
@@ -2051,9 +2105,24 @@ async def run_tui(
     ctx.tui_app = app
     ctx.ui = TuiUI(app)
 
+    # Bridge logging → ChatPane so Agno's ERROR records (rate limits,
+    # provider errors, etc.) are visible to the user instead of vanishing
+    # into Textual's captured stderr. Detached in the finally block.
+    log_bridge_handlers: list = []
+    try:
+        from aru.tui.log_bridge import install_chat_log_bridge
+        log_bridge_handlers = install_chat_log_bridge(app)
+    except Exception:
+        pass
+
     try:
         await app.run_async()
     finally:
+        try:
+            from aru.tui.log_bridge import uninstall_chat_log_bridge
+            uninstall_chat_log_bridge(log_bridge_handlers)
+        except Exception:
+            pass
         ctx.tui_app = None
         ctx.ui = None
         try:

aru_code-0.48.0/aru/tui/log_bridge.py

@@ -0,0 +1,128 @@
+"""Logging → ChatPane bridge for TUI mode.
+
+Background
+----------
+Agno (and other libraries) report API errors via Python's ``logging``
+module — for example, an OpenRouter rate-limit looks like::
+
+    ERROR    Rate limit error from OpenAI API: Error code: 429 ...
+    ERROR    Error in Agent run: Provider returned error
+
+In REPL mode these records reach the user because Python's default log
+handler writes to ``sys.stderr`` and the terminal renders it directly.
+In TUI mode Textual takes over the alternate screen and captures stdout
+/ stderr — those ERROR lines vanish, leaving the user staring at a
+spinner that eventually stops without any message.
+
+This module installs a ``logging.Handler`` that forwards qualifying
+records into the running ``AruApp``'s ``ChatPane`` as system messages
+via ``app.call_from_thread``. The handler is idempotent (a marker
+attribute on each target logger prevents double-attachment when
+``run_tui`` is invoked twice in the same process, e.g. tests).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+# Loggers we forward to chat. Keep this tight — capturing the root logger
+# would also pick up debug noise from libraries that log at WARNING for
+# routine state. We only want clearly-actionable messages.
+_BRIDGE_LOGGERS: tuple[str, ...] = ("agno", "aru")
+
+# Records below this level are dropped. ERROR is the right floor:
+# WARNING from Agno is often non-actionable (e.g. "tool call schema
+# coerced"). The user explicitly asked for transparency about *errors*.
+_BRIDGE_LEVEL = logging.ERROR
+
+# Sentinel attribute name set on a logger after we've attached our
+# handler, so re-running the install is a no-op.
+_INSTALLED_FLAG = "_aru_chat_bridge_installed"
+
+
+class _ChatPaneLogHandler(logging.Handler):
+    """Forward logging records into the TUI ChatPane.
+
+    Holds a weak reference semantically (we let the App outlive the
+    handler — the handler is detached in ``uninstall_chat_log_bridge``).
+    Failures inside ``emit`` are swallowed: a logging handler must never
+    raise, and the user can still see the error via Textual's own dev
+    log if they really need it.
+    """
+
+    def __init__(self, app: Any) -> None:
+        super().__init__(level=_BRIDGE_LEVEL)
+        self._app = app
+        self.setFormatter(logging.Formatter("%(name)s: %(message)s"))
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            text = self.format(record)
+        except Exception:
+            try:
+                text = record.getMessage()
+            except Exception:
+                return
+        try:
+            from aru.tui.widgets.chat import ChatPane
+            chat = self._app.query_one(ChatPane)
+        except Exception:
+            return
+        try:
+            self._app.call_from_thread(
+                chat.add_system_message, f"Error: {text}"
+            )
+        except Exception:
+            # Last-resort direct call — safe when already on the loop
+            # and the App is still running. If even this raises, drop
+            # the record silently rather than crashing the producer.
+            try:
+                chat.add_system_message(f"Error: {text}")
+            except Exception:
+                return
+
+
+def install_chat_log_bridge(app: Any) -> list[logging.Handler]:
+    """Attach a ChatPane bridge to each target logger.
+
+    Returns the list of installed handlers so ``uninstall_chat_log_bridge``
+    can remove them on teardown. Idempotent per logger — if a previous
+    bridge from the same process is still attached, that logger is
+    skipped and only loggers without a bridge get a new handler.
+    """
+    installed: list[logging.Handler] = []
+    for name in _BRIDGE_LOGGERS:
+        logger = logging.getLogger(name)
+        if getattr(logger, _INSTALLED_FLAG, False):
+            continue
+        handler = _ChatPaneLogHandler(app)
+        logger.addHandler(handler)
+        # Make sure ERROR records actually fire — Agno ships at WARNING
+        # by default in cli.py, but a downstream user could lower it.
+        if logger.level == logging.NOTSET or logger.level > _BRIDGE_LEVEL:
+            logger.setLevel(_BRIDGE_LEVEL)
+        setattr(logger, _INSTALLED_FLAG, True)
+        installed.append(handler)
+    return installed
+
+
+def uninstall_chat_log_bridge(handlers: list[logging.Handler]) -> None:
+    """Detach the bridge handlers and clear the per-logger marker."""
+    for name in _BRIDGE_LOGGERS:
+        logger = logging.getLogger(name)
+        for h in list(logger.handlers):
+            if isinstance(h, _ChatPaneLogHandler):
+                logger.removeHandler(h)
+        if getattr(logger, _INSTALLED_FLAG, False):
+            try:
+                delattr(logger, _INSTALLED_FLAG)
+            except AttributeError:
+                pass
+    # Best-effort close so file descriptors etc. don't leak (we don't
+    # use any, but a custom subclass might).
+    for h in handlers:
+        try:
+            h.close()
+        except Exception:
+            pass

{aru_code-0.47.0 → aru_code-0.48.0}/aru/tui/sinks.py

@@ -130,6 +130,16 @@ class TextualBusSink:
         except Exception:
             pass
 
+    def on_error(self, message: str) -> None:
+        # Errors are routed to the ChatPane (persistent) instead of a
+        # Textual toast — under Textual, Agno's ERROR log lines never
+        # reach the terminal, so this is the user's only visible signal
+        # that something went wrong. Closing the active assistant bubble
+        # first prevents the streamed-but-empty assistant message from
+        # swallowing the error widget.
+        self._call(self.chat.finalize_assistant_message)
+        self._call(self.chat.add_system_message, f"Error: {message}")
+
     def on_stream_finished(self, *, final_content: str) -> None:
         self._call(self.chat.finalize_assistant_message, final_content or None)
 

{aru_code-0.47.0 → aru_code-0.48.0/aru_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.47.0
+Version: 0.48.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT

{aru_code-0.47.0 → aru_code-0.48.0}/aru_code.egg-info/SOURCES.txt

@@ -69,6 +69,7 @@ aru/tools/web.py
 aru/tools/worktree.py
 aru/tui/__init__.py
 aru/tui/app.py
+aru/tui/log_bridge.py
 aru/tui/sanitize.py
 aru/tui/sinks.py
 aru/tui/slash_bridge.py
@@ -149,6 +150,7 @@ tests/test_runner_interrupt.py
 tests/test_runner_recovery.py
 tests/test_runtime.py
 tests/test_select.py
+tests/test_session_free_cost.py
 tests/test_skill_disallowed_tools.py
 tests/test_status_breakdown.py
 tests/test_status_cost.py
@@ -165,6 +167,7 @@ tests/test_tui_chat_adversarial.py
 tests/test_tui_completer.py
 tests/test_tui_completer_dynamic.py
 tests/test_tui_copy.py
+tests/test_tui_error_display.py
 tests/test_tui_input_behaviour.py
 tests/test_tui_layer12_recovery.py
 tests/test_tui_layer13_recovery.py
@@ -177,6 +180,7 @@ tests/test_tui_plan_task_render.py
 tests/test_tui_shell_bang.py
 tests/test_tui_sidebar_toggle.py
 tests/test_tui_slash_bridge.py
+tests/test_tui_slash_model.py
 tests/test_tui_snapshot_smoke.py
 tests/test_tui_thinking_and_boot.py
 tests/test_tui_widgets_visual.py

{aru_code-0.47.0 → aru_code-0.48.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aru-code"
-version = "0.47.0"
+version = "0.48.0"
 description = "A Claude Code clone built with Agno agents"
 readme = "README.md"
 license = "MIT"

aru_code-0.48.0/tests/test_session_free_cost.py

@@ -0,0 +1,59 @@
+"""Free models must not accumulate dollar cost.
+
+Regression: ``Session._get_pricing`` previously fell through to
+``MODEL_PRICING["default"]`` (Sonnet-4.5 pricing) for any model id not
+present in the table. OpenRouter's `:free` variants like
+``openrouter/minimax/minimax-m2.5:free`` were therefore reported as
+quite expensive in the status bar and `/cost` panel even though the
+provider charges nothing.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from aru.session import Session
+
+
+def _consume(session: Session, *, inp: int, out: int) -> None:
+    session.total_input_tokens = inp
+    session.total_output_tokens = out
+
+
+def test_openrouter_free_variant_costs_zero():
+    session = Session()
+    session.model_ref = "openrouter/minimax/minimax-m2.5:free"
+    _consume(session, inp=100_000, out=50_000)
+    assert session.estimated_cost == 0.0
+
+
+def test_openrouter_free_nemotron_costs_zero():
+    session = Session()
+    session.model_ref = "openrouter/nvidia/nemotron-3-super-120b-a12b:free"
+    _consume(session, inp=200_000, out=10_000)
+    assert session.estimated_cost == 0.0
+
+
+def test_paid_anthropic_still_costs_real_money():
+    session = Session()
+    session.model_ref = "anthropic/claude-sonnet-4-5"
+    _consume(session, inp=100_000, out=50_000)
+    assert session.estimated_cost > 0.0
+
+
+def test_free_match_is_case_insensitive():
+    session = Session()
+    session.model_ref = "openrouter/minimax/minimax-m2.5:FREE"
+    _consume(session, inp=10_000, out=5_000)
+    assert session.estimated_cost == 0.0
+
+
+def test_free_with_cache_tokens_still_zero():
+    """All four price components must be zeroed, not just input/output."""
+    session = Session()
+    session.model_ref = "openrouter/minimax/minimax-m2.5:free"
+    session.total_input_tokens = 100_000
+    session.total_output_tokens = 50_000
+    session.total_cache_read_tokens = 30_000
+    session.total_cache_write_tokens = 20_000
+    assert session.estimated_cost == 0.0

{aru_code-0.47.0 → aru_code-0.48.0}/tests/test_streaming_sink.py

@@ -46,6 +46,9 @@ class RecordingSink:
     def notify(self, message: str, style: str = "") -> None:
         self.events.append(("notify", {"msg": message}))
 
+    def on_error(self, message: str) -> None:
+        self.events.append(("error", {"msg": message}))
+
     def on_stream_finished(self, *, final_content: str) -> None:
         self.events.append(("stream_finished", {"final": final_content}))
 

aru_code-0.48.0/tests/test_tui_error_display.py

@@ -0,0 +1,205 @@
+"""TUI must surface LLM/runner errors instead of silencing them.
+
+Two layers of coverage:
+
+1. **Sink-routed errors.** When the runner's catch-all (``runner.py:693``)
+   fires, it now calls ``sink.on_error(...)``. The TUI sink must mount
+   a system message in the ChatPane so the user sees "Error: ...".
+
+2. **Logging bridge.** Agno frequently catches API errors (e.g. OpenAI
+   429), logs them at ERROR level, and continues without re-raising.
+   In REPL the records reach the terminal via stderr; in TUI Textual
+   captures stderr and the user sees nothing. The bridge installed by
+   ``install_chat_log_bridge`` must convert those records into ChatPane
+   system messages.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import pytest
+
+pytest.importorskip("textual")
+
+
+# ── Sink-routed errors ───────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_textual_bus_sink_on_error_lands_in_chat_pane():
+    """``TextualBusSink.on_error`` must mount a system message."""
+    from aru.tui.app import AruApp
+    from aru.tui.sinks import TextualBusSink
+    from aru.tui.widgets.chat import ChatMessageWidget, ChatPane
+
+    app = AruApp()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        chat = app.query_one(ChatPane)
+        sink = TextualBusSink(app=app, chat_pane=chat)
+        sink.on_error("Provider returned error")
+        await pilot.pause()
+        msgs = list(chat.query(ChatMessageWidget))
+        joined = " ".join(m.buffer for m in msgs)
+
+    assert "Provider returned error" in joined
+    assert "Error" in joined
+    # Must be a system-role message, not silently dropped.
+    assert any(m.role == "system" for m in msgs)
+
+
+# ── Logging bridge ───────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_agno_error_log_reaches_chat_via_bridge():
+    """An Agno ``logger.error(...)`` call must appear in the chat."""
+    from aru.tui.app import AruApp
+    from aru.tui.log_bridge import (
+        install_chat_log_bridge,
+        uninstall_chat_log_bridge,
+    )
+    from aru.tui.widgets.chat import ChatMessageWidget, ChatPane
+
+    app = AruApp()
+    handlers: list = []
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        handlers = install_chat_log_bridge(app)
+        try:
+            logging.getLogger("agno").error(
+                "Rate limit error from OpenAI API: Error code: 429"
+            )
+            await pilot.pause()
+            chat = app.query_one(ChatPane)
+            msgs = list(chat.query(ChatMessageWidget))
+            joined = " ".join(m.buffer for m in msgs)
+        finally:
+            uninstall_chat_log_bridge(handlers)
+
+    assert "429" in joined
+    assert "Rate limit error" in joined
+
+
+@pytest.mark.asyncio
+async def test_aru_logger_error_also_bridged():
+    """Aru's own loggers should also surface errors in the chat."""
+    from aru.tui.app import AruApp
+    from aru.tui.log_bridge import (
+        install_chat_log_bridge,
+        uninstall_chat_log_bridge,
+    )
+    from aru.tui.widgets.chat import ChatMessageWidget, ChatPane
+
+    app = AruApp()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        handlers = install_chat_log_bridge(app)
+        try:
+            logging.getLogger("aru.runner").error("runner blew up: %s", "boom")
+            await pilot.pause()
+            chat = app.query_one(ChatPane)
+            joined = " ".join(
+                m.buffer for m in chat.query(ChatMessageWidget)
+            )
+        finally:
+            uninstall_chat_log_bridge(handlers)
+
+    assert "boom" in joined
+
+
+@pytest.mark.asyncio
+async def test_warning_level_records_are_filtered_out():
+    """Bridge floor is ERROR; routine WARNINGs should not pollute chat."""
+    from aru.tui.app import AruApp
+    from aru.tui.log_bridge import (
+        install_chat_log_bridge,
+        uninstall_chat_log_bridge,
+    )
+    from aru.tui.widgets.chat import ChatMessageWidget, ChatPane
+
+    app = AruApp()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        handlers = install_chat_log_bridge(app)
+        try:
+            logging.getLogger("agno").warning("schema coerced to dict")
+            await pilot.pause()
+            chat = app.query_one(ChatPane)
+            joined = " ".join(
+                m.buffer for m in chat.query(ChatMessageWidget)
+            )
+        finally:
+            uninstall_chat_log_bridge(handlers)
+
+    assert "schema coerced" not in joined
+
+
+@pytest.mark.asyncio
+async def test_install_is_idempotent():
+    """Re-installing the bridge must not double-attach handlers."""
+    from aru.tui.app import AruApp
+    from aru.tui.log_bridge import (
+        _ChatPaneLogHandler,
+        install_chat_log_bridge,
+        uninstall_chat_log_bridge,
+    )
+
+    app = AruApp()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        first = install_chat_log_bridge(app)
+        second = install_chat_log_bridge(app)
+        try:
+            agno_handlers = [
+                h for h in logging.getLogger("agno").handlers
+                if isinstance(h, _ChatPaneLogHandler)
+            ]
+            # Exactly one bridge handler attached, regardless of install count.
+            assert len(agno_handlers) == 1
+            assert second == []  # second call returned no new handlers
+        finally:
+            uninstall_chat_log_bridge(first)
+            uninstall_chat_log_bridge(second)
+
+
+@pytest.mark.asyncio
+async def test_uninstall_removes_handlers():
+    """After uninstall, ERROR records must not leak into chat anymore."""
+    from aru.tui.app import AruApp
+    from aru.tui.log_bridge import (
+        _ChatPaneLogHandler,
+        install_chat_log_bridge,
+        uninstall_chat_log_bridge,
+    )
+
+    app = AruApp()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        handlers = install_chat_log_bridge(app)
+        uninstall_chat_log_bridge(handlers)
+        # No bridge handler should remain.
+        for name in ("agno", "aru"):
+            for h in logging.getLogger(name).handlers:
+                assert not isinstance(h, _ChatPaneLogHandler)
+
+
+# ── Rich sink continues to work for REPL ─────────────────────────────
+
+
+def test_rich_live_sink_on_error_prints_via_console():
+    """REPL path: the existing console.print behavior is preserved."""
+    from io import StringIO
+
+    from rich.console import Console
+
+    from aru.sinks import RichLiveSink
+
+    buf = StringIO()
+    console = Console(file=buf, force_terminal=False, color_system=None, width=120)
+    sink = RichLiveSink(console=console)
+    sink.on_error("Provider returned error")
+    out = buf.getvalue()
+    assert "Provider returned error" in out
+    assert "Error" in out