aria-code 4.1.7__tar.gz → 4.2.0__tar.gz

{aria_code-4.1.7 → aria_code-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 4.1.7
+Version: 4.2.0
 Summary: AI-powered financial terminal — local LLM + multi-source market data
 License: BUSL-1.1
 Project-URL: Homepage, https://github.com/artherahq/aria-code
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Office/Business :: Financial
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.10
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.9.0
@@ -37,6 +37,8 @@ Requires-Dist: pandas>=2.2.0
 Requires-Dist: scipy>=1.13.0
 Requires-Dist: pandas_ta>=0.4.67b0; python_version >= "3.12"
 Requires-Dist: yfinance>=0.2.55
+Requires-Dist: pyobjc-framework-WebKit>=10.0; sys_platform == "darwin"
+Requires-Dist: markdown>=3.6
 Provides-Extra: cn
 Requires-Dist: akshare>=1.14.68; extra == "cn"
 Provides-Extra: crypto

{aria_code-4.1.7 → aria_code-4.2.0}/agents/__init__.py

@@ -24,9 +24,11 @@ agents/ — Aria Code 可组合多智能体系统
 from .base import BaseAgent, AgentResult
 from .registry import AgentRegistry, get_registry
 from .team import AgentTeam, run_team
+from .signal_scheme import SignalScheme, FINANCIAL_SCHEME, REALTY_SCHEME
 
 __all__ = [
     "BaseAgent", "AgentResult",
     "AgentRegistry", "get_registry",
     "AgentTeam", "run_team",
+    "SignalScheme", "FINANCIAL_SCHEME", "REALTY_SCHEME",
 ]

{aria_code-4.1.7 → aria_code-4.2.0}/agents/base.py

@@ -26,6 +26,9 @@ class AgentResult:
     key_points:  List[str] = field(default_factory=list)   # 关键结论（用于 synthesis）
     data_used:   Dict[str, Any] = field(default_factory=dict)  # 使用的原始数据
     error:       Optional[str] = None   # 失败时的错误信息
+    degraded:    bool = False           # True when a deterministic fallback was used
+    provenance:  List[str] = field(default_factory=list)
+    limitations: List[str] = field(default_factory=list)
 
     @property
     def success(self) -> bool:
@@ -40,6 +43,9 @@ class AgentResult:
             "signal":     self.signal,
             "key_points": self.key_points,
             "error":      self.error,
+            "degraded":   self.degraded,
+            "provenance": list(self.provenance),
+            "limitations": list(self.limitations),
         }
 
 

{aria_code-4.1.7 → aria_code-4.2.0}/agents/portfolio_agent.py

@@ -47,12 +47,24 @@ class PortfolioAgent(BaseAgent):
 
     # ── Multi-symbol interface ────────────────────────────────────────────────
 
-    async def run_portfolio(self, symbols: List[str]) -> AgentResult:
-        """Primary entry point for multi-symbol analysis."""
-        data   = await self.fetch_portfolio_data(symbols)
+    async def run_portfolio(
+        self, symbols: List[str], weights: Optional[Dict[str, float]] = None
+    ) -> AgentResult:
+        """Primary entry point for multi-symbol analysis.
+
+        weights: optional {symbol: dollar_cost_basis} from the user's real
+        holdings (portfolio_ledger.PortfolioLedger.get_positions()). Without
+        it, every position is silently treated as equal-weight — which used
+        to be the ONLY mode this agent supported, so a user who actually
+        holds 80% NVDA and 20% everything else got a risk verdict computed
+        on a fictional 1/n-weighted portfolio instead of their real exposure.
+        """
+        data   = await self.fetch_portfolio_data(symbols, weights=weights)
         return await self.analyze_portfolio(symbols, data)
 
-    async def fetch_portfolio_data(self, symbols: List[str]) -> Dict[str, Any]:
+    async def fetch_portfolio_data(
+        self, symbols: List[str], weights: Optional[Dict[str, float]] = None
+    ) -> Dict[str, Any]:
         data: Dict[str, Any] = {"symbols": symbols}
         if len(symbols) < 2:
             return data
@@ -97,8 +109,15 @@ class PortfolioAgent(BaseAgent):
             cov_matrix  = returns.cov() * 252
             valid_syms  = list(df.columns)
             n           = len(valid_syms)
