aria-code 0.97.0__tar.gz → 0.98.0__tar.gz

{aria_code-0.97.0/src/aria_code.egg-info → aria_code-0.98.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.97.0
+Version: 0.98.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.97.0 → aria_code-0.98.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.97.0"
+version = "0.98.0"
 description = "Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{aria_code-0.97.0 → aria_code-0.98.0}/src/aria_code/_version.py

@@ -17,4 +17,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.97.0"
+__version__ = "0.98.0"

{aria_code-0.97.0 → aria_code-0.98.0}/src/aria_code/apps/cli/commands/backtest_cmds.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 from typing import Any
 
 from ._ui import has_rich, print_error
+from aria_code.apps.cli.i18n import ui_text
 
 
 def format_backtest_data_error(
@@ -278,11 +279,19 @@ class BacktestCommandsMixin:
         else:
             _resolved_start = None
 
-        _known_strategies = {"momentum", "mom", "sma_cross", "ma_cross", "moving_average",
-                              "buy_hold", "buyhold", "hold", "ml", "ml_signal", "agent"}
-        if len(parts) == 1 and parts[0].lower() not in _known_strategies:
+        from backtest_report import STRATEGY_ALIASES as _STRATEGY_ALIASES
+        _known_strategies = set(_STRATEGY_ALIASES) | {"ml", "ml_signal", "agent"}
+
+        def _is_strategy(token: str) -> bool:
+            return token.lower().replace("-", "_") in _known_strategies
+
+        if len(parts) == 1 and not _is_strategy(parts[0]):
             strategy = "momentum"
             symbol = parts[0].upper()
+        elif len(parts) > 1 and not _is_strategy(parts[0]) and _is_strategy(parts[1]):
+            # "/backtest AAPL sma": symbol first. It ran strategy "AAPL" on the
+            # ticker SMA, an unknown name that then fell through to buy-and-hold.
+            strategy, symbol = parts[1], parts[0].upper()
         else:
             strategy = parts[0] if len(parts) > 0 else "momentum"
             symbol = parts[1].upper() if len(parts) > 1 else "SPY"
@@ -306,6 +315,12 @@ class BacktestCommandsMixin:
         end_date   = (_raw_end if _raw_end and _date_re.match(_raw_end) else None) \
                      or today.isoformat()
 
+        if not _is_strategy(strategy):
+            print_error(self.context,
+                        ui_text(self, f"未知策略：{strategy}", f"Unknown strategy: {strategy}"),
+                        "momentum · sma_cross (sma) · buy_hold · ml · agent — /backtest sma AAPL")
+            return
+
         # ── ML 信号组合回测 ──────────────────────────────────────────────────
         if strategy.lower() in ("ml", "ml_signal"):
             await self._cmd_ml_signal_backtest(parts[1:], start_date=start_date,
@@ -353,14 +368,21 @@ class BacktestCommandsMixin:
                 logger.debug("local backtest failed, falling back to yfinance direct: %s", _e)
 
             # ── Direct yfinance backtest — works offline, no backend needed ──
+            # Bars found, for a precise error message. Set before the import:
+            # inside the try, a missing yfinance left it unset and the error
+            # path below raised UnboundLocalError instead of reporting.
+            _yf_bars = [0]
             try:
                 import yfinance as _yf
-                import numpy as _np
-                import statistics as _stats
 
-                _yf_bars = [0]   # records bars found, for a precise error message
 
                 def _run_yf_backtest():
+                    # Prices straight from yfinance, run through the same engine
+                    # as the main path. This had its own engine, which ran
+                    # momentum whatever strategy was asked for, counted buys and
+                    # sells as separate trades and called the share of up days
+                    # the win rate.
+                    from backtest_report import run_backtest_from_history
                     _ticker = _yf.Ticker(symbol)
                     _df = _ticker.history(start=start_date, end=end_date, auto_adjust=True)
                     if _df is None or _df.empty:
@@ -370,95 +392,24 @@ class BacktestCommandsMixin:
                             end_date=end_date,
                             bars=0,
                         ), "bars": 0}
-                    _close = _df["Close"].dropna()
-                    _yf_bars[0] = len(_close)
-                    if len(_close) < 5:
+                    _rows = [{"date": str(idx.date()), "close": float(row["Close"]),
+                              "volume": float(row["Volume"]) if "Volume" in row and row["Volume"] == row["Volume"] else None}
+                             for idx, row in _df.iterrows() if row["Close"] == row["Close"]]
+                    _yf_bars[0] = len(_rows)
+                    _res = run_backtest_from_history(_rows, local_config)
+                    if not _res.get("success"):
+                        if "Unknown strategy" in str(_res.get("error", "")):
+                            return _res
                         return {"success": False, "error": format_backtest_data_error(
                             symbol,
                             start_date=start_date,
                             end_date=end_date,
                             bars=_yf_bars[0],
                         ), "bars": _yf_bars[0]}
-                    _prices = list(_close)
-                    n = len(_prices)
-                    # Momentum strategy: buy when N-day momentum > 0
-                    _mp = int(_momentum_period)
-                    _signals = [0] * n
-                    for i in range(_mp, n):
-                        _signals[i] = 1 if _prices[i] > _prices[i - _mp] else -1
-                    # Simulate portfolio
-                    _cap = float(_initial_capital)
-                    _position = 0.0  # shares
-                    _cash = _cap
-                    _trades = 0
-                    _portfolio = []
-                    for i in range(1, n):
-                        _p = _prices[i]
-                        _sig = _signals[i - 1]
-                        if _sig == 1 and _position == 0 and _cash > 0:
-                            _shares = _cash / _p
-                            _position = _shares
-                            _cash = 0
-                            _trades += 1
-                        elif _sig == -1 and _position > 0:
-                            _cash = _position * _p
-                            _position = 0
-                            _trades += 1
-                        _portfolio.append(_cash + _position * _p)
-                    if not _portfolio:
-                        return None
-                    _final = _portfolio[-1]
-                    _total_return = (_final - _cap) / _cap
-                    _bh_return = (_prices[-1] - _prices[0]) / _prices[0]
-                    # Daily returns for Sharpe
-                    _rets = [(_portfolio[i] - _portfolio[i-1]) / _portfolio[i-1] for i in range(1, len(_portfolio)) if _portfolio[i-1] > 0]
-                    _ann_return = sum(_rets) / len(_rets) * 252 if _rets else 0
-                    _ann_vol = _stats.stdev(_rets) * (252 ** 0.5) if len(_rets) > 1 else 0
-                    _sharpe = _ann_return / _ann_vol if _ann_vol > 0 else 0
-                    # Max drawdown
-                    _peak = _portfolio[0]
-                    _max_dd = 0.0
-                    for v in _portfolio:
-                        if v > _peak:
-                            _peak = v
-                        _dd = (_peak - v) / _peak if _peak > 0 else 0
-                        if _dd > _max_dd:
-                            _max_dd = _dd
-                    # Equity curve (sampled monthly)
-                    _step = max(1, n // 24)
-                    _equity_curve = [
-                        {"date": str(_close.index[min(i + 1, n - 1)].date()), "strategy": round(_portfolio[min(i, len(_portfolio)-1)], 2)}
-                        for i in range(0, len(_portfolio), _step)
-                    ]
-                    _win_trades = sum(1 for i in range(1, len(_portfolio)) if _portfolio[i] > _portfolio[i-1])
-                    _vol = _df["Volume"].dropna() if "Volume" in _df else []
-                    _vol_count = len(_vol) if hasattr(_vol, "__len__") else 0
-                    return {
-                        "success": True,
-                        "symbol": symbol,
-                        "strategy": strategy,
-                        "total_return": round(_total_return, 4),
-                        "buy_hold_return": round(_bh_return, 4),
-                        "annualized_return": round(_ann_return, 4),
-                        "sharpe_ratio": round(_sharpe, 3),
-                        "max_drawdown": round(-_max_dd, 4),
-                        "win_rate": round(_win_trades / max(len(_portfolio) - 1, 1), 3),
-                        "num_trades": _trades,
-                        "equity_curve": _equity_curve,
-                        "data_provider": "yfinance",
-                        "provider_chain": ["yfinance"],
-                        "start_date": start_date,
-                        "end_date": end_date,
-                        "initial_capital": float(_initial_capital),
-                        "bars": n,
-                        "volume_summary": {
-                            "last": round(float(_vol.iloc[-1]), 2) if _vol_count else None,
-                            "average": round(float(_vol.mean()), 2) if _vol_count else None,
-                            "min": round(float(_vol.min()), 2) if _vol_count else None,
-                            "max": round(float(_vol.max()), 2) if _vol_count else None,
-                            "coverage": round(_vol_count / max(len(_df), 1), 4),
-                        },
-                    }
+                    _res.update({"data_provider": "yfinance", "provider_chain": ["yfinance"],
+                                 "num_trades": _res.get("total_trades", 0),
+                                 "start_date": start_date, "end_date": end_date})
+                    return _res
 
                 yf_result = await asyncio.get_event_loop().run_in_executor(None, _run_yf_backtest)
                 if yf_result and yf_result.get("success"):
@@ -546,8 +497,11 @@ class BacktestCommandsMixin:
                 for r in rows:
                     tbl.add_row(*r)
                 self.context.console.print(tbl)
-                self.context.console.print(
-                    f"  [bold]{self._bt_result_summary(d, lang=self.terminal.config.get('ui_lang', 'en') or 'en')}[/bold]")
+                # Wrapped lines stay beside "  ", not at column 0.
+                from aria_code.ui.render.output import print_hanging
+                print_hanging(self.context.console, "  ",
+                              self._bt_result_summary(d, lang=self.terminal.config.get('ui_lang', 'en') or 'en'),
+                              "bold")
 
                 actual_start = self._bt_value(d, "start", "start_date", default=start_date)
                 actual_end = self._bt_value(d, "end", "end_date", default=end_date)
@@ -561,12 +515,17 @@ class BacktestCommandsMixin:
                 from rich.table import Table
                 from rich.text import Text
                 from aria_code.ui.render.output import file_uri
+                from backtest_report import normalize_strategy as _normalize_strategy
 
                 facts: list[tuple[str, object]] = [
                     ("source", src),
                     ("period", f"{actual_start} → {actual_end} · {bars} bars"),
                     ("capital", initial),
-                    ("params", f"momentum={_momentum_period} fast={_fast_period} slow={_slow_period}"),
+                    # The parameters the strategy used: SMA showed momentum=20.
+                    ("params", {
+                        "momentum": f"momentum={_momentum_period}",
+                        "sma_cross": f"fast={_fast_period} slow={_slow_period}",
+                    }.get(_normalize_strategy(strategy) or "", "—")),
                 ]
                 if d.get("provider_chain"):
                     chain = " → ".join(str(x) for x in d.get("provider_chain") or [])

{aria_code-0.97.0 → aria_code-0.98.0}/src/aria_code/domain/backtest_report.py

@@ -93,19 +93,36 @@ def _sma(values: Sequence[float], window: int) -> List[Optional[float]]:
     return out
 
 
+# Every name accepted, mapped to the strategy it runs.
+STRATEGY_ALIASES = {
+    "buy_hold": "buy_hold", "buyhold": "buy_hold", "hold": "buy_hold", "buy_and_hold": "buy_hold",
+    "sma_cross": "sma_cross", "ma_cross": "sma_cross", "moving_average": "sma_cross", "sma": "sma_cross",
+    "sma_crossover": "sma_cross", "ma_crossover": "sma_cross",
+    "momentum": "momentum", "mom": "momentum",
+}
+
+
+def normalize_strategy(name: str) -> Optional[str]:
+    """The strategy a name runs, or None if there is no such strategy."""
+    return STRATEGY_ALIASES.get((name or "momentum").lower().replace("-", "_").replace(" ", "_"))
+
+
 def _signals(strategy: str, closes: Sequence[float], fast: int, slow: int, momentum_period: int) -> List[int]:
-    strategy = (strategy or "momentum").lower().replace("-", "_").replace(" ", "_")
+    known = normalize_strategy(strategy)
+    if known is None:
+        # Any other name used to fall through to buy-and-hold and be reported
+        # under the name asked for: "/backtest sma AAPL" was buy-and-hold.
+        raise ValueError(f"Unknown strategy '{strategy}'. Available: momentum, sma_cross (sma), buy_hold")
+    strategy = known
     n = len(closes)
-    if strategy in ("buy_hold", "buyhold", "hold"):
+    if strategy == "buy_hold":
         return [1] * n
-    if strategy in ("sma_cross", "ma_cross", "moving_average"):
+    if strategy == "sma_cross":
         fast_ma = _sma(closes, max(2, fast))
         slow_ma = _sma(closes, max(max(3, slow), fast + 1))
         return [1 if f is not None and s is not None and f > s else 0 for f, s in zip(fast_ma, slow_ma)]
-    if strategy in ("momentum", "mom"):
-        period = max(2, momentum_period)
-        return [1 if i >= period and closes[i] > closes[i - period] else 0 for i in range(n)]
-    return [1] * n
+    period = max(2, momentum_period)
+    return [1 if i >= period and closes[i] > closes[i - period] else 0 for i in range(n)]
 
 
 def _max_drawdown(values: Sequence[float]) -> float:
@@ -142,7 +159,10 @@ def run_backtest_from_history(history: Sequence[Dict[str, Any]], config: Backtes
     closes = [float(r["close"]) for r in rows]
     volumes = [_as_float(r.get("volume")) for r in rows]
     valid_volumes = [v for v in volumes if v is not None and v >= 0]
-    signals = _signals(config.strategy, closes, config.fast_period, config.slow_period, config.momentum_period)
+    try:
+        signals = _signals(config.strategy, closes, config.fast_period, config.slow_period, config.momentum_period)
+    except ValueError as exc:
+        return {"success": False, "symbol": config.symbol, "strategy": config.strategy, "error": str(exc)}
 
     initial = float(config.initial_capital or 100000.0)
     equity = [initial]
@@ -151,12 +171,18 @@ def run_backtest_from_history(history: Sequence[Dict[str, Any]], config: Backtes
     daily_benchmark_returns = [0.0]
     trades = 0
     previous_position = 0
+    trade_results: List[float] = []   # return of each round trip
+    entry_equity = None
 
     for i in range(1, len(closes)):
         day_return = closes[i] / closes[i - 1] - 1.0
         position = signals[i - 1]  # shift one day to avoid look-ahead bias
         if position == 1 and previous_position == 0:
             trades += 1
+            entry_equity = equity[-1]
+        elif position == 0 and previous_position == 1 and entry_equity:
+            trade_results.append(equity[-1] / entry_equity - 1.0)
+            entry_equity = None
         previous_position = position
         strategy_return = day_return * position
         daily_strategy_returns.append(strategy_return)
@@ -171,8 +197,11 @@ def run_backtest_from_history(history: Sequence[Dict[str, Any]], config: Backtes
     annualized_return = (1.0 + total_return) ** (1.0 / years) - 1.0 if total_return > -1 else -1.0
     volatility = _stddev(daily_strategy_returns[1:]) * math.sqrt(252)
     sharpe = (sum(daily_strategy_returns[1:]) / max(len(daily_strategy_returns) - 1, 1)) / _stddev(daily_strategy_returns[1:]) * math.sqrt(252) if _stddev(daily_strategy_returns[1:]) > 0 else 0.0
-    active_returns = [r for r, s in zip(daily_strategy_returns[1:], signals[:-1]) if s == 1]
-    win_rate = sum(1 for r in active_returns if r > 0) / len(active_returns) if active_returns else 0.0
+    if entry_equity:
+        trade_results.append(equity[-1] / entry_equity - 1.0)   # still open: marked at the last close
+    # Winning trades over trades. This was the share of up days while holding,
+    # so one buy-and-hold "trade" showed a 52.5% win rate.
+    win_rate = sum(1 for r in trade_results if r > 0) / len(trade_results) if trade_results else 0.0
 
     curve = [
         {

{aria_code-0.97.0 → aria_code-0.98.0}/src/aria_code/ui/render/output.py

@@ -281,17 +281,23 @@ def error_hint(error: str, context: str = "") -> str:
         "http://", "https://", "www.", ".com", ".org", ".net",
         "web_fetch", "web fetch", "forbidden",
     ))
-    if "401" in err_lower or "unauthorized" in err_lower:
+    def code(n: str) -> bool:
+        # A status code as a number of its own: "1500 bars" is not a 500.
+        return re.search(rf"(?<!\d){n}(?!\d)", err_lower) is not None
+
+    if code("401") or "unauthorized" in err_lower:
         if any(h in err_lower for h in ("finnhub", "alphavantage", "polygon", "api/v1", "api/v2/finance")):
             return "Hint: API key required — /apikey set finnhub <KEY>  (free at finnhub.io)"
         if _is_web:
             return "Hint: This site blocks automated access (paywall/anti-bot). Try another source."
         return "Hint: Authentication required. Run /login to sign in."
-    if "403" in err_lower or "forbidden" in err_lower:
+    if code("403") or "forbidden" in err_lower:
         if _is_web:
             return "Hint: This site blocks automated access (paywall/anti-bot). Try another source."
         return "Hint: Access denied. Check your API key or subscription."
-    if "429" in err_lower or "rate" in err_lower:
+    # "rate" alone matched strategy, generate and separate: "Unknown strategy"
+    # came with "Rate limited. Wait a moment and try again."
+    if code("429") or re.search(r"rate[\s_-]?limit|too many requests", err_lower):
         return "Hint: Rate limited. Wait a moment and try again."
     if ("ollama" in err_lower or "ollama http" in err_lower) and (
         "not found" in err_lower or "404" in err_lower
@@ -319,15 +325,15 @@ def error_hint(error: str, context: str = "") -> str:
     if "file not found" in err_lower or "no such file" in err_lower:
         return ("Hint: This file does not exist. Do NOT guess other filenames — "
                 "list the directory first, or this question may not need a file at all.")
-    if "404" in err_lower and context == "tool":
+    if code("404") and context == "tool":
         return "Hint: Tool not available. Check /tools for available tools."
     if "not found" in err_lower and context == "session":
         return "Hint: Session not found. Run /sessions to list available."
-    if "404" in err_lower or ("not found" in err_lower and context not in ("tool", "")):
+    if code("404") or ("not found" in err_lower and context not in ("tool", "")):
         return "Hint: Resource not found. Check the symbol or path."
     if "no data" in err_lower or "no result" in err_lower:
         return "Hint: No data returned. Verify the symbol spelling."
-    if "500" in err_lower or "internal" in err_lower:
+    if code("500") or "internal server" in err_lower:
         return "Hint: Server error. Try again in a moment or /health to check."
     if context == "login":
         return "Hint: Check email/password. Usage: /login email password"
@@ -353,6 +359,11 @@ def print_hanging(console, prefix: str, text: str, style: str = "") -> None:
     console.print(grid)
 
 
+# The contexts error_hint() understands; anything else given is a hint to show.
+ERROR_CONTEXTS = frozenset({"", "tool", "login", "session", "screenshot", "vision", "browser",
+                            "browser screenshot", "deep"})
+
+
 def print_error(
     msg: str,
     context: str = "",
@@ -362,7 +373,15 @@ def print_error(
     rich_box=None,
     use_panel: bool = False,
 ) -> None:
-    hint = error_hint(msg, context)
+    # The second argument is either where the error came from ("tool",
+    # "login"), from which a hint is guessed, or the hint itself. Most callers
+    # pass the hint: "请先用 /broker add 添加", "Usage: /compare SYMBOL …",
+    # "Install: pip install mss pillow". It was taken for a context and never
+    # shown, and a guess took its place.
+    if str(context or "").strip().lower() in ERROR_CONTEXTS:
+        hint = error_hint(msg, context)
+    else:
+        hint = str(context)
     if not use_panel:
         # Claude Code style: clean └ tree connector for inline error guidance
         if has_rich:

{aria_code-0.97.0 → aria_code-0.98.0/src/aria_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.97.0
+Version: 0.98.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.97.0 → aria_code-0.98.0}/src/aria_code.egg-info/SOURCES.txt

@@ -517,6 +517,7 @@ tests/test_background_processes.py
 tests/test_backtest_cmds.py
 tests/test_backtest_engine.py
 tests/test_backtest_report.py
+tests/test_backtest_runs_what_it_names.py
 tests/test_binary_bundles_runtime_imports.py
 tests/test_broken_akshare_is_optional.py
 tests/test_broker_automation.py

aria_code-0.98.0/tests/test_backtest_runs_what_it_names.py

@@ -0,0 +1,106 @@
+"""/backtest runs the strategy it names on the symbol it names, and counts wins per trade.
+
+"/backtest AAPL sma" ran a strategy called "AAPL" on the ticker SMA; the
+engine did not know "AAPL" (nor "sma") and ran buy-and-hold under that name,
+so the result matched buy-and-hold to the decimal. The yfinance fallback ran
+momentum whatever was asked. "Win Rate" was the share of up days while
+holding: one buy-and-hold trade showed 52.5%. And error guidance passed to
+print_error was never shown; a hint guessed from "rate" in "strategy" said
+"Rate limited".
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from aria_code.domain.backtest_report import BacktestConfig, normalize_strategy, run_backtest_from_history
+from aria_code.ui.render.output import error_hint
+
+
+def _history(closes):
+    return [{"date": f"2025-{1 + i // 28:02d}-{1 + i % 28:02d}", "close": c, "volume": 1000} for i, c in enumerate(closes)]
+
+
+@pytest.mark.parametrize("name, runs", [("sma", "sma_cross"), ("ma_crossover", "sma_cross"),
+                                        ("buy_and_hold", "buy_hold"), ("mom", "momentum"), ("AAPL", None)])
+def test_strategy_names(name, runs):
+    assert normalize_strategy(name) == runs
+
+
+def test_an_unknown_strategy_is_an_error_not_buy_and_hold():
+    closes = [100 + i for i in range(120)]
+    result = run_backtest_from_history(_history(closes), BacktestConfig(symbol="AAPL", strategy="turtle",
+                                                                        start_date="2025-01-01",
+                                                                        end_date="2025-12-31"))
+    assert result["success"] is False and "Unknown strategy 'turtle'" in result["error"]
+
+
+def test_win_rate_counts_trades_not_days():
+    # Rises then falls every 20 days: SMA crossings make several round trips.
+    closes = []
+    price = 100.0
+    for i in range(240):
+        price *= 1.01 if (i // 20) % 2 == 0 else 0.99
+        closes.append(round(price, 4))
+    cfg = BacktestConfig(symbol="X", strategy="sma", start_date="2025-01-01", end_date="2025-12-31",
+                         fast_period=5, slow_period=10)
+    result = run_backtest_from_history(_history(closes), cfg)
+    assert result["success"]
+    trades = result["total_trades"]
+    assert trades >= 2
+    # A win rate over trades is a multiple of 1/trades.
+    assert abs(result["win_rate"] * trades - round(result["win_rate"] * trades)) < 1e-6
+
+    hold = run_backtest_from_history(_history(closes), BacktestConfig(
+        symbol="X", strategy="buy_hold", start_date="2025-01-01", end_date="2025-12-31"))
+    assert hold["total_trades"] == 1 and hold["win_rate"] in (0.0, 1.0)
+
+
+@pytest.mark.parametrize("message", ["Unknown strategy: turtle", "No strategy results", "generate failed",
+                                     "only 1500 bars"])
+def test_hints_are_not_guessed_from_parts_of_words(message):
+    assert "Rate limited" not in error_hint(message)
+    assert "Server error" not in error_hint(message)
+
+
+def test_real_rate_limits_still_get_the_hint():
+    assert "Rate limited" in error_hint("HTTP 429 Too Many Requests")
+    assert "Rate limited" in error_hint("yfinance rate limit reached")
+
+
+def test_the_callers_hint_is_shown(snapshot):
+    from aria_code.ui.render.output import print_error
+
+    con = snapshot.console()
+    print_error("No broker configured", "请先用 /broker add 添加", console=con, has_rich=True)
+    print_error("Login failed", "login", console=con, has_rich=True)
+    text = con.file.getvalue()
+    assert "请先用 /broker add 添加" in text
+    assert "Check email/password" in text
+
+
+def test_backtest_takes_either_order(monkeypatch):
+    import asyncio
+    from types import SimpleNamespace
+
+    import aria_code.apps.cli.commands.backtest_cmds as backtest_cmds
+
+    seen = {}
+
+    def fake_report(config, output_dir=None):
+        seen["strategy"], seen["symbol"] = config.strategy, config.symbol
+        return {"success": False, "error": "stop here"}
+
+    import backtest_report
+    monkeypatch.setattr(backtest_report, "generate_backtest_report", fake_report)
+    monkeypatch.setitem(__import__("sys").modules, "yfinance", None)
+    printed = []
+    console = SimpleNamespace(print=lambda *a, **k: printed.append(" ".join(map(str, a))),
+                              status=lambda *a, **k: __import__("contextlib").nullcontext(), width=100)
+
+    class Cli(backtest_cmds.BacktestCommandsMixin):
+        context = SimpleNamespace(has_rich=True, console=console)
+        terminal = SimpleNamespace(config={"ui_lang": "en", "api_url": "http://127.0.0.1:9"})
+
+    asyncio.run(Cli().cmd_backtest("AAPL sma"))
+    assert seen == {"strategy": "sma", "symbol": "AAPL"}