aria-code 0.52.0__py3-none-any.whl

aria_code/agents/deep/quant_fusion.py

@@ -0,0 +1,192 @@
+"""P2 — fuse quantitative ground truth and calibrate confidence.
+
+The qualitative team votes a signal with a self-reported confidence. That number
+is uncalibrated — an agent saying "80%" doesn't mean it's right 80% of the time.
+This layer:
+
+  1. gathers quant signals (AI signal, risk metrics, backtest) as ground truth,
+  2. nudges confidence by whether quant *agrees* with the qualitative verdict,
+  3. scales by a *reliability* factor learned from realised outcomes (CalibrationStore),
+
+so confidence drifts toward the historical hit-rate as outcomes accumulate.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+from typing import Callable, Dict, Optional, Tuple
+
+from .models import QuantEvidence, Provenance
+
+_BULL = ("STRONG_BUY", "BUY")
+_BEAR = ("STRONG_SELL", "SELL")
+
+
+# ── gather quant evidence ─────────────────────────────────────────────────────
+def _default_provider(symbol: str) -> Dict[str, Dict]:
+    """Best-effort pull of quant signals from local_finance_tools (each optional)."""
+    out: Dict[str, Dict] = {}
+    try:
+        import local_finance_tools as lft
+    except Exception:
+        return out
+    for key, fn in (("ai", "_get_ai_signal"), ("risk", "_get_risk_metrics"),
+                    ("backtest", "_backtest_strategy"), ("factors", "_calculate_factors")):
+        f = getattr(lft, fn, None)
+        if not f:
+            continue
+        try:
+            res = f({"symbol": symbol})
+            if isinstance(res, dict) and res.get("success"):
+                out[key] = res
+        except Exception:
+            pass
+    return out
+
+
+def _num(d: Dict, *keys) -> Optional[float]:
+    for k in keys:
+        v = d.get(k)
+        if isinstance(v, (int, float)):
+            return float(v)
+    return None
+
+
+def gather_quant_evidence(
+    symbol: str,
+    provider: Optional[Callable[[str], Dict[str, Dict]]] = None,
+) -> Tuple[QuantEvidence, list]:
+    """Return (QuantEvidence, [Provenance]). Never raises."""
+    raw = {}
+    try:
+        raw = (provider or _default_provider)(symbol)
+    except Exception:
+        raw = {}
+
+    prov: list = []
+    ev = QuantEvidence()
+    if not raw:
+        ev.note = "no quant backend available"
+        return ev, prov
+
+    ai = raw.get("ai") or {}
+    if ai:
+        action = str(ai.get("action") or ai.get("signal") or "").upper()
+        ev.ai_signal = action or None
+        conf = _num(ai, "confidence") or 0.0
+        if action in _BULL:
+            ev.ai_score = conf
+        elif action in _BEAR:
+            ev.ai_score = -conf
+        else:
+            ev.ai_score = 0.0
+        prov.append(Provenance("ai_signal", str(ai.get("provider", "quant")), note=action))
+
+    risk = raw.get("risk") or {}
+    if risk:
+        ev.sharpe = _num(risk, "sharpe", "sharpe_ratio")
+        ev.max_drawdown = _num(risk, "max_drawdown", "max_dd")
+        prov.append(Provenance("risk_metrics", "local_finance", note="VaR/Sharpe"))
+
+    bt = raw.get("backtest") or {}
+    if bt:
+        ev.backtest_return = _num(bt, "total_return", "return", "cagr")
+        if ev.sharpe is None:
+            ev.sharpe = _num(bt, "sharpe", "sharpe_ratio")
+        if ev.max_drawdown is None:
+            ev.max_drawdown = _num(bt, "max_drawdown", "max_dd")
+        prov.append(Provenance("backtest", "local_finance", note=str(bt.get("strategy", ""))))
+
+    fac = raw.get("factors") or {}
+    if fac:
+        ev.ic = _num(fac, "ic", "information_coefficient")
+        ev.factors = {k: v for k, v in fac.items()
+                      if k not in ("success", "symbol") and isinstance(v, (int, float))}
+        prov.append(Provenance("factors", "local_finance"))
+
+    ev.available = bool(ai or risk or bt or fac)
+    return ev, prov
+
+
+# ── confidence calibration ────────────────────────────────────────────────────
+def _bucket(conf: float) -> str:
+    if conf < 0.4:
+        return "lo"
+    if conf < 0.7:
+        return "mid"
+    return "hi"
+
+
+def _side(signal: str) -> str:
+    if signal in _BULL:
+        return "bull"
+    if signal in _BEAR:
+        return "bear"
+    return "neutral"
+
+
+def agreement(agent_signal: str, quant_verdict: str) -> str:
+    a = _side(agent_signal)
+    q = {"BULLISH": "bull", "BEARISH": "bear", "NEUTRAL": "neutral"}.get(quant_verdict, "neutral")
+    if a == "neutral" or q == "neutral":
+        return "neutral"
+    return "agree" if a == q else "disagree"
+
+
+class CalibrationStore:
+    """Tracks realised hit-rate per (signal-side, confidence-bucket) on disk.
+
+    ``reliability(conf, signal)`` returns observed_hit_rate / nominal_confidence,
+    clamped to a sane band, so a chronically over-confident bucket gets damped and
+    an under-confident one gets a small boost. With no history it returns 1.0.
+    """
+
+    _NOMINAL = {"lo": 0.30, "mid": 0.55, "hi": 0.80}
+
+    def __init__(self, path: Optional[Path] = None):
+        self.path = Path(path or os.path.expanduser("~/.arthera/deep_calibration.json"))
+        self._data: Dict[str, Dict[str, int]] = {}
+        try:
+            if self.path.exists():
+                self._data = json.loads(self.path.read_text())
+        except Exception:
+            self._data = {}
+
+    def _key(self, side: str, bucket: str) -> str:
+        return f"{side}:{bucket}"
+
+    def reliability(self, conf: float, signal: str = "") -> float:
+        rec = self._data.get(self._key(_side(signal), _bucket(conf)))
+        if not rec or rec.get("n", 0) < 8:
+            return 1.0
+        hit = rec["hit"] / rec["n"]
+        nominal = self._NOMINAL[_bucket(conf)] or 1.0
+        return max(0.6, min(1.25, hit / nominal))
+
+    def record_outcome(self, signal: str, conf: float, correct: bool) -> None:
+        k = self._key(_side(signal), _bucket(conf))
+        rec = self._data.setdefault(k, {"n": 0, "hit": 0})
+        rec["n"] += 1
+        rec["hit"] += 1 if correct else 0
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.path.write_text(json.dumps(self._data, indent=2))
+        except Exception:
+            pass
+
+
+def calibrate_confidence(
+    raw_conf: float,
+    agent_signal: str,
+    quant: QuantEvidence,
+    store: Optional[CalibrationStore] = None,
+) -> Tuple[float, str]:
+    """Return (calibrated_confidence, agreement_label)."""
+    agree = agreement(agent_signal, quant.verdict()) if quant and quant.available else "neutral"
+    factor = {"agree": 1.15, "neutral": 1.0, "disagree": 0.70}[agree]
+    rel = store.reliability(raw_conf, agent_signal) if store else 1.0
+    cal = max(0.0, min(1.0, raw_conf * factor * rel))
+    return cal, agree

aria_code/agents/deep/themes.py

@@ -0,0 +1,95 @@
+"""P1a — group agent results by theme and build a per-theme sub-synthesis.
+
+Flat synthesis ("here are 8 opinions, here's the average") loses structure. Real
+research clusters evidence: what does *valuation* say, what does *momentum* say,
+what does *risk* say — then reconciles across clusters. This module does the
+clustering and a deterministic per-cluster roll-up (no LLM needed).
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List, Tuple
+
+from ..base import AgentResult
+from .models import ThemeGroup
+
+# Which theme each agent belongs to. Unknown agents fall into "other".
+_AGENT_THEME = {
+    "fundamental": "valuation",
+    "earnings":    "valuation",
+    "technical":   "momentum",
+    "risk":        "risk",
+    "news":        "catalysts",
+    "catalyst":    "catalysts",
+    "macro":       "macro",
+    "sector":      "macro",
+    "northbound":  "macro",
+    "debate":      "reconciliation",
+}
+
+# Display order + human labels.
+_THEME_ORDER = ["valuation", "momentum", "macro", "catalysts", "risk",
+                "reconciliation", "other"]
+_THEME_LABEL = {
+    "valuation":      "估值/基本面",
+    "momentum":       "动量/技术",
+    "macro":          "宏观/板块",
+    "catalysts":      "催化/消息",
+    "risk":           "风险",
+    "reconciliation": "分歧调解",
+    "other":          "其他",
+}
+
+_SCORE = {"STRONG_BUY": 2, "BUY": 1, "HOLD": 0, "SELL": -1, "STRONG_SELL": -2}
+
+
+def theme_of(agent_name: str) -> str:
+    return _AGENT_THEME.get(agent_name, "other")
+
+
+def _vote(results: List[AgentResult]) -> Tuple[str, float]:
+    """Confidence-weighted majority within a single theme."""
+    valid = [r for r in results if r.success and r.signal in _SCORE]
+    if not valid:
+        return "HOLD", 0.0
+    avg_score = sum(_SCORE[r.signal] * r.confidence for r in valid) / len(valid)
+    avg_conf = sum(r.confidence for r in valid) / len(valid)
+    if avg_score >= 1.5:
+        return "STRONG_BUY", avg_conf
+    if avg_score >= 0.5:
+        return "BUY", avg_conf
+    if avg_score <= -1.5:
+        return "STRONG_SELL", avg_conf
+    if avg_score <= -0.5:
+        return "SELL", avg_conf
+    return "HOLD", avg_conf
+
+
+def group_by_theme(results: List[AgentResult]) -> List[ThemeGroup]:
+    """Cluster agent results into themes with a per-theme signal + summary."""
+    buckets: Dict[str, List[AgentResult]] = {}
+    for r in results:
+        buckets.setdefault(theme_of(r.agent), []).append(r)
+
+    groups: List[ThemeGroup] = []
+    for theme in _THEME_ORDER:
+        members = buckets.get(theme)
+        if not members:
+            continue
+        signal, conf = _vote(members)
+        points: List[str] = []
+        for r in members:
+            if r.success:
+                points.extend((r.key_points or [])[:2])
+        ok = sum(1 for r in members if r.success)
+        summary = (f"{_THEME_LABEL[theme]}: {signal}（{ok}/{len(members)} agent 有效，"
+                   f"置信度 {conf:.0%}）")
+        groups.append(ThemeGroup(
+            theme=_THEME_LABEL[theme],
+            agents=[r.agent for r in members],
+            signal=signal,
+            confidence=conf,
+            summary=summary,
+            key_points=points[:5],
+        ))
+    return groups

