aria-code 4.3.0__tar.gz → 4.4.0__tar.gz

{aria_code-4.3.0/aria_code.egg-info → aria_code-4.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 4.3.0
+Version: 4.4.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

aria_code-4.4.0/adk_apps/aria_code_review/__init__.py

@@ -0,0 +1 @@
+"""Google ADK entrypoint package for Aria's read-only code reviewer."""

aria_code-4.4.0/adk_apps/aria_code_review/agent.py

@@ -0,0 +1,32 @@
+"""Google ADK entrypoint: a bounded reviewer for pasted code."""
+
+from __future__ import annotations
+
+import os
+
+from google.adk.agents.llm_agent import Agent
+
+from packages.adk_bridge import CodeReviewTools
+
+
+_tools = CodeReviewTools()
+
+root_agent = Agent(
+    model=os.getenv("ARIA_ADK_MODEL", "gemini-3.5-flash"),
+    name="aria_code_review",
+    description="A read-only code reviewer for user-submitted source text.",
+    instruction="""You are Aria Code Review, a careful software reviewer.
+
+Ask the user to paste the relevant source code when it has not been supplied.
+Use review_code for deterministic findings and preserve its severity, line,
+rule, and limitations. Never claim to have opened a local path, accessed a
+repository, run a command, changed a file, or executed tests: this ADK agent
+has none of those capabilities.
+
+Explain only findings supported by the submitted code. Separate deterministic
+findings from suggestions, and recommend a test or validation step where
+appropriate. Do not expose credentials appearing in source; tell the user to
+revoke and rotate any exposed credential instead.
+""",
+    tools=[_tools.review_code],
+)

{aria_code-4.3.0 → aria_code-4.4.0}/agents/base.py

@@ -67,12 +67,15 @@ class BaseAgent(ABC):
     name:        str = "base"
     description: str = "基础 Agent"
 
-    # Post-training IPO facts injected into every agent's system prompt
-    _POST_TRAINING_FACTS = (
-        "\n\n## ⚡ Critical post-training facts (override training memory)\n"
-        "- **SPCX** = SpaceX (Space Exploration Technologies Corp.) — IPO'd June 12, 2026 "
-        "on NASDAQ. It is NOT an ETF. ⛔ Never say 'SPCX is a China ETF' or 'SPCX is private'.\n"
-        "- **2026 FIFA World Cup** opened June 11, 2026 in USA/Canada/Mexico.\n"
+    # Time-sensitive claims must come from a tool result with a timestamp, not
+    # from a hard-coded prompt.  This is appended to every agent because a
+    # wrong IPO/symbol/event claim can otherwise contaminate all specialisms.
+    _TIME_SENSITIVE_FACT_POLICY = (
+        "\n\n## Time-sensitive fact policy\n"
+        "- Do not treat examples, aliases, model memory, or internal notes as current facts.\n"
+        "- Verify ticker identity, IPO/listing status, prices, corporate events, sports results, "
+        "and dates with an appropriate tool or source before stating them as facts.\n"
+        "- If a current fact cannot be verified, say that it is unverified instead of guessing.\n"
     )
 
     # Language rule injected per-call based on detected user language
@@ -169,10 +172,10 @@ class BaseAgent(ABC):
         """调用 LLM 生成分析文本，内置 Tool Calling 的执行循环"""
         if not self.llm:
             return ""
-        # Inject language rule + post-training facts + data guard into system prompt
+        # Inject language rule + time-sensitive fact policy + data guard.
         _lang_rule = self._LANG_RULES.get(self.lang, self._LANG_RULES["zh"])
         _data_warn = self._data_guard(quote or {})
-        system = system + self._POST_TRAINING_FACTS + _lang_rule + _data_warn
+        system = system + self._TIME_SENSITIVE_FACT_POLICY + _lang_rule + _data_warn
         from providers.llm.base import Message
 
         # 自动注入 DAG pipeline 中的 upstream context

aria_code-4.4.0/agents/code_review.py

@@ -0,0 +1,200 @@
+"""Deterministic, read-only code review agent.
+
+The agent deliberately reviews caller-supplied text only.  It never resolves a
+path, invokes a shell, or changes a workspace, so it can be used safely from
+both the CLI and a Google ADK function tool.
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+from dataclasses import dataclass
+from pathlib import PurePath
+from typing import Any, Dict, Iterable, List
+
+from .base import AgentResult, BaseAgent
+
+
+@dataclass(frozen=True)
+class CodeReviewFinding:
+    """A stable, evidence-bearing static-review finding."""
+
+    severity: str
+    rule: str
+    message: str
+    line: int | None
+    evidence: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "severity": self.severity,
+            "rule": self.rule,
+            "message": self.message,
+            "line": self.line,
+            "evidence": self.evidence,
+        }
+
+
+class CodeReviewAgent(BaseAgent):
+    """Find high-signal correctness and security hazards without an LLM."""
+
+    name = "code_review"
+    description = "Read-only deterministic code review for user-supplied snippets and diffs"
+    MAX_SOURCE_CHARS = 48_000
+    _SEVERITY_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3}
+    _SECRET_ASSIGNMENT = re.compile(
+        r"\b(?:api[_-]?key|secret|token|password)\b\s*=\s*['\"][^'\"]{8,}['\"]",
+        re.IGNORECASE,
+    )
+    _TOKEN_LITERAL = re.compile(r"\b(?:(?:ghp|github_pat)_[A-Za-z0-9_-]{12,}|sk-[A-Za-z0-9_-]{12,})\b", re.IGNORECASE)
+    _SHELL_TRUE = re.compile(r"\b(?:subprocess\.[A-Za-z_]+|os\.system)\b.*\bshell\s*=\s*True", re.IGNORECASE)
+    _EVAL_EXEC = re.compile(r"\b(?:eval|exec)\s*\(")
+    _PICKLE = re.compile(r"\bpickle\.loads?\s*\(")
+    _UNSAFE_YAML = re.compile(r"\byaml\.load\s*\(")
+    _TLS_DISABLED = re.compile(r"\brequests\.[A-Za-z_]+\s*\(.*\bverify\s*=\s*False", re.IGNORECASE)
+
+    @staticmethod
+    def _safe_filename(filename: str) -> str:
+        name = PurePath(str(filename or "snippet.py")).name
+        return name[:160] or "snippet.py"
+
+    @classmethod
+    def _append(
+        cls,
+        findings: List[CodeReviewFinding],
+        severity: str,
+        rule: str,
+        message: str,
+        line: int | None,
+        evidence: str,
+    ) -> None:
+        if rule == "hardcoded-secret":
+            evidence = "<credential value redacted>"
+        findings.append(
+            CodeReviewFinding(
+                severity=severity,
+                rule=rule,
+                message=message,
+                line=line,
+                evidence=evidence.strip()[:240],
+            )
+        )
+
+    @classmethod
+    def _scan_lines(cls, lines: Iterable[str], findings: List[CodeReviewFinding]) -> None:
+        for number, line in enumerate(lines, start=1):
+            if cls._SECRET_ASSIGNMENT.search(line) or cls._TOKEN_LITERAL.search(line):
+                cls._append(
+                    findings, "high", "hardcoded-secret",
+                    "疑似硬编码凭据；改用环境变量或受管密钥，并立即轮换已暴露的值。",
+                    number, line,
+                )
+            if cls._SHELL_TRUE.search(line):
+                cls._append(
+                    findings, "high", "shell-true",
+                    "shell=True 会把不可信输入交给 shell 解释；改用参数列表和严格的输入校验。",
+                    number, line,
+                )
+            if cls._EVAL_EXEC.search(line):
+                cls._append(
+                    findings, "high", "dynamic-execution",
+                    "eval/exec 可执行不可信文本；使用受限解析器或显式分发表。",
+                    number, line,
+                )
+            if cls._PICKLE.search(line):
+                cls._append(
+                    findings, "high", "unsafe-deserialization",
+                    "pickle 反序列化不可信数据可执行任意代码；改用 JSON 或签名的可信工件。",
+                    number, line,
+                )
+            if cls._UNSAFE_YAML.search(line) and "Loader=" not in line:
+                cls._append(
+                    findings, "high", "unsafe-yaml-load",
+                    "yaml.load 未指定安全 Loader；使用 yaml.safe_load。",
+                    number, line,
+                )
+            if cls._TLS_DISABLED.search(line):
+                cls._append(
+                    findings, "high", "tls-verification-disabled",
+                    "TLS 证书校验被关闭；除受控测试外不得使用 verify=False。",
+                    number, line,
+                )
+
+    @classmethod
+    def review_source(
+        cls,
+        source: str,
+        *,
+        filename: str = "snippet.py",
+        language: str = "python",
+        is_diff: bool = False,
+    ) -> List[CodeReviewFinding]:
+        """Review source text or an already-provided diff without touching disk."""
+        if not isinstance(source, str) or not source.strip():
+            return [CodeReviewFinding("medium", "empty-input", "没有可审查的代码内容。", None, "")]
+        if len(source) > cls.MAX_SOURCE_CHARS:
+            return [CodeReviewFinding(
+                "medium", "input-truncated",
+                f"审查输入超过 {cls.MAX_SOURCE_CHARS} 字符；请按文件或提交拆分后复查。",
+                None, "",
+            )]
+
+        findings: List[CodeReviewFinding] = []
+        lines = source.splitlines()
+        scan_lines = [line[1:] for line in lines if line.startswith("+") and not line.startswith("+++")] if is_diff else lines
+        cls._scan_lines(scan_lines, findings)
+
+        inferred_python = language.lower() in {"py", "python"} or cls._safe_filename(filename).endswith(".py")
+        if inferred_python and not is_diff:
+            try:
+                tree = ast.parse(source, filename=cls._safe_filename(filename))
+            except SyntaxError as exc:
+                cls._append(
+                    findings, "critical", "python-syntax-error",
+                    "Python 代码无法解析，运行前会失败。",
+                    exc.lineno, (exc.text or "").strip(),
+                )
+            else:
+                for node in ast.walk(tree):
+                    if isinstance(node, ast.ExceptHandler) and node.type is None:
+                        cls._append(
+                            findings, "medium", "bare-except",
+                            "裸 except 会吞掉系统退出和中断；至少捕获 Exception，并记录或处理错误。",
+                            node.lineno, "except:",
+                        )
+
+        unique = {(item.rule, item.line, item.evidence): item for item in findings}
+        return sorted(unique.values(), key=lambda item: (cls._SEVERITY_ORDER[item.severity], item.line or 0, item.rule))
+
+    @classmethod
+    def format_findings(cls, findings: List[CodeReviewFinding]) -> str:
+        if not findings:
+            return "确定性检查未发现已覆盖规则中的问题；仍需执行测试并进行语义审查。"
+        rows = []
+        for finding in findings:
+            location = f"第 {finding.line} 行" if finding.line else "输入级"
+            rows.append(f"[{finding.severity.upper()}] {location} {finding.rule}: {finding.message}")
+        return "\n".join(rows)
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        source = str(data.get("source") or data.get("content") or data.get("diff") or "")
+        filename = self._safe_filename(str(data.get("filename") or symbol or "snippet.py"))
+        findings = self.review_source(
+            source,
+            filename=filename,
+            language=str(data.get("language") or "python"),
+            is_diff=bool(data.get("is_diff")),
+        )
+        return AgentResult(
+            agent=self.name,
+            symbol=filename,
+            analysis=self.format_findings(findings),
+            confidence=0.99 if source else 0.0,
+            signal="HOLD",
+            key_points=[f"{item.severity}: {item.rule}" for item in findings[:8]],
+            data_used={"filename": filename, "finding_count": len(findings)},
+            degraded=False,
+            provenance=["deterministic_static_review"],
+            limitations=["只审查调用方提供的文本；不会读取文件、执行命令或运行测试。"],
+        )

aria_code-4.4.0/agents/financial/debate.py

@@ -0,0 +1,224 @@
+"""
+agents/financial/debate.py — 信号争议调解 Agent
+================================================
+当多个 Agent 出现真实分歧（看涨 vs 看跌）时，
+DebateAgent 作为"裁判"对冲突进行分析，输出综合判断。
+不独立运行，由 AgentTeam 在检测到分歧时自动触发。
+
+2026-08 领域词汇修正：这个 agent 原本把金融的 BUY/HOLD/SELL 硬编码在
+system prompt、信号解析和模板兜底里，但 AgentTeam 对**所有**领域都会在
+信号冲突时触发它——实测跑 warehouse 团队（GOOD/WATCH/CONCERN/SEVERE）
+时，它往结果里塞了一个 "HOLD"，正是 signal_scheme.py 开头警告过的那种
+"借用金融词汇表达完全不同含义"。表决层没被污染（SignalScheme.vote()
+会过滤掉不在本领域词表里的信号），但报告界面上会多出一张语义不搭的卡片，
+而且裁判意见实际上没参与最终结论 —— 等于白跑一趟。
+
+现在 team.py 会把当前领域的 SignalScheme 通过 data["signal_scheme"]
+传进来，本文件所有词汇都从 scheme 里取。不传时默认 FINANCIAL_SCHEME，
+所以单独调用 DebateAgent 的既有金融调用方行为完全不变。
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List
+
+from ..base import BaseAgent, AgentResult
+from ..signal_scheme import FINANCIAL_SCHEME, SignalScheme
+
+logger = logging.getLogger(__name__)
+
+
+class DebateAgent(BaseAgent):
+
+    name        = "debate"
+    description = "信号争议调解 — 当多 Agent 信号冲突时自动触发，输出裁判视角"
+
+    _SYSTEM_FINANCIAL = (
+        "You are a senior investment committee chair mediating a dispute between "
+        "analysts who have conflicting views on a stock. Your role is to:\n"
+        "1. Identify the core disagreement\n"
+        "2. Evaluate which side has stronger evidence\n"
+        "3. Determine the dominant factor (macro vs technical vs fundamental)\n"
+        "4. Provide a nuanced resolution that acknowledges both sides\n"
+        "5. Conclude with a clear signal: {vocabulary} and the primary reason\n"
+        "Be direct. Avoid empty hedging. Make a call."
+    )
+
+    _SYSTEM_GENERIC = (
+        "You are the senior reviewer mediating a dispute between specialist "
+        "analysts who reached conflicting conclusions about the same subject. "
+        "Your role is to:\n"
+        "1. Identify the core disagreement\n"
+        "2. Evaluate which side has stronger evidence\n"
+        "3. Determine which dimension dominates the overall assessment\n"
+        "4. Provide a nuanced resolution that acknowledges both sides\n"
+        "5. Conclude with a clear signal: {vocabulary} and the primary reason\n"
+        "Be direct. Avoid empty hedging. Make a call."
+    )
+
+    def _system_prompt(self, scheme: SignalScheme) -> str:
+        # 只有金融领域保留"投资委员会主席"这个具体身份设定；其它领域用中性
+        # 措辞——让仓储/地产的裁判自称投资委员会主席，会把 LLM 往错误的
+        # 推理框架上带（比如去权衡"要不要建仓"而不是"这个仓库健不健康"）。
+        template = self._SYSTEM_FINANCIAL if scheme.name == "financial" else self._SYSTEM_GENERIC
+        return template.format(vocabulary=" / ".join(_ranked_vocabulary(scheme)))
+
+    async def fetch_data(self, symbol: str) -> Dict[str, Any]:
+        return await super().fetch_data(symbol)
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        conflicting: List[Dict] = data.get("conflicting", [])
+        scheme: SignalScheme = data.get("signal_scheme") or FINANCIAL_SCHEME
+
+        if not conflicting:
+            return AgentResult(
+                agent=self.name, symbol=symbol,
+                analysis="无冲突结果可调解。",
+                confidence=0.3, signal=scheme.neutral_default,
+                key_points=["无需调解"],
+            )
+
+        debate_block = _format_conflict(conflicting, scheme)
+        vocabulary = " / ".join(_ranked_vocabulary(scheme))
+        subject_line = f"Stock: {symbol}" if scheme.name == "financial" else f"Subject: {symbol}"
+        dominant_q = (
+            "What is the dominant factor driving the stock right now? "
+            if scheme.name == "financial"
+            else "Which dimension dominates the overall assessment right now? "
+        )
+
+        prompt = (
+            f"{subject_line}\n\n"
+            f"Conflicting Analyst Views:\n{debate_block}\n\n"
+            "Mediate this dispute. Which view is more compelling and why? "
+            f"{dominant_q}"
+            f"End with: Signal: {vocabulary} — [primary reason in one line]"
+        )
+
+        analysis = await self._call_llm(self._system_prompt(scheme), prompt, max_tokens=600)
+        if not analysis:
+            analysis = _template_resolution(symbol, conflicting, scheme)
+
+        signal     = _extract_signal(analysis, scheme)
+        confidence = _estimate_confidence(conflicting)
+        key_points = _build_key_points(conflicting, analysis, scheme)
+
+        return AgentResult(
+            agent=self.name, symbol=symbol,
+            analysis=analysis,
+            confidence=confidence,
+            signal=signal,
+            key_points=key_points,
+            data_used={"conflict_count": len(conflicting)},
+        )
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _ranked_vocabulary(scheme: SignalScheme) -> List[str]:
+    """按分数从高到低列出该领域的信号词，供 prompt 展示。"""
+    return [name for name, _ in sorted(scheme.scores.items(), key=lambda kv: -kv[1])]
+
+
+def _format_conflict(results: List[Dict], scheme: SignalScheme = FINANCIAL_SCHEME) -> str:
+    lines = []
+    for r in results:
+        agent   = r.get("agent", "unknown")
+        signal  = r.get("signal", scheme.neutral_default)
+        conf    = r.get("confidence", 0)
+        pts     = r.get("key_points", [])
+        summary = "; ".join(pts[:3]) if pts else r.get("analysis", "")[:150]
+        lines.append(
+            f"  [{agent.upper()}] Signal: {signal} (conf {conf:.0%})\n"
+            f"    Key points: {summary}"
+        )
+    return "\n".join(lines)
+
+
+def _extract_signal(analysis: str, scheme: SignalScheme = FINANCIAL_SCHEME) -> str:
+    """从裁判文本里解析出本领域词汇表中的信号。
+
+    长词优先匹配（STRONG_BUY 必须排在 BUY 前面，否则 "STRONG_BUY" 会被
+    "BUY" 的前缀判定抢先命中；这是原实现手写四个 if 的顺序想表达的意思，
+    改成按长度排序后对任意领域词汇表都成立，不用每加一个领域重写一遍）。
+    """
+    text = analysis.upper()
+    vocabulary = sorted(scheme.scores, key=len, reverse=True)
+
+    for marker in ("SIGNAL: ", "SIGNAL:", "CONCLUSION:", "CONCLUSION: "):
+        idx = text.find(marker)
+        if idx != -1:
+            remainder = text[idx + len(marker):].strip()
+            for name in vocabulary:
+                if remainder.startswith(name.upper()):
+                    return name
+
+    # 没有显式 marker 时的兜底：只在文本里恰好出现一个方向的词汇时才采信，
+    # 出现多个方向说明裁判没给出明确结论，退回中性值而不是猜。
+    positives = [s for s in scheme.positive_signals if s.upper() in text]
+    negatives = [s for s in scheme.negative_signals if s.upper() in text]
+    if positives and not negatives:
+        return max(positives, key=lambda s: scheme.scores.get(s, 0))
+    if negatives and not positives:
+        return min(negatives, key=lambda s: scheme.scores.get(s, 0))
+    return scheme.neutral_default
+
+
+def _estimate_confidence(results: List[Dict]) -> float:
+    if not results:
+        return 0.4
+    confs = [r.get("confidence", 0.5) for r in results if r.get("confidence")]
+    avg   = sum(confs) / len(confs) if confs else 0.5
+    return round(min(avg * 0.9, 0.75), 2)
+
+
+def _side_labels(scheme: SignalScheme) -> tuple[str, str]:
+    """(正面阵营, 负面阵营) 的中文标签。金融叫多空，其它领域这么叫没有意义
+    ——仓储团队里没有"看跌方"，只有"报告健康"和"报告有问题"的两拨 agent。"""
+    if scheme.name == "financial":
+        return "看涨方", "看跌方"
+    return "正面评估", "负面评估"
+
+
+def _split_sides(results: List[Dict], scheme: SignalScheme) -> tuple[List[Dict], List[Dict]]:
+    positive = [r for r in results if r.get("signal") in scheme.positive_signals]
+    negative = [r for r in results if r.get("signal") in scheme.negative_signals]
+    return positive, negative
+
+
+def _build_key_points(
+    results: List[Dict], analysis: str, scheme: SignalScheme = FINANCIAL_SCHEME
+) -> List[str]:
+    positive, negative = _split_sides(results, scheme)
+    pos_label, neg_label = _side_labels(scheme)
+    points  = []
+    if positive:
+        points.append(f"{pos_label}: {', '.join(r['agent'] for r in positive)}")
+    if negative:
+        points.append(f"{neg_label}: {', '.join(r['agent'] for r in negative)}")
+    points.append("DebateAgent 已介入调解")
+    points.append(f"裁判结论: {_extract_signal(analysis, scheme)}")
+    return points
+
+
+def _template_resolution(
+    symbol: str, results: List[Dict], scheme: SignalScheme = FINANCIAL_SCHEME
+) -> str:
+    positive, negative = _split_sides(results, scheme)
+    pos_label, neg_label = _side_labels(scheme)
+
+    best = max(scheme.scores, key=lambda s: scheme.scores[s])
+    worst = min(scheme.scores, key=lambda s: scheme.scores[s])
+    if len(positive) > len(negative):
+        resolution = f"{best} — 多数{pos_label}信号占优"
+    elif len(negative) > len(positive):
+        resolution = f"{worst} — 多数{neg_label}信号占优"
+    else:
+        resolution = f"{scheme.neutral_default} — 双方力量均衡，建议观望"
+    return (
+        f"{symbol} 信号冲突调解报告\n"
+        f"{pos_label}: {', '.join(r['agent'] for r in positive) or '无'}\n"
+        f"{neg_label}: {', '.join(r['agent'] for r in negative) or '无'}\n"
+        f"裁判结论: Signal: {resolution}"
+    )

{aria_code-4.3.0 → aria_code-4.4.0}/agents/financial/fundamental.py

@@ -6,11 +6,15 @@ agents/financial/fundamental.py — 基本面分析 Agent
 from __future__ import annotations
 import os
 import sys
+from pathlib import Path
 from typing import Any, Dict, List, Optional
 from ..base import BaseAgent, AgentResult
 
 # 动态加载 aria_tools 中的 MCP 工具
-sys.path.append("/Users/mac/Desktop/aria-code/packages")
+# 相对本文件定位同仓库的 packages/，不写死开发者本机路径
+_PKGS = str(Path(__file__).resolve().parents[2] / "packages")
+if _PKGS not in sys.path:
+    sys.path.append(_PKGS)
 try:
     from aria_tools.financial.factors import run_factor_research
 except ImportError:

{aria_code-4.3.0 → aria_code-4.4.0}/agents/financial/risk.py

@@ -16,10 +16,14 @@ except ImportError:
 
 import os
 import sys
+from pathlib import Path
 import asyncio
 
 # 动态加载 aria_tools 中的 MCP 工具
-sys.path.append("/Users/mac/Desktop/aria-code/packages")
+# 相对本文件定位同仓库的 packages/，不写死开发者本机路径
+_PKGS = str(Path(__file__).resolve().parents[2] / "packages")
+if _PKGS not in sys.path:
+    sys.path.append(_PKGS)
 try:
     from aria_tools.financial.risk_tools import run_risk_profile
 except ImportError:

{aria_code-4.3.0 → aria_code-4.4.0}/agents/team.py

@@ -276,7 +276,13 @@ class AgentTeam:
         if explicit_debate or self.signal_scheme.needs_debate(results):
             debate_agent = self._build_agent("debate")
             if debate_agent:
-                debate_data = {"conflicting": [r.to_dict() for r in results if r.success]}
+                debate_data = {
+                    "conflicting": [r.to_dict() for r in results if r.success],
+                    # 领域词汇表要一起传：DebateAgent 默认说金融的 BUY/HOLD/SELL，
+                    # 不告诉它当前领域用什么词，它产出的信号会被 vote() 过滤掉
+                    # （不在 scores 里），等于裁判意见完全不参与最终结论。
+                    "signal_scheme": self.signal_scheme,
+                }
                 try:
                     debate_result = await asyncio.wait_for(
                         debate_agent.analyze(symbol, debate_data),