aria-code 0.94.0__tar.gz → 0.96.0__tar.gz

{aria_code-0.94.0/src/aria_code.egg-info → aria_code-0.96.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.94.0
+Version: 0.96.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.94.0 → aria_code-0.96.0}/pyproject.toml

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

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

{aria_code-0.94.0 → aria_code-0.96.0}/src/aria_code/apps/cli/commands/core_cmds.py

@@ -287,6 +287,7 @@ class CoreCommandsMixin:
             print("\n" + T(f"更多：/help {topics} · all · <命令>", f"More: /help {topics} · all · <command>"))
             return
 
+        from rich.cells import cell_len, set_cell_size
         from rich.text import Text
 
         console = self.context.console
@@ -301,8 +302,14 @@ class CoreCommandsMixin:
         # indent 2, name, gap 2, description, gap 3, name, gap 2, description
         desc_width = max(12, (console.width - 2 - 2 * name_width - 2 - 3 - 2) // 2)
 
+        # Widths in terminal cells, not characters: a Chinese character takes
+        # two. Counted as one, the Chinese /help padded each left description
+        # to twice its room and the right column wrapped back to column 0.
         def cell(text: str) -> str:
-            return text if len(text) <= desc_width else text[:desc_width - 1] + "…"
+            return text if cell_len(text) <= desc_width else set_cell_size(text, desc_width - 1) + "…"
+
+        def pad(text: str, width: int) -> str:
+            return text + " " * max(0, width - cell_len(text))
 
         two_columns = console.width >= 96
         if not two_columns:
@@ -317,7 +324,7 @@ class CoreCommandsMixin:
             lines = Text()
             for left, right in pairs:
                 lines.append("  " + left[0].ljust(name_width + 2), style="bold #C08050")
-                lines.append(cell(left[1]).ljust(desc_width + 3) if right[0] else cell(left[1]), style="dim")
+                lines.append(pad(cell(left[1]), desc_width + 3) if right[0] else cell(left[1]), style="dim")
                 if right[0]:
                     lines.append(right[0].ljust(name_width + 2), style="bold #C08050")
                     lines.append(cell(right[1]), style="dim")

{aria_code-0.94.0 → aria_code-0.96.0}/src/aria_code/apps/cli/commands/data_cmds.py

@@ -339,23 +339,60 @@ class DataCommandsMixin:
             with self.context.console.status(f"[dim]{ui_text(self, f'获取 {symbol} 同行数据', f'Fetching {symbol} peer data')}...[/dim]", spinner="dots"):
                 from local_finance_tools import _peer_comparison
                 r = await loop.run_in_executor(None, _peer_comparison,
-                                               {"symbol": symbol, "peers": peers})
+                                               {"symbol": symbol, "peers": peers, "lang": ui_text(self, "zh", "en")})
         else:
             from local_finance_tools import _peer_comparison
-            r = _peer_comparison({"symbol": symbol, "peers": peers})
+            r = _peer_comparison({"symbol": symbol, "peers": peers, "lang": ui_text(self, "zh", "en")})
 
         _render_peer_comparison(r)
 
     async def cmd_compare(self, args: str):