aria_code/agents/deep/tiers.py

@@ -0,0 +1,106 @@
+"""P3 — render the deep result at three depths, with data provenance.
+
+  brief    — one glance: signal, calibrated confidence, headline
+  standard — + per-theme roll-up + synthesis
+  deep     — + quant evidence + critique + provenance (data lineage) + agent points
+
+Pure text/markdown so it renders in the terminal; the HTML report layer can reuse
+the same DeepAnalysisResult.
+"""
+
+from __future__ import annotations
+
+from .models import DeepAnalysisResult
+
+_SIGNAL_ICON = {
+    "STRONG_BUY": "🟢🟢", "BUY": "🟢", "HOLD": "⚪",
+    "SELL": "🔴", "STRONG_SELL": "🔴🔴",
+}
+
+
+def _headline(r: DeepAnalysisResult) -> str:
+    icon = _SIGNAL_ICON.get(r.final_signal, "⚪")
+    conf = f"{r.calibrated_confidence:.0%}"
+    note = ""
+    if r.raw_confidence and abs(r.calibrated_confidence - r.raw_confidence) >= 0.05:
+        note = f"（原始 {r.raw_confidence:.0%} → 校准 {conf}）"
+    else:
+        note = f"（置信度 {conf}）"
+    return f"{icon} **{r.symbol} · {r.final_signal}** {note}"
+
+
+def render_brief(r: DeepAnalysisResult) -> str:
+    lines = [_headline(r)]
+    if r.quant and r.quant.available:
+        lines.append(f"  量化: {r.quant.verdict()}"
+                     + (f" · IC {r.quant.ic:.2f}" if r.quant.ic is not None else "")
+                     + (f" · Sharpe {r.quant.sharpe:.2f}" if r.quant.sharpe is not None else ""))
+    if r.critique and r.critique.high:
+        lines.append(f"  ⚠️ {r.critique.high[0].message}")
+    return "\n".join(lines)
+
+
+def render_standard(r: DeepAnalysisResult) -> str:
+    parts = [render_brief(r), ""]
+    if r.themes:
+        parts.append("### 分主题")
+        for t in r.themes:
+            parts.append(f"- {t.summary}")
+        parts.append("")
+    if r.synthesis:
+        parts.append("### 综合")
+        parts.append(r.synthesis)
+    return "\n".join(parts).rstrip()
+
+
+def render_deep(r: DeepAnalysisResult) -> str:
+    parts = [render_standard(r), ""]
+
+    if r.quant and r.quant.available:
+        q = r.quant
+        parts.append("### 量化地面真值")
+        row = []
+        if q.ai_signal:           row.append(f"AI信号 {q.ai_signal}")
+        if q.ai_score is not None:row.append(f"分值 {q.ai_score:+.2f}")
+        if q.ic is not None:      row.append(f"IC {q.ic:.3f}")
+        if q.sharpe is not None:  row.append(f"Sharpe {q.sharpe:.2f}")
+        if q.max_drawdown is not None: row.append(f"MaxDD {q.max_drawdown:.1%}")
+        if q.backtest_return is not None: row.append(f"回测收益 {q.backtest_return:+.1%}")
+        parts.append("- " + " · ".join(row) if row else "- (无)")
+        parts.append("")
+
+    if r.critique is not None:
+        parts.append("### 自检 (Critic)")
+        mark = "✅ 通过" if r.critique.passed else "❌ 存在高危问题"
+        parts.append(f"结论: {mark}" + ("（无问题）" if not r.critique.issues else ""))
+        for i in r.critique.issues:
+            sev = {"high": "🔴", "medium": "🟡", "low": "⚪"}.get(i.severity, "·")
+            parts.append(f"- {sev} [{i.kind}] {i.message}")
+        parts.append("")
+
+    if r.provenance:
+        parts.append("### 数据血缘")
+        parts.append("| 字段 | 来源 | 时效 | 备注 |")
+        parts.append("|------|------|------|------|")
+        for p in r.provenance:
+            parts.append(f"| {p.field} | {p.source} | {p.freshness} | {p.note} |")
+        parts.append("")
+
+    if r.agent_results:
+        parts.append("### 各 Agent 要点")
+        for a in r.agent_results:
+            if a.get("error"):
+                parts.append(f"- **{a['agent']}** ⚠️ {a['error']}")
+                continue
+            pts = a.get("key_points") or []
+            head = f"- **{a['agent']}** ({a.get('signal','?')}, {a.get('confidence',0):.0%})"
+            parts.append(head)
+            for pt in pts[:3]:
+                parts.append(f"    • {pt}")
+
+    return "\n".join(parts).rstrip()
+
+
+def render_tier(r: DeepAnalysisResult, tier: str = "standard") -> str:
+    return {"brief": render_brief, "standard": render_standard,
+            "deep": render_deep}.get(tier, render_standard)(r)

