aria-code 0.85.0__tar.gz → 0.87.0__tar.gz

{aria_code-0.85.0/src/aria_code.egg-info → aria_code-0.87.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.85.0
+Version: 0.87.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.85.0 → aria_code-0.87.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.85.0"
+version = "0.87.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.85.0 → aria_code-0.87.0}/src/aria_code/_version.py

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

{aria_code-0.85.0 → aria_code-0.87.0}/src/aria_code/apps/cli/commands/core_cmds.py

@@ -2187,28 +2187,40 @@ class CoreCommandsMixin:
                     "resistance": res3,
                 },
             }
+            # The summary was Chinese whatever the UI language ("趋势: 偏多 …
+            # 自审通过"); the trend value itself comes from the chart in Chinese.
+            _zh = str(self.terminal.config.get("ui_lang", "en")).lower().startswith("zh")
+            _T = (lambda a, b: a) if _zh else (lambda a, b: b)
+            _trend = str(result.get("trend") or "—")
+            if not _zh:
+                _trend = {"偏多": "bullish", "偏空": "bearish", "震荡": "range-bound",
+                          "震荡/中性": "range-bound"}.get(_trend, _trend)
+            _summary = (
+                f"{display_label}  {_T('趋势', 'trend')}: {_trend}  "
+                f"RSI: {f'{rsi_val:.1f}' if rsi_val else '—'}  "
+                f"{_T('支撑', 'support')}: {'/'.join(str(v) for v in sup3) or '—'}  "
+                f"{_T('阻力', 'resistance')}: {'/'.join(str(v) for v in res3) or '—'}  "
+                f"{_T('数据', 'source')}: {provider}"
+            )
+            _issues_head = _T(f"自审发现 {len(issues)} 个问题:", f"self-check found {len(issues)} issue(s):")
+            _clean = _T("自审通过（数据质量正常）", "self-check passed (data quality normal)")
             if self.context.has_rich:
-                self.context.console.print(f"  [green]✓[/green] chart generated  [dim]({elapsed_ms}ms)[/dim]")
-                self.context.console.print(f"    saved: [link={path}]{path_label}[/link]")
-                self.context.console.print(
-                    f"    [dim]{display_label}  "
-                    f"趋势: {result.get('trend','—')}  "
-                    f"RSI: {f'{rsi_val:.1f}' if rsi_val else '—'}  "
-                    f"支撑: {'/'.join(str(v) for v in sup3) or '—'}  "
-                    f"阻力: {'/'.join(str(v) for v in res3) or '—'}  "
-                    f"数据: {provider}[/dim]"
-                )
+                from rich.markup import escape as _esc
+
+                self.context.console.print(f"  [green]✓[/green] {_T('图表已生成', 'chart generated')}  [dim]({elapsed_ms}ms)[/dim]")
+                self.context.console.print(f"    {_T('已保存', 'saved')}: [link={path}]{path_label}[/link]")
+                self.context.console.print(f"    [dim]{_esc(_summary)}[/dim]")
                 if issues:
-                    self.context.console.print(f"  [yellow]⚠ 自审发现 {len(issues)} 个问题:[/yellow]")
+                    self.context.console.print(f"  [yellow]⚠ {_issues_head}[/yellow]")
                     for iss in issues:
-                        self.context.console.print(f"    [yellow]· {iss}[/yellow]")
+                        self.context.console.print(f"    [yellow]· {_esc(str(iss))}[/yellow]")
                 else:
-                    self.context.console.print("  [green dim]✓ 自审通过（数据质量正常）[/green dim]")
+                    self.context.console.print(f"  [green dim]✓ {_clean}[/green dim]")
             else:
-                print(f"  OK chart generated ({elapsed_ms}ms): {path_label}")
-                print(f"  {display_label}  趋势: {result.get('trend','—')}  RSI: {f'{rsi_val:.1f}' if rsi_val else '—'}  数据: {provider}")
+                print(f"  OK {_T('图表已生成', 'chart generated')} ({elapsed_ms}ms): {path_label}")
+                print(f"  {_summary}")
                 if issues:
-                    print(f"  ⚠ 自审发现 {len(issues)} 个问题:")
+                    print(f"  ⚠ {_issues_head}")
                     for iss in issues:
                         print(f"    · {iss}")
             import subprocess as _sp

{aria_code-0.85.0 → aria_code-0.87.0}/src/aria_code/apps/cli/commands/market.py

@@ -6,6 +6,7 @@ CLI, Feishu, and future gateway adapters can share the same command semantics.
 
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
 from typing import Mapping
 
@@ -56,13 +57,13 @@ _DASHBOARD_MODE_HINTS: tuple[tuple[tuple[str, ...], str], ...] = (
 )
 
 _CHART_PERIOD_HINTS: tuple[tuple[tuple[str, ...], str], ...] = (
-    (("近一年", "一年", "1y", "1年"), "1y"),
-    (("近三个月", "三个月", "3m", "3个月"), "3m"),
-    (("近六个月", "六个月", "6m", "6个月"), "6m"),
-    (("年初至今", "ytd"), "ytd"),
-    (("两年", "2y"), "2y"),
-    (("三年", "3y"), "3y"),
-    (("五年", "5y"), "5y"),
+    (("近三个月", "三个月", "3m", "3个月", "3 months", "three months", "3-month", "quarter"), "3m"),
+    (("近六个月", "六个月", "6m", "6个月", "6 months", "six months", "6-month", "half a year"), "6m"),
+    (("年初至今", "ytd", "year to date"), "ytd"),
+    (("两年", "2y", "2 years", "two years"), "2y"),
+    (("三年", "3y", "3 years", "three years"), "3y"),
+    (("五年", "5y", "5 years", "five years"), "5y"),
+    (("近一年", "一年", "1y", "1年", "1 year", "one year", "a year", "12 months"), "1y"),
 )
 
 _REPORT_TYPE_HINTS: tuple[tuple[tuple[str, ...], str], ...] = (
@@ -80,7 +81,13 @@ _TRADINGVIEW_ANALYSIS_HINTS = (
     "指标", "信号", "analyze", "analysis", "data", "indicator", "signal",
 )
 
-_ROUTE_SYMBOL_BLOCKLIST = {"K", "LINE", "CHART", "PLOT"}
+_ROUTE_SYMBOL_BLOCKLIST = {
+    "K", "LINE", "CHART", "PLOT",
+    # Product and engineering acronyms, typed in capitals and almost never a
+    # ticker in a message: "news app UI design ideas" ran `/news UI`.
+    "UI", "UX", "API", "CLI", "SDK", "URL", "PDF", "CSS", "HTML", "SQL", "JSON", "CSV", "IDE",
+    "OS", "PR", "QA", "CI", "CD", "MVP", "LLM", "GPU", "CPU", "RAM", "SSD", "DB",
+}
 _CHART_CONTEXT_TOKEN_BLOCKLIST = {
     "ABOVE", "BELOW", "INC", "TTM", "RATIO", "SIGNAL", "SUPPORT", "RESIST",
     "RESISTANCE", "LEVEL", "LEVELS", "HIGH", "LOW", "OPEN", "CLOSE", "AVG",
@@ -115,8 +122,31 @@ def _news_topic(text: str, symbols: list[str]) -> str:
     return symbols[0] if symbols else text
 
 
+def _known_tickers() -> frozenset[str]:
+    """Tickers Aria knows by name — the company table's values."""
+    global _KNOWN_TICKERS
+    if _KNOWN_TICKERS is None:
+        try:
+            from aria_code.apps.cli.utils.market_detect import _COMPANY_TO_TICKER
+
+            _KNOWN_TICKERS = frozenset(str(v).upper() for v in _COMPANY_TO_TICKER.values() if v)
+        except Exception:
+            _KNOWN_TICKERS = frozenset()
+    return _KNOWN_TICKERS
+
+
+_KNOWN_TICKERS: frozenset[str] | None = None
+
+
 def _route_symbols(text: str, *, limit: int = 6) -> list[str]:
-    """Resolve ticker/company mentions for natural-language command routing."""
+    """Resolve ticker/company mentions for natural-language command routing.
+
+    The second pass reads the message upper-cased so "aapl" is found — and it
+    used to accept anything that came out of it, so every English word became
+    a ticker: "what's the latest version of python?" ran `/news WHAT`, "write a
+    report generator script" ran `/report WRITE`. That pass now adds only
+    tickers Aria knows; the message as typed is read as before.
+    """
     seen: set[str] = set()
     out: list[str] = []
     for source in (text, text.upper()):
@@ -126,6 +156,8 @@ def _route_symbols(text: str, *, limit: int = 6) -> list[str]:
                 not normalized
                 or normalized in _ROUTE_SYMBOL_BLOCKLIST
                 or _is_blocked_market_symbol_candidate(normalized)
+                or (source is not text and normalized not in _known_tickers()
+                    and normalized not in text)
             ):
                 continue
             if len(normalized) == 1 and "." not in normalized:
@@ -135,7 +167,10 @@ def _route_symbols(text: str, *, limit: int = 6) -> list[str]:
                 out.append(normalized)
                 if len(out) >= limit:
                     return out
-    single = _extract_market_symbol(text) or _extract_market_symbol(text.upper())
+    single = _extract_market_symbol(text)
+    if not single:
+        upper = _extract_market_symbol(text.upper())
+        single = upper if str(upper or "").upper() in _known_tickers() else ""
     normalized = str(single or "").upper()
     if (
         normalized
@@ -236,12 +271,67 @@ def parse_analysis_args(args: str, *, default_symbol: str = "AAPL") -> AnalysisA
     return AnalysisArgs(symbol=(symbol or default_symbol).upper(), focus=focus, lang=lang)
 
 
+_DATA_FILE_RE = re.compile(r"(?<![\w/.-])([\w./-]+\.(?:csv|tsv|xlsx|xls|json))(?![\w.])", re.I)
+_CODE_FILE_RE = re.compile(r"\b[\w./-]+\.(?:py|js|ts|tsx|jsx|go|rs|java|rb|php|c|cc|cpp|h|cs|swift|kt|sh|"
+                           r"md|txt|toml|ya?ml|html|css|sql|ipynb|csv|tsv|json|xlsx?)\b", re.I)
+_CODE_WORDS = (
+    "script", "function", "class", "method", "refactor", "repo", "repository", "stack trace", "traceback",
+    "test coverage", "unit test", "pattern", "code", "compile", "debug", "regex", "api", "endpoint",
+    "代码", "脚本", "函数", "重构", "仓库", "测试", "报错", "调试", "接口",
+)
+# English words match whole words ("repo" is not in "report"); Chinese has no
+# spaces, so it matches as a substring.
+_CODE_WORD_RE = re.compile(
+    r"\b(?:" + "|".join(re.escape(w) for w in _CODE_WORDS if w.isascii()) + r")(?:s|es)?\b", re.I)
+_INVENTORY_WORDS = ("inventory", "reorder", "re-order", "safety stock", "stockout", "sku", "库存", "补货", "安全库存", "断货")
+_CARRIER_WORDS = ("carrier", "freight", "waybill", "shipping cost", "lane", "承运商", "运单", "运费", "物流成本")
+_FINANCE_WORDS = ("market", "stock", "finance", "financial", "earnings", "市场", "股", "财经", "金融", "财报")
+# Commands that act on one instrument and must not guess one.
+_SYMBOL_COMMANDS = {"/analyze", "/risk", "/strategy", "/signal", "/predict", "/report", "/news", "/chart",
+                    "/backtest"}
+
+
+def _logistics_route(text: str, low: str, available_commands: set[str]) -> RoutedCommand | None:
+    """ "Which SKUs in skus.csv need reordering?" → /inventory skus.csv, when that file exists."""
+    import os
+
+    files = [m.group(1) for m in _DATA_FILE_RE.finditer(text) if os.path.isfile(m.group(1))]
+    if not files:
+        return None
+    if "/inventory" in available_commands and any(w in low for w in _INVENTORY_WORDS):
+        return RoutedCommand(command="/inventory", args=files[0])
+    if "/carriers" in available_commands and any(w in low for w in _CARRIER_WORDS):
+        return RoutedCommand(command="/carriers", args=files[0])
+    return None
+
+
+def _looks_like_code_work(text: str, low: str) -> bool:
+    """A message about code or a data file, which is the model's to answer.
+
+    "plot a histogram of ages in data.csv" ran `/chart OF AGES GE IN CSV`,
+    "analyze this stack trace" ran `/analyze`, "strategy pattern in python"
+    ran `/strategy`. None of them is a market request.
+    """
+    return (bool(_CODE_FILE_RE.search(text)) or bool(_CODE_WORD_RE.search(low))
+            or any(word in low for word in _CODE_WORDS if not word.isascii()))
+
+
 def route_top_level_text(user_input: str, available_commands: set[str]) -> RoutedCommand | None:
-    """Translate bare workflow text into a slash command when possible."""
+    """Translate bare workflow text into a slash command when possible.
+
+    Only requests this can answer with certainty run a command; anything else
+    — code, data files, a keyword with no instrument — goes to the model,
+    which has the same tools and can ask.
+    """
 
     stripped = user_input.strip()
     if not stripped or stripped.startswith("/"):
         return None
+    logistics = _logistics_route(stripped, stripped.lower(), available_commands)
+    if logistics is not None:
+        return logistics
+    if _looks_like_code_work(stripped, stripped.lower()):
+        return None
         
     low = stripped.lower()
     
@@ -336,13 +426,23 @@ def route_top_level_text(user_input: str, available_commands: set[str]) -> Route
         "新闻", "消息", "最新进展", "最近进展", "news", "latest", "recent",
     )):
         symbols = _route_symbols(stripped)
