chore: evolution目录删除入库(昨日归档收尾)+analyst知识日志更新

2026-08-25 13:26:41 +08:00
parent 6b91065538
commit 67ed1ec9bd
10 changed files with 106 additions and 1686 deletions
@@ -79,3 +79,109 @@ system_audit 报 MEDIUM：6个陈旧.pyc（accumulation_scanner/batch_reassess/s

 ### [2026-08-18 11:52] 盘中自检宏观HIGH误报·美债收益率主题同日第5次重写（TODO#296）
 **闭环记录：** 11:31 执行器推送宏观HIGH「美债收益率飙升！华尔街拉响警报：美联储9月加息风险并未解除」——采集器 ID=1945 原始 HIGH，当日同主题第5次（1933/1938/1940/1942/1945）。判 MEDIUM（延续 ID=1935/1939 既定判定：30Y美债19年新高真实渠道 + 城堡证券警告属预期非政策兑现）。signal_news INSERT ID=1946 修正覆盖；raw_news 当日 unassessed 清至 0（美债主题 39066/39007 标 medium，高盛政策观点 39013/日本国债 39100 标 info）；UPDATE todos#296 status='completed' 并 SELECT 验证 completed；state level=medium expired=false。根因同前（采集器利率关键词粗筛+LLM cron 流式失败），不重复展开。