-            weights     = np.ones(n) / n
-            port_vol    = float(np.sqrt(weights @ cov_matrix.values @ weights))
+            if weights and any(weights.get(s, 0) > 0 for s in valid_syms):
+                raw = np.array([max(weights.get(s, 0.0), 0.0) for s in valid_syms])
+                w_vec = raw / raw.sum() if raw.sum() > 0 else np.ones(n) / n
+                weight_source = "ledger"
+            else:
+                w_vec = np.ones(n) / n
+                weight_source = "equal"
+            port_vol = float(np.sqrt(w_vec @ cov_matrix.values @ w_vec))
+            position_weights = {s: round(float(w_vec[i]), 4) for i, s in enumerate(valid_syms)}
 
             # High correlation pairs (|r| > 0.70)
             high_corr: List[Dict] = []
@@ -112,8 +131,10 @@ class PortfolioAgent(BaseAgent):
                             "corr": round(c, 3),
                         })
 
-            # Diversification ratio: weighted avg individual vol / portfolio vol
-            avg_vol = float(np.mean([float(ann_vols.get(s, 0)) for s in valid_syms]))
+            # Diversification ratio: weighted avg individual vol / portfolio vol.
+            # Was np.mean() (unweighted) despite the comment already claiming
+            # "weighted" — with real ledger weights now available, actually weight it.
+            avg_vol = float(sum(w_vec[i] * float(ann_vols.get(s, 0)) for i, s in enumerate(valid_syms)))
             div_ratio = round(avg_vol / port_vol, 2) if port_vol > 0 else 1.0
 
             # 52-week return per symbol
@@ -140,6 +161,8 @@ class PortfolioAgent(BaseAgent):
                 "best_performer":  sorted_ret[0]  if sorted_ret else None,
                 "worst_performer": sorted_ret[-1] if sorted_ret else None,
                 "sector_map":    sector_map,
+                "position_weights": position_weights,
+                "weight_source":    weight_source,
             })
 
         except ImportError:
@@ -171,9 +194,11 @@ class PortfolioAgent(BaseAgent):
 
         valid_syms = data.get("valid_symbols", symbols)
         port_block = _format_portfolio_stats(data)
