@arong8888/tulip-aibot-mcp 0.1.0

package/python/quant_tools.py

@@ -0,0 +1,2464 @@
+"""量化交易工具注册表：技术指标、风险绩效、仓位管理与统计工具。
+
+纯标准库、纯离线计算；不连接 MT5、不下单、不读文件。
+通过 call_tool 统一分发，list_tools 输出与 MCP tools/list 兼容的定义。
+所有输入显式校验（有限数字、长度上限），所有输出保证为有限数值。
+"""
+import math
+import random
+from typing import List, Optional
+
+MAX_SERIES_LEN = 100_000
+MAX_CANDLES = 50_000
+
+
+class ToolError(ValueError):
+    """工具参数或执行失败；call_tool 转成 ok=False 的错误响应。"""
+
+
+_TOOLS: dict = {}
+
+
+def tool(name: str, description: str, properties: dict = None, required: list = None):
+    """把函数注册为带 JSON Schema 的工具。"""
+    def decorator(func):
+        _TOOLS[name] = {
+            "name": name,
+            "description": description,
+            "inputSchema": {
+                "type": "object",
+                "properties": properties or {},
+                "required": required or [],
+            },
+            "func": func,
+        }
+        return func
+    return decorator
+
+
+def has_tool(name: str) -> bool:
+    return name in _TOOLS
+
+
+def list_tools() -> List[dict]:
+    return [{k: spec[k] for k in ("name", "description", "inputSchema")}
+            for spec in _TOOLS.values()]
+
+
+def call_tool(name: str, arguments: Optional[dict]) -> dict:
+    """统一分发入口。永不抛异常：失败返回 {"ok": False, "error": ...}。"""
+    spec = _TOOLS.get(name)
+    if spec is None:
+        return {"ok": False, "error": f"未知工具: {name}"}
+    if arguments is None:
+        arguments = {}
+    if not isinstance(arguments, dict):
+        return {"ok": False, "error": "arguments 必须是对象"}
+    try:
+        return {"ok": True, "result": spec["func"](**arguments)}
+    except ToolError as exc:
+        return {"ok": False, "error": str(exc)}
+    except TypeError as exc:
+        return {"ok": False, "error": f"参数不匹配: {exc}"}
+
+
+# ---------- 输入校验与数值辅助 ----------
+
+def _finite(value) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool) \
+        and math.isfinite(value)
+
+
+def _number(value, label, low=None, high=None) -> float:
+    if not _finite(value):
+        raise ToolError(f"{label}: 必须是有限数字")
+    v = float(value)
+    if low is not None and v < low:
+        raise ToolError(f"{label}: 不能小于 {low}")
+    if high is not None and v > high:
+        raise ToolError(f"{label}: 不能大于 {high}")
+    return v
+
+
+def _int(value, label, low=1, high=1_000_000) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ToolError(f"{label}: 必须是整数")
+    if not low <= value <= high:
+        raise ToolError(f"{label}: 必须在 [{low}, {high}] 内")
+    return value
+
+
+def _series(value, label, min_len=2, max_len=MAX_SERIES_LEN) -> List[float]:
+    if not isinstance(value, list) or not min_len <= len(value) <= max_len:
+        raise ToolError(f"{label}: 需要长度 {min_len}..{max_len} 的数组")
+    out = []
+    for i, v in enumerate(value):
+        if not _finite(v):
+            raise ToolError(f"{label}[{i}]: 必须是有限数字")
+        out.append(float(v))
+    return out
+
+
+def _ohlc(high, low, close, min_len=2, max_len=MAX_CANDLES):
+    high = _series(high, "high", min_len, max_len)
+    low = _series(low, "low", min_len, max_len)
+    close = _series(close, "close", min_len, max_len)
+    if not (len(high) == len(low) == len(close)):
+        raise ToolError("high/low/close 长度必须一致")
+    for i, (h, l, c) in enumerate(zip(high, low, close)):
+        if h < max(l, c) or l > min(h, c):
+            raise ToolError(f"第{i}根K线不满足 low <= high/close <= high")
+    return high, low, close
+
+
+def _r(value, nd=6) -> float:
+    """输出收敛：只允许有限数值，统一保留 nd 位小数。"""
+    v = float(value)
+    if not math.isfinite(v):
+        raise ToolError("计算结果出现非有限数值")
+    return round(v, nd)
+
+
+def _period(value, label, max_period=2000) -> int:
+    return _int(value, label, 1, max_period)
+
+
+# ---------- 均值类基础算法 ----------
+
+def _sma_series(values: List[float], period: int) -> List[float]:
+    out, s = [], 0.0
+    for i, v in enumerate(values):
+        s += v
+        if i >= period:
+            s -= values[i - period]
+        if i >= period - 1:
+            out.append(s / period)
+    return out
+
+
+def _ema_series(values: List[float], period: int) -> List[float]:
+    """EMA 以首段 SMA 为种子，前 period-1 位为 None（预热期）。"""
+    out = [None] * (period - 1)
+    alpha = 2.0 / (period + 1)
+    e = sum(values[:period]) / period
+    out.append(e)
+    for v in values[period:]:
+        e = alpha * v + (1 - alpha) * e
+        out.append(e)
+    return out
+
+
+def _wilder_series(values: List[float], period: int) -> List[float]:
+    """Wilder 平滑（ATR/ADX/RSI 同族）：首值为均值，之后 prev*(n-1)+v)/n。"""
+    if len(values) < period:
+        raise ToolError(f"数据不足：平滑需要至少{period}个点")
+    out = [sum(values[:period]) / period]
+    for v in values[period:]:
+        out.append((out[-1] * (period - 1) + v) / period)
+    return out
+
+
+def _std(values: List[float], ddof: int = 0) -> float:
+    n = len(values)
+    if n - ddof <= 0:
+        raise ToolError("样本量不足以计算标准差")
+    mean = sum(values) / n
+    var = sum((v - mean) ** 2 for v in values) / (n - ddof)
+    return math.sqrt(var)
+
+
+def _percentile(sorted_values: List[float], p: float) -> float:
+    """线性插值百分位，p∈[0,100]，输入必须已排序。"""
+    if not sorted_values:
+        raise ToolError("空序列")
+    if p <= 0:
+        return sorted_values[0]
+    if p >= 100:
+        return sorted_values[-1]
+    idx = p / 100 * (len(sorted_values) - 1)
+    lo = int(math.floor(idx))
+    hi = int(math.ceil(idx))
+    frac = idx - lo
+    return sorted_values[lo] * (1 - frac) + sorted_values[hi] * frac
+
+
+# ---------- 技术指标：单价格序列 ----------
+
+@tool(
+    "ma",
+    "移动平均线：method=sma|ema|wma，返回完整序列与最新值。EMA 以首段 SMA 为种子。",
+    properties={
+        "closes": {"type": "array", "description": "收盘价序列（按时间升序）"},
+        "period": {"type": "integer", "description": "周期，默认20"},
+        "method": {"type": "string", "enum": ["sma", "ema", "wma"], "description": "均线类型，默认sma"},
+    },
+    required=["closes"],
+)
+def tool_ma(closes, period: int = 20, method: str = "sma") -> dict:
+    closes = _series(closes, "closes", 2)
+    period = _period(period, "period")
+    if period > len(closes):
+        raise ToolError(f"period({period})不能大于序列长度({len(closes)})")
+    if method == "sma":
+        values = _sma_series(closes, period)
+    elif method == "ema":
+        values = [v for v in _ema_series(closes, period) if v is not None]
+    elif method == "wma":
+        weights = list(range(1, period + 1))
+        denom = sum(weights)
+        values = [sum(closes[i - period + 1:i + 1][j] * weights[j] for j in range(period)) / denom
+                  for i in range(period - 1, len(closes))]
+    else:
+        raise ToolError("method 必须是 sma/ema/wma")
+    return {"method": method, "period": period, "warmup": period - 1,
+            "latest": _r(values[-1]), "values": [_r(v) for v in values]}
+
+
+@tool(
+    "rsi",
+    "RSI 相对强弱指标（Wilder 平滑）。返回最新值与完整序列；70/30 为常用超买超卖阈值。",
+    properties={
+        "closes": {"type": "array", "description": "收盘价序列（按时间升序）"},
+        "period": {"type": "integer", "description": "周期，默认14"},
+    },
+    required=["closes"],
+)
+def tool_rsi(closes, period: int = 14) -> dict:
+    closes = _series(closes, "closes", 2)
+    period = _period(period, "period")
+    if len(closes) <= period:
+        raise ToolError(f"RSI 需要至少{period + 1}个收盘价")
+    gains, losses = [], []
+    for i in range(1, len(closes)):
+        change = closes[i] - closes[i - 1]
+        gains.append(max(change, 0.0))
+        losses.append(max(-change, 0.0))
+    avg_gain = sum(gains[:period]) / period
+    avg_loss = sum(losses[:period]) / period
+
+    def rsi_of(g, l):
+        return 100.0 if l == 0 else 100.0 - 100.0 / (1.0 + g / l)
+
+    values = [rsi_of(avg_gain, avg_loss)]  # 种子RSI：第period个变化处
+    for i in range(period, len(gains)):
+        avg_gain = (avg_gain * (period - 1) + gains[i]) / period
+        avg_loss = (avg_loss * (period - 1) + losses[i]) / period
+        values.append(rsi_of(avg_gain, avg_loss))
+    return {"period": period, "latest": _r(values[-1]),
+            "values": [_r(v) for v in values]}
+
+
+@tool(
+    "macd",
+    "MACD 指标：fast/slow EMA 差值 + 信号线 + 柱状图。返回最新值与序列。",
+    properties={
+        "closes": {"type": "array", "description": "收盘价序列（按时间升序）"},
+        "fast": {"type": "integer", "description": "快线周期，默认12"},
+        "slow": {"type": "integer", "description": "慢线周期，默认26"},
+        "signal": {"type": "integer", "description": "信号线周期，默认9"},
+    },
+    required=["closes"],
+)
+def tool_macd(closes, fast: int = 12, slow: int = 26, signal: int = 9) -> dict:
+    closes = _series(closes, "closes", 2)
+    fast = _period(fast, "fast")
+    slow = _period(slow, "slow")
+    signal = _period(signal, "signal")
+    if fast >= slow:
+        raise ToolError("fast 必须小于 slow")
+    if len(closes) < slow + signal:
+        raise ToolError(f"MACD 需要至少{slow + signal}个收盘价")
+    ema_fast = _ema_series(closes, fast)
+    ema_slow = _ema_series(closes, slow)
+    macd_line = [f - s for f, s in zip(ema_fast, ema_slow) if s is not None and f is not None]
+    sig_full = _ema_series(macd_line, signal)
+    sig = [v for v in sig_full if v is not None]
+    hist = [m - s for m, s in zip(macd_line[signal - 1:], sig)]
+    return {
+        "fast": fast, "slow": slow, "signal": signal,
+        "latest": {"macd": _r(macd_line[-1]), "signal": _r(sig[-1]), "hist": _r(hist[-1])},
+        "macd_values": [_r(v) for v in macd_line],
+    }
+
+
+@tool(
+    "bollinger_bands",
+    "布林带：SMA ± k倍标准差（总体标准差）。返回最新上/中/下轨、%B 与带宽。",
+    properties={
+        "closes": {"type": "array", "description": "收盘价序列（按时间升序）"},
+        "period": {"type": "integer", "description": "周期，默认20"},
+        "deviation": {"type": "number", "description": "标准差倍数，默认2"},
+    },
+    required=["closes"],
+)
+def tool_bollinger(closes, period: int = 20, deviation: float = 2.0) -> dict:
+    closes = _series(closes, "closes", 2)
+    period = _period(period, "period")
+    deviation = _number(deviation, "deviation", 0.1, 20)
+    if period > len(closes):
+        raise ToolError(f"period({period})不能大于序列长度({len(closes)})")
+    window = closes[-period:]
+    mid = sum(window) / period
+    sd = _std(window)
+    upper, lower = mid + deviation * sd, mid - deviation * sd
+    last = closes[-1]
+    pct_b = (last - lower) / (upper - lower) if upper != lower else 0.5
+    bandwidth = (upper - lower) / mid if mid != 0 else 0.0
+    return {"upper": _r(upper), "mid": _r(mid), "lower": _r(lower),
+            "std": _r(sd), "pct_b": _r(pct_b), "bandwidth": _r(bandwidth)}
+
+
+@tool(
+    "zscore",
+    "价格Z分数：最新价相对最近 lookback 期的均值偏离程度（标准差单位）。用于均值回归判断。",
+    properties={
+        "closes": {"type": "array", "description": "收盘价序列（按时间升序）"},
+        "lookback": {"type": "integer", "description": "回看窗口，默认20"},
+    },
+    required=["closes"],
+)
+def tool_zscore(closes, lookback: int = 20) -> dict:
+    closes = _series(closes, "closes", 2)
+    lookback = _period(lookback, "lookback")
+    if lookback > len(closes):
+        raise ToolError(f"lookback({lookback})不能大于序列长度({len(closes)})")
+    window = closes[-lookback:]
+    mean = sum(window) / lookback
+    sd = _std(window)
+    z = (closes[-1] - mean) / sd if sd > 0 else 0.0
+    return {"zscore": _r(z), "mean": _r(mean), "std": _r(sd), "lookback": lookback}
+
+
+# ---------- 技术指标：OHLC K线序列 ----------
+
+@tool(
+    "atr",
+    "ATR 真实波幅均值（Wilder 平滑）。衡量波动率，常用于止损距离设置。",
+    properties={
+        "high": {"type": "array", "description": "最高价序列"},
+        "low": {"type": "array", "description": "最低价序列"},
+        "close": {"type": "array", "description": "收盘价序列"},
+        "period": {"type": "integer", "description": "周期，默认14"},
+    },
+    required=["high", "low", "close"],
+)
+def tool_atr(high, low, close, period: int = 14) -> dict:
+    high, low, close = _ohlc(high, low, close)
+    period = _period(period, "period")
+    if len(close) <= period:
+        raise ToolError(f"ATR 需要至少{period + 1}根K线")
+    trs = []
+    for i in range(1, len(close)):
+        trs.append(max(high[i] - low[i],
+                       abs(high[i] - close[i - 1]),
+                       abs(low[i] - close[i - 1])))
+    values = _wilder_series(trs, period)
+    return {"period": period, "latest": _r(values[-1]),
+            "values": [_r(v) for v in values]}
+
+
+@tool(
+    "stochastic",
+    "随机指标 %K/%D：%K=(收盘-最低)/(最高-最低)，%D 为 %K 的SMA。80/20 为常用阈值。",
+    properties={
+        "high": {"type": "array", "description": "最高价序列"},
+        "low": {"type": "array", "description": "最低价序列"},
+        "close": {"type": "array", "description": "收盘价序列"},
+        "k_period": {"type": "integer", "description": "%K 周期，默认14"},
+        "d_period": {"type": "integer", "description": "%D 平滑周期，默认3"},
+    },
+    required=["high", "low", "close"],
+)
+def tool_stochastic(high, low, close, k_period: int = 14, d_period: int = 3) -> dict:
+    high, low, close = _ohlc(high, low, close)
+    k_period = _period(k_period, "k_period")
+    d_period = _period(d_period, "d_period")
+    if len(close) < k_period + d_period - 1:
+        raise ToolError(f"随机指标需要至少{k_period + d_period - 1}根K线")
+    k_values = []
+    for i in range(k_period - 1, len(close)):
+        hh = max(high[i - k_period + 1:i + 1])
+        ll = min(low[i - k_period + 1:i + 1])
+        k_values.append(50.0 if hh == ll else 100.0 * (close[i] - ll) / (hh - ll))
+    d_values = _sma_series(k_values, d_period)
+    return {"k_period": k_period, "d_period": d_period,
+            "k": _r(k_values[-1]), "d": _r(d_values[-1])}
+
+
+@tool(
+    "adx",
+    "ADX 趋势强度指标（Wilder）。ADX>25 视为趋势行情，+DI/-DI 指示多空方向。",
+    properties={
+        "high": {"type": "array", "description": "最高价序列"},
+        "low": {"type": "array", "description": "最低价序列"},
+        "close": {"type": "array", "description": "收盘价序列"},
+        "period": {"type": "integer", "description": "周期，默认14"},
+    },
+    required=["high", "low", "close"],
+)
+def tool_adx(high, low, close, period: int = 14) -> dict:
+    high, low, close = _ohlc(high, low, close)
+    period = _period(period, "period")
+    if len(close) < 2 * period + 1:
+        raise ToolError(f"ADX 需要至少{2 * period + 1}根K线")
+    trs, pdms, ndms = [], [], []
+    for i in range(1, len(close)):
+        h, l, pc = high[i], low[i], close[i - 1]
+        trs.append(max(h - l, abs(h - pc), abs(l - pc)))
+        up, dn = h - high[i - 1], low[i - 1] - l
+        pdms.append(up if up > dn and up > 0 else 0.0)
+        ndms.append(dn if dn > up and dn > 0 else 0.0)
+    str_ = _wilder_series(trs, period)
+    spdm = _wilder_series(pdms, period)
+    sndm = _wilder_series(ndms, period)
+    dx = []
+    for s, p, n in zip(str_, spdm, sndm):
+        if s == 0:
+            dx.append(0.0)
+            continue
+        pdi, ndi = 100.0 * p / s, 100.0 * n / s
+        denom = pdi + ndi
+        dx.append(100.0 * abs(pdi - ndi) / denom if denom > 0 else 0.0)
+    adx_values = _wilder_series(dx, period)
+    s, p, n = str_[-1], spdm[-1], sndm[-1]
+    return {"period": period, "adx": _r(adx_values[-1]),
+            "plus_di": _r(100.0 * p / s) if s > 0 else 0.0,
+            "minus_di": _r(100.0 * n / s) if s > 0 else 0.0}
+
+
+@tool(
+    "cci",
+    "CCI 顺势指标：典型价相对 SMA 的偏离（0.015 归一）。+100/-100 为常用阈值。",
+    properties={
+        "high": {"type": "array", "description": "最高价序列"},
+        "low": {"type": "array", "description": "最低价序列"},
+        "close": {"type": "array", "description": "收盘价序列"},
+        "period": {"type": "integer", "description": "周期，默认20"},
+    },
+    required=["high", "low", "close"],
+)
+def tool_cci(high, low, close, period: int = 20) -> dict:
+    high, low, close = _ohlc(high, low, close)
+    period = _period(period, "period")
+    if len(close) < period:
+        raise ToolError(f"CCI 需要至少{period}根K线")
+    tp = [(h + l + c) / 3 for h, l, c in zip(high, low, close)]
+    sma = _sma_series(tp, period)
+    window = tp[-period:]
+    mean_dev = sum(abs(v - sma[-1]) for v in window) / period
+    cci = (tp[-1] - sma[-1]) / (0.015 * mean_dev) if mean_dev > 0 else 0.0
+    return {"period": period, "cci": _r(cci)}
+
+
+@tool(
+    "obv",
+    "OBV 能量潮：收盘涨跌决定成交量正负的累计值。返回最新累计值与最近一段变化。",
+    properties={
+        "close": {"type": "array", "description": "收盘价序列"},
+        "volume": {"type": "array", "description": "成交量序列（>=0）"},
+    },
+    required=["close", "volume"],
+)
+def tool_obv(close, volume) -> dict:
+    close = _series(close, "close", 2)
+    volume = _series(volume, "volume", 2)
+    if len(close) != len(volume):
+        raise ToolError("close 与 volume 长度必须一致")
+    if any(v < 0 for v in volume):
+        raise ToolError("volume 不能为负")
+    obv = 0.0
+    values = [0.0]
+    for i in range(1, len(close)):
+        if close[i] > close[i - 1]:
+            obv += volume[i]
+        elif close[i] < close[i - 1]:
+            obv -= volume[i]
+        values.append(obv)
+    return {"latest": _r(obv, 2),
+            "change_last10": _r(obv - values[-11], 2) if len(values) >= 11 else None}
+
+
+@tool(
+    "vwap",
+    "VWAP 成交量加权平均价：sum(典型价*量)/sum(量)。返回整体 VWAP 与最新价偏离。",
+    properties={
+        "high": {"type": "array", "description": "最高价序列"},
+        "low": {"type": "array", "description": "最低价序列"},
+        "close": {"type": "array", "description": "收盘价序列"},
+        "volume": {"type": "array", "description": "成交量序列（>=0）"},
+    },
+    required=["high", "low", "close", "volume"],
+)
+def tool_vwap(high, low, close, volume) -> dict:
+    high, low, close = _ohlc(high, low, close)
+    volume = _series(volume, "volume", len(close), len(close))
+    if any(v < 0 for v in volume):
+        raise ToolError("volume 不能为负")
+    total_vol = sum(volume)
+    if total_vol <= 0:
+        raise ToolError("volume 总和必须大于0")
+    vwap = sum((h + l + c) / 3 * v for h, l, c, v in zip(high, low, close, volume)) / total_vol
+    return {"vwap": _r(vwap), "total_volume": _r(total_vol, 2),
+            "last_close": _r(close[-1]),
+            "deviation_pct": _r((close[-1] / vwap - 1) * 100) if vwap > 0 else 0.0}
+
+
+# ---------- 统计与序列分析 ----------
+
+@tool(
+    "volatility",
+    "历史波动率：对数收益率标准差 × sqrt(周期数/年)。periods_per_year 如 252(日)、252*24(小时)。",
+    properties={
+        "closes": {"type": "array", "description": "收盘价序列（按时间升序，至少3个）"},
+        "periods_per_year": {"type": "integer", "description": "每年的K线数量，默认252"},
+    },
+    required=["closes"],
+)
+def tool_volatility(closes, periods_per_year: int = 252) -> dict:
+    closes = _series(closes, "closes", 3)
+    ppy = _int(periods_per_year, "periods_per_year", 1, 10_000_000)
+    if any(c <= 0 for c in closes):
+        raise ToolError("closes 必须全部为正数才能计算对数收益")
+    rets = [math.log(closes[i] / closes[i - 1]) for i in range(1, len(closes))]
+    sd = _std(rets, ddof=1)
+    return {"vol_per_period": _r(sd),
+            "vol_annualized": _r(sd * math.sqrt(ppy)),
+            "periods": len(rets), "periods_per_year": ppy}
+
+
+@tool(
+    "correlation",
+    "皮尔逊相关系数：两序列同向变动程度，+1同向 / -1反向 / 0无关。要求等长且方差非零。",
+    properties={
+        "a": {"type": "array", "description": "序列A"},
+        "b": {"type": "array", "description": "序列B（与A等长）"},
+    },
+    required=["a", "b"],
+)
+def tool_correlation(a, b) -> dict:
+    a = _series(a, "a", 3)
+    b = _series(b, "b", 3)
+    if len(a) != len(b):
+        raise ToolError("两序列长度必须一致")
+    ma = sum(a) / len(a)
+    mb = sum(b) / len(b)
+    cov = sum((x - ma) * (y - mb) for x, y in zip(a, b))
+    va = sum((x - ma) ** 2 for x in a)
+    vb = sum((y - mb) ** 2 for y in b)
+    if va == 0 or vb == 0:
+        raise ToolError("存在常数序列（方差为0），相关系数无定义")
+    return {"correlation": _r(cov / math.sqrt(va * vb)), "n": len(a)}
+
+
+def _hurst_estimate(values: List[float]) -> float:
+    """R/S 分析估计 Hurst 指数，输入可为任意实数序列（如价差）。返回[0,1]。"""
+    lags = []
+    lag = 8
+    while lag <= len(values) // 2:
+        lags.append(lag)
+        lag *= 2
+    if len(lags) < 3:
+        raise ToolError("序列太短，无法做R/S分析")
+    rs_values, used_lags = [], []
+    for lag in lags:
+        chunks = len(values) // lag
+        rs_list = []
+        for c in range(chunks):
+            seg = values[c * lag:(c + 1) * lag]
+            mean = sum(seg) / lag
+            cum = 0.0
+            lo, hi = 0.0, 0.0
+            for v in seg:
+                cum += v - mean
+                lo, hi = min(lo, cum), max(hi, cum)
+            rng = hi - lo
+            sd = _std(seg)
+            if sd > 0 and rng > 0:
+                rs_list.append(rng / sd)
+        if rs_list:
+            rs_values.append(sum(rs_list) / len(rs_list))
+            used_lags.append(lag)
+    if len(used_lags) < 3:
+        raise ToolError("有效R/S点不足，无法拟合Hurst指数")
+    xs = [math.log(l) for l in used_lags]
+    ys = [math.log(r) for r in rs_values]
+    mx, my = sum(xs) / len(xs), sum(ys) / len(ys)
+    denom = sum((x - mx) ** 2 for x in xs)
+    hurst = sum((x - mx) * (y - my) for x, y in zip(xs, ys)) / denom if denom > 0 else 0.5
+    return min(max(hurst, 0.0), 1.0)
+
+
+def _ar1_half_life(values: List[float]):
+    """AR(1)/OU均值回归半衰期：Δy 对 y_{t-1} 回归。返回 (slope, intercept, half_life)。"""
+    n = len(values)
+    x = values[:-1]
+    dx = [values[i] - values[i - 1] for i in range(1, n)]
+    mx, md = sum(x) / len(x), sum(dx) / len(dx)
+    sxx = sum((v - mx) ** 2 for v in x)
+    if sxx <= 0:
+        raise ToolError("序列无波动，半衰期无定义")
+    sxy = sum((v - mx) * (d - md) for v, d in zip(x, dx))
+    slope = sxy / sxx
+    intercept = md - slope * mx
+    if slope >= 0:
+        return slope, intercept, None  # 无均值回归
+    if 1.0 + slope <= 1e-9:
+        raise ToolError("序列呈爆炸性/极端负自相关，半衰期无定义")
+    return slope, intercept, -math.log(2) / math.log(1.0 + slope)
+
+
+def _mat_inverse(m) -> List[List[float]]:
+    """高斯-约当部分主元求逆；奇异矩阵抛错。仅用于小规模协方差矩阵(<=25维)。"""
+    n = len(m)
+    aug = [row[:] + [1.0 if i == j else 0.0 for j in range(n)]
+           for i, row in enumerate(m)]
+    for col in range(n):
+        piv = max(range(col, n), key=lambda r: abs(aug[r][col]))
+        if abs(aug[piv][col]) < 1e-12:
+            raise ToolError("协方差矩阵奇异，无法求逆")
+        aug[col], aug[piv] = aug[piv], aug[col]
+        pv = aug[col][col]
+        aug[col] = [v / pv for v in aug[col]]
+        for r in range(n):
+            if r != col and aug[r][col] != 0.0:
+                f = aug[r][col]
+                aug[r] = [v - f * w for v, w in zip(aug[r], aug[col])]
+    return [row[n:] for row in aug]
+
+
+def _norm_cdf(x: float) -> float:
+    return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))
+
+
+def _norm_ppf(p: float) -> float:
+    """标准正态分位数（Acklam 逼近，|误差|<1.15e-9）。"""
+    if not 0.0 < p < 1.0:
+        raise ToolError("分位数概率必须在(0,1)内")
+    a = [-3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02,
+         1.383577518672690e+02, -3.066479806614716e+01, 2.506628277459239e+00]
+    b = [-5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02,
+         6.680131188771972e+01, -1.328068155288572e+01]
+    c = [-7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00,
+         -2.549732539343734e+00, 4.374664141464968e+00, 2.938163982698783e+00]
+    d = [7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00,
+         3.754408661907416e+00]
+    plow, phigh = 0.02425, 1 - 0.02425
+    if p < plow:
+        q = math.sqrt(-2 * math.log(p))
+        return (((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) / \
+               ((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1)
+    if p > phigh:
+        q = math.sqrt(-2 * math.log(1 - p))
+        return -(((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) / \
+               ((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1)
+    q = p - 0.5
+    r = q * q
+    return (((((a[0]*r+a[1])*r+a[2])*r+a[3])*r+a[4])*r+a[5])*q / \
+           (((((b[0]*r+b[1])*r+b[2])*r+b[3])*r+b[4])*r+1)
+
+
+@tool(
+    "hurst",
+    "Hurst 指数（R/S分析）：<0.5 均值回归，≈0.5 随机游走，>0.5 趋势延续。",
+    properties={
+        "closes": {"type": "array", "description": "价格序列（至少64个点）"},
+    },
+    required=["closes"],
+)
+def tool_hurst(closes) -> dict:
+    closes = _series(closes, "closes", 64, MAX_CANDLES)
+    if any(c <= 0 for c in closes):
+        raise ToolError("closes 必须全部为正数")
+    hurst = _hurst_estimate(closes)
+    regime = "均值回归" if hurst < 0.45 else ("趋势延续" if hurst > 0.55 else "接近随机游走")
+    return {"hurst": _r(hurst), "regime_hint": regime}
+
+
+@tool(
+    "linear_trend",
+    "线性回归趋势：以时间序号为自变量做OLS，返回斜率、截距、R²与归一化斜率。",
+    properties={
+        "values": {"type": "array", "description": "数值序列（按时间升序）"},
+    },
+    required=["values"],
+)
+def tool_linear_trend(values) -> dict:
+    values = _series(values, "values", 3)
+    n = len(values)
+    mx = (n - 1) / 2
+    my = sum(values) / n
+    sxx = sum((i - mx) ** 2 for i in range(n))
+    sxy = sum((i - mx) * (v - my) for i, v in enumerate(values))
+    slope = sxy / sxx
+    intercept = my - slope * mx
+    ss_tot = sum((v - my) ** 2 for v in values)
+    ss_res = sum((v - (intercept + slope * i)) ** 2 for i, v in enumerate(values))
+    r2 = 1 - ss_res / ss_tot if ss_tot > 0 else 0.0
+    norm = slope / abs(my) if my != 0 else None
+    return {"slope": _r(slope), "intercept": _r(intercept), "r2": _r(r2),
+            "slope_pct_per_step": _r(norm) if norm is not None else None}
+
+
+@tool(
+    "describe",
+    "序列描述统计：均值/标准差/偏度/峰度/分位数/极值。",
+    properties={
+        "values": {"type": "array", "description": "数值序列（至少3个）"},
+    },
+    required=["values"],
+)
+def tool_describe(values) -> dict:
+    values = _series(values, "values", 3)
+    n = len(values)
+    mean = sum(values) / n
+    sd = _std(values, ddof=1)
+    m2 = sum((v - mean) ** 2 for v in values) / n
+    m3 = sum((v - mean) ** 3 for v in values) / n
+    m4 = sum((v - mean) ** 4 for v in values) / n
+    skew = (m3 / m2 ** 1.5) if m2 > 0 else 0.0
+    kurt = (m4 / m2 ** 2 - 3) if m2 > 0 else 0.0
+    s = sorted(values)
+    return {"n": n, "mean": _r(mean), "std": _r(sd), "min": _r(s[0]), "max": _r(s[-1]),
+            "skew": _r(skew), "excess_kurtosis": _r(kurt),
+            "p25": _r(_percentile(s, 25)), "median": _r(_percentile(s, 50)),
+            "p75": _r(_percentile(s, 75))}
+
+
+# ---------- 绩效与风险 ----------
+
+@tool(
+    "sharpe_sortino",
+    "夏普与索提诺比率：基于算术收益率序列，年化 sqrt(periods_per_year)。下行波动只统计负收益。",
+    properties={
+        "returns": {"type": "array", "description": "每期收益率序列（小数，如0.01）"},
+        "periods_per_year": {"type": "integer", "description": "每年的期数，默认252"},
+    },
+    required=["returns"],
+)
+def tool_sharpe_sortino(returns, periods_per_year: int = 252) -> dict:
+    rets = _series(returns, "returns", 2)
+    ppy = _int(periods_per_year, "periods_per_year", 1, 10_000_000)
+    n = len(rets)
+    mean = sum(rets) / n
+    sd = _std(rets, ddof=1)
+    downside = math.sqrt(sum(min(r, 0.0) ** 2 for r in rets) / n)
+    sharpe = mean / sd * math.sqrt(ppy) if sd > 0 else None
+    sortino = mean / downside * math.sqrt(ppy) if downside > 0 else None
+    return {"sharpe": _r(sharpe) if sharpe is not None else None,
+            "sortino": _r(sortino) if sortino is not None else None,
+            "mean_return": _r(mean), "vol_per_period": _r(sd),
+            "downside_vol": _r(downside), "periods": n, "periods_per_year": ppy}
+
+
+def _equity_curve(equity, returns) -> List[float]:
+    """equity（净值）或 returns（收益率复利合成）二选一，返回净值曲线。"""
+    if equity is not None and returns is not None:
+        raise ToolError("equity 与 returns 只能提供其一")
+    if equity is not None:
+        curve = _series(equity, "equity", 2)
+        if any(v <= 0 for v in curve):
+            raise ToolError("equity 必须全部为正数")
+        return curve
+    if returns is not None:
+        rets = _series(returns, "returns", 2)
+        curve, v = [], 1.0
+        for r in rets:
+            v *= (1 + r)
+            if v <= 0:
+                raise ToolError("收益率导致净值归零或为负，无法计算回撤")
+            curve.append(v)
+        return curve
+    raise ToolError("必须提供 equity 或 returns")
+
+
+@tool(
+    "max_drawdown",
+    "最大回撤：输入净值曲线或收益率序列（内部复利合成净值）。返回回撤幅度与峰谷位置。",
+    properties={
+        "equity": {"type": "array", "description": "净值曲线（与returns二选一）"},
+        "returns": {"type": "array", "description": "收益率序列（小数，与equity二选一）"},
+    },
+)
+def tool_max_drawdown(equity=None, returns=None) -> dict:
+    curve = _equity_curve(equity, returns)
+    peak, peak_idx = curve[0], 0
+    max_dd, max_peak, max_trough = 0.0, 0, 0
+    for i, v in enumerate(curve):
+        if v > peak:
+            peak, peak_idx = v, i
+        dd = v / peak - 1
+        if dd < max_dd:
+            max_dd, max_peak, max_trough = dd, peak_idx, i
+    return {"max_drawdown_pct": _r(max_dd * 100), "peak_index": max_peak,
+            "trough_index": max_trough, "points": len(curve)}
+
+
+@tool(
+    "var_cvar",
+    "历史法 VaR/CVaR：给定置信度下的在险价值与条件在险价值（收益率口径，负数代表亏损）。",
+    properties={
+        "returns": {"type": "array", "description": "每期收益率序列（小数）"},
+        "confidence": {"type": "number", "description": "置信度0.9/0.95/0.99，默认0.95"},
+    },
+    required=["returns"],
+)
+def tool_var_cvar(returns, confidence: float = 0.95) -> dict:
+    rets = _series(returns, "returns", 10)
+    confidence = _number(confidence, "confidence", 0.5, 0.9999)
+    s = sorted(rets)
+    var = _percentile(s, (1 - confidence) * 100)
+    tail = [v for v in s if v <= var]
+    cvar = sum(tail) / len(tail)
+    return {"confidence": confidence, "var": _r(var), "cvar": _r(cvar),
+            "var_pct": _r(var * 100), "cvar_pct": _r(cvar * 100), "n": len(rets)}
+
+
+def _trade_stats_core(pnls: List[float]) -> dict:
+    """交易统计内核：胜率/盈亏比/期望/利润因子/连胜连亏，供多个报告工具复用。"""
+    wins = [p for p in pnls if p > 0]
+    losses = [p for p in pnls if p < 0]
+    gross_win = sum(wins)
+    gross_loss = abs(sum(losses))
+    profit_factor = gross_win / gross_loss if gross_loss > 0 else None
+    max_wins = max_losses = cur_w = cur_l = 0
+    for p in pnls:
+        if p > 0:
+            cur_w += 1
+            cur_l = 0
+        elif p < 0:
+            cur_l += 1
+            cur_w = 0
+        else:
+            cur_w = cur_l = 0
+        max_wins = max(max_wins, cur_w)
+        max_losses = max(max_losses, cur_l)
+    payoff = (gross_win / len(wins)) / (gross_loss / len(losses)) if wins and losses else None
+    return {
+        "trades": len(pnls),
+        "wins": len(wins), "losses": len(losses),
+        "breakeven": len(pnls) - len(wins) - len(losses),
+        "win_rate_pct": _r(len(wins) / len(pnls) * 100),
+        "profit_factor": _r(profit_factor) if profit_factor is not None else None,
+        "expectancy": _r(sum(pnls) / len(pnls)),
+        "avg_win": _r(gross_win / len(wins)) if wins else None,
+        "avg_loss": _r(gross_loss / len(losses)) if losses else None,
+        "payoff_ratio": _r(payoff) if payoff is not None else None,
+        "max_consecutive_wins": max_wins,
+        "max_consecutive_losses": max_losses,
+        "total_pnl": _r(sum(pnls)),
+    }
+
+
+@tool(
+    "trade_stats",
+    "交易绩效统计：胜率、盈亏比、期望值、利润因子、最大连胜/连亏。输入每笔盈亏（任意货币单位）。",
+    properties={
+        "pnls": {"type": "array", "description": "每笔交易盈亏序列（至少5笔）"},
+    },
+    required=["pnls"],
+)
+def tool_trade_stats(pnls) -> dict:
+    return _trade_stats_core(_series(pnls, "pnls", 5))
+
+
+# ---------- 仓位管理 ----------
+
+@tool(
+    "position_size",
+    "风险仓位计算：按单笔风险百分比与止损距离确定手数（含最小手数校验）。"
+    "loss_per_lot = 止损距离/tick_size × tick_value。",
+    properties={
+        "equity": {"type": "number", "description": "账户净值（>0）"},
+        "risk_pct": {"type": "number", "description": "单笔风险占净值百分比(0,50]"},
+        "entry": {"type": "number", "description": "计划入场价"},
+        "stop": {"type": "number", "description": "止损价（不等于entry）"},
+        "tick_value": {"type": "number", "description": "每手每tick价值（报价货币，>0）"},
+        "tick_size": {"type": "number", "description": "最小变动价位（>0）"},
+        "volume_step": {"type": "number", "description": "手数步长，默认0.01"},
+        "volume_min": {"type": "number", "description": "最小手数，默认0.01"},
+        "volume_max": {"type": "number", "description": "最大手数，默认100"},
+    },
+    required=["equity", "risk_pct", "entry", "stop", "tick_value", "tick_size"],
+)
+def tool_position_size(equity, risk_pct, entry, stop, tick_value, tick_size,
+                       volume_step: float = 0.01, volume_min: float = 0.01,
+                       volume_max: float = 100.0) -> dict:
+    equity = _number(equity, "equity", 1e-9, 1e15)
+    risk_pct = _number(risk_pct, "risk_pct", 1e-6, 50)
+    entry = _number(entry, "entry", 1e-12, 1e15)
+    stop = _number(stop, "stop", 0, 1e15)
+    tick_value = _number(tick_value, "tick_value", 1e-12, 1e12)
+    tick_size = _number(tick_size, "tick_size", 1e-12, 1e6)
+    step = _number(volume_step, "volume_step", 1e-9, 1000)
+    vmin = _number(volume_min, "volume_min", 0, 1000)
+    vmax = _number(volume_max, "volume_max", 0, 1000)
+    if vmax < vmin:
+        raise ToolError("volume_max 不能小于 volume_min")
+    stop_dist = abs(entry - stop)
+    if stop_dist <= 0:
+        raise ToolError("entry 与 stop 不能相同")
+    loss_per_lot = stop_dist / tick_size * tick_value
+    risk_amount = equity * risk_pct / 100
+    raw_lots = risk_amount / loss_per_lot
+    # +1e-9 容忍浮点误差：1.0/0.01=99.999...不应少一手
+    lots = math.floor(raw_lots / step + 1e-9) * step
+    lots = min(max(lots, 0.0), vmax)
+    return {
+        "risk_amount": _r(risk_amount),
+        "stop_distance": _r(stop_dist),
+        "loss_per_lot": _r(loss_per_lot),
+        "raw_lots": _r(raw_lots, 4),
+        "lots": _r(lots, 2),
+        "below_volume_min": lots < vmin,
+        "note": ("建议手数低于最小手数，应放弃该笔交易或放宽止损" if lots < vmin
+                 else "手数已按步长向下取整，实际风险不超过目标"),
+    }
+
+
+@tool(
+    "kelly_criterion",
+    "凯利公式：给定胜率与盈亏比，输出满仓/半仓/四分之一凯利比例。结果为分析参考，非加仓建议。",
+    properties={
+        "win_rate_pct": {"type": "number", "description": "胜率百分比(0,100)"},
+        "payoff_ratio": {"type": "number", "description": "盈亏比=平均盈利/平均亏损(>0)"},
+    },
+    required=["win_rate_pct", "payoff_ratio"],
+)
+def tool_kelly(win_rate_pct, payoff_ratio) -> dict:
+    win_rate_pct = _number(win_rate_pct, "win_rate_pct", 1e-9, 99.9999)
+    b = _number(payoff_ratio, "payoff_ratio", 1e-9, 1e6)
+    p = win_rate_pct / 100
+    f = p - (1 - p) / b
+    note = None
+    if f <= 0:
+        note = "期望为负或为零：该系统不具备正凯利敞口，不应使用凯利仓位"
+    return {"kelly_fraction": _r(f), "kelly_pct": _r(f * 100),
+            "half_kelly_pct": _r(f * 50), "quarter_kelly_pct": _r(f * 25),
+            "note": note}
+
+
+@tool(
+    "monte_carlo_risk",
+    "蒙特卡洛资金曲线模拟：按胜率/盈亏比/单笔风险复利模拟，输出终值分位、回撤分布与破产概率。"
+    "确定性随机（同seed同结果），仅用于风险认知，不预测真实收益。",
+    properties={
+        "win_rate_pct": {"type": "number", "description": "胜率百分比(0,100)"},
+        "payoff_ratio": {"type": "number", "description": "盈亏比(>0)"},
+        "risk_pct": {"type": "number", "description": "每笔风险占净值百分比(0,50]"},
+        "trades": {"type": "integer", "description": "每条路径交易笔数(1..2000)，默认200"},
+        "paths": {"type": "integer", "description": "模拟路径数(1..5000)，默认1000"},
+        "seed": {"type": "integer", "description": "随机种子，默认42"},
+        "ruin_pct": {"type": "number", "description": "破产线：净值回撤百分比，默认50"},
+    },
+    required=["win_rate_pct", "payoff_ratio", "risk_pct"],
+)
+def tool_monte_carlo(win_rate_pct, payoff_ratio, risk_pct, trades: int = 200,
+                     paths: int = 1000, seed: int = 42, ruin_pct: float = 50) -> dict:
+    win_rate_pct = _number(win_rate_pct, "win_rate_pct", 0.0001, 99.9999)
+    payoff = _number(payoff_ratio, "payoff_ratio", 1e-9, 1e6)
+    risk_pct = _number(risk_pct, "risk_pct", 1e-6, 50)
+    trades = _int(trades, "trades", 1, 2000)
+    paths = _int(paths, "paths", 1, 5000)
+    if trades * paths > 2_000_000:
+        raise ToolError("trades × paths 不能超过200万，请降低规模")
+    ruin_pct = _number(ruin_pct, "ruin_pct", 1, 100)
+    p = win_rate_pct / 100
+    rng = random.Random(_int(seed, "seed", 0, 2**31 - 1))
+    finals, max_dds, ruined = [], [], 0
+    for _ in range(paths):
+        equity = 1.0
+        peak = 1.0
+        dd = 0.0
+        for _ in range(trades):
+            risked = equity * risk_pct / 100
+            if rng.random() < p:
+                equity += risked * payoff
+            else:
+                equity -= risked
+            if equity <= 0:
+                equity = 0.0
+            peak = max(peak, equity)
+            dd = min(dd, equity / peak - 1)
+        if equity <= (1 - ruin_pct / 100):
+            ruined += 1
+        finals.append(equity)
+        max_dds.append(dd)
+    finals.sort()
+    max_dds.sort()
+    return {
+        "paths": paths, "trades": trades, "seed": seed,
+        "final_equity_p5": _r(_percentile(finals, 5), 4),
+        "final_equity_p25": _r(_percentile(finals, 25), 4),
+        "final_equity_p50": _r(_percentile(finals, 50), 4),
+        "final_equity_p75": _r(_percentile(finals, 75), 4),
+        "final_equity_p95": _r(_percentile(finals, 95), 4),
+        "median_max_drawdown_pct": _r(_percentile(max_dds, 50) * 100),
+        "worst_max_drawdown_pct": _r(max_dds[0] * 100),
+        "prob_ruin_pct": _r(ruined / paths * 100),
+        "note": "结果依赖输入假设（胜率/盈亏比恒定），不代表真实市场表现",
+    }
+
+
+# ---------- 第二批：动量/通道/枢轴/比率 ----------
+
+@tool(
+    "williams_r",
+    "威廉指标 %R：-100..0，-80..-100 超卖、-20..0 超买。",
+    properties={
+        "high": {"type": "array", "description": "最高价序列"},
+        "low": {"type": "array", "description": "最低价序列"},
+        "close": {"type": "array", "description": "收盘价序列"},
+        "period": {"type": "integer", "description": "周期，默认14"},
+    },
+    required=["high", "low", "close"],
+)
+def tool_williams_r(high, low, close, period: int = 14) -> dict:
+    high, low, close = _ohlc(high, low, close)
+    period = _period(period, "period")
+    if len(close) < period:
+        raise ToolError(f"威廉指标需要至少{period}根K线")
+    hh = max(high[-period:])
+    ll = min(low[-period:])
+    if hh == ll:
+        return {"williams_r": -50.0, "period": period, "note": "区间无波动"}
+    return {"williams_r": _r(-100.0 * (hh - close[-1]) / (hh - ll)), "period": period}
+
+
+@tool(
+    "roc",
+    "变动率 ROC：最新价相对 period 期前的涨跌百分比。动量与背离分析。",
+    properties={
+        "closes": {"type": "array", "description": "收盘价序列（正数）"},
+        "period": {"type": "integer", "description": "周期，默认12"},
+    },
+    required=["closes"],
+)
+def tool_roc(closes, period: int = 12) -> dict:
+    closes = _series(closes, "closes", 2)
+    period = _period(period, "period")
+    if any(c <= 0 for c in closes):
+        raise ToolError("closes 必须全部为正数")
+    if len(closes) <= period:
+        raise ToolError(f"ROC 需要至少{period + 1}个收盘价")
+    values = [100.0 * (closes[i] / closes[i - period] - 1)
+              for i in range(period, len(closes))]
+    return {"period": period, "latest": _r(values[-1]),
+            "values": [_r(v) for v in values]}
+
+
+@tool(
+    "donchian",
+    "唐奇安通道：period 期最高/最低构成上下轨，返回最新轨道与收盘价在通道内的位置。突破跟踪常用。",
+    properties={
+        "high": {"type": "array", "description": "最高价序列"},
+        "low": {"type": "array", "description": "最低价序列"},
+        "close": {"type": "array", "description": "收盘价序列"},
+        "period": {"type": "integer", "description": "周期，默认20"},
+    },
+    required=["high", "low", "close"],
+)
+def tool_donchian(high, low, close, period: int = 20) -> dict:
+    high, low, close = _ohlc(high, low, close)
+    period = _period(period, "period")
+    if len(close) < period:
+        raise ToolError(f"唐奇安通道需要至少{period}根K线")
+    upper = max(high[-period:])
+    lower = min(low[-period:])
+    position = (close[-1] - lower) / (upper - lower) if upper > lower else 0.5
+    return {"upper": _r(upper), "lower": _r(lower), "mid": _r((upper + lower) / 2),
+            "position_pct": _r(position * 100), "period": period}
+
+
+@tool(
+    "keltner",
+    "肯特纳通道：EMA ± multiplier×ATR。与布林带对照可判断波动扩张/收缩。",
+    properties={
+        "high": {"type": "array", "description": "最高价序列"},
+        "low": {"type": "array", "description": "最低价序列"},
+        "close": {"type": "array", "description": "收盘价序列"},
+        "period": {"type": "integer", "description": "周期，默认20"},
+        "multiplier": {"type": "number", "description": "ATR倍数，默认2"},
+    },
+    required=["high", "low", "close"],
+)
+def tool_keltner(high, low, close, period: int = 20, multiplier: float = 2.0) -> dict:
+    high, low, close = _ohlc(high, low, close)
+    period = _period(period, "period")
+    multiplier = _number(multiplier, "multiplier", 0.1, 20)
+    if len(close) <= period:
+        raise ToolError(f"肯特纳通道需要至少{period + 1}根K线")
+    basis = [v for v in _ema_series(close, period) if v is not None][-1]
+    trs = [max(high[i] - low[i], abs(high[i] - close[i - 1]), abs(low[i] - close[i - 1]))
+           for i in range(1, len(close))]
+    atr = _wilder_series(trs, period)[-1]
+    return {"basis": _r(basis), "upper": _r(basis + multiplier * atr),
+            "lower": _r(basis - multiplier * atr), "atr": _r(atr), "period": period}
+
+
+@tool(
+    "choppiness",
+    "盘整指数 CHOP（0..100）：>61.8 盘整，<38.2 趋势。基于真实波幅总和与区间宽度之比。",
+    properties={
+        "high": {"type": "array", "description": "最高价序列"},
+        "low": {"type": "array", "description": "最低价序列"},
+        "close": {"type": "array", "description": "收盘价序列"},
+        "period": {"type": "integer", "description": "周期，默认14"},
+    },
+    required=["high", "low", "close"],
+)
+def tool_choppiness(high, low, close, period: int = 14) -> dict:
+    high, low, close = _ohlc(high, low, close)
+    period = _period(period, "period")
+    if len(close) <= period:
+        raise ToolError(f"盘整指数需要至少{period + 1}根K线")
+    tr_sum = sum(max(high[i] - low[i], abs(high[i] - close[i - 1]),
+                     abs(low[i] - close[i - 1])) for i in range(len(close) - period, len(close)))
+    rng = max(high[-period:]) - min(low[-period:])
+    if rng <= 0 or tr_sum <= 0:
+        raise ToolError("区间无波动，盘整指数无定义")
+    chop = 100.0 * math.log10(tr_sum / rng) / math.log10(period)
+    return {"chop": _r(min(max(chop, 0.0), 100.0)), "period": period}
+
+
+@tool(
+    "pivot_points",
+    "经典枢轴点：由上一根完成的K线（日/周）H/L/C 计算 P、R1-R3、S1-S3 支撑阻力位。",
+    properties={
+        "high": {"type": "number", "description": "上一根K线最高价"},
+        "low": {"type": "number", "description": "上一根K线最低价"},
+        "close": {"type": "number", "description": "上一根K线收盘价"},
+    },
+    required=["high", "low", "close"],
+)
+def tool_pivot_points(high, low, close) -> dict:
+    high = _number(high, "high", 0, 1e15)
+    low = _number(low, "low", 0, 1e15)
+    close = _number(close, "close", 0, 1e15)
+    if not low <= close <= high or high < low:
+        raise ToolError("需满足 low <= close <= high")
+    p = (high + low + close) / 3
+    return {"p": _r(p), "r1": _r(2 * p - low), "s1": _r(2 * p - high),
+            "r2": _r(p + (high - low)), "s2": _r(p - (high - low)),
+            "r3": _r(high + 2 * (p - low)), "s3": _r(low - 2 * (high - p))}
+
+
+@tool(
+    "fibonacci_retracement",
+    "斐波那契回撤位：给定摆动高低点，返回 23.6/38.2/50/61.8/78.6% 回撤价位。",
+    properties={
+        "swing_high": {"type": "number", "description": "摆动高点（> swing_low）"},
+        "swing_low": {"type": "number", "description": "摆动低点"},
+    },
+    required=["swing_high", "swing_low"],
+)
+def tool_fibonacci(swing_high, swing_low) -> dict:
+    swing_high = _number(swing_high, "swing_high", 0, 1e15)
+    swing_low = _number(swing_low, "swing_low", 0, 1e15)
+    if swing_high <= swing_low:
+        raise ToolError("swing_high 必须大于 swing_low")
+    rng = swing_high - swing_low
+    levels = {f"{int(r * 1000) / 10}%": _r(swing_high - r * rng)
+              for r in (0.236, 0.382, 0.5, 0.618, 0.786)}
+    return {"swing_high": _r(swing_high), "swing_low": _r(swing_low),
+            "range": _r(rng), "retracement_levels": levels,
+            "note": "回撤位自摆动高点向下度量；上涨回撤关注38.2-61.8%区间"}
+
+
+@tool(
+    "ma_crossover",
+    "均线交叉状态：快慢均线当前位置与最近一次金叉/死叉。返回状态、距交叉K线数与交叉价。",
+    properties={
+        "closes": {"type": "array", "description": "收盘价序列（按时间升序）"},
+        "fast_period": {"type": "integer", "description": "快线周期，默认5"},
+        "slow_period": {"type": "integer", "description": "慢线周期，默认20"},
+        "method": {"type": "string", "enum": ["sma", "ema"], "description": "均线类型，默认sma"},
+    },
+    required=["closes"],
+)
+def tool_ma_crossover(closes, fast_period: int = 5, slow_period: int = 20,
+                      method: str = "sma") -> dict:
+    closes = _series(closes, "closes", 2)
+    fast_period = _period(fast_period, "fast_period")
+    slow_period = _period(slow_period, "slow_period")
+    if fast_period >= slow_period:
+        raise ToolError("fast_period 必须小于 slow_period")
+    if method not in ("sma", "ema"):
+        raise ToolError("method 必须是 sma 或 ema")
+
+    def aligned(values, period):
+        if method == "sma":
+            return [None] * (period - 1) + _sma_series(values, period)
+        return _ema_series(values, period)
+
+    fast, slow = aligned(closes, fast_period), aligned(closes, slow_period)
+    cross_idx, cross_type, cross_price = None, None, None
+    prev_diff = None
+    for i in range(len(closes)):
+        if fast[i] is None or slow[i] is None:
+            continue
+        diff = fast[i] - slow[i]
+        if prev_diff is not None and (prev_diff <= 0 < diff or prev_diff >= 0 > diff):
+            cross_idx = i
+            cross_type = "golden_cross" if diff > 0 else "dead_cross"
+            cross_price = closes[i]
+        prev_diff = diff
+    latest_diff = fast[-1] - slow[-1]
+    state = cross_type if cross_idx == len(closes) - 1 else \
+        ("fast_above" if latest_diff > 0 else "fast_below")
+    return {
+        "state": state,
+        "bars_since_cross": (len(closes) - 1 - cross_idx) if cross_idx is not None else None,
+        "cross_type": cross_type,
+        "cross_price": _r(cross_price) if cross_price is not None else None,
+        "fast": _r(fast[-1]), "slow": _r(slow[-1]), "diff": _r(latest_diff),
+    }
+
+
+@tool(
+    "beta_alpha",
+    "相对基准的 Beta 与 Alpha：beta=协方差/基准方差，alpha=超额收益（每期与年化）。"
+    "要求两序列等长、基准方差非零。",
+    properties={
+        "asset_returns": {"type": "array", "description": "资产每期收益率"},
+        "benchmark_returns": {"type": "array", "description": "基准每期收益率（等长）"},
+        "periods_per_year": {"type": "integer", "description": "每年期数，默认252"},
+    },
+    required=["asset_returns", "benchmark_returns"],
+)
+def tool_beta_alpha(asset_returns, benchmark_returns, periods_per_year: int = 252) -> dict:
+    a = _series(asset_returns, "asset_returns", 10)
+    b = _series(benchmark_returns, "benchmark_returns", 10)
+    if len(a) != len(b):
+        raise ToolError("两序列长度必须一致")
+    ppy = _int(periods_per_year, "periods_per_year", 1, 10_000_000)
+    n = len(a)
+    ma, mb = sum(a) / n, sum(b) / n
+    cov = sum((x - ma) * (y - mb) for x, y in zip(a, b)) / n
+    var_b = sum((y - mb) ** 2 for y in b) / n
+    if var_b == 0:
+        raise ToolError("基准收益为常数（方差为0），beta无定义")
+    beta = cov / var_b
+    alpha = ma - beta * mb
+    corr = cov / math.sqrt(var_b * (sum((x - ma) ** 2 for x in a) / n)) \
+        if sum((x - ma) ** 2 for x in a) > 0 else None
+    return {"beta": _r(beta), "alpha_per_period": _r(alpha),
+            "alpha_annualized": _r(alpha * ppy),
+            "correlation": _r(corr) if corr is not None else None,
+            "n": n, "periods_per_year": ppy}
+
+
+@tool(
+    "ulcer_index",
+    "溃疡指数：回撤深度与持续时间的综合（回撤平方和的均方根）。衡量下行痛苦的深度指标。",
+    properties={
+        "equity": {"type": "array", "description": "净值曲线（与returns二选一）"},
+        "returns": {"type": "array", "description": "收益率序列（与equity二选一）"},
+    },
+)
+def tool_ulcer_index(equity=None, returns=None) -> dict:
+    curve = _equity_curve(equity, returns)
+    peak, max_dd, squares = curve[0], 0.0, []
+    for v in curve:
+        peak = max(peak, v)
+        dd = (v / peak - 1) * 100
+        max_dd = min(max_dd, dd)
+        squares.append(dd * dd)
+    return {"ulcer_index": _r(math.sqrt(sum(squares) / len(squares))),
+            "max_drawdown_pct": _r(max_dd), "points": len(curve)}
+
+
+@tool(
+    "omega_ratio",
+    "Omega 比率：阈值上方收益与下方亏损的概率加权比。>1 表示超过阈值的收益占优。",
+    properties={
+        "returns": {"type": "array", "description": "每期收益率序列"},
+        "threshold": {"type": "number", "description": "目标收益阈值（小数），默认0"},
+    },
+    required=["returns"],
+)
+def tool_omega(returns, threshold: float = 0.0) -> dict:
+    rets = _series(returns, "returns", 5)
+    threshold = _number(threshold, "threshold", -1, 10)
+    gains = sum(max(r - threshold, 0.0) for r in rets)
+    losses = sum(max(threshold - r, 0.0) for r in rets)
+    omega = gains / losses if losses > 0 else None
+    return {"omega": _r(omega) if omega is not None else None,
+            "gains": _r(gains), "losses": _r(losses),
+            "threshold": threshold,
+            "note": "无亏损时Omega无上界，返回null" if omega is None else None}
+
+
+@tool(
+    "calmar_ratio",
+    "卡玛比率：年化收益 / |最大回撤|。回撤为零时返回null。",
+    properties={
+        "equity": {"type": "array", "description": "净值曲线（与returns二选一）"},
+        "returns": {"type": "array", "description": "收益率序列（与equity二选一）"},
+        "periods_per_year": {"type": "integer", "description": "每年期数，默认252"},
+    },
+)
+def tool_calmar(equity=None, returns=None, periods_per_year: int = 252) -> dict:
+    curve = _equity_curve(equity, returns)
+    ppy = _int(periods_per_year, "periods_per_year", 1, 10_000_000)
+    periods = len(curve) - 1
+    if periods < 1:
+        raise ToolError("净值曲线至少需要2个点")
+    growth = curve[-1] / curve[0]
+    if growth <= 0:
+        raise ToolError("净值终值为非正数，无法年化")
+    try:
+        ann_ret = growth ** (ppy / periods) - 1
+    except OverflowError:
+        raise ToolError("年化收益计算溢出") from None
+    if not math.isfinite(ann_ret):
+        raise ToolError("年化收益计算溢出")
+    peak, max_dd = curve[0], 0.0
+    for v in curve:
+        peak = max(peak, v)
+        max_dd = min(max_dd, v / peak - 1)
+    calmar = ann_ret / abs(max_dd) if max_dd < 0 else None
+    return {"annualized_return_pct": _r(ann_ret * 100),
+            "max_drawdown_pct": _r(max_dd * 100),
+            "calmar": _r(calmar) if calmar is not None else None,
+            "note": "无回撤时Calmar无定义，返回null" if calmar is None else None}
+
+
+# ---------- 第三批：多策略组合 / 多品种筛选 / 优选 / 前沿算法 / 风控 ----------
+
+MAX_PORTFOLIO_N = 25
+MAX_PORTFOLIO_LEN = 5000
+
+
+def _returns_columns(series_list, label) -> List[List[float]]:
+    """多条等长收益率序列 → 列矩阵（每列一条策略/品种收益）。"""
+    if not isinstance(series_list, list) or not 2 <= len(series_list) <= MAX_PORTFOLIO_N:
+        raise ToolError(f"{label}: 需要2..{MAX_PORTFOLIO_N}条序列")
+    cols = [_series(s, f"{label}[{i}]", 10, MAX_PORTFOLIO_LEN)
+            for i, s in enumerate(series_list)]
+    n = len(cols[0])
+    if any(len(c) != n for c in cols):
+        raise ToolError(f"{label}: 所有序列长度必须一致")
+    return cols
+
+
+def _cov_matrix(cols) -> List[List[float]]:
+    n = len(cols[0])
+    k = len(cols)
+    means = [sum(c) / n for c in cols]
+    return [[sum((cols[i][t] - means[i]) * (cols[j][t] - means[j]) for t in range(n)) / n
+             for j in range(k)] for i in range(k)]
+
+
+def _norm_weights(raw: List[float]) -> List[float]:
+    total = sum(raw)
+    if total <= 0 or not all(math.isfinite(v) for v in raw):
+        raise ToolError("权重归一化失败：总和必须为正有限值")
+    return [v / total for v in raw]
+
+
+def _pearson(a: List[float], b: List[float]) -> float:
+    ma, mb = sum(a) / len(a), sum(b) / len(b)
+    cov = sum((x - ma) * (y - mb) for x, y in zip(a, b))
+    va = sum((x - ma) ** 2 for x in a)
+    vb = sum((y - mb) ** 2 for y in b)
+    if va == 0 or vb == 0:
+        raise ToolError("存在常数序列（方差为0），相关系数无定义")
+    return cov / math.sqrt(va * vb)
+
+
+def _ranks(values: List[float]) -> List[float]:
+    """平均秩（并列取平均），供Spearman相关使用。"""
+    order = sorted(range(len(values)), key=lambda i: values[i])
+    ranks = [0.0] * len(values)
+    i = 0
+    while i < len(order):
+        j = i
+        while j + 1 < len(order) and values[order[j + 1]] == values[order[i]]:
+            j += 1
+        avg = (i + j) / 2 + 1
+        for t in range(i, j + 1):
+            ranks[order[t]] = avg
+        i = j + 1
+    return ranks
+
+
+@tool(
+    "portfolio_allocation",
+    "多策略组合权重求解：equal_weight / inverse_vol / inverse_variance / min_variance / "
+    "risk_parity（风险平价，迭代收敛）。输入每条策略的等长收益率序列。",
+    properties={
+        "returns_matrix": {"type": "array", "description": "等长收益率序列的数组，每条代表一个策略"},
+        "method": {"type": "string", "enum": ["equal_weight", "inverse_vol",
+                                              "inverse_variance", "min_variance", "risk_parity"],
+                   "description": "配置方法，默认risk_parity"},
+    },
+    required=["returns_matrix"],
+)
+def tool_portfolio_allocation(returns_matrix, method: str = "risk_parity") -> dict:
+    cols = _returns_columns(returns_matrix, "returns_matrix")
+    k = len(cols)
+    vols = [_std(c, ddof=1) for c in cols]
+    if any(v == 0 for v in vols):
+        raise ToolError("存在零波动率序列，无法配置权重")
+    cov = _cov_matrix(cols)
+    negative = False
+    if method == "equal_weight":
+        w = [1.0 / k] * k
+    elif method == "inverse_vol":
+        w = _norm_weights([1.0 / v for v in vols])
+    elif method == "inverse_variance":
+        w = _norm_weights([1.0 / (v * v) for v in vols])
+    elif method == "min_variance":
+        inv = _mat_inverse(cov)
+        w = _norm_weights([sum(row) for row in inv])
+        if any(x < 0 for x in w):
+            negative = True  # 允许负权（隐含做空），如实返回并提示
+    elif method == "risk_parity":
+        w = _norm_weights([1.0 / v for v in vols])
+        for _ in range(1000):
+            marg = [sum(cov[i][j] * w[j] for j in range(k)) for i in range(k)]
+            if any(m <= 0 for m in marg):
+                raise ToolError("风险平价迭代发散：协方差矩阵非正定")
+            w_new = _norm_weights([1.0 / m for m in marg])
+            if max(abs(a - b) for a, b in zip(w_new, w)) < 1e-12:
+                w = w_new
+                break
+            w = w_new
+    else:
+        raise ToolError("未知配置方法")
+    risk_contrib = [w[i] * sum(cov[i][j] * w[j] for j in range(k))
+                    for i in range(k)]
+    total_var = sum(risk_contrib)
+    return {"method": method, "k": k,
+            "weights": [_r(x, 4) for x in w],
+            "risk_contribution_pct": ([_r(x / total_var * 100, 2) for x in risk_contrib]
+                                      if total_var > 0 else None),
+            "has_negative_weight": negative,
+            "note": "min_variance含负权重（隐含做空），如需纯多头请手动裁剪" if negative else None}
+
+
+@tool(
+    "portfolio_metrics",
+    "组合绩效：按权重合成收益率序列（每期再平衡假设），输出夏普/索提诺/年化收益/最大回撤/分散化比率。",
+    properties={
+        "weights": {"type": "array", "description": "权重数组（与序列数一致，和≈1，自动归一）"},
+        "returns_matrix": {"type": "array", "description": "等长收益率序列的数组"},
+        "periods_per_year": {"type": "integer", "description": "每年期数，默认252"},
+    },
+    required=["weights", "returns_matrix"],
+)
+def tool_portfolio_metrics(weights, returns_matrix, periods_per_year: int = 252) -> dict:
+    cols = _returns_columns(returns_matrix, "returns_matrix")
+    k = len(cols)
+    weights = _series(weights, "weights", k, k)
+    if any(w < 0 for w in weights):
+        raise ToolError("weights 不能为负")
+    total_w = sum(weights)
+    if not 0.9 <= total_w <= 1.1:
+        raise ToolError("weights 总和应在0.9..1.1内")
+    weights = [w / total_w for w in weights]
+    ppy = _int(periods_per_year, "periods_per_year", 1, 10_000_000)
+    n = len(cols[0])
+    port = [sum(weights[i] * cols[i][t] for i in range(k)) for t in range(n)]
+    mean = sum(port) / n
+    sd = _std(port, ddof=1)
+    downside = math.sqrt(sum(min(r, 0.0) ** 2 for r in port) / n)
+    growth = 1.0
+    for r in port:
+        growth *= (1 + r)
+        if growth <= 0:
+            raise ToolError("组合收益导致净值归零或为负")
+        if not math.isfinite(growth):
+            raise ToolError("组合净值溢出，请检查输入收益量级")
+    try:
+        ann_ret = growth ** (ppy / n) - 1
+    except OverflowError:
+        raise ToolError("年化收益计算溢出") from None
+    if not math.isfinite(ann_ret):
+        raise ToolError("年化收益计算溢出")
+    peak, max_dd = 1.0, 0.0
+    v = 1.0
+    for r in port:
+        v *= (1 + r)
+        peak = max(peak, v)
+        max_dd = min(max_dd, v / peak - 1)
+    port_vol = math.sqrt(sum((r - mean) ** 2 for r in port) / (n - 1)) if n > 1 else 0.0
+    weighted_vol = sum(weights[i] * _std(cols[i], ddof=1) for i in range(k))
+    dr = weighted_vol / port_vol if port_vol > 0 else None
+    return {
+        "sharpe_annualized": _r(mean / sd * math.sqrt(ppy)) if sd > 0 else None,
+        "sortino_annualized": _r(mean / downside * math.sqrt(ppy)) if downside > 0 else None,
+        "annualized_return_pct": _r(ann_ret * 100),
+        "max_drawdown_pct": _r(max_dd * 100),
+        "vol_per_period": _r(sd),
+        "diversification_ratio": _r(dr) if dr is not None else None,
+        "note": "分散化比率>1表示组合波动低于成分加权平均波动" if dr is not None else None,
+    }
+
+
+@tool(
+    "strategy_correlation",
+    "策略/品种相关性矩阵：两两皮尔逊相关，输出矩阵、平均相关、最高相关对与阈值聚类分组。",
+    properties={
+        "return_series": {"type": "array", "description": "等长收益率序列的数组（2..25条）"},
+        "names": {"type": "array", "description": "可选名称数组（与序列数一致）"},
+        "cluster_threshold": {"type": "number", "description": "聚类阈值(|corr|≥阈值归组)，默认0.7"},
+    },
+    required=["return_series"],
+)
+def tool_strategy_correlation(return_series, names=None, cluster_threshold: float = 0.7) -> dict:
+    cols = _returns_columns(return_series, "return_series")
+    k = len(cols)
+    cluster_threshold = _number(cluster_threshold, "cluster_threshold", 0, 1)
+    if names is not None:
+        if not isinstance(names, list) or len(names) != k or \
+                any(not isinstance(nm, str) or not nm.strip() for nm in names):
+            raise ToolError("names 必须是与序列数一致的非空字符串数组")
+    labels = names or [f"S{i+1}" for i in range(k)]
+    matrix = [[_r(_pearson(cols[i], cols[j]), 4) for j in range(k)] for i in range(k)]
+    pairs = [(matrix[i][j], labels[i], labels[j])
+             for i in range(k) for j in range(i + 1, k)]
+    avg = sum(abs(p[0]) for p in pairs) / len(pairs) if pairs else 0.0
+    strongest = max(pairs, key=lambda p: abs(p[0])) if pairs else None
+    # 单链聚类：|corr| >= 阈值合并
+    parent = list(range(k))
+
+    def find(x):
+        while parent[x] != x:
+            parent[x] = parent[parent[x]]
+            x = parent[x]
+        return x
+
+    for i in range(k):
+        for j in range(i + 1, k):
+            if abs(matrix[i][j]) >= cluster_threshold:
+                ri, rj = find(i), find(j)
+                if ri != rj:
+                    parent[rj] = ri
+    groups = {}
+    for i in range(k):
+        groups.setdefault(labels[find(i)], []).append(labels[i])
+    return {"labels": labels, "matrix": matrix,
+            "avg_abs_correlation": _r(abs(avg)),
+            "strongest_pair": {"a": strongest[1], "b": strongest[2],
+                               "correlation": strongest[0]} if strongest else None,
+            "clusters": list(groups.values()),
+            "cluster_threshold": cluster_threshold}
+
+
+@tool(
+    "symbol_screener",
+    "多品种筛选打分：对每个候选品种计算动量/趋势/稳定性/低波动四个分项（跨品种min-max归一到0..1），"
+    "加权合成分并排名。输入候选品种与其收盘价序列。",
+    properties={
+        "candidates": {"type": "array", "description": "[{symbol, closes}] 数组（2..50个品种，每条至少30个收盘价）"},
+        "lookback": {"type": "integer", "description": "动量回看周期，默认20"},
+        "weights": {"type": "object",
+                    "description": "分项权重 {momentum,trend,consistency,low_vol}，默认0.4/0.3/0.2/0.1"},
+    },
+    required=["candidates"],
+)
+def tool_symbol_screener(candidates, lookback: int = 20,
+                         weights: dict = None) -> dict:
+    if not isinstance(candidates, list) or not 2 <= len(candidates) <= 50:
+        raise ToolError("candidates: 需要2..50个品种")
+    lookback = _period(lookback, "lookback")
+    w = weights or {}
+    if not isinstance(w, dict):
+        raise ToolError("weights 必须是对象")
+    w_mom = _number(w.get("momentum", 0.4), "weights.momentum", 0, 1)
+    w_trend = _number(w.get("trend", 0.3), "weights.trend", 0, 1)
+    w_cons = _number(w.get("consistency", 0.2), "weights.consistency", 0, 1)
+    w_lv = _number(w.get("low_vol", 0.1), "weights.low_vol", 0, 1)
+    w_sum = w_mom + w_trend + w_cons + w_lv
+    if w_sum <= 0:
+        raise ToolError("分项权重总和必须大于0")
+    rows = []
+    for i, cand in enumerate(candidates):
+        if not isinstance(cand, dict) or "symbol" not in cand or "closes" not in cand:
+            raise ToolError(f"candidates[{i}]: 需要 {{symbol, closes}}")
+        symbol = cand["symbol"]
+        if not isinstance(symbol, str) or not symbol.strip() or len(symbol) > 40:
+            raise ToolError(f"candidates[{i}].symbol 非法")
+        closes = _series(cand["closes"], f"candidates[{i}].closes", 30, MAX_CANDLES)
+        if any(c <= 0 for c in closes):
+            raise ToolError(f"candidates[{i}].closes 必须全部为正数")
+        if len(closes) <= lookback:
+            raise ToolError(f"candidates[{i}]: 收盘价需多于lookback({lookback})个")
+        mom = 100.0 * (closes[-1] / closes[-1 - lookback] - 1)
+        rets = [math.log(closes[j] / closes[j - 1]) for j in range(1, len(closes))]
+        vol = _std(rets, ddof=1) * math.sqrt(252)
+        n = len(closes)
+        my = sum(closes) / n
+        sxx = sum((j - (n - 1) / 2) ** 2 for j in range(n))
+        slope = sum((j - (n - 1) / 2) * (c - my) for j, c in enumerate(closes)) / sxx
+        ss_tot = sum((c - my) ** 2 for c in closes)
+        r2 = 1 - sum((c - (my + slope * (j - (n - 1) / 2))) ** 2
+                     for j, c in enumerate(closes)) / ss_tot if ss_tot > 0 else 0.0
+        rows.append({"symbol": symbol.strip(), "momentum_pct": _r(mom),
+                     "trend_pct": _r((closes[-1] / (my + slope * (n - 1)) - 1) * 100
+                                     if my + slope * (n - 1) > 0 else 0.0),
+                     "consistency_r2": _r(max(0.0, min(1.0, r2)), 4),
+                     "vol_annualized": _r(vol, 4)})
+
+    def minmax(key, invert=False):
+        vals = [r[key] for r in rows]
+        lo, hi = min(vals), max(vals)
+        span = hi - lo
+        for r in rows:
+            r["_s_" + key] = (0.5 if span == 0 else
+                              ((hi - r[key]) / span if invert else (r[key] - lo) / span))
+
+    minmax("momentum_pct")
+    minmax("trend_pct")
+    minmax("consistency_r2")
+    minmax("vol_annualized", invert=True)
+    for r in rows:
+        r["score"] = _r((w_mom * r["_s_momentum_pct"] + w_trend * r["_s_trend_pct"]
+                         + w_cons * r["_s_consistency_r2"] + w_lv * r["_s_vol_annualized"])
+                        / w_sum * 100, 2)
+        for key in ("_s_momentum_pct", "_s_trend_pct", "_s_consistency_r2", "_s_vol_annualized"):
+            del r[key]
+    rows.sort(key=lambda r: r["score"], reverse=True)
+    return {"count": len(rows), "ranking": rows,
+            "note": "score为跨候选品种相对分，不代表绝对收益预期"}
+
+
+@tool(
+    "optimizer_rank",
+    "参数/策略优选排名：对回测结果集按夏普-回撤惩罚-样本不足惩罚合成分排序，并标记可疑结果"
+    "（夏普异常高、样本过少、回撤过深）。防止只挑运气最好的参数。",
+    properties={
+        "results": {"type": "array",
+                    "description": "[{name, sharpe, max_dd_pct, trades}] 数组（2..100条）"},
+        "min_trades": {"type": "integer", "description": "最低交易笔数，默认30"},
+        "dd_penalty_divisor": {"type": "number", "description": "回撤惩罚除数（|dd|%/该值计入扣分），默认20"},
+    },
+    required=["results"],
+)
+def tool_optimizer_rank(results, min_trades: int = 30,
+                        dd_penalty_divisor: float = 20.0) -> dict:
+    if not isinstance(results, list) or not 2 <= len(results) <= 100:
+        raise ToolError("results: 需要2..100条")
+    min_trades = _int(min_trades, "min_trades", 1, 100000)
+    dd_div = _number(dd_penalty_divisor, "dd_penalty_divisor", 0.1, 1000)
+    rows = []
+    for i, r in enumerate(results):
+        if not isinstance(r, dict):
+            raise ToolError(f"results[{i}]: 必须是对象")
+        name = r.get("name", f"R{i+1}")
+        if not isinstance(name, str) or len(name) > 60:
+            raise ToolError(f"results[{i}].name 非法")
+        sharpe = _number(r.get("sharpe"), f"results[{i}].sharpe", -100, 100)
+        dd = _number(r.get("max_dd_pct"), f"results[{i}].max_dd_pct", -100, 0)
+        trades = r.get("trades")
+        if isinstance(trades, bool) or not isinstance(trades, int) or trades < 0:
+            raise ToolError(f"results[{i}].trades: 必须是非负整数")
+        score = sharpe - abs(dd) / dd_div
+        flags = []
+        if trades < min_trades:
+            score -= (min_trades - trades) / min_trades
+            flags.append("样本不足")
+        if sharpe > 5:
+            flags.append("夏普异常高，疑过拟合")
+        if dd < -50:
+            flags.append("回撤过深")
+        rows.append({"name": name, "sharpe": _r(sharpe), "max_dd_pct": _r(dd),
+                     "trades": trades, "score": _r(score), "flags": flags})
+    rows.sort(key=lambda r: r["score"], reverse=True)
+    clean = [r for r in rows if not r["flags"]]
+    return {"ranking": rows,
+            "best_clean": clean[0]["name"] if clean else None,
+            "flagged_count": len(rows) - len(clean),
+            "note": "score仅用于相对排序，不构成对未来表现的预测"}
+
+
+@tool(
+    "walk_forward_splits",
+    "前推优化(Walk-Forward)切分：生成滚动或锚定训练/测试窗口，杜绝全样本过拟合。切分确定性。",
+    properties={
+        "total": {"type": "integer", "description": "样本总长度"},
+        "train_size": {"type": "integer", "description": "训练窗口长度"},
+        "test_size": {"type": "integer", "description": "测试窗口长度"},
+        "mode": {"type": "string", "enum": ["rolling", "anchored"],
+                 "description": "rolling=滚动窗口，anchored=锚定（训练起点固定0），默认rolling"},
+        "step": {"type": "integer", "description": "窗口步进，默认=test_size"},
+    },
+    required=["total", "train_size", "test_size"],
+)
+def tool_walk_forward(total: int, train_size: int, test_size: int,
+                      mode: str = "rolling", step: int = None) -> dict:
+    total = _int(total, "total", 2, 1_000_000)
+    train = _int(train_size, "train_size", 1, total)
+    test = _int(test_size, "test_size", 1, total)
+    if mode not in ("rolling", "anchored"):
+        raise ToolError("mode 必须是 rolling 或 anchored")
+    if train < test:
+        raise ToolError("train_size 不应小于 test_size")
+    if total < train + test:
+        raise ToolError(f"total({total})不足以容纳 train+test({train + test})")
+    step = test if step is None else _int(step, "step", 1, total)
+    splits = []
+    start = 0
+    while start + train + test <= total:
+        tr_start = 0 if mode == "anchored" else start
+        splits.append({"train": [tr_start, start + train],
+                       "test": [start + train, start + train + test]})
+        start += step
+    if not splits:
+        raise ToolError("无法生成任何切分窗口")
+    return {"mode": mode, "total": total, "splits": splits,
+            "split_count": len(splits),
+            "coverage": _r((splits[-1]["test"][1]) / total * 100, 2)}
+
+
+@tool(
+    "variance_ratio",
+    "方差比检验(Lo-MacKinlay)：VR(q)=Var(q期收益)/(q·Var(1期收益))。VR>1趋势延续，<1均值回归；"
+    "z分数>1.96拒绝随机游走。",
+    properties={
+        "returns": {"type": "array", "description": "每期对数收益率序列（至少3q+1个）"},
+        "q": {"type": "integer", "description": "聚合期数，默认2..64"},
+    },
+    required=["returns"],
+)
+def tool_variance_ratio(returns, q: int = 2) -> dict:
+    rets = _series(returns, "returns", 4)
+    q = _int(q, "q", 2, 64)
+    n = len(rets)
+    if n < 3 * q + 1:
+        raise ToolError(f"方差比检验需要至少{3 * q + 1}个收益点")
+    mean = sum(rets) / n
+    var1 = sum((r - mean) ** 2 for r in rets) / (n - 1)
+    if var1 == 0:
+        raise ToolError("收益为常数，方差比无定义")
+    sums = [sum(rets[t:t + q]) for t in range(n - q + 1)]
+    ms = sum(sums) / len(sums)
+    varq = sum((s - ms) ** 2 for s in sums) / (len(sums) - 1)
+    vr = varq / (q * var1)
+    phi = 2.0 * (2 * q - 1) * (q - 1) / (3.0 * q * n)  # 同方差假设
+    z = (vr - 1) / math.sqrt(phi) if phi > 0 else 0.0
+    verdict = "拒绝随机游走" if abs(z) > 1.96 else "不能拒绝随机游走"
+    hint = "趋势/动量特征" if vr > 1 else "均值回归特征"
+    return {"q": q, "vr": _r(vr, 4), "z": _r(z, 4), "verdict": verdict, "hint": hint}
+
+
+@tool(
+    "half_life",
+    "均值回归半衰期：Δy 对 y(t-1) 做AR(1)回归（OU过程离散化）。半衰期越短回归越快，适合配对/网格策略评估。",
+    properties={
+        "values": {"type": "array", "description": "时间序列（价格或价差，至少20个点）"},
+    },
+    required=["values"],
+)
+def tool_half_life(values) -> dict:
+    values = _series(values, "values", 20)
+    slope, intercept, hl = _ar1_half_life(values)
+    return {"ar1_slope": _r(slope, 4), "intercept": _r(intercept, 4),
+            "half_life_periods": _r(hl, 2) if hl is not None else None,
+            "mean_reverting": hl is not None,
+            "note": None if hl is not None else "斜率≥0：该序列无均值回归特征"}
+
+
+@tool(
+    "pair_trade_scan",
+    "配对交易扫描：两价格序列做对数OLS得对冲比率，输出价差的半衰期/Hurst/相关性与配对可行性提示。",
+    properties={
+        "price_a": {"type": "array", "description": "A品种价格序列（正数，至少64个点）"},
+        "price_b": {"type": "array", "description": "B品种价格序列（等长）"},
+    },
+    required=["price_a", "price_b"],
+)
+def tool_pair_trade(price_a, price_b) -> dict:
+    a = _series(price_a, "price_a", 64, MAX_CANDLES)
+    b = _series(price_b, "price_b", 64, MAX_CANDLES)
+    if len(a) != len(b):
+        raise ToolError("两序列长度必须一致")
+    if any(x <= 0 for x in a) or any(x <= 0 for x in b):
+        raise ToolError("价格必须全部为正数")
+    la = [math.log(x) for x in a]
+    lb = [math.log(x) for x in b]
+    mlb = sum(lb) / len(lb)
+    sxx = sum((x - mlb) ** 2 for x in lb)
+    if sxx <= 0:
+        raise ToolError("price_b 无波动，无法估计对冲比率")
+    mla = sum(la) / len(la)
+    hedge = sum((x - mla) * (y - mlb) for x, y in zip(la, lb)) / sxx
+    spread = [x - hedge * y for x, y in zip(la, lb)]
+    sd = _std(spread, ddof=1)
+    corr = _pearson(la, lb)
+    result = {"hedge_ratio": _r(hedge, 4), "correlation": _r(corr, 4),
+              "spread_std": _r(sd, 4)}
+    if sd < 1e-12:
+        result.update({"half_life_periods": None, "hurst": None,
+                       "candidate": None, "note": "价差为常数，无交易空间"})
+        return result
+    try:
+        _, _, hl = _ar1_half_life(spread)
+    except ToolError:
+        hl = None
+    try:
+        h = _hurst_estimate(spread)
+    except ToolError:
+        h = None
+    candidate = (corr > 0.8 and hl is not None and 0 < hl <= 60)
+    result.update({"half_life_periods": _r(hl, 2) if hl is not None else None,
+                   "hurst": _r(h, 4) if h is not None else None,
+                   "candidate": candidate,
+                   "note": ("相关高且回归较快，可进入纸面验证" if candidate
+                            else "未通过初筛：需要corr>0.8且半衰期在0..60期内")})
+    return result
+
+
+@tool(
+    "sharpe_psr",
+    "概率夏普比率(PSR)与紧缩夏普比率(DSR)：衡量夏普显著性与多重试验后的幸存者偏差。"
+    "PSR=夏普超过基准的概率；DSR在trials次试验后仍显著才可信。",
+    properties={
+        "returns": {"type": "array", "description": "每期收益率序列（至少20个）"},
+        "periods_per_year": {"type": "integer", "description": "每年期数，默认252"},
+        "benchmark_sr": {"type": "number", "description": "基准夏普（同期口径），默认0"},
+        "trials": {"type": "integer", "description": "尝试过的策略/参数总数，=1时不出DSR，默认1"},
+    },
+    required=["returns"],
+)
+def tool_sharpe_psr(returns, periods_per_year: int = 252,
+                    benchmark_sr: float = 0.0, trials: int = 1) -> dict:
+    rets = _series(returns, "returns", 20, MAX_PORTFOLIO_LEN)
+    ppy = _int(periods_per_year, "periods_per_year", 1, 10_000_000)
+    benchmark_sr = _number(benchmark_sr, "benchmark_sr", -10, 10)
+    trials = _int(trials, "trials", 1, 100000)
+    n = len(rets)
+    mean = sum(rets) / n
+    sd = _std(rets, ddof=1)
+    if sd == 0:
+        raise ToolError("收益为常数，夏普比率无定义")
+    sr = mean / sd
+    m2 = sum((r - mean) ** 2 for r in rets) / n
+    m3 = sum((r - mean) ** 3 for r in rets) / n
+    m4 = sum((r - mean) ** 4 for r in rets) / n
+    skew = m3 / m2 ** 1.5 if m2 > 0 else 0.0
+    kurt = m4 / m2 ** 2 if m2 > 0 else 3.0
+    denom2 = 1.0 - skew * sr + (kurt - 1) / 4.0 * sr * sr
+    if denom2 <= 0:
+        raise ToolError("夏普方差项非正，无法计算PSR（样本过短或分布极端）")
+    v_sr = denom2 / (n - 1)
+
+    def psr_at(sr_b):
+        return _norm_cdf((sr - sr_b) * math.sqrt(n - 1) / math.sqrt(denom2))
+
+    out = {"sharpe_per_period": _r(sr, 4),
+           "sharpe_annualized": _r(sr * math.sqrt(ppy), 4),
+           "skew": _r(skew, 4), "kurtosis": _r(kurt, 4),
+           "psr_vs_benchmark": _r(psr_at(benchmark_sr), 4),
+           "n": n}
+    if trials > 1:
+        sr0 = math.sqrt(v_sr) * _norm_ppf(1.0 - 1.0 / trials)
+        out["dsr_threshold_sr"] = _r(sr0, 4)
+        out["dsr"] = _r(psr_at(sr0), 4)
+        out["note"] = f"trials={trials}：夏普需超过{out['dsr_threshold_sr']}（同期口径）DSR才>0.5"
+    else:
+        out["note"] = "设置trials为实际尝试的策略/参数总数可获得DSR"
+    return out
+
+
+@tool(
+    "bootstrap_ci",
+    "自助法(Bootstrap)置信区间：有放回重采样收益序列，给出均值/夏普等指标的置信区间。"
+    "确定性种子，同输入同结果。",
+    properties={
+        "returns": {"type": "array", "description": "每期收益率序列（至少20个）"},
+        "metric": {"type": "string", "enum": ["mean", "sharpe", "median"],
+                   "description": "重采样统计量，默认sharpe"},
+        "iterations": {"type": "integer", "description": "重采样次数(100..10000)，默认2000"},
+        "confidence": {"type": "number", "description": "置信度，默认0.95"},
+        "seed": {"type": "integer", "description": "随机种子，默认42"},
+    },
+    required=["returns"],
+)
+def tool_bootstrap_ci(returns, metric: str = "sharpe", iterations: int = 2000,
+                      confidence: float = 0.95, seed: int = 42) -> dict:
+    rets = _series(returns, "returns", 20, MAX_PORTFOLIO_LEN)
+    if metric not in ("mean", "sharpe", "median"):
+        raise ToolError("metric 必须是 mean/sharpe/median")
+    iterations = _int(iterations, "iterations", 100, 10000)
+    confidence = _number(confidence, "confidence", 0.5, 0.9999)
+    rng = random.Random(_int(seed, "seed", 0, 2**31 - 1))
+    n = len(rets)
+
+    def stat(sample):
+        if metric == "mean":
+            return sum(sample) / n
+        if metric == "median":
+            s = sorted(sample)
+            mid = n // 2
+            return s[mid] if n % 2 else (s[mid - 1] + s[mid]) / 2
+        m = sum(sample) / n
+        sd = _std(sample, ddof=1)
+        return m / sd if sd > 0 else 0.0
+
+    point = stat(rets)
+    samples = []
+    for _ in range(iterations):
+        samples.append(stat([rets[rng.randrange(n)] for _ in range(n)]))
+    samples.sort()
+    alpha = (1 - confidence) / 2
+    lo = _percentile(samples, alpha * 100)
+    hi = _percentile(samples, (1 - alpha) * 100)
+    return {"metric": metric, "point_estimate": _r(point, 4),
+            "ci_low": _r(lo, 4), "ci_high": _r(hi, 4),
+            "confidence": confidence, "iterations": iterations,
+            "significant_away_from_zero": not (lo <= 0 <= hi)}
+
+
+@tool(
+    "exposure_check",
+    "组合敞口风控检查：单品种/组别/净/总敞口占净值百分比与限额比对，逐条输出违规警示。只做算术，不下单。",
+    properties={
+        "equity": {"type": "number", "description": "账户净值（>0，账户货币）"},
+        "positions": {"type": "array",
+                      "description": "[{symbol, value, group?}] value为带符号市值（多头正/空头负）"},
+        "max_single_pct": {"type": "number", "description": "单品种限额%，默认20"},
+        "max_group_pct": {"type": "number", "description": "单组别限额%（按绝对值合计），默认40"},
+        "max_net_pct": {"type": "number", "description": "净敞口限额%，默认100"},
+        "max_gross_pct": {"type": "number", "description": "总敞口限额%，默认200"},
+    },
+    required=["equity", "positions"],
+)
+def tool_exposure_check(equity, positions, max_single_pct: float = 20.0,
+                        max_group_pct: float = 40.0, max_net_pct: float = 100.0,
+                        max_gross_pct: float = 200.0) -> dict:
+    equity = _number(equity, "equity", 1e-9, 1e15)
+    if not isinstance(positions, list) or not 1 <= len(positions) <= 200:
+        raise ToolError("positions: 需要1..200个持仓")
+    max_single_pct = _number(max_single_pct, "max_single_pct", 0.01, 1000)
+    max_group_pct = _number(max_group_pct, "max_group_pct", 0.01, 1000)
+    max_net_pct = _number(max_net_pct, "max_net_pct", 0.01, 1000)
+    max_gross_pct = _number(max_gross_pct, "max_gross_pct", 0.01, 1000)
+    groups, warnings, details = {}, [], []
+    net = 0.0
+    gross = 0.0
+    for i, p in enumerate(positions):
+        if not isinstance(p, dict) or "symbol" not in p or "value" not in p:
+            raise ToolError(f"positions[{i}]: 需要 {{symbol, value}}")
+        symbol = p["symbol"]
+        if not isinstance(symbol, str) or not symbol.strip() or len(symbol) > 40:
+            raise ToolError(f"positions[{i}].symbol 非法")
+        value = _number(p["value"], f"positions[{i}].value", -1e15, 1e15)
+        group = p.get("group", "ungrouped")
+        if not isinstance(group, str) or len(group) > 40:
+            raise ToolError(f"positions[{i}].group 非法")
+        symbol = symbol.strip()
+        weight = value / equity * 100
+        net += value
+        gross += abs(value)
+        groups.setdefault(group, 0.0)
+        groups[group] += abs(value)
+        if abs(weight) > max_single_pct:
+            warnings.append(f"{symbol}: 单品种敞口{weight:.1f}%超限额{max_single_pct}%")
+        details.append({"symbol": symbol, "value": _r(value), "weight_pct": _r(weight)})
+    for gname, gval in sorted(groups.items()):
+        gweight = gval / equity * 100
+        if gweight > max_group_pct:
+            warnings.append(f"组[{gname}]: 合计敞口{gweight:.1f}%超限额{max_group_pct}%")
+    net_pct, gross_pct = net / equity * 100, gross / equity * 100
+    if abs(net_pct) > max_net_pct:
+        warnings.append(f"净敞口{net_pct:.1f}%超限额{max_net_pct}%")
+    if gross_pct > max_gross_pct:
+        warnings.append(f"总敞口{gross_pct:.1f}%超限额{max_gross_pct}%")
+    return {"positions": details, "groups": {g: _r(v / equity * 100, 2)
+                                             for g, v in sorted(groups.items())},
+            "net_exposure_pct": _r(net_pct), "gross_exposure_pct": _r(gross_pct),
+            "ok": not warnings, "warnings": warnings}
+
+
+@tool(
+    "risk_ladder",
+    "回撤响应阶梯：给定当前回撤，输出应处风控档位与动作（降仓→停止开新仓→清仓复盘）。"
+    "确定性映射，默认5%/10%/15%三档，可自定义。",
+    properties={
+        "current_dd_pct": {"type": "number", "description": "当前回撤百分比（0..100，正数）"},
+        "levels": {"type": "array",
+                   "description": "[{dd_pct, action}] 升序档位，默认5/10/15三档"},
+    },
+    required=["current_dd_pct"],
+)
+def tool_risk_ladder(current_dd_pct, levels=None) -> dict:
+    current_dd_pct = _number(current_dd_pct, "current_dd_pct", 0, 100)
+    if levels is None:
+        levels = [{"dd_pct": 5, "action": "reduce_risk_50pct"},
+                  {"dd_pct": 10, "action": "stop_new_entries"},
+                  {"dd_pct": 15, "action": "close_all_and_review"}]
+    if not isinstance(levels, list) or not 1 <= len(levels) <= 10:
+        raise ToolError("levels: 需要1..10个档位")
+    parsed = []
+    for i, lv in enumerate(levels):
+        if not isinstance(lv, dict) or "dd_pct" not in lv or "action" not in lv:
+            raise ToolError(f"levels[{i}]: 需要 {{dd_pct, action}}")
+        dd = _number(lv["dd_pct"], f"levels[{i}].dd_pct", 0.01, 100)
+        action = lv["action"]
+        if not isinstance(action, str) or not action.strip() or len(action) > 60:
+            raise ToolError(f"levels[{i}].action 非法")
+        parsed.append((dd, action.strip()))
+    parsed.sort(key=lambda x: x[0])
+    tier, action = None, "normal_operation"
+    for idx, (dd, act) in enumerate(parsed):
+        if current_dd_pct >= dd:
+            tier, action = idx, act
+    nxt = parsed[tier + 1][0] if tier is not None and tier + 1 < len(parsed) else \
+        (parsed[0][0] if tier is None else None)
+    return {"current_dd_pct": _r(current_dd_pct),
+            "tier": tier, "action": action,
+            "next_threshold_pct": _r(nxt) if nxt is not None else None,
+            "buffer_pct": _r(nxt - current_dd_pct) if nxt is not None else None,
+            "levels": [{"dd_pct": _r(d), "action": a} for d, a in parsed]}
+
+
+# ---------- 第四批：回测报告 / 策略挖掘 ----------
+
+def _ann_return(growth: float, periods: int, ppy: int) -> float:
+    if growth <= 0:
+        raise ToolError("净值终值为非正数，无法年化")
+    try:
+        value = growth ** (ppy / periods) - 1
+    except OverflowError:
+        raise ToolError("年化收益计算溢出") from None
+    if not math.isfinite(value):
+        raise ToolError("年化收益计算溢出")
+    return value
+
+
+@tool(
+    "backtest_report",
+    "一站式回测报告：输入净值曲线或收益序列（可选交易盈亏列表），输出收益/风险/交易三段完整指标，"
+    "含CAGR、夏普、索提诺、卡玛、溃疡指数、水下时间占比。",
+    properties={
+        "equity": {"type": "array", "description": "净值曲线（与returns二选一）"},
+        "returns": {"type": "array", "description": "收益率序列（与equity二选一）"},
+        "trades": {"type": "array", "description": "可选：每笔盈亏列表（至少5笔）"},
+        "periods_per_year": {"type": "integer", "description": "每年期数，默认252"},
+    },
+)
+def tool_backtest_report(equity=None, returns=None, trades=None,
+                         periods_per_year: int = 252) -> dict:
+    curve = _equity_curve(equity, returns)
+    ppy = _int(periods_per_year, "periods_per_year", 1, 10_000_000)
+    n = len(curve)
+    rets = [curve[i] / curve[i - 1] - 1 for i in range(1, n)]
+    mean = sum(rets) / len(rets)
+    sd = _std(rets, ddof=1)
+    downside = math.sqrt(sum(min(r, 0.0) ** 2 for r in rets) / len(rets))
+    total = curve[-1] / curve[0] - 1
+    cagr = _ann_return(curve[-1] / curve[0], n - 1, ppy)
+    peak, max_dd, under_water = curve[0], 0.0, 0
+    squares = []
+    for v in curve:
+        if v < peak:
+            under_water += 1
+        peak = max(peak, v)
+        dd = (v / peak - 1) * 100
+        max_dd = min(max_dd, dd)
+        squares.append(dd * dd)
+    ulcer = math.sqrt(sum(squares) / n)
+    report = {
+        "periods": n, "periods_per_year": ppy,
+        "returns": {
+            "total_return_pct": _r(total * 100),
+            "cagr_pct": _r(cagr * 100),
+            "best_period_pct": _r(max(rets) * 100),
+            "worst_period_pct": _r(min(rets) * 100),
+            "sharpe": _r(mean / sd * math.sqrt(ppy)) if sd > 0 else None,
+            "sortino": _r(mean / downside * math.sqrt(ppy)) if downside > 0 else None,
+        },
+        "risk": {
+            "vol_annualized_pct": _r(sd * math.sqrt(ppy) * 100),
+            "max_drawdown_pct": _r(max_dd),
+            "calmar": _r(cagr / abs(max_dd)) if max_dd < 0 else None,
+            "ulcer_index": _r(ulcer),
+            "time_underwater_pct": _r(under_water / n * 100),
+        },
+    }
+    if trades is not None:
+        report["trades"] = _trade_stats_core(_series(trades, "trades", 5))
+        report["note"] = "交易统计与净值曲线的口径需一致（同一回测输出）"
+    return report
+
+
+@tool(
+    "drawdown_episodes",
+    "回撤事件表：从净值曲线提取各回撤区间（峰值→谷底→修复），按深度排序输出Top N，"
+    "并给出水下时间占比。用于回答'历史上最难熬的回撤长什么样'。",
+    properties={
+        "equity": {"type": "array", "description": "净值曲线（与returns二选一）"},
+        "returns": {"type": "array", "description": "收益率序列（与equity二选一）"},
+        "top_n": {"type": "integer", "description": "返回最深的N个回撤事件，默认5"},
+    },
+)
+def tool_drawdown_episodes(equity=None, returns=None, top_n: int = 5) -> dict:
+    curve = _equity_curve(equity, returns)
+    top_n = _int(top_n, "top_n", 1, 50)
+    episodes = []
+    peak, peak_idx = curve[0], 0
+    trough, trough_idx = None, None
+    under_water = 0
+    for i, v in enumerate(curve):
+        if v >= peak and trough is None:
+            peak, peak_idx = v, i
+        elif v < peak:
+            under_water += 1
+            if trough is None:
+                trough, trough_idx = v, i
+            elif v < trough:
+                trough, trough_idx = v, i
+        elif v >= peak and trough is not None:
+            episodes.append({"peak_index": peak_idx, "trough_index": trough_idx,
+                             "recovery_index": i,
+                             "depth_pct": _r((trough / peak - 1) * 100),
+                             "duration_bars": i - peak_idx,
+                             "ongoing": False})
+            peak, peak_idx = v, i
+            trough, trough_idx = None, None
+    if trough is not None:
+        episodes.append({"peak_index": peak_idx, "trough_index": trough_idx,
+                         "recovery_index": None,
+                         "depth_pct": _r((trough / peak - 1) * 100),
+                         "duration_bars": len(curve) - 1 - peak_idx,
+                         "ongoing": True})
+    episodes.sort(key=lambda e: e["depth_pct"])
+    return {"episodes": episodes[:top_n], "total_episodes": len(episodes),
+            "ongoing": any(e["ongoing"] for e in episodes),
+            "time_underwater_pct": _r(under_water / len(curve) * 100),
+            "note": "duration_bars自峰值起算，未修复事件ongoing=true"}
+
+
+@tool(
+    "segment_returns",
+    "分段收益稳定性：把回测期等分为N段，逐段给出收益与最大回撤。回答'收益是均匀的还是靠某一段'。",
+    properties={
+        "equity": {"type": "array", "description": "净值曲线（与returns二选一）"},
+        "returns": {"type": "array", "description": "收益率序列（与equity二选一）"},
+        "segments": {"type": "integer", "description": "分段数(2..50)，默认5"},
+    },
+)
+def tool_segment_returns(equity=None, returns=None, segments: int = 5) -> dict:
+    curve = _equity_curve(equity, returns)
+    segments = _int(segments, "segments", 2, 50)
+    block, remainder = divmod(len(curve), segments)
+    if block < 2:
+        raise ToolError(f"每段至少需要2个点：序列长度{len(curve)}不足{segments}段")
+    rows = []
+    start = 0
+    for s in range(segments):
+        end = start + block + (1 if s < remainder else 0)
+        seg = curve[start:end]
+        seg_peak, seg_dd = seg[0], 0.0
+        for v in seg:
+            seg_peak = max(seg_peak, v)
+            seg_dd = min(seg_dd, v / seg_peak - 1)
+        rows.append({"segment": s + 1, "range": [start, end - 1],
+                     "return_pct": _r((seg[-1] / seg[0] - 1) * 100),
+                     "max_drawdown_pct": _r(seg_dd * 100)})
+        start = end
+    positive = sum(1 for r in rows if r["return_pct"] > 0)
+    best = max(rows, key=lambda r: r["return_pct"])
+    worst = min(rows, key=lambda r: r["return_pct"])
+    concentrated = _segment_concentration(rows)
+    return {"segments": rows, "positive_blocks": positive,
+            "consistency_pct": _r(positive / segments * 100),
+            "best_segment": best["segment"], "worst_segment": worst["segment"],
+            "best_share_note": ("收益高度集中：最好一段超过其余各段绝对收益之和，警惕样本外衰减"
+                                if concentrated else None)}
+
+
+def _segment_concentration(rows) -> bool:
+    """最好一段的收益绝对值是否超过其余各段绝对值之和。"""
+    rows_sorted = sorted(rows, key=lambda r: abs(r["return_pct"]), reverse=True)
+    if len(rows_sorted) < 2:
+        return False
+    top = abs(rows_sorted[0]["return_pct"])
+    rest = sum(abs(r["return_pct"]) for r in rows_sorted[1:])
+    return top > 0 and top > rest
+
+
+@tool(
+    "trade_deep_dive",
+    "交易明细深挖：多空方向拆分、盈亏分布尾部、持仓时长对比、极值交易。"
+    "输入[{pnl, direction?, hold_bars?}]，direction为long/short，hold_bars为持仓K线数。",
+    properties={
+        "trades": {"type": "array",
+                   "description": "[{pnl必填, direction?: long|short, hold_bars?: >=0整数}]（至少5笔）"},
+    },
+    required=["trades"],
+)
+def tool_trade_deep_dive(trades) -> dict:
+    if not isinstance(trades, list) or not 5 <= len(trades) <= 100000:
+        raise ToolError("trades: 需要5..100000笔")
+    pnls, directions, holds = [], {}, []
+    for i, t in enumerate(trades):
+        if not isinstance(t, dict) or "pnl" not in t:
+            raise ToolError(f"trades[{i}]: 必须包含 pnl")
+        pnls.append(_number(t["pnl"], f"trades[{i}].pnl", -1e15, 1e15))
+        if "direction" in t:
+            d = t["direction"]
+            if d not in ("long", "short"):
+                raise ToolError(f"trades[{i}].direction 必须是 long 或 short")
+            directions.setdefault(d, []).append(t["pnl"])
+        if "hold_bars" in t:
+            holds.append(_int(t["hold_bars"], f"trades[{i}].hold_bars", 0, 10**9))
+    result = {"overall": _trade_stats_core(pnls)}
+    if directions:
+        split = {}
+        for d in ("long", "short"):
+            sub = directions.get(d)
+            if not sub:
+                split[d] = None
+                continue
+            wins = sum(1 for p in sub if p > 0)
+            split[d] = {"count": len(sub),
+                        "win_rate_pct": _r(wins / len(sub) * 100),
+                        "total_pnl": _r(sum(sub)),
+                        "expectancy": _r(sum(sub) / len(sub))}
+        result["by_direction"] = split
+    sorted_p = sorted(pnls)
+    p5, p95 = _percentile(sorted_p, 5), _percentile(sorted_p, 95)
+    if p5 < 0 < p95:
+        result["tail_ratio"] = _r(p95 / abs(p5), 4)  # 盈利尾/亏损尾相对厚度
+    result["largest_win"] = _r(max(pnls))
+    result["largest_loss"] = _r(min(pnls))
+    if holds:
+        win_holds = [h for h, p in zip(holds, pnls) if p > 0]
+        loss_holds = [h for h, p in zip(holds, pnls) if p < 0]
+        result["holding"] = {
+            "avg_win_hold_bars": _r(sum(win_holds) / len(win_holds), 1) if win_holds else None,
+            "avg_loss_hold_bars": _r(sum(loss_holds) / len(loss_holds), 1) if loss_holds else None,
+            "note": ("止损比止盈更慢（亏损单持仓更久），需检查止损纪律"
+                     if loss_holds and win_holds and
+                     sum(loss_holds) / len(loss_holds) > sum(win_holds) / len(win_holds)
+                     else None)}
+    return result
+
+
+@tool(
+    "signal_quality",
+    "信号质量评估：信号(+1/0/-1)与随后实际收益对齐后，分信号统计命中率/平均收益/t统计量。"
+    "调用方必须保证forward_returns无前视偏差。",
+    properties={
+        "signals": {"type": "array", "description": "信号序列，每项为-1/0/1"},
+        "forward_returns": {"type": "array", "description": "信号发出后实现的收益（等长）"},
+    },
+    required=["signals", "forward_returns"],
+)
+def tool_signal_quality(signals, forward_returns) -> dict:
+    if not isinstance(signals, list) or len(signals) < 10:
+        raise ToolError("signals: 至少10个信号")
+    rets = _series(forward_returns, "forward_returns", len(signals), len(signals))
+    for i, s in enumerate(signals):
+        if s not in (-1, 0, 1) or isinstance(s, bool):
+            raise ToolError(f"signals[{i}]: 必须是-1/0/1")
+    groups = {s: [] for s in (-1, 0, 1)}
+    for s, r in zip(signals, rets):
+        groups[s].append(r)
+    rows = {}
+    for s in (1, -1, 0):
+        sub = groups[s]
+        if not sub:
+            rows[str(s)] = {"count": 0}
+            continue
+        n = len(sub)
+        m = sum(sub) / n
+        sd = _std(sub, ddof=1) if n > 1 else 0.0
+        if s != 0:
+            hits = sum(1 for r in sub if (r > 0) == (s > 0) and r != 0)
+            hit_rate = hits / n * 100
+        else:
+            hit_rate = None
+        rows[str(s)] = {"count": n, "avg_return_pct": _r(m * 100),
+                        "hit_rate_pct": _r(hit_rate) if hit_rate is not None else None,
+                        "total_return_pct": _r(sum(sub) * 100),
+                        "t_stat": _r(m / (sd / math.sqrt(n)), 3) if sd > 0 else None}
+    spread = None
+    if groups[1] and groups[-1]:
+        spread = sum(groups[1]) / len(groups[1]) - sum(groups[-1]) / len(groups[-1])
+    return {"signals": rows,
+            "long_short_spread_pct": _r(spread * 100) if spread is not None else None,
+            "note": "t_stat≈2以上才谈得上统计显著；调用方保证forward_returns无前视"}
+
+
+@tool(
+    "factor_ic",
+    "因子信息系数：因子值与前瞻收益的Spearman秩相关(IC)，并按窗口分块计算ICIR与IC为正占比。"
+    "因子挖掘的基础评估。",
+    properties={
+        "factor_values": {"type": "array", "description": "因子值序列（与前瞻收益等长）"},
+        "forward_returns": {"type": "array", "description": "前瞻收益序列"},
+        "window": {"type": "integer", "description": "分块窗口（计算ICIR），默认20"},
+    },
+    required=["factor_values", "forward_returns"],
+)
+def tool_factor_ic(factor_values, forward_returns, window: int = 20) -> dict:
+    fac = _series(factor_values, "factor_values", 30)
+    rets = _series(forward_returns, "forward_returns", len(fac), len(fac))
+    window = _int(window, "window", 2, len(fac))
+    ic = _pearson(_ranks(fac), _ranks(rets))
+    blocks = []
+    for start in range(0, len(fac) - window + 1, window):
+        sf, sr = fac[start:start + window], rets[start:start + window]
+        try:
+            blocks.append(_pearson(_ranks(sf), _ranks(sr)))
+        except ToolError:
+            pass  # 常数块跳过
+    icir = None
+    positive_share = None
+    if len(blocks) >= 2:
+        m = sum(blocks) / len(blocks)
+        sd = _std(blocks, ddof=1)
+        icir = _r(m / sd, 4) if sd > 0 else None
+        positive_share = _r(sum(1 for b in blocks if b > 0) / len(blocks) * 100, 1)
+    return {"ic": _r(ic, 4), "ic_blocks": len(blocks),
+            "icir": icir, "positive_ic_pct": positive_share,
+            "note": ("|IC|>0.03且ICIR>0.5才值得跟进" if icir is not None
+                     else "数据不足两个有效块，ICIR不可得")}
+
+
+@tool(
+    "param_robustness",
+    "参数高原稳健性：对一维参数扫描结果，检查最优参数邻域的表现是否同样好。"
+    "'刀锋参数'（只有窄邻域有效）样本外大概率失效。",
+    properties={
+        "param_values": {"type": "array", "description": "参数值序列（数值，3..1000个）"},
+        "scores": {"type": "array", "description": "对应绩效分数（如夏普），等长"},
+        "plateau_pct": {"type": "number", "description": "邻域带宽占参数区间的比例，默认0.1"},
+    },
+    required=["param_values", "scores"],
+)
+def tool_param_robustness(param_values, scores, plateau_pct: float = 0.1) -> dict:
+    params = _series(param_values, "param_values", 3, 1000)
+    sc = _series(scores, "scores", len(params), len(params))
+    plateau_pct = _number(plateau_pct, "plateau_pct", 0.01, 0.5)
+    pairs = sorted(zip(params, sc))
+    best_idx = max(range(len(pairs)), key=lambda i: pairs[i][1])
+    best_param, best_score = pairs[best_idx]
+    lo_param, hi_param = pairs[0][0], pairs[-1][0]
+    rng = hi_param - lo_param
+    if rng <= 0:
+        raise ToolError("参数值全部相同，无法评估稳健性")
+    band = [s for p, s in pairs if abs(p - best_param) <= plateau_pct * rng]
+    plateau_mean = sum(band) / len(band)
+    ratio = plateau_mean / best_score if best_score > 0 else None
+    if best_score <= 0:
+        verdict = "最优分数非正：该参数域整体不可用"
+    elif len(band) < 3 or plateau_mean < 0.5 * best_score:
+        verdict = "knife_edge刀锋参数：邻域表现远差于最优点，慎用"
+    elif plateau_mean >= 0.8 * best_score:
+        verdict = "robust参数高原：邻域表现接近最优，可信度较高"
+    else:
+        verdict = "moderate：邻域有一定衰减"
+    spearman = _pearson(_ranks(params), _ranks(sc)) if len(pairs) >= 3 else None
+    return {"best_param": _r(best_param), "best_score": _r(best_score),
+            "band_points": len(band), "plateau_mean": _r(plateau_mean),
+            "plateau_ratio": _r(ratio) if ratio is not None else None,
+            "monotonic_spearman": _r(spearman, 4) if spearman is not None else None,
+            "verdict": verdict}
+
+
+@tool(
+    "regime_split",
+    "分市场状态绩效：把收益序列按状态标签（趋势/震荡/高波动等）拆分，逐状态统计胜率、夏普与年化。"
+    "回答'策略赚的是什么状态的钱'。",
+    properties={
+        "returns": {"type": "array", "description": "收益序列（至少10个）"},
+        "regimes": {"type": "array", "description": "状态标签序列（等长，最多12种，字符串或数字）"},
+        "periods_per_year": {"type": "integer", "description": "每年期数，默认252"},
+    },
+    required=["returns", "regimes"],
+)
+def tool_regime_split(returns, regimes, periods_per_year: int = 252) -> dict:
+    rets = _series(returns, "returns", 10)
+    if not isinstance(regimes, list) or len(regimes) != len(rets):
+        raise ToolError("regimes: 必须与returns等长")
+    ppy = _int(periods_per_year, "periods_per_year", 1, 10_000_000)
+    labels = []
+    for i, r in enumerate(regimes):
+        if isinstance(r, bool) or not isinstance(r, (str, int, float)):
+            raise ToolError(f"regimes[{i}]: 必须是字符串或数字")
+        label = str(r).strip() if isinstance(r, str) else str(r)
+        if not label or len(label) > 30:
+            raise ToolError(f"regimes[{i}]: 标签长度非法")
+        labels.append(label)
+    distinct = set(labels)
+    if len(distinct) > 12:
+        raise ToolError("状态种类超过12种，请先合并状态")
+    rows = []
+    for label in sorted(distinct):
+        sub = [r for r, l in zip(rets, labels) if l == label]
+        n = len(sub)
+        m = sum(sub) / n
+        sd = _std(sub, ddof=1) if n > 1 else 0.0
+        rows.append({"regime": label, "n": n, "share_pct": _r(n / len(rets) * 100),
+                     "mean_per_period_pct": _r(m * 100),
+                     "annualized_pct": _r(m * ppy * 100),
+                     "vol_annualized_pct": _r(sd * math.sqrt(ppy) * 100),
+                     "sharpe": _r(m / sd * math.sqrt(ppy), 3) if sd > 0 else None,
+                     "hit_rate_pct": _r(sum(1 for r in sub if r > 0) / n * 100)})
+    rows.sort(key=lambda r: (r["sharpe"] is None, -(r["sharpe"] or 0)))
+    return {"regimes": rows,
+            "note": "算术年化（各期收益均值×期数），非复利；样本少的状态统计意义弱"}
+
+
+@tool(
+    "greedy_portfolio_search",
+    "贪心策略组合搜索：从候选策略池中逐步挑选使等权组合夏普提升最大的策略，直到无提升或达到上限。"
+    "挖掘互补策略组合的快速启发式。",
+    properties={
+        "return_series": {"type": "array", "description": "等长收益率序列数组（2..15条，每条至少20点）"},
+        "names": {"type": "array", "description": "可选策略名（与序列数一致）"},
+        "max_k": {"type": "integer", "description": "最多选择的策略数，默认不设限"},
+        "periods_per_year": {"type": "integer", "description": "每年期数，默认252"},
+    },
+    required=["return_series"],
+)
+def tool_greedy_search(return_series, names=None, max_k: int = None,
+                       periods_per_year: int = 252) -> dict:
+    cols = _returns_columns(return_series, "return_series")
+    k = len(cols)
+    if names is not None:
+        if not isinstance(names, list) or len(names) != k or \
+                any(not isinstance(nm, str) or not nm.strip() for nm in names):
+            raise ToolError("names 必须是与序列数一致的非空字符串数组")
+    labels = names or [f"S{i+1}" for i in range(k)]
+    ppy = _int(periods_per_year, "periods_per_year", 1, 10_000_000)
+    max_k = k if max_k is None else _int(max_k, "max_k", 1, k)
+    n = len(cols[0])
+
+    def combo_sharpe(idxs):
+        combo = [sum(cols[i][t] for i in idxs) / len(idxs) for t in range(n)]
+        m = sum(combo) / n
+        sd = _std(combo, ddof=1)
+        return (m / sd if sd > 0 else 0.0), m, sd
+
+    chosen = []
+    remaining = list(range(k))
+    steps = []
+    best_sharpe = None
+    while remaining and len(chosen) < max_k:
+        cand_best = None
+        for c in remaining:
+            sharpe, _, _ = combo_sharpe(chosen + [c])
+            if cand_best is None or sharpe > cand_best[1]:
+                cand_best = (c, sharpe)
+        c, sharpe = cand_best
+        if best_sharpe is not None and sharpe <= best_sharpe + 1e-9:
+            break
+        chosen.append(c)
+        remaining.remove(c)
+        best_sharpe = sharpe
+        steps.append({"added": labels[c], "combo_sharpe": _r(sharpe, 4)})
+    if not chosen:
+        raise ToolError("无法形成有效组合（所有候选夏普均不可得）")
+    sharpe, mean, sd = combo_sharpe(chosen)
+    return {"selected": [labels[i] for i in chosen],
+            "weights": [_r(1.0 / len(chosen), 4)] * len(chosen),
+            "steps": steps,
+            "combo_sharpe": _r(sharpe, 4),
+            "combo_annualized_pct": _r(mean * ppy * 100),
+            "note": "贪心启发式不保证全局最优；等权假设，实际配置请配合portfolio_allocation"}