+
+### [2026-08-18 13:54] 盘中自检宏观HIGH误报·粮食ETF主题同日第2次重写（TODO#298 执行器重试变体）
+**闭环记录：** 13:31 执行器推送宏观HIGH「粮食ETF景顺涨近4%！新一轮全球粮食危机或于2027年上半年爆发」——采集器 ID=1949 原始 HIGH，当日粮食主题第2次（10:31 ID=1942→1943、13:31 ID=1949→1950）。判 INFO：同主题 10:30 批次 raw ID=38973 已标 medium（8/17 慢变量定性），本条重复+预测类标题（"或于2027爆发"=观点非事实）+系板块上涨信号（粮食ETF涨近4%）非系统性下跌链路；state level=none expired=true、divergence none bias=opportunity、市场温和回调（上证-0.38%/创业板-1.76%）无系统性崩盘。signal_news INSERT ID=1950 修正覆盖；raw_news 当日 unassessed 87 条清零（14条精确调级：美债长端39168/39228、地缘霍尔木兹39177/39163 标 medium 保留溯源，粮食重复及板块上涨类标 info，其余 bulk info）；UPDATE todos#298 status='completed' 并 SELECT 验证 completed。
+**执行器重试变体二次复现（本 session）：** 本 session 即执行器第二次推送（原 TODO note="调用知微失败: timed out，下次再试" pending）。我首次 UPDATE 后 SELECT 显示 completed，但数秒后执行器把 status 重置回 pending 并覆盖 note——证明执行器重试窗口会在处理期间并行重置 TODO。正确处理：UPDATE 后必须立即 SELECT 确认，若又变 pending 需再次 UPDATE，最终以稳定 completed 为准。与 8/13#269/8/14#273/8/18#294 同型，本次为第4次复现。
+
+## [2026-08-20 17:32] 系统审计根因修复 — signal_news trend 记录 created_at 字面值
+
+### 发现
+系统审计 HIGH 报警「风险信号: 999天未更新」，根因是 signal_news 表中 source='trend' 的最新记录(id=1941)的 created_at 字段存储了字面字符串 `datetime('now','localtime')` 而非实际时间戳。SQLite 在写入时未调用 datetime() 函数，导致后续比较时无法解析为有效日期，计算出"999天"。
+
+### 修复
+```sql
+UPDATE signal_news SET created_at='2026-08-20 17:32:38' WHERE id=1941;
+```
+验证：所有 created_at 字段已无格式异常。
+
+### 根因
+写入 trend 记录的代码（可能是 trend_analyzer.py 或 signal_collector.py）使用了 `datetime('now','localtime')` 作为 Python 字符串而非 SQL 函数。当通过 Python sqlite3 的 `INSERT ... VALUES (?)` 参数化写入时，Python 会将该字符串作为纯文本存储，不会触发 SQLite 的 datetime() 计算。
+
+### 预防
+- 审查 trend 源的写入逻辑，确认所有 created_at 使用 Python `datetime.now().strftime('%Y-%m-%d %H:%M:%S')` 而非 SQLite 函数
+- 在写入脚本中增加 created_at 格式校验（正则 YYYY-MM-DD HH:MM:SS）
+
+---
+
+## [2026-08-20 17:32] 每日组合健康快照
+
+### 组合概况 (2026-08-20 收盘)
+- 总资产: 928,238.23 CNY
+- 可用现金: 149,518.90 CNY (16.1%)
+- 总仓位: 83.89% (15只活跃持仓)
+- 活跃策略: 112条
+
+### 持仓盈亏分布
+| 类别 | 数量 | 标的 |
+|------|------|------|
+| 盈利 | 3只 | 华茂+9.19%, 爱博+4.46%, 腾讯+0.96% |
+| 小亏<10% | 4只 | 影石-8.78%, 宁德-3.84%, 神华-4.03%, 广信-0.8% |
+| 中亏10-30% | 4只 | 紫金-14.14%, 比亚-12.97%, 华恒-19.33%, 海博-25.09% |
+| 深套>30% | 4只 | 科电-36.34%, 万科-48.19%, 丘钛-50.68%, 黄金ETF-24.29% |
+
+### ⚠️ 风险关注（RR<1.0 的持仓）
+| 标的 | RR | 止损 | 现价 | 类型 |
+|------|-----|------|------|------|
+| 300035 中科电气 | 0.5 | 12.78 | 14.19 | 深套 |
+| 02202 万科企业 | 0.6 | 2.31 | 2.44 HKD | 深套 |
+| 688639 华恒生物 | 0.8 | 15.75 | 17.35 | 中短线 |
+| 01088 中国神华 | 0.9 | 42.5 | 44.44 HKD | 中短线 |
+
+### ⚠️ 距止损不足5%
+| 标的 | 现价 | 止损 | 距离 |
+|------|------|------|------|
+| 300750 宁德时代 | 385.0 | 377.0 | 2.1% |
+| 603599 广信股份 | 10.14 | 9.9 | 2.4% |
+| 000850 华茂股份 | 4.19 | 4.04 | 3.6% |
+| 01088 中国神华 | 44.44 | 42.5 | 4.4% |
+
+### 在买入区内的持仓
+| 标的 | 现价 | 买入区 | RR |
+|------|------|--------|-----|
+| 000850 华茂股份 | 4.19 | 4.04-4.22 | 2.9 |
+| 300750 宁德时代 | 385.0 | 383.02-387.56 | 1.2 |
+| 300035 中科电气 | 14.19 | 12.66-14.77 | 0.5 |
+| 02202 万科企业 | 2.44 | 2.2-2.56 | 0.6 |
+| 688639 华恒生物 | 17.35 | 16.59-17.36 | 0.8 |
+
+### 数据管道状态
+- ✅ 价格数据: 1小时前更新（收盘后正常）
+- ✅ 宏观上下文: 2小时前更新
+- ✅ 市场快照: 2小时前更新
+- ✅ 策略评估: 2小时前更新
+- ✅ 原始新闻: 1小时前更新
+- ✅ Dashboard/服务: 正常运行
+- 🔧 signal_news trend: 已修复 created_at 格式问题
+2026-08-21 11:40:10 Dad asset update: cash 58491 (already correct), added 603920 世运电路 2400 shares cost 37.93, total_mv fixed to 869472.60 (HKD converted), total_assets=927963.65, position_pct=93.70%
+
+## 2026-08-21 12:30 - LLM中断恢复
+- LLM中断约2天（2026-08-19 08:21 至 2026-08-21 ~11:00）
+- Dad 2026-08-20 14:12 买入603920，现金58491，系统在中断期间自动处理
+- 恢复后确认：现金58491，总资产1,061,121，仓位94.5%
+
+## 2026-08-25 13:15 price_monitor.py 市值同步bug
+
+**问题**: price_monitor.py 第464行更新price后未重算market_value，导致holdings.market_value与实时价漂移。
+
+**根因代码** (deploy/profile-scripts/price_monitor.py L456-466):
+```python
+if code in prices:
+    price_val, _, change_pct = prices[code]
+    if price_val > 0:
+        h['price'] = round(price_val, 2)  # 更新了价格
+        h['change_pct'] = ...  # 更新了涨跌幅
+        # 但没有重算 h['market_value']!
+```
+
+**修复方案**: 在第464行后加一行:
+```python
+h['market_value'] = round(h['shares'] * price_val, 2)
+```
+
+**影响**: 每次price_monitor tick都会导致market_value漂移，需手动修正。
+
+**临时修正**: 已用live_prices全量重算holdings.market_value (2026-08-25 13:15)
+
+**待办**: 需要笑笑审核并提交代码修复 (kanban API不可用，已记录)
+
@@ -1,70 +0,0 @@
-"""
-evolution/__init__.py — 自我进化模块
-Loop Engineering: 策略健康度监控 + 教训提取 + 自动迭代
-"""
-import sqlite3, os
-
-DB = os.environ.get('MOFIN_DB', '/home/hmo/MoFin/data/mofin.db')
-
-def init_evolution_tables(conn=None):
-    """初始化进化模块数据表"""
-    close_conn = False
-    if conn is None:
-        conn = sqlite3.connect(DB)
-        close_conn = True
-    
-    # 策略健康度每日快照
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS strategy_health (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            strategy_version TEXT NOT NULL,
-            date TEXT NOT NULL,
-            live_trades INTEGER DEFAULT 0,
-            live_wins INTEGER DEFAULT 0,
-            live_return_pct REAL DEFAULT 0,
-            backtest_wr REAL DEFAULT 0,
-            backtest_avg_ret REAL DEFAULT 0,
-            deviation REAL DEFAULT 0,
-            health_score REAL DEFAULT 0,
-            created_at TEXT DEFAULT (datetime('now','localtime')),
-            UNIQUE(strategy_version, date)
-        )
-    """)
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_health_version_date ON strategy_health(strategy_version, date)")
-    
-    # 教训库
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS strategy_lessons (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            strategy_version TEXT NOT NULL,
-            trade_id INTEGER,
-            lesson_type TEXT NOT NULL,
-            lesson_text TEXT NOT NULL,
-            confidence REAL DEFAULT 0.5,
-            applied INTEGER DEFAULT 0,
-            created_at TEXT DEFAULT (datetime('now','localtime'))
-        )
-    """)
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_lessons_version ON strategy_lessons(strategy_version, applied)")
-    
-    # 策略迭代历史
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS strategy_evolution (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            parent_version TEXT NOT NULL,
-            child_version TEXT NOT NULL,
-            change_description TEXT,
-            backtest_result TEXT,
-            promoted INTEGER DEFAULT 0,
-            created_at TEXT DEFAULT (datetime('now','localtime'))
-        )
-    """)
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_evolution_parent ON strategy_evolution(parent_version, promoted)")
-    
-    conn.commit()
-    if close_conn:
-        conn.close()
-
-if __name__ == '__main__':
-    init_evolution_tables()
-    print("进化模块数据表初始化完成")
@@ -1,200 +0,0 @@
-# -*- coding: utf-8 -*-
-"""evolution/b_group_miner.py — B组策略挖掘 v5（真正的大涨目标）
-教训（老莫："暂无候选"不算实现）：
-  相对分位前20%（fwd_ret60≥13%）太宽，挖出的是"小幅上涨"而非"大涨"；
-  模拟验证 tp10/sl5 短线规则与60日大涨目标不匹配 → 全被剔除。
-修正：
-  果 = fwd_ret60 >= 30%（绝对大涨，趋势市基线7.8%）
-  因子组合扫描找大涨率显著提升
-  模拟验证用匹配大涨的规则（tp20%/sl10%/maxh40）+ 扫描最优参数
-"""
-import json
-import sqlite3
-import numpy as np
-import pandas as pd
-from datetime import datetime
-from itertools import combinations
-
-DATA_DIR = "/home/hmo/MoFin/data"
-OUT_JSON = f"{DATA_DIR}/b_group_candidates.json"
-BIG_TH = 30  # 大涨目标
-
-
-def load_regime_map(market="a"):
-    conn = sqlite3.connect("/home/hmo/MoFin/data/mofin.db", timeout=10)
-    rows = conn.execute("SELECT date, regime FROM market_regime WHERE market=?", (market,)).fetchall()
-    conn.close()
-    return {d: r for d, r in rows}
-
-
-def load_panel(market):
-    path = "/tmp/panel_12d_hk.pkl" if market == "hk" else "/tmp/panel_12d.pkl"
-    p = pd.read_pickle(path)
-    p = p.sort_values(["code", "date"]).reset_index(drop=True)
-    p["fwd_ret60"] = p.groupby("code")["close"].transform(lambda x: x.shift(-60) / x - 1) * 100
-    return p
-
-
-def scan_big(market, regime, panel, min_n=500):
-    """扫描因子组合：找绝对大涨率显著提升的组合"""
-    rm = load_regime_map(market)
-    p = panel.copy()
-    p["_regime"] = p["date"].map(rm)
-    sub = p[p["_regime"] == regime].dropna(subset=["fwd_ret60"])
-    if len(sub) < min_n:
-        return []
-    sub["is_big"] = (sub["fwd_ret60"] >= BIG_TH).astype(int)
-    br = sub["is_big"].mean() * 100
-    print(f"[{market}/{regime}] 样本{len(sub)} 基线大涨率(60d>={BIG_TH}%){br:.1f}%")
-
-    # 因子池（方向：大盘弱 + 个股超跌 + 小盘低估值 + 基本面催化）
-    factor_defs = {
-        "mkt_ret20": ("<", 0), "mkt_rsi": ("<", 50), "mkt_adx": (">", 20),
-        "bias60": ("<", -10), "rsi": ("<", 40), "dist_lo20": (">", 5),
-        "mcap_q": ("<", 0.3), "pe_q": ("<", 0.3), "pb_q": ("<", 0.3),
-        "sec_ret20": ("<", 0), "news3": (">=", 1), "vol_ratio": (">", 1.2),
-        "ret20": ("<", 0), "flow5": (">", 0),
-    }
-    # 单条件测试
-    single = []
-    for feat, (op, val) in factor_defs.items():
-        if feat not in sub.columns:
-            continue
-        cond = sub[feat] < val if op == "<" else sub[feat] > val
-        m = sub[cond]
-        if len(m) < 200:
-            continue
-        rate = m["is_big"].mean() * 100
-        if rate > br + 0.5:  # 单条件提升>0.5pp 进组合池（多因子叠加才有大提升）
-            single.append((feat, round(rate, 1), len(m), round(rate - br, 1)))
-    single.sort(key=lambda x: -x[3])
-    print("  单条件:", single[:6])
-
-    # 4-6 因子组合（从单条件提升>0.5pp 里取 8 个，测 4/5/6 组合）
-    pool = [s[0] for s in single if s[3] > 0.5][:8]
-    results = []
-    for k in [4, 5, 6]:
-        for combo in combinations(pool, k):
-            cond = pd.Series(True, index=sub.index)
-            for feat in combo:
-                op, val = factor_defs[feat]
-                cond &= (sub[feat] < val) if op == "<" else (sub[feat] > val)
-            m = sub[cond]
-            if len(m) < 200:
-                continue
-            rate = m["is_big"].mean() * 100
-            avg = m["fwd_ret60"].mean()
-            results.append(({f: factor_defs[f] for f in combo}, len(m), round(rate, 1),
-                            round(avg, 1), round(rate - br, 1), len(combo)))
-    results.sort(key=lambda x: -x[4])
-    return results[:5]
-
-
-def _simulate_verify(market, regime, panel, cond, tp=20, sl=10, maxh=40):
-    """模拟验证：候选在温区的模拟交易（大涨匹配规则）"""
-    rm = load_regime_map(market)
-    sub = panel.copy()
-    sub["_regime"] = sub["date"].map(rm)
-    sub = sub[(sub["_regime"] == regime) & cond].copy()
-    if len(sub) < 200:
-        return None
-    sub = sub.sort_values(["code", "date"])
-    trades = []
-    trade_details = []
-    for code, g in sub.groupby("code"):
-        g = g.sort_values("date")
-        idxs = list(g.index)
-        for k, i in enumerate(idxs):
-            fut = g.iloc[k+1:k+maxh+1]
-            if len(fut) < 2:
-                continue
-            ep = g.loc[i, "close"]
-            if ep <= 0:
-                continue
-            res = None
-            hold_days = maxh
-            for j, (_, fb) in enumerate(fut.iterrows()):
-                if fb["close"] <= ep * (1 - sl / 100):
-                    res = -sl
-                    hold_days = j + 1
-                    break
-                if fb["close"] >= ep * (1 + tp / 100):
-                    res = tp
-                    hold_days = j + 1
-                    break
-            if res is None:
-                res = (fut.iloc[-1]["close"] / ep - 1) * 100
-                hold_days = len(fut)
-            trades.append(res)
-            trade_details.append({"entry_date": str(g.loc[i, "date"]), "pnl_pct": round(res, 2),
-                                  "profit_pct": round(res, 2), "hold_days": hold_days,
-                                  "code": str(code)})
-    if not trades:
-        return None
-    wins = [x for x in trades if x > 0]
-    if not trades:
-        return None
-    return {"n": len(trades), "win_rate": len(wins) / len(trades) * 100,
-            "avg_pnl": sum(trades) / len(trades), "trades": trade_details}
-
-
-def to_entry(cond_dict):
-    entry = {}
-    for feat, (op, val) in cond_dict.items():
-        key = feat + ("_min" if (op == ">" or op == ">=") else "_max")
-        entry[key] = float(val)
-    return entry
-
-
-def mine(market="a", regimes=None):
-    regimes = regimes or ["trend_up", "choppy", "trend_down"]
-    panel = load_panel(market)
-    out = {"market": market, "mined_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "candidates": []}
-    for rg in regimes:
-        combos = scan_big(market, rg, panel)
-        for cond, n, rate, avg, extra, nf in combos[:3]:
-            c = pd.Series(True, index=panel.index)
-            for feat, (op, val) in cond.items():
-                if feat not in panel.columns:
-                    c = None
-                    break
-                c &= (panel[feat] < val) if op == "<" else (panel[feat] > val)
-            verified = None
-            if c is not None:
-                # 多参数模拟验证，取最优
-                # 先筛胜率≥50%的参数，再取其中收益最高（2026-08-16 修正：原取收益最高可能选中胜率<50%参数）
-                passed_params = []
-                for tp, sl, mh in [(20, 10, 40), (25, 10, 45), (30, 12, 50), (15, 8, 35)]:
-                    r = _simulate_verify(market, rg, panel, c, tp, sl, mh)
-                    if r and r["win_rate"] >= 50 and r["avg_pnl"] > 0:
-                        passed_params.append((tp, sl, mh, r))
-                if passed_params:
-                    best = max(passed_params, key=lambda x: x[3]["avg_pnl"])
-                    tp, sl, mh, rd = best
-                    tn, twr, tavg = rd["n"], rd["win_rate"], rd["avg_pnl"]
-                    if twr >= 50 and tavg > 0:
-                        cand = {
-                            "regime": rg, "market": market, "group": "B", "status": "verified",
-                            "entry": to_entry(cond), "trades_est": n, "big_rate": rate,
-                            "avg60": avg, "excess_pp": extra,
-                            "sim_trades": tn, "sim_win_rate": round(twr, 1), "sim_avg_pnl": round(tavg, 2),
-                            "sim_tp": tp, "sim_sl": sl, "sim_maxh": mh,
-                            "trades": rd.get("trades", []),
-                            "hypothesis": f"[{rg}] 由果及因{nf}因子: {list(cond.keys())} → 大涨率{rate}%(基线+{extra}pp)",
-                        }
-                        out["candidates"].append(cand)
-                        print(f"  [{rg}] {list(cond.keys())} ✅大涨率{rate}% 模拟胜率{twr:.0f}%/均{tavg:.2f}%", flush=True)
-                    else:
-                        print(f"  [{rg}] {list(cond.keys())} 模拟未达标(胜率{twr:.0f}%/均{tavg:.2f}%) 剔除", flush=True)
-                else:
-                    print(f"  [{rg}] {list(cond.keys())} 模拟无结果 剔除", flush=True)
-    return out
-
-
-if __name__ == "__main__":
-    import sys
-    market = sys.argv[1] if len(sys.argv) > 1 else "a"
-    res = mine(market)
-    with open(OUT_JSON, "w", encoding="utf-8") as f:
-        json.dump(res, f, ensure_ascii=False, indent=1)
-    print(f"写入 {OUT_JSON}: {len(res['candidates'])} 个候选")
@@ -1,256 +0,0 @@
-"""
-evolution/evolution_api.py — 进化模块 API 接口
-供 dashboard 查询健康度、教训、迭代历史
-"""
-import sys, os, json, sqlite3
-
-sys.path.insert(0, '/home/hmo/MoFin')
-sys.path.insert(0, '/home/hmo/MoFin/deploy/profile-scripts')
-
-DB = os.environ.get('MOFIN_DB', '/home/hmo/MoFin/data/mofin.db')
-
-
-def get_evolution_dashboard():
-    """进化模块 Dashboard 数据"""
-    conn = sqlite3.connect(DB)
-    conn.row_factory = sqlite3.Row
-    
-    # 最近健康度（近30天）
-    health = []
-    for r in conn.execute("""
-        SELECT strategy_version, date, live_trades, live_wins, live_return_pct,
-               backtest_wr, backtest_avg_ret, deviation, health_score
-        FROM strategy_health ORDER BY date DESC LIMIT 30
-    """).fetchall():
-        health.append(dict(r))
-    
-    # 最近教训（近20条）
-    lessons = []
-    for r in conn.execute("""
-        SELECT strategy_version, lesson_type, lesson_text, confidence, applied, created_at
-        FROM strategy_lessons ORDER BY id DESC LIMIT 20
-    """).fetchall():
-        lessons.append(dict(r))
-    
-    # 迭代历史
-    evolution = []
-    for r in conn.execute("""
-        SELECT parent_version, child_version, change_description, promoted, created_at
-        FROM strategy_evolution ORDER BY id DESC LIMIT 20
-    """).fetchall():
-        evolution.append(dict(r))
-    
-    # 当前策略基线（2026-08-15: 数据驱动——跟随 strategy_weights.json 激活集合，
-    # 原硬编码 ['v_weak','v_oversold'] 与温区路由脱节，激活策略换了一批但基线还显示旧的）
-    def _active_versions():
-        try:
-            d = json.loads(open('/home/hmo/MoFin/data/strategy_weights.json', encoding='utf-8').read())
-            vs = list(d.get('active') or [])
-            vs += list(((d.get('markets') or {}).get('hk') or {}).get('active') or [])
-            seen, out = set(), []
-            for v in vs:
-                if v and v not in seen:
-                    seen.add(v)
-                    out.append(v)
-            return out or ['v_weak', 'v_oversold']
-        except Exception:
-            return ['v_weak', 'v_oversold']
-    baseline = {}
-    for v in _active_versions():
-        r = conn.execute("""
-            SELECT results_json FROM strategy_research 
-            WHERE version=? AND period_tag='5y' ORDER BY id DESC LIMIT 1
-        """, (v,)).fetchone()
-        if r:
-            res = json.loads(r[0])
-            s = res.get('summary', {})
-            pf = s.get('portfolio_full', {})
-            baseline[v] = {
-                'win_rate': s.get('win_rate', 0),
-                'total_return': pf.get('total_return_pct', 0),
-                'cagr': pf.get('cagr_pct', 0),
-                'max_dd': pf.get('portfolio_max_dd_pct', 0),
-            }
-    
-    # ── 2026-08-16 进化机制数据：读预计算快照（precompute_evolution.py 定期生成，避免实时重算）──
-    hypotheses = []
-    b_group = []
-    qual_overview = []
-    try:
-        _ec = json.loads(open('/home/hmo/MoFin/data/evolution_center.json', encoding='utf-8').read())
-        hypotheses = _ec.get('hypotheses', [])
-        b_group = _ec.get('b_group', [])
-        qual_overview = _ec.get('qual_overview', [])
-    except Exception:
-        pass
-
-    conn.close()
-    
-    return {
-        'health': health,
-        'lessons': lessons,
-        'evolution': evolution,
-        'baseline': baseline,
-        'hypotheses': hypotheses,
-        'b_group': b_group,
-        'qual_overview': qual_overview,
-    }
-
-
-def get_combo_dashboard():
-    """组合方案 Dashboard 数据 (2026-08-02 新增)
-    返回: 当前组合方案(v_next4+v_mr按regime分工) + 组合回测版本(v_combo) + 市场阶段
-    """
-    conn = sqlite3.connect(DB)
-    conn.row_factory = sqlite3.Row
-
-    # 1. 当前市场阶段 (market_regime)
-    regime = None
-    r = conn.execute("SELECT * FROM market_regime ORDER BY date DESC LIMIT 1").fetchone()
-    if r:
-        regime = dict(r)
-
-    # 2. 组合回测版本 (v_combo 家族)
-    combos = []
-    rows = conn.execute(
-        "SELECT id, version, market, period_tag, created_at, results_json"
-        " FROM strategy_research WHERE version LIKE '%combo%' OR version LIKE 'v_combo%'"
-        " ORDER BY id DESC"
-    ).fetchall()
-    for r in rows:
-        d = dict(r)
-        res = json.loads(d.pop("results_json") or "{}")
-        s = res.get("summary", {})
-        pf = s.get("portfolio_full", {})
-        p5 = s.get("portfolio", {})
-        d["summary_stats"] = {
-            "total_trades": s.get("total_trades"),
-            "win_rate": s.get("win_rate"),
-            "avg_profit_pct": s.get("avg_profit_pct"),
-            "avg_hold_days": s.get("avg_hold_days"),
-            "sharpe_ratio": s.get("sharpe_ratio"),
-            "profit_factor": s.get("profit_factor"),
-            "universality": s.get("universality", {}),
-            "portfolio": p5,
-            "portfolio_full": pf,
-        }
-        combos.append(d)
-
-    # 3. 组合成员策略的独立指标
-    # 2026-08-11 更新：组合成员 = v_weak（实盘）+ p_oversold（新策略），替代旧的 v_next4+v_mr
-    # v_next4 移除（池内卫星仓，全市场失效；现有池子票不是它选的）
-    members = {}
-    for v in ["v_weak", "p_oversold"]:
-        sel_v = "v_weak" if v == "v_mr" else None
-        # 2026-08-12: p_oversold 实盘名 → 回测数据存 v_oversold（研究名），两个都查
-        candidates = ["v_oversold", "p_oversold"] if v == "p_oversold" else (["v_weak", "v_mr_sel", v] if sel_v else [v])
-        r = None
-        used_sel = False
-        for cv in candidates:
-            r = conn.execute(
-                "SELECT results_json FROM strategy_research"
-                " WHERE version=? AND period_tag='10y' ORDER BY id DESC LIMIT 1",
-                (cv,),
-            ).fetchone()
-            if r:
-                used_sel = (cv == "v_weak")
-                break
-        if r:
-            res = json.loads(r[0])
-            s = res.get("summary", {})
-            pf = s.get("portfolio_full", {})
-            p5 = s.get("portfolio", {})
-            members[v] = {
-                "role": "弱市超跌确认（实盘）" if v == "v_weak" else "预测超跌反弹（新策略）",
-                "version": ("v_weak" if used_sel else "v_mr") if v == "v_mr" else v,
-                "is_sel": used_sel,
-                "trades": s.get("total_trades"),
-                "win_rate": s.get("win_rate"),
-                "avg_profit_pct": s.get("avg_profit_pct"),
-                "avg_hold_days": s.get("avg_hold_days"),
-                "cagr_pct": p5.get("cagr_pct"),
-                "return_pct": p5.get("total_return_pct"),
-                "max_dd_pct": p5.get("portfolio_max_dd_pct"),
-                "slots": p5.get("slots") or 6,
-                "universality": s.get("universality", {}),
-                # 组合模拟实际执行笔数(扣费后) + 年均(手工可行性参考)
-                "positions_taken_5slot": p5.get("positions_taken"),
-                "positions_taken_full": pf.get("positions_taken"),
-            }
-    # 2026-08-11：p_oversold 无回测数据时给兜底卡片（新策略待回测）
-    if "p_oversold" not in members:
-        members["p_oversold"] = {
-            "role": "预测超跌反弹（新策略）",
-            "version": "p_oversold",
-            "is_sel": False,
-            "trades": None, "win_rate": None, "avg_profit_pct": None,
-            "avg_hold_days": None, "cagr_pct": None, "return_pct": None,
-            "max_dd_pct": None, "slots": 10,
-            "universality": {},
-            "positions_taken_5slot": None, "positions_taken_full": None,
-            "note": "新策略，待回测/实盘验证",
-        }
-
-    conn.close()
-
-    # 2026-08-13 温区自适应：并入 strategy_weights.json（当前温区+温度+各策略权重/激活）
-    # + strategy_alerts.json（三振出局状态）
-    import json as _json
-    from pathlib import Path as _Path
-    _d = _Path("/home/hmo/MoFin/data")
-    weights_data = None
-    alerts_data = None
-    try:
-        _w = _d / "strategy_weights.json"
-        if _w.exists():
-            weights_data = _json.loads(_w.read_text(encoding="utf-8"))
-    except Exception:
-        pass
-    try:
-        _a = _d / "strategy_alerts.json"
-        if _a.exists():
-            alerts_data = _json.loads(_a.read_text(encoding="utf-8"))
-    except Exception:
-        pass
-
-    return {
-        "regime": regime,
-        "regime_weights": weights_data,   # 当前温区/温度/各策略权重/激活
-        "strategy_alerts": alerts_data,   # 三振出局状态
-        "combos": combos,
-        "members": members,
-        "routing": [
-            {"regime": "trend_up", "active": "p_oversold", "action": "预测超跌反弹", "desc": "趋势市/反弹期, p_oversold 预测超跌反弹"},
-            {"regime": "choppy", "active": "v_weak", "action": "弱市超跌确认", "desc": "震荡/下跌市, v_weak 均值回复主战场"},
-            {"regime": "trend_down", "active": "v_weak", "action": "深超跌管理", "desc": "下跌市, v_weak 管理超跌持仓"},
-        ],
-    }
-
-
-def get_health_trend(version='v_weak', days=30):
-    """健康度趋势"""
-    conn = sqlite3.connect(DB)
-    conn.row_factory = sqlite3.Row
-    rows = conn.execute("""
-        SELECT date, health_score, deviation, live_trades
-        FROM strategy_health WHERE strategy_version=? ORDER BY date DESC LIMIT ?
-    """, (version, days)).fetchall()
-    conn.close()
-    return [dict(r) for r in rows]
-
-
-def record_evolution(parent, child, description, backtest_result=None, promoted=0):
-    """记录一次策略迭代"""
-    conn = sqlite3.connect(DB)
-    conn.execute("""
-        INSERT INTO strategy_evolution (parent_version, child_version, change_description, backtest_result, promoted)
-        VALUES (?, ?, ?, ?, ?)
-    """, (parent, child, description, json.dumps(backtest_result) if backtest_result else None, promoted))
-    conn.commit()
-    conn.close()
-
-
-if __name__ == '__main__':
-    d = get_evolution_dashboard()
-    print(f"健康度: {len(d['health'])}条, 教训: {len(d['lessons'])}条, 迭代: {len(d['evolution'])}条")
-    print(f"基线: {list(d['baseline'].keys())}")
@@ -1,438 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-evolution/evolution_engine.py — 策略自我进化引擎（每周六 22:00，hermes cron）
-
-设计依据：docs/decisions/2026-08-15-策略自我进化闭环重构.md（老莫已批准）
-闭环：统计数据每日自动更新 → 本引擎每周检测退化 → 生成参数变体 → 回测验证 → 有价值才推送
-
-流程：
-  1. 读激活策略集合（data/strategy_weights.json：A股 active + 港股 markets.hk.active）
-  2. 退化信号检测（宁缺毋滥，任一命中即触发研究）：
-     S1 健康度连续低：strategy_health 连续 5 天 health_score < 40（排除 50 中性=无实盘数据）
-     S2 温区表现衰减：激活策略在其适应温区（strategy_regime_perf）温区级组合年化 cagr_pct < 0
-  3. 有退化 → 生成参数变体：
-     - 只对 lab.STRATEGIES 里可回测的策略（v_oversold/v_weak 等标准回测体系）
-     - 参数空间从策略 config 实际数值字段出发（递归遍历，单变量 ±20%，一次只动一个）
-     - 港股走 hk_backtest（entry/exit 字段 ±20%）
-  4. 回测验证（统一资金约束）：
-     - A股：lab.run_backtest(save=False)，取 portfolio_full
-     - 港股：hk_backtest.gen_trades_defensive + lab.portfolio_sim(max_positions=8)
-     - 验收：温区级组合年化 cagr_pct ≥ 原策略 + 3pp 且 max_dd 不劣化超过 2pp
-  5. 达标变体 → 写 strategy_evolution（promoted=0）+ XMPP 推送老莫（附对比证据）
-     （永不自动 promote，老莫说"上线"才进路由）
-  6. 无退化或变体全灭 → 当周静默（不制造噪音）
-
-单例守卫：fcntl.flock 防并发（deploy_guard / 手动重跑均安全）
-"""
-import sys, os, json, sqlite3, copy, io, traceback
-from datetime import datetime, timedelta
-
-sys.path.insert(0, "/home/hmo/MoFin")
-sys.path.insert(0, "/home/hmo/MoFin/deploy/profile-scripts")
-sys.path.insert(0, "/home/hmo/MoFin/evolution")
-
-DB = os.environ.get("MOFIN_DB", "/home/hmo/MoFin/data/mofin.db")
-WEIGHTS_JSON = "/home/hmo/MoFin/data/strategy_weights.json"
-
-# 退化信号参数
-HEALTH_LOW = 40          # 健康度低于此值视为低
-HEALTH_STREAK_DAYS = 5   # 连续天数
-REGIME_CAGR_BAD = 0.0    # 温区级组合年化低于此值视为退化
-
-# 变体生成参数
-VAR_PCT = 0.20           # ±20% 网格
-MAX_VARIANTS = 6         # 每策略最多生成变体数
-MAX_VARIANTS_TEST = 1    # 最多回测验证的变体数（资源约束：单变体2y全市场回测6-8分钟/6-8GB，详见下方BT注释）
-
-# 验证回测周期（2026-08-15：原5y全市场回测单变体8+分钟/5GB内存，改为2y控制资源；
-# 验收对比用同周期原策略数据，相对改善仍有效）
-BT_START = "2024-07-01"
-BT_END = "2026-07-24"
-BT_PERIOD_TAG = "2y"
-
-# 验收门槛（2026-08-15 口径说明：变体与 parent 用同周期 strategy_research 2y 整体组合年化对比，
-# 相对改善有效；原设计"温区级组合年化"需按温区分段重跑变体，资源过重，整体同口径更务实）
-ACCEPT_CAGR_PP = 3.0     # 组合年化 ≥ 原 + 3pp
-ACCEPT_DD_PP = 2.0       # max_dd 不劣化超过 2pp
-
-
-def log(msg):
-    line = f"[{datetime.now().isoformat(timespec='seconds')}] {msg}"
-    print(line, flush=True)
-
-
-# ── 单例守卫（fcntl，Windows 不可用则跳过）──
-try:
-    import fcntl
-    _LOCK_FD = open("/tmp/evolution_engine.lock", "w")
-    try:
-        fcntl.flock(_LOCK_FD, fcntl.LOCK_EX | fcntl.LOCK_NB)
-    except OSError:
-        log("已有 evolution_engine 实例在运行，退出")
-        sys.exit(0)
-except ImportError:
-    pass
-
-
-def get_conn():
-    conn = sqlite3.connect(DB)
-    conn.row_factory = sqlite3.Row
-    return conn
-
-
-# ── 1. 激活策略集合 ──
-def load_active_strategies():
-    """返回 [(version, market, regime)]：A股 active + 港股 markets.hk.active"""
-    try:
-        d = json.load(io.open(WEIGHTS_JSON, encoding="utf-8"))
-    except Exception as e:
-        log(f"读 strategy_weights.json 失败: {e}")
-        return []
-    out = []
-    for v in (d.get("active") or []):
-        info = (d.get("weights") or {}).get(v, {})
-        out.append({"version": v, "market": "a",
-                    "regime": info.get("best_regime") or info.get("regime") or d.get("state")})
-    hk = (d.get("markets") or {}).get("hk") or {}
-    for v in (hk.get("active") or []):
-        out.append({"version": v, "market": "hk", "regime": hk.get("state")})
-    return out
-
-
-# ── 2. 退化信号检测 ──
-def detect_degradation(conn, version, market):
-    """返回退化原因列表（空=健康）。S1 健康度连续低；S2 温区组合年化<0"""
-    reasons = []
-
-    # S1：健康度连续 5 天 < 40（排除 50 中性=无实盘）
-    rows = conn.execute(
-        "SELECT date, health_score FROM strategy_health WHERE strategy_version=? ORDER BY date DESC LIMIT ?",
-        (version, HEALTH_STREAK_DAYS)).fetchall()
-    if len(rows) >= HEALTH_STREAK_DAYS:
-        scores = [r["health_score"] for r in rows]
-        # 排除"无实盘=50中性"污染：只要连续5天都 < 40 且不是 50 占位
-        if all(s is not None and s < HEALTH_LOW for s in scores) and any(s != 50 for s in scores):
-            reasons.append(f"S1 健康度连续{HEALTH_STREAK_DAYS}天<{HEALTH_LOW}（{scores}）")
-
-    # S2：适应温区温区级组合年化 < 0（strategy_regime_perf.cagr_pct）
-    r = conn.execute(
-        "SELECT regime, cagr_pct, trades FROM strategy_regime_perf WHERE strategy=? AND market=? ORDER BY trades DESC LIMIT 1",
-        (version, market)).fetchone()
-    if r and r["cagr_pct"] is not None and r["cagr_pct"] < REGIME_CAGR_BAD:
-        reasons.append(f"S2 适应温区[{r['regime']}]组合年化{r['cagr_pct']}%<0（{r['trades']}笔）")
-
-    return reasons
-
-
-# ── 3. 变体生成（数据驱动，从实际 config 出发）──
-_NUM_KEYS = ("tp_pct", "sl_pct", "sl_atr", "max_hold_days", "min_score", "min_momentum",
-             "adx_min", "atr_pct_min", "atr_pct_max", "roc_min", "roc_max",
-             "macd_hist_min", "macd_hist_max", "dist_ma20_min", "vol_ratio_min",
-             "vol_ratio_max", "ma20_slope_max", "mkt_slope_max", "mkt_adx_min",
-             "sector_slope_max", "bias_max", "rsi_max", "ret_max", "mom20_max",
-             "amount_max", "rsi_delta_min", "mkt_rsi_max", "mkt_dd60_max",
-             "mcap_q_max", "pe_q_max", "news3_min", "sec_ret20_max",
-             "pe_q_max", "mcap_q_max", "sec_ret20_min", "bias60_max",
-             "vol_ratio_min", "rsi_delta_min", "bias60_min")
-_SKIP_KEYS = ("mode", "family", "launch", "version", "name", "summary", "hypothesis",
-              "mkt_mode", "mkt_above_ma20", "hh_only", "hl_only", "sector_above_ma20")
-
-
-def iter_numeric_fields(node, path=()):
-    """递归遍历 config，产出 (path_list, field_name, value) 数值字段"""
-    if isinstance(node, dict):
-        for k, v in node.items():
-            if k in _SKIP_KEYS:
-                continue
-            if isinstance(v, (int, float)) and not isinstance(v, bool) and k in _NUM_KEYS:
-                yield list(path) + [k], k, v
-            elif isinstance(v, dict):
-                yield from iter_numeric_fields(v, list(path) + [k])
-
-
-def get_parent_cagr(conn, version, market, period_tag=BT_PERIOD_TAG):
-    """原策略基准：优先同周期 strategy_research（period_tag=2y），无则温区级组合年化（全量）"""
-    if market == "a":
-        r = conn.execute(
-            "SELECT results_json FROM strategy_research WHERE version=? AND period_tag=? "
-            "AND market='a' ORDER BY id DESC LIMIT 1", (version, period_tag)).fetchone()
-        if r:
-            res = json.loads(r["results_json"] or "{}")
-            s = res.get("summary", {})
-            pf = s.get("portfolio_full", {})
-            cagr = pf.get("cagr_pct")
-            dd = pf.get("portfolio_max_dd_pct")
-            if cagr is not None:
-                return cagr, dd
-    # 回退：温区级组合年化（strategy_regime_perf，全量）——仅当同周期数据缺失时
-    r = conn.execute(
-        "SELECT cagr_pct, portfolio_max_dd_pct FROM strategy_regime_perf WHERE strategy=? AND market=? ORDER BY trades DESC LIMIT 1",
-        (version, market)).fetchone()
-    if r:
-        return r["cagr_pct"], r["portfolio_max_dd_pct"]
-    return None, None
-
-
-def generate_hypothesis_variants(version, market, base_config, period_tag=BT_PERIOD_TAG):
-    """2026-08-16 数据归纳假设变体：从交易数据归纳可描述条件 → 生成加条件的策略版本
-    假设格式：{feature, direction(max/min), threshold} → 对应入场条件
-    返回 [{version, name, config, change_desc, evidence, hypothesis}]
-    """
-    try:
-        from hypothesis_miner import induce_hypotheses
-        hs, _ = induce_hypotheses(version, market, period_tag=period_tag)
-    except Exception:
-        hs = []
-    variants = []
-    for h in hs[:MAX_VARIANTS_TEST]:
-        feat = h["feature"]
-        direction = h["direction"]
-        threshold = h["threshold"]
-        # 映射到策略 config 的字段（A股 entry.filters/mr，港股 entry 顶层）
-        cfg = copy.deepcopy(base_config)
-        if market == "hk":
-            entry = cfg.get("entry", {})
-        else:
-            entry = cfg.get("entry", {})
-        # 字段名映射：面板字段 → 策略字段（多数同名，A股 mr 下）
-        key = feat
-        target = entry
-        # A股 config 是 {entry:{filters,mr}} 结构，找可放的位置
-        if market != "hk":
-            if "mr" in entry:
-                target = entry["mr"]
-            elif "filters" in entry:
-                target = entry["filters"]
-        if direction == "max":
-            target[key + "_max"] = threshold
-        else:
-            target[key + "_min"] = threshold
-        vname = f"evo_{version}_{key}_{direction}{threshold}"
-        variants.append({
-            "version": vname,
-            "name": f"自进化-{version}-规避{key}{direction}{threshold}",
-            "config": cfg,
-            "change_desc": f"[数据归纳] {h['hypothesis']}",
-            "evidence": h.get("evidence", ""),
-            "hypothesis": h.get("hypothesis", ""),
-            "field": key,
-            "delta": 0,
-        })
-    return variants
-
-
-def generate_variants(version, market, config):
-    """生成变体参数建议：单变量 ±20%，最多 MAX_VARIANTS 个
-    返回 [{version, name, config, change_desc, field, delta}]"""
-    fields = list(iter_numeric_fields(config))
-    if not fields:
-        return []
-    variants = []
-    for path, fname, val in fields:
-        if val <= 0:
-            continue
-        for factor, tag in [(1 - VAR_PCT, "减20%"), (1 + VAR_PCT, "加20%")]:
-            new_val = round(val * factor, 4)
-            if new_val <= 0:
-                continue
-            # 克隆 config 并修改目标字段
-            new_cfg = copy.deepcopy(config)
-            node = new_cfg
-            for p in path[:-1]:
-                node = node[p]
-            node[path[-1]] = new_val
-            variants.append({
-                "version": f"evo_{version}_{fname}_{tag.replace('20%','')}{round(new_val, 2)}",
-                "name": f"自进化-{version}-{fname}{tag}",
-                "config": new_cfg,
-                "change_desc": f"{fname}: {val} → {new_val}（{tag}）",
-                "field": fname,
-                "delta": round(new_val - val, 4),
-            })
-            if len(variants) >= MAX_VARIANTS:
-                return variants
-    return variants
-
-
-# ── 4. 回测验证 ──
-def verify_variant_a(variant, parent_version):
-    """A股变体验证：注册进 lab 跑回测（save=False），返回 summary 关键指标"""
-    import strategy_lab as lab
-    name = variant["version"]
-    base = lab.get_strategy(parent_version)
-    cfg = copy.deepcopy(base)
-    cfg["version"] = name
-    cfg["name"] = variant["name"]
-    # 用变体 config 覆盖（变体 config 从原 config 克隆并改了一个字段）
-    merged = copy.deepcopy(base["config"])
-    _deep_update(merged, variant["config"])
-    cfg["config"] = merged
-    lab.STRATEGIES[name] = cfg
-    try:
-        r = lab.run_backtest(name, BT_START, BT_END, 913000, save=False,
-                             universe="a", period_tag=BT_PERIOD_TAG)
-        s = r.get("summary", {})
-        pf = s.get("portfolio_full", {})
-        return {
-            "trades": s.get("total_trades"),
-            "win_rate": s.get("win_rate"),
-            "cagr": pf.get("cagr_pct"),
-            "total_return": pf.get("total_return_pct"),
-            "max_dd": pf.get("portfolio_max_dd_pct"),
-        }
-    finally:
-        lab.STRATEGIES.pop(name, None)
-
-
-def _deep_update(dst, src):
-    for k, v in src.items():
-        if isinstance(v, dict) and isinstance(dst.get(k), dict):
-            _deep_update(dst[k], v)
-        else:
-            dst[k] = v
-
-
-def verify_variant_hk(variant, parent_version):
-    """港股变体验证：hk_backtest 生成交易 + portfolio_sim 8槽"""
-    import pandas as pd
-    sys.path.insert(0, "/home/hmo/MoFin/deploy/profile-scripts")
-    from hk_strategies import HK_STRATEGIES, get_hk_strategy
-    import hk_backtest
-    import strategy_lab as lab
-
-    base = get_hk_strategy(parent_version)
-    if not base:
-        return None
-    new_cfg = copy.deepcopy(base)
-    new_cfg["version"] = variant["version"]
-    new_cfg["name"] = variant["name"]
-    _deep_update(new_cfg, variant["config"])
-    panel = hk_backtest.load_panel()
-    # 2y 窗口过滤（与 A股验证周期一致，控制资源）
-    panel = panel[(panel["date"] >= BT_START) & (panel["date"] <= BT_END)].copy()
-    trades = hk_backtest.gen_trades_defensive(panel, new_cfg, strike=3, cooldown_days=15)
-    if not trades:
-        return {"trades": 0, "win_rate": None, "cagr": None, "total_return": None, "max_dd": None}
-    sim = lab.portfolio_sim(trades, 1000000, max_positions=8)
-    return {
-        "trades": len(trades),
-        "win_rate": round(100 * sum(1 for t in trades if t["profit_pct"] > 0) / len(trades), 1),
-        "cagr": sim.get("cagr_pct"),
-        "total_return": sim.get("total_return_pct"),
-        "max_dd": sim.get("portfolio_max_dd_pct"),
-    }
-
-
-# ── 5. 记录 + 推送 ──
-def record_and_notify(conn, parent_version, market, variant, result, parent_cagr, parent_dd):
-    """写 strategy_evolution + XMPP 推送"""
-    conn.execute("""
-        INSERT INTO strategy_evolution (parent_version, child_version, change_description, backtest_result, promoted)
-        VALUES (?, ?, ?, ?, 0)
-    """, (parent_version, variant["version"], variant["change_desc"],
-          json.dumps(result, ensure_ascii=False)))
-    conn.commit()
-
-    msg = (f"🧬 策略进化建议 [{parent_version}]\n"
-           f"改动: {variant['change_desc']}\n"
-           f"回测: 年化 {parent_cagr}% → {result.get('cagr')}%"
-           f" (Δ{round((result.get('cagr') or 0) - (parent_cagr or 0), 1)}pp)"
-           f" | 回撤 {parent_dd}% → {result.get('max_dd')}%\n"
-           f"胜率 {result.get('win_rate')}% / {result.get('trades')}笔\n"
-           f"【验证达标，待你决定是否上线】")
-    try:
-        sys.path.insert(0, "/home/hmo/MoFin/deploy/profile-scripts")
-        from alert_helper import notify, ACTION
-        notify("策略进化", msg, level=ACTION)
-        log(f"XMPP 推送: {parent_version} → {variant['version']}")
-    except Exception as e:
-        log(f"XMPP 推送失败: {e}")
-    return msg
-
-
-# ── 主流程 ──
-def run_evolution():
-    conn = get_conn()
-    actives = load_active_strategies()
-    log(f"激活策略: {[a['version'] for a in actives]}")
-    if not actives:
-        log("无激活策略，退出")
-        conn.close()
-        return
-
-    findings = []   # 退化发现
-    passed = []     # 达标变体
-
-    for act in actives:
-        v, mkt = act["version"], act["market"]
-        reasons = detect_degradation(conn, v, mkt)
-        if not reasons:
-            continue
-        log(f"退化信号: {v} [{mkt}] → {'; '.join(reasons)}")
-        findings.append((v, mkt, reasons))
-
-        # 生成变体（A股从 lab 读 config；港股从 HK_STRATEGIES）
-        if mkt == "hk":
-            sys.path.insert(0, "/home/hmo/MoFin/deploy/profile-scripts")
-            from hk_strategies import get_hk_strategy
-            base = get_hk_strategy(v)
-            if not base:
-                log(f"  {v} 无港股策略定义，跳过")
-                continue
-            # 2026-08-16 优先数据归纳假设，无则参数变体
-            variants = generate_hypothesis_variants(v, mkt, base)
-            if not variants:
-                variants = generate_variants(v, mkt, base)
-            verify_fn = verify_variant_hk
-        else:
-            try:
-                import strategy_lab as lab
-                base = lab.get_strategy(v)
-            except ValueError:
-                log(f"  {v} 不在标准回测体系（scanner 类策略），跳过变体研究")
-                continue
-            # 2026-08-16 优先数据归纳假设，无则参数变体
-            variants = generate_hypothesis_variants(v, mkt, base["config"])
-            if not variants:
-                variants = generate_variants(v, mkt, base["config"])
-            verify_fn = verify_variant_a
-        if not variants:
-            log(f"  {v} 无可用变体字段，跳过")
-            continue
-
-        parent_cagr, parent_dd = get_parent_cagr(conn, v, mkt)
-        log(f"  {v} 原温区年化 {parent_cagr}% / 回撤 {parent_dd}% | 生成 {len(variants)} 个变体，验证前 {MAX_VARIANTS_TEST} 个")
-        for var in variants[:MAX_VARIANTS_TEST]:
-            try:
-                res = verify_fn(var, v)
-            except Exception as e:
-                log(f"  {var['version']} 回测失败: {str(e)[:100]}")
-                continue
-            if not res or res.get("cagr") is None:
-                log(f"  {var['version']} 无结果（0笔或空），跳过")
-                continue
-            ok_cagr = parent_cagr is None or res["cagr"] >= (parent_cagr or 0) + ACCEPT_CAGR_PP
-            ok_dd = parent_dd is None or res["max_dd"] <= (parent_dd or 0) + ACCEPT_DD_PP
-            status = "✅达标" if (ok_cagr and ok_dd) else "❌不达标"
-            log(f"  {var['version']}: 年化 {parent_cagr}→{res['cagr']}% 回撤 {parent_dd}→{res['max_dd']}% [{status}]")
-            if ok_cagr and ok_dd:
-                record_and_notify(conn, v, mkt, var, res, parent_cagr, parent_dd)
-                passed.append((v, var, res))
-
-    conn.close()
-
-    # 汇总
-    if not findings:
-        log("── 无退化信号，当周静默 ──")
-    else:
-        log(f"── 检测 {len(findings)} 个退化策略，{len(passed)} 个达标变体已推送 ──")
-    return findings, passed
-
-
-if __name__ == "__main__":
-    try:
-        run_evolution()
-    except Exception as e:
-        log(f"evolution_engine 异常: {e}")
-        traceback.print_exc()
-        sys.exit(1)
@@ -1,143 +0,0 @@
-"""
-evolution/health_monitor.py — 策略健康度监控
-对比实盘交易 vs 回测预期，计算健康分，偏差过大时报警
-"""
-import sys, os, json, sqlite3
-from datetime import datetime, timedelta
-
-sys.path.insert(0, '/home/hmo/MoFin')
-sys.path.insert(0, '/home/hmo/MoFin/deploy/profile-scripts')
-
-DB = os.environ.get('MOFIN_DB', '/home/hmo/MoFin/data/mofin.db')
-CURRENT_STRATEGY = 'v_next4'
-
-
-def get_backtest_baseline(conn, version):
-    """从 strategy_research 取回测基线"""
-    r = conn.execute("""
-        SELECT results_json FROM strategy_research 
-        WHERE version=? AND period_tag='5y' ORDER BY id DESC LIMIT 1
-    """, (version,)).fetchone()
-    if not r:
-        return None
-    res = json.loads(r[0])
-    s = res.get('summary', {})
-    return {
-        'win_rate': s.get('win_rate', 0),
-        'avg_profit_pct': s.get('avg_profit_pct', 0),
-        'total_trades': s.get('total_trades', 0),
-    }
-
-
-def get_live_trades(conn, days=7):
-    """取近N天实盘交易（holding_strategies 全部，计算盈亏）"""
-    since = (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d')
-    try:
-        rows = conn.execute("""
-            SELECT code, name, price as current_price, avg_price as entry_price,
-                   timing_signal as signal, updated_at,
-                   CASE WHEN avg_price > 0 THEN round((price - avg_price) / avg_price * 100, 2) ELSE 0 END as profit_pct
-            FROM holding_strategies 
-            WHERE updated_at >= ? AND avg_price > 0
-            ORDER BY updated_at DESC
-        """, (since,)).fetchall()
-        return rows
-    except sqlite3.OperationalError as e:
-        print(f"查询失败: {e}", flush=True)
-        return []
-
-
-def calc_health_score(live_wr, live_ret, backtest_wr, backtest_ret):
-    """计算健康分 (0-100)
-    健康分 = 100 - 偏差惩罚
-    偏差 = |实盘胜率-回测胜率| + |实盘收益-回测收益|/2
-    """
-    if backtest_wr == 0:
-        return 50  # 无基线，中性分
-    
-    wr_dev = abs(live_wr - backtest_wr)
-    ret_dev = abs(live_ret - backtest_ret) / 2
-    deviation = wr_dev + ret_dev
-    
-    # 偏差越大，健康分越低
-    health = max(0, 100 - deviation * 2)
-    return round(health, 1)
-
-
-def run_health_check(strategy_version=None):
-    """执行健康度检查"""
-    version = strategy_version or CURRENT_STRATEGY
-    conn = sqlite3.connect(DB)
-    conn.row_factory = sqlite3.Row
-    
-    # 回测基线
-    baseline = get_backtest_baseline(conn, version)
-    if not baseline:
-        print(f"无 {version} 回测基线", flush=True)
-        conn.close()
-        return None
-    
-    # 实盘交易（近7天）
-    live = get_live_trades(conn, days=7)
-    today = datetime.now().strftime('%Y-%m-%d')
-    
-    if not live:
-        # 无实盘数据，记录中性健康分
-        health = 50
-        deviation = 0
-        live_wr = live_ret = 0
-        print(f"{version}: 近7天无实盘交易，健康分=50(中性)", flush=True)
-    else:
-        wins = sum(1 for t in live if (t.get('profit_pct') or 0) > 0)
-        total = len(live)
-        live_wr = round(100 * wins / total, 1) if total else 0
-        live_ret = round(sum(t.get('profit_pct') or 0 for t in live) / total, 2) if total else 0
-        
-        health = calc_health_score(live_wr, live_ret, baseline['win_rate'], baseline['avg_profit_pct'])
-        deviation = abs(live_wr - baseline['win_rate'])
-    
-    # 写入 strategy_health 表
-    conn.execute("""
-        INSERT OR REPLACE INTO strategy_health 
-        (strategy_version, date, live_trades, live_wins, live_return_pct, 
-         backtest_wr, backtest_avg_ret, deviation, health_score)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    """, (version, today, len(live), sum(1 for t in live if (t.get('profit_pct') or 0) > 0),
-          live_ret, baseline['win_rate'], baseline['avg_profit_pct'], deviation, health))
-    conn.commit()
-    
-    # 报警判断（2026-08-12 修：无实盘交易时不告警——health=50 是中性"无数据"，非"偏低"）
-    alert = None
-    if live:
-        if health < 40:
-            alert = f"🔴 策略健康度严重下降: {health}分 (偏差{deviation}pp)"
-        elif health < 60:
-            alert = f"🟡 策略健康度偏低: {health}分 (偏差{deviation}pp)"
-    
-    result = {
-        'version': version,
-        'date': today,
-        'live_trades': len(live),
-        'live_wr': live_wr,
-        'live_ret': live_ret,
-        'backtest_wr': baseline['win_rate'],
-        'backtest_ret': baseline['avg_profit_pct'],
-        'deviation': deviation,
-        'health_score': health,
-        'alert': alert,
-    }
-    
-    print(f"{version} 健康度: {health}分 (实盘{live_wr}%/{live_ret}% vs 回测{baseline['win_rate']}%/{baseline['avg_profit_pct']}%)", flush=True)
-    if alert:
-        print(f"  {alert}", flush=True)
-    
-    conn.close()
-    return result
-
-
-if __name__ == '__main__':
-    import sys
-    sys.path.insert(0, '/home/hmo/MoFin/evolution')
-    from __init__ import init_evolution_tables
-    init_evolution_tables()
-    run_health_check()
@@ -1,142 +0,0 @@
-# -*- coding: utf-8 -*-
-"""evolution/hypothesis_miner.py — 数据归纳假设引擎 v2
-从策略最新交易数据 + 面板特征，归纳可描述的优化假设（方向一核心）
-数据源：strategy_research trades（code+date）→ 关联 panel_12d 的入场日特征
-"""
-import json
-import sqlite3
-import pandas as pd
-
-# 可归纳特征：panel 字段名 + 标签 + 高值是否坏
-CANDIDATE_FEATURES = [
-    ("mkt_adx", "大盘趋势强度ADX", True),
-    ("mkt_rsi", "大盘RSI", True),
-    ("mkt_ret20", "大盘近20日涨幅", False),
-    ("bias60", "个股60日偏离", True),
-    ("rsi", "个股RSI", True),
-    ("vol_ratio", "量比", False),
-    ("sec_ret20", "行业近20日涨幅", False),
-]
-
-_PANEL_CACHE = {}  # 模块级缓存：market -> panel（避免每次重载600万行pkl）
-
-
-def _load_panel(market):
-    """加载面板：A股 panel_12d.pkl，港股 panel_12d_hk.pkl（带缓存）"""
-    global _PANEL_CACHE
-    if market in _PANEL_CACHE:
-        return _PANEL_CACHE[market]
-    path = "/tmp/panel_12d_hk.pkl" if market == "hk" else "/tmp/panel_12d.pkl"
-    p = pd.read_pickle(path)
-    p = p.sort_values(["code", "date"]).reset_index(drop=True)
-    # 建 code+date → 特征映射
-    p["_key"] = p["code"].astype(str) + "_" + p["date"].astype(str)
-    p = p.drop_duplicates(subset=["_key"])
-    p = p.set_index("_key")
-    _PANEL_CACHE[market] = p
-    return p
-
-
-def load_trades(version, market, period_tag="2y"):
-    """从 strategy_research 读 trades，关联面板特征"""
-    conn = sqlite3.connect("/home/hmo/MoFin/data/mofin.db", timeout=10)
-    conn.row_factory = sqlite3.Row
-    r = conn.execute(
-        "SELECT results_json FROM strategy_research WHERE version=? AND market=? AND period_tag=? "
-        "ORDER BY id DESC LIMIT 1", (version, market, period_tag)).fetchone()
-    conn.close()
-    if not r:
-        return []
-    res = json.loads(r["results_json"] or "{}")
-    trades = res.get("trades", [])
-    try:
-        panel = _load_panel(market)
-    except Exception as e:
-        print(f"panel 加载失败: {e}", flush=True)
-        return []
-    out = []
-    for t in trades:
-        key = str(t.get("code")) + "_" + str(t.get("entry_date"))
-        row = panel.loc[key] if key in panel.index else None
-        out.append({
-            "profit_pct": t.get("profit_pct", 0),
-            "win": t.get("profit_pct", 0) > 0,
-            "hold_days": t.get("hold_days", 0),
-            "exit_reason": t.get("exit_reason", ""),
-            "mkt_adx": row["mkt_adx"] if row is not None and pd.notna(row.get("mkt_adx")) else None,
-            "mkt_rsi": row["mkt_rsi"] if row is not None and pd.notna(row.get("mkt_rsi")) else None,
-            "mkt_ret20": row["mkt_ret20"] if row is not None and pd.notna(row.get("mkt_ret20")) else None,
-            "bias60": row["bias60"] if row is not None and pd.notna(row.get("bias60")) else None,
-            "rsi": row["rsi"] if row is not None and pd.notna(row.get("rsi")) else None,
-            "vol_ratio": row["vol_ratio"] if row is not None and pd.notna(row.get("vol_ratio")) else None,
-            "sec_ret20": row["sec_ret20"] if row is not None and pd.notna(row.get("sec_ret20")) else None,
-        })
-    return out
-
-
-def _percentile(vals, p):
-    if not vals:
-        return None
-    s = sorted(vals)
-    return s[int((len(s) - 1) * p)]
-
-
-def induce_hypotheses(version, market, period_tag="2y", min_trades=20, min_effect=15):
-    """归纳优化假设：找盈利/亏损组的特征差异"""
-    trades = load_trades(version, market, period_tag)
-    if len(trades) < min_trades:
-        return [], trades
-    overall_wr = sum(1 for t in trades if t["win"]) / len(trades) * 100
-
-    hypotheses = []
-    for feat_key, feat_label, high_is_bad in CANDIDATE_FEATURES:
-        vals = [t[feat_key] for t in trades if t.get(feat_key) is not None]
-        if len(vals) < max(5, min_trades * 0.3):
-            continue
-        hi = _percentile(vals, 0.75)
-        lo = _percentile(vals, 0.25)
-        if hi is None or lo is None or hi == lo:
-            continue
-        hi_trades = [t for t in trades if t.get(feat_key) is not None and t[feat_key] >= hi]
-        lo_trades = [t for t in trades if t.get(feat_key) is not None and t[feat_key] <= lo]
-        if len(hi_trades) < 5 or len(lo_trades) < 5:
-            continue
-        hi_wr = sum(1 for t in hi_trades if t["win"]) / len(hi_trades) * 100
-        lo_wr = sum(1 for t in lo_trades if t["win"]) / len(lo_trades) * 100
-
-        if high_is_bad and hi_wr < overall_wr - min_effect:
-            hypotheses.append({
-                "hypothesis": f"当{feat_label}({feat_key})≥{hi:.1f}时胜率仅{hi_wr:.0f}%（整体{overall_wr:.0f}%），应规避",
-                "feature": feat_key, "direction": "max", "threshold": round(hi, 2),
-                "win_rate_affected": round(hi_wr, 1), "win_rate_clean": round(lo_wr, 1),
-                "overall_wr": round(overall_wr, 1),
-                "effect_pp": round(overall_wr - hi_wr, 1),
-                "evidence": f"高分组{len(hi_trades)}笔胜率{hi_wr:.0f}% vs 低分组{len(lo_trades)}笔胜率{lo_wr:.0f}%",
-                "trades_affected": len(hi_trades),
-            })
-        elif not high_is_bad and lo_wr < overall_wr - min_effect:
-            hypotheses.append({
-                "hypothesis": f"当{feat_label}({feat_key})≤{lo:.1f}时胜率仅{lo_wr:.0f}%（整体{overall_wr:.0f}%），应规避",
-                "feature": feat_key, "direction": "min", "threshold": round(lo, 2),
-                "win_rate_affected": round(lo_wr, 1), "win_rate_clean": round(hi_wr, 1),
-                "overall_wr": round(overall_wr, 1),
-                "effect_pp": round(overall_wr - lo_wr, 1),
-                "evidence": f"低分组{len(lo_trades)}笔胜率{lo_wr:.0f}% vs 高分组{len(hi_trades)}笔胜率{hi_wr:.0f}%",
-                "trades_affected": len(lo_trades),
-            })
-
-    hypotheses.sort(key=lambda h: -h["effect_pp"])
-    return hypotheses, trades
-
-
-if __name__ == "__main__":
-    import sys
-    version = sys.argv[1] if len(sys.argv) > 1 else "v_oversold"
-    market = sys.argv[2] if len(sys.argv) > 2 else "a"
-    hs, trades = induce_hypotheses(version, market)
-    print(f"=== {version} [{market}] {len(trades)}笔 ===")
-    for h in hs:
-        print(f"  [Δ{h['effect_pp']:.0f}pp] {h['hypothesis']}")
-        print(f"     证据: {h['evidence']}")
-    if not hs:
-        print("  未归纳出显著假设")
@@ -1,150 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-evolution/lesson_extractor.py — 实盘平仓教训提取（2026-08-15 重写）
-
-旧版病状（见 docs/decisions/2026-08-15-策略自我进化闭环重构.md）：
-  - 硬编码 version='v_next4'（已证伪策略）
-  - 名为"已平仓交易教训"，实际读的是回测 trades 而非实盘平仓
-  - 用 LLM 逐笔分析回测 trades（既贵又假——回测交易没有"教训"可挖）
-
-重写方向（设计文档批准）：
-  1. 数据源改实盘：strategy_tracking 已平仓记录（status=hit_tp/hit_sl/expired/manual_close）
-  2. 结合当日温区（market_regime）归因
-  3. 规则化提取（非 LLM）：命中止盈=盈利规律，止损/超时=亏损教训
-  4. 每周一次，跟随 evolution_engine 同跑（周六 22:00）
-
-幂等：按 trade_id 去重（同笔不重复写）；已写过的 lesson_text 跳过。
-"""
-import sys, os, sqlite3
-from datetime import datetime, timedelta
-
-sys.path.insert(0, "/home/hmo/MoFin")
-
-DB = os.environ.get("MOFIN_DB", "/home/hmo/MoFin/data/mofin.db")
-LOOKBACK_DAYS = 30   # 提取近30天已平仓
-
-# 状态 → 教训类型映射
-STATUS_LESSON = {
-    "hit_tp": ("win_pattern", "止盈有效"),
-    "hit_sl": ("loss_pattern", "止损生效"),
-    "expired": ("loss_pattern", "持有到期未达目标"),
-    "manual_close": ("loss_pattern", "人工平仓"),
-}
-
-# 平仓原因 → 细化教训
-REASON_TEXT = {
-    "止盈触发": "触达止盈位落袋",
-    "止损触发": "跌破止损位离场",
-    "反弹减仓触发": "反弹遇阻减仓",
-    "超时退出": "持有超时退出",
-}
-
-
-def get_conn():
-    conn = sqlite3.connect(DB)
-    conn.row_factory = sqlite3.Row
-    return conn
-
-
-def get_regime_for(conn, date_str, market="a"):
-    """取指定日期最近的市场温区"""
-    r = conn.execute(
-        "SELECT regime FROM market_regime WHERE market=? AND date<=? ORDER BY date DESC LIMIT 1",
-        (market, date_str)).fetchone()
-    return r["regime"] if r else None
-
-
-def extract_lessons(days=LOOKBACK_DAYS, verbose=True):
-    """提取近 N 天实盘已平仓交易的教训"""
-    conn = get_conn()
-    since = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")
-
-    rows = conn.execute("""
-        SELECT id, code, name, status, closed_at, close_reason, theoretical_pnl,
-               actual_pnl, actual_exit_reason
-        FROM strategy_tracking
-        WHERE status != 'active' AND closed_at >= ?
-        ORDER BY closed_at DESC
-    """, (since,)).fetchall()
-    if not rows:
-        if verbose:
-            print(f"近{days}天无已平仓记录，跳过", flush=True)
-        conn.close()
-        return []
-
-    # 统计 + 提取
-    stats = {"hit_tp": 0, "hit_sl": 0, "expired": 0, "manual_close": 0}
-    lessons = []
-    written = 0
-    for r in rows:
-        status = r["status"]
-        stats[status] = stats.get(status, 0) + 1
-        # 只对止盈/止损提取（expired/manual_close 噪音大，跳过教训提取但统计）
-        if status not in ("hit_tp", "hit_sl"):
-            continue
-        pnl = r["actual_pnl"] if r["actual_pnl"] is not None else r["theoretical_pnl"]
-        if pnl is None:
-            continue
-        # 幂等：同 trade_id 已写过则跳过
-        exist = conn.execute(
-            "SELECT 1 FROM strategy_lessons WHERE trade_id=? AND lesson_type=?",
-            (r["id"], "win_pattern" if status == "hit_tp" else "loss_pattern")).fetchone()
-        if exist:
-            continue
-
-        regime = get_regime_for(conn, (r["closed_at"] or "")[:10])
-        reason_txt = REASON_TEXT.get(r["close_reason"], r["close_reason"] or "平仓")
-        if status == "hit_tp":
-            ltype = "win_pattern"
-            conf = 0.6 if pnl >= 5 else 0.4
-            text = (f"实盘止盈：{r['name']}({r['code']}) {reason_txt}，"
-                    f"收益{pnl:+.1f}%" + (f"（{regime}温区）" if regime else ""))
-        else:
-            ltype = "loss_pattern"
-            conf = 0.6 if pnl <= -5 else 0.4
-            text = (f"实盘止损：{r['name']}({r['code']}) {reason_txt}，"
-                    f"亏损{pnl:+.1f}%" + (f"（{regime}温区）" if regime else ""))
-        lessons.append({
-            "trade_id": r["id"], "lesson_type": ltype, "lesson_text": text,
-            "confidence": conf, "profit_pct": pnl,
-        })
-
-    # 写库
-    for l in lessons:
-        conn.execute("""
-            INSERT INTO strategy_lessons (strategy_version, trade_id, lesson_type, lesson_text, confidence, applied)
-            VALUES ('live_trades', ?, ?, ?, ?, 0)
-        """, (l["trade_id"], l["lesson_type"], l["lesson_text"], l["confidence"]))
-        written += 1
-    conn.commit()
-
-    # 温区级汇总教训（全部已平仓按温区归因）
-    if stats["hit_tp"] + stats["hit_sl"] > 0:
-        tp_pnl = sum((r["actual_pnl"] if r["actual_pnl"] is not None else r["theoretical_pnl"] or 0)
-                     for r in rows if r["status"] == "hit_tp")
-        sl_pnl = sum((r["actual_pnl"] if r["actual_pnl"] is not None else r["theoretical_pnl"] or 0)
-                     for r in rows if r["status"] == "hit_sl")
-        summary = (f"近{days}天实盘复盘：止盈{stats['hit_tp']}笔(均{round(tp_pnl/max(stats['hit_tp'],1),1)}%)"
-                   f" / 止损{stats['hit_sl']}笔(均{round(sl_pnl/max(stats['hit_sl'],1),1)}%)")
-        # 汇总教训写一条（幂等：按文本）
-        exist_sum = conn.execute(
-            "SELECT 1 FROM strategy_lessons WHERE lesson_text=? AND lesson_type='summary'",
-            (summary,)).fetchone()
-        if not exist_sum:
-            conn.execute("""
-                INSERT INTO strategy_lessons (strategy_version, trade_id, lesson_type, lesson_text, confidence, applied)
-                VALUES ('live_trades', NULL, 'summary', ?, 0.8, 0)
-            """, (summary,))
-            written += 1
-        conn.commit()
-
-    conn.close()
-    if verbose:
-        print(f"近{days}天已平仓: {stats}，新增教训 {written} 条", flush=True)
-        for l in lessons[:5]:
-            print(f"  [{l['lesson_type']}] {l['lesson_text']} ({l['confidence']})", flush=True)
-    return lessons
-
-
-if __name__ == "__main__":
-    extract_lessons()
@@ -1,217 +0,0 @@
-# -*- coding: utf-8 -*-
-"""evolution/merge_b_group.py — AB融合机制（2026-08-16 方向二闭环）
-
-老莫：B组候选与A组对照后，融合/合并成为最终实施组（新的A组）。
-
-流程：
-  1. 读 B 组 verified 候选（data/b_group_candidates.json, status='verified'）
-  2. 老莫选择要融合的候选 → 注册为正式策略版本：
-     - A股：写入 strategy_research（results_json 用回测验证的 trades）
-     - 港股：注册进 hk_strategies.py（entry 条件）
-  3. 加入候选池（strategy_weights 路由可识别）
-  4. 手动可用性把关（老莫决定是否启用）——融合≠自动上线
-
-安全：不自动 promote，不自动启用；融合只是把候选变成"可用的新策略版本"。
-"""
-import json
-import subprocess
-import sys
-import sqlite3
-from datetime import datetime
-
-DATA_DIR = "/home/hmo/MoFin/data"
-CAND_JSON = f"{DATA_DIR}/b_group_candidates.json"
-DB = "/home/hmo/MoFin/data/mofin.db"
-
-
-def load_candidates():
-    try:
-        d = json.load(open(CAND_JSON, encoding="utf-8"))
-        return d.get("candidates", [])
-    except Exception:
-        return []
-
-
-def get_verified():
-    return [c for c in load_candidates() if c.get("status") == "verified"]
-
-
-def strategy_name(cand):
-    """生成策略版本名：b{regime缩写}{序号}"""
-    rg_map = {"trend_up": "tu", "choppy": "ch", "trend_down": "td"}
-    rg = rg_map.get(cand.get("regime"), "x")
-    idx = cand.get("_idx", 1)
-    return f"b_{rg}{idx}"
-
-
-def register_a_share(cand):
-    """A股候选注册：写入 strategy_research（B组候选，供研究Tab/回测）
-    实际回测验证由进化引擎跑，这里先注册占位 + 候选条件记录
-    """
-    conn = sqlite3.connect(DB, timeout=10)
-    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    name = strategy_name(cand)
-    # 检查是否已注册
-    exist = conn.execute("SELECT 1 FROM strategy_research WHERE version=? LIMIT 1", (name,)).fetchone()
-    if exist:
-        conn.close()
-        return {"status": "exists", "version": name}
-    conn.execute("""
-        INSERT INTO strategy_research (version, name, summary, hypothesis, parent, config_json,
-            results_json, analysis_json, period, created_at, market, period_tag, deprecated)
-        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)
-    """, (name, f"B组-{cand.get('regime','')}", cand.get("hypothesis", ""),
-          "B组融合候选（由果及因挖掘）", "B组", json.dumps(cand.get("entry", {})),
-          json.dumps({"summary": {"total_trades": cand.get("trades_est"),
-                                   "win_rate": cand.get("sim_win_rate"),
-                                   "avg_profit_pct": cand.get("sim_avg_pnl")}}),
-          None, None, now, "a", "2y", None))
-    conn.commit()
-    conn.close()
-    return {"status": "registered", "version": name}
-
-
-def register_hk(cand):
-    """港股候选注册：追加到 hk_strategies.py"""
-    name = strategy_name(cand)
-    entry = cand.get("entry", {})
-    # 追加到 hk_strategies.py（先读再写）
-    path = "/home/hmo/MoFin/deploy/profile-scripts/hk_strategies.py"
-    src = open(path, encoding="utf-8").read()
-    if f'"{name}"' in src:
-        return {"status": "exists", "version": name}
-    new_block = f'''
-    "{name}": {{
-        "version": "{name}",
-        "name": "B组-{cand.get('regime','')}（由果及因融合）",
-        "regime": "{cand.get('regime','all')}",
-        "summary": "{cand.get('hypothesis','B组候选')[:80]}",
-        "entry": {json.dumps(entry, ensure_ascii=False)},
-        "exit": {{"tp_pct": 0.10, "sl_pct": 0.05, "max_hold_days": 20}},
-    }},
-}}'''
-    # 在 HK_STRATEGIES 的收尾 "}" 前插入（精确：找最后一个顶层 dict 的收尾）
-    # HK_STRATEGIES 结构：{ "k1": {...}, ..., "kn": {...}, } 然后空行 + get_hk_strategy
-    marker = "\n\n\ndef get_hk_strategy"
-    idx = src.rfind(marker)
-    if idx == -1:
-        return {"status": "error", "version": name, "error": "hk_strategies 结构异常"}
-    insert_at = src.rfind("}", 0, idx)
-    # 去掉 new_block 末尾多余的 }}
-    clean_block = new_block.rstrip()
-    if clean_block.endswith("}}"):
-        clean_block = clean_block[:-1]
-    src = src[:insert_at] + clean_block + src[insert_at:]
-    open(path, "w", encoding="utf-8").write(src)
-    return {"status": "registered", "version": name}
-
-
-def merge(version=None):
-    """融合：把 verified 候选注册为策略版本。version 指定要融合的候选，None=全部"""
-    verified = get_verified()
-    if not verified:
-        return {"error": "无 verified B组候选（需先通过模拟验证门槛）", "verified": 0}
-    out = []
-    for i, cand in enumerate(verified):
-        if version and cand.get("version_name") != version:
-            continue
-        cand["_idx"] = i + 1
-        if cand.get("market") == "hk":
-            r = register_hk(cand)
-        else:
-            r = register_a_share(cand)
-        r["candidate"] = cand.get("hypothesis", "")
-        # 融合链路：多周期trades + 温区预计算 + 资格评估 + 可用性初始化
-        if r.get("status") in ("registered", "exists") and r.get("version"):
-            try:
-                link = _post_merge_chain(r["version"], cand)
-                r["chain"] = link
-            except Exception as e:
-                r["chain"] = {"error": str(e)}
-        out.append(r)
-    return {"merged": out}
-
-
-def _post_merge_chain(version, cand):
-    """融合后链路：按period_tag生成窗口trades → 温区预计算 → 资格评估 → 可用性
-    返回 {period_trades: {...}, regime_records: n, qualification: {...}, availability: {...}}"""
-    import subprocess, json as _json
-    out = {}
-    # 1) 生成各周期窗口trades 写入 strategy_research（每个 period_tag 记录独立 results_json）
-    #    （B组候选的 trades 来自模拟验证，按 entry_date 过滤窗口）
-    try:
-        import sys as _sys
-        _sys.path.insert(0, "/home/hmo/MoFin")
-        _sys.path.insert(0, "/home/hmo/MoFin/evolution")
-        import sqlite3 as _sq
-        import pandas as _pd
-        from datetime import datetime as _dt, timedelta as _td
-        from b_group_miner import _simulate_verify
-        market = cand.get("market", "a")
-        regime = cand.get("regime", "trend_down")
-        entry = cand.get("entry", {})
-        panel_path = "/tmp/panel_12d_hk.pkl" if market == "hk" else "/tmp/panel_12d.pkl"
-        panel = _pd.read_pickle(panel_path)
-        panel = panel.sort_values(["code", "date"]).reset_index(drop=True)
-        panel["fwd_ret60"] = panel.groupby("code")["close"].transform(lambda x: x.shift(-60) / x - 1) * 100
-        cond = _pd.Series(True, index=panel.index)
-        for feat, val in entry.items():
-            if "_min" in feat:
-                cond &= panel[feat.replace("_min", "")] >= val
-            elif "_max" in feat:
-                cond &= panel[feat.replace("_max", "")] < val
-            elif feat in panel.columns:
-                cond &= panel[feat] == val
-        tp = int(cand.get("sim_tp", 15)); sl = int(cand.get("sim_sl", 8)); mh = int(cand.get("sim_maxh", 35))
-        r = _simulate_verify(market, regime, panel, cond, tp=tp, sl=sl, maxh=mh)
-        if not r:
-            out["period_trades"] = {"error": "模拟验证无结果"}
-        else:
-            all_trades = r["trades"]
-            latest_dt = _dt.strptime(max(t["entry_date"] for t in all_trades), "%Y-%m-%d")
-            conn = _sq.connect("/home/hmo/MoFin/data/mofin.db", timeout=30)
-            for pt, yrs in [("1y", 1), ("2y", 2), ("5y", 5), ("10y", 10)]:
-                cutoff = (latest_dt - _td(days=365 * yrs)).strftime("%Y-%m-%d")
-                wt = [t for t in all_trades if t["entry_date"] >= cutoff]
-                n = len(wt)
-                wins = [t for t in wt if t.get("profit_pct", 0) > 0]
-                wr = round(len(wins) / n * 100, 1) if n else 0
-                avg = round(sum(t.get("profit_pct", 0) for t in wt) / n, 2) if n else 0
-                results = {"summary": {"total_trades": n, "win_rate": wr, "avg_profit_pct": avg},
-                           "trades": wt[:5000],
-                           "sim_params": {"tp": tp, "sl": sl, "maxh": mh},
-                           "window": {"cutoff": cutoff, "latest": max(t["entry_date"] for t in all_trades)}}
-                conn.execute("UPDATE strategy_research SET results_json=? WHERE version=? AND period_tag=?",
-                             (_json.dumps(results, ensure_ascii=False), version, pt))
-                out.setdefault("period_trades", {})[pt] = {"n": n, "win_rate": wr}
-            conn.commit(); conn.close()
-    except Exception as e:
-        out["period_trades"] = {"error": str(e)}
-    # 2) 温区预计算
-    try:
-        mkt_flag = "--market=hk" if market == "hk" else "--market=a"
-        p = subprocess.run(["/home/hmo/MoFin/venv/bin/python",
-                            "/home/hmo/MoFin/deploy/profile-scripts/regime_perf_by_period.py",
-                            mkt_flag, "--periods=1y 2y 5y 10y"],
-                           capture_output=True, text=True, timeout=900)
-        out["regime_run"] = {"rc": p.returncode, "tail": (p.stdout or "").strip().splitlines()[-1:]}
-    except Exception as e:
-        out["regime_run"] = {"error": str(e)}
-    # 3) 资格评估 + 可用性
-    try:
-        _sys.path.insert(0, "/home/hmo/MoFin/deploy/profile-scripts")
-        import strategy_qualify as sq
-        out["qualification"] = sq.evaluate_all_regimes(version, market=market)
-        sq.auto_init_availability([version])
-        av = sq.load_availability().get(version)
-        out["availability"] = av
-    except Exception as e:
-        out["qualification"] = {"error": str(e)}
-    return out
-
-
-if __name__ == "__main__":
-    import sys
-    v = sys.argv[1] if len(sys.argv) > 1 else None
-    res = merge(v)
-    print(json.dumps(res, ensure_ascii=False, indent=1))
@@ -1,70 +0,0 @@
-# -*- coding: utf-8 -*-
-"""evolution/precompute_evolution.py — 进化机制预计算（2026-08-16）
-定期（每周/每日）预计算进化机制数据，供研究Tab展示（API 只读快照，不实时重算）：
-1. 假设归纳（方向一）：每个激活策略的归纳优化假设
-2. B组候选（方向二）：由果及因挖掘的候选
-3. 策略资格概览
-输出：data/evolution_center.json
-"""
-import sys, os, json
-from datetime import datetime
-
-sys.path.insert(0, "/home/hmo/MoFin")
-sys.path.insert(0, "/home/hmo/MoFin/evolution")
-sys.path.insert(0, "/home/hmo/MoFin/deploy/profile-scripts")
-
-OUT = "/home/hmo/MoFin/data/evolution_center.json"
-
-
-def active_versions():
-    try:
-        d = json.load(open("/home/hmo/MoFin/data/strategy_weights.json", encoding="utf-8"))
-        vs = list(d.get("active") or [])
-        vs += list(((d.get("markets") or {}).get("hk") or {}).get("active") or [])
-        return list(dict.fromkeys(vs))
-    except Exception:
-        return []
-
-
-def main():
-    print("=== 进化机制预计算开始 ===", flush=True)
-    from hypothesis_miner import induce_hypotheses
-    from strategy_qualify import evaluate_all_regimes, get_benchmarks
-
-    out = {"generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "hypotheses": [], "b_group": [], "qual_overview": []}
-
-    # 1. 假设归纳（方向一）
-    for v in active_versions():
-        mkt = "hk" if v.startswith("hk") else "a"
-        try:
-            hs, _ = induce_hypotheses(v, mkt, period_tag="2y")
-            for h in hs[:3]:
-                out["hypotheses"].append({"strategy": v, "market": mkt, **h})
-                print(f"  假设 [{v}]: {h['hypothesis'][:60]}", flush=True)
-        except Exception as e:
-            print(f"  假设 [{v}] 失败: {e}", flush=True)
-
-    # 2. B组候选（方向二）
-    try:
-        p = json.load(open("/home/hmo/MoFin/data/b_group_candidates.json", encoding="utf-8"))
-        out["b_group"] = p.get("candidates", [])
-        print(f"  B组候选: {len(out['b_group'])}", flush=True)
-    except Exception as e:
-        print(f"  B组读取失败: {e}", flush=True)
-
-    # 3. 资格概览
-    for v in active_versions():
-        mkt = "hk" if v.startswith("hk") else "a"
-        try:
-            q = evaluate_all_regimes(v, mkt, bench=get_benchmarks(mkt))
-            out["qual_overview"].append({"strategy": v, "market": mkt, "qualification": q})
-        except Exception:
-            pass
-
-    with open(OUT, "w", encoding="utf-8") as f:
-        json.dump(out, f, ensure_ascii=False, indent=1)
-    print(f"写入 {OUT}: hypotheses={len(out['hypotheses'])} b_group={len(out['b_group'])} qual={len(out['qual_overview'])}")
-
-
-if __name__ == "__main__":
-    main()