aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/agents/portfolio_agent.py

@@ -0,0 +1,392 @@
+"""
+agents/portfolio_agent.py — 组合级分析 Agent
+=============================================
+跨标的分析：相关性矩阵、波动率、集中度风险、再平衡建议。
+数据源：yfinance 1年日线（免费，无需 key）
+触发：/portfolio analyze [symbols…]
+      /portfolio rebalance [symbols…]
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from .base import BaseAgent, AgentResult
+
+logger = logging.getLogger(__name__)
+
+
+class PortfolioAgent(BaseAgent):
+
+    name        = "portfolio"
+    description = "组合级分析 — 相关性、分散度、整体风险、再平衡建议"
+
+    _SYSTEM = (
+        "You are a portfolio risk analyst. Given price history and statistics for "
+        "a portfolio of stocks, your job is to:\n"
+        "1. Evaluate overall portfolio risk (Low / Medium / High)\n"
+        "2. Identify diversification gaps — highly correlated pairs, sector crowding\n"
+        "3. Flag concentration risk if any single position dominates\n"
+        "4. Give 2-3 actionable rebalancing suggestions (be specific: which stocks to "
+        "trim / add / replace and why)\n"
+        "5. End with a one-line verdict: HEALTHY / NEEDS_ATTENTION / HIGH_RISK\n"
+        "Be concrete. Avoid boilerplate."
+    )
+
+    # ── BaseAgent compatibility ───────────────────────────────────────────────
+
+    async def fetch_data(self, symbol: str) -> Dict[str, Any]:
+        symbols = [s.strip().upper() for s in symbol.split(",") if s.strip()]
+        return await self.fetch_portfolio_data(symbols)
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        symbols = data.get("symbols") or [s.strip().upper() for s in symbol.split(",") if s.strip()]
+        return await self.analyze_portfolio(symbols, data)
+
+    # ── Multi-symbol interface ────────────────────────────────────────────────
+
+    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], weights: Optional[Dict[str, float]] = None
+    ) -> Dict[str, Any]:
+        data: Dict[str, Any] = {"symbols": symbols}
+        if len(symbols) < 2:
+            return data
+
+        price_series: Dict[str, Any] = {}
+        latest_prices: Dict[str, float] = {}
+        sector_map: Dict[str, str] = {}
+
+        for sym in symbols:
+            try:
+                import yfinance as yf
+                ticker = yf.Ticker(sym)
+                hist   = ticker.history(period="1y")
+                if not hist.empty and len(hist) > 20:
+                    price_series[sym] = hist["Close"]
+                    latest_prices[sym] = float(hist["Close"].iloc[-1])
+                    # Try to get sector info
+                    try:
+                        info = ticker.info or {}
+                        sector = info.get("sector") or info.get("industry", "")
+                        if sector:
+                            sector_map[sym] = sector
+                    except Exception:
+                        pass
+            except Exception as e:
+                logger.debug("[portfolio] yfinance %s: %s", sym, e)
+
+        if len(price_series) < 2:
+            data["error"] = "insufficient_data"
+            return data
+
+        try:
+            import pandas as pd
+            import numpy as np
+
+            df      = pd.DataFrame(price_series).dropna()
+            returns = df.pct_change().dropna()
+
+            corr        = returns.corr()
+            ann_returns = (returns.mean() * 252).round(4)
+            ann_vols    = (returns.std() * np.sqrt(252)).round(4)
+            cov_matrix  = returns.cov() * 252
+            valid_syms  = list(df.columns)
+            n           = len(valid_syms)
+            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] = []
+            for i in range(len(valid_syms)):
+                for j in range(i + 1, len(valid_syms)):
+                    c = float(corr.iloc[i, j])
+                    if abs(c) > 0.70:
+                        high_corr.append({
+                            "sym1": valid_syms[i],
+                            "sym2": valid_syms[j],
+                            "corr": round(c, 3),
+                        })
+
+            # 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
+            returns_1y: Dict[str, float] = {}
+            for sym in valid_syms:
+                first = float(df[sym].iloc[0])
+                last  = float(df[sym].iloc[-1])
+                if first > 0:
+                    returns_1y[sym] = round((last - first) / first, 4)
+
+            # Best/worst performer
+            sorted_ret = sorted(returns_1y.items(), key=lambda x: x[1], reverse=True)
+
+            data.update({
+                "valid_symbols": valid_syms,
+                "latest_prices": latest_prices,
+                "ann_returns":   {s: float(v) for s, v in ann_returns.items()},
+                "ann_vols":      {s: float(v) for s, v in ann_vols.items()},
+                "port_vol_ann":  round(port_vol, 4),
+                "div_ratio":     div_ratio,
+                "corr_matrix":   corr.round(3).to_dict(),
+                "high_corr":     high_corr,
+                "returns_1y":    returns_1y,
+                "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:
+            data["error"] = "pandas/numpy not available"
+        except Exception as e:
+            logger.warning("[portfolio] stats calculation: %s", e)
+            data["error"] = str(e)
+
+        return data
+
+    async def analyze_portfolio(
+        self, symbols: List[str], data: Dict[str, Any]
+    ) -> AgentResult:
+        zh = self.lang != "en"
+        if len(symbols) < 2:
+            return AgentResult(
+                agent=self.name, symbol=",".join(symbols),
+                analysis=("组合分析需要至少 2 个标的。" if zh
+                          else "A portfolio analysis needs at least 2 symbols."),
+                confidence=0.0, signal="HOLD",
+                key_points=["标的数量不足" if zh else "Not enough symbols"],
+            )
+
+        if data.get("error") == "insufficient_data":
+            return AgentResult(
+                agent=self.name, symbol=",".join(symbols),
+                analysis=("无法获取足够的历史价格数据进行组合分析。" if zh
+                          else "Not enough price history could be fetched to analyse the portfolio."),
+                confidence=0.3, signal="HOLD",
+                key_points=["历史数据不足（需要 >20 个交易日）" if zh
+                            else "Not enough history (needs more than 20 trading days)"],
+            )
+
+        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, weighted by {weight_desc})\n\n"
+            f"{port_block}\n\n"
+            "Analyze this portfolio:\n"
+            "1. Overall risk level (Low / Medium / High)\n"
+            "2. Diversification quality — any dangerous correlations or sector crowding?\n"
+            "3. Top 2-3 concerns (be specific about which symbols)\n"
+            "4. Concrete rebalancing suggestions\n"
+            "5. End with: HEALTHY / NEEDS_ATTENTION / HIGH_RISK"
+        )
+
+        analysis = await self._call_llm(self._SYSTEM, prompt, max_tokens=650)
+        if not analysis:
+            analysis = _template_analysis(valid_syms, data, self.lang)
+
+        verdict    = _extract_verdict(analysis)
+        signal     = _verdict_to_signal(verdict)
+        confidence = _estimate_confidence(data)
+        key_points = _build_key_points(data, verdict, self.lang)
+
+        return AgentResult(
+            agent=self.name,
+            symbol=",".join(valid_syms),
+            analysis=analysis,
+            confidence=confidence,
+            signal=signal,
+            key_points=key_points,
+            data_used={
+                # The verdict itself: the signal maps NEEDS_ATTENTION to SELL,
+                # and a banner built from the signal said HIGH_RISK.
+                "verdict": verdict,
+                "n": len(valid_syms),
+                "port_vol_ann": data.get("port_vol_ann"),
+                "div_ratio": data.get("div_ratio"),
+                "high_corr_count": len(data.get("high_corr", [])),
+            },
+        )
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _format_portfolio_stats(d: Dict) -> str:
+    lines = []
+
+    # Returns & volatility table
+    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 │ 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} │ {w*100:>5.1f}% │ {v*100:>6.1f}% │ {r*100:>6.1f}% │ {y*100:>+7.1f}%"
+            )
+
+    port_vol = d.get("port_vol_ann", 0)
+    div_r    = d.get("div_ratio", 1)
+    if port_vol:
+        lines.append(f"\nPortfolio Ann.Vol: {port_vol*100:.1f}%")
+        lines.append(f"Diversification Ratio: {div_r:.2f}x "
+                     f"({'good' if div_r >= 1.3 else 'poor'})")
+
+    high_corr = d.get("high_corr", [])
+    if high_corr:
+        lines.append("\nHigh-Correlation Pairs (|r|>0.70):")
+        for p in high_corr[:5]:
+            lines.append(f"  {p['sym1']} ↔ {p['sym2']}: {p['corr']:+.2f}")
+
+    sectors = d.get("sector_map", {})
+    if sectors:
+        from collections import Counter
+        sector_counts = Counter(sectors.values())
+        dominant = [(s, c) for s, c in sector_counts.items() if c >= 2]
+        if dominant:
+            lines.append("\nSector Concentration:")
+            for sec, cnt in dominant:
+                lines.append(f"  {sec}: {cnt} positions")
+
+    best  = d.get("best_performer")
+    worst = d.get("worst_performer")
+    if best and worst:
+        lines.append(f"\nBest 1Y: {best[0]} ({best[1]*100:+.1f}%)")
+        lines.append(f"Worst 1Y: {worst[0]} ({worst[1]*100:+.1f}%)")
+
+    return "\n".join(lines)
+
+
+def _extract_verdict(analysis: str) -> str:
+    text = analysis.upper()
+    if "HIGH_RISK" in text or "HIGH RISK" in text:
+        return "HIGH_RISK"
+    if "NEEDS_ATTENTION" in text or "NEEDS ATTENTION" in text:
+        return "NEEDS_ATTENTION"
+    if "HEALTHY" in text:
+        return "HEALTHY"
+    return "NEEDS_ATTENTION"
+
+
+def _verdict_to_signal(verdict: str) -> str:
+    return {"HEALTHY": "HOLD", "NEEDS_ATTENTION": "SELL", "HIGH_RISK": "SELL"}.get(verdict, "HOLD")
+
+
+def _estimate_confidence(d: Dict) -> float:
+    base = 0.60
+    n    = len(d.get("valid_symbols", []))
+    if n >= 5:
+        base += 0.05
+    if d.get("div_ratio", 1) < 1.1:
+        base += 0.05
+    return min(round(base, 2), 0.75)
+
+
+def _build_key_points(d: Dict, verdict: str, lang: str = "zh") -> List[str]:
+    zh  = lang != "en"
+    pts = []
+    n   = len(d.get("valid_symbols", []))
+    if d.get("weight_source") == "ledger":
+        pts.append(f"{n} 个标的，按真实持仓成本加权" if zh
+                   else f"{n} symbols, weighted by the cost of your real positions")
+    else:
+        pts.append(f"{n} 个标的，等权配置（无真实持仓数据，非实际风险暴露）" if zh
+                   else f"{n} symbols, equal weight (no real positions recorded, so not your actual exposure)")
+
+    port_vol = d.get("port_vol_ann", 0)
+    if port_vol:
+        if zh:
+            risk_lv = "高风险" if port_vol > 0.30 else ("中等" if port_vol > 0.18 else "低风险")
+            pts.append(f"组合年化波动 {port_vol*100:.1f}%（{risk_lv}）")
+        else:
+            risk_lv = "high" if port_vol > 0.30 else ("medium" if port_vol > 0.18 else "low")
+            pts.append(f"Annualised portfolio volatility {port_vol*100:.1f}% ({risk_lv})")
+
+    div_r = d.get("div_ratio", 1)
+    if div_r < 1.1:
+        pts.append(f"分散度不足（ratio {div_r:.2f}x，标的相关性高）" if zh
+                   else f"Poorly diversified (ratio {div_r:.2f}x, the symbols move together)")
+    else:
+        pts.append(f"分散度合理（ratio {div_r:.2f}x）" if zh
+                   else f"Reasonably diversified (ratio {div_r:.2f}x)")
+
+    high_corr = d.get("high_corr", [])
+    if high_corr:
+        top = high_corr[0]
+        pts.append(f"{'最高相关对' if zh else 'Most correlated pair'}: "
+                   f"{top['sym1']}↔{top['sym2']} ({top['corr']:+.2f})")
+
+    pts.append(f"{'整体评级' if zh else 'Overall'}: {verdict}")
+    return pts[:6]
+
+
+def _template_analysis(symbols: List[str], d: Dict, lang: str = "zh") -> str:
+    high_corr = d.get("high_corr", [])
+    port_vol  = d.get("port_vol_ann", 0)
+    div_r     = d.get("div_ratio", 1)
+
+    verdict = "NEEDS_ATTENTION"
+    if not high_corr and port_vol < 0.20 and div_r >= 1.2:
+        verdict = "HEALTHY"
+    elif len(high_corr) >= 3 or port_vol > 0.30:
+        verdict = "HIGH_RISK"
+
+    if lang == "en":
+        lines = [f"{','.join(symbols)} portfolio report (template)"]
+        lines.append(f"Annualised volatility: {port_vol*100:.1f}%")
+        lines.append(f"Diversification ratio: {div_r:.2f}x")
+        if high_corr:
+            lines.append(f"{len(high_corr)} highly correlated pairs, the highest "
+                         f"{high_corr[0]['sym1']}↔{high_corr[0]['sym2']} {high_corr[0]['corr']:+.2f}")
+        else:
+            lines.append("No highly correlated pairs.")
+        lines.append(f"\n{verdict}")
+        return "\n".join(lines)
+
+    lines = [f"{','.join(symbols)} 组合分析报告（模板）"]
+    lines.append(f"年化波动率: {port_vol*100:.1f}%")
+    lines.append(f"分散度系数: {div_r:.2f}x")
+    if high_corr:
+        lines.append(f"高相关对 {len(high_corr)} 组，最高: "
+                     f"{high_corr[0]['sym1']}↔{high_corr[0]['sym2']} {high_corr[0]['corr']:+.2f}")
+    else:
+        lines.append("无显著高相关对，分散良好。")
+    lines.append(f"\n{verdict}")
+    return "\n".join(lines)

aria_code/agents/realty/__init__.py

@@ -0,0 +1,62 @@
+"""
+agents/realty — 经营权共创平台 AI Agent 模块
+=============================================
+9 个领域专属 Agent，继承 BaseAgent，用于：
+  - 资产诊断与处置建议
+  - 业态匹配与经营方推荐
+  - 合同条款结构化生成
+  - 分账规则配置建议
+  - 流水核验与异常检测
+  - 能耗异常分析
+  - 合同履约风控
+  - 运营优化建议
+  - 退出清算方案生成
+
+用法:
+    from agents.realty import AssetDiagnosisAgent, RevenueShareAgent
+    from agents.realty import REALTY_TEAM  # 默认 team 名称列表
+"""
+
+from .asset_diagnosis  import AssetDiagnosisAgent
+from .business_match   import BusinessMatchAgent
+from .contract_rules   import ContractRulesAgent
+from .revenue_share    import RevenueShareAgent
+from .cashflow_verify  import CashFlowVerifyAgent
+from .energy_anomaly   import EnergyAnomalyAgent
+from .fulfillment_risk import FulfillmentRiskAgent
+from .ops_optimize     import OpsOptimizeAgent
+from .exit_settlement  import ExitSettlementAgent
+
+# 默认完整 team
+REALTY_TEAM = [
+    "asset_diagnosis",
+    "business_match",
+    "contract_rules",
+    "revenue_share",
+    "cashflow_verify",
+    "energy_anomaly",
+    "fulfillment_risk",
+    "ops_optimize",
+    "exit_settlement",
+]
+
+# 风控专项 team（快速预警）
+RISK_TEAM = [
+    "cashflow_verify",
+    "energy_anomaly",
+    "fulfillment_risk",
+]
+
+__all__ = [
+    "AssetDiagnosisAgent",
+    "BusinessMatchAgent",
+    "ContractRulesAgent",
+    "RevenueShareAgent",
+    "CashFlowVerifyAgent",
+    "EnergyAnomalyAgent",
+    "FulfillmentRiskAgent",
+    "OpsOptimizeAgent",
+    "ExitSettlementAgent",
+    "REALTY_TEAM",
+    "RISK_TEAM",
+]

aria_code/agents/realty/asset_diagnosis.py

@@ -0,0 +1,152 @@
+"""
+agents/realty/asset_diagnosis.py — 资产诊断 Agent
+==================================================
+判断资产适合出租、出售还是经营权共创。
+
+输入数据（data dict keys）:
+    asset_info       — 资产基础信息 dict（面积、位置、产权状态、空置时间等）
+    market_context   — 周边业态、租金行情（可选）
+    renovation_cost  — 估算改造成本（可选）
+
+输出:
+    analysis    — 详细分析文本
+    signal      — GOOD=推荐共创 / WATCH=需观察 / CONCERN=建议出租或出售
+                  （地产健康度尺度，见 agents/signal_scheme.py::REALTY_SCHEME，
+                  不是股票 BUY/SELL 那套交易动作词汇）
+    key_points  — 3-5 条关键结论
+"""
+from __future__ import annotations
+
+from typing import Any, Dict
+from ..base import BaseAgent, AgentResult
+
+
+class AssetDiagnosisAgent(BaseAgent):
+    name        = "asset_diagnosis"
+    description = "资产诊断：判断处置方式（出租/出售/共创）并给出保底与分润结构建议"
+
+    _SYSTEM = (
+        "你是一名专业的不动产资产运营顾问，擅长评估商业空间的经营潜力。\n"
+        "你的任务是根据资产条件、空置状况、市场行情，判断该资产最适合哪种处置方式：\n"
+        "  A) 传统出租（固定租金）\n"
+        "  B) 经营权共创（保底+流水分润）\n"
+        "  C) 出售（一次性变现）\n\n"
+        "输出格式要求：\n"
+        "1. 推荐方式及理由（2-3句话）\n"
+        "2. 如推荐共创，给出：保底收益建议（元/月）、分润比例建议（%）、适合业态Top3\n"
+        "3. 主要风险提示（1-2条）\n"
+        "4. 综合评分：[适合共创] / [建议观察] / [不建议共创]"
+    )
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        asset   = data.get("asset_info", {})
+        market  = data.get("market_context", {})
+        reno    = data.get("renovation_cost", 0)
+
+        # 构建资产摘要
+        area        = asset.get("area", 0)
+        location    = asset.get("location", "未知位置")
+        vacancy_days= asset.get("vacancy_days", 0)
+        expected_rent = asset.get("expected_rent", 0)
+        floor_height  = asset.get("floor_height", 0)
+        business_types = asset.get("allowed_business", [])
+        prohibited    = asset.get("prohibited_business", [])
+        property_state= asset.get("property_state", "正常")
+
+        user_prompt = (
+            f"资产信息：\n"
+            f"  位置: {location}\n"
+            f"  面积: {area} m²  层高: {floor_height}m\n"
+            f"  产权状态: {property_state}  空置天数: {vacancy_days}天\n"
+            f"  评估租金: {expected_rent}元/月  改造成本估算: {reno}元\n"
+            f"  适合业态: {', '.join(business_types) or '未指定'}\n"
+            f"  禁止业态: {', '.join(prohibited) or '无'}\n"
+            f"  市场背景: {market.get('summary', '暂无周边数据')}\n\n"
+            "请根据以上信息完成资产诊断。"
+        )
+
+        analysis = await self._call_llm(self._SYSTEM, user_prompt, max_tokens=600)
+        if not analysis:
+            analysis = _template_diagnosis(asset, reno)
+
+        signal      = _score_to_signal(asset, reno)
+        confidence  = _calc_confidence(asset)
+        key_points  = _extract_key_points(asset, reno, market)
+
+        return AgentResult(
+            agent      = self.name,
+            symbol     = symbol,
+            analysis   = analysis,
+            confidence = confidence,
+            signal     = signal,
+            key_points = key_points,
+            data_used  = {"asset_info": asset, "renovation_cost": reno},
+        )
+
+
+# ── 内部辅助函数 ──────────────────────────────────────────────────────────────
+
+def _score_to_signal(asset: Dict, reno: float) -> str:
+    """根据资产条件估算共创适合度"""
+    area         = asset.get("area", 0)
+    vacancy_days = asset.get("vacancy_days", 0)
+    rent         = asset.get("expected_rent", 0)
+    allowed      = asset.get("allowed_business", [])
+    state        = asset.get("property_state", "正常")
+
+    score = 0
+    if area >= 50:      score += 1
+    if area >= 200:     score += 1
+    if vacancy_days >= 90:  score += 1   # 空置越久越需要共创
+    if rent > 0:        score += 1
+    if len(allowed) >= 2: score += 1
+    if state != "正常":   score -= 2
+    if reno > rent * 24:  score -= 1     # 改造成本超过2年租金则不划算
+
+    if score >= 4:  return "GOOD"      # 非常适合共创
+    if score >= 2:  return "WATCH"     # 需进一步评估
+    return "CONCERN"                    # 建议传统出租或出售
+
+
+def _calc_confidence(asset: Dict) -> float:
+    """数据越完整，置信度越高"""
+    fields = ["area", "location", "expected_rent", "allowed_business", "property_state"]
+    filled = sum(1 for f in fields if asset.get(f))
+    return round(0.5 + 0.1 * filled, 2)
+
+
+def _extract_key_points(asset: Dict, reno: float, market: Dict) -> list:
+    points = []
+    area = asset.get("area", 0)
+    vacancy = asset.get("vacancy_days", 0)
+    rent = asset.get("expected_rent", 0)
+    allowed = asset.get("allowed_business", [])
+
+    if area >= 200:
+        points.append(f"面积 {area}m² 具备多业态组合潜力")
+    if vacancy >= 90:
+        points.append(f"已空置 {vacancy} 天，引入经营方具有紧迫性")
+    if rent > 0:
+        points.append(f"评估租金 {rent:,.0f} 元/月，保底基准参考值")
+    if allowed:
+        points.append(f"适合业态：{', '.join(allowed[:3])}")
+    if reno > 0:
+        points.append(f"改造成本约 {reno:,.0f} 元，需纳入分润谈判")
+    return points[:5]
+
+
+def _template_diagnosis(asset: Dict, reno: float) -> str:
+    area    = asset.get("area", 0)
+    vacancy = asset.get("vacancy_days", 0)
+    rent    = asset.get("expected_rent", 0)
+    allowed = asset.get("allowed_business", [])
+
+    suitability = "建议经营权共创" if area >= 100 and vacancy >= 30 else "建议先评估市场需求"
+    return (
+        f"资产诊断（模板）：\n"
+        f"  面积: {area}m²  空置: {vacancy}天  评估租金: {rent:,.0f}元/月\n"
+        f"  适合业态: {', '.join(allowed[:3]) or '待评估'}\n"
+        f"  改造成本估算: {reno:,.0f}元\n"
+        f"  诊断结论: {suitability}\n"
+        f"  建议保底: {int(rent * 0.7):,}元/月  建议分润比例: 8-12%"
+    )