+        weight_desc = ("your actual position sizes" if data.get("weight_source") == "ledger"
+                       else "equal weight — no real position sizes available")
 
         prompt = (
-            f"Portfolio: {', '.join(valid_syms)} ({len(valid_syms)} positions, equal weight)\n\n"
+            f"Portfolio: {', '.join(valid_syms)} ({len(valid_syms)} positions, weighted by {weight_desc})\n\n"
             f"{port_block}\n\n"
             "Analyze this portfolio:\n"
             "1. Overall risk level (Low / Medium / High)\n"
@@ -217,15 +242,17 @@ def _format_portfolio_stats(d: Dict) -> str:
     vols    = d.get("ann_vols", {})
     rets    = d.get("ann_returns", {})
     rets_1y = d.get("returns_1y", {})
+    pweights = d.get("position_weights", {})
     if vols:
-        lines.append("Symbol │ Ann.Vol │ Ann.Ret │ 1Y Return")
-        lines.append("─" * 42)
+        lines.append("Symbol │ Weight │ Ann.Vol │ Ann.Ret │ 1Y Return")
+        lines.append("─" * 52)
         for sym in d.get("valid_symbols", list(vols)):
             v  = vols.get(sym, 0)
             r  = rets.get(sym, 0)
             y  = rets_1y.get(sym, 0)
+            w  = pweights.get(sym, 0)
             lines.append(
-                f"{sym:<6} │ {v*100:>6.1f}% │ {r*100:>6.1f}% │ {y*100:>+7.1f}%"
+                f"{sym:<6} │ {w*100:>5.1f}% │ {v*100:>6.1f}% │ {r*100:>6.1f}% │ {y*100:>+7.1f}%"
             )
 
     port_vol = d.get("port_vol_ann", 0)
@@ -288,7 +315,10 @@ def _estimate_confidence(d: Dict) -> float:
 def _build_key_points(d: Dict, verdict: str) -> List[str]:
     pts = []
     n   = len(d.get("valid_symbols", []))
-    pts.append(f"{n} 个标的，等权配置")
+    if d.get("weight_source") == "ledger":
+        pts.append(f"{n} 个标的，按真实持仓成本加权")
+    else:
+        pts.append(f"{n} 个标的，等权配置（无真实持仓数据，非实际风险暴露）")
 
     port_vol = d.get("port_vol_ann", 0)
     if port_vol:

{aria_code-4.1.7 → aria_code-4.2.0}/agents/realty/asset_diagnosis.py

@@ -10,7 +10,9 @@ agents/realty/asset_diagnosis.py — 资产诊断 Agent
 
 输出:
     analysis    — 详细分析文本
-    signal      — BUY=推荐共创 / HOLD=需观察 / SELL=建议出租或出售
+    signal      — GOOD=推荐共创 / WATCH=需观察 / CONCERN=建议出租或出售
+                  （地产健康度尺度，见 agents/signal_scheme.py::REALTY_SCHEME，
+                  不是股票 BUY/SELL 那套交易动作词汇）
     key_points  — 3-5 条关键结论
 """
 from __future__ import annotations
@@ -101,9 +103,9 @@ def _score_to_signal(asset: Dict, reno: float) -> str:
     if state != "正常":   score -= 2
     if reno > rent * 24:  score -= 1     # 改造成本超过2年租金则不划算
 
-    if score >= 4:  return "BUY"       # 非常适合共创
-    if score >= 2:  return "HOLD"      # 需进一步评估
-    return "SELL"                       # 建议传统出租或出售
+    if score >= 4:  return "GOOD"      # 非常适合共创
+    if score >= 2:  return "WATCH"     # 需进一步评估
+    return "CONCERN"                    # 建议传统出租或出售
 
 
 def _calc_confidence(asset: Dict) -> float:

{aria_code-4.1.7 → aria_code-4.2.0}/agents/realty/business_match.py

@@ -10,7 +10,8 @@ agents/realty/business_match.py — 业态匹配 Agent
 
 输出:
     analysis    — 业态匹配建议
-    signal      — BUY=高度匹配 / HOLD=一般匹配 / SELL=低匹配
+    signal      — GOOD=高度匹配 / WATCH=一般匹配 / CONCERN=低匹配
+                  （地产健康度尺度，见 signal_scheme.py）
     key_points  — 推荐业态 Top3 + 理由
 """
 from __future__ import annotations
@@ -115,9 +116,9 @@ def _match_signal(asset: Dict, market: Dict) -> str:
     if market_score >= 7:  score += 1
     elif 0 < market_score <= 3: score -= 1
 
-    if score >= 4:  return "BUY"
-    if score >= 2:  return "HOLD"
-    return "SELL"
+    if score >= 4:  return "GOOD"
+    if score >= 2:  return "WATCH"
+    return "CONCERN"
 
 
 def _match_confidence(asset: Dict, market: Dict) -> float:

{aria_code-4.1.7 → aria_code-4.2.0}/agents/realty/cashflow_verify.py

@@ -14,7 +14,8 @@ agents/realty/cashflow_verify.py — 流水核验 Agent
 
 输出:
     analysis    — 核验报告
-    signal      — BUY=流水真实 / HOLD=轻度异常需复核 / SELL=疑似造假/私账
+    signal      — GOOD=流水真实 / WATCH=轻度异常需复核 / CONCERN=疑似造假/私账
+                  / SEVERE=多项异常+差距极大（地产健康度尺度，见 signal_scheme.py）
     key_points  — 异常项目清单
 """
 from __future__ import annotations
@@ -174,10 +175,10 @@ def _cross_verify(
 def _verify_signal(check: Dict) -> str:
     n = check.get("anomaly_count", 0)
     gap = abs(check.get("gap_pct", 0))
-    if n == 0 and gap < 15: return "BUY"
-    if n <= 1 and gap < 30: return "HOLD"
-    if n <= 2 and gap < 50: return "SELL"
-    return "STRONG_SELL"
+    if n == 0 and gap < 15: return "GOOD"
+    if n <= 1 and gap < 30: return "WATCH"
+    if n <= 2 and gap < 50: return "CONCERN"
+    return "SEVERE"
 
 
 def _verify_confidence(check: Dict) -> float:

{aria_code-4.1.7 → aria_code-4.2.0}/agents/realty/contract_rules.py

@@ -10,7 +10,8 @@ agents/realty/contract_rules.py — 合同规则 Agent
 
 输出:
     analysis    — 合同条款草案文本
-    signal      — BUY=条款清晰可执行 / HOLD=需补充条款 / SELL=有重大风险条款
+    signal      — GOOD=条款清晰可执行 / WATCH=需补充条款 / CONCERN=有重大风险条款
+                  （地产健康度尺度，见 signal_scheme.py）
     key_points  — 关键条款摘要（保底金额/分润比例/结算周期/违约条款）
 """
 from __future__ import annotations
@@ -139,9 +140,9 @@ def _contract_signal(nego: Dict) -> str:
     if not nego.get("settlement_cycle"):   issues += 1
     if not nego.get("contract_years"):     issues += 1
 
-    if issues == 0:  return "BUY"
-    if issues <= 2:  return "HOLD"
-    return "SELL"
+    if issues == 0:  return "GOOD"
+    if issues <= 2:  return "WATCH"
+    return "CONCERN"
 
 
 def _contract_confidence(nego: Dict) -> float:

{aria_code-4.1.7 → aria_code-4.2.0}/agents/realty/energy_anomaly.py

@@ -13,7 +13,8 @@ agents/realty/energy_anomaly.py — 能耗异常 Agent
 
 输出:
     analysis    — 能耗分析报告
-    signal      — BUY=正常 / HOLD=轻度异常 / SELL=严重异常/疑似空置
+    signal      — GOOD=正常 / WATCH=轻度异常 / CONCERN=中度异常 / SEVERE=严重异常/疑似空置
+                  （地产健康度尺度，见 signal_scheme.py）
     key_points  — 异常指标清单
 """
 from __future__ import annotations
@@ -154,10 +155,10 @@ def _analyze_energy(
 
 def _energy_signal(check: Dict) -> str:
     n = check.get("anomaly_count", 0)
-    if n == 0: return "BUY"
-    if n == 1: return "HOLD"
-    if n == 2: return "SELL"
-    return "STRONG_SELL"
+    if n == 0: return "GOOD"
+    if n == 1: return "WATCH"
+    if n == 2: return "CONCERN"
+    return "SEVERE"
 
 
 def _energy_confidence(check: Dict) -> float:

{aria_code-4.1.7 → aria_code-4.2.0}/agents/realty/exit_settlement.py

@@ -11,7 +11,8 @@ agents/realty/exit_settlement.py — 退出清算 Agent
 
 输出:
     analysis    — 清算方案草案
-    signal      — BUY=清算顺利无纠纷 / HOLD=有待确认项 / SELL=存在较大争议
+    signal      — GOOD=清算顺利无纠纷 / WATCH=有待确认项 / CONCERN=存在较大争议
+                  （地产健康度尺度，见 signal_scheme.py）
     key_points  — 各方清算金额摘要
     data_used   — 包含 settlement_result（结构化清算数据）
 """
@@ -145,12 +146,12 @@ def _calculate_settlement(
 
 def _settlement_signal(s: Dict, reason: str) -> str:
     if s["net_settlement"] > 0 and not s["is_breach"]:
-        return "HOLD"   # 经营方有欠款但无违约，需催收
+        return "WATCH"    # 经营方有欠款但无违约，需催收
     if s["is_breach"] and s["net_settlement"] > 0:
-        return "SELL"   # 违约且有欠款
+        return "CONCERN"  # 违约且有欠款
     if s["operator_owes"] == 0 and s["platform_owes"] == 0:
-        return "BUY"    # 干净退出
-    return "HOLD"
+        return "GOOD"      # 干净退出
+    return "WATCH"
 
 
 def _settlement_confidence(fin: Dict) -> float:

{aria_code-4.1.7 → aria_code-4.2.0}/agents/realty/fulfillment_risk.py

@@ -12,7 +12,8 @@ agents/realty/fulfillment_risk.py — 履约风控 Agent
 
 输出:
     analysis    — 风险报告
-    signal      — BUY=低风险 / HOLD=中等风险 / SELL=高风险 / STRONG_SELL=极高风险
+    signal      — GOOD=低风险 / WATCH=中等风险 / CONCERN=高风险 / SEVERE=极高风险
+                  （地产健康度尺度，见 signal_scheme.py）
     key_points  — 风险事项清单（按级别）
 """
 from __future__ import annotations
@@ -134,7 +135,7 @@ def _assess_risk(
 
     # 5. 流水核验异常
     cf_signal = cf.get("signal", "")
-    if cf_signal in ("SELL", "STRONG_SELL"):
+    if cf_signal in ("CONCERN", "SEVERE"):
         risk_items.append({"level": "高",
                            "desc": f"流水核验异常（{cf.get('anomaly_summary','')}），需稽查"})
 
@@ -157,12 +158,12 @@ def _assess_risk(
 
 
 def _risk_signal(risk: Dict) -> str:
-    if risk.get("has_extreme_risk"): return "STRONG_SELL"
-    if risk.get("has_high_risk"):    return "SELL"
+    if risk.get("has_extreme_risk"): return "SEVERE"
+    if risk.get("has_high_risk"):    return "CONCERN"
     mid_count = sum(1 for r in risk.get("risk_items", []) if r["level"] == "中")
-    if mid_count >= 2:               return "SELL"
-    if mid_count >= 1:               return "HOLD"
-    return "BUY"
+    if mid_count >= 2:               return "CONCERN"
+    if mid_count >= 1:               return "WATCH"
+    return "GOOD"
 
 
 def _risk_confidence(risk: Dict, invoices: List) -> float:

{aria_code-4.1.7 → aria_code-4.2.0}/agents/realty/ops_optimize.py

@@ -11,7 +11,8 @@ agents/realty/ops_optimize.py — 运营提升 Agent
 
 输出:
     analysis    — 运营优化建议
-    signal      — BUY=经营健康/高潜力 / HOLD=有改善空间 / SELL=经营不佳需干预
+    signal      — GOOD=经营健康/高潜力 / WATCH=有改善空间 / CONCERN=经营不佳 / SEVERE=急需干预
+                  （地产健康度尺度，见 signal_scheme.py）
     key_points  — Top3 优化建议
 """
 from __future__ import annotations
@@ -101,12 +102,12 @@ def _calc_metrics(project: Dict, perf: Dict, marketing: Dict, bench: Dict) -> Di
 def _ops_signal(metrics: Dict, bench: Dict) -> str:
     psm = metrics.get("revenue_per_sqm", 0)
     bench_psm = metrics.get("bench_psm", 300)
-    if bench_psm <= 0: return "HOLD"
+    if bench_psm <= 0: return "WATCH"
     ratio = psm / bench_psm
-    if ratio >= 1.2: return "BUY"
-    if ratio >= 0.8: return "HOLD"
-    if ratio >= 0.5: return "SELL"
-    return "STRONG_SELL"
+    if ratio >= 1.2: return "GOOD"
+    if ratio >= 0.8: return "WATCH"
+    if ratio >= 0.5: return "CONCERN"
+    return "SEVERE"
 
 
 def _ops_confidence(perf: Dict, marketing: Dict) -> float:

{aria_code-4.1.7 → aria_code-4.2.0}/agents/realty/revenue_share.py

@@ -10,7 +10,8 @@ agents/realty/revenue_share.py — 分账规则 Agent
 
 输出:
     analysis    — 分账计算说明文本
-    signal      — BUY=分账正常 / HOLD=有补足情况 / SELL=流水严重不足
+    signal      — GOOD=分账正常 / WATCH=有补足情况 / CONCERN=流水勉强覆盖 / SEVERE=流水严重不足
+                  （地产健康度尺度，见 signal_scheme.py）
     key_points  — 各方金额摘要
     data_used   — 包含 split_result（可直接入库）
 """
@@ -159,12 +160,12 @@ def _split_signal(split: Dict) -> str:
     guaranteed = split.get("guaranteed", 0)
     op_net     = split.get("operator_net", 0)
 
-    if guaranteed <= 0:  return "HOLD"
+    if guaranteed <= 0:  return "WATCH"
     coverage = net / guaranteed if guaranteed else 0
-    if coverage >= 2.0 and op_net > 0:  return "BUY"
-    if coverage >= 1.0 and op_net > 0:  return "HOLD"
-    if op_net > 0 and coverage >= 0.5:  return "SELL"    # 经营方能勉强覆盖
-    return "STRONG_SELL"   # 经营方净收入为负或流水极低
+    if coverage >= 2.0 and op_net > 0:  return "GOOD"
+    if coverage >= 1.0 and op_net > 0:  return "WATCH"
+    if op_net > 0 and coverage >= 0.5:  return "CONCERN"   # 经营方能勉强覆盖
+    return "SEVERE"   # 经营方净收入为负或流水极低
 
 
 def _split_status(split: Dict) -> str:

aria_code-4.2.0/agents/signal_scheme.py

@@ -0,0 +1,97 @@
+"""
+agents/signal_scheme.py — 领域可插拔的信号词汇表
+====================================================
+team.py 里的表决(_vote_signal)、辩论触发(_needs_debate)原本硬编码了金融的
+BUY/HOLD/SELL/STRONG_BUY/STRONG_SELL 五级词汇。realty 的 9 个 agent 长期以来
+借用同一套词汇表达完全不同的含义(BUY=推荐共创、流水真实、条款清晰、低风险……
+每个文件的 BUY 意思都不一样，只在各自 docstring 里注明)，靠 aria_cli.py 里
+一张 _SIGNAL_LABELS 翻译表在展示层补救。这意味着一旦有人把多个 realty agent
+接进 AgentTeam 做 vote/debate（cashflow_verify 的 SELL=疑似造假 和
+ops_optimize 的 SELL=经营不佳需干预 完全不是同一个维度），_vote_signal 会把
+它们当同一根多空轴数值平均，产出一个语义上没有意义的"共识"。
+
+SignalScheme 把这套词汇表和打分/辩论触发规则抽成领域可配置的对象，
+AgentTeam 默认用 FINANCIAL_SCHEME（对现有金融调用方零行为变化），
+其他领域注册自己的词汇表即可复用同一套并行/表决/辩论/synthesis 编排逻辑，
+而不必借用金融的 BUY/SELL 语义或答案词不达意。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Tuple
+
+from .base import AgentResult
+
+
+@dataclass(frozen=True)
+class SignalScheme:
+    """一套领域信号词汇表：多空打分 + 辩论触发条件。
+
+    upper_thresholds / lower_thresholds 特意分成两条腿而不是一条单向扫描的
+    区间列表——原始金融判定逻辑本身就是两段非对称的边界（上方 >= 含右端点，
+    下方 <= 含左端点，中间落空隙才算 neutral_default），一条单向 >= 扫描的
+    区间列表没法同时正确表达"上方含端点"和"下方也含端点"这两种边界方向，
+    会把 avg_score=0 这种中性分数错误地吃进最负的那个区间（已在 fuzz 测试里
+    实测过这个 bug：单向列表版本对 avg_score=0 的输入返回了 STRONG_SELL）。
+    """
+
+    name: str
+    # 信号 → 打分（用于表决时按置信度加权平均）；分数越高越"正面"。
+    scores: Dict[str, int]
+    # 从高到低排列；第一个满足 avg_score >= threshold 的胜出。
+    upper_thresholds: List[Tuple[float, str]]
+    # 按"最极端优先"排列（比如先检查 <=-1.5 再检查 <=-0.5）；
+    # 第一个满足 avg_score <= threshold 的胜出。
+    lower_thresholds: List[Tuple[float, str]]
+    # 触发 debate 的两组信号（出现其一 + 另一组其一即触发，比如金融的"多"与"空"）
+    positive_signals: frozenset
+    negative_signals: frozenset
+    neutral_default: str = "HOLD"
+
+    def vote(self, results: List[AgentResult]) -> Tuple[str, float]:
+        valid = [r for r in results if r.success and r.signal in self.scores]
+        if not valid:
+            return self.neutral_default, 0.0
+        avg_score = sum(self.scores[r.signal] * r.confidence for r in valid) / len(valid)
+        avg_conf = sum(r.confidence for r in valid) / len(valid)
+        for threshold, label in self.upper_thresholds:
+            if avg_score >= threshold:
+                return label, avg_conf
+        for threshold, label in self.lower_thresholds:
+            if avg_score <= threshold:
+                return label, avg_conf
+        return self.neutral_default, avg_conf
+
+    def needs_debate(self, results: List[AgentResult]) -> bool:
+        signals = [r.signal for r in results if r.success and r.signal]
+        has_positive = any(s in self.positive_signals for s in signals)
+        has_negative = any(s in self.negative_signals for s in signals)
+        return has_positive and has_negative
+
+
+# ── 金融：既有行为，原样保留（upper/lower 拆分精确复刻原 if/elif 分支）────────
+FINANCIAL_SCHEME = SignalScheme(
+    name="financial",
+    scores={"STRONG_BUY": 2, "BUY": 1, "HOLD": 0, "SELL": -1, "STRONG_SELL": -2},
+    upper_thresholds=[(1.5, "STRONG_BUY"), (0.5, "BUY")],
+    lower_thresholds=[(-1.5, "STRONG_SELL"), (-0.5, "SELL")],
+    positive_signals=frozenset({"BUY", "STRONG_BUY"}),
+    negative_signals=frozenset({"SELL", "STRONG_SELL"}),
+    neutral_default="HOLD",
+)
+
+# ── 地产资管：健康度评估，不是交易动作 ──────────────────────────────────────
+# GOOD/WATCH/CONCERN/SEVERE —— 这条轴描述"这个维度是否健康"，不是"要不要买"。
+# 9 个 realty agent 各自评估不同维度（流水真实性、合同风险、能耗异常、履约风险
+# 等），但共享同一个"健康 → 需关注 → 有问题 → 严重"的四级尺度，用领域自己的
+# 词汇表述比借用股票的 BUY/SELL 更准确，也让 vote/debate 的语义站得住脚。
+REALTY_SCHEME = SignalScheme(
+    name="realty",
+    scores={"GOOD": 2, "WATCH": 0, "CONCERN": -1, "SEVERE": -2},
+    upper_thresholds=[(1.0, "GOOD")],
+    lower_thresholds=[(-1.5, "SEVERE"), (-0.5, "CONCERN")],
+    positive_signals=frozenset({"GOOD"}),
+    negative_signals=frozenset({"CONCERN", "SEVERE"}),
+    neutral_default="WATCH",
+)

{aria_code-4.1.7 → aria_code-4.2.0}/agents/sports/football_agent.py

@@ -1,7 +1,23 @@
 """
 agents/sports/football_agent.py — Football Analysis Agent
 ===========================================================
-LLM-powered football match analysis using Poisson prediction + form data.
+LLM-powered football match analysis using Elo + Dixon-Coles prediction + form data.
+
+Prediction comes from packages.quant_engine.sports.predictor (Elo ratings,
+Dixon-Coles with negative-binomial tail for lopsided matches, dynamic
+Elo/DC mixing weights, recency-form and head-to-head adjustments, and
+self-calibration), not football_data_client.predict_match — that function
+is a much simpler independent-Poisson model over a static, hand-maintained
+attack/defense lookup table with a flat home-advantage constant, no
+Dixon-Coles low-score correlation correction, and no Elo. Verified the two
+disagree by double digits on some matchups (13.1pp on a real fixture) rather
+than assuming the richer model is worth switching to on faith.
+
+football_data_client itself is left untouched — aria_feishu_bot.py calls
+predict_match directly and has its own tested formatting/localization
+pinned to that function's exact output, which is out of scope here. Only
+get_team_stats() (recent-form text, not part of either prediction model)
+is still sourced from football_data_client.
 """
 
 from __future__ import annotations
@@ -61,10 +77,19 @@ class FootballAgent:
         away_team: str,
         league: str = "pl",
         with_llm: bool = True,
+        neutral_venue: bool = False,
     ) -> MatchPrediction:
-        from football_data_client import predict_match, get_team_stats
-
-        raw = predict_match(home_team, away_team, league)
+        from football_data_client import get_team_stats
+        from packages.quant_engine.sports.predictor import quick_predict
+
+        # neutral_venue defaults False: club leagues (pl/bl1/sa/pd/fl1, the
+        # default `league="pl"`) really do have a home team playing at home.
+        # Pass True for a genuinely neutral-site fixture (e.g. a World Cup
+        # group match at a third country's stadium).
+        raw = quick_predict(home_team, away_team, league, neutral_venue=neutral_venue)
+        raw["most_likely_score"] = (
+            raw["top_scorelines"][0]["score"] if raw.get("top_scorelines") else "0-0"
+        )
         h_stats = get_team_stats(league, home_team)
         a_stats = get_team_stats(league, away_team)
 
@@ -73,7 +98,10 @@ class FootballAgent:
             key_factors.append(f"{home_team} 近5场: {h_stats['form']} (场均进球 {h_stats['avg_gf']})")
         if a_stats:
             key_factors.append(f"{away_team} 近5场: {a_stats['form']} (场均进球 {a_stats['avg_gf']})")
-        key_factors.append(f"主场优势系数: ×1.25 (泊松模型)")
+        key_factors.append(
+            f"模型: {raw['model']}  Elo差: {raw['elo_diff']:+.0f}"
+            f"  (DC权重{raw['w_dc']:.0%}/Elo权重{raw['w_elo']:.0%})"
+        )
 
         analysis = ""
         if with_llm and self._llm: