aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/agents/realty/business_match.py

@@ -0,0 +1,166 @@
+"""
+agents/realty/business_match.py — 业态匹配 Agent
+=================================================
+匹配资产条件与经营方能力，给出业态组合建议。
+
+输入数据（data dict keys）:
+    asset_info      — 资产基础信息（面积、位置、层高、客流等）
+    operators       — 候选经营方列表（可选）
+    market_context  — 周边业态、人口、消费力数据（可选）
+
+输出:
+    analysis    — 业态匹配建议
+    signal      — GOOD=高度匹配 / WATCH=一般匹配 / CONCERN=低匹配
+                  （地产健康度尺度，见 signal_scheme.py）
+    key_points  — 推荐业态 Top3 + 理由
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+from ..base import BaseAgent, AgentResult
+
+
+class BusinessMatchAgent(BaseAgent):
+    name        = "business_match"
+    description = "业态匹配：根据空间条件和市场数据推荐适合的经营业态组合"
+
+    _SYSTEM = (
+        "你是一名商业空间招商运营专家，擅长根据空间条件匹配最优业态。\n"
+        "分析维度：\n"
+        "  1. 空间适配度（面积、层高、水电、消防条件）\n"
+        "  2. 市场需求（周边客群、竞争格局、消费力）\n"
+        "  3. 经营方能力（品牌力、资金实力、运营经验）\n"
+        "  4. 收益预期（流水规模、分润可行性）\n\n"
+        "输出格式：\n"
+        "1. 推荐业态 Top3（每个包含：业态名称、预期月流水范围、分润比例建议、空间需求匹配度）\n"
+        "2. 经营方匹配建议（如有候选方）\n"
+        "3. 不建议的业态及原因\n"
+        "4. 综合匹配评级：[高度匹配] / [一般匹配] / [谨慎入场]"
+    )
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        asset     = data.get("asset_info", {})
+        operators = data.get("operators", [])
+        market    = data.get("market_context", {})
+
+        area        = asset.get("area", 0)
+        location    = asset.get("location", "")
+        floor_ht    = asset.get("floor_height", 0)
+        power_cap   = asset.get("power_capacity", "未知")
+        allowed     = asset.get("allowed_business", [])
+        prohibited  = asset.get("prohibited_business", [])
+        foot_traffic= asset.get("foot_traffic", "未知")
+        can_fire    = asset.get("open_fire_allowed", False)
+        can_renovate= asset.get("renovation_allowed", True)
+
+        op_summary = ""
+        if operators:
+            op_lines = []
+            for op in operators[:3]:
+                op_lines.append(
+                    f"  - {op.get('name','未知')}: 行业={op.get('industry','未知')}, "
+                    f"预算={op.get('budget',0):,}元, 品牌={op.get('brand_level','未知')}"
+                )
+            op_summary = "候选经营方：\n" + "\n".join(op_lines)
+
+        user_prompt = (
+            f"资产条件：\n"
+            f"  位置: {location}  面积: {area}m²  层高: {floor_ht}m\n"
+            f"  电容量: {power_cap}  明火许可: {'是' if can_fire else '否'}\n"
+            f"  可改造: {'是' if can_renovate else '否'}  客流量: {foot_traffic}\n"
+            f"  允许业态: {', '.join(allowed) or '无限制'}\n"
+            f"  禁止业态: {', '.join(prohibited) or '无'}\n"
+            f"  市场背景: {market.get('summary','暂无')}\n"
+            f"{op_summary}\n\n"
+            "请给出业态匹配分析。"
+        )
+
+        analysis = await self._call_llm(self._SYSTEM, user_prompt, max_tokens=700)
+        if not analysis:
+            analysis = _template_match(asset, operators)
+
+        signal     = _match_signal(asset, market)
+        confidence = _match_confidence(asset, market)
+        key_points = _match_key_points(asset, operators, market)
+
+        return AgentResult(
+            agent      = self.name,
+            symbol     = symbol,
+            analysis   = analysis,
+            confidence = confidence,
+            signal     = signal,
+            key_points = key_points,
+            data_used  = {"asset_info": asset, "operators_count": len(operators)},
+        )
+
+
+# ── 辅助函数 ──────────────────────────────────────────────────────────────────
+
+def _match_signal(asset: Dict, market: Dict) -> str:
+    score = 0
+    area  = asset.get("area", 0)
+    allowed = asset.get("allowed_business", [])
+    foot_traffic = str(asset.get("foot_traffic", "")).lower()
+    ft_score = asset.get("foot_traffic_score", 0)   # numeric 0-10
+
+    # market_score: direct int, or derive from market_maturity string
+    market_score = market.get("score", 0)
+    if not market_score:
+        maturity = str(market.get("market_maturity", "")).lower()
+        market_score = {"high": 8, "medium": 5, "low": 2, "成熟": 8, "一般": 5, "新兴": 4}.get(maturity, 0)
+
+    if area >= 100:   score += 1
+    if area >= 300:   score += 1
+    if len(allowed) >= 3: score += 1
+    if "高" in foot_traffic or "large" in foot_traffic or ft_score >= 7: score += 1
+    if market_score >= 7:  score += 1
+    elif 0 < market_score <= 3: score -= 1
+
+    if score >= 4:  return "GOOD"
+    if score >= 2:  return "WATCH"
+    return "CONCERN"
+
+
+def _match_confidence(asset: Dict, market: Dict) -> float:
+    fields = ["area", "location", "foot_traffic", "allowed_business", "floor_height"]
+    filled = sum(1 for f in fields if asset.get(f))
+    market_bonus = 0.1 if market.get("summary") else 0
+    return round(min(0.9, 0.4 + 0.1 * filled + market_bonus), 2)
+
+
+def _match_key_points(asset: Dict, operators: List, market: Dict) -> List[str]:
+    points = []
+    area    = asset.get("area", 0)
+    allowed = asset.get("allowed_business", [])
+    can_fire= asset.get("open_fire_allowed", False)
+
+    if allowed:
+        points.append(f"允许业态：{', '.join(allowed[:3])} 等 {len(allowed)} 类")
+    if area:
+        points.append(f"面积 {area}m²，适合{'大型品牌' if area >= 300 else '中小型经营方'}")
+    if not can_fire:
+        points.append("不允许明火，餐饮业态受限（建议西餐/轻食/烘焙）")
+    if operators:
+        points.append(f"共 {len(operators)} 个候选经营方，需进一步资质评估")
+    if market.get("competitors"):
+        points.append(f"周边竞争: {market['competitors']}")
+    return points[:5]
+
+
+def _template_match(asset: Dict, operators: List) -> str:
+    area    = asset.get("area", 0)
+    allowed = asset.get("allowed_business", [])
+    can_fire= asset.get("open_fire_allowed", False)
+
+    top3 = allowed[:3] if allowed else ["零售", "轻餐饮", "生活服务"]
+    if not can_fire and "餐饮" in top3:
+        top3 = [b for b in top3 if "餐饮" not in b] + ["轻食/咖啡"]
+
+    return (
+        f"业态匹配分析（模板）：\n"
+        f"  面积: {area}m²  适合业态: {', '.join(allowed[:5]) or '无限制'}\n"
+        f"  推荐 Top3:\n"
+        + "\n".join(f"    {i+1}. {b}（预期流水 {(area*200*(i+1)):,.0f}-{area*400*(i+1):,.0f}元/月）"
+                    for i, b in enumerate(top3[:3]))
+        + f"\n  候选经营方数: {len(operators)}"
+    )

aria_code/agents/realty/cashflow_verify.py

@@ -0,0 +1,209 @@
+"""
+agents/realty/cashflow_verify.py — 流水核验 Agent
+=================================================
+判断经营方申报流水是否真实，识别私账/逃费/低报行为。
+
+输入数据（data dict keys）:
+    pos_transactions    — POS/扫码流水列表（可选）
+    bank_statements     — 银行流水（可选）
+    delivery_revenue    — 外卖/团购收入（可选）
+    inventory_data      — 库存进货数据（可选）
+    energy_data         — 水电用量（可选）
+    declared_revenue    — 经营方自报流水
+    expected_revenue    — 系统预估流水（基于历史/业态/客流）
+
+输出:
+    analysis    — 核验报告
+    signal      — GOOD=流水真实 / WATCH=轻度异常需复核 / CONCERN=疑似造假/私账
+                  / SEVERE=多项异常+差距极大（地产健康度尺度，见 signal_scheme.py）
+    key_points  — 异常项目清单
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+from ..base import BaseAgent, AgentResult
+
+
+class CashFlowVerifyAgent(BaseAgent):
+    name        = "cashflow_verify"
+    description = "流水核验：多源数据交叉比对，识别私账/逃费/低报流水行为"
+
+    _SYSTEM = (
+        "你是一名专业的财务审计和风控专家，擅长识别经营流水中的异常。\n"
+        "请对流水核验结果进行分析：\n"
+        "  1. 各数据源的一致性分析（POS/银行/外卖/库存/能耗）\n"
+        "  2. 申报流水与预估流水的差异分析\n"
+        "  3. 识别的异常模式（如：只用现金、收款码变更、能耗与流水不匹配）\n"
+        "  4. 风险等级判断：[正常] / [需复核] / [疑似私账] / [建议稽查]\n"
+        "  5. 具体建议：要求补充哪些凭证，或启动哪种核查程序"
+    )
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        # 支持两种输入格式：
+        #   标量简化模式: pos_revenue=55000, bank_revenue=48000, cash_ratio=0.35
+        #   列表精细模式: pos_transactions=[{amount,payment_type,...}], bank_statements=[{amount,type,...}]
+        pos      = data.get("pos_transactions", [])
+        bank     = data.get("bank_statements", [])
+        delivery = data.get("delivery_revenue", 0)
+        inventory= data.get("inventory_data", {})
+        energy   = data.get("energy_data", {})
+        declared = data.get("declared_revenue", 0)
+        expected = data.get("expected_revenue", 0)
+
+        # 标量快捷键：如果没有列表数据但有聚合数字，转换为单条虚拟记录
+        if not pos and data.get("pos_revenue", 0):
+            pos_total_val = data["pos_revenue"]
+            cash_r = data.get("cash_ratio", 0.0)   # 0.0~1.0
+            if cash_r > 0:
+                pos = [
+                    {"amount": pos_total_val * (1 - cash_r), "payment_type": "digital"},
+                    {"amount": pos_total_val * cash_r,       "payment_type": "cash"},
+                ]
+            else:
+                pos = [{"amount": pos_total_val, "payment_type": "digital"}]
+        if not bank and data.get("bank_revenue", 0):
+            bank = [{"amount": data["bank_revenue"], "type": "IN"}]
+        if not delivery and data.get("wechat_revenue", 0):
+            delivery = data.get("wechat_revenue", 0) + data.get("alipay_revenue", 0)
+
+        # 交叉核验
+        check = _cross_verify(pos, bank, delivery, inventory, energy, declared, expected)
+
+        user_prompt = (
+            f"流水核验数据：\n"
+            f"  经营方申报流水: {declared:,.2f}元\n"
+            f"  系统预估流水: {expected:,.2f}元\n"
+            f"  差异率: {check['gap_pct']:.1f}%（{'偏低' if check['gap_pct'] < 0 else '偏高'}）\n\n"
+            f"数据源汇总：\n"
+            f"  POS/扫码流水: {check['pos_total']:,.2f}元（{len(pos)}笔）\n"
+            f"  银行流水: {check['bank_total']:,.2f}元\n"
+            f"  外卖/团购收入: {delivery:,.2f}元\n"
+            f"  能耗指数（用电）: {energy.get('electricity_kwh',0)} kWh\n"
+            f"  库存周转估算: {check['inventory_implied_revenue']:,.2f}元\n\n"
+            f"发现异常：\n"
+            + "\n".join(f"  - {a}" for a in check["anomalies"])
+            + "\n\n请完成流水核验报告。"
+        )
+
+        analysis = await self._call_llm(self._SYSTEM, user_prompt, max_tokens=700)
+        if not analysis:
+            analysis = _template_verify(check, declared, expected)
+
+        signal     = _verify_signal(check)
+        confidence = _verify_confidence(check)
+        key_points = _verify_key_points(check, declared, expected)
+
+        return AgentResult(
+            agent      = self.name,
+            symbol     = symbol,
+            analysis   = analysis,
+            confidence = confidence,
+            signal     = signal,
+            key_points = key_points,
+            data_used  = {"verify_result": check},
+        )
+
+
+# ── 核验逻辑 ──────────────────────────────────────────────────────────────────
+
+def _cross_verify(
+    pos: List[Dict], bank: List[Dict], delivery: float,
+    inventory: Dict, energy: Dict, declared: float, expected: float,
+) -> Dict:
+    pos_total = sum(t.get("amount", 0) for t in pos if not t.get("is_refund"))
+    bank_total = sum(t.get("amount", 0) for t in bank if t.get("type") in ("IN", "in", None))
+
+    # 库存推算流水（进货金额 * 毛利率倒推）
+    purchase_cost = inventory.get("purchase_cost", 0)
+    gross_margin  = inventory.get("expected_margin_pct", 40) / 100
+    inv_implied   = purchase_cost / (1 - gross_margin) if gross_margin < 1 else 0
+
+    # 综合核验流水（取最大可信来源）
+    verified_sources = [s for s in [pos_total, bank_total, delivery + pos_total] if s > 0]
+    verified_max = max(verified_sources) if verified_sources else declared
+
+    gap_pct = ((declared - expected) / expected * 100) if expected else 0
+    source_gap = ((declared - verified_max) / declared * 100) if declared else 0
+
+    anomalies = []
+
+    # 申报 vs 预期 差距
+    if gap_pct < -30:
+        anomalies.append(f"申报流水比预估低{abs(gap_pct):.1f}%，偏差较大")
+    if gap_pct < -50:
+        anomalies.append("申报流水不足预估50%，建议启动稽查")
+
+    # POS vs 银行 不一致
+    if pos_total > 0 and bank_total > 0:
+        consistency = abs(pos_total - bank_total) / max(pos_total, bank_total)
+        if consistency > 0.2:
+            anomalies.append(f"POS流水({pos_total:,.0f})与银行流水({bank_total:,.0f})差异{consistency*100:.1f}%")
+
+    # 申报 vs 核验源 差距
+    if declared > 0 and verified_max > 0 and source_gap > 25:
+        anomalies.append(f"申报流水比可核验来源高{source_gap:.1f}%，可能虚报")
+    elif declared < verified_max * 0.7:
+        anomalies.append(f"申报流水({declared:,.0f})低于可核验来源({verified_max:,.0f})，疑似漏报")
+
+    # 能耗异常（有水电无流水）
+    elec = energy.get("electricity_kwh", 0)
+    if elec > 0 and declared == 0:
+        anomalies.append("有水电消耗记录但申报流水为零，疑似有经营未申报")
+
+    # 库存推算差距
+    if inv_implied > 0 and declared < inv_implied * 0.6:
+        anomalies.append(f"库存进货推算流水{inv_implied:,.0f}元，申报仅{declared:,.0f}元，差距较大")
+
+    # 现金比例过高
+    cash_txns = [t for t in pos if t.get("payment_type") in ("cash", "现金")]
+    if pos and len(cash_txns) / len(pos) > 0.3:
+        anomalies.append(f"现金交易占比{len(cash_txns)/len(pos)*100:.1f}%偏高，难以核验")
+
+    return {
+        "pos_total":              pos_total,
+        "bank_total":             bank_total,
+        "delivery":               delivery,
+        "inventory_implied_revenue": inv_implied,
+        "verified_max":           verified_max,
+        "gap_pct":                gap_pct,
+        "source_gap_pct":         source_gap,
+        "anomalies":              anomalies,
+        "anomaly_count":          len(anomalies),
+    }
+
+
+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 "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:
+    sources = sum(1 for k in ["pos_total", "bank_total", "delivery"] if check.get(k, 0) > 0)
+    return round(min(0.9, 0.5 + 0.15 * sources), 2)
+
+
+def _verify_key_points(check: Dict, declared: float, expected: float) -> List[str]:
+    pts = [f"申报流水: {declared:,.2f}元  预估流水: {expected:,.2f}元  "
+           f"差异: {check['gap_pct']:+.1f}%"]
+    if check["pos_total"]:
+        pts.append(f"POS核验流水: {check['pos_total']:,.2f}元")
+    for a in check["anomalies"][:3]:
+        pts.append(f"异常: {a}")
+    return pts[:5]
+
+
+def _template_verify(check: Dict, declared: float, expected: float) -> str:
+    status = "正常" if check["anomaly_count"] == 0 else "发现异常"
+    return (
+        f"流水核验报告（模板）：\n"
+        f"  申报流水: {declared:,.2f}元  预估流水: {expected:,.2f}元  "
+        f"差异: {check['gap_pct']:+.1f}%\n"
+        f"  POS流水: {check['pos_total']:,.2f}元  银行流水: {check['bank_total']:,.2f}元\n"
+        f"  核验状态: {status}\n"
+        + ("  发现异常:\n" + "\n".join(f"    • {a}" for a in check["anomalies"])
+           if check["anomalies"] else "  无异常项目")
+    )

aria_code/agents/realty/contract_rules.py

@@ -0,0 +1,210 @@
+"""
+agents/realty/contract_rules.py — 合同规则 Agent
+=================================================
+将业务谈判结果转化为合同条款和分账规则草案。
+
+输入数据（data dict keys）:
+    negotiation     — 谈判结果摘要（保底/分润比例/结算周期/退出条件等）
+    asset_info      — 资产基础信息
+    operator_info   — 经营方信息（资质/历史数据等）
+
+输出:
+    analysis    — 合同条款草案文本
+    signal      — GOOD=条款清晰可执行 / WATCH=需补充条款 / CONCERN=有重大风险条款
+                  （地产健康度尺度，见 signal_scheme.py）
+    key_points  — 关键条款摘要（保底金额/分润比例/结算周期/违约条款）
+"""
+from __future__ import annotations
+
+from decimal import Decimal, ROUND_HALF_UP
+from typing import Any, Dict, List, Optional
+from ..base import BaseAgent, AgentResult
+
+
+class ContractRulesAgent(BaseAgent):
+    name        = "contract_rules"
+    description = "合同规则生成：将谈判结果结构化为可执行的合同条款和分账规则草案"
+
+    _SYSTEM = (
+        "你是一名专业的不动产运营合同起草顾问。\n"
+        "你的任务是根据谈判结果，生成结构化的合同条款草案，包含：\n"
+        "  1. 经营权共创模式说明（资产方不转让产权，基于使用权获得收益）\n"
+        "  2. 收益分配规则：保底收益、流水分润计算方式、阶梯分成规则\n"
+        "  3. 结算周期与结算方式\n"
+        "  4. 保证金条款（金额、用途、退还条件）\n"
+        "  5. 风险准备金（比例、用途）\n"
+        "  6. 平台服务费（比例或固定金额）\n"
+        "  7. 退出条款（提前退出违约金、清算顺序）\n"
+        "  8. 开业义务与履约要求\n\n"
+        "输出要求：\n"
+        "- 每个条款必须包含：条款名称、具体数值、计算公式（如适用）\n"
+        "- 标注 [系统可执行] / [需人工确认] / [建议律师审核]\n"
+        "- 最后给出：合同风险评级 [低/中/高] 及主要风险点"
+    )
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        nego     = data.get("negotiation", {})
+        asset    = data.get("asset_info", {})
+        operator = data.get("operator_info", {})
+
+        # 解析谈判关键数值（兼容多种字段命名）
+        guaranteed    = nego.get("guaranteed_amount",
+                                 nego.get("guaranteed_monthly", 0))
+        revenue_share = nego.get("revenue_share_pct", 0)
+        base_revenue  = nego.get("base_revenue",
+                                 nego.get("revenue_share_base", 0))
+        tiered_rules  = nego.get("tiered_rules", [])
+        settle_cycle  = nego.get("settlement_cycle", "monthly")
+        # 保证金：直接金额 > deposit_months × 保底 > 0
+        deposit_months = nego.get("deposit_months", 0)
+        deposit = nego.get("deposit_amount",
+                           nego.get("deposit",
+                                    guaranteed * deposit_months if deposit_months else 0))
+        risk_reserve  = nego.get("risk_reserve_pct", 3)
+        platform_fee  = nego.get("platform_fee_pct", 5)
+        contract_years= nego.get("contract_years", 1)
+        exit_penalty  = nego.get("exit_penalty_months", 3)
+
+        user_prompt = (
+            f"谈判结果：\n"
+            f"  保底收益: {guaranteed:,}元/月\n"
+            f"  流水分润: 月流水超过{base_revenue:,}元后按{revenue_share}%分润\n"
+            f"  阶梯规则: {tiered_rules or '无阶梯'}\n"
+            f"  结算周期: {settle_cycle}\n"
+            f"  保证金: {deposit:,}元\n"
+            f"  风险准备金: 流水的{risk_reserve}%\n"
+            f"  平台服务费: 流水的{platform_fee}%\n"
+            f"  合同年限: {contract_years}年\n"
+            f"  提前退出违约: {exit_penalty}个月保底金额\n\n"
+            f"资产信息: {asset.get('name','未命名')} ({asset.get('area',0)}m²)\n"
+            f"经营方: {operator.get('name','未知')} "
+            f"(行业: {operator.get('industry','未知')})\n\n"
+            "请生成完整的合同条款草案。"
+        )
+
+        analysis = await self._call_llm(self._SYSTEM, user_prompt, max_tokens=1000)
+        if not analysis:
+            analysis = _template_contract(nego, asset, operator)
+
+        # 结构化规则供系统执行
+        structured = _build_structured_rules(nego)
+        signal     = _contract_signal(nego)
+        confidence = _contract_confidence(nego)
+        key_points = _contract_key_points(nego, structured)
+
+        return AgentResult(
+            agent      = self.name,
+            symbol     = symbol,
+            analysis   = analysis,
+            confidence = confidence,
+            signal     = signal,
+            key_points = key_points,
+            data_used  = {"structured_rules": structured, "negotiation": nego},
+        )
+
+
+# ── 辅助函数 ──────────────────────────────────────────────────────────────────
+
+def _build_structured_rules(nego: Dict) -> Dict:
+    """生成系统可直接执行的分账规则 JSON（兼容多种字段命名）"""
+    _g             = nego.get("guaranteed_amount", nego.get("guaranteed_monthly", 0))
+    guaranteed     = Decimal(str(_g))
+    share_pct      = Decimal(str(nego.get("revenue_share_pct", 0)))
+    base_revenue   = Decimal(str(nego.get("base_revenue", nego.get("revenue_share_base", 0))))
+    risk_reserve   = Decimal(str(nego.get("risk_reserve_pct", 3)))
+    platform_fee   = Decimal(str(nego.get("platform_fee_pct", 5)))
+    _dm            = nego.get("deposit_months", 0)
+    deposit        = Decimal(str(nego.get("deposit_amount",
+                                          nego.get("deposit",
+                                                   float(_g) * _dm if _dm else 0))))
+
+    return {
+        "guaranteed_monthly":   float(guaranteed),
+        "revenue_share_pct":    float(share_pct),
+        "revenue_share_base":   float(base_revenue),
+        "risk_reserve_pct":     float(risk_reserve),
+        "platform_fee_pct":     float(platform_fee),
+        "deposit_amount":       float(deposit),
+        "settlement_cycle":     nego.get("settlement_cycle", "monthly"),
+        "tiered_rules":         nego.get("tiered_rules", []),
+        "contract_years":       nego.get("contract_years", 1),
+        "exit_penalty_months":  nego.get("exit_penalty_months", 3),
+    }
+
+
+def _contract_signal(nego: Dict) -> str:
+    issues = 0
+    if not (nego.get("guaranteed_amount") or nego.get("guaranteed_monthly")): issues += 1
+    if not nego.get("revenue_share_pct"):  issues += 1
+    if not (nego.get("deposit") or nego.get("deposit_amount") or nego.get("deposit_months")): issues += 1
+    if not nego.get("settlement_cycle"):   issues += 1
+    if not nego.get("contract_years"):     issues += 1
+
+    if issues == 0:  return "GOOD"
+    if issues <= 2:  return "WATCH"
+    return "CONCERN"
+
+
+def _contract_confidence(nego: Dict) -> float:
+    keys_pairs = [
+        ("guaranteed_amount", "guaranteed_monthly"),
+        ("revenue_share_pct",),
+        ("base_revenue", "revenue_share_base"),
+        ("deposit", "deposit_amount", "deposit_months"),
+        ("settlement_cycle",),
+        ("contract_years",),
+    ]
+    filled = sum(1 for kp in keys_pairs if any(nego.get(k) for k in kp))
+    return round(0.4 + 0.1 * filled, 2)
+
+
+def _contract_key_points(nego: Dict, rules: Dict) -> List[str]:
+    pts = []
+    g = rules.get("guaranteed_monthly", 0)
+    s = rules.get("revenue_share_pct", 0)
+    b = rules.get("revenue_share_base", 0)
+    d = rules.get("deposit_amount", 0)
+    c = rules.get("settlement_cycle", "monthly")
+    yrs = rules.get("contract_years", 1)
+
+    if g:  pts.append(f"保底收益: {g:,.0f}元/月（年合计 {g*12:,.0f}元）")
+    if s:  pts.append(f"流水分润: 超过{b:,.0f}元后按{s}%分润")
+    if d:  pts.append(f"保证金: {d:,.0f}元（合同结束后退还）")
+    if c:  pts.append(f"结算周期: {c}")
+    if yrs: pts.append(f"合同年限: {yrs}年，到期可续签")
+    return pts[:5]
+
+
+def _template_contract(nego: Dict, asset: Dict, operator: Dict) -> str:
+    g  = nego.get("guaranteed_amount", nego.get("guaranteed_monthly", 0))
+    s  = nego.get("revenue_share_pct", 0)
+    b  = nego.get("base_revenue", nego.get("revenue_share_base", 0))
+    dm = nego.get("deposit_months", 0)
+    d  = nego.get("deposit_amount", nego.get("deposit", g * dm if dm else 0))
+    rf = nego.get("risk_reserve_pct", 3)
+    pf = nego.get("platform_fee_pct", 5)
+    ep = nego.get("exit_penalty_months", 3)
+    c  = nego.get("settlement_cycle", "月结")
+    y  = nego.get("contract_years", 1)
+
+    return (
+        f"经营权共创合同规则草案（模板）\n"
+        f"{'='*40}\n"
+        f"资产方：{asset.get('owner','待确认')}    经营方：{operator.get('name','待确认')}\n"
+        f"标的资产：{asset.get('name','未命名')} ({asset.get('area',0)}m²)\n\n"
+        f"第一条 收益分配规则\n"
+        f"  1.1 保底收益: {g:,}元/月 [系统可执行]\n"
+        f"  1.2 流水分润: 月流水超过{b:,}元后，资产方按{s}%分润 [系统可执行]\n"
+        f"  1.3 平台服务费: 月流水的{pf}% [系统可执行]\n"
+        f"  1.4 风险准备金: 月流水的{rf}%，累计至3个月保底额度后暂停 [系统可执行]\n\n"
+        f"第二条 结算条款\n"
+        f"  2.1 结算周期: {c} [系统可执行]\n"
+        f"  2.2 保底补足: 当月流水分润低于保底金额时，由经营方补足差额 [需人工确认]\n\n"
+        f"第三条 保证金\n"
+        f"  3.1 保证金: {d:,}元，签约时一次性缴纳 [需人工确认]\n"
+        f"  3.2 用途: 用于弥补违约、欠费等损失 [系统可执行]\n\n"
+        f"第四条 合同期限与退出\n"
+        f"  4.1 合同年限: {y}年 [系统可执行]\n"
+        f"  4.2 提前退出违约金: {ep}个月保底金额（即{g*ep:,}元）[需人工确认]\n\n"
+        f"【风险评级: {'低' if g>0 and d>0 else '中'}】[建议律师审核]"
+    )