-        """多策略横向对比 → /api/v1/backtest/compare-strategies"""
-        parts = args.split() if args else ["SPY"]
-        symbol = parts[0].upper() if parts else "SPY"
-        start = parts[1] if len(parts) > 1 else "2020-01-01"
-        end = parts[2] if len(parts) > 2 else __import__("datetime").date.today().isoformat()
+        """/compare SYMBOL [start] [end] — several strategies on one symbol, against buy-and-hold.
+
+        /compare AAPL MSFT read MSFT as the start date, and the local fallback
+        ran four of its five strategies as buy-and-hold (the local engine had
+        no such names and fell through to it), so the table showed four
+        identical rows. Its "start → end" title was the dates asked for, not
+        the ones used, and the Buy & Hold row was a total return in the
+        annual-return column with a made-up trade count.
+        """
+        import re as _re
+
+        parts = args.split() if args and args.strip() else ["SPY"]
+        symbol = parts[0].upper()
+        rest = parts[1:]
+        def is_date(token: str) -> bool:
+            # A real date: 2024-13-01 has the shape and reached yfinance, whose
+            # failure was then explained as rate limiting.
+            try:
+                __import__("datetime").date.fromisoformat(token)
+                return len(token) == 10
+            except ValueError:
+                return False
+        if rest and not is_date(rest[0]):
+            # A symbol has a letter (AAPL, 0700.HK) or is a six-digit A-share code.
+            if all(_re.fullmatch(r"(?=.*[A-Za-z])[A-Za-z0-9.^=-]{1,12}|\d{6}", t) for t in rest):
+                # Two or more symbols: the user is comparing stocks, which is /peer.
+                peers = " ".join(t.upper() for t in rest)
+                note = f"→ /peer {symbol} {peers}"
+                self.context.console.print(f"  [dim]{note}[/dim]") if self.context.has_rich else print(f"  {note}")
+                await self.cmd_peer(f"{symbol} {peers}")
+                return
+            print_error(self.context, ui_text(self, f"无法识别的日期：{rest[0]}", f"Not a date: {rest[0]}"),
+                        "Usage: /compare SYMBOL [YYYY-MM-DD] [YYYY-MM-DD]")
+            return
+        if len(rest) > 1 and not is_date(rest[1]):
+            print_error(self.context, ui_text(self, f"无法识别的日期：{rest[1]}", f"Not a date: {rest[1]}"),
+                        "Usage: /compare SYMBOL [YYYY-MM-DD] [YYYY-MM-DD]")
+            return
+        start = rest[0] if rest else "2020-01-01"
+        end = rest[1] if len(rest) > 1 else __import__("datetime").date.today().isoformat()
         api_url = self.terminal.config.get("api_url", "http://localhost:8000")
         import aiohttp
 
         _STRATS = ["momentum", "mean_reversion", "breakout", "turtle", "ma_crossover"]
+        # What the local engine can run, under the names /compare shows.
+        _LOCAL = {"momentum": "momentum", "mean_reversion": "rsi_mean_revert", "ma_crossover": "sma_cross"}
 
         async def _do():
             payload = {"symbol": symbol, "strategies": _STRATS,
@@ -367,76 +404,90 @@ class DataCommandsMixin:
                     body = await resp.json()
                     return body.get("data", body)
 
+        def _row(name: str, d: dict) -> dict:
+            ann = float(d.get("annual_return", 0) or 0)
+            mdd = float(d.get("max_drawdown", 0) or 0)
+            return {
+                "name": name,
+                "annualized_return_pct": ann * 100,
+                "sharpe_ratio": float(d.get("sharpe_ratio", 0) or 0),
+                "max_drawdown_pct": mdd * 100,
+                "calmar_ratio": (ann / abs(mdd)) if mdd else 0.0,
+                "sortino_ratio": float(d.get("sortino_ratio", 0) or 0),
+                "win_rate_pct": float(d.get("win_rate", 0) or 0) * 100,
+                "n_trades": int(d.get("total_trades", 0) or 0),
+            }
+
         def _do_local():
-            """Fallback: run each strategy via the local backtest engine and
-            assemble the same shape the backend endpoint returns. Used when the
-            backend is down or lacks the compare-strategies endpoint."""
-            import asyncio as _aio
-            rows = []
-            bench_pct = 0.0
-            for strat in _STRATS:
+            """The strategies the local engine has, over the same dates, and
+            buy-and-hold run through the same engine as the benchmark."""
+            run = _get_LOCAL_TOOLS()["backtest_strategy"][0]
+            rows, period, errors = [], None, []
+            for shown, local in _LOCAL.items():
                 try:
-                    res = _get_LOCAL_TOOLS()["backtest_strategy"][0](
-                        {"symbol": symbol, "strategy": strat})
-                except Exception:
+                    res = run({"symbol": symbol, "strategy": local, "start": start, "end": end})
+                except Exception as exc:
+                    errors.append(f"{shown}: {exc}")
                     continue
                 if not res.get("success"):
+                    errors.append(f"{shown}: {res.get('error', 'failed')}")
                     continue
                 d = res.get("data", res)
-                ann = float(d.get("annual_return", 0) or 0)
-                mdd = float(d.get("max_drawdown", 0) or 0)
-                calmar = (ann / abs(mdd)) if mdd else 0.0
-                rows.append({
-                    "name": strat,
-                    "annualized_return_pct": ann * 100,
-                    "sharpe_ratio": float(d.get("sharpe_ratio", 0) or 0),
-                    "max_drawdown_pct": mdd * 100,
-                    "calmar_ratio": calmar,
-                    "sortino_ratio": float(d.get("sortino_ratio", 0) or 0),
-                    "win_rate_pct": float(d.get("win_rate", 0) or 0) * 100,
-                    "n_trades": int(d.get("total_trades", 0) or 0),
-                })
-                br = d.get("benchmark_return")
-                if br is not None and br == br:  # not NaN
-                    bench_pct = float(br) * 100
+                period = period or (d.get("start"), d.get("end"))
+                rows.append(_row(shown, d))
             rows.sort(key=lambda r: r["sharpe_ratio"], reverse=True)
             for i, r in enumerate(rows, 1):
                 r["rank_by_sharpe"] = i
-            return {"strategies": rows, "benchmark": {"annualized_return_pct": bench_pct},
-                    "provider": "local"}
+            bench = {}
+            try:
+                b = run({"symbol": symbol, "strategy": "buy_hold", "start": start, "end": end})
+                if b.get("success"):
+                    bench = _row("buy_hold", b.get("data", b))
+            except Exception:
+                pass
+            return {"strategies": rows, "benchmark": bench, "provider": "local", "period": period,
+                    "skipped": [s for s in _STRATS if s not in _LOCAL], "errors": errors}
 
         async def _do_with_fallback():
             try:
                 return await _do()
             except Exception:
                 # Backend unavailable / missing endpoint → local engine
+                note = ui_text(self, "后端不可用，使用本地回测引擎对比…",
+                               "Backend unavailable; comparing with the local backtest engine…")
                 if self.context.has_rich:
-                    self.context.console.print("  [dim]后端不可用，使用本地回测引擎对比…[/dim]")
-                return _do_local()
+                    self.context.console.print(f"  [dim]{note}[/dim]")
+                import asyncio as _aio
+                return await _aio.get_event_loop().run_in_executor(None, _do_local)
 
+        status = ui_text(self, f"正在对比 {symbol} 的策略", f"Comparing strategies on {symbol}")
         if self.context.has_rich:
-            with self.context.console.status(f"[dim]Comparing strategies on {symbol}...[/dim]", spinner="dots"):
+            with self.context.console.status(f"[dim]{status}...[/dim]", spinner="dots"):
                 try:
                     data = await _do_with_fallback()
                 except Exception as e:
                     print_error(self.context, str(e), "tool")
                     return
         else:
-            print(f"Comparing strategies on {symbol}...")
+            print(f"{status}...")
             try:
                 data = await _do_with_fallback()
             except Exception as e:
                 print_error(self.context, str(e), "tool")
                 return
         if not data.get("strategies"):
-            print_error(self.context, "策略对比无结果", "本地回测引擎未返回数据，检查标的代码是否正确")
+            detail = "; ".join(data.get("errors") or []) or ui_text(
+                self, "检查标的代码和日期是否正确", "check the symbol and the dates")
+            print_error(self.context, ui_text(self, "策略对比无结果", "No strategy results"), detail)
             return
 
         strategies = data.get("strategies", [])
-        bh = data.get("benchmark", {})
+        bh = data.get("benchmark", {}) or {}
+        period = data.get("period") or (start, end)
         if self.context.has_rich:
             from rich.table import Table
-            tbl = Table(title=f"[bold]{symbol} Strategy Comparison[/bold]  {start} → {end}", show_header=True, header_style="bold")
+            tbl = Table(title=f"[bold]{symbol} Strategy Comparison[/bold]  {period[0]} → {period[1]}",
+                        show_header=True, header_style="bold")
             for col in ["Rank", "Strategy", "Ann.Ret%", "Sharpe", "MaxDD%", "Calmar", "Sortino", "Win%", "Trades"]:
                 tbl.add_column(col, justify="right")
             for s in strategies:
@@ -451,11 +502,20 @@ class DataCommandsMixin:
                     f"{s.get('win_rate_pct',0):.0f}%",
                     str(s.get("n_trades",0)),
                 )
-            tbl.add_row("—", "[dim]Buy & Hold[/dim]",
-                        f"{bh.get('annualized_return_pct',0):+.1f}%",
-                        f"{bh.get('sharpe_ratio',0):.3f}",
-                        f"{bh.get('max_drawdown_pct',0):.1f}%", "—", "—", "—", "2")
+            if bh:
+                tbl.add_row("—", "[dim]Buy & Hold[/dim]",
+                            f"{bh.get('annualized_return_pct',0):+.1f}%",
+                            f"{bh.get('sharpe_ratio',0):.3f}",
+                            f"{bh.get('max_drawdown_pct',0):.1f}%",
+                            f"{bh['calmar_ratio']:.2f}" if "calmar_ratio" in bh else "—",
+                            f"{bh['sortino_ratio']:.2f}" if "sortino_ratio" in bh else "—",
+                            "—", str(bh["n_trades"]) if "n_trades" in bh else "—")
             self.context.console.print(tbl)
+            if data.get("skipped"):
+                self.context.console.print("  [dim]" + ui_text(
+                    self, f"本地引擎没有 {', '.join(data['skipped'])}，需后端才能对比。",
+                    f"{', '.join(data['skipped'])} need the backend; the local engine does not have them.")
+                    + "[/dim]")
         else:
             for s in strategies:
                 print(f"{s['name']}: Ann={s.get('annualized_return_pct',0):+.1f}% Sharpe={s.get('sharpe_ratio',0):.2f} DD={s.get('max_drawdown_pct',0):.1f}%")

{aria_code-0.94.0 → aria_code-0.96.0}/src/aria_code/apps/cli/commands/portfolio_cmds.py

@@ -758,10 +758,12 @@ class PortfolioCommandsMixin:
                 # NEEDS_ATTENTION (signal SELL) came out as HIGH_RISK.
                 _port_verdict = str((result.data_used or {}).get("verdict") or "NEEDS_ATTENTION")
                 if self.context.has_rich:
-                    self.context.console.print()
+                    # The header already ends in a blank line, and the banner's
+                    # panel opens with one: two blank lines each side before.
+                    if tokens:
+                        self.context.console.print()
                     for pt in (result.key_points or []):
                         self.context.console.print(f"  [dim]• {pt}[/dim]")
-                    self.context.console.print()
                     _subtitle = " · ".join(result.key_points[:2]) if result.key_points else ""
                     _print_verdict_banner(_port_verdict, subtitle=_subtitle,
                                           confidence=result.confidence, lang=_lang)

{aria_code-0.94.0 → aria_code-0.96.0}/src/aria_code/apps/cli/handlers/chart_handlers.py

@@ -672,7 +672,12 @@ def handle_stock_chart_analysis_direct(symbol: str, period: str = "1y") -> dict:
     pe         = info.get("trailingPE")
     pb         = info.get("priceToBook")
     roe        = info.get("returnOnEquity")
-    div_yield  = info.get("trailingAnnualDividendYield") or info.get("dividendYield")
+    # A fraction, as _fv(div_yield, 100, pct=True) below expects. The fallback
+    # was dividendYield, which yfinance gives already in percent: 100x too big.
+    trailing   = info.get("trailingAnnualDividendYield")
+    rate       = info.get("dividendRate")
+    price_now  = info.get("regularMarketPrice") or info.get("currentPrice")
+    div_yield  = trailing or (float(rate) / float(price_now) if rate and price_now else None)
     market_cap = info.get("marketCap")
 
     def _fv(v, mult=1.0, pct=False):

aria_code-0.96.0/src/aria_code/apps/cli/headless.py

