aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/agents/realty/ops_optimize.py

@@ -0,0 +1,160 @@
+"""
+agents/realty/ops_optimize.py — 运营提升 Agent
+===============================================
+分析坪效、客流、商品排行、活动效果，提出经营优化建议。
+
+输入数据（data dict keys）:
+    project_info    — 项目基本信息（面积/业态/开业时间）
+    performance_data — 经营绩效数据（坪效/客流/流水趋势/商品排行）
+    marketing_data  — 营销活动数据（会员/优惠券/外卖/团购）
+    peer_benchmarks — 同业基准数据（可选）
+
+输出:
+    analysis    — 运营优化建议
+    signal      — GOOD=经营健康/高潜力 / WATCH=有改善空间 / CONCERN=经营不佳 / SEVERE=急需干预
+                  （地产健康度尺度，见 signal_scheme.py）
+    key_points  — Top3 优化建议
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+from ..base import BaseAgent, AgentResult
+
+
+class OpsOptimizeAgent(BaseAgent):
+    name        = "ops_optimize"
+    description = "运营提升：分析坪效/客流/营销效果，提出招商补位和经营优化建议"
+
+    _SYSTEM = (
+        "你是一名资深的商业空间运营顾问，专注于帮助经营方提升业绩。\n"
+        "请基于以下经营数据给出针对性的优化建议：\n"
+        "  1. 坪效分析（当前坪效 vs 行业基准，提升空间）\n"
+        "  2. 客流优化（高峰时段利用率、低谷期激活策略）\n"
+        "  3. 商品/品类优化（畅销/滞销商品，品类结构调整）\n"
+        "  4. 营销活动效果评估（会员召回、优惠券核销率、外卖占比）\n"
+        "  5. 营业时间优化建议\n"
+        "  6. 招商补位建议（空置面积是否可引入互补业态）\n"
+        "  7. 优先级最高的3项具体可执行建议（含预期效果）"
+    )
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        project  = data.get("project_info", {})
+        perf     = data.get("performance_data", {})
+        marketing= data.get("marketing_data", {})
+        bench    = data.get("peer_benchmarks", {})
+
+        metrics = _calc_metrics(project, perf, marketing, bench)
+
+        user_prompt = (
+            f"项目信息：{project.get('name','未命名')} "
+            f"({project.get('area',0)}m²  {project.get('business_type','未知业态')})\n"
+            f"开业: {project.get('open_date','未知')}\n\n"
+            f"经营绩效：\n"
+            f"  月均流水: {perf.get('monthly_revenue',0):,.2f}元\n"
+            f"  坪效: {metrics['revenue_per_sqm']:.1f}元/m²/月  行业基准: {bench.get('revenue_per_sqm',300):.1f}\n"
+            f"  日均客流: {perf.get('daily_visits',0):.0f}人次  转化率: {metrics['conversion_rate']:.1%}\n"
+            f"  会员复购率: {marketing.get('member_repurchase_pct',0):.1f}%\n"
+            f"  外卖收入占比: {metrics['delivery_pct']:.1f}%\n"
+            f"  优惠券核销率: {marketing.get('coupon_redemption_pct',0):.1f}%\n\n"
+            f"Top10商品: {perf.get('top_products', [])[:5]}\n"
+            f"垫底商品: {perf.get('bottom_products', [])[:3]}\n\n"
+            "请给出运营优化建议。"
+        )
+
+        analysis = await self._call_llm(self._SYSTEM, user_prompt, max_tokens=700)
+        if not analysis:
+            analysis = _template_ops(metrics, perf, marketing, bench)
+
+        signal     = _ops_signal(metrics, bench)
+        confidence = _ops_confidence(perf, marketing)
+        key_points = _ops_key_points(metrics, perf, marketing, bench)
+
+        return AgentResult(
+            agent      = self.name,
+            symbol     = symbol,
+            analysis   = analysis,
+            confidence = confidence,
+            signal     = signal,
+            key_points = key_points,
+            data_used  = {"metrics": metrics},
+        )
+
+
+# ── 辅助逻辑 ──────────────────────────────────────────────────────────────────
+
+def _calc_metrics(project: Dict, perf: Dict, marketing: Dict, bench: Dict) -> Dict:
+    area     = project.get("area", 1)
+    revenue  = perf.get("monthly_revenue", 0)
+    visits   = perf.get("daily_visits", 0) * 30
+    orders   = perf.get("monthly_orders", 0)
+    delivery = marketing.get("delivery_revenue", 0)
+
+    return {
+        "revenue_per_sqm":  revenue / area if area else 0,
+        "conversion_rate":  orders / visits if visits else 0,
+        "delivery_pct":     delivery / revenue * 100 if revenue else 0,
+        "bench_psm":        bench.get("revenue_per_sqm", 300),
+        "psm_gap_pct":      (revenue / area - bench.get("revenue_per_sqm", 300))
+                            / bench.get("revenue_per_sqm", 300) * 100 if area else 0,
+    }
+
+
+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 "WATCH"
+    ratio = psm / bench_psm
+    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:
+    has = sum([
+        1 if perf.get("monthly_revenue") else 0,
+        1 if perf.get("daily_visits")    else 0,
+        1 if marketing.get("member_count") else 0,
+        1 if perf.get("top_products")    else 0,
+    ])
+    return round(0.5 + 0.1 * has, 2)
+
+
+def _ops_key_points(metrics: Dict, perf: Dict, marketing: Dict, bench: Dict) -> List[str]:
+    pts = []
+    psm = metrics.get("revenue_per_sqm", 0)
+    bench_psm = metrics.get("bench_psm", 300)
+
+    pts.append(f"坪效: {psm:.1f}元/m²/月  行业基准: {bench_psm:.1f}  差距: {metrics['psm_gap_pct']:+.1f}%")
+    pts.append(f"转化率: {metrics['conversion_rate']:.1%}  外卖占比: {metrics['delivery_pct']:.1f}%")
+
+    if psm < bench_psm * 0.7:
+        pts.append("坪效显著低于基准，建议重新评估业态或开展营销活动")
+    if marketing.get("coupon_redemption_pct", 50) < 20:
+        pts.append("优惠券核销率低，营销触达效果需改善")
+    if marketing.get("member_repurchase_pct", 0) < 30:
+        pts.append("会员复购率偏低，建议加强会员运营和精准推送")
+    return pts[:5]
+
+
+def _template_ops(metrics: Dict, perf: Dict, marketing: Dict, bench: Dict) -> str:
+    psm = metrics.get("revenue_per_sqm", 0)
+    bench_psm = metrics.get("bench_psm", 300)
+    gap = metrics.get("psm_gap_pct", 0)
+
+    recs = []
+    if psm < bench_psm:
+        recs.append("1. 引入高客单价品类或体验型业态，提升坪效")
+    if metrics.get("delivery_pct", 0) < 20:
+        recs.append("2. 开通美团/饿了么外卖渠道，提高营业时段覆盖")
+    if marketing.get("member_count", 0) < 500:
+        recs.append("3. 启动会员招募计划，目标500+活跃会员")
+    recs.append("4. 分析低峰时段，设计限时优惠活动激活非高峰客流")
+
+    return (
+        f"运营提升建议（模板）：\n"
+        f"  坪效: {psm:.1f}元/m²/月（{'+' if gap >= 0 else ''}{gap:.1f}% vs 行业）\n"
+        f"  转化率: {metrics['conversion_rate']:.1%}  外卖占比: {metrics['delivery_pct']:.1f}%\n\n"
+        f"优化建议：\n"
+        + "\n".join(f"  {r}" for r in recs)
+    )

aria_code/agents/realty/revenue_share.py

@@ -0,0 +1,215 @@
+"""
+agents/realty/revenue_share.py — 分账规则 Agent
+================================================
+根据合同规则和实际流水，计算各方收益并生成分账配置建议。
+
+输入数据（data dict keys）:
+    contract_rules  — 合同规则（保底/分润比例/阶梯/服务费/风险准备金等）
+    transaction_data — 本期实际流水数据（总流水/支付渠道明细/退款等）
+    accounts        — 各方收款账户信息（可选，用于分账配置验证）
+
+输出:
+    analysis    — 分账计算说明文本
+    signal      — GOOD=分账正常 / WATCH=有补足情况 / CONCERN=流水勉强覆盖 / SEVERE=流水严重不足
+                  （地产健康度尺度，见 signal_scheme.py）
+    key_points  — 各方金额摘要
+    data_used   — 包含 split_result（可直接入库）
+"""
+from __future__ import annotations
+
+from decimal import Decimal, ROUND_HALF_UP
+from typing import Any, Dict, List
+from ..base import BaseAgent, AgentResult
+
+
+class RevenueShareAgent(BaseAgent):
+    name        = "revenue_share"
+    description = "分账规则：根据合同和实际流水计算各方应得金额，生成分账配置建议"
+
+    _SYSTEM = (
+        "你是一名分账与财务核算专家，专注于不动产经营权共创模式下的收益分配。\n"
+        "请对分账计算结果进行解读和说明：\n"
+        "  1. 说明本期各方应得金额的计算过程（分润基数→分润金额→保底补足→扣除项）\n"
+        "  2. 分析流水与保底的差距，判断经营状态（正常/偏低/严重不足）\n"
+        "  3. 如有阶梯分成被触发，解释阶梯规则的执行情况\n"
+        "  4. 给出本期结算的注意事项或风险提示\n"
+        "  5. 对下期经营给出1-2条改善建议"
+    )
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        rules = data.get("contract_rules", {})
+        txn   = data.get("transaction_data", {})
+        accts = data.get("accounts", {})
+
+        split = _calculate_split(rules, txn)
+
+        user_prompt = (
+            f"本期分账计算结果：\n"
+            f"  实际总流水: {split['gross_revenue']:,.2f}元\n"
+            f"  参与分润流水: {split['net_revenue']:,.2f}元\n"
+            f"  保底金额: {split['guaranteed']:,.2f}元\n"
+            f"  分润比例: {split['share_pct']}%\n"
+            f"  资产方分润金额: {split['owner_share']:,.2f}元\n"
+            f"  保底补足金额: {split['top_up']:,.2f}元（需经营方补缴）\n"
+            f"  资产方实得: {split['owner_total']:,.2f}元\n"
+            f"  平台服务费: {split['platform_fee']:,.2f}元\n"
+            f"  风险准备金: {split['risk_reserve']:,.2f}元\n"
+            f"  经营方实得: {split['operator_net']:,.2f}元\n"
+            f"  结算周期: {rules.get('settlement_cycle','月结')}\n\n"
+            f"合同规则: 保底{rules.get('guaranteed_monthly',0):,}元/月, "
+            f"流水分润{rules.get('revenue_share_pct',0)}%, "
+            f"平台{rules.get('platform_fee_pct',5)}%, "
+            f"风险准备金{rules.get('risk_reserve_pct',3)}%\n\n"
+            "请对以上分账结果进行解读和说明。"
+        )
+
+        analysis = await self._call_llm(self._SYSTEM, user_prompt, max_tokens=600)
+        if not analysis:
+            analysis = _template_split_analysis(split, rules)
+
+        signal     = _split_signal(split)
+        confidence = 0.95  # 分账计算是确定性逻辑，置信度高
+        key_points = _split_key_points(split)
+
+        return AgentResult(
+            agent      = self.name,
+            symbol     = symbol,
+            analysis   = analysis,
+            confidence = confidence,
+            signal     = signal,
+            key_points = key_points,
+            data_used  = {"split_result": split, "contract_rules": rules},
+        )
+
+
+# ── 核心计算逻辑（Decimal精度） ────────────────────────────────────────────────
+
+def _calculate_split(rules: Dict, txn: Dict) -> Dict:
+    """
+    分账计算（精确到分）
+
+    分配顺序:
+        1. 从总流水中扣除: 平台服务费 + 风险准备金 + 退款
+        2. 剩余净流水 vs 分润基数 → 计算资产方分润
+        3. 资产方分润 vs 保底 → 计算保底补足
+        4. 经营方实得 = 净流水 - 资产方总收益 - 平台费 - 风险准备金
+    """
+    D = Decimal
+
+    gross        = D(str(txn.get("gross_revenue", 0)))
+    refunds      = D(str(txn.get("refunds", 0)))
+    guaranteed   = D(str(rules.get("guaranteed_monthly", 0)))
+    share_pct    = D(str(rules.get("revenue_share_pct", 0))) / D("100")
+    base_revenue = D(str(rules.get("revenue_share_base", 0)))
+    platform_pct = D(str(rules.get("platform_fee_pct", 5))) / D("100")
+    reserve_pct  = D(str(rules.get("risk_reserve_pct", 3))) / D("100")
+
+    # 各扣除项
+    net_revenue   = gross - refunds
+    platform_fee  = (net_revenue * platform_pct).quantize(D("0.01"), ROUND_HALF_UP)
+    risk_reserve  = (net_revenue * reserve_pct).quantize(D("0.01"), ROUND_HALF_UP)
+    distributable = net_revenue - platform_fee - risk_reserve
+
+    # 资产方分润（超出分润基数部分 * 分润比例）
+    shareable_revenue = max(D("0"), distributable - base_revenue)
+    owner_share       = (shareable_revenue * share_pct).quantize(D("0.01"), ROUND_HALF_UP)
+
+    # 保底补足（若分润不足保底，经营方须补足）
+    top_up = max(D("0"), guaranteed - owner_share)
+
+    owner_total    = owner_share + top_up
+    operator_net   = distributable - owner_total
+
+    # 阶梯分成（如有）
+    tiered_triggered = _apply_tiered(rules.get("tiered_rules", []), net_revenue)
+
+    return {
+        "gross_revenue":    float(gross),
+        "refunds":          float(refunds),
+        "net_revenue":      float(net_revenue),
+        "platform_fee":     float(platform_fee),
+        "risk_reserve":     float(risk_reserve),
+        "distributable":    float(distributable),
+        "guaranteed":       float(guaranteed),
+        "share_pct":        float(rules.get("revenue_share_pct", 0)),
+        "owner_share":      float(owner_share),
+        "top_up":           float(top_up),
+        "owner_total":      float(owner_total),
+        "operator_net":     float(operator_net),
+        "tiered_triggered": tiered_triggered,
+    }
+
+
+def _apply_tiered(tiered_rules: List[Dict], revenue: Decimal) -> List[Dict]:
+    """计算触发的阶梯分成规则"""
+    triggered = []
+    for rule in tiered_rules:
+        threshold = Decimal(str(rule.get("threshold", 0)))
+        pct       = rule.get("pct", 0)
+        if revenue >= threshold:
+            triggered.append({"threshold": float(threshold), "pct": pct,
+                               "status": "triggered"})
+        else:
+            triggered.append({"threshold": float(threshold), "pct": pct,
+                               "status": "not_triggered"})
+    return triggered
+
+
+def _split_signal(split: Dict) -> str:
+    net        = split.get("net_revenue", 0)
+    guaranteed = split.get("guaranteed", 0)
+    op_net     = split.get("operator_net", 0)
+
+    if guaranteed <= 0:  return "WATCH"
+    coverage = net / guaranteed if guaranteed else 0
+    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:
+    """根据分账结果给出人读友好状态描述"""
+    top_up   = split.get("top_up", 0)
+    op_net   = split.get("operator_net", 0)
+    guaranteed = split.get("guaranteed", 0)
+    if top_up == 0:
+        return "流水分润超过保底，经营状况良好"
+    if op_net >= guaranteed * 0.5:
+        return "保底兜底生效（属正常），经营方净收入尚可"
+    if op_net > 0:
+        return "保底兜底生效，经营方净收入偏低，建议持续关注"
+    return "经营方净收入为负，无法自覆保底，需紧急处置"
+
+
+def _split_key_points(split: Dict) -> List[str]:
+    pts = []
+    pts.append(f"本期总流水: {split['gross_revenue']:,.2f}元")
+    pts.append(f"资产方实得: {split['owner_total']:,.2f}元"
+               + (f"（含补足{split['top_up']:,.2f}元）" if split['top_up'] > 0 else ""))
+    pts.append(f"经营方实得: {split['operator_net']:,.2f}元")
+    pts.append(f"平台服务费: {split['platform_fee']:,.2f}元  风险准备金: {split['risk_reserve']:,.2f}元")
+    if split.get("top_up", 0) > 0:
+        pts.append(f"保底补足: {split['top_up']:,.2f}元（需经营方在结算日前缴纳）")
+    return pts
+
+
+def _template_split_analysis(split: Dict, rules: Dict) -> str:
+    top_up_line = (
+        "保底补足: {:,.2f}元（须补缴）".format(split['top_up'])
+        if split['top_up'] > 0 else "流水覆盖保底，无需补足"
+    )
+    return (
+        f"分账计算说明（模板）：\n"
+        f"  本期总流水: {split['gross_revenue']:,.2f}元  退款: {split['refunds']:,.2f}元\n"
+        f"  净流水: {split['net_revenue']:,.2f}元\n"
+        f"  平台服务费 ({rules.get('platform_fee_pct',5)}%): -{split['platform_fee']:,.2f}元\n"
+        f"  风险准备金 ({rules.get('risk_reserve_pct',3)}%): -{split['risk_reserve']:,.2f}元\n"
+        f"  可分配金额: {split['distributable']:,.2f}元\n"
+        f"  资产方分润: {split['owner_share']:,.2f}元\n"
+        f"  保底收益: {split['guaranteed']:,.2f}元\n"
+        f"  {top_up_line}\n"
+        f"  资产方实得: {split['owner_total']:,.2f}元\n"
+        f"  经营方实得: {split['operator_net']:,.2f}元\n"
+        f"  状态: {_split_status(split)}"
+    )

aria_code/agents/registry.py

@@ -0,0 +1,168 @@
+"""
+agents/registry.py — Agent 注册与自动发现
+==========================================
+1. 内置 agent 预注册（technical / fundamental / macro / risk）
+2. 扫描 ./aria_agents/ → 自动注册用户自定义 agent
+3. 提供 get() / list() / register() 接口
+
+自定义 Agent 放置规则:
+    项目根/aria_agents/my_agent.py
+    类需继承 BaseAgent，且声明 name 属性
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import inspect
+import logging
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional, Type
+
+from .base import BaseAgent
+from .financial.technical import TechnicalAgent
+
+logger = logging.getLogger(__name__)
+
+# ── 内置 agent 预注册 ─────────────────────────────────────────────────────────
+_BUILTIN: Dict[str, Type[BaseAgent]] = {
+    "technical": TechnicalAgent,
+}
+
+# 尝试加载其他内置 agent（文件存在则注册）
+# The package this module was loaded as: "aria_code.agents", or "agents" when the
+# CLI's bare import root is in use. The built-ins were imported by the fixed
+# name "aria_code.agents.…" — a second copy of the package under the other
+# root, whose classes subclass a different BaseAgent. issubclass() then said
+# no and they were dropped without a word: /team announced four analysts and
+# only "technical" (imported relatively, above) ever ran.
+_PACKAGE = __package__ or "aria_code.agents"
+
+
+def _try_import_builtin(module_path: str, name: str) -> None:
+    if module_path.startswith("aria_code.agents."):
+        module_path = _PACKAGE + module_path[len("aria_code.agents"):]
+    try:
+        mod = importlib.import_module(module_path)
+        for _, cls in inspect.getmembers(mod, inspect.isclass):
+            if issubclass(cls, BaseAgent) and cls is not BaseAgent:
+                _BUILTIN[cls.name] = cls
+    except ImportError:
+        pass
+
+
+_try_import_builtin("aria_code.agents.financial.macro",       "macro")
+_try_import_builtin("aria_code.agents.financial.fundamental",  "fundamental")
+_try_import_builtin("aria_code.agents.financial.risk",         "risk")
+_try_import_builtin("aria_code.agents.financial.synthesis",    "synthesis")
+_try_import_builtin("aria_code.agents.financial.news",         "news")
+_try_import_builtin("aria_code.agents.financial.catalyst",     "catalyst")
+_try_import_builtin("aria_code.agents.financial.debate",       "debate")
+_try_import_builtin("aria_code.agents.financial.earnings",     "earnings")
+_try_import_builtin("aria_code.agents.financial.sector",       "sector")
+_try_import_builtin("aria_code.agents.financial.strategist",   "strategist")
+_try_import_builtin("aria_code.agents.engineering.coder",      "coder")
+_try_import_builtin("aria_code.agents.engineering.tester",     "tester")
+_try_import_builtin("aria_code.agents.financial.corporate_finance", "corporate_finance")
+_try_import_builtin("aria_code.agents.financial.cashflow_burn",     "cashflow_burn")
+_try_import_builtin("aria_code.agents.financial.stripe_revenue",    "stripe_revenue")
+_try_import_builtin("aria_code.agents.portfolio_agent",        "portfolio")
+_try_import_builtin("aria_code.agents.supervisor",             "supervisor")
+
+# ── 经营权共创平台 Agent 包 ────────────────────────────────────────────────────
+_try_import_builtin("aria_code.agents.realty.asset_diagnosis",  "asset_diagnosis")
+_try_import_builtin("aria_code.agents.realty.business_match",   "business_match")
+_try_import_builtin("aria_code.agents.realty.contract_rules",   "contract_rules")
+_try_import_builtin("aria_code.agents.realty.revenue_share",    "revenue_share")
+_try_import_builtin("aria_code.agents.realty.cashflow_verify",  "cashflow_verify")
+_try_import_builtin("aria_code.agents.realty.energy_anomaly",   "energy_anomaly")
+_try_import_builtin("aria_code.agents.realty.fulfillment_risk", "fulfillment_risk")
+_try_import_builtin("aria_code.agents.realty.ops_optimize",     "ops_optimize")
+_try_import_builtin("aria_code.agents.realty.exit_settlement",  "exit_settlement")
+
+# ── 海外仓与物流供应链 Agent 包 ──────────────────────────────────────────────────
+_try_import_builtin("aria_code.agents.warehouse.logistics_sync", "warehouse_logistics_sync")
+_try_import_builtin("aria_code.agents.warehouse.inbound_exceptions", "warehouse_inbound_exceptions")
+_try_import_builtin("aria_code.agents.warehouse.inventory_health", "warehouse_inventory_health")
+_try_import_builtin("aria_code.agents.warehouse.logistics_cost", "warehouse_logistics_cost")
+_try_import_builtin("aria_code.agents.warehouse.fulfillment_leadtime", "warehouse_fulfillment_leadtime")
+
+
+class AgentRegistry:
+    """
+    Agent 注册中心（单例）。
+
+    用法:
+        registry = get_registry()
+        registry.register(MyAgent)
+        agent_cls = registry.get("my_agent")
+    """
+
+    def __init__(self):
+        self._agents: Dict[str, Type[BaseAgent]] = dict(_BUILTIN)
+        self._scanned = False
+
+    def register(self, cls: Type[BaseAgent]) -> None:
+        """手动注册一个 Agent 类"""
+        if not (isinstance(cls, type) and issubclass(cls, BaseAgent)):
+            raise TypeError(f"{cls} 不是 BaseAgent 子类")
+        self._agents[cls.name] = cls
+        logger.info(f"✓ 注册 Agent: {cls.name}")
+
+    def get(self, name: str) -> Optional[Type[BaseAgent]]:
+        """按名称获取 Agent 类"""
+        self._ensure_scanned()
+        return self._agents.get(name.lower())
+
+    def list(self) -> List[Dict]:
+        """列出所有已注册 Agent"""
+        self._ensure_scanned()
+        return [
+            {"name": name, "description": cls.description, "builtin": name in _BUILTIN}
+            for name, cls in self._agents.items()
+        ]
+
+    def _ensure_scanned(self) -> None:
+        if not self._scanned:
+            self._scan_project()
+            self._scanned = True
+
+    def _scan_project(self) -> None:
+        """扫描当前工作目录及父级的 aria_agents/ 目录"""
+        search_paths = [Path.cwd(), Path.cwd().parent]
+        for base in search_paths:
+            agents_dir = base / "aria_agents"
+            if not agents_dir.is_dir():
+                continue
+            for py_file in sorted(agents_dir.glob("*.py")):
+                if py_file.name.startswith("_"):
+                    continue
+                self._load_file(py_file)
+            break   # 找到第一个 aria_agents/ 即停止向上搜索
+
+    def _load_file(self, path: Path) -> None:
+        """加载一个 .py 文件，自动注册其中的 BaseAgent 子类"""
+        try:
+            spec   = importlib.util.spec_from_file_location(path.stem, path)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            for _, cls in inspect.getmembers(module, inspect.isclass):
+                if (cls.__module__ == module.__name__
+                        and issubclass(cls, BaseAgent)
+                        and cls is not BaseAgent
+                        and hasattr(cls, "name")
+                        and cls.name != "base"):
+                    self._agents[cls.name] = cls
+                    logger.info(f"✓ 自动发现 Agent: {cls.name} ({path.name})")
+        except Exception as e:
+            logger.warning(f"加载 agent 文件 {path} 失败: {e}")
+
+
+# ── 单例 ──────────────────────────────────────────────────────────────────────
+_registry: Optional[AgentRegistry] = None
+
+def get_registry() -> AgentRegistry:
+    global _registry
+    if _registry is None:
+        _registry = AgentRegistry()
+    return _registry

aria_code/agents/signal_scheme.py

@@ -0,0 +1,111 @@
+"""
+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",
+)
+
+# ── 仓储 ERP：同样是运营健康度，不是交易动作 ────────────────────────────────
+# Warehouse agents assess carrier synchronisation, inbound exceptions and stock
+# health.  Keeping a named scheme prevents callers from accidentally applying
+# the financial BUY/HOLD/SELL vote to these operational signals.
+WAREHOUSE_SCHEME = SignalScheme(
+    name="warehouse",
+    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",
+)