-        return RoutedCommand(command="/news", args=_news_topic(stripped, symbols))
+        topic = _news_topic(stripped, symbols)
+        # "latest"/"recent" alone are ordinary words ("the latest version of
+        # python"): without an instrument, only an explicit news request about
+        # markets is one ("今天有什么财经新闻", "market news today").
+        explicit = any(k in low for k in ("新闻", "news")) and any(k in low for k in _FINANCE_WORDS)
+        if symbols or topic in ("SpaceX", "LVMH") or explicit:
+            return RoutedCommand(command="/news", args=topic)
     parts = stripped.split(maxsplit=1)
     keyword = parts[0].lower()
     rest = parts[1] if len(parts) > 1 else ""
     command = TOP_LEVEL_ROUTES.get(keyword)
     if not command or command not in available_commands:
         return None
+    # "risk of this refactor?", "strategy pattern …", "analyze this …": these
+    # commands act on one instrument, and parse_analysis_args fell back to AAPL.
+    if command in _SYMBOL_COMMANDS and not _route_symbols(rest or stripped):
+        return None
     if command == "/analyze":
         parsed = parse_analysis_args(rest)
         focus_arg = f" --focus {parsed.focus}" if parsed.focus else ""
@@ -424,11 +524,18 @@ def parse_technical_args(args: str, *, default_symbol: str = "AAPL", default_day
     return TechnicalArgs(symbol=symbol, days=days)
 
 
-async def try_top_level_route(user_input: str, commands) -> bool:
-    """Execute a top-level routed slash command through a SlashCommands object."""
+async def try_top_level_route(user_input: str, commands, *, announce=None) -> bool:
+    """Execute a top-level routed slash command through a SlashCommands object.
+
+    ``announce`` is told the command first ("→ /news AAPL"): the interactive
+    loop routes here before send_message, so a routed message used to run its
+    command with nothing on screen saying which.
+    """
 
     routed = route_top_level_text(user_input, set(commands.commands))
     if routed is None:
         return False
+    if announce is not None:
+        announce(routed.text)
     await commands.execute(routed.text)
     return True

{aria_code-0.85.0 → aria_code-0.87.0}/src/aria_code/apps/cli/commands/market_cmds.py

@@ -352,6 +352,24 @@ from typing import Dict, Any, Optional
 logger = logging.getLogger(__name__)
 
 
+def _news_date(raw: str) -> str:
+    """A feed's publish time as 2026-10-05.
+
+    The first ten characters were kept, which suits ISO dates and cut an RSS
+    date mid-word: "Mon, 05 Oct 2026 12:00:00 GMT" showed as "Mon, 05 Oc".
+    """
+    from datetime import datetime
+    from email.utils import parsedate_to_datetime
+
+    text = str(raw or "").strip()
+    for parse in (lambda t: datetime.fromisoformat(t.replace("Z", "+00:00")), parsedate_to_datetime):
+        try:
+            return parse(text).strftime("%Y-%m-%d")
+        except (TypeError, ValueError, IndexError):
+            continue
+    return text[:10]
+
+
 class MarketCommandsMixin:
     """Mixin: Market commands: quote, realty, football, screen, news, screen_cn, limitup, north."""
 
@@ -1185,7 +1203,7 @@ class MarketCommandsMixin:
                         url_item = a.get("url", a.get("link", ""))
                         pub_date = a.get("published_at", a.get("date", a.get("publishedAt", "")))
                         if pub_date:
-                            pub_date = pub_date[:10] if len(pub_date) >= 10 else pub_date
+                            pub_date = _news_date(pub_date)
                     else:
                         title = str(a)
                         source = pub_date = url_item = ""
@@ -1224,7 +1242,7 @@ class MarketCommandsMixin:
                     source = a.get("source", "") if isinstance(a, dict) else ""
                     pub_date = a.get("published_at", "") if isinstance(a, dict) else ""
                     if pub_date:
-                        pub_date = pub_date[:10] if len(pub_date) >= 10 else pub_date
+                        pub_date = _news_date(pub_date)
                     if self.context.has_rich:
                         self.context.console.print(f"  [bold]{idx}.[/bold] {title}")
                         meta_parts = [p for p in [source, pub_date] if p]

{aria_code-0.85.0 → aria_code-0.87.0}/src/aria_code/apps/cli/handlers/market_handlers.py

@@ -294,6 +294,11 @@ def _nearest_levels(
     return support, resistance
 
 
+def _compact_levels(currency: str, levels: list[float]) -> str:
+    """"USD 332.54 / 328.35 / 325.81": the currency once."""
+    return f"{currency} " + " / ".join(f"{v:,.2f}" for v in levels) if levels else "—"
+
+
 def _format_levels(currency: str, levels: list[float]) -> str:
     return ", ".join(f"{currency} {v:,.2f}" for v in levels) if levels else "—"
 
@@ -389,22 +394,17 @@ def _append_timeframe_levels(
         resistance = row.get("resistance") or []
         action = _level_action_line(name, support, resistance, currency, english=english)
 
+        # Two lines a timeframe, not four: the levels on one line, what to do
+        # with them on the next. Every level stays; the data source is in the
+        # header already. The whole snapshot ran to about 48 lines.
         if english:
-            meta = f"For: {horizon}"
-            if source:
-                meta += f" · Source: {source}"
-            lines.append(f"- **{name}** — {meta}")
-            lines.append(f"  - Support: {_format_levels(currency, support)}")
-            lines.append(f"  - Resistance: {_format_levels(currency, resistance)}")
-            lines.append(f"  - Use: {action}")
+            lines.append(f"- **{name}** ({horizon}) — support {_compact_levels(currency, support)}"
+                         f" · resistance {_compact_levels(currency, resistance)}  ")
+            lines.append(f"  {action}")
         else:
-            meta = f"适合：{horizon}"
-            if source:
-                meta += f" · 来源：{source}"
-            lines.append(f"- **{name}** — {meta}")
-            lines.append(f"  - 支撑：{_format_levels(currency, support)}")
-            lines.append(f"  - 压力：{_format_levels(currency, resistance)}")
-            lines.append(f"  - 用法：{action}")
+            lines.append(f"- **{name}**（{horizon}）— 支撑 {_compact_levels(currency, support)}"
+                         f" · 压力 {_compact_levels(currency, resistance)}  ")
+            lines.append(f"  {action}")
 
 
 _HORIZON_UNITS_EN = {"日": "days", "周": "weeks", "月": "months"}

{aria_code-0.85.0 → aria_code-0.87.0}/src/aria_code/apps/cli/prompts/system_prompts.py

@@ -38,7 +38,7 @@ def build_response_style_rule(lang: str) -> str:
         return (
             "## Terminal Answer Style\n"
             "- Lead with the answer or conclusion. Do not start with filler such as 'Sure' or 'I can help'.\n"
-            "- Strict Currency: US assets (e.g. AAPL, TSLA) use '$' (USD); A-shares use '¥' (CNY); HK assets use 'HK$'. Never mix currencies.\n"
+            "- Strict Currency: label amounts with the asset's currency as the data gives it — USD for US assets (e.g. AAPL, TSLA), CNY for A-shares, HKD for Hong Kong — and never mix currencies.\n"
             "- Format Financial Metrics Cleanly: Use structured Markdown tables or concise bullet points for Price, RSI, MACD, MA, and Bollinger Bands.\n"
             "- Never dump raw, unexecuted Python code or pseudo-scripts in chat when performing analytical queries. Synthesize insights directly.\n"
             "- Never explain tool errors, missing parameters, or recovery mechanics to the user. Silently proceed with available data.\n"
@@ -53,7 +53,7 @@ def build_response_style_rule(lang: str) -> str:
     return (
         "## 终端回答风格\n"
         "- 先给结论或直接答案，不要以“好的/当然/我来帮你”开头。\n"
-        "- 严格匹配货币符号：美股（如 AAPL、TSLA）必须使用 '$' (USD)；A股使用 '¥' (CNY)；港股使用 'HK$'。严禁将美股均线/价格标注为人民币。\n"
+        "- 严格匹配货币：按数据给出的货币代码标注金额——美股（如 AAPL、TSLA）用 USD，A股用 CNY，港股用 HKD；严禁混用，严禁将美股均线/价格标注为人民币。\n"
         "- 金融指标结构化排版：价格、涨跌幅、RSI、MACD、均线、布林带等必须使用结构清晰的 Markdown 表格或整齐键值对呈现，禁止乱序纯文本堆砌。\n"
         "- 严禁在对话中向用户输出未执行的 Python 伪代码或脚本片段；直接给出整理后的金融分析结论与核心数据。\n"
         "- 严禁向用户解释底层工具调用失败的原因或道歉（如“因缺少参数导致web_search失败”）；遇网络或工具异常时静默使用备用数据并继续分析。\n"

{aria_code-0.85.0 → aria_code-0.87.0}/src/aria_code/aria_cli.py

@@ -2752,6 +2752,50 @@ def _render_answer_block(text: str) -> None:
     console.print(Padding(make_markdown(_strip_latex(text)), (0, 0, 0, 4)))
 
 
+_MODEL_UNAVAILABLE_MARKERS = (
+    "vertex_needs_project", "vertex_not_logged_in", "vertex_gcloud_failed", "missing_api_key:",
+    "no_cloud_provider", "no_provider", "all_providers_failed", "http 401", "http 403", "http 402",
+    "insufficient balance", "http 429", "rate limit",
+)
+
+
+def _model_unavailable(error: object) -> bool:
+    """The turn failed because no model could be reached — not because of what was asked."""
+    text = str(error or "").lower()
+    return any(marker in text for marker in _MODEL_UNAVAILABLE_MARKERS)
+
+
+def _data_without_model(message: str, history: list) -> dict:
+    """What Aria can answer from data alone, for a turn whose model is unreachable.
+
+    With no Google project set, "AAPL price" printed setup guidance and
+    nothing else, though the quote needs no model: the same pre-fetch that
+    serves tool-less routes answers it.
+    """
+    try:
+        found = _run_deterministic_chain(message, model_has_tools=False, history=history)
+    except Exception as exc:
+        logger.debug("data fallback failed: %s", exc)
+        return {}
+    return found if found.get("success") and (found.get("response") or "").strip() else {}
+
+
+def _announce_route(command_text: str) -> None:
+    """Say which command a plain-language message ran: "→ /news AAPL".
+
+    Routed messages used to run their command silently, so a misroute looked
+    like Aria misunderstanding, and nobody learned the command for next time.
+    """
+    if _ARIA_BOT_MODE:
+        return
+    if HAS_RICH:
+        from rich.text import Text
+
+        console.print(Text(f"  → {command_text}", style="dim"))
+    else:
+        print(f"  → {command_text}")
+
+
 def _print_tool_call(tool_name: str, params: dict):
     """Print tool call header — Claude Code-style ⏺ bullet tree."""
     if _ARIA_BOT_MODE:
@@ -4694,6 +4738,7 @@ class ArtheraTerminal:
             if routed is not None:
                 self._send_message_route_active = True
                 try:
+                    _announce_route(routed.text)
                     self._maybe_show_intent_preflight(routed.text)
                     await self.commands.execute(routed.text)
                 finally:
@@ -4703,6 +4748,7 @@ class ArtheraTerminal:
             if routed is not None:
                 self._send_message_route_active = True
                 try:
+                    _announce_route(routed.text)
                     self._maybe_show_intent_preflight(routed.text)
                     await self.commands.execute(routed.text)
                 finally:
@@ -5335,6 +5381,30 @@ class ArtheraTerminal:
                     result.get("error", "Unknown error"),
                     lang=self.config.get("ui_lang", "en") or "en",
                 )
+                _offline_answer = (
+                    _data_without_model(message, self.conversation[:-1])
+                    if _model_unavailable(result.get("error")) else {}
+                )
+                if _offline_answer:
+                    # The data is the answer; the model problem is a note under it.
+                    _en_note = _detect_lang(message) == "en"
+                    _answer = _offline_answer["response"]
+                    if HAS_RICH:
+                        console.print()
+                        console.print(make_markdown(_strip_latex(_answer)))   # its header carries the disclaimer
+                    else:
+                        print("\n" + _answer)
+                    self.conversation.append({"role": "assistant", "content": _answer})
+                    self._last_response = _answer
+                    error_presentation = AgentErrorPresentation(
+                        error=error_presentation.error,
+                        level="warning",
+                        lines=[
+                            ("模型不可用，以上为数据快照（未经模型分析）。" if not _en_note else
+                             "The model is unavailable, so this is the data snapshot without model analysis."),
+                            *error_presentation.lines[-1:],
+                        ],
+                    )
                 console.print() if HAS_RICH else print()
                 if error_presentation.use_generic_error_prefix:
                     _print_error(error_presentation.lines[0])
@@ -6357,7 +6427,7 @@ class ArtheraTerminal:
                 # Intercepts bare keywords like "analyze AAPL" → /analyze AAPL
                 # so users don't need to type the slash for common quant workflows.
                 self._maybe_show_intent_preflight(user_input)
-                _routed = await try_top_level_route(user_input, self.commands)
+                _routed = await try_top_level_route(user_input, self.commands, announce=_announce_route)
                 if _routed:
                     continue
 

{aria_code-0.85.0 → aria_code-0.87.0}/src/aria_code/ui/completer.py

@@ -321,31 +321,76 @@ if HAS_PT:
                     display_meta    = meta_str,
                 )
 
+        def _mention_index(self):
+            if getattr(self, "_mentions", None) is None:
+                from aria_code.ui.mentions import MentionIndex
+
+                self._mentions = MentionIndex(self.workspace, output_root=self.output_root, symbols=self.symbols)
+            return self._mentions
+
+        def _kind_label(self, name: str) -> str:
+            for kind in REFERENCE_KINDS:
+                if kind.name == name:
+                    return kind.label_zh if self.lang == "zh" else kind.label_en
+            return name
+
+        def _kind_shortcuts(self, frag: str) -> Iterator[Completion]:
+            lowered = frag.lower()
+            for kind in REFERENCE_KINDS:
+                if kind.name.startswith(lowered):
+                    yield Completion(
+                        f"{kind.name}:",
+                        start_position=-len(frag),
+                        display=FormattedText([("class:fz-hi", f"@{kind.name}"), ("class:fz-cat", ":")]),
+                        display_meta=(f"只看{self._kind_label(kind.name)}" if self.lang == "zh"
+                                      else f"{self._kind_label(kind.name)} only"),
+                    )
+
+        def _mention_completions(self, mentions, replace: int) -> Iterator[Completion]:
+            for mention in mentions:
+                hits = set(mention.matched)
+                parts = [("class:fz-hi" if i in hits else "", ch) for i, ch in enumerate(mention.label)]
+                yield Completion(
+                    mention.insert_text,
+                    start_position=-replace,
+                    display=FormattedText(parts),
+                    display_meta=self._kind_label(mention.kind),
+                )
+
         def _reference_completions(self, frag: str) -> Iterator[Completion]:
-            """Complete typed reference namespaces and their values."""
+            """Complete "@" references: results across every kind first.
+
+            "@" used to open on the kinds (file:, asset: …) and list files only
+            after a path character, so attaching a file took three steps. A
+            bare "@" now shows recently changed files, "@fx" searches files,
+            folders, assets and saved resources together, and "@file:" or
+            another kind prefix narrows to that kind.
+            """
             if ":" not in frag:
-                lowered = frag.lower()
-                for kind in REFERENCE_KINDS:
-                    if kind.name.startswith(lowered):
-                        label = kind.label_zh if self.lang == "zh" else kind.label_en
-                        yield Completion(
-                            f"{kind.name}:",
-                            start_position=-len(frag),
-                            display=FormattedText([
-                                ("class:fz-hi", f"@{kind.name}"),
-                                ("class:fz-cat", ":"),
-                            ]),
-                            display_meta=label,
-                        )
-                # Keep the first-level @ menu semantic and compact. Plain-path
-                # completion remains available only after an explicit path
-                # prefix; normal discovery goes through @file:/@folder:.
+                # Browsing by path ("@src/", "@./", "@~/") works as before.
                 if frag and (frag.startswith((".", "/", "~")) or "/" in frag):
                     yield from self._file_completions(frag)
+                    return
+                index = self._mention_index()
+                if not frag:
+                    from aria_code.ui.mentions import Mention
+
+                    recent = [Mention("file", path, 0) for path in index.recent_files()]
+                    yield from self._mention_completions(recent, 0)
+                    yield from self._kind_shortcuts("")
+                    return
+                if len(frag) >= 2:
+                    yield from self._kind_shortcuts(frag)
+                yield from self._mention_completions(index.search(frag), len(frag))
                 return
 
             kind, value_frag = frag.split(":", 1)
             kind = kind.lower()
+            path_like = value_frag.startswith((".", "/", "~")) or "/" in value_frag
+            if kind in {"file", "folder"} and value_frag and not path_like:
+                found = self._mention_index().search(value_frag, kind=kind)
+                yield from self._mention_completions(found, len(frag))
+                return
             if kind == "asset":
                 for symbol in self.symbols:
                     if symbol.lower().startswith(value_frag.lower()):