@@ -0,0 +1,288 @@
+"""Non-interactive Aria: `aria-code -p "…"` and `--watch`.
+
+Moved out of aria_cli.py, where ArtheraTerminal held it alongside the REPL.
+The bodies are unchanged and still use aria_cli's names (console, LOCAL_TOOLS,
+_run_deterministic_chain, …): aria_cli binds a copy of this class to its own
+globals with bind_to() and puts it among ArtheraTerminal's bases. A copy per
+binding, because aria_cli loads under two names (aria_cli and
+aria_code.aria_cli); rebinding one shared class would leave both terminals
+on whichever module loaded last.
+"""
+
+from __future__ import annotations
+
+import types
+
+
+class HeadlessMixin:
+    """run_prompt, _run_prompt_turn, _finish_prompt and run_watch for ArtheraTerminal."""
+
+    async def run_prompt(self, prompt: str, json_output: bool = False,
+                         fmt: str = "table", output_file: str = None, quiet: bool = False,
+                         machine_out=None):
+        """Run a single prompt (non-interactive / pipe mode).
+
+        ``machine_out`` is the real stdout when the output is JSON (sys.stdout
+        then points at stderr). With fmt "jsonl" each step is written there as
+        one JSON event per line as it happens.
+        """
+        from aria_code.apps.cli.exec_events import ExecEvents, json_safe
+        events = ExecEvents(machine_out if fmt == "jsonl" else None)
+        events.emit("turn.started", prompt=prompt, model=self.config.get("model", ""))
+        result = await self._run_prompt_turn(prompt, quiet=quiet, events=events)
+        self._finish_prompt(result, json_output=json_output, fmt=fmt, output_file=output_file,
+                            quiet=quiet, machine_out=machine_out, events=events)
+
+    async def _run_prompt_turn(self, prompt: str, *, quiet: bool, events) -> dict:
+        """The work of run_prompt: a slash command, a deterministic answer, or an agent turn."""
+        model = self.config.get("model", "qwen2.5:7b")
+        thinking_mode = self.config.get("thinking_mode", "auto")
+        auth_token = self.config.get("auth_token")
+        user_context = _build_user_context(self.config)
+
+        local_mode = self.config.get("local_mode", False)
+
+        # Dispatch slash commands in -p mode (same as interactive REPL loop).
+        # Without this, /memory /note /init /review are sent to the LLM as plain text.
+        _stripped_prompt = prompt.strip()
+        if self.commands.is_command(_stripped_prompt):
+            self._maybe_show_intent_preflight(_stripped_prompt, quiet=quiet)
+            await self.commands.execute(_stripped_prompt)
+            return {"success": True, "command": _stripped_prompt.split()[0], "response": ""}
+
+        _reference_context = ""
+        _reference_service = getattr(self, "_reference_service", None)
+        if _reference_service is not None and "@" in prompt:
+            _prepared_references = _reference_service.prepare(prompt)
+            if _prepared_references.errors:
+                self._print_reference_errors(_prepared_references)
+                return {"success": False, "response": "", "error": "unresolved @ reference"}
+            if _prepared_references.references:
+                self._print_reference_summary(_prepared_references)
+                prompt = _prepared_references.expanded_text
+                _reference_context = _prepared_references.context_block
+
+        # Keep referenced local files as pointers; the model reads them through
+        # audited tools instead of silently embedding their contents.
+        if _reference_context:
+            prompt = f"{prompt}\n\n{_reference_context}"
+        else:
+            _file_tool_hint = _build_file_tool_hint(prompt)
+            if _file_tool_hint:
+                prompt = _file_tool_hint + prompt
+        self._maybe_show_intent_preflight(prompt, quiet=quiet)
+
+        _curr_model_id_p = self.config.get("model", "")
+        # The route counts as much as the model: on backend_chat the model gets
+        # no local tools whatever it could do with them. This only looked at the
+        # model, so the deterministic chain skipped its data pre-fetch there.
+        from aria_code.apps.cli.workspace_route import no_tools_message, needs_workspace, route_has_tools
+        _model_has_tools_p = route_has_tools(_curr_model_id_p, self.config, self.api_url)
+
+        # ── Broker guide intent: broad discovery should not start an add wizard ──
+        if _is_broker_guide_intent(prompt):
+            if HAS_RICH:
+                console.print("\n[bold]Aria[/bold]  [dim]  正在打开券商与服务指南…[/dim]\n")
+            await self.commands.cmd_broker("guide")
+            await self.commands.cmd_broker("services")
+            await self.commands.cmd_packages("services")
+            return {"success": True, "command": "/broker guide", "response": ""}
+
+        # ── Broker setup intent: intercept before LLM / deterministic routing ──
+        if _is_broker_setup_intent(prompt):
+            _btype_p = _detect_broker_type(prompt)
+            if HAS_RICH:
+                from apps.cli.utils.market_detect import _BROKER_SETUP_NAMES
+                _display_p = _BROKER_SETUP_NAMES.get(_btype_p, ("",))[0] if _btype_p else ""
+                _label_p = f"  正在启动{_display_p}配置向导…" if _display_p else "  正在启动券商配置向导…"
+                console.print(f"\n[bold]Aria[/bold]  [dim]{_label_p}[/dim]\n")
+            await self.commands._cmd_broker_add(_btype_p)
+            return {"success": True, "command": "/broker add", "response": ""}
+
+        # ── Football prediction intercept → built-in Poisson handler ──────────
+        if await self._try_football_nl_intercept(prompt):
+            return {"success": True, "command": "football", "response": ""}
+
+        deterministic = _run_deterministic_chain(
+            prompt, model_has_tools=_model_has_tools_p)
+        if deterministic.get("success") or _is_stock_chart_analysis_request(prompt):
+            result = deterministic
+        else:
+            # No one reads a headless answer before a script acts on it. A task
+            # about this folder on a model that cannot open it would come back as
+            # a confident guess with exit 0; fail before sending it instead.
+            if not _model_has_tools_p and needs_workspace(prompt):
+                _zh = str(self.config.get("ui_lang", "en")).lower().startswith("zh")
+                _why = no_tools_message(self.config, lang="zh" if _zh else "en")
+                print(_why, file=sys.stderr)
+                return {"success": False, "response": "", "error": "model_cannot_use_tools", "detail": _why}
+            # Spinner for terminal usage: gives visual feedback while the model generates.
+            # Only starts when we actually need to call the LLM (not for deterministic responses).
+            _prompt_spinner = None
+            if HAS_RICH and sys.stdout.isatty():
+                try:
+                    _prompt_spinner = console.status("", spinner="dots", spinner_style="dim")
+                    _prompt_spinner.__enter__()
+                except Exception:
+                    _prompt_spinner = None
+            try:
+                # Headless -p runs the SAME loop as the REPL.
+                #
+                # It used to call stream_provider_result directly: one provider
+                # round, tool schemas advertised but nothing executing what came
+                # back, and a single best-effort pass over tool_calls_pending
+                # afterwards whose results the model never saw. So `-p` was not
+                # agentic at all — no rounds, no tool results fed back, no loop
+                # guard, no acceptance gate. Every non-interactive user (CI, a
+                # pipe, the eval harness) got a chat reply where the REPL would
+                # have done the work.
+                #
+                # run_chat_via_runtime is the documented single entry point and
+                # already handles provider selection and cloud→Ollama fallback,
+                # which is what the two branches here were open-coding.
+                from aria_code.apps.cli.providers.runtime_bridge import run_chat_via_runtime
+
+                _turn = await run_chat_via_runtime(
+                    prompt=prompt, history=[],
+                    local_tools=LOCAL_TOOLS, tool_schemas=LOCAL_TOOL_SCHEMAS,
+                    model=model, config=self.config, api_url=self.api_url,
+                    ollama_url=self.config.get("ollama_url", "http://localhost:11434"),
+                    thinking_mode=thinking_mode, user_context=user_context,
+                    auth_token=auth_token, project_context=_PROJECT_CONTEXT,
+                    max_rounds=int(self.config.get("max_rounds", 30) or 30),
+                    # No approval UI exists in headless mode. Leaving the confirm
+                    # set populated would block every write on a prompt nobody is
+                    # there to answer; the operator opts in with
+                    # --dangerously-skip-permissions or --allow-tools.
+                    confirm_tools=(
+                        frozenset() if _auto_approve_session
+                        else frozenset(_CONFIRM_TOOLS) - _session_always_allow
+                    ),
+                    on_tool_call=events.tool_started,
+                    on_tool_result=events.tool_completed,
+                    return_result=True,
+                )
+                _tools_used = list(getattr(_turn.final, "tools", []) or [])
+                # An empty closing message after the tools already ran is not a
+                # failed turn. The model did the work and then said nothing;
+                # exiting 1 there told a script the task failed while the edit
+                # sat finished on disk. Narrow on purpose — any other error,
+                # and a turn that ran no tools at all, still fails.
+                _empty_after_work = (
+                    _turn.error == "empty_response" and bool(_tools_used)
+                )
+                result = {
+                    "success": _turn.ok or _empty_after_work,
+                    "response": (
+                        _turn.text
+                        or (f"（模型未给出收尾说明。已执行的工具：{', '.join(_tools_used)}）"
+                            if _empty_after_work else "")
+                    ),
+                    "error": "" if _empty_after_work else (_turn.error or ""),
+                    "provider": getattr(_turn.final, "provider", ""),
+                    "tools_used": _tools_used,
+                    "acceptance": getattr(_turn.final, "acceptance", None),
+                }
+            finally:
+                if _prompt_spinner is not None:
+                    try:
+                        _prompt_spinner.__exit__(None, None, None)
+                    except Exception:
+                        pass
+
+        return result
+
+    def _finish_prompt(self, result: dict, *, json_output: bool, fmt: str, output_file,
+                       quiet: bool, machine_out, events) -> None:
+        """Print or save run_prompt's result, and exit 1 if it failed."""
+        from aria_code.apps.cli.exec_events import json_safe
+        result = result or {"success": False, "response": "", "error": "no result"}
+        # The agent loop executes tools now, so there is nothing left over to
+        # run here — only stream_provider_result ever populated
+        # tool_calls_pending, and the deterministic chain never does. Keeping
+        # the old pass would risk running a write twice.
+        #
+        # What is worth surfacing instead is the acceptance verdict: in headless
+        # mode nobody watched the run, so a turn that changed files and failed
+        # its checks must say so on stderr rather than print a confident summary
+        # and exit 0.
+        _acceptance = (result or {}).get("acceptance") or {}
+        if _acceptance.get("verified") is False and not quiet:
+            _zh = str(self.config.get("ui_lang", "en")).lower().startswith("zh")
+            print(f"⚠ {'验收未通过' if _zh else 'Checks failed'}: {_acceptance.get('headline', '')}",
+                  file=sys.stderr)
+
+        events.emit("turn.completed", **json_safe(result))
+        out = machine_out or sys.stdout
+        if fmt == "jsonl":
+            content = None              # the events were the output
+        elif json_output or fmt == "json":
+            content = json.dumps(json_safe(result), ensure_ascii=False, indent=2)
+        elif fmt == "csv":
+            content = f"role,content\nassistant,\"{result.get('response', '').replace(chr(34), chr(34)+chr(34))}\""
+        elif fmt == "md":
+            content = f"# Aria Code AI Response\n\n{result.get('response', '')}\n"
+        else:
+            content = result.get("response", "") if result.get("success") else f"Error: {result.get('error', 'Unknown')}"
+
+        # Output routing
+        if content is None or (fmt == "table" and not json_output and result.get("command") and not content):
+            pass                        # jsonl, or a command that printed its own output
+        elif output_file:
+            with open(output_file, "w") as f:
+                f.write(content)
+            if not quiet:
+                console.print(f"[green]Saved to {output_file}[/green]" if HAS_RICH
+                              else f"Saved: {output_file}")
+        elif not result.get("success") and fmt == "table" and not json_output:
+            print(f"Error: {result.get('error', 'Unknown')}", file=sys.stderr)
+        # In default (table) format: render with Rich Markdown when output is
+        # a terminal.  This gives properly formatted headings, bold, and tables
+        # in interactive use.  When piped/redirected, fall back to plain text
+        # for scripting compatibility.
+        elif HAS_RICH and fmt == "table" and not json_output and sys.stdout.isatty() and result.get("success"):
+            console.print(make_markdown(_strip_latex(content)))
+        else:
+            print(content, file=out, flush=True)
+        # A failed turn exits 1 in every format. Only table did; with --json a
+        # script got exit 0 and had to read the body to learn it had failed.
+        if not result.get("success"):
+            sys.exit(1)
+
+    async def run_watch(self, command_fn, interval: int, cmd_args: str):
+        """Run a command repeatedly with interval (like Unix watch)."""
+        try:
+            while True:
+                if not self.config.get("_quiet"):
+                    os.system("clear" if os.name == "posix" else "cls")
+                    ts = datetime.now().strftime("%H:%M:%S")
+                    if HAS_RICH:
+                        console.print(f"[dim]Every {interval}s | {ts} | Ctrl+C to stop[/dim]\n")
+                    else:
+                        print(f"Every {interval}s | {ts} | Ctrl+C to stop\n")
+
+                await command_fn(cmd_args)
+
+                await asyncio.sleep(interval)
+        except (KeyboardInterrupt, asyncio.CancelledError):
+            if HAS_RICH:
+                console.print("\n[dim]Watch stopped[/dim]")
+            else:
+                print("\nStopped")
+
+
+def bind_to(namespace: dict) -> type:
+    """A copy of HeadlessMixin whose methods resolve bare names in ``namespace``."""
+    methods = {}
+    for name, attr in vars(HeadlessMixin).items():
+        if isinstance(attr, types.FunctionType):
+            bound = types.FunctionType(attr.__code__, namespace, attr.__name__,
+                                       attr.__defaults__, attr.__closure__)
+            bound.__kwdefaults__ = attr.__kwdefaults__
+            bound.__doc__ = attr.__doc__
+            bound.__qualname__ = f"ArtheraTerminal.{attr.__name__}"
+            methods[name] = bound
+    return type("HeadlessMixin", (), {"__doc__": HeadlessMixin.__doc__, "__module__": __name__, **methods})
+
+
+__all__ = ["HeadlessMixin", "bind_to"]