aria_code/agents/engineering/__init__.py

@@ -0,0 +1,14 @@
+"""
+agents/engineering/__init__.py — Engineering & Code Execution Agents
+===================================================================
+Provides Coder, Tester, and Self-Healing Debugger agents for Aria Code.
+"""
+
+from .coder import CoderAgent
+from .tester import TesterAgent, TesterSelfHealingAgent
+
+__all__ = [
+    "CoderAgent",
+    "TesterAgent",
+    "TesterSelfHealingAgent",
+]

aria_code/agents/engineering/coder.py

@@ -0,0 +1,222 @@
+"""
+agents/engineering/coder.py — Coder Agent
+=========================================
+Engineering agent responsible for translating Quant Strategist Rule Trees
+into self-contained, robust, executable Python / TypeScript backtest scripts.
+Never dumps raw unexecuted code into user dialogue; saves directly to disk.
+"""
+
+from __future__ import annotations
+
+import inspect
+import logging
+import os
+import pathlib
+import re
+import shlex
+import subprocess
+from typing import Any, Awaitable, Callable, Dict, Optional
+
+from ..base import BaseAgent, AgentResult
+
+logger = logging.getLogger(__name__)
+
+
+class CoderAgent(BaseAgent):
+    name = "coder"
+    description = "编码智能体 — 在指定工作区读写文件；执行命令需宿主明确授权"
+
+    def __init__(
+        self,
+        output_dir: Optional[pathlib.Path] = None,
+        llm_provider=None,
+        data_router=None,
+        on_token: Optional[Callable[[str], None]] = None,
+        on_thought: Optional[Callable[[str], None]] = None,
+        on_tool_start: Optional[Callable[[str, Dict], None]] = None,
+        on_tool_end: Optional[Callable[[str, Any], None]] = None,
+        lang: str = "zh",
+        command_approval: Optional[Callable[[list[str], pathlib.Path], bool | Awaitable[bool]]] = None,
+        on_user_question: Optional[Callable[[str], str | Awaitable[str]]] = None,
+    ) -> None:
+        super().__init__(
+            llm_provider=llm_provider,
+            data_router=data_router,
+            on_token=on_token,
+            on_thought=on_thought,
+            on_tool_start=on_tool_start,
+            on_tool_end=on_tool_end,
+            lang=lang,
+        )
+        self.output_dir = (output_dir or pathlib.Path.cwd() / "generated").resolve()
+        self.command_approval = command_approval
+        self.on_user_question = on_user_question
+
+    def _workspace_path(self, raw_path: str, *, required: bool = True) -> pathlib.Path:
+        """Resolve a model-supplied path without allowing access outside the workspace."""
+        if required and not raw_path:
+            raise ValueError("A workspace-relative path is required")
+        path = pathlib.Path(raw_path)
+        if path.is_absolute():
+            raise ValueError("Absolute paths are not allowed")
+        resolved = (self.output_dir / path).resolve()
+        if not resolved.is_relative_to(self.output_dir):
+            raise ValueError("Path escapes the workspace")
+        return resolved
+
+    async def _execute_tool(self, tool_name: str, tool_args: Dict[str, Any]) -> str:
+        if self.on_tool_start:
+            self.on_tool_start(tool_name, tool_args)
+
+        try:
+            if tool_name == "run_command":
+                argv = shlex.split(str(tool_args.get("command", "")))
+                if not argv:
+                    raise ValueError("Command is required")
+                cwd = self._workspace_path(str(tool_args.get("cwd", "")), required=False)
+                if not cwd.is_dir():
+                    raise ValueError("Command directory does not exist")
+                if self.command_approval is None:
+                    result = "Error: command approval is unavailable; command was not run"
+                else:
+                    approved = self.command_approval(argv, cwd)
+                    if inspect.isawaitable(approved):
+                        approved = await approved
+                    if not approved:
+                        result = "Error: command was denied; command was not run"
+                    else:
+                        proc = subprocess.run(argv, shell=False, cwd=cwd, capture_output=True, text=True, timeout=120)
+                        result = f"STDOUT:\n{proc.stdout}\nSTDERR:\n{proc.stderr}\nReturnCode: {proc.returncode}"
+
+            elif tool_name in {"write_file", "read_file", "edit_file_chunk"}:
+                path = self._workspace_path(str(tool_args.get("filename", "")))
+                if tool_name == "write_file":
+                    path.parent.mkdir(parents=True, exist_ok=True)
+                    path.write_text(str(tool_args.get("content", "")), encoding="utf-8")
+                    result = f"Successfully wrote full file to {path}"
+                elif tool_name == "read_file":
+                    lines = path.read_text(encoding="utf-8").splitlines()
+                    result = f"File: {path}\n" + "\n".join(f"{i:04d} | {line}" for i, line in enumerate(lines, 1))
+                else:
+                    target = str(tool_args.get("target_content", ""))
+                    if not target:
+                        raise ValueError("target_content is required")
+                    original = path.read_text(encoding="utf-8")
+                    if target not in original:
+                        result = f"Error: target_content not found in {path}"
+                    else:
+                        path.write_text(original.replace(target, str(tool_args.get("replacement_content", ""))), encoding="utf-8")
+                        result = f"Successfully replaced chunk in {path}"
+
+            elif tool_name == "search_code":
+                query = str(tool_args.get("query", ""))
+                if not query:
+                    raise ValueError("Search query is required")
+                matches: list[str] = []
+                for root, dirs, files in os.walk(self.output_dir, followlinks=False):
+                    dirs[:] = [name for name in dirs if not name.startswith(".")]
+                    for filename in files:
+                        if len(matches) >= 50:
+                            break
+                        path = pathlib.Path(root) / filename
+                        try:
+                            if filename.startswith(".") or not path.resolve().is_relative_to(self.output_dir) or path.stat().st_size > 1_000_000:
+                                continue
+                            lines = path.read_text(encoding="utf-8").splitlines()
+                        except (OSError, UnicodeError):
+                            continue
+                        for line_no, line in enumerate(lines, 1):
+                            if query in line:
+                                matches.append(f"{path.relative_to(self.output_dir)}:{line_no}:{line}")
+                                if len(matches) >= 50:
+                                    break
+                    if len(matches) >= 50:
+                        break
+                result = "\n".join(matches) if matches else "No matches found."
+
+            elif tool_name == "list_dir":
+                path = self._workspace_path(str(tool_args.get("path", "")), required=False)
+                if not path.is_dir():
+                    raise ValueError("Directory does not exist")
+                items: list[str] = []
+                for root, dirs, files in os.walk(path, followlinks=False):
+                    depth = len(pathlib.Path(root).relative_to(path).parts)
+                    if depth >= 3:
+                        dirs[:] = []
+                    dirs[:] = [name for name in dirs if not name.startswith(".")]
+                    items.extend(str((pathlib.Path(root) / name).relative_to(path)) for name in dirs + files if not name.startswith("."))
+                    if len(items) >= 200:
+                        break
+                result = "\n".join(items[:200])
+
+            elif tool_name == "take_screenshot":
+                result = "Error: screenshot capability is not configured; no image was captured"
+
+            elif tool_name == "github_api":
+                repo = str(tool_args.get("repo", ""))
+                issue = str(tool_args.get("issue_number", ""))
+                if tool_args.get("action") != "read_issue" or not re.fullmatch(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+", repo) or not issue.isdecimal():
+                    raise ValueError("Only read_issue with a valid repository and issue number is supported")
+                proc = subprocess.run(["gh", "issue", "view", issue, "--repo", repo], shell=False, capture_output=True, text=True, timeout=30)
+                result = proc.stdout if proc.returncode == 0 else proc.stderr
+
+            elif tool_name == "ask_user":
+                question = str(tool_args.get("question", ""))
+                if self.on_user_question is None:
+                    result = "Error: user interaction is unavailable; no user response was received"
+                else:
+                    answer = self.on_user_question(question)
+                    if inspect.isawaitable(answer):
+                        answer = await answer
+                    result = f"USER REPLIED: {answer}"
+            else:
+                result = await super()._execute_tool(tool_name, tool_args)
+        except (OSError, ValueError, subprocess.TimeoutExpired) as exc:
+            result = f"Tool Error: {exc}"
+
+        if self.on_tool_end:
+            self.on_tool_end(tool_name, result)
+        return result
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        """
+        Advanced Autonomous Software Engineer Loop (Cursor/Claude Code caliber).
+        """
+        rule_tree = data.get("strategy_rules") or data.get("rule_tree")
+        request_text = data.get("request", "Write a Python script.")
+        
+        system_prompt = (
+            "You are a software engineer working within a bounded local workspace. "
+            "Use workspace-relative paths only. Never claim an action succeeded without a tool result.\n"
+            "Tools: list_dir(path), search_code(query), read_file(filename), "
+            "write_file(filename, content), edit_file_chunk(filename, target_content, replacement_content), "
+            "github_api(action='read_issue', repo='owner/repo', issue_number='123').\n"
+            "run_command(command, cwd) executes an argv command only after host approval. "
+            "If approval is unavailable or denied, do not retry to bypass it; report that verification was not run. "
+            "Shell pipelines, redirects and command substitution are unavailable.\n"
+            "Screenshot capture is unavailable; do not claim visual verification.\n"
+            + ("ask_user(question) forwards a real question to the host.\n" if self.on_user_question else "User interaction is unavailable; do not invent a reply.\n")
+            + "Call a tool with one JSON block per turn: "
+            + '{"type":"tool_call","name":"<tool_name>","args":{}}\n'
+            + "Inspect context, make focused edits, request approved verification, and report observed results."
+        )
+
+        user_prompt = f"Workspace: {self.output_dir}\nTarget Symbol: {symbol}\nRules: {rule_tree}\nUser Request: {request_text}\n\nPlease begin autonomous execution."
+        
+        analysis = await self._call_llm(system_prompt, user_prompt, max_tokens=2500, max_tool_loops=15)
+        
+        report = (
+            f"### Aria Coder - Engineering Report\n\n"
+            f"**项目根目录**：`{self.output_dir.absolute()}`\n\n"
+            f"**执行记录与结果**：\n{analysis}\n"
+        )
+        
+        return AgentResult(
+            agent=self.name,
+            symbol=symbol,
+            analysis=report,
+            confidence=0.5,
+            signal="HOLD",
+            key_points=[],
+            data_used={"workspace": str(self.output_dir)},
+        )