Document snapshot/20260723-2 after strategy compare work.

Co-authored-by: Cursor <cursoragent@cursor.com>

.cursor/rules/auto-push-deploy.mdc

@@ -1,18 +0,0 @@
----
-description: After each completed code change, commit, push origin/main, and deploy to zk.hyf2.cc
-alwaysApply: true
----
-
-# Auto push & deploy
-
-When a user-facing code change is **finished** (not mid-debug / not "先不要改代码"):
-
-1. Commit only the relevant files (skip unrelated CRLF-only docs noise).
-2. `git push origin main` to `https://git.bz121.com/dekun/crypto_monitor.git`.
-3. Deploy to production `zk.hyf2.cc`:`cd /opt/crypto_monitor && git pull && bash deploy/pull_and_restart.sh`.
-4. Confirm PM2 processes are online; briefly report commit hash + deploy status.
-
-Do **not** wait for the user to say "推送并部署" again unless they cancel this habit.
-
-SSH: Prefer key auth; if BatchMode fails, use existing Paramiko root login path used in this project.
-Do not print or put passwords in user-facing replies.

.gitignore

@@ -15,12 +15,17 @@
 **/.env.backup*
 **/.env.bak
 **/.env.local
+
+# Cursor 本机规则/配置（勿提交；只留本地）
+.cursor/
+
 manual_trading_hub/hub_settings.json
 manual_trading_hub/hub_backup_state.json
 manual_trading_hub/hub_fund_history.json
 manual_trading_hub/hub_supervisor_state.json
 manual_trading_hub/hub_ai_summaries.json
 manual_trading_hub/hub_ai_chat.json
+manual_trading_hub/amp_stats_history.json
 manual_trading_hub/hub_ai_fund_history.json
 manual_trading_hub/data/
 backups/

crypto_monitor_binance/.env.example

@@ -158,6 +158,8 @@ RISK_CONTROL_ENABLED=true
 RISK_COOLING_HOURS_MANUAL=4
 RISK_COOLING_HOURS_MANUAL_JOURNAL=1
 RISK_MANUAL_CLOSE_DAILY_LIMIT=2
+# 日亏损次数上限:平仓盈亏<0 计1次;达限当日冻结开仓;0=不启用
+RISK_DAILY_LOSS_LIMIT=2
 RISK_MOOD_ISSUES_DAILY_FREEZE=true
 
 # 资金与仓位刷新周期(秒)

crypto_monitor_binance/app.py

@@ -2751,6 +2751,17 @@ def insert_trade_record(
             opened_at_ms=open_ts_ms,
             closed_at_ms=close_ts_ms,
         )
+    try:
+        from lib.trade.account_risk_lib import on_closed_trade_pnl
+
+        close_dt = parse_dt_for_trading_day(close_ts)
+        on_closed_trade_pnl(
+            conn,
+            pnl_amount=pnl_amount,
+            trading_day=get_trading_day(close_dt),
+        )
+    except Exception:
+        pass
     return tid
 
 

crypto_monitor_gate/.env.example

@@ -160,6 +160,8 @@ RISK_CONTROL_ENABLED=true
 RISK_COOLING_HOURS_MANUAL=4
 RISK_COOLING_HOURS_MANUAL_JOURNAL=1
 RISK_MANUAL_CLOSE_DAILY_LIMIT=2
+# 日亏损次数上限:平仓盈亏<0 计1次;达限当日冻结开仓;0=不启用
+RISK_DAILY_LOSS_LIMIT=2
 RISK_MOOD_ISSUES_DAILY_FREEZE=true
 
 # 资金与仓位刷新周期(秒)

crypto_monitor_gate/app.py

@@ -2445,6 +2445,17 @@ def insert_trade_record(
         sync_trade_records_from_exchange(conn, force=False)
     except Exception:
         pass
+    try:
+        from lib.trade.account_risk_lib import on_closed_trade_pnl
+
+        close_dt = parse_dt_for_trading_day(close_ts)
+        on_closed_trade_pnl(
+            conn,
+            pnl_amount=pnl_amount,
+            trading_day=get_trading_day(close_dt),
+        )
+    except Exception:
+        pass
     return tid
 
 

crypto_monitor_okx/.env.example

@@ -219,6 +219,8 @@ RISK_CONTROL_ENABLED=true
 RISK_COOLING_HOURS_MANUAL=4
 RISK_COOLING_HOURS_MANUAL_JOURNAL=1
 RISK_MANUAL_CLOSE_DAILY_LIMIT=2
+# 日亏损次数上限:平仓盈亏<0 计1次;达限当日冻结开仓;0=不启用
+RISK_DAILY_LOSS_LIMIT=2
 RISK_MOOD_ISSUES_DAILY_FREEZE=true
 
 # 资金与仓位刷新周期(秒)

crypto_monitor_okx/app.py

@@ -2364,6 +2364,17 @@ def insert_trade_record(
         sync_trade_records_from_exchange(conn, force=False)
     except Exception:
         pass
+    try:
+        from lib.trade.account_risk_lib import on_closed_trade_pnl
+
+        close_dt = parse_dt_for_trading_day(close_ts)
+        on_closed_trade_pnl(
+            conn,
+            pnl_amount=pnl_amount,
+            trading_day=get_trading_day(close_dt),
+        )
+    except Exception:
+        pass
     return tid
 
 

docs/ETH时段振幅统计-开发方案.md

@@ -0,0 +1,262 @@
+# 标的时段振幅统计 — 开发方案
+
+> 状态:**方案冻结**(按本文实现;改需求先改本文).  
+> 范围:**中控**新增只读统计工具;不改开平仓、不接 AI 教练(首版).  
+> 数据源:**仅 OKX**.  
+> 相关:[交易执行手册-期权与Gate.md](./交易执行手册-期权与Gate.md)(16:00 会话窗纪律) · [振幅统计说明.md](./振幅统计说明.md)
+
+---
+
+## 1. 目标
+
+在中控提供 **自定义时段、固定 16:00 收窗** 的历史振幅档案:
+
+- **标的下拉**:`ETH` / `BTC`(默认 ETH)
+- 按整点起点 + **终点固定北京时间 16:00** 切出每日统计窗
+- 回溯周期可选(1 月 / 2 月 / 3 月 / 半年 / 1 年 / 自定义)
+- 日表明细分页展示;下方为汇总统计
+- 每次有效计算可写入 **历史**;支持 **下载**(明细 + 统计摘要)
+
+定位:服务一天期期权开仓前的「空间」判断(已实现波动点数档案),**不算 IV / 权利金 / Greeks**.
+
+---
+
+## 2. 不做(首版外)
+
+- 币安 / Gate 等非 OKX 价源
+- 百分比振幅列(可后加「参考 %」,不进必须统计)
+- 未完成窗(当天尚未到 16:00)计入样本
+- 自动推送企业微信 / 注入交易教练
+- 中控代下单或改期权仓
+
+---
+
+## 3. 时间与样本规则
+
+### 3.1 时区与终点
+
+- 时区:**Asia/Shanghai(北京时间)**
+- **到期/收窗时刻固定 `16:00`**,不可改
+- 起点时刻:**仅整点** `00:00`～`23:00`(下拉选择)
+
+### 3.2 跨天切窗(结算日 D)
+
+对每个结算日 **D**(窗终点 = `D 日 16:00`):
+
+| 起点整点 T | 窗起点 | 窗终点 |
+|------------|--------|--------|
+| `T >= 16:00` | **D-1 日 T:00** | D 日 16:00 |
+| `T < 16:00` | **D 日 T:00** | D 日 16:00 |
+
+示例:
+
+| 用户选择 | 某一结算日 D 的实际窗 |
+|----------|------------------------|
+| 16:00 → 16:00 | D-1 16:00 → D 16:00 |
+| 22:00 → 16:00 | D-1 22:00 → D 16:00 |
+| 08:00 → 16:00 | D 08:00 → D 16:00 |
+
+### 3.3 回溯周期
+
+| 选项 | 含义(完整收窗个数,约) |
+|------|------------------------|
+| 1 个月 | 约 30 个结算日 |
+| 2 个月 | 约 60 个结算日(默认推荐) |
+| 3 个月 | 约 90 个结算日 |
+| 半年 | 约 180 个结算日 |
+| 1 年 | 约 365 个结算日 |
+| 自定义 | 用户输入天数 N(`7`～`400`,可配置上下限) |
+
+说明:
+
+- 「月」按 **日历回溯 + 完整 16:00 收窗** 计数,不足整天的末日不入样
+- 仅纳入 **已结束** 的窗(`now >= D 16:00`);进行中的今天不入样
+
+### 3.4 标的与价源(OKX)
+
+| UI 下拉 | 价源(优先) | 降级(仅指数失败时) |
+|---------|------------|---------------------|
+| **ETH** | OKX **ETH-USD 指数** | OKX `ETH/USDT` 永续标记 |
+| **BTC** | OKX **BTC-USD 指数** | OKX `BTC/USDT` 永续标记 |
+
+约束:
+
+- **交易所固定 OKX**,UI 不提供其它所
+- 具体指数/合约符号以实现时 OKX 接口与 `hub_ohlcv` 对齐为准;结果与下载须标注 `exchange=okx` + 实际价源
+- K 线粒度:**1H**(与整点起止对齐,优先);同一作业内不得混用粒度.若后续要更细高低点,可升 5m/1m(P2)
+
+---
+
+## 4. 指标口径(点数,非百分比)
+
+全部为 **绝对价格点数**(标的报价差;BTC/ETH 各自用自身价格刻度).
+
+设窗内:
+
+- `O` = 起点时刻价(或起点分钟 K 的 open)
+- `H` = 窗内最高
+- `L` = 窗内最低
+- `C` = 终点 16:00 价(或该分钟 close)
+
+| 字段 | 算法 | 例(O=2000,H=2500,L=1800) |
+|------|------|---------------------------|
+| 开盘价 | `O` | 2000 |
+| 最高价 | `H` | 2500 |
+| 最低价 | `L` | 1800 |
+| 收盘/窗末价 | `C` | (另算) |
+| 开→高距离 | `H − O` | **500** |
+| 开→低距离 | `O − L` | **200** |
+| **振幅** | `(H−O)+(O−L)` = **`H−L`** | **700** |
+| 涨跌值 | `C − O`(可正负) | 可选列,首版建议保留 |
+
+**必须统计(汇总层):**
+
+- **最大振幅**(值 + 对应结算日)
+- **开→高距离**:最大、均值(建议)
+- **开→低距离**:最大、均值(建议)
+
+可选汇总(首版建议带上,成本低):
+
+- 振幅均值 / 中位数
+- 上涨窗占比(`C>O`)、下跌窗占比
+- 振幅 ≥ 用户阈值 X 点数的天数(X 可填,默认空=不算)
+
+---
+
+## 5. 界面(中控)
+
+### 5.1 入口
+
+- 顶栏新增导航项:**「振幅统计」**或 **「期权统计」**(最终文案实现时定一处;设置里可隐藏)
+- 手机端进「更多」
+
+### 5.2 Tab
+
+| Tab | 作用 |
+|-----|------|
+| **统计** | 配参数 → 计算 → 看日表+汇总 → 下载 / 存历史 |
+| **历史** | 过往作业列表;打开复看;再下载 |
+
+### 5.3 「统计」页布局
+
+1. **参数区**
+   - **标的**:下拉 `ETH` / `BTC`(默认 ETH)
+   - 数据源:只读展示 `OKX`
+   - 起点整点:下拉 `00`～`23`(默认 `16`)
+   - 终点:固定展示 `16:00`(不可改)
+   - 周期:单选 `1月 / 2月 / 3月 / 半年 / 1年 / 自定义`
+   - 自定义天数:仅自定义时显示
+   - 按钮:`计算` · `保存到历史` · `下载`
+2. **日表明细**(分页,如每页 20 行;排序默认结算日倒序)
+3. **下方汇总区**(本次全样本,不是当前页)
+
+### 5.4 「历史」页
+
+每条记录至少:
+
+- 创建时间、**标的**、起点整点、周期/天数、价源(OKX+指数/标记)、样本数
+- 最大振幅(+日期)
+- 操作:查看 / 下载 / 删除
+
+**写入规则(建议):** 用户点击 **「保存到历史」** 才入库;仅点「计算」不自动灌历史(避免误点刷屏).若产品坚持「输入一次就算进历史」,可改为计算成功自动写入——实现前在本文改为冻结口径.
+
+> 当前方案冻结倾向:**显式「保存到历史」**.
+
+---
+
+## 6. 下载
+
+格式:优先 **CSV**(UTF-8 BOM,Excel 可开);或单文件双段.
+
+必须包含:
+
+1. **日表明细**(本次全部结算日,非当前页)
+2. **统计摘要**:标的、交易所 OKX、价源、最大振幅(+日)、开→高最大/均值、开→低最大/均值、样本数、起点整点、终点 16:00、周期、生成时间
+
+文件名示例:`okx_eth_amp_22to16_60d_20260723.csv` / `okx_btc_amp_16to16_90d_20260723.csv`
+
+---
+
+## 7. 数据与实现要点
+
+### 7.1 复用
+
+- 优先复用中控 `hub_ohlcv` / `hub_kline_store`,按 `exchange_key=okx` + 标的对应指数/合约拉齐历史 K 线并本地缓存
+- 首次 1 年 × 1m 数据量较大:计算前检查缓存覆盖;缺口再增量拉取;UI 显示进度/耗时提示
+- BTC / ETH 缓存键分离
+
+### 7.2 后端模块(建议)
+
+| 路径 | 职责 |
+|------|------|
+| `lib/hub/amp_stats_lib.py` | 标的映射、切窗、算日行、汇总 |
+| `manual_trading_hub/` 路由 + 静态页 | UI / API |
+| `manual_trading_hub/amp_stats_history.json`(或 sqlite) | 历史作业 |
+
+### 7.3 API 草稿
+
+| 方法 | 路径 | 说明 |
+|------|------|------|
+| `POST` | `/api/amp-stats/compute` | body: `symbol`(eth\|btc), start_hour, period\|days → 日表+汇总 |
+| `GET` | `/api/amp-stats/history` | 历史列表(可按 symbol 筛选) |
+| `POST` | `/api/amp-stats/history` | 保存当前结果 |
+| `GET` | `/api/amp-stats/history/{id}` | 详情 |
+| `DELETE` | `/api/amp-stats/history/{id}` | 删除 |
+| `GET` | `/api/amp-stats/export` | query 或 history id → 文件下载 |
+
+### 7.4 性能
+
+- 2 个月 × 1m:可接受同步(数十秒级需有 loading)
+- 1 年:建议异步任务或分块拉齐后再算;首版可限制「自定义 > 180 天」需确认二次点击
+
+---
+
+## 8. 验收清单
+
+- [ ] 标的下拉 ETH / BTC 可切换;数据源固定 OKX
+- [ ] 起点仅整点;终点 UI 固定 16:00
+- [ ] `22→16` / `16→16` / `08→16` 跨天规则与 §3.2 一致
+- [ ] 周期六档 + 自定义天数生效;默认 2 个月
+- [ ] 日表含:开高低收、开→高、开→低、振幅(点数)、涨跌值
+- [ ] 例:O=2000,H=2500,L=1800 → 开→高 500、开→低 200、振幅 700
+- [ ] 汇总含最大振幅(+日)、开→高/开→低统计
+- [ ] 分页只影响展示;汇总与下载用全样本
+- [ ] 未到 16:00 的当日不入样
+- [ ] 保存历史含标的字段 / 回看 / 删除
+- [ ] 下载含明细 + 统计摘要(含标的与 OKX)
+- [ ] 电脑与手机均可完成计算与下载(手机下载走系统分享/保存即可)
+
+---
+
+## 9. 分期
+
+| 阶段 | 内容 |
+|------|------|
+| **P0** | 统计 Tab:标的下拉(ETH/BTC) + 参数 + 计算 + 日表分页 + 汇总 + 下载(不经历史) |
+| **P1** | 历史 Tab:保存 / 列表 / 回看 / 再下载 / 删除 |
+| **P2** | 缓存加速、长周期异步、振幅阈值天数、可选 % 参考列 |
+
+---
+
+## 10. 待冻结(实现前确认)
+
+| # | 问题 | 当前倾向 |
+|---|------|----------|
+| 1 | 历史写入:自动 vs 点保存 | **点保存** |
+| 2 | 下载 CSV vs Excel | **CSV** |
+| 3 | 价源 | **OKX 指数优先**(ETH-USD / BTC-USD);失败再降级永续标记 |
+| 4 | K 线 1m vs 5m vs 1H | **1H**(整点窗) |
+| 5 | 导航文案 | **「振幅统计」** |
+
+**已冻结(开工口径):** 点保存进历史 · CSV · OKX 指数优先 · **1H K 线**(整点对齐,降低拉取量;与整点窗一致) · 导航「振幅统计」.
+
+确认后将本文状态改为 **方案冻结**,再开工实现.
+
+---
+
+## 11. 修订记录
+
+| 日期 | 说明 |
+|------|------|
+| 2026-07-23 | 初稿:中控 ETH 时段振幅统计;点数口径;周期档位;16:00 固定收窗;历史+下载 |
+| 2026-07-23 | 支持 BTC/ETH 下拉;数据源固定 OKX 指数(可降级永续标记);模块/API 改名为 amp-stats |

docs/account-risk-cooldown.md

@@ -41,6 +41,7 @@
 |------|------|
 | 第 1 次用户主动平仓 | 默认 **4h** 冷静期 |
 | 第 2 次用户主动平仓(同一交易日) | **日冻结** |
+| 平仓亏损达 `RISK_DAILY_LOSS_LIMIT` 次(同一交易日) | **日冻结**(默认 2 次;`0`=不启用) |
 | 复盘勾选任意情绪标签 | **日冻结** |
 | 复盘:离场=手动平仓 且说明非空 | 将当前冷静期降为 **1h**(须处于 4h 档冷静期中) |
 
@@ -77,11 +78,15 @@ RISK_CONTROL_ENABLED=true
 RISK_COOLING_HOURS_MANUAL=4
 RISK_COOLING_HOURS_MANUAL_JOURNAL=1
 RISK_MANUAL_CLOSE_DAILY_LIMIT=2
+RISK_DAILY_LOSS_LIMIT=2
 RISK_MOOD_ISSUES_DAILY_FREEZE=true
 TRADING_DAY_RESET_HOUR=8
 APP_TIMEZONE=Asia/Shanghai
 ```
 
+- `RISK_DAILY_LOSS_LIMIT`:任意已平仓交易若盈亏 < 0 计 1 次(含止损/止盈后仍亏损等);达上限当日冻结开仓;`0` 表示不因亏损次数冻结.
+- `RISK_MANUAL_CLOSE_DAILY_LIMIT`:仅计**用户主动平仓**次数(与亏损次数独立).
+
 `RISK_COOLING_HOURS_EXTERNAL` 已废弃(外部平仓不再触发风控).
 
 ## API 与 `risk_status` 字段
@@ -102,6 +107,7 @@ APP_TIMEZONE=Asia/Shanghai
 | `can_trade` | 是否允许新开仓(仅风控维度) |
 | `reason` | 悬停提示文案 |
 | `active_count` / `max_active_positions` | 当前活跃持仓与 `.env` 中 `MAX_ACTIVE_POSITIONS` |
+| `daily_loss_count` / `daily_loss_limit` | 当日亏损笔数与上限(`0` 上限表示未启用) |
 | `cooloff_until_ms` | 1h/4h 冷静期结束时间戳(毫秒) |
 | `freeze_until_ms` | 倒计时结束时间戳(日冻结为下一交易日切点) |
 | `freeze_remaining_sec` | 服务端计算的剩余秒数(供调试) |
@@ -123,7 +129,7 @@ APP_TIMEZONE=Asia/Shanghai
 
 ## 相关代码
 
-- `account_risk_lib.py` — 状态机,`enrich_risk_status_countdown`,`apply_position_limit_risk`,`on_user_initiated_close`
+- `account_risk_lib.py` — 状态机,`enrich_risk_status_countdown`,`apply_position_limit_risk`,`on_user_initiated_close`,`on_closed_trade_pnl`
 - `hub_bridge.py` — `/api/hub/account-risk/user-close`
 - `manual_trading_hub/hub.py` — 中控平仓成功后调用 user-close
 - `strategy_trend_register.py` — `stop_trend_pullback` 结束计划时登记风控

docs/env配置说明.md

@@ -131,6 +131,7 @@ AI 相关环境变量(`AI_PROVIDER`,`OPENAI_*`,`OLLAMA_*`,`AI_MODEL`,`AI_TIMEOUT
 | 手动平仓冷静(小时) | |
 | 复盘情绪冷静(小时) | |
 | 日手动平仓次数上限 | |
+| 日亏损次数上限 | 默认2;达限当日冻结开仓;0=不启用 |
 | 情绪标签日冻结 | |
 
 详见 [account-risk-cooldown.md](./account-risk-cooldown.md).

docs/strategy/README.md

@@ -4,6 +4,8 @@
 
 | 文档 | 实例 | 状态 |
 |------|------|------|
+| [交易执行手册-期权与Gate.md](../交易执行手册-期权与Gate.md) | 中控「策略说明」·执行手册 | 个人开单纪律 |
+| [交易行为准则-开单三检.md](../交易行为准则-开单三检.md) | 中控「策略说明」·行为准则 | 开单前信号/流程/情绪三检 |
 | [binance-alt-trend-long.md](./binance-alt-trend-long.md) | 币安山寨·多头趋势 | v0.4 讨论稿 |
 | [okx-trend-both.md](./okx-trend-both.md) | OKX·多空趋势 | v0.4 讨论稿 |
 | [gate-intraday.md](./gate-intraday.md) | Gate·BTC 日内 | v0.2 |

docs/strategy/checklists/behavior.json

@@ -0,0 +1,32 @@
+{
+  "exchange": "behavior",
+  "title": "开单三检清单",
+  "version": "v0.1",
+  "groups": [
+    {
+      "title": "信号判断",
+      "items": [
+        "最核心、最明确的一个点位/结构确认已写清",
+        "该确认本身足够清晰（不是靠一长串宏大叙事）",
+        "已过方向 → 空间 → 值不值得（不够格则空仓）"
+      ]
+    },
+    {
+      "title": "流程确认",
+      "items": [
+        "账户资金与当日额度符合要求",
+        "单笔风险 / 组合敞口在手册预算内",
+        "无跳步；超限则暂停开单"
+      ]
+    },
+    {
+      "title": "情绪自检",
+      "items": [
+        "心态是「符合系统所以做」，不是「证明自己」",
+        "无怕踏空 → 否则放弃",
+        "无回本 / 报复交易念头 → 否则放弃",
+        "不需要再找更多开单理由"
+      ]
+    }
+  ]
+}

docs/交易执行手册-期权与Gate.md

@@ -0,0 +1,148 @@
+# 交易执行手册（期权为主 · Gate 为辅）
+
+> 个人开单纪律与仓位规则（2026-07 起）。  
+> 目标：少而精、可控回撤、样本干净；**不保证收益**。  
+> 工具：OKX 期权（主）+ Gate 合约（辅）；其它账户暂不做。  
+> **开单前先过** [交易行为准则-开单三检.md](./交易行为准则-开单三检.md)（信号 / 流程 / 情绪）；本手册管怎么做单。
+
+---
+
+## 1. 总原则
+
+1. **主做期权，合约为辅**；同一时段尽量只让一边「说话」。
+2. **看不懂不做**；过滤比频率重要。
+3. 动手前先过 **开单三检**（信号判断 → 流程确认 → 情绪自检）；不过 → 空仓。详见 [行为准则](./交易行为准则-开单三检.md)。
+4. 开仓前再过玩法三关：**方向 → 空间 → 值不值得**。不够格 → 空仓。
+5. 期权离场只认：**止盈（规则触发）** 与 **到期**；**不手动平仓**（紧急例外单不算策略样本）。
+6. 过程可控、结果随缘：用规则管仓位与次数，不追求每天打满理想上限。
+
+---
+
+## 2. 账户与分工
+
+| 账户 | 角色 | 说明 |
+|------|------|------|
+| OKX 期权 | **主业** | 横盘对冲 / 方向单 / 偏置对冲 |
+| Gate 合约 | **辅业** | 结构清楚时的波段；与期权尽量错开 |
+| 其它 | 暂不做 | 减少分心与样本污染 |
+
+**到期选择（期权）**
+
+- 方向单、对冲默认 **一天期**。
+- 尽量在 **北京时间下午 4 点后** 开 **次日到期**，覆盖较完整的美盘 + 亚盘 + 欧盘窗口。
+- Gate 波段样本里最长持仓约十余小时量级 → 一天期权通常够表达；更长故事优先考虑合约，不强行拉长期权。
+
+---
+
+## 3. 入场逻辑（三类）
+
+开仓前先判断：当前是 **买波动** 还是 **买方向**。
+
+### 3.1 横盘 → 期期对冲
+
+- **条件**：横盘已持续较久（例如满约 12 小时），方向不明。
+- **工具**：一天期 Call + Put（对冲）；总权利金预算见仓位章。
+- **意图**：买接下来的波动，不赌单边。
+- **期间**：一般 **不再开 Gate 方向单**（已在买波动，勿叠同一宏观暴露）。
+
+### 3.2 方向明确 · 结构突破 → 期权
+
+- **条件**：方向、空间、值不值得均过关；结构突破成立。
+- **工具**：**一天期期权方向单**（或明显顺势结构）。
+- **离场**：目标止盈或到期；不手平。
+- **默认**：先只开期权，不上合约。
+
+### 3.3 结构突破后 · 反向假突破确认 → 可加合约
+
+- **条件**：已有结构突破的期权表达；随后出现反向假突破且确认失败、续原方向。
+- **工具**：Gate 合约 **小仓加强**（止损纪律见下）。
+- **注意**：BTC 合约与 ETH 期权高度相关，属加重暴露，不是分散；仓位按「一笔故事」计风险。
+- **假突破定义**需事先写死（相对哪段结构、如何确认收回），避免临场随便加仓。
+
+### 3.4 独立假突破（没有先开突破期权时）
+
+- 按「假破专用」处理：优先 **只做合约** 或 **空仓**，勿与「突破后再假破加仓」混用同一套仓。
+
+---
+
+## 4. 对冲偏好（偏置对冲）
+
+在「尽量用对冲」的前提下：
+
+- 对冲内常带 **做多/做空比例**；若略偏多，则 **做多一侧比例更高**。
+- 顺势侧尽量用 **实值（或更实）**：
+  - 方向对了：可能 **少赚一点**（相对纯单边）；
+  - 方向错了：争取 **不亏或少亏**（相对虚值双买两边磨光）。
+- **总权利金仍锁在对冲预算内**（见仓位）；偏置只调张数/行权远近，不偷偷加预算。
+- **偏置有度**（例如勿极端到名存实亡的单边）；完全没方向时更接近均分/近平值；方向非常明确时应走单边期权，不必硬套对冲壳。
+- 复盘建议区分：**中性对冲** vs **偏多/偏空对冲**，以便检验偏置是否真压低亏损。
+
+---
+
+## 5. 仓位与风险预算
+
+**总资金参考：约 800U。**
+
+| 项目 | 规则 |
+|------|------|
+| 单笔期权 | 约 **10U** 权利金预算；**一次只持有一个期权仓位** |
+| 期期对冲 | **合计约 10U**（两腿加总，不是各 10） |
+| Gate 合约 | 日内保证金约 **50U**、约 **10 倍**；有单才用，无单为 0 |
+| 合约止损 | 一般约 **5U**；单笔最大亏损不超过约 **10U** |
+| 日损失心理框 | 期权+合约若都错：合计大约 **≤20U**；都对时期望可到 **40U+**（理想情形，非每日目标） |
+
+相对 800U：单笔约 **1.25%** 量级；全错一天约 **2.5%** 量级——防守优先。
+
+**叠加红线**
+
+- 期权一仓 + 合约加仓同日存在时，按合计风险接受最坏约 20U，且尽量少「同向双开」。
+- 不因「期权偏置可能少亏」而放大合约。
+
+---
+
+## 6. 合约日纪律（Gate）
+
+1. 只做 **很明确的位置**；不明确基本不做。
+2. 动手前想清：**如何进场**。
+3. **同一位置最多两次机会**：结构突破、假突破。
+4. **两次都错 → 当日不再做单**（即使后面更「看起来清楚」也留到明天）。
+5. 止损约 **5U**；波段规则（含是否时间离场）开仓前想清。
+6. 已关闭「强制清仓」误伤策略意图时，离场以结构止盈/止损为准；历史里「强制清仓但盈利」按规则结果理解，复盘看盈亏与结构。
+
+---
+
+## 7. 期权日纪律（OKX）
+
+1. **不手动平仓**；只等规则止盈或到期（紧急手平标记为非策略样本）。
+2. 一次一仓；对冲共 10U。
+3. 横盘对冲期间一般不开 Gate 方向单。
+4. 结构突破用期权表达；假破加强才考虑合约。
+5. 默认一天期；优先完整会话窗口再开。
+
+---
+
+## 8. 开仓前自检清单
+
+- [ ] 今天是否只动「期权 / Gate」，其它账户零操作？
+- [ ] 买波动还是买方向？工具选对了吗？
+- [ ] 方向 / 空间 / 值不值得是否都过关？
+- [ ] 期权：止盈条件与「接受到期」是否写清？
+- [ ] 对冲：比例与实值偏置是否有度？总预算是否仍 ≤10U？
+- [ ] 合约：本位置第几次机会？止损约 5U 设好了吗？
+- [ ] 若加合约：是否已有突破期权且假破确认？是否当成一笔故事控总风险？
+- [ ] 今日合约两点机会是否已用完？（用完则收工）
+
+---
+
+## 9. 一句话版本
+
+> **横盘对冲（可偏置实值）；突破用一天期权；假破确认后小仓合约加强；先过方向/空间/值不值得；期权不手平；一位置两次，错完收工；单笔小亏、组合回撤可控。**
+
+---
+
+## 10. 修订记录
+
+| 日期 | 说明 |
+|------|------|
+| 2026-07-21 | 初版：根据实盘讨论整理（期权为主、Gate 为辅、仓位与日停手规则） |
+| 2026-07-23 | 挂钩开单三检行为准则 |

docs/交易行为准则-开单三检.md

@@ -0,0 +1,114 @@
+# 交易行为准则（开单三检）
+
+> 个人强制思维动作 · 初级版（2026-07）。  
+> **不是策略**，是开单前的「交易防火墙」：保证动作在可控轨道上，**不判断这笔会不会赚钱**。  
+> 来源：中控 AI 复盘对话（2026-07-22）与本人归纳。  
+> 仓位与玩法细则见 [交易执行手册-期权与Gate.md](./交易执行手册-期权与Gate.md)。
+
+---
+
+## 1. 一句话
+
+> **信号够不够清晰？流程有没有跑通？情绪是不是在证明自己？三检不过 → 不开。**
+
+复盘成败的第一标准：**三检是否完整完成**，而不是这笔盈亏。
+
+---
+
+## 2. 总循环
+
+```
+信号判断 → 流程确认 → 情绪自检 → 全部通过
+    → 开仓 → 等待系统结果（止盈 / 止损 / 到期）
+    → 本次结束 → 复盘整环 → 等待下一个信号
+```
+
+任一步否决 → **空仓离开**，不找补丁理由硬开。
+
+---
+
+## 3. 开单前：三秒停顿
+
+手要动之前，强制停顿，把注意力从宏大叙事拉回内部三点：
+
+1. 我的**核心信号**是什么？  
+2. **安全流程**跑通了吗？  
+3. 我现在是冷静执行，还是急着证明 / 怕踏空 / 想回本？
+
+---
+
+## 4. 三检细则
+
+### 4.1 信号判断（Signal Judgment）
+
+**问：** 这次入场，最核心、最明确的那一个点位 / 结构确认是什么？它本身够不够清晰？
+
+| 通过 | 否决 |
+|------|------|
+| 能用一句话说清「唯一核心确认」 | 说不清、要靠一长串宏观故事才能自圆其说 |
+| 点位 / 结构本身已经够清楚 | 「好像有戏」但确认点模糊 |
+| 只描述事实与系统条件 | 堆细节证明自己分析很厉害 |
+
+对照执行手册时：先过 **方向 → 空间 → 值不值得**；不够格 → 空仓（见手册 §1、§3）。
+
+### 4.2 流程确认（Process Confirmation）
+
+**问：** 决定执行前，有没有按设定步骤检查资金与风险敞口？内部安全流程跑通了吗？
+
+| 通过 | 否决 / 暂停 |
+|------|-------------|
+| 账户资金与当日额度符合要求 | 资金或次数已触限 |
+| 单笔风险 / 组合敞口在手册预算内 | 单笔或日最坏超限 → **暂停开单** |
+| 该走的检查项没有跳步 | 「先开了再说」 |
+
+细则数字以执行手册仓位章为准（单笔期权、对冲总权利金、Gate 止损与日停手等）。
+
+### 4.3 情绪自检（Emotional Self-Check）
+
+**问：** 看到复杂结构与逻辑时，内心是什么？是「必须证明分析是对的」，还是「符合系统要求，所以做」？
+
+| 通过 | 否决（果断放弃） |
+|------|------------------|
+| 「符合系统信号 + 账户没问题 → 开」 | 「怕踏空」 |
+| 不需要再找更多开单理由 | 「上回亏了，这单要回本」 |
+| 旁观者视角、可接受空仓 | 「必须证明我是对的」 |
+
+**原则：** 不为开单找理由；情绪红灯亮了，信号再好看也不开。
+
+---
+
+## 5. 开仓后纪律（与手册一致）
+
+- 开仓后：**等待系统结果**（规则止盈 / 止损 / 到期），不靠情绪手平（紧急例外不算策略样本）。  
+- 持仓期盯的是「程序与纪律是否正常」，不是浮盈浮亏数字本身。  
+- 无信号时的空档也算训练：反复在脑子里空跑三检，比硬找单更重要。
+
+---
+
+## 6. 复盘只记什么
+
+每次交易（含未开成的冲动）建议只记：
+
+1. 信号判断：做了吗？核心确认写了什么？是否清晰？  
+2. 流程确认：资金 / 敞口是否过关？有无跳步？  
+3. 情绪自检：当时心态是哪一类？有无怕踏空 / 回本？  
+4. 结果：止盈 / 止损 / 到期 / 未开 — **结果不推翻「三检是否完成」这一评分。**
+
+---
+
+## 7. 与执行手册的分工
+
+| 文档 | 管什么 |
+|------|--------|
+| **本准则** | 能不能动手（防火墙 / 操作系统） |
+| **执行手册** | 怎么做单（期权 / Gate、仓位、离场） |
+
+先过本准则三检，再谈手册里的玩法与仓位。
+
+---
+
+## 8. 修订记录
+
+| 日期 | 说明 |
+|------|------|
+| 2026-07-23 | 初级版：三检 + 总循环 + 红线；对齐 AI 复盘与本人总结 |

docs/快照备份.md

@@ -6,7 +6,10 @@
 
 | 标签 | 指向提交 | 说明 |
 |------|----------|------|
-| `snapshot/20260721` | `2a60d47` | 2026-07-21：仓库代码统计文档、期权复盘亮色主题、对冲腿盈亏时区修复、本快照说明等 |
+| `snapshot/20260723-2` | `9e0591c` | 2026-07-23：策略对比页（合约/单期权/期期7:3）、监控与看板隐藏浮盈偏好、对比页卡片内边距等 |
+| `snapshot/20260723-pre-amp-stats` | `40be3a5` | 2026-07-23：振幅统计开发前；含执行手册进教练、日亏损冻结、手机监控 UI、振幅统计开发方案等 |
+| `snapshot/20260721-2` | `a721642` | 2026-07-21 晚：日亏损次数冻结、交易执行手册入中控策略说明、期权/Gate 执行手册文档等 |
+| `snapshot/20260721` | `1a163c0` | 2026-07-21：仓库代码统计文档、期权复盘亮色主题、对冲腿盈亏时区修复、本快照说明等 |
 
 ## 历史标签（节选）
 
@@ -25,7 +28,7 @@
 git tag -l 'snapshot/*'
 
 # 检出快照（只读查看，勿在此分支直接开发）
-git checkout snapshot/20260721
+git checkout snapshot/20260723-2
 
 # 回到主线
 git checkout main

docs/振幅统计说明.md

@@ -0,0 +1,111 @@
+# 振幅统计（中控）
+
+中控只读工具：按自定义整点起点、**固定北京时间 16:00 收窗**，统计 OKX 上 ETH/BTC 的历史「点数振幅」档案，辅助一天期期权判断空间。
+
+> 开发方案见 [ETH时段振幅统计-开发方案.md](./ETH时段振幅统计-开发方案.md)。  
+> **不改下单链路**；不算 IV / 权利金。
+
+---
+
+## 入口
+
+- 顶栏 **振幅统计**（`/amp-stats`）
+- 手机端：**更多 → 振幅统计**
+- 可在系统设置里隐藏该导航
+
+---
+
+## 怎么用
+
+1. 打开 **统计** Tab  
+2. 选择 **标的** ETH / BTC；数据源固定 **OKX**  
+3. **起点整点**（00–23）；终点固定 **16:00**  
+4. **周期**：1 月 / 2 月 / 3 月 / 半年 / 1 年 / 自定义天数（默认 2 个月）  
+5. 点 **计算** → 下方看汇总 + 分页日表  
+6. 需要留存时点 **保存到历史**；**下载 CSV** 含摘要 + 全日明细  
+
+**跨天例子**
+
+| 起点 | 含义（结算日 D） |
+|------|------------------|
+| 22:00 | 昨天 22:00 → 今天 16:00 |
+| 16:00 | 昨天 16:00 → 今天 16:00 |
+| 08:00 | 今天 08:00 → 今天 16:00 |
+
+未到当日 16:00 的「今天」不入样本。
+
+---
+
+## 指标（点数）
+
+设开盘 O、最高 H、最低 L、收盘 C：
+
+| 字段 | 算法 |
+|------|------|
+| 开→高 | `H − O` |
+| 开→低 | `O − L` |
+| **振幅** | `H − L`（= 开→高 + 开→低） |
+| 涨跌值 | `C − O` |
+
+例：O=2000，H=2500，L=1800 → 开→高 500，开→低 200，振幅 **700**。
+
+汇总必含：最大振幅（及日期）、开→高/开→低的最大与均值等。
+
+K 线粒度：**1H**（与整点对齐）；价源优先 OKX 指数（ETH-USD / BTC-USD），失败再降级永续标记。  
+近期 K 线接口约仅 **1440** 根（1H≈60 天）；更长周期自动续拉 `history-index-candles` / `history-candles`。  
+分页带间隔，遇 OKX **429** 会自动退避重试（长周期首次会慢一些）。
+
+---
+
+## 买跨对照（赌波动）
+
+表单可填 **双边权利金（点）**，例如 `30`；旁边可填 **止盈点**（可空）：
+
+| 汇总项 | 口径 |
+|--------|------|
+| 开→高超过权利金 | `H−O > 权利金` 的天数与占比 |
+| 开→低超过权利金 | `O−L > 权利金` 的天数与占比 |
+| \|涨跌\|超过权利金 | `\|C−O\| > 权利金` 的天数与占比 |
+| 有效波动 | 若设止盈且 `开→高≥止盈` 或 `开→低≥止盈` → 用止盈点；否则用 `\|C−O\|` |
+| 买跨收益 | `有效波动 − 权利金`（日表「收益」列同口径） |
+
+- 方向：**买跨**  
+- 权利金越过：严格 **`>`**；止盈触达：**`≥`**  
+- 止盈留空 / ≤0：有效波动一律按 `|涨跌|`  
+- 已算出日表后，改权利金 / 止盈 / 周末筛选会**本地重算**（不重拉 K 线）  
+
+### 周末
+
+- 下拉：**全部**（默认）/ **排除周末** / **仅周末**  
+- 按 **结算日** 北京时间星期判断；表中六、日带标注并高亮  
+
+---
+
+## 历史 Tab
+
+- 仅 **保存到历史** 后出现（不会一算就自动入库）  
+- 可查看、再下载、删除  
+- 数据文件：`manual_trading_hub/amp_stats_history.json`（勿当密钥提交）
+
+---
+
+## 相关代码
+
+| 路径 | 说明 |
+|------|------|
+| `lib/hub/amp_stats_lib.py` | 切窗、汇总、OKX 拉取、CSV |
+| `manual_trading_hub/amp_stats_routes.py` | API |
+| `manual_trading_hub/amp_stats_store.py` | 历史 JSON |
+| `manual_trading_hub/static/amp_stats.js` | 前端 |
+| `tests/test_amp_stats_lib.py` | 单元测试 |
+
+---
+
+## 修订
+
+| 日期 | 说明 |
+|------|------|
+| 2026-07-23 | 首版上线说明 |
+| 2026-07-23 | 买跨对照：可设双边权利金、越过占比与收盘盈亏 |
+| 2026-07-23 | 周末筛选/标注、止盈点(≥)、日表收益列 |
+| 2026-07-23 | 长周期续拉 history K 线；收益列红绿着色 |

docs/策略对比说明.md

@@ -0,0 +1,62 @@
+# 策略对比说明
+
+中控独立页 **策略对比**（`/compare`）：在同一风险额 `R` 下，对比三种工具的止盈能力与止损/踏空路径。
+
+## 用途
+
+回答两件事：
+
+1. **盈利时谁更厉害**：干净止盈路径下各赚多少 U  
+2. **谁更易亏 / 更易踏空**：合约止损后踏空；期权/对冲最坏亏满权利金，但踏空路径下常仍可持有到目标
+
+不是精确概率模型。到期「小盈/小亏」与 4 点收盘相关，**未纳入主表与推荐**。
+
+## 入口
+
+- 顶栏「策略对比」；设置 → 显示与导航可隐藏（`show_nav_compare`）  
+- API：`POST /api/compare/calc`（页面即时调用，价格均为手填）
+
+## 输入
+
+| 区块 | 字段 |
+|------|------|
+| 公共 | 标的 ETH/BTC、方向、入场价、风险 R、统一止损、止盈 |
+| 单期权 | Call/Put、行权价、卖一（每币）、可选目标价 |
+| 期期 | 主腿/次腿 各自行权与卖一；预算固定 **7:3** |
+
+卖一口径与对冲计划一致：`单张成本 = 卖一 × ct_mult`（默认 `ct_mult=0.01`）。
+
+## 仓位
+
+- **合约**：`张数 = floor(R / (|入场−止损| × 面值))`，默认面值 0.01  
+- **单期权**：`张数 = floor(R / 单张成本)`  
+- **期期**：主预算 `0.7R`、次预算 `0.3R`，各自 `floor(预算/单张成本)`
+
+## 主情景（A/B/C）
+
+| 路径 | 合约 | 单期权 / 期期 |
+|------|------|----------------|
+| A 干净止盈 | 入场→止盈盈亏 | 目标价内在价值 − 已付权利金（近似） |
+| B 打止损 | −实际止损额（≈R） | 止损价处内在−权利金；并注最坏 −权利金 |
+| C 先止损再去止盈 | **本单仍为止损亏损**；旁注踏空未拿到的原止盈空间 | **仍持有**至目标价，结果同 A（抗踏空对照） |
+
+期权止盈按**内在价值近似**，不是盘口卖出价。
+
+## 推荐规则（可解释）
+
+1. 比较三者 A / R  
+2. 若合约止盈明显高于另两者（≥1.15×）→ 倾向合约，并提示踏空  
+3. 否则若存在踏空对照（合约亏、期权类 C 仍为正）→ 倾向单期权或期期（期期与单腿接近时优先期期）  
+4. 平局：抗踏空优先期权类，赔付碾压则合约  
+
+## 手测示例
+
+`ETH` 做多，入场 3500，止损 3400，止盈 3700，R=10；单 Call 行权 3600 卖一 50；对冲主 Call 3600/50、次 Put 3400/30：
+
+- 合约约 10 张，止损 −10U，止盈约 +20U，踏空未拿到约 +20U  
+- 单期权约 20 张，权利金 10U，止盈约 +10U，最坏 −10U  
+- 期期主 14 / 次 10 张  
+
+## 不做
+
+实盘下单、拉交易所卖一（二期可选）、历史回测入库。

lib/common/static/options_position_cards.js

@@ -147,9 +147,10 @@
     opts = opts || {};
     const hub = !!opts.hub;
     const readOnly = !!opts.readOnly;
-    const net = netPnlFromPos(p);
-    const roi = netRoiFromPos(p, net);
-    const uplCls = pnlCls(net, hub);
+    const hidePnl = !!opts.hidePnl;
+    const net = hidePnl ? null : netPnlFromPos(p);
+    const roi = hidePnl ? null : netRoiFromPos(p, net);
+    const uplCls = hidePnl ? "" : pnlCls(net, hub);
     const sideCls = (p.opt_type || "").toUpperCase() === "P" ? "pos-side-short" : "pos-side-long";
     const expMs = p.exp_time_ms != null ? p.exp_time_ms : p.exp_time;
     const expAttr = expMs != null && expMs !== "" ? String(expMs) : "";
@@ -166,6 +167,12 @@
         '<button type="button" class="btn-primary opt-close-btn" data-inst="' + (p.inst_id || "") + '" data-sheets="' + closeSheets + '">买一平仓</button>' +
         "</div>";
     }
+    const pnlCells = hidePnl
+      ? ""
+      : '<div class="pos-cell"><span class="pos-label">净盈亏</span><span class="pos-value ' + uplCls + '">' +
+        (closePreview.bid_invalid || net == null ? "—" : fmt(net, 2)) + "</span></div>" +
+        '<div class="pos-cell"><span class="pos-label">收益率</span><span class="pos-value ' + uplCls + '">' +
+        (closePreview.bid_invalid || roi == null ? "—" : fmt(roi, 2) + "%") + "</span></div>";
     return (
       '<div class="pos-card-head">' +
       '<div class="pos-card-symbol"><strong>' + (p.inst_id || "") + "</strong>" +
@@ -189,15 +196,12 @@
       '<div class="pos-cell"><span class="pos-label">指数价</span><span class="pos-value">' + fmt(p.idx_px, 0) + "</span></div>" +
       '<div class="pos-cell"><span class="pos-label">到期平衡</span><span class="pos-value">' + fmt(p.expiry_be_px, 0) + "</span></div>" +
       '<div class="pos-cell"><span class="pos-label">平掉回本</span><span class="pos-value">' + fmt(p.close_be_px, 0) + "</span></div>" +
-      '<div class="pos-cell"><span class="pos-label">净盈亏</span><span class="pos-value ' + uplCls + '">' +
-      (closePreview.bid_invalid || net == null ? "—" : fmt(net, 2)) + "</span></div>" +
-      '<div class="pos-cell"><span class="pos-label">收益率</span><span class="pos-value ' + uplCls + '">' +
-      (closePreview.bid_invalid || roi == null ? "—" : fmt(roi, 2) + "%") + "</span></div>" +
+      pnlCells +
       '<div class="pos-cell opt-pos-cell--depth"><span class="pos-label">买盘深度</span><span class="pos-value opt-bid-plain">' + fmtCloseLevels(closePreview, tickSz) + "</span></div>" +
       '<div class="pos-cell opt-pos-cell--close"><span class="pos-label">按买盘回收</span><span class="pos-value">' +
       (closePreview.bid_invalid
         ? '<span class="muted">暂无有效买盘</span>'
-        : fmtClosePreview(closePreview, p.premium_paid, hub)) + "</span></div>" +
+        : fmtClosePreview(closePreview, hidePnl ? null : p.premium_paid, hub)) + "</span></div>" +
       "</div>" +
       (function () {
         const hint = closeGateHint(closePreview);
@@ -217,19 +221,22 @@
               const intrinsic = o === "C" ? Math.max(0, tgt - strike) : o === "P" ? Math.max(0, strike - tgt) : null;
               if (intrinsic != null) {
                 value = Math.round(intrinsic * eth * 100) / 100;
-                if (Number.isFinite(prem)) profit = Math.round((value - prem) * 100) / 100;
+                if (!hidePnl && Number.isFinite(prem)) profit = Math.round((value - prem) * 100) / 100;
               }
             }
             const profitTxt = profit == null ? "—" : ((profit > 0 ? "+" : "") + fmtUsdc(profit) + " USDC");
             const profitCls = profit > 0 ? " pnl-pos" : profit < 0 ? " pnl-neg" : "";
             const hedgeTarget = p.hedge_plan_target || null;
             const managed = hedgeTarget && hedgeTarget.managed_by === "hedge_plan";
+            const profitSpan = hidePnl
+              ? ""
+              : '<span class="pos-value' + profitCls + '">预估盈利 ' + profitTxt + "</span>";
             return (
               '<div class="opt-target-row opt-target-row--ro' + (managed ? " opt-target-row--managed" : "") + '">' +
               '<span class="opt-target-row-label">' + (managed ? "对冲计划 #" + hedgeTarget.plan_id : "委托") + "</span>" +
               '<span class="pos-value">目标 ' + fmt(p.target_index, 1) + "</span>" +
               '<span class="pos-value">价值 ' + (value == null ? "—" : fmtUsdc(value) + " USDC") + "</span>" +
-              '<span class="pos-value' + profitCls + '">预估盈利 ' + profitTxt + "</span>" +
+              profitSpan +
               '<span class="muted opt-target-row-hint">' +
               (managed ? "进行中 · 由对冲计划监控，到位后仅平盈利腿" : "监控中 · 到位按买一限价平") +
               "</span></div>"

lib/env/env_schema.py

@@ -58,6 +58,7 @@ HOT_RELOAD_EXACT = frozenset({
     "RISK_COOLING_HOURS_MANUAL",
     "RISK_COOLING_HOURS_MANUAL_JOURNAL",
     "RISK_MANUAL_CLOSE_DAILY_LIMIT",
+    "RISK_DAILY_LOSS_LIMIT",
     "RISK_MOOD_ISSUES_DAILY_FREEZE",
     "KEY_AUTO_ORDER_ENABLED",
     "TRADE_DIRECTION_RESTRICT_ENABLED",

lib/env/env_ui_manifest.py

@@ -94,6 +94,7 @@ _SHARED_SECTIONS: list[dict[str, Any]] = [
             ("RISK_COOLING_HOURS_MANUAL", "手动平仓冷静(小时)", ""),
             ("RISK_COOLING_HOURS_MANUAL_JOURNAL", "复盘情绪冷静(小时)", ""),
             ("RISK_MANUAL_CLOSE_DAILY_LIMIT", "日手动平仓次数上限", ""),
+            ("RISK_DAILY_LOSS_LIMIT", "日亏损次数上限", "默认2;达限当日冻结开仓;0=不因亏损次数冻结"),
             ("RISK_MOOD_ISSUES_DAILY_FREEZE", "情绪标签日冻结", ""),
         ],
     },
@@ -197,6 +198,7 @@ _RUNTIME_ENV_DEFAULTS: dict[str, str] = {
     "RISK_COOLING_HOURS_MANUAL": "4",
     "RISK_COOLING_HOURS_MANUAL_JOURNAL": "1",
     "RISK_MANUAL_CLOSE_DAILY_LIMIT": "2",
+    "RISK_DAILY_LOSS_LIMIT": "2",
     "RISK_MOOD_ISSUES_DAILY_FREEZE": "true",
     "HEDGE_PLAN_SHOW_PERP_OPTIONS": "true",
     "HEDGE_PLAN_SHOW_OPTIONS_OPTIONS": "true",

lib/hub/amp_stats_lib.py

@@ -0,0 +1,833 @@
+"""中控振幅统计:OKX 指数(可降级永续)按时段切窗,点数口径.
+
+仅只读行情;不触及下单链路.
+"""
+from __future__ import annotations
+
+import csv
+import io
+import statistics
+import time
+from datetime import date, datetime, timedelta
+from typing import Any, Callable, Optional
+from zoneinfo import ZoneInfo
+
+import httpx
+
+APP_TZ = ZoneInfo("Asia/Shanghai")
+END_HOUR = 16
+EXCHANGE = "okx"
+TIMEFRAME = "1H"
+
+SYMBOLS: dict[str, dict[str, str]] = {
+    "eth": {
+        "label": "ETH",
+        "index_inst": "ETH-USD",
+        "swap_inst": "ETH-USDT-SWAP",
+    },
+    "btc": {
+        "label": "BTC",
+        "index_inst": "BTC-USD",
+        "swap_inst": "BTC-USDT-SWAP",
+    },
+}
+
+PERIOD_DAYS: dict[str, int] = {
+    "1m": 30,
+    "2m": 60,
+    "3m": 90,
+    "6m": 180,
+    "1y": 365,
+}
+
+OKX_INDEX_CANDLES = "https://www.okx.com/api/v5/market/index-candles"
+OKX_HISTORY_INDEX_CANDLES = "https://www.okx.com/api/v5/market/history-index-candles"
+OKX_SWAP_CANDLES = "https://www.okx.com/api/v5/market/candles"
+OKX_HISTORY_SWAP_CANDLES = "https://www.okx.com/api/v5/market/history-candles"
+
+
+def normalize_symbol(raw: str) -> str:
+    s = (raw or "").strip().lower()
+    if s in ("eth", "ethereum"):
+        return "eth"
+    if s in ("btc", "bitcoin"):
+        return "btc"
+    raise ValueError("symbol 仅支持 eth / btc")
+
+
+def resolve_sample_days(period: str, custom_days: Any = None) -> int:
+    p = (period or "2m").strip().lower()
+    if p == "custom":
+        try:
+            n = int(custom_days)
+        except (TypeError, ValueError):
+            raise ValueError("自定义天数无效") from None
+        return max(7, min(400, n))
+    if p not in PERIOD_DAYS:
+        raise ValueError("周期无效")
+    return PERIOD_DAYS[p]
+
+
+def window_bounds_for_settlement(settlement: date, start_hour: int) -> tuple[datetime, datetime]:
+    """返回 [start, end) 的本地时刻;end 为结算日 16:00."""
+    if not (0 <= int(start_hour) <= 23):
+        raise ValueError("起点须为 0-23 整点")
+    end = datetime(settlement.year, settlement.month, settlement.day, END_HOUR, 0, 0, tzinfo=APP_TZ)
+    sh = int(start_hour)
+    if sh >= END_HOUR:
+        prev = settlement - timedelta(days=1)
+        start = datetime(prev.year, prev.month, prev.day, sh, 0, 0, tzinfo=APP_TZ)
+    else:
+        start = datetime(settlement.year, settlement.month, settlement.day, sh, 0, 0, tzinfo=APP_TZ)
+    return start, end
+
+
+def list_settlement_dates(*, sample_days: int, now: Optional[datetime] = None) -> list[date]:
+    """最近 sample_days 个已收窗结算日(不含进行中的今天未到 16:00)."""
+    now = now or datetime.now(APP_TZ)
+    if now.tzinfo is None:
+        now = now.replace(tzinfo=APP_TZ)
+    else:
+        now = now.astimezone(APP_TZ)
+    today = now.date()
+    today_end = datetime(today.year, today.month, today.day, END_HOUR, 0, 0, tzinfo=APP_TZ)
+    latest = today if now >= today_end else today - timedelta(days=1)
+    return [latest - timedelta(days=i) for i in range(int(sample_days))]
+
+
+def _safe_float(v: Any) -> Optional[float]:
+    try:
+        if v is None or v == "":
+            return None
+        return float(v)
+    except (TypeError, ValueError):
+        return None
+
+
+def bars_to_map(bars: list[dict[str, Any]]) -> dict[int, dict[str, float]]:
+    """open_time_ms -> {o,h,l,c}."""
+    m: dict[int, dict[str, float]] = {}
+    for b in bars or []:
+        if not isinstance(b, dict):
+            continue
+        ts = b.get("ts")
+        if ts is None:
+            ts = b.get("open_time_ms")
+        try:
+            ts_i = int(ts)
+        except (TypeError, ValueError):
+            continue
+        o = _safe_float(b.get("o") if "o" in b else b.get("open"))
+        h = _safe_float(b.get("h") if "h" in b else b.get("high"))
+        l = _safe_float(b.get("l") if "l" in b else b.get("low"))
+        c = _safe_float(b.get("c") if "c" in b else b.get("close"))
+        if None in (o, h, l, c):
+            continue
+        m[ts_i] = {"o": float(o), "h": float(h), "l": float(l), "c": float(c)}
+    return m
+
+
+def compute_day_row(
+    settlement: date,
+    start_hour: int,
+    bar_map: dict[int, dict[str, float]],
+) -> Optional[dict[str, Any]]:
+    start, end = window_bounds_for_settlement(settlement, start_hour)
+    start_ms = int(start.timestamp() * 1000)
+    # 1H 棒覆盖 [T, T+1h);窗终点 16:00 用 15:00 棒的 close
+    last_bar_ms = int((end - timedelta(hours=1)).timestamp() * 1000)
+    if start_ms not in bar_map or last_bar_ms not in bar_map:
+        return None
+    opens = bar_map[start_ms]["o"]
+    close = bar_map[last_bar_ms]["c"]
+    hi = bar_map[start_ms]["h"]
+    lo = bar_map[start_ms]["l"]
+    t = start_ms
+    while t <= last_bar_ms:
+        b = bar_map.get(t)
+        if b:
+            hi = max(hi, b["h"])
+            lo = min(lo, b["l"])
+        t += 3600 * 1000
+    up = hi - opens
+    down = opens - lo
+    amp = hi - lo
+    change = close - opens
+    wd = settlement.weekday()  # Mon=0 … Sun=6
+    is_we = wd >= 5
+    return {
+        "settlement_day": settlement.isoformat(),
+        "window_start": start.strftime("%Y-%m-%d %H:%M"),
+        "window_end": end.strftime("%Y-%m-%d %H:%M"),
+        "weekday": wd,
+        "weekday_label": "六" if wd == 5 else ("日" if wd == 6 else ""),
+        "is_weekend": is_we,
+        "open": round(opens, 4),
+        "high": round(hi, 4),
+        "low": round(lo, 4),
+        "close": round(close, 4),
+        "up_points": round(up, 4),
+        "down_points": round(down, 4),
+        "amplitude": round(amp, 4),
+        "change": round(change, 4),
+    }
+
+
+def normalize_straddle_premium(raw: Any) -> Optional[float]:
+    """双边权利金(点数).空/≤0 表示不做跨式对照."""
+    if raw is None or raw == "":
+        return None
+    try:
+        v = float(raw)
+    except (TypeError, ValueError):
+        raise ValueError("双边权利金须为数字") from None
+    if v <= 0:
+        return None
+    return v
+
+
+def normalize_take_profit(raw: Any) -> Optional[float]:
+    """止盈点.空/≤0 表示不止盈,有效波动用 |涨跌|."""
+    if raw is None or raw == "":
+        return None
+    try:
+        v = float(raw)
+    except (TypeError, ValueError):
+        raise ValueError("止盈点须为数字") from None
+    if v <= 0:
+        return None
+    return v
+
+
+def normalize_weekend_filter(raw: Any) -> str:
+    """all | exclude | only;默认全部."""
+    s = (str(raw) if raw is not None else "all").strip().lower()
+    if s in ("", "all", "全部"):
+        return "all"
+    if s in ("exclude", "exclude_weekend", "no_weekend", "排除周末"):
+        return "exclude"
+    if s in ("only", "weekend_only", "only_weekend", "仅周末"):
+        return "only"
+    raise ValueError("周末筛选须为 all / exclude / only")
+
+
+def filter_weekend_rows(rows: list[dict[str, Any]], weekend_filter: Any = "all") -> list[dict[str, Any]]:
+    mode = normalize_weekend_filter(weekend_filter)
+    if mode == "all":
+        return list(rows or [])
+    out: list[dict[str, Any]] = []
+    for r in rows or []:
+        is_we = bool(r.get("is_weekend"))
+        if "is_weekend" not in r and r.get("settlement_day"):
+            try:
+                is_we = date.fromisoformat(str(r["settlement_day"])).weekday() >= 5
+            except ValueError:
+                is_we = False
+        if mode == "exclude" and is_we:
+            continue
+        if mode == "only" and not is_we:
+            continue
+        out.append(r)
+    return out
+
+
+def effective_move_points(row: dict[str, Any], take_profit: Optional[float]) -> float:
+    """触达止盈(≥)用止盈点,否则用 |涨跌|."""
+    abs_chg = abs(float(row.get("change") or 0))
+    if take_profit is None:
+        return abs_chg
+    tp = float(take_profit)
+    up = float(row.get("up_points") or 0)
+    down = float(row.get("down_points") or 0)
+    if up >= tp or down >= tp:
+        return tp
+    return abs_chg
+
+
+def enrich_rows_pnl(
+    rows: list[dict[str, Any]],
+    *,
+    straddle_premium: Optional[float] = None,
+    take_profit: Optional[float] = None,
+) -> list[dict[str, Any]]:
+    """为日表附加有效波动 / 是否触达止盈 / 收益(有权利金时)."""
+    prem = normalize_straddle_premium(straddle_premium)
+    tp = normalize_take_profit(take_profit)
+    out: list[dict[str, Any]] = []
+    for r in rows or []:
+        item = dict(r)
+        if "is_weekend" not in item and item.get("settlement_day"):
+            try:
+                wd = date.fromisoformat(str(item["settlement_day"])).weekday()
+                item["weekday"] = wd
+                item["weekday_label"] = "六" if wd == 5 else ("日" if wd == 6 else "")
+                item["is_weekend"] = wd >= 5
+            except ValueError:
+                item.setdefault("weekday_label", "")
+                item.setdefault("is_weekend", False)
+        move = effective_move_points(item, tp)
+        hit = False
+        if tp is not None:
+            hit = float(item.get("up_points") or 0) >= tp or float(item.get("down_points") or 0) >= tp
+        item["effective_move"] = round(move, 4)
+        item["take_profit_hit"] = hit
+        item["profit"] = round(move - prem, 4) if prem is not None else None
+        out.append(item)
+    return out
+
+
+def straddle_long_stats(
+    rows: list[dict[str, Any]],
+    premium: float,
+    *,
+    take_profit: Any = None,
+) -> dict[str, Any]:
+    """买跨:越过权利金用严格 >;收益=有效波动−权利金(止盈≥触达用止盈点,否则|涨跌|)."""
+    prem = float(premium)
+    if prem <= 0:
+        raise ValueError("双边权利金须 > 0")
+    tp = normalize_take_profit(take_profit)
+    enriched = enrich_rows_pnl(rows, straddle_premium=prem, take_profit=tp)
+    if not enriched:
+        return {
+            "side": "long_straddle",
+            "premium": prem,
+            "take_profit": tp,
+            "sample_count": 0,
+            "up_exceed_days": 0,
+            "up_exceed_ratio": None,
+            "down_exceed_days": 0,
+            "down_exceed_ratio": None,
+            "abs_change_exceed_days": 0,
+            "abs_change_exceed_ratio": None,
+            "tp_hit_days": 0,
+            "tp_hit_ratio": None,
+            "pnl_total": None,
+            "pnl_avg": None,
+            "win_days": 0,
+            "win_ratio": None,
+            "pnl_max": None,
+            "pnl_min": None,
+        }
+    n = len(enriched)
+    up_ex = sum(1 for r in enriched if float(r["up_points"]) > prem)
+    down_ex = sum(1 for r in enriched if float(r["down_points"]) > prem)
+    abs_ex = sum(1 for r in enriched if abs(float(r["change"])) > prem)
+    tp_hits = sum(1 for r in enriched if r.get("take_profit_hit"))
+    pnls = [float(r["profit"]) for r in enriched if r.get("profit") is not None]
+    win = sum(1 for p in pnls if p > 0)
+    return {
+        "side": "long_straddle",
+        "premium": round(prem, 4),
+        "take_profit": round(tp, 4) if tp is not None else None,
+        "sample_count": n,
+        "up_exceed_days": up_ex,
+        "up_exceed_ratio": round(up_ex / n, 4),
+        "down_exceed_days": down_ex,
+        "down_exceed_ratio": round(down_ex / n, 4),
+        "abs_change_exceed_days": abs_ex,
+        "abs_change_exceed_ratio": round(abs_ex / n, 4),
+        "tp_hit_days": tp_hits,
+        "tp_hit_ratio": round(tp_hits / n, 4) if tp is not None else None,
+        "pnl_total": round(sum(pnls), 4),
+        "pnl_avg": round(statistics.fmean(pnls), 4),
+        "win_days": win,
+        "win_ratio": round(win / n, 4),
+        "pnl_max": round(max(pnls), 4),
+        "pnl_min": round(min(pnls), 4),
+    }
+
+
+def summarize_rows(
+    rows: list[dict[str, Any]],
+    *,
+    straddle_premium: Any = None,
+    take_profit: Any = None,
+) -> dict[str, Any]:
+    if not rows:
+        out = {
+            "sample_count": 0,
+            "max_amplitude": None,
+            "max_amplitude_day": None,
+            "avg_amplitude": None,
+            "median_amplitude": None,
+            "max_up_points": None,
+            "avg_up_points": None,
+            "max_down_points": None,
+            "avg_down_points": None,
+            "up_day_ratio": None,
+            "down_day_ratio": None,
+            "straddle": None,
+        }
+        prem = normalize_straddle_premium(straddle_premium)
+        if prem is not None:
+            out["straddle"] = straddle_long_stats([], prem, take_profit=take_profit)
+        return out
+    amps = [float(r["amplitude"]) for r in rows]
+    ups = [float(r["up_points"]) for r in rows]
+    downs = [float(r["down_points"]) for r in rows]
+    max_amp = max(amps)
+    max_amp_day = next(r["settlement_day"] for r in rows if float(r["amplitude"]) == max_amp)
+    up_days = sum(1 for r in rows if float(r["change"]) > 0)
+    down_days = sum(1 for r in rows if float(r["change"]) < 0)
+    n = len(rows)
+    out: dict[str, Any] = {
+        "sample_count": n,
+        "max_amplitude": round(max_amp, 4),
+        "max_amplitude_day": max_amp_day,
+        "avg_amplitude": round(statistics.fmean(amps), 4),
+        "median_amplitude": round(statistics.median(amps), 4),
+        "max_up_points": round(max(ups), 4),
+        "avg_up_points": round(statistics.fmean(ups), 4),
+        "max_down_points": round(max(downs), 4),
+        "avg_down_points": round(statistics.fmean(downs), 4),
+        "up_day_ratio": round(up_days / n, 4),
+        "down_day_ratio": round(down_days / n, 4),
+        "straddle": None,
+    }
+    prem = normalize_straddle_premium(straddle_premium)
+    if prem is not None:
+        out["straddle"] = straddle_long_stats(rows, prem, take_profit=take_profit)
+    return out
+
+
+def _parse_okx_candle_row(row: list) -> Optional[dict[str, Any]]:
+    if not row or len(row) < 5:
+        return None
+    try:
+        ts = int(row[0])
+        o, h, l, c = float(row[1]), float(row[2]), float(row[3]), float(row[4])
+    except (TypeError, ValueError, IndexError):
+        return None
+    return {"ts": ts, "o": o, "h": h, "l": l, "c": c}
+
+
+def _okx_get_json(
+    client: httpx.Client,
+    url: str,
+    params: dict[str, str],
+    *,
+    retries: int = 8,
+) -> dict[str, Any]:
+    """GET OKX 公共行情;遇 429 指数退避重试."""
+    last_err: Optional[BaseException] = None
+    for attempt in range(max(1, int(retries))):
+        try:
+            r = client.get(url, params=params)
+            if r.status_code == 429:
+                wait = min(12.0, 0.7 * (2**attempt))
+                time.sleep(wait)
+                last_err = httpx.HTTPStatusError(
+                    f"429 Too Many Requests for url '{r.url}'",
+                    request=r.request,
+                    response=r,
+                )
+                continue
+            r.raise_for_status()
+            body = r.json()
+            if not isinstance(body, dict):
+                raise RuntimeError("OKX 返回非对象 JSON")
+            return body
+        except httpx.HTTPStatusError as exc:
+            status = exc.response.status_code if exc.response is not None else None
+            if status == 429 and attempt + 1 < retries:
+                wait = min(12.0, 0.7 * (2**attempt))
+                time.sleep(wait)
+                last_err = exc
+                continue
+            raise
+        except httpx.TransportError as exc:
+            if attempt + 1 < retries:
+                time.sleep(min(8.0, 0.5 * (2**attempt)))
+                last_err = exc
+                continue
+            raise
+    if last_err is not None:
+        raise last_err
+    raise RuntimeError("OKX 请求失败")
+
+
+def fetch_okx_candles(
+    *,
+    url: str,
+    inst_id: str,
+    since_ms: int,
+    until_ms: int,
+    bar: str = "1H",
+    client: Optional[httpx.Client] = None,
+    timeout: float = 30.0,
+    history_url: Optional[str] = None,
+    max_pages: int = 200,
+    page_pause_sec: float = 0.12,
+    history_page_pause_sec: float = 0.22,
+) -> list[dict[str, Any]]:
+    """拉取 [since_ms, until_ms] 覆盖的 K 线(含边界).
+
+    OKX 近期接口约仅 1440 根;更早需 history_* 端点续拉.
+    分页带间隔,429 自动退避重试.
+    """
+    own = client is None
+    client = client or httpx.Client(
+        timeout=timeout,
+        trust_env=False,
+        headers={"User-Agent": "crypto_monitor-amp-stats/1.0"},
+    )
+    try:
+        out: dict[int, dict[str, Any]] = {}
+        after: Optional[str] = None
+        active_url = url
+        switched_history = False
+        for page_i in range(max(20, int(max_pages))):
+            if page_i > 0:
+                pause = history_page_pause_sec if switched_history or "history" in active_url else page_pause_sec
+                if pause > 0:
+                    time.sleep(pause)
+            params: dict[str, str] = {"instId": inst_id, "bar": bar, "limit": "100"}
+            if after:
+                params["after"] = after
+            body = _okx_get_json(client, active_url, params)
+            if str(body.get("code") or "") not in ("0", "0.0", ""):
+                raise RuntimeError(body.get("msg") or f"OKX error {body.get('code')}")
+            data = body.get("data") or []
+            if not data:
+                # 近期接口到头 → 切历史端点再试
+                if history_url and not switched_history and after is not None:
+                    active_url = history_url
+                    switched_history = True
+                    time.sleep(max(history_page_pause_sec, 0.35))
+                    continue
+                break
+            oldest_ts = None
+            for row in data:
+                parsed = _parse_okx_candle_row(row)
+                if not parsed:
+                    continue
+                ts = int(parsed["ts"])
+                oldest_ts = ts if oldest_ts is None else min(oldest_ts, ts)
+                if ts < since_ms - 3600 * 1000:
+                    continue
+                if ts > until_ms + 3600 * 1000:
+                    continue
+                out[ts] = parsed
+            if oldest_ts is None:
+                break
+            if oldest_ts <= since_ms:
+                break
+            # 无新进度时避免死循环
+            if after is not None and str(oldest_ts) == after:
+                if history_url and not switched_history:
+                    active_url = history_url
+                    switched_history = True
+                    time.sleep(max(history_page_pause_sec, 0.35))
+                    continue
+                break
+            after = str(oldest_ts)
+            # 近期接口返回变少且仍未覆盖 since → 切历史
+            if (
+                history_url
+                and not switched_history
+                and len(data) < 100
+                and oldest_ts > since_ms
+            ):
+                active_url = history_url
+                switched_history = True
+                time.sleep(max(history_page_pause_sec, 0.35))
+        return [out[k] for k in sorted(out.keys())]
+    finally:
+        if own:
+            client.close()
+
+
+def fetch_symbol_bars(
+    symbol: str,
+    *,
+    since_ms: int,
+    until_ms: int,
+    fetch_fn: Optional[Callable[..., list[dict[str, Any]]]] = None,
+) -> tuple[list[dict[str, Any]], str, str]:
+    """返回 (bars, price_source_label, inst_id)."""
+    key = normalize_symbol(symbol)
+    meta = SYMBOLS[key]
+    if fetch_fn:
+        bars = fetch_fn(inst_id=meta["index_inst"], since_ms=since_ms, until_ms=until_ms)
+        return bars, f"okx_index:{meta['index_inst']}", meta["index_inst"]
+
+    index_err: Optional[BaseException] = None
+    try:
+        bars = fetch_okx_candles(
+            url=OKX_INDEX_CANDLES,
+            history_url=OKX_HISTORY_INDEX_CANDLES,
+            inst_id=meta["index_inst"],
+            since_ms=since_ms,
+            until_ms=until_ms,
+        )
+        if bars:
+            return bars, f"okx_index:{meta['index_inst']}", meta["index_inst"]
+    except Exception as exc:
+        index_err = exc
+        # 指数侧已触发限频时先冷却,再降级永续,避免连环 429
+        time.sleep(1.2)
+
+    try:
+        bars = fetch_okx_candles(
+            url=OKX_SWAP_CANDLES,
+            history_url=OKX_HISTORY_SWAP_CANDLES,
+            inst_id=meta["swap_inst"],
+            since_ms=since_ms,
+            until_ms=until_ms,
+        )
+    except Exception as exc:
+        detail = f"index={index_err}; swap={exc}" if index_err else str(exc)
+        raise RuntimeError(f"OKX K线拉取失败({detail})") from exc
+    if not bars:
+        detail = f"index={index_err}" if index_err else "empty"
+        raise RuntimeError(f"OKX 指数与永续 K 线均无数据({detail})")
+    return bars, f"okx_swap:{meta['swap_inst']}", meta["swap_inst"]
+
+
+def compute_amp_stats(
+    *,
+    symbol: str = "eth",
+    start_hour: int = 16,
+    period: str = "2m",
+    custom_days: Any = None,
+    straddle_premium: Any = None,
+    take_profit: Any = None,
+    weekend_filter: Any = "all",
+    now: Optional[datetime] = None,
+    fetch_fn: Optional[Callable[..., list[dict[str, Any]]]] = None,
+) -> dict[str, Any]:
+    key = normalize_symbol(symbol)
+    sh = int(start_hour)
+    if sh < 0 or sh > 23:
+        raise ValueError("起点须为 0-23 整点")
+    prem = normalize_straddle_premium(straddle_premium)
+    tp = normalize_take_profit(take_profit)
+    we_mode = normalize_weekend_filter(weekend_filter)
+    sample_days = resolve_sample_days(period, custom_days)
+    settlements = list_settlement_dates(sample_days=sample_days, now=now)
+    if not settlements:
+        raise RuntimeError("无可用结算日")
+    # 最远窗起点
+    oldest = settlements[-1]
+    newest = settlements[0]
+    start0, _ = window_bounds_for_settlement(oldest, sh)
+    _, end1 = window_bounds_for_settlement(newest, sh)
+    since_ms = int(start0.timestamp() * 1000)
+    until_ms = int(end1.timestamp() * 1000)
+    bars, price_source, inst_id = fetch_symbol_bars(
+        key, since_ms=since_ms, until_ms=until_ms, fetch_fn=fetch_fn
+    )
+    bar_map = bars_to_map(bars)
+    rows_all: list[dict[str, Any]] = []
+    missing: list[str] = []
+    for d in settlements:
+        row = compute_day_row(d, sh, bar_map)
+        if row is None:
+            missing.append(d.isoformat())
+            continue
+        rows_all.append(row)
+    return build_amp_result(
+        rows_all=rows_all,
+        symbol_key=key,
+        start_hour=sh,
+        period=period,
+        sample_days=sample_days,
+        straddle_premium=prem,
+        take_profit=tp,
+        weekend_filter=we_mode,
+        price_source=price_source,
+        inst_id=inst_id,
+        missing=missing,
+    )
+
+
+def build_amp_result(
+    *,
+    rows_all: list[dict[str, Any]],
+    symbol_key: str,
+    start_hour: int,
+    period: str,
+    sample_days: int,
+    straddle_premium: Any = None,
+    take_profit: Any = None,
+    weekend_filter: Any = "all",
+    price_source: str = "",
+    inst_id: str = "",
+    missing: Optional[list[str]] = None,
+) -> dict[str, Any]:
+    prem = normalize_straddle_premium(straddle_premium)
+    tp = normalize_take_profit(take_profit)
+    we_mode = normalize_weekend_filter(weekend_filter)
+    filtered = filter_weekend_rows(rows_all, we_mode)
+    rows = enrich_rows_pnl(filtered, straddle_premium=prem, take_profit=tp)
+    summary = summarize_rows(rows, straddle_premium=prem, take_profit=tp)
+    if period == "custom" or str(period).startswith("custom:"):
+        period_label = period if str(period).startswith("custom:") else f"custom:{sample_days}"
+    else:
+        period_label = str(period)
+    miss = missing or []
+    return {
+        "ok": True,
+        "exchange": EXCHANGE,
+        "symbol": symbol_key,
+        "symbol_label": SYMBOLS[symbol_key]["label"],
+        "start_hour": start_hour,
+        "end_hour": END_HOUR,
+        "period": period_label,
+        "sample_days_requested": sample_days,
+        "straddle_premium": prem,
+        "take_profit": tp,
+        "weekend_filter": we_mode,
+        "timeframe": TIMEFRAME,
+        "price_source": price_source,
+        "inst_id": inst_id,
+        "timezone": "Asia/Shanghai",
+        "rows_all": rows_all,
+        "rows": rows,
+        "summary": summary,
+        "missing_days": miss[:30],
+        "missing_count": len(miss),
+    }
+
+
+def reframe_amp_stats(
+    *,
+    rows_all: list[dict[str, Any]],
+    symbol: str = "eth",
+    start_hour: int = 16,
+    period: str = "2m",
+    sample_days: int = 60,
+    straddle_premium: Any = None,
+    take_profit: Any = None,
+    weekend_filter: Any = "all",
+    price_source: str = "",
+    inst_id: str = "",
+    missing: Optional[list[str]] = None,
+) -> dict[str, Any]:
+    """已有日表上改周末/权利金/止盈,不拉 K 线."""
+    key = normalize_symbol(symbol)
+    return build_amp_result(
+        rows_all=list(rows_all or []),
+        symbol_key=key,
+        start_hour=int(start_hour),
+        period=period,
+        sample_days=int(sample_days or 60),
+        straddle_premium=straddle_premium,
+        take_profit=take_profit,
+        weekend_filter=weekend_filter,
+        price_source=price_source,
+        inst_id=inst_id,
+        missing=missing,
+    )
+
+
+def rows_page(rows: list[dict[str, Any]], *, page: int = 1, page_size: int = 20) -> dict[str, Any]:
+    page = max(1, int(page or 1))
+    page_size = max(5, min(100, int(page_size or 20)))
+    total = len(rows)
+    start = (page - 1) * page_size
+    chunk = rows[start : start + page_size]
+    return {
+        "page": page,
+        "page_size": page_size,
+        "total": total,
+        "total_pages": max(1, (total + page_size - 1) // page_size) if total else 1,
+        "rows": chunk,
+    }
+
+
+def build_export_csv(payload: dict[str, Any]) -> str:
+    buf = io.StringIO()
+    # Excel 友好 BOM
+    buf.write("\ufeff")
+    w = csv.writer(buf)
+    s = payload.get("summary") or {}
+    w.writerow(["【统计摘要】"])
+    w.writerow(["交易所", payload.get("exchange")])
+    w.writerow(["标的", payload.get("symbol_label")])
+    w.writerow(["价源", payload.get("price_source")])
+    w.writerow(["起点整点", f"{payload.get('start_hour')}:00"])
+    w.writerow(["终点", f"{payload.get('end_hour')}:00"])
+    w.writerow(["周期", payload.get("period")])
+    w.writerow(["周末筛选", payload.get("weekend_filter")])
+    w.writerow(["样本数", s.get("sample_count")])
+    w.writerow(["最大振幅", s.get("max_amplitude"), "日期", s.get("max_amplitude_day")])
+    w.writerow(["振幅均值", s.get("avg_amplitude"), "中位数", s.get("median_amplitude")])
+    w.writerow(["开→高最大", s.get("max_up_points"), "均值", s.get("avg_up_points")])
+    w.writerow(["开→低最大", s.get("max_down_points"), "均值", s.get("avg_down_points")])
+    w.writerow(["上涨窗占比", s.get("up_day_ratio"), "下跌窗占比", s.get("down_day_ratio")])
+    st = s.get("straddle") or {}
+    if st:
+        w.writerow([])
+        w.writerow(["【买跨对照·双边权利金】", st.get("premium"), "止盈点", st.get("take_profit")])
+        w.writerow(["开→高超过权利金", st.get("up_exceed_days"), "占比", st.get("up_exceed_ratio")])
+        w.writerow(["开→低超过权利金", st.get("down_exceed_days"), "占比", st.get("down_exceed_ratio")])
+        w.writerow(["|涨跌|超过权利金", st.get("abs_change_exceed_days"), "占比", st.get("abs_change_exceed_ratio")])
+        if st.get("take_profit") is not None:
+            w.writerow(["触达止盈天数", st.get("tp_hit_days"), "占比", st.get("tp_hit_ratio")])
+        w.writerow(
+            [
+                "买跨点数盈亏合计",
+                st.get("pnl_total"),
+                "日均",
+                st.get("pnl_avg"),
+                "赚钱天数",
+                st.get("win_days"),
+                "胜率",
+                st.get("win_ratio"),
+            ]
+        )
+        w.writerow(["单日最大赚", st.get("pnl_max"), "单日最大亏", st.get("pnl_min")])
+    w.writerow([])
+    w.writerow(["【日表明细】"])
+    w.writerow(
+        [
+            "结算日",
+            "星期",
+            "周末",
+            "窗起点",
+            "窗终点",
+            "开盘",
+            "最高",
+            "最低",
+            "收盘",
+            "开→高",
+            "开→低",
+            "振幅",
+            "涨跌值",
+            "有效波动",
+            "触达止盈",
+            "收益",
+        ]
+    )
+    for r in payload.get("rows") or []:
+        w.writerow(
+            [
+                r.get("settlement_day"),
+                r.get("weekday_label") or "",
+                "是" if r.get("is_weekend") else "否",
+                r.get("window_start"),
+                r.get("window_end"),
+                r.get("open"),
+                r.get("high"),
+                r.get("low"),
+                r.get("close"),
+                r.get("up_points"),
+                r.get("down_points"),
+                r.get("amplitude"),
+                r.get("change"),
+                r.get("effective_move"),
+                "是" if r.get("take_profit_hit") else "否",
+                r.get("profit"),
+            ]
+        )
+    return buf.getvalue()
+
+
+def export_filename(payload: dict[str, Any]) -> str:
+    sym = (payload.get("symbol") or "eth").lower()
+    sh = int(payload.get("start_hour") or 16)
+    period = str(payload.get("period") or "2m").replace(":", "")
+    day = datetime.now(APP_TZ).strftime("%Y%m%d")
+    return f"okx_{sym}_amp_{sh}to16_{period}_{day}.csv"

lib/hub/hub_compare_lib.py

@@ -0,0 +1,400 @@
+"""中控策略对比:同风险额下 合约 / 单期权 / 期期7:3 情景测算(纯函数)."""
+
+from __future__ import annotations
+
+import math
+from typing import Any, Optional
+
+
+def _f(v: Any) -> Optional[float]:
+    if v is None or v == "":
+        return None
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return None
+
+
+def default_contract_size(base: str) -> float:
+    """OKX 线性永续常用面值(币/张);与计算器缺省一致."""
+    b = (base or "ETH").strip().upper()
+    return 0.01
+
+
+def default_ct_mult(base: str) -> float:
+    return 0.01
+
+
+def floor_sheets(n: float, step: float = 1.0) -> float:
+    if n is None or not math.isfinite(n) or n <= 0:
+        return 0.0
+    s = float(step) if step and step > 0 else 1.0
+    return math.floor(n / s + 1e-12) * s
+
+
+def option_unit_cost(*, ask: float, ct_mult: float) -> float:
+    return float(ask) * float(ct_mult or 0.01)
+
+
+def option_intrinsic_value(
+    *,
+    opt_type: str,
+    strike: float,
+    spot: float,
+    sheets: float,
+    ct_mult: float,
+) -> float:
+    o = (opt_type or "").strip().upper()
+    k = float(strike)
+    s = float(spot)
+    if o == "C":
+        intrinsic = max(0.0, s - k)
+    elif o == "P":
+        intrinsic = max(0.0, k - s)
+    else:
+        intrinsic = 0.0
+    return intrinsic * float(sheets) * float(ct_mult or 0.01)
+
+
+def option_pnl_at_spot(
+    *,
+    opt_type: str,
+    strike: float,
+    spot: float,
+    sheets: float,
+    ct_mult: float,
+    premium_paid: float,
+) -> float:
+    return option_intrinsic_value(
+        opt_type=opt_type,
+        strike=strike,
+        spot=spot,
+        sheets=sheets,
+        ct_mult=ct_mult,
+    ) - float(premium_paid)
+
+
+def perp_pnl(
+    *,
+    direction: str,
+    entry: float,
+    exit_px: float,
+    contracts: float,
+    contract_size: float,
+) -> float:
+    coins = float(contracts) * float(contract_size or 0.01)
+    d = (direction or "long").strip().lower()
+    if d == "short":
+        return (float(entry) - float(exit_px)) * coins
+    return (float(exit_px) - float(entry)) * coins
+
+
+def _validate_common(inp: dict[str, Any]) -> Optional[str]:
+    base = str(inp.get("base") or "ETH").strip().upper()
+    if base not in ("ETH", "BTC"):
+        return "标的仅支持 ETH / BTC"
+    direction = str(inp.get("direction") or "long").strip().lower()
+    if direction not in ("long", "short"):
+        return "方向须为 long / short"
+    s0 = _f(inp.get("entry"))
+    sl = _f(inp.get("sl"))
+    tp = _f(inp.get("tp"))
+    risk = _f(inp.get("risk_u"))
+    if s0 is None or s0 <= 0:
+        return "请填写有效入场价"
+    if sl is None or sl <= 0:
+        return "请填写有效止损价"
+    if tp is None or tp <= 0:
+        return "请填写有效止盈价"
+    if risk is None or risk <= 0:
+        return "请填写有效风险额 R"
+    if direction == "long" and not (sl < s0 < tp):
+        return "做多须满足 止损 < 入场 < 止盈"
+    if direction == "short" and not (tp < s0 < sl):
+        return "做空须满足 止盈 < 入场 < 止损"
+    return None
+
+
+def _calc_perp(inp: dict[str, Any], *, contract_size: float) -> dict[str, Any]:
+    direction = str(inp.get("direction") or "long").strip().lower()
+    s0 = float(inp["entry"])
+    sl = float(inp["sl"])
+    tp = float(inp["tp"])
+    risk = float(inp["risk_u"])
+    per_sheet_sl = abs(s0 - sl) * contract_size
+    sheets = floor_sheets(risk / per_sheet_sl) if per_sheet_sl > 0 else 0.0
+    actual_sl_loss = abs(perp_pnl(
+        direction=direction, entry=s0, exit_px=sl, contracts=sheets, contract_size=contract_size
+    ))
+    tp_pnl = perp_pnl(
+        direction=direction, entry=s0, exit_px=tp, contracts=sheets, contract_size=contract_size
+    )
+    # 路径 C:本单已止损 −actual;踏空未拿到 = 原止盈盈利
+    path_a = round(tp_pnl, 4)
+    path_b = round(-actual_sl_loss if sheets > 0 else -risk, 4)
+    path_c_realized = path_b
+    path_c_missed = path_a
+    return {
+        "kind": "perp",
+        "sheets": sheets,
+        "contract_size": contract_size,
+        "per_sheet_sl_u": round(per_sheet_sl, 6),
+        "risk_used_u": round(actual_sl_loss, 4),
+        "path_a_tp": path_a,
+        "path_b_sl": path_b,
+        "path_c_realized": path_c_realized,
+        "path_c_missed": path_c_missed,
+        "path_c_note": "本单已止损;踏空未拿到原止盈空间",
+        "worst_u": path_b,
+    }
+
+
+def _calc_single_option(inp: dict[str, Any], *, ct_mult: float) -> dict[str, Any]:
+    direction = str(inp.get("direction") or "long").strip().lower()
+    risk = float(inp["risk_u"])
+    tp = float(inp.get("tp_opt") if inp.get("tp_opt") not in (None, "") else inp["tp"])
+    sl = float(inp["sl"])
+    opt = inp.get("option") if isinstance(inp.get("option"), dict) else {}
+    default_type = "C" if direction == "long" else "P"
+    opt_type = str(opt.get("opt_type") or default_type).strip().upper()
+    if opt_type not in ("C", "P"):
+        opt_type = default_type
+    strike = _f(opt.get("strike"))
+    ask = _f(opt.get("ask"))
+    if strike is None or strike <= 0:
+        return {"ok": False, "msg": "请填写单期权行权价"}
+    if ask is None or ask <= 0:
+        return {"ok": False, "msg": "请填写单期权卖一价"}
+    unit = option_unit_cost(ask=ask, ct_mult=ct_mult)
+    sheets = floor_sheets(risk / unit) if unit > 0 else 0.0
+    premium = option_unit_cost(ask=ask, ct_mult=ct_mult) * sheets if sheets else 0.0
+    # 若张数为 0
+    path_a = option_pnl_at_spot(
+        opt_type=opt_type, strike=strike, spot=tp, sheets=sheets, ct_mult=ct_mult, premium_paid=premium
+    )
+    path_b_at_sl = option_pnl_at_spot(
+        opt_type=opt_type, strike=strike, spot=sl, sheets=sheets, ct_mult=ct_mult, premium_paid=premium
+    )
+    path_b_worst = -premium
+    # 踏空路径:合约被洗后标的仍到 TP,期权仍持有 → 同止盈
+    path_c = path_a
+    return {
+        "ok": True,
+        "kind": "option",
+        "opt_type": opt_type,
+        "strike": strike,
+        "ask": ask,
+        "ct_mult": ct_mult,
+        "sheets": sheets,
+        "unit_cost_u": round(unit, 6),
+        "premium_u": round(premium, 4),
+        "path_a_tp": round(path_a, 4),
+        "path_b_sl": round(path_b_at_sl, 4),
+        "path_b_worst": round(path_b_worst, 4),
+        "path_c_hold_to_tp": round(path_c, 4),
+        "path_c_note": "合约踏空路径下期权仍持有至目标价(内在近似)",
+        "worst_u": round(path_b_worst, 4),
+    }
+
+
+def _calc_hedge(inp: dict[str, Any], *, ct_mult: float) -> dict[str, Any]:
+    direction = str(inp.get("direction") or "long").strip().lower()
+    risk = float(inp["risk_u"])
+    tp = float(inp.get("tp_hedge") if inp.get("tp_hedge") not in (None, "") else inp["tp"])
+    sl = float(inp["sl"])
+    hedge = inp.get("hedge") if isinstance(inp.get("hedge"), dict) else {}
+    main_default = "C" if direction == "long" else "P"
+    side_default = "P" if direction == "long" else "C"
+    main = hedge.get("main") if isinstance(hedge.get("main"), dict) else {}
+    side = hedge.get("side") if isinstance(hedge.get("side"), dict) else {}
+    main_type = str(main.get("opt_type") or main_default).strip().upper()
+    side_type = str(side.get("opt_type") or side_default).strip().upper()
+    if main_type not in ("C", "P"):
+        main_type = main_default
+    if side_type not in ("C", "P"):
+        side_type = side_default
+    main_k = _f(main.get("strike"))
+    main_ask = _f(main.get("ask"))
+    side_k = _f(side.get("strike"))
+    side_ask = _f(side.get("ask"))
+    if None in (main_k, main_ask, side_k, side_ask) or min(
+        main_k or 0, main_ask or 0, side_k or 0, side_ask or 0
+    ) <= 0:
+        return {"ok": False, "msg": "请填写期期对冲两腿的行权价与卖一"}
+    main_budget = 0.7 * risk
+    side_budget = 0.3 * risk
+    main_unit = option_unit_cost(ask=float(main_ask), ct_mult=ct_mult)
+    side_unit = option_unit_cost(ask=float(side_ask), ct_mult=ct_mult)
+    main_sheets = floor_sheets(main_budget / main_unit) if main_unit > 0 else 0.0
+    side_sheets = floor_sheets(side_budget / side_unit) if side_unit > 0 else 0.0
+    main_prem = main_unit * main_sheets
+    side_prem = side_unit * side_sheets
+    premium = main_prem + side_prem
+
+    def combo_at(spot: float) -> float:
+        a = option_pnl_at_spot(
+            opt_type=main_type,
+            strike=float(main_k),
+            spot=spot,
+            sheets=main_sheets,
+            ct_mult=ct_mult,
+            premium_paid=main_prem,
+        )
+        b = option_pnl_at_spot(
+            opt_type=side_type,
+            strike=float(side_k),
+            spot=spot,
+            sheets=side_sheets,
+            ct_mult=ct_mult,
+            premium_paid=side_prem,
+        )
+        return a + b
+
+    path_a = combo_at(tp)
+    path_b_at_sl = combo_at(sl)
+    path_b_worst = -premium
+    path_c = path_a
+    return {
+        "ok": True,
+        "kind": "hedge",
+        "ratio": "7:3",
+        "ct_mult": ct_mult,
+        "main": {
+            "opt_type": main_type,
+            "strike": main_k,
+            "ask": main_ask,
+            "sheets": main_sheets,
+            "premium_u": round(main_prem, 4),
+            "budget_u": round(main_budget, 4),
+        },
+        "side": {
+            "opt_type": side_type,
+            "strike": side_k,
+            "ask": side_ask,
+            "sheets": side_sheets,
+            "premium_u": round(side_prem, 4),
+            "budget_u": round(side_budget, 4),
+        },
+        "premium_u": round(premium, 4),
+        "path_a_tp": round(path_a, 4),
+        "path_b_sl": round(path_b_at_sl, 4),
+        "path_b_worst": round(path_b_worst, 4),
+        "path_c_hold_to_tp": round(path_c, 4),
+        "path_c_note": "合约踏空路径下对冲组合仍持有至目标价(内在近似)",
+        "worst_u": round(path_b_worst, 4),
+    }
+
+
+def recommend(perp: dict[str, Any], opt: dict[str, Any], hedge: dict[str, Any], risk: float) -> dict[str, Any]:
+    """可解释规则推荐."""
+    candidates: list[tuple[str, float, dict[str, Any]]] = []
+    if perp and perp.get("sheets", 0) > 0:
+        candidates.append(("合约", float(perp.get("path_a_tp") or 0), perp))
+    if opt and opt.get("ok") and opt.get("sheets", 0) > 0:
+        candidates.append(("单期权", float(opt.get("path_a_tp") or 0), opt))
+    if hedge and hedge.get("ok") and (hedge.get("premium_u") or 0) > 0:
+        candidates.append(("期期对冲", float(hedge.get("path_a_tp") or 0), hedge))
+    if not candidates:
+        return {
+            "choice": "—",
+            "reason": "输入不足,无法推荐",
+            "bullets": ["请检查风险额与卖一/止损距是否过小导致张数为 0"],
+        }
+
+    best_name, best_a, _ = max(candidates, key=lambda x: x[1])
+    perp_a = float(perp.get("path_a_tp") or 0) if perp else 0.0
+    opt_a = float(opt.get("path_a_tp") or 0) if opt and opt.get("ok") else 0.0
+    hedge_a = float(hedge.get("path_a_tp") or 0) if hedge and hedge.get("ok") else 0.0
+
+    # 踏空:合约 C 实现为亏损,期权/对冲 C 仍接近 A
+    perp_miss = float(perp.get("path_c_missed") or 0) if perp else 0.0
+    opt_c = float(opt.get("path_c_hold_to_tp") or 0) if opt and opt.get("ok") else None
+    hedge_c = float(hedge.get("path_c_hold_to_tp") or 0) if hedge and hedge.get("ok") else None
+    anti_whipsaw = False
+    if perp_miss > 0 and (
+        (opt_c is not None and opt_c > 0) or (hedge_c is not None and hedge_c > 0)
+    ):
+        anti_whipsaw = True
+
+    # 合约止盈明显更高(>= 另两者 1.15 倍)且用户能接受踏空 → 推合约
+    others_max = max(opt_a, hedge_a, 0.0)
+    choice = best_name
+    if perp_a > 0 and perp_a >= others_max * 1.15 and perp_a >= best_a * 0.99:
+        choice = "合约"
+        if anti_whipsaw:
+            reason = "合约止盈赔付更高,但震荡易洗时存在踏空;能接受洗盘再走可选合约"
+        else:
+            reason = "同风险下合约干净止盈赔付最高"
+    elif anti_whipsaw and (opt_a > 0 or hedge_a > 0):
+        # 抗踏空优先期权类;期期与单腿接近时推期期
+        if hedge_a > 0 and (opt_a <= 0 or hedge_a >= opt_a * 0.85):
+            choice = "期期对冲"
+            reason = "震荡易洗时期权类更抗踏空;期期 7:3 兼顾方向与保护"
+        else:
+            choice = "单期权"
+            reason = "震荡易洗时单期权仍可持有到目标,抗踏空优于合约"
+    else:
+        reason = f"同风险下「{best_name}」干净止盈赔付最高"
+
+    bullets = [
+        f"止盈对比:合约 {perp_a:.2f}U / 单期权 {opt_a:.2f}U / 期期 {hedge_a:.2f}U(风险 R={risk:.2f}U)",
+        (
+            "止损与踏空:合约打止损即结束并可能踏空;"
+            "期权/对冲最坏约亏满权利金,踏空路径下常仍持有至目标"
+            if anti_whipsaw
+            else "止损与踏空:三者最坏接近 −R;关注合约是否易被洗后错过止盈"
+        ),
+        f"选用建议:{reason}",
+    ]
+    return {"choice": choice, "reason": reason, "bullets": bullets}
+
+
+def run_compare(inp: dict[str, Any]) -> dict[str, Any]:
+    err = _validate_common(inp)
+    if err:
+        return {"ok": False, "msg": err}
+    base = str(inp.get("base") or "ETH").strip().upper()
+    risk = float(inp["risk_u"])
+    cs = _f(inp.get("contract_size")) or default_contract_size(base)
+    ct = _f(inp.get("ct_mult")) or default_ct_mult(base)
+    perp = _calc_perp(inp, contract_size=float(cs))
+    opt = _calc_single_option(inp, ct_mult=float(ct))
+    hedge = _calc_hedge(inp, ct_mult=float(ct))
+    rec = recommend(
+        perp,
+        opt if opt.get("ok") else {"ok": False},
+        hedge if hedge.get("ok") else {"ok": False},
+        risk,
+    )
+    warnings: list[str] = []
+    if perp.get("sheets", 0) <= 0:
+        warnings.append("合约张数为 0:止损距过大或 R 过小")
+    if isinstance(opt, dict) and opt.get("ok") and opt.get("sheets", 0) <= 0:
+        warnings.append("单期权张数为 0:卖一过高或 R 过小")
+    if isinstance(hedge, dict) and hedge.get("ok") and hedge.get("premium_u", 0) <= 0:
+        warnings.append("期期对冲未开出张数:卖一过高或 R 过小")
+    if isinstance(opt, dict) and not opt.get("ok"):
+        warnings.append(str(opt.get("msg") or "单期权输入不完整"))
+    if isinstance(hedge, dict) and not hedge.get("ok"):
+        warnings.append(str(hedge.get("msg") or "期期对冲输入不完整"))
+    return {
+        "ok": True,
+        "base": base,
+        "direction": str(inp.get("direction") or "long").strip().lower(),
+        "entry": float(inp["entry"]),
+        "sl": float(inp["sl"]),
+        "tp": float(inp["tp"]),
+        "risk_u": risk,
+        "contract_size": float(cs),
+        "ct_mult": float(ct),
+        "perp": perp,
+        "option": opt,
+        "hedge": hedge,
+        "recommend": rec,
+        "warnings": warnings,
+        "notes": [
+            "期权止盈按标的到价的内在价值近似,非盘口卖出价",
+            "到期小盈/小亏未纳入主表与推荐",
+            "仅本地测算,不下单",
+        ],
+    }

lib/hub/hub_strategy_lib.py

@@ -10,9 +10,20 @@ from typing import Any
 
 from lib.paths import REPO_ROOT
 
-STRATEGY_EXCHANGES: tuple[str, ...] = ("binance", "okx", "gate")
+STRATEGY_EXCHANGES: tuple[str, ...] = ("playbook", "behavior", "binance", "okx", "gate")
 
 STRATEGY_META: dict[str, dict[str, str]] = {
+    "playbook": {
+        "label": "执行手册",
+        "title": "交易执行手册（期权为主 · Gate 为辅）",
+        # 相对仓库根;其余条目用 md_file 相对 docs/strategy
+        "md_rel": "docs/交易执行手册-期权与Gate.md",
+    },
+    "behavior": {
+        "label": "行为准则",
+        "title": "交易行为准则（开单三检）",
+        "md_rel": "docs/交易行为准则-开单三检.md",
+    },
     "binance": {
         "label": "币安",
         "title": "币安·山寨多头趋势",
@@ -43,6 +54,9 @@ def _md_path(exchange_key: str) -> Path:
     meta = STRATEGY_META.get((exchange_key or "").strip().lower())
     if not meta:
         raise KeyError(exchange_key)
+    md_rel = (meta.get("md_rel") or "").strip()
+    if md_rel:
+        return REPO_ROOT / md_rel
     return _strategy_dir() / meta["md_file"]
 
 

lib/instance/instance_settings_lib.py

@@ -8,6 +8,7 @@ from lib.key_monitor.key_auto_order_lib import load_key_auto_order_enabled
 from lib.trade.account_risk_lib import (
     cooling_hours_manual,
     cooling_hours_manual_journal,
+    daily_loss_limit,
     manual_close_daily_limit,
     max_active_positions_from_env,
     mood_issues_daily_freeze_enabled,
@@ -113,6 +114,15 @@ def build_instance_settings_view(
                 _row("手动平仓冷静", f"{cooling_hours_manual():g} 小时"),
                 _row("复盘后冷静", f"{cooling_hours_manual_journal():g} 小时", "手动平仓且填写说明后可缩短"),
                 _row("日手动平仓上限", f"{manual_close_daily_limit()} 次", "超限当日冻结"),
+                _row(
+                    "日亏损次数上限",
+                    (
+                        f"{daily_loss_limit()} 次"
+                        if daily_loss_limit() > 0
+                        else "未启用"
+                    ),
+                    "平仓亏损达限后当日冻结开仓;0=不启用" if daily_loss_limit() > 0 else "RISK_DAILY_LOSS_LIMIT=0",
+                ),
                 _row(
                     "复盘情绪日冻结",
                     _on_off(mood_issues_daily_freeze_enabled()),

lib/trade/account_risk_lib.py

@@ -86,6 +86,14 @@ def manual_close_daily_limit() -> int:
         return 2
 
 
+def daily_loss_limit() -> int:
+    """日亏损次数上限:达限当日冻结开仓;0=不因亏损次数冻结."""
+    try:
+        return max(0, int(os.getenv("RISK_DAILY_LOSS_LIMIT", "2")))
+    except (TypeError, ValueError):
+        return 2
+
+
 def max_active_positions_from_env(default: int = 1) -> int:
     try:
         return max(1, int(os.getenv("MAX_ACTIVE_POSITIONS", str(default))))
@@ -116,6 +124,7 @@ def ensure_account_risk_schema(conn) -> None:
             id INTEGER PRIMARY KEY CHECK (id = 1),
             trading_day TEXT,
             manual_close_count INTEGER DEFAULT 0,
+            daily_loss_count INTEGER DEFAULT 0,
             cooloff_until_ms INTEGER,
             cooloff_hours INTEGER,
             daily_frozen INTEGER DEFAULT 0,
@@ -124,10 +133,18 @@ def ensure_account_risk_schema(conn) -> None:
             updated_at TEXT
         )"""
     )
+    cols = {
+        str(r[1])
+        for r in conn.execute("PRAGMA table_info(account_risk_state)").fetchall()
+    }
+    if "daily_loss_count" not in cols:
+        conn.execute(
+            "ALTER TABLE account_risk_state ADD COLUMN daily_loss_count INTEGER DEFAULT 0"
+        )
     row = conn.execute("SELECT id FROM account_risk_state WHERE id=1").fetchone()
     if not row:
         conn.execute(
-            "INSERT INTO account_risk_state (id, trading_day, manual_close_count, daily_frozen) VALUES (1, '', 0, 0)"
+            "INSERT INTO account_risk_state (id, trading_day, manual_close_count, daily_loss_count, daily_frozen) VALUES (1, '', 0, 0, 0)"
         )
 
 
@@ -268,6 +285,7 @@ def _sync_trading_day(conn, trading_day: str, now: Optional[datetime] = None) ->
             """UPDATE account_risk_state SET
                trading_day=?,
                manual_close_count=0,
+               daily_loss_count=0,
                daily_frozen=0,
                cooloff_until_ms=?,
                cooloff_hours=?,
@@ -600,6 +618,43 @@ def on_manual_close(
     )
 
 
+def on_closed_trade_pnl(
+    conn,
+    *,
+    pnl_amount: Any,
+    trading_day: str,
+    now: Optional[datetime] = None,
+) -> None:
+    """
+    已平仓交易记盈亏后调用:亏损笔数达 RISK_DAILY_LOSS_LIMIT 则当日冻结开仓.
+    上限为 0 时不启用本规则.
+    """
+    if not risk_control_enabled():
+        return
+    limit = daily_loss_limit()
+    if limit <= 0:
+        return
+    try:
+        pnl = float(pnl_amount)
+    except (TypeError, ValueError):
+        return
+    if pnl >= 0:
+        return
+    row = _sync_trading_day(conn, trading_day, now=now)
+    if int(_row_get(row, "daily_frozen") or 0) == 1:
+        return
+    count = int(_row_get(row, "daily_loss_count") or 0) + 1
+    conn.execute(
+        """UPDATE account_risk_state SET
+           daily_loss_count=?,
+           updated_at=?
+           WHERE id=1""",
+        (count, (now or datetime.now()).strftime("%Y-%m-%d %H:%M:%S")),
+    )
+    if count >= limit:
+        _set_daily_frozen(conn, trading_day=trading_day, now=now)
+
+
 def on_journal_saved(
     conn,
     *,
@@ -762,6 +817,7 @@ def compute_account_risk_status(
             "cooloff_until_ms": None,
             "cooloff_until": None,
             "manual_close_count": 0,
+            "daily_loss_count": 0,
             "daily_frozen": False,
         }
     row = _sync_trading_day(conn, trading_day, now=now)
@@ -784,12 +840,21 @@ def compute_account_risk_status(
         row = _load_state(conn)
         cooloff_until_ms = _resolved_cooloff_until_ms(row, now_ms)
     manual_close_count = int(_row_get(row, "manual_close_count") or 0)
+    daily_loss_count = int(_row_get(row, "daily_loss_count") or 0)
+    loss_limit = daily_loss_limit()
 
     status = STATUS_NORMAL
     reason = ""
     if daily_frozen:
         status = STATUS_DAILY
-        reason = f"账户今日已冻结(手动平仓 {manual_close_count} 次或复盘情绪标签)"
+        parts = []
+        if loss_limit > 0 and daily_loss_count >= loss_limit:
+            parts.append(f"日亏损 {daily_loss_count}/{loss_limit} 次")
+        if manual_close_count >= manual_close_daily_limit():
+            parts.append(f"手动平仓 {manual_close_count} 次")
+        if not parts:
+            parts.append("手动平仓/日亏损达限或复盘情绪标签")
+        reason = "账户今日已冻结(" + "、".join(parts) + ")"
     elif cooloff_until_ms is not None:
         remaining_ms = cooloff_until_ms - now_ms
         hours = _cooloff_hours_value(row)
@@ -818,6 +883,8 @@ def compute_account_risk_status(
         if fmt_local_ms and cooloff_until_ms
         else None,
         "manual_close_count": manual_close_count,
+        "daily_loss_count": daily_loss_count,
+        "daily_loss_limit": loss_limit,
         "daily_frozen": daily_frozen,
         "pending_journal_trade_id": pending,
         "freeze_remaining_sec": freeze_remaining_sec if not can_trade else 0,

manual_trading_hub/AI教练说明.md

@@ -6,7 +6,7 @@
 
 | 功能 | 说明 |
 |------|------|
-| **交易教练** | 口语化陪聊;注入三户监控快照与今日总结摘要(后台自动生成,不在页面展示) |
+| **交易教练** | 口语化陪聊;注入三户监控快照(**含 OKX 期权持仓明细**)、执行手册短摘要与今日总结摘要(后台自动生成,不在页面展示) |
 | **普通聊天** | 不绑交易数据,适合闲聊,答疑 |
 | **交易监管** | 今日长会话;手动/中控开平仓与新开仓自动推送 + 企业微信 + 可回聊(见 [交易监管说明.md](./交易监管说明.md)) |
 | **会话历史** | 右侧列表:切换,删除;消息一键复制 |

manual_trading_hub/amp_stats_routes.py

@@ -0,0 +1,222 @@
+"""中控振幅统计 API."""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from fastapi import APIRouter, HTTPException, Query
+from fastapi.responses import Response
+from pydantic import BaseModel, Field
+
+from amp_stats_store import delete_history, get_history, list_history, save_history
+from lib.hub.amp_stats_lib import (
+    build_export_csv,
+    compute_amp_stats,
+    export_filename,
+    normalize_straddle_premium,
+    normalize_take_profit,
+    normalize_weekend_filter,
+    reframe_amp_stats,
+    rows_page,
+)
+
+
+class ComputeBody(BaseModel):
+    symbol: str = "eth"
+    start_hour: int = 16
+    period: str = "2m"
+    custom_days: Optional[int] = None
+    straddle_premium: Optional[float] = None
+    take_profit: Optional[float] = None
+    weekend_filter: str = "all"
+    page: int = 1
+    page_size: int = 20
+
+
+class SaveBody(BaseModel):
+    result: dict[str, Any] = Field(default_factory=dict)
+
+
+class ReframeBody(BaseModel):
+    """已有日表上改周末/权利金/止盈(不拉 K 线)."""
+
+    rows_all: list[dict[str, Any]] = Field(default_factory=list)
+    symbol: str = "eth"
+    start_hour: int = 16
+    period: str = "2m"
+    sample_days: int = 60
+    straddle_premium: Optional[float] = None
+    take_profit: Optional[float] = None
+    weekend_filter: str = "all"
+    price_source: str = ""
+    inst_id: str = ""
+    page: int = 1
+    page_size: int = 20
+
+
+def create_amp_stats_router() -> APIRouter:
+    router = APIRouter(prefix="/api/amp-stats", tags=["amp-stats"])
+
+    @router.get("/meta")
+    def api_meta():
+        return {
+            "ok": True,
+            "exchange": "okx",
+            "symbols": [
+                {"key": "eth", "label": "ETH"},
+                {"key": "btc", "label": "BTC"},
+            ],
+            "end_hour": 16,
+            "start_hours": list(range(24)),
+            "periods": [
+                {"key": "1m", "label": "1个月"},
+                {"key": "2m", "label": "2个月"},
+                {"key": "3m", "label": "3个月"},
+                {"key": "6m", "label": "半年"},
+                {"key": "1y", "label": "1年"},
+                {"key": "custom", "label": "自定义"},
+            ],
+            "weekend_filters": [
+                {"key": "all", "label": "全部"},
+                {"key": "exclude", "label": "排除周末"},
+                {"key": "only", "label": "仅周末"},
+            ],
+            "default_period": "2m",
+            "default_weekend_filter": "all",
+            "timeframe": "1H",
+            "metric_note": "振幅与距离均为点数:振幅=最高-最低=(开→高)+(开→低)",
+            "straddle_note": "买跨:越过权利金用>;止盈≥触达用止盈点否则|涨跌|;收益=有效波动-权利金",
+        }
+
+    @router.post("/compute")
+    def api_compute(body: ComputeBody):
+        try:
+            result = compute_amp_stats(
+                symbol=body.symbol,
+                start_hour=body.start_hour,
+                period=body.period,
+                custom_days=body.custom_days,
+                straddle_premium=body.straddle_premium,
+                take_profit=body.take_profit,
+                weekend_filter=body.weekend_filter,
+            )
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        except Exception as exc:
+            raise HTTPException(status_code=502, detail=str(exc)) from exc
+        page = rows_page(result.get("rows") or [], page=body.page, page_size=body.page_size)
+        return {
+            "ok": True,
+            "result": result,
+            "page": page,
+        }
+
+    @router.post("/reframe")
+    def api_reframe(body: ReframeBody):
+        rows_all = body.rows_all or []
+        if not rows_all:
+            raise HTTPException(status_code=400, detail="无日表可重算")
+        try:
+            result = reframe_amp_stats(
+                rows_all=rows_all,
+                symbol=body.symbol,
+                start_hour=body.start_hour,
+                period=body.period,
+                sample_days=body.sample_days,
+                straddle_premium=body.straddle_premium,
+                take_profit=body.take_profit,
+                weekend_filter=body.weekend_filter,
+                price_source=body.price_source,
+                inst_id=body.inst_id,
+            )
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        page = rows_page(result.get("rows") or [], page=body.page, page_size=body.page_size)
+        return {"ok": True, "result": result, "page": page}
+
+    @router.get("/history")
+    def api_history(symbol: str = "", limit: int = 50):
+        return {"ok": True, "items": list_history(symbol=symbol, limit=limit)}
+
+    @router.post("/history")
+    def api_history_save(body: SaveBody):
+        payload = body.result if isinstance(body.result, dict) else {}
+        if not payload.get("rows") and not payload.get("rows_all") and not payload.get("summary"):
+            raise HTTPException(status_code=400, detail="无可保存的结果")
+        item = save_history(payload)
+        return {"ok": True, "item": item}
+
+    @router.get("/history/{item_id}")
+    def api_history_detail(item_id: str):
+        item = get_history(item_id)
+        if not item:
+            raise HTTPException(status_code=404, detail="历史不存在")
+        return {"ok": True, "item": item}
+
+    @router.delete("/history/{item_id}")
+    def api_history_delete(item_id: str):
+        if not delete_history(item_id):
+            raise HTTPException(status_code=404, detail="历史不存在")
+        return {"ok": True}
+
+    @router.get("/export")
+    def api_export(
+        history_id: str = Query(default=""),
+        symbol: str = Query(default="eth"),
+        start_hour: int = Query(default=16),
+        period: str = Query(default="2m"),
+        custom_days: Optional[int] = Query(default=None),
+        straddle_premium: Optional[float] = Query(default=None),
+        take_profit: Optional[float] = Query(default=None),
+        weekend_filter: str = Query(default="all"),
+    ):
+        if (history_id or "").strip():
+            item = get_history(history_id.strip())
+            if not item:
+                raise HTTPException(status_code=404, detail="历史不存在")
+            rows_all = item.get("rows_all") or item.get("rows") or []
+            try:
+                payload = reframe_amp_stats(
+                    rows_all=rows_all,
+                    symbol=item.get("symbol") or symbol,
+                    start_hour=int(item.get("start_hour") if item.get("start_hour") is not None else start_hour),
+                    period=str(item.get("period") or period),
+                    sample_days=int(item.get("sample_days_requested") or 60),
+                    straddle_premium=straddle_premium
+                    if straddle_premium is not None
+                    else item.get("straddle_premium"),
+                    take_profit=take_profit if take_profit is not None else item.get("take_profit"),
+                    weekend_filter=weekend_filter or item.get("weekend_filter") or "all",
+                    price_source=str(item.get("price_source") or ""),
+                    inst_id=str(item.get("inst_id") or ""),
+                    missing=item.get("missing_days") or [],
+                )
+            except ValueError as exc:
+                raise HTTPException(status_code=400, detail=str(exc)) from exc
+        else:
+            try:
+                # validate enums early
+                normalize_weekend_filter(weekend_filter)
+                normalize_straddle_premium(straddle_premium)
+                normalize_take_profit(take_profit)
+                payload = compute_amp_stats(
+                    symbol=symbol,
+                    start_hour=start_hour,
+                    period=period,
+                    custom_days=custom_days,
+                    straddle_premium=straddle_premium,
+                    take_profit=take_profit,
+                    weekend_filter=weekend_filter,
+                )
+            except ValueError as exc:
+                raise HTTPException(status_code=400, detail=str(exc)) from exc
+            except Exception as exc:
+                raise HTTPException(status_code=502, detail=str(exc)) from exc
+        csv_text = build_export_csv(payload)
+        name = export_filename(payload)
+        return Response(
+            content=csv_text.encode("utf-8"),
+            media_type="text/csv; charset=utf-8",
+            headers={"Content-Disposition": f'attachment; filename="{name}"'},
+        )
+
+    return router

manual_trading_hub/amp_stats_store.py

@@ -0,0 +1,122 @@
+"""振幅统计历史作业存储(中控 JSON)."""
+from __future__ import annotations
+
+import json
+import threading
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+_LOCK = threading.Lock()
+_STORE_NAME = "amp_stats_history.json"
+_MAX_ITEMS = 80
+
+
+def _store_path() -> Path:
+    return Path(__file__).resolve().parent / _STORE_NAME
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).astimezone().strftime("%Y-%m-%d %H:%M:%S")
+
+
+def _load() -> dict[str, Any]:
+    path = _store_path()
+    if not path.is_file():
+        return {"items": []}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return {"items": []}
+    if not isinstance(data, dict):
+        return {"items": []}
+    items = data.get("items")
+    if not isinstance(items, list):
+        items = []
+    return {"items": items}
+
+
+def _save(data: dict[str, Any]) -> None:
+    path = _store_path()
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def list_history(*, symbol: str = "", limit: int = 50) -> list[dict[str, Any]]:
+    with _LOCK:
+        items = list(_load().get("items") or [])
+    sym = (symbol or "").strip().lower()
+    if sym:
+        items = [x for x in items if str(x.get("symbol") or "").lower() == sym]
+    limit = max(1, min(200, int(limit or 50)))
+    out = []
+    for it in items[:limit]:
+        out.append(
+            {
+                "id": it.get("id"),
+                "created_at": it.get("created_at"),
+                "symbol": it.get("symbol"),
+                "symbol_label": it.get("symbol_label"),
+                "start_hour": it.get("start_hour"),
+                "end_hour": it.get("end_hour"),
+                "period": it.get("period"),
+                "price_source": it.get("price_source"),
+                "sample_count": (it.get("summary") or {}).get("sample_count"),
+                "max_amplitude": (it.get("summary") or {}).get("max_amplitude"),
+                "max_amplitude_day": (it.get("summary") or {}).get("max_amplitude_day"),
+            }
+        )
+    return out
+
+
+def get_history(item_id: str) -> Optional[dict[str, Any]]:
+    iid = (item_id or "").strip()
+    if not iid:
+        return None
+    with _LOCK:
+        for it in _load().get("items") or []:
+            if str(it.get("id")) == iid:
+                return dict(it)
+    return None
+
+
+def save_history(payload: dict[str, Any]) -> dict[str, Any]:
+    item = {
+        "id": uuid.uuid4().hex[:12],
+        "created_at": _now_iso(),
+        "exchange": payload.get("exchange"),
+        "symbol": payload.get("symbol"),
+        "symbol_label": payload.get("symbol_label"),
+        "start_hour": payload.get("start_hour"),
+        "end_hour": payload.get("end_hour"),
+        "period": payload.get("period"),
+        "timeframe": payload.get("timeframe"),
+        "price_source": payload.get("price_source"),
+        "inst_id": payload.get("inst_id"),
+        "timezone": payload.get("timezone"),
+        "summary": payload.get("summary") or {},
+        "rows": payload.get("rows") or [],
+        "missing_count": payload.get("missing_count") or 0,
+    }
+    with _LOCK:
+        data = _load()
+        items = list(data.get("items") or [])
+        items.insert(0, item)
+        data["items"] = items[:_MAX_ITEMS]
+        _save(data)
+    return item
+
+
+def delete_history(item_id: str) -> bool:
+    iid = (item_id or "").strip()
+    if not iid:
+        return False
+    with _LOCK:
+        data = _load()
+        items = list(data.get("items") or [])
+        new_items = [x for x in items if str(x.get("id")) != iid]
+        if len(new_items) == len(items):
+            return False
+        data["items"] = new_items
+        _save(data)
+    return True

manual_trading_hub/docs/help/02-hub-nav.md

@@ -7,7 +7,8 @@
 | **资金概况** | 总资金曲线、分户权益、回撤与 24h 变化 |
 | **开仓计划** | 事前写下计划、跟踪进行中、统计历史胜率 |
 | **监控区** | **核心操作台**：三所持仓卡片、全平/撤单、关键位与趋势计划摘要 |
-| **策略说明** | 三所策略 playbook + 开仓检查清单（非系统操作手册） |
+| **策略说明** | 执行手册 + 行为准则(开单三检) + 三所策略 playbook + 开仓检查清单（非系统操作手册） |
+| **振幅统计** | OKX ETH/BTC 时段点数振幅档案（只读，固定 16:00 收窗） |
 | **使用说明** | 本页：中控与实例怎么用 |
 | **行情区** | K 线、指标、画线；可从持仓跳转带币种 |
 | **计算器** | 趋势回调 / 滚仓张数与盈亏测算（手动填价） |

manual_trading_hub/hub.py

@@ -991,6 +991,7 @@ def root_redirect():
 @app.get("/monitor")
 @app.get("/plan")
 @app.get("/calculator")
+@app.get("/compare")
 @app.get("/market")
 @app.get("/archive")
 @app.get("/quotes")
@@ -998,6 +999,7 @@ def root_redirect():
 @app.get("/funds")
 @app.get("/ai")
 @app.get("/strategy")
+@app.get("/amp-stats")
 @app.get("/help")
 @app.get("/logs")
 @app.get("/settings")
@@ -1012,8 +1014,10 @@ def _all_exchanges_for_ai() -> list:
 
 from hub_ai.routes import create_hub_ai_router
 from hub_dashboard import build_dashboard_payload, default_trading_day
+from amp_stats_routes import create_amp_stats_router
 
 app.include_router(create_hub_ai_router(load_all_exchanges=_all_exchanges_for_ai))
+app.include_router(create_amp_stats_router())
 
 
 async def _run_dashboard_aggregate() -> dict:
@@ -1110,7 +1114,9 @@ class SettingsDisplayBody(BaseModel):
     show_nav_quotes: bool = True
     show_nav_ai: bool = True
     show_nav_calculator: bool = True
+    show_nav_compare: bool = True
     show_nav_strategy: bool = True
+    show_nav_amp_stats: bool = True
     show_nav_help: bool = True
     show_nav_logs: bool = True
 
@@ -1208,6 +1214,27 @@ class RollCalculatorBody(BaseModel):
     base: str = "ETH"
 
 
+class CompareOptionLegBody(BaseModel):
+    opt_type: str = "C"
+    strike: float | None = None
+    ask: float | None = None
+
+
+class CompareBody(BaseModel):
+    base: str = "ETH"
+    direction: str = "long"
+    entry: float = Field(gt=0)
+    sl: float = Field(gt=0)
+    tp: float = Field(gt=0)
+    risk_u: float = Field(gt=0)
+    tp_opt: float | None = None
+    tp_hedge: float | None = None
+    contract_size: float | None = None
+    ct_mult: float | None = None
+    option: CompareOptionLegBody | None = None
+    hedge: dict | None = None
+
+
 @app.get("/api/calculator/exchanges")
 def api_calculator_exchanges():
     from lib.hub.hub_calculator_market_lib import list_calculator_exchanges
@@ -1268,6 +1295,26 @@ def api_calculator_roll(body: RollCalculatorBody):
     return {"ok": True, "data": data}
 
 
+@app.post("/api/compare/calc")
+def api_compare_calc(body: CompareBody):
+    from lib.hub.hub_compare_lib import run_compare
+
+    payload = body.model_dump()
+    hedge = payload.get("hedge") if isinstance(payload.get("hedge"), dict) else {}
+    # normalize hedge legs from nested dicts
+    if hedge:
+        payload["hedge"] = {
+            "main": hedge.get("main") if isinstance(hedge.get("main"), dict) else {},
+            "side": hedge.get("side") if isinstance(hedge.get("side"), dict) else {},
+        }
+    if payload.get("option") is None:
+        payload["option"] = {}
+    data = run_compare(payload)
+    if not data.get("ok"):
+        return JSONResponse(data, status_code=400)
+    return data
+
+
 def _find_exchange_by_key(exchange_key: str) -> dict | None:
     key = (exchange_key or "").strip().lower()
     if not key:

manual_trading_hub/hub_ai/chat.py

@@ -25,6 +25,7 @@ from hub_ai.context import (
     format_chat_context_for_chat,
     format_chat_position_overview,
 )
+from hub_ai.playbook_brief import format_playbook_brief_for_chat
 from hub_ai.prompts import (
     CHAT_GENERAL_SYSTEM,
     CHAT_SYSTEM,
@@ -217,6 +218,10 @@ def send_chat_message(
         ctx = build_chat_context(exchanges, trading_day=day)
         day = ctx["trading_day"]
         brief_ctx, excerpt = _trading_context_bundle(ctx, prior_count=prior_count)
+        # 首轮带完整手册摘要;续聊缩短,避免挤占对话上下文
+        playbook = format_playbook_brief_for_chat(
+            max_chars=1200 if prior_count <= 0 else 700
+        )
         user_prompt = build_chat_user_prompt(
             context_text=brief_ctx,
             trading_day=day,
@@ -225,6 +230,7 @@ def send_chat_message(
             history_lines=history_tail,
             user_message=user_for_prompt,
             attachment_note=str(parsed.get("attachment_note") or ""),
+            playbook_brief=playbook,
         )
         if parsed.get("text_append"):
             user_prompt += "\n\n【附件正文】\n" + _clip_text(parsed["text_append"], 3000)

manual_trading_hub/hub_ai/context.py

@@ -86,7 +86,81 @@ def _filter_open_positions(positions: list) -> list[dict]:
 
 
 def _account_open_position_count(ac: dict) -> int:
-    return len(_filter_open_positions(ac.get("positions") or []))
+    perp = len(_filter_open_positions(ac.get("positions") or []))
+    opt = int(ac.get("options_open_position_count") or 0)
+    if opt <= 0:
+        opt = len(_iter_options_position_dicts(ac))
+    return perp + opt
+
+
+def _iter_options_position_dicts(ac: dict) -> list[dict]:
+    snap = ac.get("options_snapshot")
+    if not isinstance(snap, dict):
+        return []
+    if snap.get("ok") is False or snap.get("enabled") is False:
+        return []
+    out: list[dict] = []
+    for p in snap.get("positions") or []:
+        if not isinstance(p, dict):
+            continue
+        inst = str(p.get("inst_id") or p.get("instId") or "").strip()
+        if not inst:
+            continue
+        out.append(p)
+    return out
+
+
+def _format_options_position_detail_line(p: dict) -> str:
+    inst = p.get("inst_id") or p.get("instId") or "?"
+    opt_type = (p.get("opt_type") or p.get("optType") or "").upper()
+    label = "Call" if opt_type == "C" else "Put" if opt_type == "P" else (opt_type or "OPT")
+    src = _options_source_label(p)
+    sheets = p.get("pos")
+    if sheets is None:
+        sheets = p.get("sheets")
+    if sheets is None:
+        sheets = p.get("contracts")
+    if sheets is None:
+        sheets = "?"
+    parts = [f"期权 {inst} {label}", f"来源{src}", f"张数{sheets}"]
+    paid = _safe_float(p.get("premium_paid"))
+    if paid is not None:
+        parts.append(f"权利金{paid:g}U")
+    net: Optional[float] = None
+    try:
+        from lib.options.options_positions_lib import net_pnl_from_display_row
+
+        net = net_pnl_from_display_row(p)
+    except Exception:
+        net = None
+    if net is None:
+        net = _safe_float(p.get("net_pnl"))
+    if net is None:
+        net = _safe_float(p.get("upl"))
+    if net is not None:
+        parts.append(f"净盈亏{net:.4f}U")
+    tgt = _options_target_monitor_text(p)
+    if tgt and tgt not in ("—", "-", ""):
+        parts.append(f"目标{tgt}")
+    return "  - " + " ".join(parts)
+
+
+def _append_options_position_lines(lines: list[str], ac: dict, *, limit: int = 6, indent: str = "  - ") -> None:
+    rows = _iter_options_position_dicts(ac)
+    if not rows:
+        return
+    if indent.startswith("    "):
+        # chat slim: already under account bullet
+        for p in rows[:limit]:
+            lines.append(f"    · {_format_options_position_detail_line(p).lstrip('  - ')}")
+        if len(rows) > limit:
+            lines.append(f"    · …共{len(rows)}笔期权持仓")
+        return
+    lines.append("期权持仓明细(交易所实盘,含目标位若已挂):")
+    for p in rows[:limit]:
+        lines.append(_format_options_position_detail_line(p))
+    if len(rows) > limit:
+        lines.append(f"  - …共{len(rows)}笔期权持仓")
 
 
 def _monitor_counts(ac: dict) -> dict[str, int]:
@@ -788,7 +862,9 @@ def format_context_text(payload: dict) -> str:
     lines.append(
         f"【合计·今日 {day}】平仓盈亏 {totals.get('total_pnl_u')}U | "
         f"笔数 {totals.get('closed_count')}(胜{totals.get('win_count')}/负{totals.get('loss_count')})| "
-        f"实盘持仓 {totals.get('open_position_count', 0)} 仓 | "
+        f"实盘持仓 {totals.get('open_position_count', 0)} 仓"
+        f"(永续{totals.get('perpetual_open_position_count', totals.get('open_position_count', 0))}/"
+        f"期权{totals.get('options_open_position_count', 0)}) | "
         f"浮盈亏 {totals.get('float_pnl_u')}U | "
         f"资金账户合计 {_fmt_fund(totals.get('total_funding_usdt'))} | "
         f"交易账户合计 {_fmt_fund(totals.get('total_trading_usdt'))}"
@@ -855,6 +931,7 @@ def format_context_text(payload: dict) -> str:
                 if not isinstance(p, dict):
                     continue
                 lines.append(_format_position_detail_line(p, hub_mon))
+        _append_options_position_lines(lines, ac, limit=8)
         lines.append(
             f"Agent合约余额:{ac.get('balance_usdt') if ac.get('balance_usdt') is not None else '未知'} USDT"
         )
@@ -885,7 +962,9 @@ def format_summary_context_text(payload: dict) -> str:
     lines.append(
         f"【合计·今日 {day}】平仓盈亏 {totals.get('total_pnl_u')}U | "
         f"笔数 {totals.get('closed_count')}(胜{totals.get('win_count')}/负{totals.get('loss_count')})| "
-        f"实盘持仓 {totals.get('open_position_count', 0)} 仓 | "
+        f"实盘持仓 {totals.get('open_position_count', 0)} 仓"
+        f"(永续{totals.get('perpetual_open_position_count', totals.get('open_position_count', 0))}/"
+        f"期权{totals.get('options_open_position_count', 0)}) | "
         f"浮盈亏 {totals.get('float_pnl_u')}U | "
         f"资金账户合计 {_fmt_fund(totals.get('total_funding_usdt'))} | "
         f"交易账户合计 {_fmt_fund(totals.get('total_trading_usdt'))}"
@@ -943,6 +1022,7 @@ def format_summary_context_text(payload: dict) -> str:
                 if not isinstance(p, dict):
                     continue
                 lines.append(_format_position_detail_line(p, hub_mon))
+        _append_options_position_lines(lines, ac, limit=8)
         lines.append(
             f"Agent合约余额:{ac.get('balance_usdt') if ac.get('balance_usdt') is not None else '未知'} USDT"
         )
@@ -1289,21 +1369,30 @@ def collect_closed_trades_snapshot(
 def format_chat_position_overview(payload: dict) -> str:
     totals = payload.get("totals") or {}
     total_open = int(totals.get("open_position_count") or 0)
+    opt_total = int(totals.get("options_open_position_count") or 0)
+    perp_total = int(
+        totals.get("perpetual_open_position_count")
+        if totals.get("perpetual_open_position_count") is not None
+        else max(0, total_open - opt_total)
+    )
     if total_open <= 0:
         head = f"【实盘持仓总览】当前空仓(监控户合计 0 仓).浮盈亏 0U 表示无持仓,不是「有仓但不动」."
     else:
         head = (
-            f"【实盘持仓总览】监控户合计 {total_open} 仓,"
+            f"【实盘持仓总览】监控户合计 {total_open} 仓"
+            f"(永续{perp_total}/期权{opt_total}),"
             f"浮盈亏合计 {totals.get('float_pnl_u')}U."
         )
     lines = [
         head,
-        "【区分】只有带「持仓明细/交易所实盘」字样的才是已开仓;趋势回调,关键位,下单监控,顺势加仓是本地计划/监控,不算持仓.持仓明细若含止损/止盈价,表示已挂条件单或监控计划中有价位.",
+        "【区分】只有带「持仓明细/交易所实盘/期权持仓」字样的才是已开仓;趋势回调,关键位,下单监控,顺势加仓是本地计划/监控,不算持仓.持仓明细若含止损/止盈价,表示已挂条件单或监控计划中有价位.",
     ]
     for ac in payload.get("accounts") or []:
         if ac.get("status") == "未监控":
             continue
         n = int(ac.get("open_position_count") or _account_open_position_count(ac))
+        opt_n = int(ac.get("options_open_position_count") or len(_iter_options_position_dicts(ac)))
+        perp_n = len(_filter_open_positions(ac.get("positions") or []))
         mc = _monitor_counts(ac)
         mon_parts = []
         if mc["trends"]:
@@ -1319,8 +1408,11 @@ def format_chat_position_overview(payload: dict) -> str:
             lines.append(f"- {ac.get('name')}:空仓{mon_txt}")
         else:
             lines.append(
-                f"- {ac.get('name')}:{n}仓 浮盈亏{ac.get('float_pnl_u')}U{mon_txt}"
+                f"- {ac.get('name')}:{n}仓(永续{perp_n}/期权{opt_n}) "
+                f"浮盈亏{ac.get('float_pnl_u')}U{mon_txt}"
             )
+            for p in _iter_options_position_dicts(ac)[:4]:
+                lines.append(f"  · {_format_options_position_detail_line(p).lstrip('  - ')}")
     return "\n".join(lines)
 
 
@@ -1328,11 +1420,19 @@ def format_chat_context_slim(payload: dict) -> str:
     """聊天专用:不含 180 日资金曲线与昨日平仓明细,避免挤占对话上下文."""
     totals = payload.get("totals") or {}
     day = totals.get("trading_day")
+    opt_total = int(totals.get("options_open_position_count") or 0)
+    perp_total = int(
+        totals.get("perpetual_open_position_count")
+        if totals.get("perpetual_open_position_count") is not None
+        else max(0, int(totals.get("open_position_count") or 0) - opt_total)
+    )
     lines = [
         f"【今日合计 {day}】平仓盈亏 {totals.get('total_pnl_u')}U | "
         f"笔数 {totals.get('closed_count')}(胜{totals.get('win_count')}/负{totals.get('loss_count')})| "
-        f"实盘持仓 {totals.get('open_position_count', 0)} 仓 | 浮盈亏 {totals.get('float_pnl_u')}U",
-        "【说明】持仓=交易所实盘;趋势/关键位/监控单=本地计划,不等于已开仓.持仓行内「止损/止盈」= 交易所条件单或监控计划价(与监控页一致).",
+        f"实盘持仓 {totals.get('open_position_count', 0)} 仓"
+        f"(永续{perp_total}/期权{opt_total}) | 浮盈亏 {totals.get('float_pnl_u')}U",
+        "【说明】持仓=交易所实盘(含期权);趋势/关键位/监控单=本地计划,不等于已开仓."
+        "永续行「止损/止盈」=条件单或监控计划价;期权行含合约/来源/权利金/净盈亏/目标位.",
     ]
     for ac in payload.get("accounts") or []:
         if ac.get("status") == "未监控":
@@ -1340,7 +1440,12 @@ def format_chat_context_slim(payload: dict) -> str:
             continue
         st = ac.get("trade_stats") or {}
         open_n = int(ac.get("open_position_count") or _account_open_position_count(ac))
-        pos_txt = "空仓" if open_n <= 0 else f"{open_n}仓 浮盈亏{ac.get('float_pnl_u')}U"
+        opt_n = int(ac.get("options_open_position_count") or len(_iter_options_position_dicts(ac)))
+        perp_n = len(_filter_open_positions(ac.get("positions") or []))
+        if open_n <= 0:
+            pos_txt = "空仓"
+        else:
+            pos_txt = f"{open_n}仓(永续{perp_n}/期权{opt_n}) 浮盈亏{ac.get('float_pnl_u')}U"
         mc = _monitor_counts(ac)
         mon = []
         if mc["trends"]:
@@ -1369,6 +1474,7 @@ def format_chat_context_slim(payload: dict) -> str:
             if not isinstance(p, dict):
                 continue
             lines.append(f"    · {_format_position_detail_line(p, hub_mon).lstrip('  - ')}")
+        _append_options_position_lines(lines, ac, limit=6, indent="    · ")
     return "\n".join(lines)
 
 

manual_trading_hub/hub_ai/playbook_brief.py

@@ -0,0 +1,29 @@
+"""交易教练用的执行手册短摘要(来源 docs/交易执行手册-期权与Gate.md)."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from lib.paths import REPO_ROOT
+
+# 控制 token:保持简短;手册大改时同步修订本摘要.
+_PLAYBOOK_BRIEF = """【用户策略执行手册·摘要】(来源:docs/交易执行手册-期权与Gate.md + docs/交易行为准则-开单三检.md)
+开单防火墙(强制):信号判断(核心点位是否清晰)→流程确认(资金/单笔敞口超限则暂停)→情绪自检(符合系统才做;怕踏空/回本/证明自己→放弃)。三检不过不开。成败先看三检是否跑完,不看这笔盈亏。
+一句话:横盘对冲(可偏置实值);突破用一天期权;假破确认后小仓合约加强;先过方向/空间/值不值得;期权不手平;一位置两次,错完收工;单笔小亏、组合回撤可控.
+分工:OKX 期权=主业;Gate 合约=辅业;其它账户暂不做.同一时段尽量只让一边说话.
+入场三类:①横盘较久→期期对冲(一天 Call+Put,总权利金约10U),期间一般不开 Gate;②方向/空间/值不值得过关且结构突破→一天期权方向单,默认不上合约;③已有突破期权后出现反向假破确认→Gate 小仓加强(加重暴露,按一笔故事控风险).
+仓位(总资约800U):单笔期权约10U且一次一仓;期期对冲合计约10U;Gate 保证金约50U×约10x,止损约5U,单笔最亏约≤10U;日最坏约≤20U.
+期权纪律:不手动平仓,只认规则止盈或到期(紧急手平非策略样本);默认一天期,尽量北京时间16:00后开次日到期.
+Gate 纪律:只做很明确位置;同一位置最多两次机会(结构突破/假突破);两次都错→当日收工.
+教练用法:对照上述纪律讨论执行与心态;开单前优先提醒三检;勿另造策略或鼓励期权手平/超仓."""
+
+
+def playbook_md_path() -> Path:
+    return REPO_ROOT / "docs" / "交易执行手册-期权与Gate.md"
+
+
+def format_playbook_brief_for_chat(max_chars: int = 1200) -> str:
+    """返回注入交易教练上下文的短摘要."""
+    text = _PLAYBOOK_BRIEF.strip()
+    if len(text) <= max_chars:
+        return text
+    return text[: max(200, max_chars - 1)].rstrip() + "…"

manual_trading_hub/hub_ai/prompts.py

@@ -44,10 +44,12 @@ CHAT_SYSTEM = """
 - 不要「第1点第2点你应该…」;不要「作为你的教练我必须…」.
 - 不预测涨跌,不保证收益,不替用户做决定.
 - 只能依据提供的监控与交易数据说话;看不到的就说「我这边看不到,你可以去 xx 实例页确认」.
-- **持仓判定**:只有快照里「实盘持仓总览 / 持仓明细 / 交易所实盘」才算已开仓;「空仓 / 0 仓」就是没仓位.浮盈亏 0U 且空仓时,不要说「还有仓」「卡着不动」.
+- **持仓判定**:只有快照里「实盘持仓总览 / 持仓明细 / 交易所实盘 / 期权持仓」才算已开仓;「空仓 / 0 仓」就是没仓位.浮盈亏 0U 且空仓时,不要说「还有仓」「卡着不动」.
+- **期权持仓**:快照中「期权 …」行与永续同样是实盘;须分开提及.期权净盈亏/目标位以快照为准.
 - **监控单 ≠ 持仓**:趋势回调,关键位,顺势加仓,下单监控是本地计划或挂单监控,用户说已平仓时,即使还有这些监控,也不要当成手里还有仓.
 - 用户口述与快照冲突时,以快照为准并口语说明「我这边看到是空仓/有N仓」.
 - 若附带「今日总结摘要」,那是较早生成的缓存,**实盘持仓以【当前多账户快照】里的「实盘持仓总览」为准**,摘要里若提到持仓可能已过时.
+- 若附带【用户策略执行手册·摘要】,须按该纪律理解账户分工与离场规则(如期权通常不手平、Gate 一位置两次等);勿另造策略或鼓励违反摘要纪律.
 - 若用户上传图片,可结合图中可见信息讨论,看不清的明确说看不清.
 - **优先接住【用户现在说】和【对话核心摘要】**:用户聊心态,悔单,某笔操作时,先顺着这个话题回应,不要每句都复述账户资金数字.
 - **接续对话**:有【对话核心摘要】时须接着聊,不要重复开场白;整段回复必须写完,以句号/问号/感叹号收尾,不得停在半句话;编号列表每条单独一行.
@@ -143,12 +145,20 @@ def build_chat_user_prompt(
     history_lines: str = "",
     user_message: str,
     attachment_note: str = "",
+    playbook_brief: str = "",
 ) -> str:
     parts = [f"【交易日】{trading_day}"]
     if rolling_summary.strip():
         parts.extend(["【对话核心摘要(须接续,勿重复开场)】", rolling_summary.strip()])
     elif history_lines.strip():
         parts.extend(["【最近对话】", history_lines.strip()])
+    if playbook_brief.strip():
+        parts.extend(
+            [
+                "【用户策略执行手册·摘要(须知悉分工与纪律)】",
+                playbook_brief.strip(),
+            ]
+        )
     parts.extend([
         "【当前多账户快照(事实参考;持仓以「实盘持仓总览」为准)】",
         context_text.strip() or "(无监控数据)",

manual_trading_hub/settings_store.py

@@ -29,7 +29,9 @@ DEFAULT_DISPLAY = {
     "show_nav_quotes": True,
     "show_nav_ai": True,
     "show_nav_calculator": True,
+    "show_nav_compare": True,
     "show_nav_strategy": True,
+    "show_nav_amp_stats": True,
     "show_nav_help": True,
     "show_nav_logs": True,
 }

manual_trading_hub/static/amp_stats.js

@@ -0,0 +1,451 @@
+/**
+ * 中控振幅统计:OKX ETH/BTC + 买跨/止盈/周末筛选.
+ */
+(function () {
+  const page = document.getElementById("page-amp-stats");
+  if (!page) return;
+
+  let lastResult = null;
+  let pageNo = 1;
+  let bound = false;
+  let reframeTimer = null;
+
+  const el = (id) => document.getElementById(id);
+
+  async function apiFetch(url, opts) {
+    const r = await fetch(url, { credentials: "same-origin", ...(opts || {}) });
+    const ct = (r.headers.get("content-type") || "").toLowerCase();
+    if (ct.includes("application/json")) {
+      const data = await r.json();
+      if (!r.ok) throw new Error((data && (data.detail || data.msg)) || r.statusText || "请求失败");
+      return data;
+    }
+    if (!r.ok) throw new Error(r.statusText || "请求失败");
+    return r;
+  }
+
+  function esc(s) {
+    return String(s ?? "")
+      .replace(/&/g, "&")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;");
+  }
+
+  function pct(ratio) {
+    if (ratio == null || ratio === "") return "—";
+    const n = Number(ratio);
+    if (!Number.isFinite(n)) return "—";
+    return (n * 100).toFixed(1) + "%";
+  }
+
+  function readPremium() {
+    const raw = (el("amp-straddle-premium")?.value || "").trim();
+    if (!raw) return null;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0) return null;
+    return n;
+  }
+
+  function readTakeProfit() {
+    const raw = (el("amp-take-profit")?.value || "").trim();
+    if (!raw) return null;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0) return null;
+    return n;
+  }
+
+  function readWeekend() {
+    return el("amp-weekend-filter")?.value || "all";
+  }
+
+  function setStatus(msg) {
+    const s = el("amp-status");
+    if (s) s.textContent = msg || "";
+  }
+
+  function setView(view) {
+    const isHist = view === "history";
+    el("amp-panel-stats")?.classList.toggle("hidden", isHist);
+    el("amp-panel-history")?.classList.toggle("hidden", !isHist);
+    page.querySelectorAll(".amp-view-tab").forEach((btn) => {
+      const on = btn.getAttribute("data-view") === view;
+      btn.classList.toggle("is-active", on);
+      btn.setAttribute("aria-selected", on ? "true" : "false");
+    });
+    if (isHist) void loadHistory();
+  }
+
+  function syncCustomDays() {
+    const period = el("amp-period")?.value || "2m";
+    const wrap = el("amp-custom-wrap");
+    if (wrap) wrap.classList.toggle("hidden", period !== "custom");
+  }
+
+  function fillMetaControls() {
+    const hourSel = el("amp-start-hour");
+    if (hourSel && !hourSel.options.length) {
+      for (let h = 0; h < 24; h++) {
+        const opt = document.createElement("option");
+        opt.value = String(h);
+        opt.textContent = String(h).padStart(2, "0") + ":00";
+        if (h === 16) opt.selected = true;
+        hourSel.appendChild(opt);
+      }
+    }
+  }
+
+  function pnlClass(v) {
+    const n = Number(v);
+    if (!Number.isFinite(n) || n === 0) return "";
+    return n > 0 ? "is-pos" : "is-neg";
+  }
+
+  function renderSummary(summary, result) {
+    const box = el("amp-summary");
+    if (!box) return;
+    const s = summary || {};
+    if (!s.sample_count) {
+      box.innerHTML = '<p class="amp-empty">暂无汇总</p>';
+      renderStraddle(null);
+      return;
+    }
+    box.innerHTML =
+      `<div class="amp-sum-grid">` +
+      `<div><span class="amp-sum-k">样本</span><span class="amp-sum-v">${esc(s.sample_count)}</span></div>` +
+      `<div><span class="amp-sum-k">最大振幅</span><span class="amp-sum-v">${esc(s.max_amplitude)} <small>(${esc(s.max_amplitude_day)})</small></span></div>` +
+      `<div><span class="amp-sum-k">振幅均值</span><span class="amp-sum-v">${esc(s.avg_amplitude)}</span></div>` +
+      `<div><span class="amp-sum-k">振幅中位</span><span class="amp-sum-v">${esc(s.median_amplitude)}</span></div>` +
+      `<div><span class="amp-sum-k">开→高最大/均</span><span class="amp-sum-v">${esc(s.max_up_points)} / ${esc(s.avg_up_points)}</span></div>` +
+      `<div><span class="amp-sum-k">开→低最大/均</span><span class="amp-sum-v">${esc(s.max_down_points)} / ${esc(s.avg_down_points)}</span></div>` +
+      `<div><span class="amp-sum-k">涨/跌窗占比</span><span class="amp-sum-v">${esc(s.up_day_ratio)} / ${esc(s.down_day_ratio)}</span></div>` +
+      `<div><span class="amp-sum-k">价源</span><span class="amp-sum-v">${esc(result && result.price_source)}</span></div>` +
+      `</div>`;
+    renderStraddle(s.straddle);
+  }
+
+  function renderStraddle(st) {
+    const box = el("amp-straddle");
+    if (!box) return;
+    if (!st) {
+      box.innerHTML = '<p class="amp-empty">填写「买跨·双边权利金」后计算，可看越过天数与买跨点数盈亏</p>';
+      return;
+    }
+    const verdict =
+      st.pnl_total == null
+        ? "—"
+        : Number(st.pnl_total) > 0
+          ? "样本合计盈利"
+          : Number(st.pnl_total) < 0
+            ? "样本合计亏损"
+            : "样本合计持平";
+    const tpLine =
+      st.take_profit != null
+        ? `<div><span class="amp-sum-k">止盈点 / 触达</span><span class="amp-sum-v">${esc(st.take_profit)} · ${esc(st.tp_hit_days)} 天 · ${esc(pct(st.tp_hit_ratio))}</span></div>`
+        : `<div><span class="amp-sum-k">止盈点</span><span class="amp-sum-v">未设(按|涨跌|)</span></div>`;
+    box.innerHTML =
+      `<div class="amp-sum-grid">` +
+      `<div><span class="amp-sum-k">双边权利金</span><span class="amp-sum-v">${esc(st.premium)}</span></div>` +
+      tpLine +
+      `<div><span class="amp-sum-k">开→高超过权利金</span><span class="amp-sum-v">${esc(st.up_exceed_days)} 天 · ${esc(pct(st.up_exceed_ratio))}</span></div>` +
+      `<div><span class="amp-sum-k">开→低超过权利金</span><span class="amp-sum-v">${esc(st.down_exceed_days)} 天 · ${esc(pct(st.down_exceed_ratio))}</span></div>` +
+      `<div><span class="amp-sum-k">|涨跌|超过权利金</span><span class="amp-sum-v">${esc(st.abs_change_exceed_days)} 天 · ${esc(pct(st.abs_change_exceed_ratio))}</span></div>` +
+      `<div><span class="amp-sum-k">买跨盈亏合计</span><span class="amp-sum-v ${pnlClass(st.pnl_total)}">${esc(st.pnl_total)} <small>(${esc(verdict)})</small></span></div>` +
+      `<div><span class="amp-sum-k">日均盈亏</span><span class="amp-sum-v ${pnlClass(st.pnl_avg)}">${esc(st.pnl_avg)}</span></div>` +
+      `<div><span class="amp-sum-k">赚钱天数/胜率</span><span class="amp-sum-v">${esc(st.win_days)} · ${esc(pct(st.win_ratio))}</span></div>` +
+      `<div><span class="amp-sum-k">单日最大赚/亏</span><span class="amp-sum-v">${esc(st.pnl_max)} / ${esc(st.pnl_min)}</span></div>` +
+      `</div>`;
+  }
+
+  function dayLabel(r) {
+    const day = esc(r.settlement_day);
+    if (r.is_weekend && r.weekday_label) {
+      return `${day}<span class="amp-wd-tag">${esc(r.weekday_label)}</span>`;
+    }
+    return day;
+  }
+
+  function renderTable(pagePayload) {
+    const body = el("amp-table-body");
+    const pager = el("amp-pager");
+    if (!body) return;
+    const rows = (pagePayload && pagePayload.rows) || [];
+    if (!rows.length) {
+      body.innerHTML = '<tr><td colspan="11" class="amp-empty">暂无数据</td></tr>';
+    } else {
+      body.innerHTML = rows
+        .map((r) => {
+          const profit =
+            r.profit == null || r.profit === ""
+              ? "—"
+              : `<span class="amp-pnl ${pnlClass(r.profit)}">${esc(r.profit)}</span>`;
+          const trClass = r.is_weekend ? ' class="amp-row-weekend"' : "";
+          return (
+            `<tr${trClass}>` +
+            `<td>${dayLabel(r)}</td>` +
+            `<td>${esc(r.window_start)}</td>` +
+            `<td>${esc(r.open)}</td>` +
+            `<td>${esc(r.high)}</td>` +
+            `<td>${esc(r.low)}</td>` +
+            `<td>${esc(r.close)}</td>` +
+            `<td>${esc(r.up_points)}</td>` +
+            `<td>${esc(r.down_points)}</td>` +
+            `<td><strong>${esc(r.amplitude)}</strong></td>` +
+            `<td>${esc(r.change)}</td>` +
+            `<td>${profit}</td>` +
+            `</tr>`
+          );
+        })
+        .join("");
+    }
+    if (pager && pagePayload) {
+      pager.innerHTML =
+        `<button type="button" class="ghost" id="amp-page-prev" ${pagePayload.page <= 1 ? "disabled" : ""}>上一页</button>` +
+        `<span class="amp-pager-meta">第 ${esc(pagePayload.page)} / ${esc(pagePayload.total_pages)} 页 · 共 ${esc(pagePayload.total)} 天</span>` +
+        `<button type="button" class="ghost" id="amp-page-next" ${pagePayload.page >= pagePayload.total_pages ? "disabled" : ""}>下一页</button>`;
+      el("amp-page-prev")?.addEventListener("click", () => {
+        if (pageNo > 1) {
+          pageNo -= 1;
+          void reframe(false);
+        }
+      });
+      el("amp-page-next")?.addEventListener("click", () => {
+        if (pagePayload.page < pagePayload.total_pages) {
+          pageNo += 1;
+          void reframe(false);
+        }
+      });
+    }
+  }
+
+  function rowsAllFromLast() {
+    if (!lastResult) return [];
+    if (Array.isArray(lastResult.rows_all) && lastResult.rows_all.length) return lastResult.rows_all;
+    return lastResult.rows || [];
+  }
+
+  async function reframe(resetPage) {
+    if (!lastResult) {
+      renderStraddle(null);
+      return;
+    }
+    if (resetPage) pageNo = 1;
+    const rowsAll = rowsAllFromLast();
+    if (!rowsAll.length) return;
+    try {
+      const data = await apiFetch("/api/amp-stats/reframe", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          rows_all: rowsAll,
+          symbol: lastResult.symbol || el("amp-symbol")?.value || "eth",
+          start_hour: lastResult.start_hour ?? Number(el("amp-start-hour")?.value || 16),
+          period: lastResult.period || el("amp-period")?.value || "2m",
+          sample_days: lastResult.sample_days_requested || 60,
+          straddle_premium: readPremium(),
+          take_profit: readTakeProfit(),
+          weekend_filter: readWeekend(),
+          price_source: lastResult.price_source || "",
+          inst_id: lastResult.inst_id || "",
+          page: pageNo,
+          page_size: 20,
+        }),
+      });
+      const prevAll = rowsAll;
+      lastResult = data.result || lastResult;
+      if (!lastResult.rows_all || !lastResult.rows_all.length) lastResult.rows_all = prevAll;
+      renderSummary(lastResult.summary, lastResult);
+      renderTable(data.page);
+      setStatus(`完成 · 样本 ${(lastResult.summary || {}).sample_count || 0}`);
+    } catch (e) {
+      setStatus(String(e && e.message ? e.message : e));
+    }
+  }
+
+  function scheduleReframe() {
+    if (!lastResult) return;
+    if (reframeTimer) clearTimeout(reframeTimer);
+    reframeTimer = setTimeout(() => void reframe(true), 280);
+  }
+
+  async function compute(resetPage) {
+    if (resetPage) pageNo = 1;
+    const symbol = el("amp-symbol")?.value || "eth";
+    const startHour = Number(el("amp-start-hour")?.value || 16);
+    const period = el("amp-period")?.value || "2m";
+    const customDays = Number(el("amp-custom-days")?.value || 60);
+    setStatus("计算中…(长周期会分页拉 OKX，遇限频会自动重试，请稍候)");
+    try {
+      const data = await apiFetch("/api/amp-stats/compute", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          symbol,
+          start_hour: startHour,
+          period,
+          custom_days: period === "custom" ? customDays : null,
+          straddle_premium: readPremium(),
+          take_profit: readTakeProfit(),
+          weekend_filter: readWeekend(),
+          page: pageNo,
+          page_size: 20,
+        }),
+      });
+      lastResult = data.result || null;
+      renderSummary(lastResult && lastResult.summary, lastResult);
+      renderTable(data.page);
+      const miss = (lastResult && lastResult.missing_count) || 0;
+      setStatus(
+        miss
+          ? `完成 · 样本 ${(lastResult.summary || {}).sample_count || 0} · 缺 ${miss} 天`
+          : `完成 · 样本 ${(lastResult.summary || {}).sample_count || 0}`
+      );
+    } catch (e) {
+      setStatus(String(e && e.message ? e.message : e));
+    }
+  }
+
+  async function saveHistory() {
+    if (!lastResult) {
+      setStatus("请先计算");
+      return;
+    }
+    try {
+      await apiFetch("/api/amp-stats/history", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ result: lastResult }),
+      });
+      setStatus("已保存到历史");
+    } catch (e) {
+      setStatus(String(e && e.message ? e.message : e));
+    }
+  }
+
+  function downloadCurrent() {
+    if (!lastResult) {
+      setStatus("请先计算");
+      return;
+    }
+    const symbol = el("amp-symbol")?.value || "eth";
+    const startHour = Number(el("amp-start-hour")?.value || 16);
+    const period = el("amp-period")?.value || "2m";
+    const customDays = Number(el("amp-custom-days")?.value || 60);
+    const prem = readPremium();
+    const tp = readTakeProfit();
+    const q = new URLSearchParams({
+      symbol,
+      start_hour: String(startHour),
+      period,
+      weekend_filter: readWeekend(),
+    });
+    if (period === "custom") q.set("custom_days", String(customDays));
+    if (prem != null) q.set("straddle_premium", String(prem));
+    if (tp != null) q.set("take_profit", String(tp));
+    window.location.href = "/api/amp-stats/export?" + q.toString();
+  }
+
+  async function loadHistory() {
+    const box = el("amp-history-list");
+    if (!box) return;
+    box.innerHTML = '<p class="amp-empty">加载中…</p>';
+    try {
+      const data = await apiFetch("/api/amp-stats/history?limit=50");
+      const items = data.items || [];
+      if (!items.length) {
+        box.innerHTML = '<p class="amp-empty">暂无历史</p>';
+        return;
+      }
+      box.innerHTML = items
+        .map(
+          (it) =>
+            `<div class="amp-hist-card" data-id="${esc(it.id)}">` +
+            `<div class="amp-hist-main">` +
+            `<strong>${esc(it.symbol_label || it.symbol)}</strong> · ${esc(String(it.start_hour).padStart(2, "0"))}:00→16:00 · ${esc(it.period)}` +
+            `<div class="amp-hist-sub">${esc(it.created_at)} · 样本 ${esc(it.sample_count)} · 最大振幅 ${esc(it.max_amplitude)} (${esc(it.max_amplitude_day)})</div>` +
+            `</div>` +
+            `<div class="amp-hist-actions">` +
+            `<button type="button" class="ghost amp-hist-view">查看</button>` +
+            `<button type="button" class="ghost amp-hist-dl">下载</button>` +
+            `<button type="button" class="danger amp-hist-del">删除</button>` +
+            `</div></div>`
+        )
+        .join("");
+      box.querySelectorAll(".amp-hist-card").forEach((card) => {
+        const id = card.getAttribute("data-id");
+        card.querySelector(".amp-hist-view")?.addEventListener("click", () => void openHistory(id));
+        card.querySelector(".amp-hist-dl")?.addEventListener("click", () => {
+          const prem = readPremium();
+          const tp = readTakeProfit();
+          let url =
+            "/api/amp-stats/export?history_id=" +
+            encodeURIComponent(id) +
+            "&weekend_filter=" +
+            encodeURIComponent(readWeekend());
+          if (prem != null) url += "&straddle_premium=" + encodeURIComponent(String(prem));
+          if (tp != null) url += "&take_profit=" + encodeURIComponent(String(tp));
+          window.location.href = url;
+        });
+        card.querySelector(".amp-hist-del")?.addEventListener("click", async () => {
+          if (!confirm("删除该历史记录?")) return;
+          await apiFetch("/api/amp-stats/history/" + encodeURIComponent(id), { method: "DELETE" });
+          void loadHistory();
+        });
+      });
+    } catch (e) {
+      box.innerHTML = `<p class="amp-empty">${esc(String(e && e.message ? e.message : e))}</p>`;
+    }
+  }
+
+  async function openHistory(id) {
+    try {
+      const data = await apiFetch("/api/amp-stats/history/" + encodeURIComponent(id));
+      lastResult = data.item || null;
+      setView("stats");
+      if (lastResult) {
+        if (el("amp-symbol")) el("amp-symbol").value = lastResult.symbol || "eth";
+        if (el("amp-start-hour")) el("amp-start-hour").value = String(lastResult.start_hour ?? 16);
+        if (lastResult.straddle_premium != null && el("amp-straddle-premium")) {
+          el("amp-straddle-premium").value = String(lastResult.straddle_premium);
+        }
+        if (lastResult.take_profit != null && el("amp-take-profit")) {
+          el("amp-take-profit").value = String(lastResult.take_profit);
+        }
+        if (lastResult.weekend_filter && el("amp-weekend-filter")) {
+          el("amp-weekend-filter").value = lastResult.weekend_filter;
+        }
+        pageNo = 1;
+        setStatus("已载入历史 " + id);
+        await reframe(true);
+      }
+    } catch (e) {
+      setStatus(String(e && e.message ? e.message : e));
+    }
+  }
+
+  function bind() {
+    if (bound) return;
+    bound = true;
+    fillMetaControls();
+    page.querySelectorAll(".amp-view-tab").forEach((btn) => {
+      btn.addEventListener("click", () => setView(btn.getAttribute("data-view")));
+    });
+    el("amp-period")?.addEventListener("change", syncCustomDays);
+    el("amp-btn-compute")?.addEventListener("click", () => void compute(true));
+    el("amp-btn-save")?.addEventListener("click", () => void saveHistory());
+    el("amp-btn-download")?.addEventListener("click", downloadCurrent);
+    el("amp-straddle-premium")?.addEventListener("input", scheduleReframe);
+    el("amp-take-profit")?.addEventListener("input", scheduleReframe);
+    el("amp-weekend-filter")?.addEventListener("change", () => void reframe(true));
+    syncCustomDays();
+  }
+
+  window.hubAmpStatsPage = {
+    init() {
+      bind();
+      setView("stats");
+      setStatus("");
+      renderStraddle(null);
+    },
+  };
+})();

manual_trading_hub/static/app.css

@@ -2357,6 +2357,12 @@ html[data-theme="light"] .hub-pos-card .pos-tp-profit {
   margin-bottom: 12px;
 }
 
+.stat-row-options .stat-label {
+  color: var(--accent);
+  text-transform: none;
+  letter-spacing: 0;
+}
+
 .stat-box {
   background: var(--inset-surface);
   border: 1px solid var(--border-soft);
@@ -4301,6 +4307,70 @@ body.login-page {
     gap: 6px;
   }
 
+  /* 手机:隐藏「操作·刷新/紧急全平」,桌面不变 */
+  body.hub-phone #monitor-ops-fold {
+    display: none !important;
+  }
+
+  /* 手机收起态:今日统计固定两行(左标题/交易日,右总浮盈亏) */
+  body.hub-phone .monitor-stats-card.is-collapsed {
+    padding: 0;
+  }
+
+  body.hub-phone .monitor-stats-card.is-collapsed .monitor-stats-head {
+    display: grid;
+    grid-template-columns: minmax(0, 1fr) auto;
+    grid-template-rows: auto auto;
+    column-gap: 10px;
+    row-gap: 2px;
+    align-items: center;
+    padding: 10px 12px;
+  }
+
+  body.hub-phone .monitor-stats-card.is-collapsed .monitor-stats-head-main {
+    display: contents;
+  }
+
+  body.hub-phone .monitor-stats-card.is-collapsed .card-title-row {
+    grid-column: 1;
+    grid-row: 1;
+    flex-wrap: nowrap;
+    min-width: 0;
+  }
+
+  body.hub-phone .monitor-stats-card.is-collapsed .card-title {
+    font-size: 13px;
+    margin: 0;
+  }
+
+  body.hub-phone .monitor-stats-card.is-collapsed .card-sub {
+    grid-column: 1;
+    grid-row: 2;
+    margin: 0;
+    font-size: 10px;
+    line-height: 1.3;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  body.hub-phone .monitor-stats-card.is-collapsed .monitor-stats-float-summary {
+    grid-column: 2;
+    grid-row: 1 / span 2;
+    align-self: center;
+    padding: 0;
+    text-align: right;
+  }
+
+  body.hub-phone .monitor-stats-card.is-collapsed .monitor-stats-float-summary .monitor-stat-label {
+    margin-bottom: 0;
+    font-size: 10px;
+  }
+
+  body.hub-phone .monitor-stats-card.is-collapsed .monitor-stats-float-value {
+    font-size: 16px;
+  }
+
   body.hub-phone .monitor-stat-cell {
     padding: 8px 6px;
   }
@@ -10875,3 +10945,181 @@ html[data-theme="light"] .hub-logs-card-hint {
     min-height: 360px;
   }
 }
+
+/* —— 振幅统计 —— */
+.amp-view-tabs { display: flex; gap: 8px; margin: 0 0 12px; }
+.amp-view-tab {
+  min-height: 34px; padding: 6px 14px; border: 1px solid var(--border-soft);
+  border-radius: 8px; background: transparent; color: var(--muted); cursor: pointer;
+}
+.amp-view-tab.is-active { color: var(--text); border-color: var(--accent); background: rgba(0, 212, 255, 0.08); }
+.amp-panel { padding: 14px 16px 18px; }
+.amp-form {
+  display: grid; grid-template-columns: repeat(auto-fill, minmax(140px, 1fr));
+  gap: 10px 12px; align-items: end; margin-bottom: 8px;
+}
+.amp-field { display: flex; flex-direction: column; gap: 4px; font-size: 12px; color: var(--muted); }
+.amp-field select, .amp-field input {
+  min-height: 34px; padding: 6px 8px; border-radius: 8px;
+  border: 1px solid var(--border-soft); background: var(--panel-solid); color: var(--text);
+}
+.amp-actions { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; }
+.amp-hint { font-size: 12px; color: var(--muted); margin: 4px 0 12px; }
+.amp-status { margin: 0 0 8px; }
+.amp-block-title { font-size: 14px; margin: 14px 0 8px; }
+.amp-sum-grid {
+  display: grid; grid-template-columns: repeat(auto-fill, minmax(180px, 1fr)); gap: 8px;
+}
+.amp-sum-grid > div {
+  border: 1px solid var(--border-soft); border-radius: 8px; padding: 8px 10px;
+  display: flex; flex-direction: column; gap: 2px;
+}
+.amp-sum-k { font-size: 11px; color: var(--muted); }
+.amp-sum-v { font-size: 14px; font-weight: 600; color: var(--text); }
+.amp-sum-v.is-pos { color: var(--green); }
+.amp-sum-v.is-neg { color: var(--red); }
+.amp-pnl.is-pos { color: var(--green); font-weight: 600; }
+.amp-pnl.is-neg { color: var(--red); font-weight: 600; }
+.amp-straddle { margin-bottom: 4px; }
+.amp-table tr.amp-row-weekend td { background: rgba(255, 180, 60, 0.08); }
+.amp-wd-tag {
+  display: inline-block; margin-left: 6px; padding: 1px 6px; border-radius: 4px;
+  font-size: 11px; font-weight: 600; color: #f0c14b;
+  border: 1px solid rgba(240, 193, 75, 0.45);
+}
+.amp-table-wrap { overflow-x: auto; }
+.amp-table { width: 100%; border-collapse: collapse; font-size: 12px; }
+.amp-table th, .amp-table td {
+  border-bottom: 1px solid var(--border-soft); padding: 7px 8px; text-align: right; white-space: nowrap;
+}
+.amp-table th:first-child, .amp-table td:first-child,
+.amp-table th:nth-child(2), .amp-table td:nth-child(2) { text-align: left; }
+.amp-pager { display: flex; align-items: center; gap: 10px; margin-top: 10px; }
+.amp-pager-meta { font-size: 12px; color: var(--muted); }
+.amp-empty { color: var(--muted); text-align: center; padding: 16px; }
+.amp-history-list { display: flex; flex-direction: column; gap: 10px; }
+.amp-hist-card {
+  display: flex; justify-content: space-between; gap: 12px; flex-wrap: wrap;
+  border: 1px solid var(--border-soft); border-radius: 10px; padding: 10px 12px;
+}
+.amp-hist-sub { font-size: 12px; color: var(--muted); margin-top: 4px; }
+.amp-hist-actions { display: flex; gap: 6px; align-items: center; }
+@media (max-width: 720px) {
+  .amp-form { grid-template-columns: 1fr 1fr; }
+  .amp-actions { grid-column: 1 / -1; }
+}
+
+/* --- strategy compare --- */
+#page-compare .toolbar {
+  padding: 12px 16px;
+  margin-bottom: 14px;
+}
+.cmp-form { display: flex; flex-direction: column; gap: 14px; margin-bottom: 16px; }
+.cmp-form .card,
+.cmp-common-card,
+.cmp-sum-card,
+.cmp-rec-card {
+  padding: 18px 20px;
+}
+.cmp-common-card h2,
+.cmp-form .card h2 {
+  margin: 0 0 14px;
+  font-size: 15px;
+}
+.cmp-subhead {
+  margin: 16px 0 10px;
+  font-size: 13px;
+  color: var(--muted);
+  font-weight: 600;
+}
+.cmp-form-grid {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 14px 16px;
+}
+.cmp-field {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  font-size: 12px;
+  color: var(--muted);
+}
+.cmp-field input,
+.cmp-field select {
+  background: var(--inset-surface);
+  border: 1px solid var(--border-soft);
+  border-radius: 8px;
+  color: var(--text);
+  padding: 9px 12px;
+  font-size: 13px;
+}
+.cmp-input-cols {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 14px;
+}
+.cmp-summary {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 14px;
+  margin-bottom: 16px;
+}
+.cmp-sum-card h3 { margin: 0 0 12px; font-size: 14px; }
+.cmp-sum-row {
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  font-size: 12px;
+  margin: 6px 0;
+  color: var(--muted);
+}
+.cmp-sum-row strong { color: var(--text); font-weight: 600; }
+.cmp-muted { color: var(--muted); font-size: 12px; margin: 0; }
+.cmp-table-wrap { margin-bottom: 16px; }
+.cmp-table-scroll { overflow-x: auto; }
+.cmp-table {
+  width: 100%;
+  border-collapse: separate;
+  border-spacing: 0;
+  font-size: 13px;
+  background: var(--panel);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  overflow: hidden;
+}
+.cmp-table th,
+.cmp-table td {
+  border-bottom: 1px solid var(--border-soft);
+  padding: 14px 16px;
+  vertical-align: top;
+  text-align: left;
+}
+.cmp-table th:first-child,
+.cmp-table td:first-child { width: 22%; }
+.cmp-table tr:last-child td { border-bottom: none; }
+.cmp-cell-note {
+  margin-top: 6px;
+  font-size: 11px;
+  color: var(--muted);
+  line-height: 1.4;
+}
+.cmp-pnl-pos { color: var(--green); font-weight: 600; }
+.cmp-pnl-neg { color: var(--red); font-weight: 600; }
+.cmp-rec-head { font-size: 16px; margin-bottom: 8px; }
+.cmp-rec-reason { margin: 0 0 10px; color: var(--muted); font-size: 13px; }
+.cmp-rec-list { margin: 0; padding-left: 20px; font-size: 13px; line-height: 1.55; }
+.cmp-warn { margin-top: 12px; font-size: 12px; color: var(--warn, #e6a23c); }
+.cmp-foot-note { margin: 12px 0 0; font-size: 11px; color: var(--muted); }
+@media (max-width: 900px) {
+  .cmp-form .card,
+  .cmp-common-card,
+  .cmp-sum-card,
+  .cmp-rec-card {
+    padding: 16px;
+  }
+  .cmp-form-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+  .cmp-input-cols,
+  .cmp-summary { grid-template-columns: 1fr; }
+  .cmp-table th,
+  .cmp-table td { padding: 12px 14px; }
+}

manual_trading_hub/static/app.js

@@ -13,6 +13,8 @@
     return displayPref("show_account_pnl", true);
   }
 
+  window.hubShowAccountPnlPref = showAccountPnlPref;
+
   function showNavFundsPref() {
     return displayPref("show_nav_funds", true);
   }
@@ -41,10 +43,18 @@
     return displayPref("show_nav_calculator", true);
   }
 
+  function showNavComparePref() {
+    return displayPref("show_nav_compare", true);
+  }
+
   function showNavStrategyPref() {
     return displayPref("show_nav_strategy", true);
   }
 
+  function showNavAmpStatsPref() {
+    return displayPref("show_nav_amp_stats", true);
+  }
+
   function showNavHelpPref() {
     return displayPref("show_nav_help", true);
   }
@@ -63,7 +73,9 @@
       ["nav-quotes", "m-nav-quotes", d.show_nav_quotes === false],
       ["nav-ai", "m-tab-ai", d.show_nav_ai === false],
       ["nav-calculator", "m-tab-calculator", d.show_nav_calculator === false],
+      ["nav-compare", "m-nav-compare", d.show_nav_compare === false],
       ["nav-strategy", "m-nav-strategy", d.show_nav_strategy === false],
+      ["nav-amp-stats", "m-nav-amp-stats", d.show_nav_amp_stats === false],
       ["nav-help", "m-nav-help", d.show_nav_help === false],
       ["nav-logs", "m-nav-logs", d.show_nav_logs === false],
     ];
@@ -135,7 +147,9 @@
     if (page === "quotes") return showNavQuotesPref();
     if (page === "ai") return showNavAiPref();
     if (page === "calculator") return showNavCalculatorPref();
+    if (page === "compare") return showNavComparePref();
     if (page === "strategy") return showNavStrategyPref();
+    if (page === "amp-stats") return showNavAmpStatsPref();
     if (page === "help") return showNavHelpPref();
     if (page === "logs") return showNavLogsPref();
     return true;
@@ -151,7 +165,9 @@
     const quotesCb = document.getElementById("pref-show-nav-quotes");
     const aiCb = document.getElementById("pref-show-nav-ai");
     const calcCb = document.getElementById("pref-show-nav-calculator");
+    const compareCb = document.getElementById("pref-show-nav-compare");
     const strategyCb = document.getElementById("pref-show-nav-strategy");
+    const ampCb = document.getElementById("pref-show-nav-amp-stats");
     const helpCb = document.getElementById("pref-show-nav-help");
     const logsCb = document.getElementById("pref-show-nav-logs");
     if (pnlCb) pnlCb.checked = d.show_account_pnl !== false;
@@ -162,7 +178,9 @@
     if (quotesCb) quotesCb.checked = d.show_nav_quotes !== false;
     if (aiCb) aiCb.checked = d.show_nav_ai !== false;
     if (calcCb) calcCb.checked = d.show_nav_calculator !== false;
+    if (compareCb) compareCb.checked = d.show_nav_compare !== false;
     if (strategyCb) strategyCb.checked = d.show_nav_strategy !== false;
+    if (ampCb) ampCb.checked = d.show_nav_amp_stats !== false;
     if (helpCb) helpCb.checked = d.show_nav_help !== false;
     if (logsCb) logsCb.checked = d.show_nav_logs !== false;
     syncNavVisibility(data);
@@ -1277,7 +1295,9 @@
     if (p.includes("funds")) return "funds";
     if (p.includes("plan")) return "plan";
     if (p.includes("calculator")) return "calculator";
+    if (p.includes("compare")) return "compare";
     if (p.includes("help")) return "help";
+    if (p.includes("amp-stats")) return "amp-stats";
     if (p.includes("strategy")) return "strategy";
     if (p.includes("logs")) return "logs";
     if (p.includes("market")) return "market";
@@ -1293,8 +1313,10 @@
     if (page === "funds") return "page-funds";
     if (page === "plan") return "page-plan";
     if (page === "calculator") return "page-calculator";
+    if (page === "compare") return "page-compare";
     if (page === "help") return "page-help";
     if (page === "strategy") return "page-strategy";
+    if (page === "amp-stats") return "page-amp-stats";
     if (page === "logs") return "page-logs";
     if (page === "market") return "page-market";
     if (page === "ai") return "page-ai";
@@ -1324,11 +1346,13 @@
     document.body.classList.toggle("hub-page-monitor", page === "monitor");
     document.body.classList.toggle("hub-page-market", page === "market");
     document.body.classList.toggle("hub-page-calculator", page === "calculator");
+    document.body.classList.toggle("hub-page-compare", page === "compare");
     document.body.classList.toggle("hub-page-settings", page === "settings");
     document.body.classList.toggle("hub-page-archive", page === "archive");
     document.body.classList.toggle("hub-page-quotes", page === "quotes");
     document.body.classList.toggle("hub-page-plan", page === "plan");
     document.body.classList.toggle("hub-page-strategy", page === "strategy");
+    document.body.classList.toggle("hub-page-amp-stats", page === "amp-stats");
     document.body.classList.toggle("hub-page-logs", page === "logs");
     document.body.classList.toggle("hub-page-help", page === "help");
     syncHubPhoneShellClass();
@@ -1363,6 +1387,11 @@
     if (page === "calculator" && window.hubCalculatorPage) {
       window.hubCalculatorPage.init();
     }
+    if (page === "compare" && window.hubComparePage) {
+      window.hubComparePage.init();
+    } else if (window.hubComparePage && window.hubComparePage.destroy) {
+      window.hubComparePage.destroy();
+    }
     if (page === "funds" && window.hubFundsPage) {
       window.hubFundsPage.init();
     } else if (window.hubFundsPage && window.hubFundsPage.destroy) {
@@ -1373,6 +1402,9 @@
     } else if (window.hubStrategyPage && window.hubStrategyPage.destroy) {
       window.hubStrategyPage.destroy();
     }
+    if (page === "amp-stats" && window.hubAmpStatsPage) {
+      window.hubAmpStatsPage.init();
+    }
     if (page === "help" && window.hubHelpPage) {
       window.hubHelpPage.init();
     } else if (window.hubHelpPage && window.hubHelpPage.destroy) {
@@ -2412,10 +2444,20 @@
       lossN > 0 && Number.isFinite(Number(t.loss_pnl_u))
         ? `<span class="${pnlCls(t.loss_pnl_u)}">${esc(pnlSigned(t.loss_pnl_u, 2))}U</span>`
         : "—";
+    const showFloat = showAccountPnlPref();
     const floatMain = esc(pnlSigned(floatVal, 2)) + "U";
     const floatCls = Math.abs(floatVal) > 1e-9 ? pnlCls(floatVal) : "";
     const foldLabel = collapsed ? "展开明细" : "收起";
-    return `<div class="card card-online monitor-stats-card${collapsed ? " is-collapsed" : ""}" data-monitor-stats="1">
+    const floatSummary = showFloat
+      ? `<div class="monitor-stats-float-summary">
+          <div class="monitor-stat-label">总浮盈亏</div>
+          <div class="monitor-stat-value monitor-stats-float-value ${floatCls}">${floatMain}</div>
+        </div>`
+      : "";
+    const floatCell = showFloat ? cell("总浮盈亏", floatMain, "", floatCls) : "";
+    return `<div class="card card-online monitor-stats-card${collapsed ? " is-collapsed" : ""}${
+      showFloat ? "" : " hide-float-pnl"
+    }" data-monitor-stats="1">
       <div class="card-head monitor-stats-head">
         <div class="monitor-stats-head-main">
           <div class="card-title-row">
@@ -2424,10 +2466,7 @@
           </div>
           <div class="card-sub">交易日 ${esc(day)} · 北京时间 ${esc(String(resetH))}:00 切日</div>
         </div>
-        <div class="monitor-stats-float-summary">
-          <div class="monitor-stat-label">总浮盈亏</div>
-          <div class="monitor-stat-value monitor-stats-float-value ${floatCls}">${floatMain}</div>
-        </div>
+        ${floatSummary}
       </div>
       <div class="card-body monitor-stats-detail">
         <div class="monitor-stats-grid">
@@ -2436,7 +2475,7 @@
           ${cell("持有仓位", String(Number(t.open_position_count) || 0), "", "")}
           ${cell("盈利", String(winN), winSub, winN > 0 ? "pnl-pos" : "")}
           ${cell("亏损", String(lossN), lossSub, lossN > 0 ? "pnl-neg" : "")}
-          ${cell("总浮盈亏", floatMain, "", floatCls)}
+          ${floatCell}
         </div>
       </div>
     </div>`;
@@ -3741,22 +3780,39 @@
   }
 
   function optionsBalanceFields(opt) {
-    const bal = (opt && opt.balances) || opt || {};
+    if (!opt || typeof opt !== "object") {
+      return { funding: null, trading: null, upl: null };
+    }
+    const bal =
+      opt.balances && typeof opt.balances === "object" ? opt.balances : {};
+    const pick = (a, b) => (a != null && a !== "" ? a : b);
     return {
-      funding: sumUsdtEquiv(bal.funding_usdt, bal.funding_usdc),
-      trading: sumUsdtEquiv(bal.trading_usdt, bal.trading_usdc),
-      upl: opt && opt.upl_total_usdc != null && Number.isFinite(Number(opt.upl_total_usdc))
-        ? Number(opt.upl_total_usdc)
-        : null,
+      funding: sumUsdtEquiv(
+        pick(bal.funding_usdt, opt.funding_usdt),
+        pick(bal.funding_usdc, opt.funding_usdc)
+      ),
+      trading: sumUsdtEquiv(
+        pick(bal.trading_usdt, opt.trading_usdt),
+        pick(bal.trading_usdc, opt.trading_usdc)
+      ),
+      upl:
+        opt.upl_total_usdc != null && Number.isFinite(Number(opt.upl_total_usdc))
+          ? Number(opt.upl_total_usdc)
+          : null,
     };
   }
 
-  function renderStatRow(funding, trading, upnl) {
+  function renderStatRow(funding, trading, upnl, kind) {
     if (!showAccountPnlPref()) return "";
-    return `<div class="stat-row">
-      <div class="stat-box"><div class="stat-label">资金账户</div><div class="stat-value">${fmt(funding, 2)} <small style="font-size:12px;color:var(--muted)">U</small></div></div>
-      <div class="stat-box"><div class="stat-label">交易账户</div><div class="stat-value">${fmt(trading, 2)} <small style="font-size:12px;color:var(--muted)">U</small></div></div>
-      <div class="stat-box"><div class="stat-label">浮盈合计</div><div class="stat-value ${pnlCls(upnl)}">${fmt(upnl, 2)}</div></div>
+    const isOpt = kind === "options";
+    const fundLabel = isOpt ? "期权资金账户" : "资金账户";
+    const tradeLabel = isOpt ? "期权交易账户" : "交易账户";
+    const pnlLabel = isOpt ? "期权浮盈" : "浮盈合计";
+    const rowCls = isOpt ? "stat-row stat-row-options" : "stat-row";
+    return `<div class="${rowCls}">
+      <div class="stat-box"><div class="stat-label">${fundLabel}</div><div class="stat-value">${fmt(funding, 2)} <small style="font-size:12px;color:var(--muted)">U</small></div></div>
+      <div class="stat-box"><div class="stat-label">${tradeLabel}</div><div class="stat-value">${fmt(trading, 2)} <small style="font-size:12px;color:var(--muted)">U</small></div></div>
+      <div class="stat-box"><div class="stat-label">${pnlLabel}</div><div class="stat-value ${pnlCls(upnl)}">${fmt(upnl, 2)}</div></div>
     </div>`;
   }
 
@@ -3764,6 +3820,11 @@
     return renderStatRow(row.funding_usdt, row.trading_usdt, ag.total_unrealized_pnl);
   }
 
+  function renderOptionsAccountStatRow(opt) {
+    const bal = optionsBalanceFields(opt);
+    return renderStatRow(bal.funding, bal.trading, bal.upl, "options");
+  }
+
   function shortOptionsInst(instId) {
     const s = String(instId || "");
     if (s.length <= 22) return s;
@@ -3799,9 +3860,10 @@
 
   function renderOptionsPositionsTable(pos, targets) {
     if (!pos.length) return '<div class="empty-hint hub-slot-pos">暂无期权持仓</div>';
+    const showPnl = showAccountPnlPref();
     let html = '<div class="table-wrap hub-options-table-wrap"><table class="hub-options-table"><thead><tr>';
-    html +=
-      "<th>合约</th><th>类型</th><th>张数</th><th>到期倒计时</th><th>目标监控</th><th>净盈亏</th><th>收益率</th>";
+    html += "<th>合约</th><th>类型</th><th>张数</th><th>到期倒计时</th><th>目标监控</th>";
+    if (showPnl) html += "<th>净盈亏</th><th>收益率</th>";
     html += "</tr></thead><tbody>";
     pos.forEach((p) => {
       const optType =
@@ -3825,10 +3887,12 @@
         <td>${esc(optType)}</td>
         <td>${esc(p.pos)}</td>
         <td>${optionsExpiryCdHtml(p.exp_time_ms != null ? p.exp_time_ms : p.exp_time)}</td>
-        ${renderOptionsTargetCell(target)}
-        <td class="${pnlCls(net)}">${net == null ? "—" : fmt(net, 2)}</td>
-        <td class="${pnlCls(net)}">${roi == null ? "—" : esc(Number(roi).toFixed(2)) + "%"}</td>
-      </tr>`;
+        ${renderOptionsTargetCell(target)}`;
+      if (showPnl) {
+        html += `<td class="${pnlCls(net)}">${net == null ? "—" : fmt(net, 2)}</td>
+        <td class="${pnlCls(net)}">${roi == null ? "—" : esc(Number(roi).toFixed(2)) + "%"}</td>`;
+      }
+      html += "</tr>";
     });
     html += "</tbody></table></div>";
     return html;
@@ -3856,8 +3920,9 @@
     }
     const cls = hubPosListCountClass(pos.length);
     let html = `<div class="hub-pos-list hub-opt-pos-list ${cls}" data-pos-count="${pos.length}">`;
+    const hidePnl = !showAccountPnlPref();
     pos.forEach((p) => {
-      html += OptionsPositionCards.renderCard(p, { readOnly: true, hub: true });
+      html += OptionsPositionCards.renderCard(p, { readOnly: true, hub: true, hidePnl });
     });
     html += "</div>";
     return html;
@@ -3869,18 +3934,17 @@
     const opt = row.options || {};
     let html = "";
     if (opt.enabled === false) {
-      html += renderStatRow(null, null, null);
+      html += renderOptionsAccountStatRow(opt);
       html += '<div class="section-title hub-options-title">期权持仓</div>';
       html += '<div class="empty-hint">期权未启用(OKX_OPTIONS_ENABLED)</div>';
     } else if (opt.ok === false) {
-      html += renderStatRow(null, null, null);
+      html += renderOptionsAccountStatRow(opt);
       html += '<div class="section-title hub-options-title">期权持仓</div>';
       html += `<div class="err">${esc(opt.msg || "期权数据不可用")}</div>`;
     } else {
       const pos = Array.isArray(opt.positions) ? opt.positions : [];
       const targets = Array.isArray(opt.target_monitors) ? opt.target_monitors : [];
-      const bal = optionsBalanceFields(opt);
-      html += renderStatRow(bal.funding, bal.trading, bal.upl);
+      html += renderOptionsAccountStatRow(opt);
       html += `<div class="section-title hub-options-title">期权持仓 · ${pos.length} 仓</div>`;
       html +=
         layout === "cards"
@@ -4312,17 +4376,22 @@
           opt.position_count != null ? opt.position_count : (opt.positions || []).length
         );
         const n = Number.isFinite(optCount) ? optCount : 0;
-        const bal = typeof optionsBalanceFields === "function" ? optionsBalanceFields(opt) : {};
-        const optUpl = bal && bal.upl != null ? bal.upl : null;
-        optLine = n > 0 ? `期权 ${n}仓` : "期权 空仓";
-        if (optUpl != null && Number.isFinite(Number(optUpl))) {
-          optLine += ` · 浮盈 ${fmt(optUpl, 2)}U`;
-          // 永续空仓时主数字优先展示期权浮盈,避免一直显示 0U
-          if (openCount === 0) {
+        const bal = optionsBalanceFields(opt);
+        const optUpl = bal.upl != null ? bal.upl : null;
+        const parts = [n > 0 ? `期权 ${n}仓` : "期权 空仓"];
+        if (showAccountPnlPref()) {
+          if (bal.funding != null) parts.push(`资金 ${fmt(bal.funding, 2)}U`);
+          if (bal.trading != null) parts.push(`交易 ${fmt(bal.trading, 2)}U`);
+          if (optUpl != null && Number.isFinite(Number(optUpl))) {
+            parts.push(`浮盈 ${fmt(optUpl, 2)}U`);
+          }
+          if (optUpl != null && Number.isFinite(Number(optUpl)) && openCount === 0) {
+            // 永续空仓时主数字优先展示期权浮盈,避免一直显示 0U
             pnlShow = optUpl;
             pnlSuffix = "期权";
           }
         }
+        optLine = parts.join(" · ");
       }
     }
     const hm = row.hub_monitor || {};
@@ -5051,7 +5120,9 @@
     const quotesCb = document.getElementById("pref-show-nav-quotes");
     const aiCb = document.getElementById("pref-show-nav-ai");
     const calcCb = document.getElementById("pref-show-nav-calculator");
+    const compareCb = document.getElementById("pref-show-nav-compare");
     const strategyCb = document.getElementById("pref-show-nav-strategy");
+    const ampCb = document.getElementById("pref-show-nav-amp-stats");
     const helpCb = document.getElementById("pref-show-nav-help");
     const logsCb = document.getElementById("pref-show-nav-logs");
     const supEnabled = document.getElementById("supervisor-enabled");
@@ -5074,7 +5145,9 @@
         show_nav_quotes: quotesCb ? !!quotesCb.checked : true,
         show_nav_ai: aiCb ? !!aiCb.checked : true,
         show_nav_calculator: calcCb ? !!calcCb.checked : true,
+        show_nav_compare: compareCb ? !!compareCb.checked : true,
         show_nav_strategy: strategyCb ? !!strategyCb.checked : true,
+        show_nav_amp_stats: ampCb ? !!ampCb.checked : true,
         show_nav_help: helpCb ? !!helpCb.checked : true,
         show_nav_logs: logsCb ? !!logsCb.checked : true,
       },
@@ -5134,6 +5207,9 @@
         loadSettingsMetaLine();
       }
       if (lastMonitorRows.length) renderMonitorGrid(lastMonitorRows);
+      if (window.hubDashboardPage && window.hubDashboardPage.refresh) {
+        window.hubDashboardPage.refresh();
+      }
       if (!pageNavAllowed(currentPage())) {
         history.replaceState({}, "", "/monitor");
         setActiveNav();

manual_trading_hub/static/compare.js

@@ -0,0 +1,296 @@
+/**
+ * 中控策略对比:同风险额 R 下 合约 / 单期权 / 期期7:3
+ */
+(function () {
+  const page = document.getElementById("page-compare");
+  if (!page) return;
+
+  let inited = false;
+  let calcTimer = null;
+
+  function $(id) {
+    return document.getElementById(id);
+  }
+
+  function esc(s) {
+    return String(s == null ? "" : s)
+      .replace(/&/g, "&")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;");
+  }
+
+  function num(id) {
+    const el = $(id);
+    if (!el) return null;
+    const n = Number(el.value);
+    return Number.isFinite(n) ? n : null;
+  }
+
+  function text(id) {
+    const el = $(id);
+    return el ? String(el.value || "").trim() : "";
+  }
+
+  function fmtU(v) {
+    if (v == null || !Number.isFinite(Number(v))) return "—";
+    const n = Number(v);
+    const abs = Math.abs(n).toFixed(2);
+    if (Math.abs(n) < 1e-9) return "0.00U";
+    return (n > 0 ? "+" : "-") + abs + "U";
+  }
+
+  function pnlClass(v) {
+    const n = Number(v);
+    if (!Number.isFinite(n) || Math.abs(n) < 1e-9) return "";
+    return n > 0 ? "cmp-pnl-pos" : "cmp-pnl-neg";
+  }
+
+  function setStatus(msg, isErr) {
+    const el = $("cmp-status");
+    if (!el) return;
+    el.textContent = msg || "";
+    el.className = "toolbar-meta" + (isErr ? " err" : "");
+  }
+
+  function syncDirectionDefaults() {
+    const dir = text("cmp-direction") || "long";
+    const isLong = dir === "long";
+    const optType = $("cmp-opt-type");
+    const mainType = $("cmp-hedge-main-type");
+    const sideType = $("cmp-hedge-side-type");
+    if (optType && !optType.dataset.touched) optType.value = isLong ? "C" : "P";
+    if (mainType && !mainType.dataset.touched) mainType.value = isLong ? "C" : "P";
+    if (sideType && !sideType.dataset.touched) sideType.value = isLong ? "P" : "C";
+  }
+
+  function collectPayload() {
+    const tp = num("cmp-tp");
+    return {
+      base: text("cmp-base") || "ETH",
+      direction: text("cmp-direction") || "long",
+      entry: num("cmp-entry"),
+      sl: num("cmp-sl"),
+      tp: tp,
+      risk_u: num("cmp-risk"),
+      tp_opt: num("cmp-tp-opt") != null ? num("cmp-tp-opt") : tp,
+      tp_hedge: num("cmp-tp-hedge") != null ? num("cmp-tp-hedge") : tp,
+      option: {
+        opt_type: text("cmp-opt-type") || "C",
+        strike: num("cmp-opt-strike"),
+        ask: num("cmp-opt-ask"),
+      },
+      hedge: {
+        main: {
+          opt_type: text("cmp-hedge-main-type") || "C",
+          strike: num("cmp-hedge-main-strike"),
+          ask: num("cmp-hedge-main-ask"),
+        },
+        side: {
+          opt_type: text("cmp-hedge-side-type") || "P",
+          strike: num("cmp-hedge-side-strike"),
+          ask: num("cmp-hedge-side-ask"),
+        },
+      },
+    };
+  }
+
+  function renderSummaryCards(data) {
+    const box = $("cmp-summary");
+    if (!box) return;
+    const perp = data.perp || {};
+    const opt = data.option || {};
+    const hedge = data.hedge || {};
+    const cards = [];
+    cards.push(`<article class="cmp-sum-card card">
+      <h3>单独合约</h3>
+      <div class="cmp-sum-row"><span>张数</span><strong>${esc(perp.sheets)}</strong></div>
+      <div class="cmp-sum-row"><span>止损占用</span><strong>${fmtU(perp.risk_used_u)}</strong></div>
+      <div class="cmp-sum-row"><span>面值</span><strong>${esc(perp.contract_size)} 币/张</strong></div>
+    </article>`);
+    if (opt.ok) {
+      cards.push(`<article class="cmp-sum-card card">
+        <h3>单独期权 · ${esc(opt.opt_type)} ${esc(opt.strike)}</h3>
+        <div class="cmp-sum-row"><span>张数</span><strong>${esc(opt.sheets)}</strong></div>
+        <div class="cmp-sum-row"><span>权利金</span><strong>${fmtU(opt.premium_u)}</strong></div>
+        <div class="cmp-sum-row"><span>单张成本</span><strong>${fmtU(opt.unit_cost_u)}</strong></div>
+      </article>`);
+    } else {
+      cards.push(`<article class="cmp-sum-card card">
+        <h3>单独期权</h3>
+        <p class="cmp-muted">${esc(opt.msg || "输入不完整")}</p>
+      </article>`);
+    }
+    if (hedge.ok) {
+      const m = hedge.main || {};
+      const s = hedge.side || {};
+      cards.push(`<article class="cmp-sum-card card">
+        <h3>期期对冲 7:3</h3>
+        <div class="cmp-sum-row"><span>主腿 ${esc(m.opt_type)} ${esc(m.strike)}</span><strong>${esc(m.sheets)} 张 · ${fmtU(m.premium_u)}</strong></div>
+        <div class="cmp-sum-row"><span>次腿 ${esc(s.opt_type)} ${esc(s.strike)}</span><strong>${esc(s.sheets)} 张 · ${fmtU(s.premium_u)}</strong></div>
+        <div class="cmp-sum-row"><span>总权利金</span><strong>${fmtU(hedge.premium_u)}</strong></div>
+      </article>`);
+    } else {
+      cards.push(`<article class="cmp-sum-card card">
+        <h3>期期对冲</h3>
+        <p class="cmp-muted">${esc(hedge.msg || "输入不完整")}</p>
+      </article>`);
+    }
+    box.innerHTML = cards.join("");
+  }
+
+  function cell(v, note) {
+    const main = `<span class="${pnlClass(v)}">${fmtU(v)}</span>`;
+    if (!note) return main;
+    return `${main}<div class="cmp-cell-note">${esc(note)}</div>`;
+  }
+
+  function renderTable(data) {
+    const box = $("cmp-table-wrap");
+    if (!box) return;
+    const perp = data.perp || {};
+    const opt = data.option && data.option.ok ? data.option : null;
+    const hedge = data.hedge && data.hedge.ok ? data.hedge : null;
+    const dash = "—";
+    box.innerHTML = `<div class="cmp-table-scroll"><table class="cmp-table">
+      <thead>
+        <tr>
+          <th>路径</th>
+          <th>单独合约</th>
+          <th>单独期权</th>
+          <th>期期对冲</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <td><strong>A 干净止盈</strong><div class="cmp-cell-note">盈利能力主对比</div></td>
+          <td>${cell(perp.path_a_tp)}</td>
+          <td>${opt ? cell(opt.path_a_tp) : dash}</td>
+          <td>${hedge ? cell(hedge.path_a_tp) : dash}</td>
+        </tr>
+        <tr>
+          <td><strong>B 打止损</strong><div class="cmp-cell-note">合约实现亏损;期权另注最坏</div></td>
+          <td>${cell(perp.path_b_sl)}</td>
+          <td>${
+            opt
+              ? cell(opt.path_b_sl, "最坏到期亏满权利金 " + fmtU(opt.path_b_worst))
+              : dash
+          }</td>
+          <td>${
+            hedge
+              ? cell(hedge.path_b_sl, "最坏双腿归零 " + fmtU(hedge.path_b_worst))
+              : dash
+          }</td>
+        </tr>
+        <tr>
+          <td><strong>C 先止损再去止盈</strong><div class="cmp-cell-note">合约踏空对照</div></td>
+          <td>${cell(
+            perp.path_c_realized,
+            "踏空未拿到 " + fmtU(perp.path_c_missed)
+          )}</td>
+          <td>${opt ? cell(opt.path_c_hold_to_tp, opt.path_c_note || "") : dash}</td>
+          <td>${hedge ? cell(hedge.path_c_hold_to_tp, hedge.path_c_note || "") : dash}</td>
+        </tr>
+      </tbody>
+    </table></div>`;
+  }
+
+  function renderRecommend(data) {
+    const box = $("cmp-recommend");
+    if (!box) return;
+    const rec = data.recommend || {};
+    const bullets = Array.isArray(rec.bullets) ? rec.bullets : [];
+    const warns = Array.isArray(data.warnings) ? data.warnings : [];
+    box.innerHTML = `<div class="cmp-rec-card card">
+      <div class="cmp-rec-head">推荐:<strong>${esc(rec.choice || "—")}</strong></div>
+      <p class="cmp-rec-reason">${esc(rec.reason || "")}</p>
+      <ul class="cmp-rec-list">${bullets.map((b) => `<li>${esc(b)}</li>`).join("")}</ul>
+      ${
+        warns.length
+          ? `<div class="cmp-warn">${warns.map((w) => esc(w)).join(" · ")}</div>`
+          : ""
+      }
+      <p class="cmp-foot-note">${(data.notes || []).map(esc).join(" · ")}</p>
+    </div>`;
+  }
+
+  async function runCalc() {
+    const payload = collectPayload();
+    if (
+      payload.entry == null ||
+      payload.sl == null ||
+      payload.tp == null ||
+      payload.risk_u == null
+    ) {
+      setStatus("请填写入场 / 止损 / 止盈 / 风险额", true);
+      return;
+    }
+    setStatus("计算中…");
+    try {
+      const r = await fetch("/api/compare/calc", {
+        method: "POST",
+        credentials: "same-origin",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      });
+      const data = await r.json();
+      if (!data.ok) {
+        setStatus(data.msg || "计算失败", true);
+        return;
+      }
+      renderSummaryCards(data);
+      renderTable(data);
+      renderRecommend(data);
+      setStatus("已更新");
+    } catch (e) {
+      setStatus(String(e.message || e), true);
+    }
+  }
+
+  function scheduleCalc() {
+    if (calcTimer) clearTimeout(calcTimer);
+    calcTimer = setTimeout(() => {
+      void runCalc();
+    }, 280);
+  }
+
+  function bind() {
+    const form = $("cmp-form");
+    if (!form || form.dataset.bound === "1") return;
+    form.dataset.bound = "1";
+    form.addEventListener("submit", (ev) => {
+      ev.preventDefault();
+      void runCalc();
+    });
+    form.querySelectorAll("input, select").forEach((el) => {
+      el.addEventListener("change", () => {
+        if (el.id === "cmp-direction") syncDirectionDefaults();
+        if (
+          el.id === "cmp-opt-type" ||
+          el.id === "cmp-hedge-main-type" ||
+          el.id === "cmp-hedge-side-type"
+        ) {
+          el.dataset.touched = "1";
+        }
+        scheduleCalc();
+      });
+      el.addEventListener("input", scheduleCalc);
+    });
+    const btn = $("cmp-btn-run");
+    if (btn) btn.addEventListener("click", () => void runCalc());
+  }
+
+  window.hubComparePage = {
+    init() {
+      if (!inited) {
+        bind();
+        syncDirectionDefaults();
+        inited = true;
+      }
+      scheduleCalc();
+    },
+    destroy() {
+      /* keep form state */
+    },
+  };
+})();

manual_trading_hub/static/dashboard.js

@@ -54,8 +54,16 @@
     elStatus.className = "dash-status" + (isErr ? " err" : "");
   }
 
+  function showAccountPnlPref() {
+    if (typeof window.hubShowAccountPnlPref === "function") {
+      return !!window.hubShowAccountPnlPref();
+    }
+    return true;
+  }
+
   function renderKpi(totals) {
     if (!elKpi || !totals) return;
+    const showPnl = showAccountPnlPref();
     const closed = Number(totals.total_pnl_u);
     const floating = Number(totals.float_pnl_u);
     const funding = totals.total_funding_usdt;
@@ -68,16 +76,20 @@
       totals.perpetual_open_position_count != null
         ? Number(totals.perpetual_open_position_count) || 0
         : Math.max(0, totalPos - optPos);
-    const items = [
-      kpiItem("交易日", esc(totals.trading_day || "—")),
-      kpiItem("资金合计", Number.isFinite(funds) ? `${fmt(funds, 2)}U` : "—"),
+    const items = [kpiItem("交易日", esc(totals.trading_day || "—"))];
+    if (showPnl) {
+      items.push(kpiItem("资金合计", Number.isFinite(funds) ? `${fmt(funds, 2)}U` : "—"));
+    }
+    items.push(
       kpiItem("总持仓数量", `${totalPos}`),
       kpiItem("期权持仓", `${optPos}`),
       kpiItem("永续持仓", `${perpPos}`),
       kpiItem("平仓数量", `${totals.closed_count || 0}`),
-      kpiItem("平仓盈亏", pnlSigned(closed, 2), pnlClass(closed)),
-      kpiItem("浮盈亏", pnlSigned(floating, 2), pnlClass(floating)),
-    ];
+      kpiItem("平仓盈亏", pnlSigned(closed, 2), pnlClass(closed))
+    );
+    if (showPnl) {
+      items.push(kpiItem("浮盈亏", pnlSigned(floating, 2), pnlClass(floating)));
+    }
     elKpi.innerHTML = `<div class="dash-kpi-summary">${items.join("")}</div>`;
   }
 
@@ -197,6 +209,7 @@
 
   function renderUnifiedPerpTable(rows) {
     if (!rows.length) return "";
+    const showPnl = showAccountPnlPref();
     const body = rows
       .map(({ ac, ln }) => {
         const source = String((ln && ln.source) || "—");
@@ -213,7 +226,7 @@
           <td>${contracts}</td>
           <td>${slTpCell(ln, "sl")}</td>
           <td>${slTpCell(ln, "tp")}</td>
-          <td>${floatPnlCell(ln)}</td>
+          ${showPnl ? `<td>${floatPnlCell(ln)}</td>` : ""}
         </tr>`;
       })
       .join("");
@@ -222,7 +235,9 @@
       <div class="dash-table-wrap">
         <table class="dash-table dash-pos-table">
           <thead><tr>
-            <th>交易所</th><th>类型</th><th>合约</th><th>方向</th><th>开仓价</th><th>标记价</th><th>张数</th><th>止损</th><th>止盈</th><th>浮盈</th>
+            <th>交易所</th><th>类型</th><th>合约</th><th>方向</th><th>开仓价</th><th>标记价</th><th>张数</th><th>止损</th><th>止盈</th>${
+              showPnl ? "<th>浮盈</th>" : ""
+            }
           </tr></thead>
           <tbody>${body}</tbody>
         </table>
@@ -291,7 +306,7 @@
     return null;
   }
 
-  function renderOptionsLegRow(ac, p) {
+  function renderOptionsLegRow(ac, p, showPnl) {
     const optType =
       (p.opt_type || "").toUpperCase() === "C"
         ? "Call"
@@ -303,21 +318,25 @@
     const targetCls = target && target !== "—" ? "dash-target-monitor is-on" : "dash-target-monitor";
     const net = optionsNetPnl(p);
     const roi = optionsRoiPct(p);
-    return `<tr>
+    let html = `<tr>
       <td>${exchangeLinkCell(ac)}</td>
       <td>${sourceTypeCell(source)}</td>
       <td title="${esc(p.inst_id || "")}">${esc(shortDashInst(p.inst_id))}</td>
       <td>${esc(optType)}</td>
       <td>${dashOptionsExpiryCd(p.exp_time_ms != null ? p.exp_time_ms : p.exp_time)}</td>
       <td>${p.idx_px != null ? fmt(p.idx_px, 0) : "—"}</td>
-      <td><span class="${targetCls}">${esc(target)}</span></td>
-      <td class="${pnlClass(net)}">${net != null ? pnlSigned(net, 2) : "—"}</td>
-      <td class="${pnlClass(roi)}">${roi != null ? esc(Number(roi).toFixed(2)) + "%" : "—"}</td>
-    </tr>`;
+      <td><span class="${targetCls}">${esc(target)}</span></td>`;
+    if (showPnl) {
+      html += `<td class="${pnlClass(net)}">${net != null ? pnlSigned(net, 2) : "—"}</td>
+      <td class="${pnlClass(roi)}">${roi != null ? esc(Number(roi).toFixed(2)) + "%" : "—"}</td>`;
+    }
+    html += "</tr>";
+    return html;
   }
 
   function renderUnifiedOptionsTable(rows) {
     if (!rows.length) return "";
+    const showPnl = showAccountPnlPref();
     // 同所同计划相邻,Call 在前 Put 在后;不额外画分组框
     const sorted = rows.slice().sort((a, b) => {
       const ka = optionsGroupKey(a.ac, a.p);
@@ -330,14 +349,16 @@
       if (tb === "C") return 1;
       return ta.localeCompare(tb);
     });
-    const body = sorted.map(({ ac, p }) => renderOptionsLegRow(ac, p)).join("");
+    const body = sorted.map(({ ac, p }) => renderOptionsLegRow(ac, p, showPnl)).join("");
 
     return `<div class="dash-pos-block dash-options-block">
       <div class="dash-ac-section-label">期权持仓</div>
       <div class="dash-table-wrap dash-options-table-wrap">
         <table class="dash-table dash-options-table">
           <thead><tr>
-            <th>交易所</th><th>类型</th><th>合约</th><th>Call/Put</th><th>到期倒计时</th><th>指数</th><th>目标监控</th><th>净盈亏</th><th>收益率</th>
+            <th>交易所</th><th>类型</th><th>合约</th><th>Call/Put</th><th>到期倒计时</th><th>指数</th><th>目标监控</th>${
+              showPnl ? "<th>净盈亏</th><th>收益率</th>" : ""
+            }
           </tr></thead>
           <tbody>${body}</tbody>
         </table>
@@ -539,5 +560,9 @@
       inited = false;
       stopLive();
     },
+    refresh() {
+      if (!inited) return;
+      void fetchDashboardSnapshot({ silent: true, force: true });
+    },
   };
 })();

manual_trading_hub/static/index.html

@@ -16,7 +16,7 @@
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
   <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&family=Orbitron:wght@500;600;700&display=swap" rel="stylesheet" media="print" onload="this.media='all'" />
   <noscript><link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&family=Orbitron:wght@500;600;700&display=swap" rel="stylesheet" /></noscript>
-      <link rel="stylesheet" href="/assets/app.css?v=20260720-calc-equal-height" />
+      <link rel="stylesheet" href="/assets/app.css?v=20260723-cmp-pad" />
   <link rel="stylesheet" href="/assets/trade_stats_calendar.css?v=4" />
   <link rel="stylesheet" href="/assets/account_risk_badge.css?v=4" />
   <script src="/assets/account_risk_badge.js?v=4"></script>
@@ -53,9 +53,11 @@
           <a href="/plan" id="nav-plan">开仓计划</a>
           <a href="/monitor" id="nav-monitor">监控区</a>
           <a href="/strategy" id="nav-strategy">策略说明</a>
+          <a href="/amp-stats" id="nav-amp-stats">振幅统计</a>
           <a href="/help" id="nav-help">使用说明</a>
           <a href="/market" id="nav-market">行情区</a>
           <a href="/calculator" id="nav-calculator">计算器</a>
+          <a href="/compare" id="nav-compare">策略对比</a>
           <a href="/archive" id="nav-archive">内照明心</a>
           <a href="/quotes" id="nav-quotes">语录</a>
           <a href="/dashboard" id="nav-dashboard">数据看板</a>
@@ -956,11 +958,130 @@
       </div>
     </div>
 
+    <div id="page-compare" class="page hidden">
+      <div class="page-head">
+        <h1><span class="head-tag">CMP</span> 策略对比</h1>
+        <p class="page-desc">同风险额下对比 · 单独合约 / 单独期权 / 期期对冲(7:3) · 看止盈谁强、谁更易踏空</p>
+      </div>
+      <div class="toolbar">
+        <button type="button" id="cmp-btn-run" class="primary">计算对比</button>
+        <span id="cmp-status" class="toolbar-meta"></span>
+      </div>
+      <form id="cmp-form" class="cmp-form">
+        <section class="card cmp-common-card">
+          <h2>公共参数</h2>
+          <div class="cmp-form-grid">
+            <label class="cmp-field">
+              <span>标的</span>
+              <select id="cmp-base">
+                <option value="ETH" selected>ETH</option>
+                <option value="BTC">BTC</option>
+              </select>
+            </label>
+            <label class="cmp-field">
+              <span>方向</span>
+              <select id="cmp-direction">
+                <option value="long" selected>做多</option>
+                <option value="short">做空</option>
+              </select>
+            </label>
+            <label class="cmp-field">
+              <span>入场价</span>
+              <input id="cmp-entry" type="number" min="0" step="any" value="3500" required />
+            </label>
+            <label class="cmp-field">
+              <span>统一风险 R (U)</span>
+              <input id="cmp-risk" type="number" min="0.01" step="any" value="10" required />
+            </label>
+            <label class="cmp-field">
+              <span>统一止损价</span>
+              <input id="cmp-sl" type="number" min="0" step="any" value="3400" required />
+            </label>
+            <label class="cmp-field">
+              <span>止盈价</span>
+              <input id="cmp-tp" type="number" min="0" step="any" value="3700" required />
+            </label>
+          </div>
+        </section>
+        <div class="cmp-input-cols">
+          <section class="card">
+            <h2>单独期权</h2>
+            <div class="cmp-form-grid">
+              <label class="cmp-field">
+                <span>类型</span>
+                <select id="cmp-opt-type">
+                  <option value="C" selected>Call</option>
+                  <option value="P">Put</option>
+                </select>
+              </label>
+              <label class="cmp-field">
+                <span>行权价</span>
+                <input id="cmp-opt-strike" type="number" min="0" step="any" value="3600" />
+              </label>
+              <label class="cmp-field">
+                <span>卖一价(每币)</span>
+                <input id="cmp-opt-ask" type="number" min="0" step="any" value="50" />
+              </label>
+              <label class="cmp-field">
+                <span>期权目标价(默认同止盈)</span>
+                <input id="cmp-tp-opt" type="number" min="0" step="any" placeholder="空=用止盈价" />
+              </label>
+            </div>
+          </section>
+          <section class="card">
+            <h2>期期对冲 · 主腿 70%</h2>
+            <div class="cmp-form-grid">
+              <label class="cmp-field">
+                <span>类型</span>
+                <select id="cmp-hedge-main-type">
+                  <option value="C" selected>Call</option>
+                  <option value="P">Put</option>
+                </select>
+              </label>
+              <label class="cmp-field">
+                <span>行权价</span>
+                <input id="cmp-hedge-main-strike" type="number" min="0" step="any" value="3600" />
+              </label>
+              <label class="cmp-field">
+                <span>卖一价</span>
+                <input id="cmp-hedge-main-ask" type="number" min="0" step="any" value="50" />
+              </label>
+            </div>
+            <h2 class="cmp-subhead">次腿 30%</h2>
+            <div class="cmp-form-grid">
+              <label class="cmp-field">
+                <span>类型</span>
+                <select id="cmp-hedge-side-type">
+                  <option value="C">Call</option>
+                  <option value="P" selected>Put</option>
+                </select>
+              </label>
+              <label class="cmp-field">
+                <span>行权价</span>
+                <input id="cmp-hedge-side-strike" type="number" min="0" step="any" value="3400" />
+              </label>
+              <label class="cmp-field">
+                <span>卖一价</span>
+                <input id="cmp-hedge-side-ask" type="number" min="0" step="any" value="30" />
+              </label>
+              <label class="cmp-field">
+                <span>对冲目标价(默认同止盈)</span>
+                <input id="cmp-tp-hedge" type="number" min="0" step="any" placeholder="空=用止盈价" />
+              </label>
+            </div>
+          </section>
+        </div>
+      </form>
+      <div id="cmp-summary" class="cmp-summary"></div>
+      <div id="cmp-table-wrap" class="cmp-table-wrap"></div>
+      <div id="cmp-recommend" class="cmp-recommend"></div>
+    </div>
+
     <div id="page-strategy" class="page hidden">
       <div class="page-head strategy-page-head">
         <div>
           <h1><span class="head-tag">STR</span> 策略说明</h1>
-          <p class="page-desc">策略正文(带目录) · 执行清单(打印对照) · 三所切换</p>
+          <p class="page-desc">执行手册 · 三所策略正文(带目录) · 执行清单(打印对照)</p>
         </div>
         <div class="strategy-page-actions no-print">
           <button type="button" id="strategy-btn-download" class="ghost">下载 HTML</button>
@@ -1003,6 +1124,102 @@
       </div>
     </div>
 
+    <div id="page-amp-stats" class="page hidden">
+      <div class="page-head">
+        <div>
+          <h1><span class="head-tag">AMP</span> 振幅统计</h1>
+          <p class="page-desc">OKX 指数 · 整点起点 → 固定 16:00 · 点数振幅档案(只读)</p>
+        </div>
+      </div>
+      <div class="amp-view-tabs" role="tablist" aria-label="振幅视图">
+        <button type="button" class="amp-view-tab is-active" data-view="stats" role="tab" aria-selected="true">统计</button>
+        <button type="button" class="amp-view-tab" data-view="history" role="tab" aria-selected="false">历史</button>
+      </div>
+      <section id="amp-panel-stats" class="card amp-panel">
+        <div class="amp-form">
+          <label class="amp-field">
+            <span>标的</span>
+            <select id="amp-symbol">
+              <option value="eth" selected>ETH</option>
+              <option value="btc">BTC</option>
+            </select>
+          </label>
+          <label class="amp-field">
+            <span>数据源</span>
+            <input type="text" value="OKX" disabled />
+          </label>
+          <label class="amp-field">
+            <span>起点整点</span>
+            <select id="amp-start-hour"></select>
+          </label>
+          <label class="amp-field">
+            <span>终点</span>
+            <input type="text" value="16:00" disabled />
+          </label>
+          <label class="amp-field">
+            <span>周期</span>
+            <select id="amp-period">
+              <option value="1m">1个月</option>
+              <option value="2m" selected>2个月</option>
+              <option value="3m">3个月</option>
+              <option value="6m">半年</option>
+              <option value="1y">1年</option>
+              <option value="custom">自定义</option>
+            </select>
+          </label>
+          <label class="amp-field hidden" id="amp-custom-wrap">
+            <span>自定义天数</span>
+            <input id="amp-custom-days" type="number" min="7" max="400" value="60" />
+          </label>
+          <label class="amp-field">
+            <span>周末</span>
+            <select id="amp-weekend-filter">
+              <option value="all" selected>全部</option>
+              <option value="exclude">排除周末</option>
+              <option value="only">仅周末</option>
+            </select>
+          </label>
+          <label class="amp-field">
+            <span>买跨·双边权利金(点)</span>
+            <input id="amp-straddle-premium" type="number" min="0" step="any" placeholder="如 30" />
+          </label>
+          <label class="amp-field">
+            <span>止盈点(点)</span>
+            <input id="amp-take-profit" type="number" min="0" step="any" placeholder="空=按涨跌" />
+          </label>
+          <div class="amp-actions">
+            <button type="button" id="amp-btn-compute" class="primary">计算</button>
+            <button type="button" id="amp-btn-save" class="ghost">保存到历史</button>
+            <button type="button" id="amp-btn-download" class="ghost">下载 CSV</button>
+          </div>
+        </div>
+        <p id="amp-status" class="toolbar-meta amp-status"></p>
+        <p class="amp-hint">口径:开→高=最高−开盘;开→低=开盘−最低;振幅=最高−最低.买跨收益=有效波动−权利金;止盈≥触达则有效波动=止盈点,否则用|涨跌|.周末按结算日标注/筛选.</p>
+        <h3 class="amp-block-title">汇总</h3>
+        <div id="amp-summary" class="amp-summary"></div>
+        <h3 class="amp-block-title">买跨对照</h3>
+        <div id="amp-straddle" class="amp-summary amp-straddle"></div>
+        <h3 class="amp-block-title">日表明细</h3>
+        <div class="amp-table-wrap">
+          <table class="amp-table">
+            <thead>
+              <tr>
+                <th>结算日</th><th>窗起点</th><th>开</th><th>高</th><th>低</th><th>收</th>
+                <th>开→高</th><th>开→低</th><th>振幅</th><th>涨跌</th><th>收益</th>
+              </tr>
+            </thead>
+            <tbody id="amp-table-body">
+              <tr><td colspan="11" class="amp-empty">点击「计算」加载</td></tr>
+            </tbody>
+          </table>
+        </div>
+        <div id="amp-pager" class="amp-pager"></div>
+      </section>
+      <section id="amp-panel-history" class="card amp-panel hidden">
+        <div id="amp-history-list" class="amp-history-list"></div>
+      </section>
+    </div>
+
     <div id="page-help" class="page hidden">
       <div class="page-head">
         <div>
@@ -1115,7 +1332,7 @@
             </div>
             <label class="chk-label settings-display-chk">
               <input type="checkbox" id="pref-show-account-pnl" checked />
-              监控区显示资金账户,交易账户与浮动盈亏
+              监控区/数据看板显示资金账户、交易账户与浮动盈亏（关闭可隐藏期权盈亏与总浮盈）
             </label>
             <label class="chk-label settings-display-chk">
               <input type="checkbox" id="pref-show-nav-funds" checked />
@@ -1145,10 +1362,18 @@
               <input type="checkbox" id="pref-show-nav-calculator" checked />
               顶栏显示「计算器」
             </label>
+            <label class="chk-label settings-display-chk">
+              <input type="checkbox" id="pref-show-nav-compare" checked />
+              顶栏显示「策略对比」
+            </label>
             <label class="chk-label settings-display-chk">
               <input type="checkbox" id="pref-show-nav-strategy" checked />
               顶栏显示「策略说明」
             </label>
+            <label class="chk-label settings-display-chk">
+              <input type="checkbox" id="pref-show-nav-amp-stats" checked />
+              顶栏显示「振幅统计」
+            </label>
             <label class="chk-label settings-display-chk">
               <input type="checkbox" id="pref-show-nav-help" checked />
               顶栏显示「使用说明」
@@ -1343,6 +1568,8 @@
         <a href="/quotes" id="m-nav-quotes">语录</a>
         <a href="/dashboard" id="m-nav-dashboard">数据看板</a>
         <a href="/strategy" id="m-nav-strategy">策略说明</a>
+        <a href="/amp-stats" id="m-nav-amp-stats">振幅统计</a>
+        <a href="/compare" id="m-nav-compare">策略对比</a>
         <a href="/help" id="m-nav-help">使用说明</a>
         <a href="/logs" id="m-nav-logs">系统日志</a>
         <a href="/settings" id="m-nav-settings">系统设置</a>
@@ -1400,19 +1627,21 @@
   <script src="/assets/chart.js?v=20260720-option-day-1600"></script>
   <script src="/assets/plan.js?v=20260720-autofill"></script>
   <script src="/assets/calculator.js?v=20260715-calc-tabs"></script>
+  <script src="/assets/compare.js?v=20260723-compare"></script>
   <script src="/assets/trade_stats_calendar.js?v=3"></script>
   <script src="/assets/archive.js?v=20260717-archive-cal-chart"></script>
   <script src="/assets/quotes.js?v=20260717-quotes-feed"></script>
   <script src="/assets/funds.js?v=20260717-funds-scroll-fix"></script>
-  <script src="/assets/dashboard.js?v=20260720-dash-sl-tp"></script>
-  <script src="/assets/strategy.js?v=8"></script>
+  <script src="/assets/dashboard.js?v=20260723-hide-pnl"></script>
+  <script src="/assets/strategy.js?v=9"></script>
+  <script src="/assets/amp_stats.js?v=5"></script>
   <script src="/assets/help.js?v=1"></script>
   <script src="/assets/logs.js?v=1"></script>
   <script src="/assets/ai_review_render.js?v=3"></script>
   <script src="/assets/time_close_ui.js?v=3"></script>
   <script src="/assets/options_expiry_countdown.js?v=1"></script>
-  <script src="/assets/options_position_cards.js?v=2"></script>
+  <script src="/assets/options_position_cards.js?v=3"></script>
   <script src="/assets/backup.js?v=1"></script>
-  <script src="/assets/app.js?v=20260720-dash-back"></script>
+  <script src="/assets/app.js?v=20260723-compare"></script>
 </body>
 </html>

manual_trading_hub/static/strategy.js

@@ -21,7 +21,7 @@
   const btnPrintChecklistInline = document.getElementById("strategy-btn-print-checklist-inline");
   const btnDownload = document.getElementById("strategy-btn-download");
 
-  let activeKey = "binance";
+  let activeKey = "playbook";
   let activeView = "doc";
   let tabsMeta = [];
   let cache = {};
@@ -128,13 +128,14 @@
 
   function sectionTag(title) {
     const t = String(title || "");
-    if (/账户|定位/.test(t)) return "账户";
-    if (/开仓类型|开仓|入场|反转|顺势|波段|假破|结构/.test(t)) return "入场";
+    if (/总原则|原则/.test(t)) return "原则";
+    if (/账户|定位|分工/.test(t)) return "账户";
+    if (/开仓类型|开仓|入场|反转|顺势|波段|假破|结构|对冲|方向单/.test(t)) return "入场";
     if (/周期/.test(t)) return "周期";
     if (/方向/.test(t)) return "方向";
-    if (/纪律|出场|笔数|节奏/.test(t)) return "纪律";
-    if (/持仓|离场|强平/.test(t)) return "离场";
-    if (/资金|杠杆|计仓/.test(t)) return "仓位";
+    if (/纪律|出场|笔数|节奏|止损|次数/.test(t)) return "纪律";
+    if (/持仓|离场|强平|到期/.test(t)) return "离场";
+    if (/资金|杠杆|计仓|仓位|预算/.test(t)) return "仓位";
     if (/系统|字段|对接/.test(t)) return "系统";
     if (/修订|记录/.test(t)) return "版本";
     if (/边界|关系|行情状态/.test(t)) return "边界";

tests/test_account_risk_lib.py

@@ -20,6 +20,7 @@ from lib.trade.account_risk_lib import (
     enrich_risk_status_countdown,
     ensure_account_risk_schema,
     max_active_positions_from_env,
+    on_closed_trade_pnl,
     on_journal_saved,
     on_manual_close,
     on_user_initiated_close,
@@ -58,6 +59,7 @@ class AccountRiskLibTests(unittest.TestCase):
         os.environ["RISK_COOLING_HOURS_MANUAL"] = "4"
         os.environ["RISK_COOLING_HOURS_MANUAL_JOURNAL"] = "1"
         os.environ["RISK_MANUAL_CLOSE_DAILY_LIMIT"] = "2"
+        os.environ["RISK_DAILY_LOSS_LIMIT"] = "2"
         os.environ["RISK_MOOD_ISSUES_DAILY_FREEZE"] = "1"
         os.environ["APP_TIMEZONE"] = "Asia/Shanghai"
 
@@ -521,6 +523,41 @@ class AccountRiskLibTests(unittest.TestCase):
         os.environ["MAX_ACTIVE_POSITIONS"] = "3"
         self.assertEqual(max_active_positions_from_env(), 3)
 
+    def test_daily_loss_limit_freezes_on_second_loss(self):
+        conn = _mem_conn()
+        now = datetime(2026, 6, 14, 12, 0, 0)
+        on_closed_trade_pnl(conn, pnl_amount=-1.5, trading_day="2026-06-14", now=now)
+        st = compute_account_risk_status(conn, trading_day="2026-06-14", now=now)
+        self.assertEqual(st["daily_loss_count"], 1)
+        self.assertEqual(st["status"], STATUS_NORMAL)
+        on_closed_trade_pnl(conn, pnl_amount=-0.2, trading_day="2026-06-14", now=now)
+        st2 = compute_account_risk_status(conn, trading_day="2026-06-14", now=now)
+        self.assertEqual(st2["daily_loss_count"], 2)
+        self.assertEqual(st2["status"], STATUS_DAILY)
+        self.assertFalse(st2["can_trade"])
+        self.assertIn("日亏损", st2["reason"])
+
+    def test_daily_loss_limit_zero_disables(self):
+        os.environ["RISK_DAILY_LOSS_LIMIT"] = "0"
+        conn = _mem_conn()
+        now = datetime(2026, 6, 14, 12, 0, 0)
+        on_closed_trade_pnl(conn, pnl_amount=-10, trading_day="2026-06-14", now=now)
+        on_closed_trade_pnl(conn, pnl_amount=-10, trading_day="2026-06-14", now=now)
+        st = compute_account_risk_status(conn, trading_day="2026-06-14", now=now)
+        self.assertEqual(st["daily_loss_count"], 0)
+        self.assertEqual(st["daily_loss_limit"], 0)
+        self.assertEqual(st["status"], STATUS_NORMAL)
+        self.assertTrue(st["can_trade"])
+
+    def test_profitable_close_does_not_count_loss(self):
+        conn = _mem_conn()
+        now = datetime(2026, 6, 14, 12, 0, 0)
+        on_closed_trade_pnl(conn, pnl_amount=3.2, trading_day="2026-06-14", now=now)
+        on_closed_trade_pnl(conn, pnl_amount=0, trading_day="2026-06-14", now=now)
+        st = compute_account_risk_status(conn, trading_day="2026-06-14", now=now)
+        self.assertEqual(st["daily_loss_count"], 0)
+        self.assertEqual(st["status"], STATUS_NORMAL)
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_amp_stats_lib.py

@@ -0,0 +1,329 @@
+"""振幅统计核心逻辑单元测试(不打交易所)."""
+from __future__ import annotations
+
+import unittest
+from datetime import date, datetime
+from zoneinfo import ZoneInfo
+
+from lib.hub.amp_stats_lib import (
+    build_export_csv,
+    compute_amp_stats,
+    compute_day_row,
+    list_settlement_dates,
+    summarize_rows,
+    window_bounds_for_settlement,
+)
+
+import httpx
+
+TZ = ZoneInfo("Asia/Shanghai")
+
+
+def _bar(ts_ms: int, o: float, h: float, l: float, c: float) -> dict:
+    return {"ts": ts_ms, "o": o, "h": h, "l": l, "c": c}
+
+
+class AmpStatsLibTests(unittest.TestCase):
+    def test_window_cross_day_22_to_16(self):
+        start, end = window_bounds_for_settlement(date(2026, 7, 22), 22)
+        self.assertEqual(start.strftime("%Y-%m-%d %H:%M"), "2026-07-21 22:00")
+        self.assertEqual(end.strftime("%Y-%m-%d %H:%M"), "2026-07-22 16:00")
+
+    def test_window_same_day_8_to_16(self):
+        start, end = window_bounds_for_settlement(date(2026, 7, 22), 8)
+        self.assertEqual(start.strftime("%Y-%m-%d %H:%M"), "2026-07-22 08:00")
+        self.assertEqual(end.strftime("%Y-%m-%d %H:%M"), "2026-07-22 16:00")
+
+    def test_settlement_excludes_incomplete_today(self):
+        now = datetime(2026, 7, 22, 10, 0, tzinfo=TZ)
+        days = list_settlement_dates(sample_days=3, now=now)
+        self.assertEqual(days[0].isoformat(), "2026-07-21")
+        self.assertEqual(len(days), 3)
+
+    def test_settlement_includes_today_after_1600(self):
+        now = datetime(2026, 7, 22, 16, 0, tzinfo=TZ)
+        days = list_settlement_dates(sample_days=1, now=now)
+        self.assertEqual(days[0].isoformat(), "2026-07-22")
+
+    def test_day_row_points(self):
+        # 22:00 D-1 → 16:00 D; O=2000 H=2500 L=1800 C=2100 → up500 down200 amp700
+        settlement = date(2026, 7, 22)
+        start, end = window_bounds_for_settlement(settlement, 22)
+        bar_map = {}
+        t = int(start.timestamp() * 1000)
+        last = int((end.replace(hour=15)).timestamp() * 1000)
+        # first bar
+        bar_map[t] = {"o": 2000.0, "h": 2100.0, "l": 1950.0, "c": 2050.0}
+        cur = t + 3600 * 1000
+        while cur < last:
+            bar_map[cur] = {"o": 2050.0, "h": 2200.0, "l": 1900.0, "c": 2100.0}
+            cur += 3600 * 1000
+        # peak and trough somewhere
+        mid = t + 5 * 3600 * 1000
+        bar_map[mid] = {"o": 2100.0, "h": 2500.0, "l": 1800.0, "c": 2000.0}
+        bar_map[last] = {"o": 2000.0, "h": 2150.0, "l": 1990.0, "c": 2100.0}
+        # fill any missing hours with flat
+        cur = t
+        while cur <= last:
+            if cur not in bar_map:
+                bar_map[cur] = {"o": 2000.0, "h": 2000.0, "l": 2000.0, "c": 2000.0}
+            cur += 3600 * 1000
+        row = compute_day_row(settlement, 22, bar_map)
+        self.assertIsNotNone(row)
+        self.assertEqual(row["open"], 2000.0)
+        self.assertEqual(row["high"], 2500.0)
+        self.assertEqual(row["low"], 1800.0)
+        self.assertEqual(row["up_points"], 500.0)
+        self.assertEqual(row["down_points"], 200.0)
+        self.assertEqual(row["amplitude"], 700.0)
+        self.assertEqual(row["change"], 100.0)
+
+    def test_summary_max_amplitude(self):
+        rows = [
+            {"amplitude": 100, "up_points": 40, "down_points": 60, "change": 10, "settlement_day": "2026-07-01"},
+            {"amplitude": 700, "up_points": 500, "down_points": 200, "change": -5, "settlement_day": "2026-07-02"},
+            {"amplitude": 200, "up_points": 50, "down_points": 150, "change": 20, "settlement_day": "2026-07-03"},
+        ]
+        s = summarize_rows(rows)
+        self.assertEqual(s["max_amplitude"], 700)
+        self.assertEqual(s["max_amplitude_day"], "2026-07-02")
+        self.assertEqual(s["max_up_points"], 500)
+        self.assertEqual(s["max_down_points"], 200)
+        self.assertIsNone(s["straddle"])
+
+    def test_long_straddle_stats(self):
+        rows = [
+            # |chg|=40>30 win+10; up=40>30; down=10
+            {"up_points": 40, "down_points": 10, "change": 40, "amplitude": 50, "settlement_day": "2026-07-01"},
+            # |chg|=10 lose-20; up=5; down=35>30
+            {"up_points": 5, "down_points": 35, "change": -10, "amplitude": 40, "settlement_day": "2026-07-02"},
+            # |chg|=30 not >30 lose-30; boundary
+            {"up_points": 30, "down_points": 30, "change": 30, "amplitude": 60, "settlement_day": "2026-07-03"},
+        ]
+        s = summarize_rows(rows, straddle_premium=30)
+        st = s["straddle"]
+        self.assertEqual(st["side"], "long_straddle")
+        self.assertEqual(st["premium"], 30)
+        self.assertEqual(st["up_exceed_days"], 1)  # only 40
+        self.assertEqual(st["down_exceed_days"], 1)  # only 35
+        self.assertEqual(st["abs_change_exceed_days"], 1)  # only 40
+        self.assertAlmostEqual(st["pnl_total"], 40 - 30 + 10 - 30 + 30 - 30)
+        self.assertEqual(st["win_days"], 1)
+        self.assertEqual(st["win_ratio"], round(1 / 3, 4))
+        csv_text = build_export_csv(
+            {"exchange": "okx", "symbol_label": "ETH", "summary": s, "rows": rows, "start_hour": 22, "end_hour": 16}
+        )
+        self.assertIn("买跨对照", csv_text)
+        self.assertIn("买跨点数盈亏合计", csv_text)
+
+    def test_take_profit_and_weekend(self):
+        from lib.hub.amp_stats_lib import (
+            enrich_rows_pnl,
+            filter_weekend_rows,
+            reframe_amp_stats,
+        )
+
+        # Sat 2026-07-18, Sun 2026-07-19, Mon 2026-07-20
+        rows = [
+            {
+                "settlement_day": "2026-07-18",
+                "is_weekend": True,
+                "weekday_label": "六",
+                "up_points": 100,
+                "down_points": 10,
+                "change": -5,
+                "amplitude": 110,
+            },
+            {
+                "settlement_day": "2026-07-19",
+                "is_weekend": True,
+                "weekday_label": "日",
+                "up_points": 20,
+                "down_points": 15,
+                "change": 12,
+                "amplitude": 35,
+            },
+            {
+                "settlement_day": "2026-07-20",
+                "is_weekend": False,
+                "weekday_label": "",
+                "up_points": 50,
+                "down_points": 40,
+                "change": 8,
+                "amplitude": 90,
+            },
+        ]
+        excl = filter_weekend_rows(rows, "exclude")
+        self.assertEqual(len(excl), 1)
+        self.assertEqual(excl[0]["settlement_day"], "2026-07-20")
+        only = filter_weekend_rows(rows, "only")
+        self.assertEqual(len(only), 2)
+
+        # TP=80: day1 hit → move 80; day2 no → |12|; day3 no → 8
+        enriched = enrich_rows_pnl(rows, straddle_premium=10, take_profit=80)
+        self.assertTrue(enriched[0]["take_profit_hit"])
+        self.assertEqual(enriched[0]["effective_move"], 80)
+        self.assertEqual(enriched[0]["profit"], 70)
+        self.assertFalse(enriched[1]["take_profit_hit"])
+        self.assertEqual(enriched[1]["effective_move"], 12)
+        self.assertEqual(enriched[1]["profit"], 2)
+        # TP empty → use |change|
+        no_tp = enrich_rows_pnl(rows[:1], straddle_premium=10, take_profit=None)
+        self.assertEqual(no_tp[0]["effective_move"], 5)
+        self.assertEqual(no_tp[0]["profit"], -5)
+
+        # TP boundary >= : up=80 counts as hit
+        edge = enrich_rows_pnl(
+            [{"up_points": 80, "down_points": 1, "change": 2, "settlement_day": "2026-07-20", "is_weekend": False}],
+            straddle_premium=10,
+            take_profit=80,
+        )
+        self.assertTrue(edge[0]["take_profit_hit"])
+        self.assertEqual(edge[0]["profit"], 70)
+
+        reframed = reframe_amp_stats(
+            rows_all=rows,
+            symbol="eth",
+            weekend_filter="exclude",
+            straddle_premium=10,
+            take_profit=80,
+        )
+        self.assertEqual(reframed["summary"]["sample_count"], 1)
+        # Mon: 未触达止盈 → |8|-10
+        self.assertEqual(reframed["rows"][0]["profit"], -2)
+        self.assertIn("收益", build_export_csv(reframed))
+
+    def test_fetch_switches_to_history_endpoint(self):
+        """近期接口到头后应切 history 续拉."""
+        from lib.hub.amp_stats_lib import fetch_okx_candles
+
+        calls: list[str] = []
+
+        class FakeResp:
+            def __init__(self, data, url="https://x", status_code=200):
+                self._data = data
+                self.status_code = status_code
+                self.url = url
+                self.request = httpx.Request("GET", url)
+
+            def raise_for_status(self):
+                if self.status_code >= 400:
+                    raise httpx.HTTPStatusError(
+                        "err", request=self.request, response=self
+                    )
+
+            def json(self):
+                return {"code": "0", "data": self._data}
+
+        class FakeClient:
+            def get(self, url, params=None):
+                calls.append(url)
+                after = (params or {}).get("after")
+                # recent: only 2 pages then empty; history continues
+                if "history" not in url:
+                    if after is None:
+                        return FakeResp([["2000", "1", "2", "0.5", "1.5"], ["1900", "1", "2", "0.5", "1.5"]], url=url)
+                    if after == "1900":
+                        return FakeResp([], url=url)  # recent exhausted
+                    return FakeResp([], url=url)
+                # history
+                if after == "1900":
+                    return FakeResp([["1800", "1", "2", "0.5", "1.5"], ["1000", "1", "2", "0.5", "1.5"]], url=url)
+                return FakeResp([], url=url)
+
+            def close(self):
+                return None
+
+        bars = fetch_okx_candles(
+            url="https://www.okx.com/api/v5/market/index-candles",
+            history_url="https://www.okx.com/api/v5/market/history-index-candles",
+            inst_id="ETH-USD",
+            since_ms=1000,
+            until_ms=3000,
+            client=FakeClient(),
+            max_pages=10,
+            page_pause_sec=0,
+            history_page_pause_sec=0,
+        )
+        self.assertTrue(any("history-index-candles" in u for u in calls))
+        self.assertGreaterEqual(len(bars), 3)
+        self.assertEqual(bars[0]["ts"], 1000)
+
+    def test_fetch_retries_on_429(self):
+        from lib.hub.amp_stats_lib import fetch_okx_candles
+        import httpx as _httpx
+
+        hits = {"n": 0}
+
+        class FakeResp:
+            def __init__(self, status_code, data=None):
+                self.status_code = status_code
+                self.url = "https://www.okx.com/api/v5/market/history-candles"
+                self.request = _httpx.Request("GET", self.url)
+                self._data = data or []
+
+            def raise_for_status(self):
+                if self.status_code >= 400:
+                    raise _httpx.HTTPStatusError("429", request=self.request, response=self)
+
+            def json(self):
+                return {"code": "0", "data": self._data}
+
+        class FakeClient:
+            def get(self, url, params=None):
+                hits["n"] += 1
+                if hits["n"] < 3:
+                    return FakeResp(429)
+                return FakeResp(200, [["1000", "1", "2", "0.5", "1.5"]])
+
+            def close(self):
+                return None
+
+        bars = fetch_okx_candles(
+            url="https://www.okx.com/api/v5/market/candles",
+            history_url=None,
+            inst_id="ETH-USDT-SWAP",
+            since_ms=1000,
+            until_ms=2000,
+            client=FakeClient(),
+            max_pages=3,
+            page_pause_sec=0,
+            history_page_pause_sec=0,
+        )
+        self.assertGreaterEqual(hits["n"], 3)
+        self.assertEqual(len(bars), 1)
+
+    def test_compute_with_mock_fetch(self):
+        now = datetime(2026, 7, 22, 18, 0, tzinfo=TZ)
+
+        def fetch_fn(*, inst_id, since_ms, until_ms):
+            bars = []
+            t = since_ms - (since_ms % (3600 * 1000))
+            while t <= until_ms:
+                # synthetic: open 2000, one spike day
+                o = 2000.0
+                h = 2500.0 if t == since_ms + 5 * 3600 * 1000 else 2050.0
+                l = 1800.0 if t == since_ms + 5 * 3600 * 1000 else 1950.0
+                c = 2020.0
+                bars.append(_bar(t, o, h, l, c))
+                t += 3600 * 1000
+            return bars
+
+        result = compute_amp_stats(
+            symbol="eth",
+            start_hour=16,
+            period="custom",
+            custom_days=7,
+            now=now,
+            fetch_fn=fetch_fn,
+        )
+        self.assertTrue(result["ok"])
+        self.assertEqual(result["exchange"], "okx")
+        self.assertGreaterEqual(result["summary"]["sample_count"], 1)
+        csv_text = build_export_csv(result)
+        self.assertIn("最大振幅", csv_text)
+        self.assertIn("日表明细", csv_text)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_hub_ai_options_playbook.py

@@ -0,0 +1,97 @@
+"""hub_ai:期权持仓进教练上下文 + 执行手册摘要."""
+from __future__ import annotations
+
+import unittest
+
+from hub_ai.context import (
+    format_chat_context_for_chat,
+    format_chat_context_slim,
+    format_chat_position_overview,
+)
+from hub_ai.playbook_brief import format_playbook_brief_for_chat
+from hub_ai.prompts import build_chat_user_prompt
+
+
+def _sample_payload():
+    return {
+        "totals": {
+            "trading_day": "2026-07-22",
+            "total_pnl_u": 0,
+            "closed_count": 0,
+            "win_count": 0,
+            "loss_count": 0,
+            "float_pnl_u": 1.25,
+            "open_position_count": 1,
+            "options_open_position_count": 1,
+            "perpetual_open_position_count": 0,
+        },
+        "accounts": [
+            {
+                "name": "OKX_趋势",
+                "key": "okx",
+                "status": "已监控",
+                "open_position_count": 1,
+                "options_open_position_count": 1,
+                "float_pnl_u": 1.25,
+                "funding_usdt": 100,
+                "trading_usdt": 50,
+                "trade_stats": {"total_pnl_u": 0, "closed_count": 0, "win_count": 0, "loss_count": 0},
+                "positions": [],
+                "trades": [],
+                "monitor_lines": {},
+                "options_snapshot": {
+                    "ok": True,
+                    "enabled": True,
+                    "positions": [
+                        {
+                            "inst_id": "ETH-USD-260723-3500-C",
+                            "opt_type": "C",
+                            "pos": 1,
+                            "premium_paid": 8.5,
+                            "source_label": "纯期权",
+                            "source": "option",
+                            "upl": 1.25,
+                            "target_monitor_text": "目标 3600",
+                        }
+                    ],
+                },
+            }
+        ],
+    }
+
+
+class HubAiOptionsPlaybookTests(unittest.TestCase):
+    def test_chat_slim_includes_options_line(self):
+        text = format_chat_context_slim(_sample_payload())
+        self.assertIn("期权 ETH-USD-260723-3500-C Call", text)
+        self.assertIn("永续0/期权1", text)
+        self.assertIn("权利金8.5U", text)
+
+    def test_overview_lists_options(self):
+        text = format_chat_position_overview(_sample_payload())
+        self.assertIn("期权1", text)
+        self.assertIn("ETH-USD-260723-3500-C", text)
+
+    def test_chat_bundle_keeps_options(self):
+        text = format_chat_context_for_chat(_sample_payload(), max_chars=8000)
+        self.assertIn("ETH-USD-260723-3500-C", text)
+        self.assertIn("期权", text)
+
+    def test_playbook_brief_injected(self):
+        brief = format_playbook_brief_for_chat()
+        self.assertIn("执行手册", brief)
+        self.assertIn("OKX", brief)
+        self.assertIn("不手动平仓", brief)
+        prompt = build_chat_user_prompt(
+            context_text="快照",
+            trading_day="2026-07-22",
+            summary_excerpt="",
+            user_message="今天怎么样",
+            playbook_brief=brief,
+        )
+        self.assertIn("用户策略执行手册", prompt)
+        self.assertIn("不手动平仓", prompt)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_hub_compare_lib.py

@@ -0,0 +1,82 @@
+"""策略对比仓位与情景测算."""
+from __future__ import annotations
+
+from lib.hub.hub_compare_lib import run_compare
+
+
+def test_long_eth_realistic_asks():
+    out = run_compare(
+        {
+            "base": "ETH",
+            "direction": "long",
+            "entry": 3500,
+            "sl": 3400,
+            "tp": 3700,
+            "risk_u": 10,
+            "option": {"opt_type": "C", "strike": 3600, "ask": 50},
+            "hedge": {
+                "main": {"opt_type": "C", "strike": 3600, "ask": 50},
+                "side": {"opt_type": "P", "strike": 3400, "ask": 30},
+            },
+        }
+    )
+    assert out["ok"] is True
+    perp = out["perp"]
+    # 每张止损 = 100 * 0.01 = 1U → 10 张
+    assert perp["sheets"] == 10
+    assert abs(perp["path_b_sl"] + 10) < 1e-6
+    assert perp["path_a_tp"] > 0
+    assert perp["path_c_realized"] == perp["path_b_sl"]
+    assert perp["path_c_missed"] == perp["path_a_tp"]
+
+    opt = out["option"]
+    assert opt["ok"] is True
+    # unit = 50 * 0.01 = 0.5U → 20 张, premium = 10
+    assert opt["sheets"] == 20
+    assert abs(opt["premium_u"] - 10) < 1e-6
+    assert abs(opt["path_b_worst"] + 10) < 1e-6
+    # at TP 3700, call 3600 intrinsic = 100 * 20 * 0.01 = 20, pnl = 20-10 = 10
+    assert abs(opt["path_a_tp"] - 10) < 1e-6
+    assert abs(opt["path_c_hold_to_tp"] - opt["path_a_tp"]) < 1e-6
+
+    hedge = out["hedge"]
+    assert hedge["ok"] is True
+    # main budget 7, unit 0.5 → 14 sheets; side budget 3, unit 0.3 → 10 sheets
+    assert hedge["main"]["sheets"] == 14
+    assert hedge["side"]["sheets"] == 10
+    assert out["recommend"]["choice"] in ("合约", "单期权", "期期对冲")
+
+
+def test_short_validation():
+    bad = run_compare(
+        {
+            "base": "ETH",
+            "direction": "short",
+            "entry": 3500,
+            "sl": 3400,
+            "tp": 3300,
+            "risk_u": 10,
+        }
+    )
+    assert bad["ok"] is False
+
+
+def test_recommend_has_bullets():
+    out = run_compare(
+        {
+            "base": "ETH",
+            "direction": "long",
+            "entry": 3500,
+            "sl": 3490,
+            "tp": 3520,
+            "risk_u": 10,
+            "option": {"opt_type": "C", "strike": 3500, "ask": 20},
+            "hedge": {
+                "main": {"opt_type": "C", "strike": 3500, "ask": 20},
+                "side": {"opt_type": "P", "strike": 3480, "ask": 15},
+            },
+        }
+    )
+    assert out["ok"] is True
+    assert out["recommend"]["choice"]
+    assert len(out["recommend"]["bullets"]) == 3

tests/test_hub_strategy_lib.py

@@ -12,10 +12,19 @@ from lib.hub.hub_strategy_lib import (
 
 
 class TestHubStrategyLib(unittest.TestCase):
-    def test_meta_has_three_exchanges(self):
+    def test_meta_has_playbook_and_exchanges(self):
         meta = strategy_meta_payload()
         keys = [x["key"] for x in meta["exchanges"]]
-        self.assertEqual(keys, ["binance", "okx", "gate"])
+        self.assertEqual(keys, ["playbook", "binance", "okx", "gate"])
+
+    def test_load_playbook_payload(self):
+        p = load_strategy_payload("playbook")
+        self.assertTrue(p["ok"])
+        self.assertEqual(p["label"], "执行手册")
+        self.assertIn("交易执行手册", p["md_source"])
+        self.assertIn("strategy_html", p)
+        self.assertIn("<h2", p["strategy_html"].lower())
+        self.assertIn("总原则", p["strategy_html"])
 
     def test_load_binance_payload(self):
         p = load_strategy_payload("binance")