Merge pull request #41 from WrBug/ai_fix/n_39

fix: backtest equity curve bugs

.cursor/skills/README.md

@@ -14,10 +14,6 @@
 │           └── package.json
 ├── backend/                     # 后端相关 skill
 └── common/                      # 通用 skill
-    └── create-release/          # 创建 GitHub Release
-        ├── SKILL.md
-        └── scripts/
-            └── create-release.sh
 ```
 
 - **SKILL.md**：YAML frontmatter（`name`、`description` 必填，`name` 须与父文件夹名一致、小写连字符）+ 给 Agent 的详细指令。
@@ -31,8 +27,7 @@
 
 ## 示例
 
-- `frontend/check-i18n-keys/SKILL.md` + `frontend/check-i18n-keys/scripts/` — 检查前端多语言 key
-- `common/create-release/SKILL.md` + `common/create-release/scripts/` — 创建 GitHub Release
+- `frontend/check-i18n-keys/SKILL.md` + `frontend/check-i18n-keys/scripts/` — 检查前端多语言 key。
 
 ## 运行 check-i18n-keys
 
@@ -42,17 +37,3 @@ npm install
 npm run check-i18n
 ```
 
-## 运行 create-release
-
-```bash
-cd .cursor/skills/common/create-release/scripts
-./create-release.sh -t v1.0.0 -T "Release v1.0.0" -d "发布说明"
-```
-
-参数说明：
-- `-t` 版本号（必需，格式 v1.0.0）
-- `-T` Release 标题
-- `-d` Release 描述
-- `-p` 标记为 Pre-release（自动加 -beta 后缀）
-- `-y` 无交互模式
-

.cursor/skills/common/create-release/SKILL.md

@@ -1,341 +0,0 @@
----
-name: create-release
-description: 创建 PolyHermes 项目的 GitHub Release。当用户要求发布版本、创建 release、打 tag 或发布新版本时使用。
----
-
-# Create Release
-
-创建 PolyHermes 项目的 GitHub Release，包括创建 Git tag、推送 tag、创建 GitHub Release（支持 pre-release），并自动在 Issue #1 发布公告。
-
-## 使用时机
-
-- 用户要求「发布版本」「创建 release」「打 tag」「发布新版本」时
-- 用户要求「创建 pre-release」「beta 版本」时
-- 用户提到「v1.x.x」等版本号相关操作时
-
-## 前置条件
-
-1. **GitHub CLI 已安装**：确保 `gh` 命令可用
-2. **已登录 GitHub**：运行 `gh auth status` 确认
-3. **工作目录干净**：建议先提交所有更改
-
-## 指令
-
-### 步骤 1：收集发布信息
-
-询问用户以下信息：
-- 版本号（格式：vX.Y.Z，如 v1.0.0）
-- 是否为 Pre-release（测试版本）
-- Release 标题和描述（可选，如未提供则自动生成）
-
-### 步骤 2：生成 Release 内容
-
-**重要**：如果用户未提供描述，需要根据 Git commits 自动生成。
-
-1. **获取上一个版本的 tag**：
-   ```bash
-   git describe --tags --abbrev=0 HEAD
-   ```
-
-2. **获取版本间的 commits**：
-   ```bash
-   git log <PREVIOUS_TAG>..HEAD --oneline --no-merges
-   ```
-
-3. **过滤 commit 规则**：
-   - **排除**：版本内新增功能的修复 commit
-   - **判断方法**：如果一个 commit 的消息包含「fix」「修复」「bugfix」等关键词，且是针对同一版本内新增代码的修复，则不包含
-   - **保留**：新功能、性能优化、重构、文档更新等
-
-4. **生成中英文 Release 内容**：
-   - 格式要求：**中文在上，英文在下**
-   - 使用分隔线 `---` 分隔中英文部分
-   - 按功能类型分组（新功能、改进、修复等）
-
-   示例格式：
-   ```markdown
-   ## 新功能
-
-   - 添加了 A 功能
-   - 支持了 B 操作
-
-   ## 改进
-
-   - 优化了 C 性能
-
-   ---
-
-   ## New Features
-
-   - Added feature A
-   - Supported operation B
-
-   ## Improvements
-
-   - Optimized performance C
-   ```
-
-### 步骤 3：运行发布脚本
-
-在项目根目录下执行：
-
-```bash
-cd .cursor/skills/common/create-release/scripts && \
-chmod +x create-release.sh && \
-./create-release.sh -t <VERSION> [-T "<TITLE>"] [-d "<DESCRIPTION>"] [-p] [-y]
-```
-
-### 步骤 4：发布公告到 Issue #1
-
-**重要**：Release 创建成功后，必须自动在 Issue #1 下发布公告 comment。
-
-1. **生成公告内容**（面向用户，通俗易懂）：
-
-   公告格式模板：
-   ```markdown
-   # 🎉 PolyHermes vX.X.X 版本发布公告
-
-   ## 📅 发布日期
-
-   YYYY年MM月DD日
-
-   ---
-
-   ## ✨ 本次更新亮点
-
-   ### 🚀 新功能
-
-   **功能名称**
-   - 用通俗的语言描述这个功能是什么
-   - 用户能从中获得什么好处
-   - 如何使用这个功能
-
-   ### 🔧 改进优化
-
-   - 优化了 XXX，现在 XXX 更快/更稳定了
-   - 改进了 XXX 体验，操作更简单了
-
-   ### 🐛 问题修复
-
-   - 修复了 XXX 问题，不再出现 XXX 情况
-
-   ---
-
-   ## 📦 如何更新
-
-   ### Docker 部署（推荐）
-
-   ```bash
-   # 拉取最新镜像
-   docker pull wrbug/polyhermes:vX.X.X
-
-   # 重启服务
-   docker-compose -f docker-compose.prod.yml down
-   docker-compose -f docker-compose.prod.yml up -d
-   ```
-
-   ---
-
-   ## ⚠️ 安全提醒
-
-   **请务必使用官方 Docker 镜像源，避免财产损失！**
-
-   **官方镜像地址**：`wrbug/polyhermes`
-
-   ---
-
-   ## 📚 相关链接
-
-   - **GitHub Release**: https://github.com/WrBug/PolyHermes/releases/tag/vX.X.X
-   - **Docker Hub**: https://hub.docker.com/r/wrbug/polyhermes
-   ```
-
-2. **公告内容编写原则**：
-
-   - ✅ **通俗易懂**：避免技术术语，用用户能理解的语言
-   - ✅ **突出价值**：告诉用户这个更新对他们有什么好处
-   - ✅ **简洁明了**：每个功能点用 1-2 句话说明
-   - ✅ **包含操作指引**：告诉用户如何使用新功能
-   - ✅ **中英文双语**：中文在上，英文在下（可选）
-   - ❌ **避免**：commit hash、代码细节、内部实现
-
-3. **执行发布公告命令**：
-
-   ```bash
-   gh issue comment 1 --repo WrBug/PolyHermes --body "$(cat <<'EOF'
-   # 🎉 PolyHermes vX.X.X 版本发布公告
-
-   [公告内容...]
-
-   ---
-   EOF
-   )"
-   ```
-
-   或使用文件方式（内容较长时推荐）：
-
-   ```bash
-   echo "[公告内容...]" > /tmp/announcement.md
-   gh issue comment 1 --repo WrBug/PolyHermes --body-file /tmp/announcement.md
-   ```
-
-### 参数说明
-
-| 参数 | 说明 | 示例 |
-|------|------|------|
-| `-t, --tag` | 版本号（必需） | `-t v1.0.0` |
-| `-T, --title` | Release 标题 | `-T "Release v1.0.0"` |
-| `-d, --description` | Release 描述 | `-d "## 新功能\n- 功能1"` |
-| `-f, --description-file` | 从文件读取描述 | `-f CHANGELOG.md` |
-| `-p, --prerelease` | 标记为 Pre-release（自动加 -beta 后缀） | `-p` |
-| `-y, --yes` | 无交互模式 | `-y` |
-
-## 版本号格式
-
-- 必须格式：`v数字.数字.数字`（如 v1.0.0, v1.10.2, v1.1.12）
-- 如果指定 `--prerelease`，会自动拼接 `-beta` 后缀（如 v1.0.1 → v1.0.1-beta）
-
-## Release 内容生成规则
-
-### 中英文格式
-
-Release 描述**必须**使用中英文双语格式：
-
-```markdown
-## 中文标题
-
-- 内容项1
-- 内容项2
-
----
-
-## English Title
-
-- Item 1
-- Item 2
-```
-
-### Commit 过滤规则
-
-**需要排除的 commit 类型**：
-
-1. **版本内修复**：对同一版本新增功能的后续修复
-   - 例如：v1.0.1 新增了功能 A，然后有一个 commit 修复功能 A 的 bug → 不包含
-   - 判断依据：commit 消息包含「fix」「修复」「bugfix」且相关功能在本版本新增
-
-2. **琐碎修改**：
-   - typo 修正
-   - 代码格式调整
-   - 注释更新
-
-**需要保留的 commit 类型**：
-
-1. 新功能（feat、feature）
-2. 改进/优化（improve、optimize、enhance）
-3. 重要 bug 修复（针对旧版本的 bug）
-4. 重构（refactor）
-5. 文档更新（docs）
-
-### 分组建议
-
-- **新功能 / New Features**
-- **改进 / Improvements**
-- **修复 / Bug Fixes**（仅包含对旧版本 bug 的修复）
-- **其他 / Others**
-
-## 公告内容示例
-
-以下是一个面向用户的公告示例：
-
-```markdown
-# 🎉 PolyHermes v1.2.0 版本发布公告
-
-## 📅 发布日期
-
-2026年3月2日
-
----
-
-## ✨ 本次更新亮点
-
-### 🚀 新功能
-
-**系统自动更新**
-- 现在可以在网页上直接更新系统，无需手动重启 Docker
-- 更新过程约 30-60 秒，系统会自动处理
-- 如果更新失败，系统会自动恢复到旧版本
-
-**RPC 节点管理**
-- 可以在系统设置中添加、编辑、删除自定义 RPC 节点
-- 可以随时启用或禁用节点
-- 系统会自动选择可用的节点
-
-### 🔧 改进优化
-
-- **更快的跟单响应**：通过实时监听链上交易，跟单速度提升到秒级
-- **更准确的盈亏统计**：系统会自动追踪实际成交价，统计数据更准确
-- **内存占用优化**：修复了内存泄漏问题，系统可以长时间稳定运行
-
-### 🐛 问题修复
-
-- 修复了部分市场无法正确查询价格的问题
-- 修复了卖出订单偶发失败的问题
-
----
-
-## 📦 如何更新
-
-### 方式一：网页更新（推荐）
-
-1. 登录系统，进入 **系统设置** → **系统更新**
-2. 点击 **检查更新**
-3. 如果有新版本，点击 **立即升级**
-4. 等待更新完成即可
-
-### 方式二：Docker 更新
-
-```bash
-docker pull wrbug/polyhermes:v1.2.0
-docker-compose -f docker-compose.prod.yml down
-docker-compose -f docker-compose.prod.yml up -d
-```
-
----
-
-## ⚠️ 安全提醒
-
-**请务必使用官方 Docker 镜像源！**
-
-官方镜像：`wrbug/polyhermes`
-
----
-
-## 📚 相关链接
-
-- **GitHub Release**: https://github.com/WrBug/PolyHermes/releases/tag/v1.2.0
-- **Docker Hub**: https://hub.docker.com/r/wrbug/polyhermes
-```
-
-## 发布流程
-
-1. 验证版本号格式
-2. 检查 Git 工作目录状态
-3. 检查 tag 是否已存在
-4. 生成 Release 内容（中英文）
-5. 创建本地 tag
-6. 推送 tag 到远程
-7. 创建 GitHub Release
-8. **生成面向用户的公告内容**
-9. **发布公告到 Issue #1**
-10. 返回 Release URL 和公告链接
-
-## 注意事项
-
-- Pre-release 版本不会触发 Telegram 通知
-- GitHub Actions 会自动触发构建流程
-- 如果 tag 已存在，会提示是否删除并重新创建
-- **必须**在 Release 创建成功后发布公告到 Issue #1
-
-## 可选目录说明
-
-- `scripts/`：包含 `create-release.sh` 发布脚本

.github/ISSUE_TEMPLATE/ai-bug-report.yml

@@ -0,0 +1,183 @@
+---
+name: 🤖 Bug Report for AI Fix / AI Bug 报告
+description: Bug 报告模板
+title: '[Bug] / '
+assignees: []
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ## Bug Report Template 🐛
+
+        本模板用于报告 PolyHermes 项目的 bug。
+
+        ⚠️ **Important / 重要提示**：
+        - AI fixes will be on the `fix_issues_by_ai` branch / AI 修复将在 `fix_issues_by_ai` 分支上进行
+        - All AI fixes require human review before merging / 所有 AI 修复需要人工审核后才能合并
+        - Security vulnerabilities, database migrations, major changes are not recommended for AI auto-fix
+          / 涉及安全漏洞、数据库迁移、重大变更等问题不建议使用 AI 自动修复
+
+        ---
+        
+        本模板用于报告 PolyHermes 项目的 bug。
+
+        This template is for reporting bugs in the PolyHermes project.
+
+  - type: textarea
+    id: description
+    attributes:
+      label: 📝 Bug Description / Bug 描述
+      description: Clearly and concisely describe the bug / 清晰简洁地描述这个 bug
+      placeholder: Describe the bug you encountered / 描述你遇到的问题...
+    validations:
+      required: true
+
+  - type: dropdown
+    id: type
+    attributes:
+      label: 🎯 Bug Type / 问题类型
+      description: Select the type of bug / 选择问题类型
+      options:
+        - Frontend bug (UI/UX/interaction) / 前端 bug (UI/UX/交互问题)
+        - Backend bug (API/logic/data) / 后端 bug (API/逻辑/数据处理)
+        - Database issue / 数据库问题
+        - Performance issue / 性能问题
+        - Configuration/Deployment / 配置/部署问题
+        - Documentation / 文档问题
+        - Other / 其他
+    validations:
+      required: true
+
+  - type: dropdown
+    id: scope
+    attributes:
+      label: 📍 Affected Scope / 影响范围
+      description: Select the scope of impact / 选择问题影响范围
+      options:
+        - Specific page/function only / 仅影响特定页面/功能
+        - Entire system / 影响整个系统
+        - Specific user role / 影响特定用户角色
+        - Only in specific environment / 仅在特定环境下重现
+    validations:
+      required: true
+
+  - type: textarea
+    id: steps
+    attributes:
+      label: 🔍 Steps to Reproduce / 复现步骤
+      description: Provide clear, detailed steps to reproduce the bug / 提供清晰、详细的步骤来重现这个 bug
+      placeholder: |
+        1. Visit page: `...` / 访问页面：`...`
+        2. Click button: `...` / 点击按钮：`...`
+        3. Input data: `...` / 输入数据：`...`
+        4. Submit form: `...` / 提交表单：`...`
+        5. Observe error: `...` / 观察到错误：`...`
+    validations:
+      required: true
+
+  - type: dropdown
+    id: frequency
+    attributes:
+      label: Reproduction Frequency / 复现频率
+      options:
+        - Always reproducible (100%) / 总是能复现 (100%)
+        - Frequently reproducible (50%+) / 经常能复现 (50%+)
+        - Occasionally reproducible (<50%) / 偶尔能复现 (<50%)
+        - Hard to reproduce / 很难复现
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: 💻 Expected Behavior / 预期行为
+      description: Describe what you expected to happen / 描述你期望发生什么
+      placeholder: What should happen / 应该发生什么...
+    validations:
+      required: true
+
+  - type: textarea
+    id: actual
+    attributes:
+      label: ❌ Actual Behavior / 实际行为
+      description: Describe what actually happened / 描述实际发生了什么
+      placeholder: What actually happened / 实际发生了什么...
+    validations:
+      required: true
+
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: 📸 Screenshots / Recordings / 截图/录屏
+      description: If applicable, add screenshots or recordings to illustrate the problem (drag and drop files here)
+        / 如果适用，添加截图或录屏来说明问题（可以拖拽文件到这里）
+      placeholder: Add screenshots or recordings / 添加截图或录屏...
+
+  - type: textarea
+    id: environment
+    attributes:
+      label: 🌐 Environment / 环境
+      description: Provide relevant environment information / 提供相关环境信息
+      value: |
+        **Browser (for frontend issues) / 浏览器（前端问题）：**
+        - Browser: ______ / 浏览器：______
+        - Browser version: ______ / 浏览器版本：______
+        - Operating System: ______ / 操作系统：______
+
+        **Backend Environment (for backend issues) / 后端环境（后端问题）：**
+        - Node.js version: ______ / Node.js 版本：______
+        - Database version: ______ / 数据库版本：______
+        - Docker version (if used): ______ / Docker 版本（如果使用）：______
+        - Other relevant dependencies: ______ / 其他相关依赖版本：______
+    validations:
+      required: false
+
+  - type: textarea
+    id: related-files
+    attributes:
+      label: 📁 Related Files / Code / 相关文件/代码
+      description: Provide relevant file paths or code snippets / 提供可能涉及的文件路径或相关代码片段
+      placeholder: |
+        Possibly related files / 可能涉及的文件：
+        - frontend/src/components/...
+        - backend/src/main/kotlin/...
+
+        Error logs / 错误日志：
+        ```
+        Paste error logs here / 粘贴错误日志
+        ```
+    validations:
+      required: false
+
+  - type: textarea
+    id: suggestions
+    attributes:
+      label: 🎯 Fix Suggestions (Optional) / 修复建议（可选）
+      description: If you have fix ideas, describe them briefly / 如果你有修复思路，可以在这里简单描述
+      placeholder: |
+        Suggest adding ZZZ check in the YYY method of file XXX
+        / 建议在 XXX 文件的 YYY 方法中，添加 ZZZ 检查
+        ...
+
+  - type: dropdown
+    id: priority
+    attributes:
+      label: 🚨 Priority / 优先级
+      options:
+        - 🔴 High - Blocking core functionality, affects user experience / 高 - 阻塞核心功能，影响用户体验
+        - 🟡 Medium - Limited functionality but not blocking / 中 - 功能受限但不阻塞
+        - 🟢 Low - Minor issue, doesn't affect usage / 低 - 小问题，不影响使用
+    validations:
+      required: true
+
+  - type: textarea
+    id: additional
+    attributes:
+      label: 📝 Additional Information / 补充说明
+      description: Any other information that helps AI understand and fix the issue / 任何其他有助于 AI 理解和修复问题的信息
+      placeholder: |
+        - Was this bug introduced recently? / 这个 bug 是最近引入的吗？
+        - Is it related to a specific PR or commit? / 是否与某个特定的 PR 或 commit 相关？
+        - Does it only occur with specific datasets or users? / 是否只在特定数据集或特定用户情况下出现？
+        / ...
+        Any other context / 其他任何上下文信息...

.github/workflows/close-issue-on-pr-merge.yml

@@ -0,0 +1,127 @@
+# PR 合并后自动关闭关联的 Issue
+# 当 PR 从 ai_fix/N_xxx 分支合并到 main 时，关闭 #N 对应的 Issue（若 PR 描述中未含 Closes #N 则通过分支名解析）
+# 关闭后发送 Telegram 通知（复用 TELEGRAM_BOT_TOKEN / TELEGRAM_CHAT_ID）
+
+name: Close issue on PR merge
+
+on:
+  pull_request:
+    types: [closed]
+    branches: [main]
+
+jobs:
+  close-issue:
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: read
+
+    steps:
+      - name: Get PR info
+        id: pr
+        run: |
+          # 从 PR body 查找 Closes #N / Fixes #N（若已有则 GitHub 已自动关 issue，本 step 仅做解析）
+          BODY="${{ github.event.pull_request.body }}"
+          HEAD_REF="${{ github.event.pull_request.head.ref }}"
+
+          # 优先从 PR 描述解析（无匹配时 grep 会 exit 1，需 || true 避免 set -e 导致脚本退出）
+          ISSUE_NUM=$(echo "$BODY" | grep -oE '(Closes|Fixes|Resolves) #([0-9]+)' | head -1 | grep -oE '[0-9]+' || true)
+          if [ -z "$ISSUE_NUM" ]; then
+            # 从分支名解析 ai_fix/N_xxx
+            ISSUE_NUM=$(echo "$HEAD_REF" | sed -n 's|^ai_fix/\([0-9]*\)_.*|\1|p')
+          fi
+
+          if [ -z "$ISSUE_NUM" ]; then
+            echo "ISSUE_NUMBER=" >> $GITHUB_OUTPUT
+            echo "skip=true" >> $GITHUB_OUTPUT
+            echo "未从 PR 描述或分支名解析到 Issue 编号，跳过关闭"
+            exit 0
+          fi
+
+          echo "ISSUE_NUMBER=$ISSUE_NUM" >> $GITHUB_OUTPUT
+          echo "skip=false" >> $GITHUB_OUTPUT
+          echo "解析到 Issue #$ISSUE_NUM"
+
+      - name: Get issue details
+        if: steps.pr.outputs.skip != 'true'
+        id: issue
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          ISSUE_NUM="${{ steps.pr.outputs.ISSUE_NUMBER }}"
+          # 获取 issue 标题与 URL（用于 TG 消息）
+          JSON=$(gh issue view "$ISSUE_NUM" --json title,url 2>/dev/null || echo '{"title":"","url":""}')
+          TITLE=$(echo "$JSON" | jq -r '.title')
+          ISSUE_URL=$(echo "$JSON" | jq -r '.url')
+          echo "title<<EOF" >> $GITHUB_OUTPUT
+          echo "$TITLE" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+          echo "url=$ISSUE_URL" >> $GITHUB_OUTPUT
+
+      - name: Close issue
+        if: steps.pr.outputs.skip != 'true'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const issueNumber = parseInt('${{ steps.pr.outputs.ISSUE_NUMBER }}', 10);
+            if (!issueNumber || isNaN(issueNumber)) {
+              console.log('No valid issue number, skip');
+              return;
+            }
+            const { data: issue } = await github.rest.issues.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issueNumber
+            });
+            if (issue.state === 'open') {
+              await github.rest.issues.update({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                state: 'closed'
+              });
+              console.log(`Issue #${issueNumber} closed.`);
+            } else {
+              console.log(`Issue #${issueNumber} already closed.`);
+            }
+
+      - name: Send Telegram notification
+        if: steps.pr.outputs.skip != 'true'
+        env:
+          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
+          TELEGRAM_CHAT_ID: ${{ secrets.TELEGRAM_CHAT_ID }}
+        run: |
+          # 与 docker-build 一致：未配置则跳过
+          if [ -z "$TELEGRAM_BOT_TOKEN" ] || [ -z "$TELEGRAM_CHAT_ID" ]; then
+            echo "⚠️  Telegram Bot Token 或 Chat ID 未配置，跳过通知"
+            exit 0
+          fi
+
+          ISSUE_NUM="${{ steps.pr.outputs.ISSUE_NUMBER }}"
+          ISSUE_TITLE="${{ steps.issue.outputs.title }}"
+          ISSUE_URL="${{ steps.issue.outputs.url }}"
+          PR_URL="${{ github.event.pull_request.html_url }}"
+
+          # 与 docker-build 相同的 HTML 消息格式
+          MESSAGE="✅ <b>AI 修复的 Issue 已关闭</b>"$'\n'$'\n'"🔢 <b>Issue:</b> #${ISSUE_NUM} ${ISSUE_TITLE}"$'\n'"📎 <a href=\"${ISSUE_URL}\">查看 Issue</a>"$'\n'"🔗 <a href=\"${PR_URL}\">查看 PR</a>"
+
+          curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
+            -H "Content-Type: application/json" \
+            -d "$(jq -n \
+              --arg chat_id "$TELEGRAM_CHAT_ID" \
+              --arg text "$MESSAGE" \
+              '{chat_id: $chat_id, text: $text, parse_mode: "HTML", disable_web_page_preview: false}')" > /tmp/telegram_response.json
+
+          if [ $? -eq 0 ]; then
+            RESPONSE=$(cat /tmp/telegram_response.json)
+            if echo "$RESPONSE" | grep -q '"ok":true'; then
+              echo "✅ Telegram 通知发送成功"
+            else
+              echo "❌ Telegram 通知发送失败: $RESPONSE"
+              exit 0
+            fi
+          else
+            echo "❌ 发送 Telegram 消息时发生错误"
+            exit 0
+          fi

.github/workflows/docker-build.yml

@@ -6,6 +6,14 @@ on:
       - published  # 当通过 GitHub Releases 页面创建 release 时触发
   workflow_dispatch:
     inputs:
+      build_type:
+        description: '构建类型'
+        required: true
+        type: choice
+        options:
+          - package-only        # 只打包产物
+          - package-and-docker # 打包产物 + Docker 镜像
+        default: 'package-and-docker'
       version:
         description: '版本号（例如: v1.0.0）'
         required: false
@@ -28,6 +36,22 @@ jobs:
         with:
           ref: ${{ github.event.release.tag_name || github.event.inputs.tag_name || github.event.inputs.version || github.ref }}
       
+      - name: Determine build type
+        id: build_config
+        run: |
+          # 确定构建类型
+          if [ "${{ github.event_name }}" = "release" ]; then
+            # Release 事件：默认只打包产物（不构建 Docker）
+            BUILD_TYPE="package-only"
+            echo "📦 Release 事件：将只打包产物（不构建 Docker）"
+          else
+            # workflow_dispatch 事件：使用用户输入
+            BUILD_TYPE="${{ github.event.inputs.build_type }}"
+            echo "🔧 手动触发：构建类型 = ${BUILD_TYPE}"
+          fi
+          
+          echo "BUILD_TYPE=${BUILD_TYPE}" >> $GITHUB_OUTPUT
+      
       - name: Extract version and check if pre-release
         id: extract_version
         run: |
@@ -76,6 +100,53 @@ jobs:
             echo "📦 这是正式版本: $TAG_NAME"
           fi
       
+      - name: Send Telegram notification (build started)
+        if: steps.extract_version.outputs.IS_PRERELEASE == 'false' && steps.build_config.outputs.BUILD_TYPE == 'package-and-docker'
+        env:
+          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
+          TELEGRAM_CHAT_ID: ${{ secrets.TELEGRAM_CHAT_ID }}
+        run: |
+          # 检查必要的环境变量
+          if [ -z "$TELEGRAM_BOT_TOKEN" ] || [ -z "$TELEGRAM_CHAT_ID" ]; then
+            echo "⚠️  Telegram Bot Token 或 Chat ID 未配置，跳过通知"
+            exit 0
+          fi
+          
+          # 获取构建信息
+          TAG="${{ steps.extract_version.outputs.TAG }}"
+          
+          if [ "${{ github.event_name }}" = "release" ]; then
+            RELEASE_URL="${{ github.event.release.html_url }}"
+            MESSAGE="🔨 <b>Release 构建中</b>"$'\n'$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔧 <b>构建类型:</b> Docker 升级"$'\n'"🔗 <a href=\"${RELEASE_URL}\">查看 Release</a>"
+          else
+            WORKFLOW_URL="https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}"
+            MESSAGE="🔨 <b>构建中</b>"$'\n'$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔧 <b>构建类型:</b> Docker 升级"$'\n'"🔗 <a href=\"${WORKFLOW_URL}\">查看 Workflow</a>"
+          fi
+          
+          # 发送 Telegram 消息（使用 jq 转义 JSON）
+          curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
+            -H "Content-Type: application/json" \
+            -d "$(jq -n \
+              --arg chat_id "$TELEGRAM_CHAT_ID" \
+              --arg text "$MESSAGE" \
+              '{chat_id: $chat_id, text: $text, parse_mode: "HTML", disable_web_page_preview: false}')" > /tmp/telegram_response.json
+          
+          # 检查发送结果
+          if [ $? -eq 0 ]; then
+            RESPONSE=$(cat /tmp/telegram_response.json)
+            if echo "$RESPONSE" | grep -q '"ok":true'; then
+              echo "✅ Telegram 通知发送成功"
+            else
+              echo "❌ Telegram 通知发送失败: $RESPONSE"
+              # 通知失败不应该导致整个 job 失败
+              exit 0
+            fi
+          else
+            echo "❌ 发送 Telegram 消息时发生错误"
+            # 通知失败不应该导致整个 job 失败
+            exit 0
+          fi
+      
       # ============ 编译前后端产物 ============
       - name: Setup JDK 17
         uses: actions/setup-java@v4
@@ -192,66 +263,22 @@ jobs:
             checksums.txt
           retention-days: 30
       
-      # ============ 发送产物上传成功通知 ============
-      - name: Send Telegram notification (package uploaded)
-        if: steps.extract_version.outputs.IS_PRERELEASE == 'false'
-        env:
-          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
-          TELEGRAM_CHAT_ID: ${{ secrets.TELEGRAM_CHAT_ID }}
-        run: |
-          # 检查必要的环境变量
-          if [ -z "$TELEGRAM_BOT_TOKEN" ] || [ -z "$TELEGRAM_CHAT_ID" ]; then
-            echo "⚠️  Telegram Bot Token 或 Chat ID 未配置，跳过通知"
-            exit 0
-          fi
-          
-          # 获取构建信息
-          TAG="${{ steps.extract_version.outputs.TAG }}"
-          
-          if [ "${{ github.event_name }}" = "release" ]; then
-            RELEASE_URL="${{ github.event.release.html_url }}"
-            MESSAGE="✅ <b>PolyHermes Package Built</b>"$'\n'$'\n'"🏷️ <b>Version:</b> <code>${TAG}</code>"$'\n'"🔧 <b>Type:</b> Online Update"$'\n'"🔗 <a href=\"${RELEASE_URL}\">View Release</a>"$'\n'"📍 <b>Update Path:</b> System Management → Overview → Check for Updates"$'\n'$'\n'"🐳 Building Docker image..."
-          else
-            WORKFLOW_URL="https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}"
-            MESSAGE="✅ <b>PolyHermes Package Built</b>"$'\n'$'\n'"🏷️ <b>Version:</b> <code>${TAG}</code>"$'\n'"🔧 <b>Type:</b> Online Update"$'\n'"🔗 <a href=\"${WORKFLOW_URL}\">View Workflow</a>"$'\n'$'\n'"🐳 Building Docker image..."
-          fi
-          
-          # 发送 Telegram 消息（使用 jq 转义 JSON）
-          curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
-            -H "Content-Type: application/json" \
-            -d "$(jq -n \
-              --arg chat_id "$TELEGRAM_CHAT_ID" \
-              --arg text "$MESSAGE" \
-              '{chat_id: $chat_id, text: $text, parse_mode: "HTML", disable_web_page_preview: false}')" > /tmp/telegram_response.json
-          
-          # 检查发送结果
-          if [ $? -eq 0 ]; then
-            RESPONSE=$(cat /tmp/telegram_response.json)
-            if echo "$RESPONSE" | grep -q '"ok":true'; then
-              echo "✅ Telegram 通知发送成功"
-            else
-              echo "❌ Telegram 通知发送失败: $RESPONSE"
-              exit 0
-            fi
-          else
-            echo "❌ 发送 Telegram 消息时发生错误"
-            exit 0
-          fi
-      
-      # ============ Docker 构建 ============
       - name: Set up Docker Buildx
+        if: steps.build_config.outputs.BUILD_TYPE == 'package-and-docker'
         uses: docker/setup-buildx-action@v3
         with:
           # 启用多架构构建支持
           platforms: linux/amd64,linux/arm64
       
       - name: Log in to Docker Hub
+        if: steps.build_config.outputs.BUILD_TYPE == 'package-and-docker'
         uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       
       - name: Prepare Docker build context
+        if: steps.build_config.outputs.BUILD_TYPE == 'package-and-docker'
         run: |
           echo "📦 准备 Docker 构建上下文..."
           # 确保构建产物存在且可访问
@@ -268,7 +295,7 @@ jobs:
           ls -lh backend/build/libs/*.jar
       
       - name: Build and push Docker image
-        id: docker_build
+        if: steps.build_config.outputs.BUILD_TYPE == 'package-and-docker'
         uses: docker/build-push-action@v5
         with:
           context: .
@@ -287,8 +314,13 @@ jobs:
           cache-from: type=registry,ref=wrbug/polyhermes:latest
           cache-to: type=inline
       
-      # ============ 发送 Docker 构建成功通知 ============
-      - name: Send Telegram notification (Docker build completed)
+      - name: Skip Docker build notice
+        if: steps.build_config.outputs.BUILD_TYPE == 'package-only'
+        run: |
+          echo "⏭️  跳过 Docker 镜像构建（构建类型：package-only）"
+          echo "✅ 仅打包产物已完成"
+
+      - name: Send Telegram notification
         if: steps.extract_version.outputs.IS_PRERELEASE == 'false'
         env:
           TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
@@ -303,14 +335,25 @@ jobs:
           # 获取构建信息
           VERSION="${{ steps.extract_version.outputs.VERSION }}"
           TAG="${{ steps.extract_version.outputs.TAG }}"
+          BUILD_TYPE="${{ steps.build_config.outputs.BUILD_TYPE }}"
+          
+          # 构建消息内容（仅包含关键信息）
           DEPLOY_DOC_URL="https://github.com/WrBug/PolyHermes/blob/main/docs/zh/DEPLOYMENT.md"
           
           if [ "${{ github.event_name }}" = "release" ]; then
             RELEASE_URL="${{ github.event.release.html_url }}"
-            MESSAGE="🐳 <b>Docker Image Built Successfully</b>"$'\n'$'\n'"🏷️ <b>Version:</b> <code>${TAG}</code>"$'\n'"📦 <b>Image:</b> <code>wrbug/polyhermes:${TAG}</code>"$'\n'"🔗 <a href=\"${RELEASE_URL}\">View Release</a>"$'\n'"📚 <a href=\"${DEPLOY_DOC_URL}\">Docker Deployment Guide</a>"
+            if [ "$BUILD_TYPE" = "package-and-docker" ]; then
+              MESSAGE="✅ <b>Release 构建成功</b>"$'\n'$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔧 <b>构建类型:</b> Docker 升级"$'\n'"🔗 <a href=\"${RELEASE_URL}\">查看 Release</a>"$'\n'"📚 <a href=\"${DEPLOY_DOC_URL}\">Docker 部署文档</a>"
+            else
+              MESSAGE="✅ <b>Release 打包成功</b>"$'\n'$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔧 <b>构建类型:</b> 在线升级"$'\n'"🔗 <a href=\"${RELEASE_URL}\">查看 Release</a>"$'\n'"📍 <b>升级路径:</b> 系统管理 → 概览 → 检查更新"
+            fi
           else
             WORKFLOW_URL="https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}"
-            MESSAGE="🐳 <b>Docker Image Built Successfully</b>"$'\n'$'\n'"🏷️ <b>Version:</b> <code>${TAG}</code>"$'\n'"📦 <b>Image:</b> <code>wrbug/polyhermes:${TAG}</code>"$'\n'"🔗 <a href=\"${WORKFLOW_URL}\">View Workflow</a>"$'\n'"📚 <a href=\"${DEPLOY_DOC_URL}\">Docker Deployment Guide</a>"
+            if [ "$BUILD_TYPE" = "package-and-docker" ]; then
+              MESSAGE="✅ <b>构建成功</b>"$'\n'$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔧 <b>构建类型:</b> Docker 升级"$'\n'"🔗 <a href=\"${WORKFLOW_URL}\">查看 Workflow</a>"$'\n'"📚 <a href=\"${DEPLOY_DOC_URL}\">Docker 部署文档</a>"
+            else
+              MESSAGE="✅ <b>打包成功</b>"$'\n'$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔧 <b>构建类型:</b> 在线升级"$'\n'"🔗 <a href=\"${WORKFLOW_URL}\">查看 Workflow</a>"$'\n'"📍 <b>升级路径:</b> 系统管理 → 概览 → 检查更新"
+            fi
           fi
           
           # 发送 Telegram 消息（使用 jq 转义 JSON）
@@ -328,9 +371,11 @@ jobs:
               echo "✅ Telegram 通知发送成功"
             else
               echo "❌ Telegram 通知发送失败: $RESPONSE"
+              # 构建成功，通知失败不应该导致整个 job 失败
               exit 0
             fi
           else
             echo "❌ 发送 Telegram 消息时发生错误"
+            # 构建成功，通知失败不应该导致整个 job 失败
             exit 0
-          fi
+          fi

backend/src/main/kotlin/com/wrbug/polymarketbot/api/PolymarketClobApi.kt

@@ -212,7 +212,6 @@ data class NewOrderResponse(
     val success: Boolean,               // boolean indicating if server-side error
     @SerializedName("errorMsg")
     val errorMsg: String? = null,       // error message in case of unsuccessful placement
-    val error: String? = null,          // error message (alternative field, e.g. "Trading restricted in your region...")
     @SerializedName("orderID")
     val orderId: String? = null,        // id of order（API 返回字段名为 orderID）
     @SerializedName("transactionsHashes")
@@ -223,17 +222,7 @@ data class NewOrderResponse(
     val takingAmount: String? = null,   // taking amount
     @SerializedName("makingAmount")
     val makingAmount: String? = null    // making amount
-) {
-    /**
-     * 获取错误信息的便捷方法
-     * 优先返回 errorMsg，其次返回 error，最后返回默认消息
-     */
-    fun getErrorMessage(): String {
-        return errorMsg?.takeIf { it.isNotBlank() }
-            ?: error?.takeIf { it.isNotBlank() }
-            ?: "创建订单失败"
-    }
-}
+)
 
 /**
  * 旧的订单请求格式（已废弃，保留用于兼容）

backend/src/main/kotlin/com/wrbug/polymarketbot/controller/cryptotail/CryptoTailStrategyController.kt

@@ -13,15 +13,10 @@ import com.wrbug.polymarketbot.dto.CryptoTailMarketOptionDto
 import com.wrbug.polymarketbot.dto.CryptoTailAutoMinSpreadResponse
 import com.wrbug.polymarketbot.dto.CryptoTailMonitorInitRequest
 import com.wrbug.polymarketbot.dto.CryptoTailMonitorInitResponse
-import com.wrbug.polymarketbot.dto.CryptoTailManualOrderRequest
-import com.wrbug.polymarketbot.dto.CryptoTailManualOrderResponse
-import com.wrbug.polymarketbot.dto.CryptoTailPnlCurveRequest
-import com.wrbug.polymarketbot.dto.CryptoTailPnlCurveResponse
 import com.wrbug.polymarketbot.enums.ErrorCode
 import com.wrbug.polymarketbot.service.binance.BinanceKlineAutoSpreadService
 import com.wrbug.polymarketbot.service.cryptotail.CryptoTailStrategyService
 import com.wrbug.polymarketbot.service.cryptotail.CryptoTailMonitorService
-import com.wrbug.polymarketbot.service.cryptotail.CryptoTailStrategyExecutionService
 import org.slf4j.LoggerFactory
 import org.springframework.context.MessageSource
 import org.springframework.http.ResponseEntity
@@ -29,14 +24,12 @@ import org.springframework.web.bind.annotation.PostMapping
 import org.springframework.web.bind.annotation.RequestBody
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RestController
-import kotlinx.coroutines.runBlocking
 
 @RestController
 @RequestMapping("/api/crypto-tail-strategy")
 class CryptoTailStrategyController(
     private val cryptoTailStrategyService: CryptoTailStrategyService,
     private val cryptoTailMonitorService: CryptoTailMonitorService,
-    private val cryptoTailStrategyExecutionService: CryptoTailStrategyExecutionService,
     private val binanceKlineAutoSpreadService: BinanceKlineAutoSpreadService,
     private val messageSource: MessageSource
 ) {
@@ -132,26 +125,6 @@ class CryptoTailStrategyController(
         }
     }
 
-    @PostMapping("/pnl-curve")
-    fun getPnlCurve(@RequestBody request: CryptoTailPnlCurveRequest): ResponseEntity<ApiResponse<CryptoTailPnlCurveResponse>> {
-        return try {
-            if (request.strategyId <= 0) {
-                return ResponseEntity.ok(ApiResponse.error(ErrorCode.CRYPTO_TAIL_STRATEGY_NOT_FOUND, messageSource = messageSource))
-            }
-            val result = cryptoTailStrategyService.getPnlCurve(request)
-            result.fold(
-                onSuccess = { ResponseEntity.ok(ApiResponse.success(it)) },
-                onFailure = { e ->
-                    logger.error("查询收益曲线失败: ${e.message}", e)
-                    ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_CRYPTO_TAIL_STRATEGY_TRIGGERS_FETCH_FAILED, e.message, messageSource))
-                }
-            )
-        } catch (e: Exception) {
-            logger.error("查询收益曲线异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_CRYPTO_TAIL_STRATEGY_TRIGGERS_FETCH_FAILED, e.message, messageSource))
-        }
-    }
-
     @PostMapping("/triggers")
     fun getTriggerRecords(@RequestBody request: CryptoTailStrategyTriggerListRequest): ResponseEntity<ApiResponse<CryptoTailStrategyTriggerListResponse>> {
         return try {
@@ -243,41 +216,4 @@ class CryptoTailStrategyController(
             ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, e.message, messageSource))
         }
     }
-
-    /**
-     * 手动下单
-     * 用户主动触发下单，不检查任何条件，仅检查当前周期是否已下单
-     */
-    @PostMapping("/manual-order")
-    fun manualOrder(@RequestBody request: CryptoTailManualOrderRequest): ResponseEntity<ApiResponse<CryptoTailManualOrderResponse>> {
-        return runBlocking {
-            try {
-                if (request.strategyId <= 0) {
-                    return@runBlocking ResponseEntity.ok(
-                        ApiResponse.error(ErrorCode.CRYPTO_TAIL_STRATEGY_NOT_FOUND, messageSource = messageSource)
-                    )
-                }
-                val result = cryptoTailStrategyExecutionService.manualOrder(request)
-                result.fold(
-                    onSuccess = { ResponseEntity.ok(ApiResponse.success(it)) },
-                    onFailure = { e ->
-                        logger.error("手动下单失败: ${e.message}", e)
-                        val code = when (e.message) {
-                            "策略不存在" -> ErrorCode.CRYPTO_TAIL_STRATEGY_NOT_FOUND
-                            "当前周期已下单" -> ErrorCode.PARAM_ERROR
-                            "价格必须在 0~1 之间" -> ErrorCode.PARAM_ERROR
-                            "数量不能少于 1" -> ErrorCode.PARAM_ERROR
-                            "总金额不能少于 1 USDC" -> ErrorCode.PARAM_ERROR
-                            "总金额超过策略配置的投入金额" -> ErrorCode.PARAM_ERROR
-                            else -> ErrorCode.SERVER_ERROR
-                        }
-                        ResponseEntity.ok(ApiResponse.error(code, e.message, messageSource))
-                    }
-                )
-            } catch (e: Exception) {
-                logger.error("手动下单异常: ${e.message}", e)
-                ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, e.message, messageSource))
-            }
-        }
-    }
 }

backend/src/main/kotlin/com/wrbug/polymarketbot/controller/system/NotificationController.kt

@@ -3,7 +3,6 @@ package com.wrbug.polymarketbot.controller.system
 import com.wrbug.polymarketbot.dto.*
 import com.wrbug.polymarketbot.enums.ErrorCode
 import com.wrbug.polymarketbot.service.system.NotificationConfigService
-import com.wrbug.polymarketbot.service.system.NotificationTemplateService
 import com.wrbug.polymarketbot.service.system.TelegramNotificationService
 import kotlinx.coroutines.runBlocking
 import org.slf4j.LoggerFactory
@@ -19,7 +18,6 @@ import org.springframework.web.bind.annotation.*
 class NotificationController(
     private val notificationConfigService: NotificationConfigService,
     private val telegramNotificationService: TelegramNotificationService,
-    private val notificationTemplateService: NotificationTemplateService,
     private val messageSource: MessageSource
 ) {
     
@@ -337,155 +335,6 @@ class NotificationController(
             ))
         }
     }
-
-    // ==================== 模板相关 API ====================
-
-    /**
-     * 获取所有模板类型
-     */
-    @PostMapping("/templates/types")
-    fun getTemplateTypes(): ResponseEntity<ApiResponse<List<TemplateTypeInfoDto>>> {
-        return try {
-            val types = notificationTemplateService.getTemplateTypes()
-            ResponseEntity.ok(ApiResponse.success(types))
-        } catch (e: Exception) {
-            logger.error("获取模板类型失败: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, messageSource = messageSource))
-        }
-    }
-
-    /**
-     * 获取所有模板
-     */
-    @PostMapping("/templates/list")
-    fun getTemplates(): ResponseEntity<ApiResponse<List<NotificationTemplateDto>>> {
-        return try {
-            val templates = notificationTemplateService.getAllTemplates()
-            ResponseEntity.ok(ApiResponse.success(templates))
-        } catch (e: Exception) {
-            logger.error("获取模板列表失败: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, messageSource = messageSource))
-        }
-    }
-
-    /**
-     * 获取单个模板
-     */
-    @PostMapping("/templates/detail")
-    fun getTemplateDetail(@RequestBody request: TemplateDetailRequest): ResponseEntity<ApiResponse<NotificationTemplateDto>> {
-        return try {
-            if (request.templateType.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("模板类型不能为空"))
-            }
-
-            val template = notificationTemplateService.getTemplate(request.templateType)
-            if (template == null) {
-                ResponseEntity.ok(ApiResponse.error(ErrorCode.NOT_FOUND, messageSource = messageSource))
-            } else {
-                ResponseEntity.ok(ApiResponse.success(template))
-            }
-        } catch (e: Exception) {
-            logger.error("获取模板详情失败: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, messageSource = messageSource))
-        }
-    }
-
-    /**
-     * 获取模板可用变量
-     */
-    @PostMapping("/templates/variables")
-    fun getTemplateVariables(@RequestBody request: TemplateDetailRequest): ResponseEntity<ApiResponse<TemplateVariablesResponse>> {
-        return try {
-            if (request.templateType.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("模板类型不能为空"))
-            }
-
-            val variables = notificationTemplateService.getTemplateVariables(request.templateType)
-            if (variables == null) {
-                ResponseEntity.ok(ApiResponse.error(ErrorCode.NOT_FOUND, messageSource = messageSource))
-            } else {
-                ResponseEntity.ok(ApiResponse.success(variables))
-            }
-        } catch (e: Exception) {
-            logger.error("获取模板变量失败: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, messageSource = messageSource))
-        }
-    }
-
-    /**
-     * 更新模板
-     */
-    @PostMapping("/templates/update")
-    fun updateTemplate(@RequestBody request: UpdateTemplateRequestWithId): ResponseEntity<ApiResponse<NotificationTemplateDto>> {
-        return try {
-            if (request.templateType.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("模板类型不能为空"))
-            }
-            if (request.templateContent.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("模板内容不能为空"))
-            }
-
-            val template = notificationTemplateService.updateTemplate(request.templateType, request.templateContent)
-            ResponseEntity.ok(ApiResponse.success(template))
-        } catch (e: Exception) {
-            logger.error("更新模板失败: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, messageSource = messageSource))
-        }
-    }
-
-    /**
-     * 重置模板为默认
-     */
-    @PostMapping("/templates/reset")
-    fun resetTemplate(@RequestBody request: TemplateDetailRequest): ResponseEntity<ApiResponse<NotificationTemplateDto>> {
-        return try {
-            if (request.templateType.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("模板类型不能为空"))
-            }
-
-            val template = notificationTemplateService.resetTemplate(request.templateType)
-            if (template == null) {
-                ResponseEntity.ok(ApiResponse.error(ErrorCode.NOT_FOUND, messageSource = messageSource))
-            } else {
-                ResponseEntity.ok(ApiResponse.success(template))
-            }
-        } catch (e: Exception) {
-            logger.error("重置模板失败: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, messageSource = messageSource))
-        }
-    }
-
-    /**
-     * 发送模板测试消息
-     */
-    @PostMapping("/templates/test")
-    fun testTemplate(@RequestBody request: TestTemplateRequest): ResponseEntity<ApiResponse<Boolean>> {
-        return try {
-            if (request.templateType.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("模板类型不能为空"))
-            }
-
-            val success = runBlocking {
-                notificationTemplateService.sendTestMessage(request.templateType, request.templateContent)
-            }
-
-            if (success) {
-                ResponseEntity.ok(ApiResponse.success(true))
-            } else {
-                ResponseEntity.ok(ApiResponse.error(
-                    ErrorCode.NOTIFICATION_TEST_FAILED,
-                    messageSource = messageSource
-                ))
-            }
-        } catch (e: Exception) {
-            logger.error("发送模板测试消息失败: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.error(
-                ErrorCode.NOTIFICATION_TEST_FAILED,
-                customMsg = "发送测试消息失败：${e.message}",
-                messageSource = messageSource
-            ))
-        }
-    }
 }
 
 /**
@@ -535,18 +384,3 @@ data class NotificationConfigDeleteRequest(
     val id: Long
 )
 
-/**
- * 模板详情请求
- */
-data class TemplateDetailRequest(
-    val templateType: String
-)
-
-/**
- * 更新模板请求（带类型）
- */
-data class UpdateTemplateRequestWithId(
-    val templateType: String,
-    val templateContent: String
-)
-

backend/src/main/kotlin/com/wrbug/polymarketbot/dto/CryptoTailManualOrderRequest.kt

@@ -1,21 +0,0 @@
-package com.wrbug.polymarketbot.dto
-
-/**
- * 加密价差策略手动下单请求
- */
-data class CryptoTailManualOrderRequest(
-    /** 策略ID */
-    val strategyId: Long = 0L,
-    /** 当前周期开始时间 (Unix 秒) */
-    val periodStartUnix: Long = 0L,
-    /** 下单方向: UP or DOWN */
-    val direction: String = "UP",
-    /** 下单价格 */
-    val price: String = "0",
-    /** 下单数量 */
-    val size: String = "1",
-    /** 市场标题（用于记录） */
-    val marketTitle: String = "",
-    /** Token IDs */
-    val tokenIds: List<String> = emptyList()
-)

backend/src/main/kotlin/com/wrbug/polymarketbot/dto/CryptoTailManualOrderResponse.kt

@@ -1,31 +0,0 @@
-package com.wrbug.polymarketbot.dto
-
-/**
- * 加密价差策略手动下单响应
- */
-data class CryptoTailManualOrderResponse(
-    /** 是否成功 */
-    val success: Boolean = false,
-    /** 订单ID */
-    val orderId: String? = null,
-    /** 提示消息 */
-    val message: String = "",
-    /** 下单详情 */
-    val orderDetails: ManualOrderDetails? = null
-)
-
-/**
- * 手动下单详情
- */
-data class ManualOrderDetails(
-    /** 策略ID */
-    val strategyId: Long = 0L,
-    /** 方向 */
-    val direction: String = "",
-    /** 下单价格 */
-    val price: String = "",
-    /** 下单数量 */
-    val size: String = "",
-    /** 总金额 */
-    val totalAmount: String = ""
-)

backend/src/main/kotlin/com/wrbug/polymarketbot/dto/CryptoTailMonitorDto.kt

@@ -5,9 +5,7 @@ package com.wrbug.polymarketbot.dto
  */
 data class CryptoTailMonitorInitRequest(
     /** 策略ID */
-    val strategyId: Long = 0L,
-    /** 指定周期开始时间 (Unix 秒)，不传则用服务器当前周期 */
-    val periodStartUnix: Long? = null
+    val strategyId: Long = 0L
 )
 
 /**
@@ -57,11 +55,7 @@ data class CryptoTailMonitorInitResponse(
     /** 当前时间 (毫秒时间戳) */
     val currentTimestamp: Long = System.currentTimeMillis(),
     /** 是否启用 */
-    val enabled: Boolean = true,
-    /** 投入金额模式: FIXED or RATIO */
-    val amountMode: String? = null,
-    /** 投入金额数值 */
-    val amountValue: String? = null
+    val enabled: Boolean = true
 )
 
 /**

backend/src/main/kotlin/com/wrbug/polymarketbot/dto/CryptoTailStrategyDto.kt

@@ -167,45 +167,3 @@ data class CryptoTailMarketOptionDto(
     val periodStartUnix: Long = 0L,
     val endDate: String? = null
 )
-
-/**
- * 收益曲线请求
- * @param strategyId 策略ID
- * @param startDate 开始时间（毫秒时间戳），null 表示不限制
- * @param endDate 结束时间（毫秒时间戳），null 表示不限制
- */
-data class CryptoTailPnlCurveRequest(
-    val strategyId: Long = 0L,
-    val startDate: Long? = null,
-    val endDate: Long? = null
-)
-
-/**
- * 收益曲线单点数据
- */
-data class CryptoTailPnlCurvePoint(
-    /** 时间点（毫秒时间戳，结算时间或创建时间） */
-    val timestamp: Long = 0L,
-    /** 累计收益 USDC */
-    val cumulativePnl: String = "0",
-    /** 当笔收益 USDC */
-    val pointPnl: String = "0",
-    /** 截至该点累计已结算笔数 */
-    val settledCount: Long = 0L
-)
-
-/**
- * 收益曲线响应
- */
-data class CryptoTailPnlCurveResponse(
-    val strategyId: Long = 0L,
-    val strategyName: String = "",
-    /** 筛选范围内总已实现收益 USDC */
-    val totalRealizedPnl: String = "0",
-    val settledCount: Long = 0L,
-    val winCount: Long = 0L,
-    val winRate: String? = null,
-    /** 最大回撤 USDC（正数表示回撤幅度） */
-    val maxDrawdown: String? = null,
-    val curveData: List<CryptoTailPnlCurvePoint> = emptyList()
-)

backend/src/main/kotlin/com/wrbug/polymarketbot/dto/NotificationTemplateDto.kt

@@ -1,63 +0,0 @@
-package com.wrbug.polymarketbot.dto
-
-/**
- * 消息模板 DTO
- */
-data class NotificationTemplateDto(
-    val id: Long? = null,
-    val templateType: String,  // 模板类型
-    val templateContent: String,  // 模板内容
-    val isDefault: Boolean = false,  // 是否使用默认模板
-    val createdAt: Long? = null,
-    val updatedAt: Long? = null
-)
-
-/**
- * 模板变量 DTO
- */
-data class TemplateVariableDto(
-    val key: String,  // 变量名，如 account_name
-    val category: String,  // 分类：common, order, copy_trading, redeem, error
-    val sortOrder: Int = 0  // 排序顺序
-)
-
-/**
- * 模板变量分类 DTO
- */
-data class TemplateVariableCategoryDto(
-    val key: String,  // 分类 key
-    val sortOrder: Int = 0  // 排序顺序
-)
-
-/**
- * 模板变量列表响应
- */
-data class TemplateVariablesResponse(
-    val templateType: String,  // 模板类型
-    val categories: List<TemplateVariableCategoryDto>,  // 分类列表
-    val variables: List<TemplateVariableDto>  // 变量列表
-)
-
-/**
- * 更新模板请求
- */
-data class UpdateTemplateRequest(
-    val templateContent: String  // 模板内容
-)
-
-/**
- * 测试模板请求
- */
-data class TestTemplateRequest(
-    val templateType: String,  // 模板类型
-    val templateContent: String? = null  // 可选，如果不提供则使用已保存的模板
-)
-
-/**
- * 模板类型信息
- */
-data class TemplateTypeInfoDto(
-    val type: String,  // 模板类型
-    val name: String,  // 类型名称
-    val description: String  // 类型描述
-)

backend/src/main/kotlin/com/wrbug/polymarketbot/dto/OrderMessageDto.kt

@@ -51,21 +51,18 @@ data class OrderPushMessage(
 
 /**
  * 订单详情（通过 API 获取）
- * @param price 订单限价（用户提交的买入/卖出价）
- * @param avgFilledPrice 实际成交价 = original_size * price / size_matched（有成交时优先用于推送展示）
  */
 data class OrderDetailDto(
     val id: String,                    // 订单 ID
     val market: String,                 // 市场 ID (condition ID)
     val side: String,                   // BUY/SELL
-    val price: String,                  // 订单限价
+    val price: String,                  // 价格
     val size: String,                   // 订单大小
     val filled: String,                 // 已成交数量
     val status: String,                 // 订单状态
     val createdAt: String,             // 创建时间（ISO 8601 格式）
     val marketName: String? = null,     // 市场名称（通过 Data API 获取）
     val marketSlug: String? = null,     // 市场 slug
-    val marketIcon: String? = null,    // 市场图标
-    val avgFilledPrice: String? = null  // 实际成交价 = original_size*price/size_matched（有成交时使用）
+    val marketIcon: String? = null       // 市场图标
 )
 

backend/src/main/kotlin/com/wrbug/polymarketbot/entity/CryptoTailStrategyTrigger.kt

@@ -56,9 +56,6 @@ data class CryptoTailStrategyTrigger(
     @Column(name = "fail_reason", length = 500)
     val failReason: String? = null,
 
-    @Column(name = "trigger_type", nullable = false, length = 20)
-    val triggerType: String = "AUTO",
-
     @Column(name = "created_at", nullable = false)
     val createdAt: Long = System.currentTimeMillis(),
 

backend/src/main/kotlin/com/wrbug/polymarketbot/entity/NotificationTemplate.kt

@@ -1,30 +0,0 @@
-package com.wrbug.polymarketbot.entity
-
-import jakarta.persistence.*
-
-/**
- * 消息推送模板实体
- * 用于存储用户自定义的消息模板
- */
-@Entity
-@Table(name = "notification_templates")
-data class NotificationTemplate(
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    val id: Long? = null,
-
-    @Column(name = "template_type", unique = true, nullable = false, length = 50)
-    val templateType: String,  // ORDER_SUCCESS, ORDER_FAILED, ORDER_FILTERED, CRYPTO_TAIL_SUCCESS, REDEEM_SUCCESS, REDEEM_NO_RETURN
-
-    @Column(name = "template_content", nullable = false, columnDefinition = "TEXT")
-    var templateContent: String,  // 模板内容，支持 {{variable}} 变量
-
-    @Column(name = "is_default", nullable = false)
-    var isDefault: Boolean = false,  // 是否使用默认模板
-
-    @Column(name = "created_at", nullable = false)
-    val createdAt: Long = System.currentTimeMillis(),
-
-    @Column(name = "updated_at", nullable = false)
-    var updatedAt: Long = System.currentTimeMillis()
-)

backend/src/main/kotlin/com/wrbug/polymarketbot/repository/CryptoTailStrategyTriggerRepository.kt

@@ -40,16 +40,4 @@ interface CryptoTailStrategyTriggerRepository : JpaRepository<CryptoTailStrategy
     /** 策略已结算中赢的笔数（outcome_index = winner_outcome_index） */
     @Query("SELECT COUNT(t) FROM CryptoTailStrategyTrigger t WHERE t.strategyId = :strategyId AND t.resolved = true AND t.outcomeIndex = t.winnerOutcomeIndex")
     fun countWinsByStrategyId(@Param("strategyId") strategyId: Long): Long
-
-    /** 收益曲线：已结算记录，按结算时间（无则创建时间）在区间内升序 */
-    @Query(
-        "SELECT t FROM CryptoTailStrategyTrigger t WHERE t.strategyId = :strategyId AND t.resolved = true " +
-            "AND COALESCE(t.settledAt, t.createdAt) >= :start AND COALESCE(t.settledAt, t.createdAt) <= :end " +
-            "ORDER BY COALESCE(t.settledAt, t.createdAt) ASC"
-    )
-    fun findResolvedByStrategyIdAndTimeRangeOrderBySettledAsc(
-        @Param("strategyId") strategyId: Long,
-        @Param("start") start: Long,
-        @Param("end") end: Long
-    ): List<CryptoTailStrategyTrigger>
 }

backend/src/main/kotlin/com/wrbug/polymarketbot/repository/NotificationTemplateRepository.kt

@@ -1,11 +0,0 @@
-package com.wrbug.polymarketbot.repository
-
-import com.wrbug.polymarketbot.entity.NotificationTemplate
-import org.springframework.data.jpa.repository.JpaRepository
-import org.springframework.stereotype.Repository
-
-@Repository
-interface NotificationTemplateRepository : JpaRepository<NotificationTemplate, Long> {
-    fun findByTemplateType(templateType: String): NotificationTemplate?
-    fun existsByTemplateType(templateType: String): Boolean
-}

backend/src/main/kotlin/com/wrbug/polymarketbot/service/accounts/AccountService.kt

@@ -10,10 +10,7 @@ import com.wrbug.polymarketbot.util.toSafeBigDecimal
 import com.wrbug.polymarketbot.util.eq
 import com.wrbug.polymarketbot.util.gt
 import com.wrbug.polymarketbot.util.JsonUtils
-import com.wrbug.polymarketbot.util.fromJson
 import com.wrbug.polymarketbot.util.getEventSlug
-import com.google.gson.JsonObject
-import com.google.gson.JsonPrimitive
 import com.wrbug.polymarketbot.service.common.PolymarketClobService
 import com.wrbug.polymarketbot.service.common.BlockchainService
 import com.wrbug.polymarketbot.service.common.MarketService
@@ -1334,22 +1331,13 @@ class AccountService(
 
                             // 使用当前时间作为订单创建时间
                             val orderTime = System.currentTimeMillis()
-                            
-                            // 查询可用余额
-                            val availableBalance = try {
-                                blockchainService.getUsdcBalance(account.walletAddress, account.proxyAddress).getOrNull()
-                            } catch (e: Exception) {
-                                logger.warn("查询可用余额失败: accountId=${account.id}, ${e.message}")
-                                null
-                            }
 
                             telegramNotificationService?.sendOrderSuccessNotification(
                                 orderId = orderId,
                                 marketTitle = marketTitle,
                                 marketId = request.marketId,
                                 marketSlug = marketSlug,
-                                side = "SELL",  // 手动卖出订单，方向固定为 SELL
-                                outcome = request.side,  // request.side 是市场方向（YES/NO）
+                                side = request.side,
                                 price = sellPrice,  // 直接传递卖出价格
                                 size = sellQuantity.toPlainString(),  // 直接传递卖出数量
                                 accountName = account.accountName,
@@ -1360,8 +1348,7 @@ class AccountService(
                                 apiPassphrase = try { cryptoUtils.decrypt(account.apiPassphrase!!) } catch (e: Exception) { null },
                                 walletAddressForApi = account.walletAddress,
                                 locale = locale,
-                                orderTime = orderTime,  // 使用订单创建时间
-                                availableBalance = availableBalance
+                                orderTime = orderTime  // 使用订单创建时间
                             )
                         } catch (e: Exception) {
                             logger.warn("发送订单成功通知失败: ${e.message}", e)
@@ -1381,7 +1368,7 @@ class AccountService(
                         )
                     )
                 } else {
-                    val errorMsg = response.getErrorMessage()
+                    val errorMsg = response.errorMsg ?: "未知错误"
                     val fullErrorMsg = "创建订单失败: accountId=${account.id}, marketId=${request.marketId}, side=${request.side}, orderType=${request.orderType}, price=${if (request.orderType == "LIMIT") sellPrice else "MARKET"}, quantity=${sellQuantity.toPlainString()}, errorMsg=$errorMsg"
                     logger.error(fullErrorMsg)
                     
@@ -1426,14 +1413,6 @@ class AccountService(
                 } catch (e: Exception) {
                     null
                 }
-                
-                // 尝试从 errorBody 解析 error 字段（使用 Gson）
-                val apiError = try {
-                    (errorBody?.fromJson<JsonObject>()?.get("error") as? JsonPrimitive)?.asString
-                } catch (e: Exception) {
-                    null
-                }
-                
                 val fullErrorMsg = "创建订单失败: accountId=${account.id}, marketId=${request.marketId}, side=${request.side}, orderType=${request.orderType}, price=${if (request.orderType == "LIMIT") sellPrice else "MARKET"}, quantity=${sellQuantity.toPlainString()}, code=${orderResponse.code()}, message=${orderResponse.message()}${if (errorBody != null) ", errorBody=$errorBody" else ""}"
                 logger.error(fullErrorMsg)
                 
@@ -1452,10 +1431,8 @@ class AccountService(
                             java.util.Locale("zh", "CN")  // 默认简体中文
                         }
 
-                        // 优先使用解析的 API error，其次使用响应体的 errorMsg，最后使用默认消息
-                        val errorMsg = apiError 
-                            ?: orderResponse.body()?.getErrorMessage() 
-                            ?: "创建订单失败 (HTTP ${orderResponse.code()})"
+                        // 只传递后端返回的 msg，不传递完整堆栈
+                        val errorMsg = orderResponse.body()?.errorMsg ?: "创建订单失败"
 
                         telegramNotificationService?.sendOrderFailureNotification(
                             marketTitle = marketTitle,
@@ -1465,7 +1442,7 @@ class AccountService(
                             outcome = null,  // 失败时可能没有 outcome
                             price = if (request.orderType == "LIMIT") sellPrice.toString() else "MARKET",
                             size = sellQuantity.toString(),
-                            errorMessage = errorMsg,  // 只传递后端返回的错误信息
+                            errorMessage = errorMsg,  // 只传递后端返回的 msg
                             accountName = account.accountName,
                             walletAddress = account.walletAddress,
                             locale = locale
@@ -1823,42 +1800,16 @@ class AccountService(
                     for (transaction in accountTransactions) {
                         val account = accounts[transaction.accountId]
                         if (account != null) {
-                            // 查询可用余额
-                            val availableBalance = try {
-                                blockchainService.getUsdcBalance(account.walletAddress, account.proxyAddress).getOrNull()
-                            } catch (e: Exception) {
-                                logger.warn("查询可用余额失败: accountId=${account.id}, ${e.message}")
-                                null
-                            }
-                            
-                            // 计算该账户的赎回总价值
-                            val accountTotalValue = transaction.positions.fold(BigDecimal.ZERO) { sum, info ->
-                                sum.add(info.value.toSafeBigDecimal())
-                            }
-                            
-                            // 根据赎回价值选择不同的通知类型
-                            if (accountTotalValue.gt(BigDecimal.ZERO)) {
-                                // 有收益：发送赎回成功通知
-                                telegramNotificationService?.sendRedeemNotification(
-                                    accountName = account.accountName,
-                                    walletAddress = account.walletAddress,
-                                    transactionHash = transaction.transactionHash,
-                                    totalRedeemedValue = accountTotalValue.toPlainString(),
-                                    positions = transaction.positions,
-                                    locale = locale,
-                                    availableBalance = availableBalance
-                                )
-                            } else {
-                                // 无收益（输的仓位）：发送已结算无收益通知
-                                telegramNotificationService?.sendRedeemNoReturnNotification(
-                                    accountName = account.accountName,
-                                    walletAddress = account.walletAddress,
-                                    transactionHash = transaction.transactionHash,
-                                    positions = transaction.positions,
-                                    locale = locale,
-                                    availableBalance = availableBalance
-                                )
-                            }
+                            telegramNotificationService?.sendRedeemNotification(
+                                accountName = account.accountName,
+                                walletAddress = account.walletAddress,
+                                transactionHash = transaction.transactionHash,
+                                totalRedeemedValue = transaction.positions.fold(BigDecimal.ZERO) { sum, info ->
+                                    sum.add(info.value.toSafeBigDecimal())
+                                }.toPlainString(),
+                                positions = transaction.positions,
+                                locale = locale
+                            )
                         }
                     }
                 } catch (e: Exception) {

backend/src/main/kotlin/com/wrbug/polymarketbot/service/backtest/BacktestExecutionService.kt

@@ -408,10 +408,25 @@ class BacktestExecutionService(
                                 val cost = actualSellQuantity.multiply(position.avgPrice)
                                 val profitLoss = netAmount.subtract(cost)
 
-                                // 更新余额和持仓
+                                // Bug #39 Fix: correctly reduce position quantity after sell
                                 currentBalance += netAmount
-                                if (position.quantity <= BigDecimal.ZERO) {
+                                val remainingQuantity = position.quantity - actualSellQuantity
+                                val remainingLeaderBuyQuantity = if (position.leaderBuyQuantity != null && position.leaderBuyQuantity > BigDecimal.ZERO) {
+                                    val totalQty = position.quantity
+                                    val leaderReduction = actualSellQuantity.divide(
+                                        totalQty, 8, java.math.RoundingMode.DOWN
+                                    )
+                                    (position.leaderBuyQuantity - leaderReduction).coerceAtLeast(BigDecimal.ZERO)
+                                } else {
+                                    position.leaderBuyQuantity
+                                }
+                                if (remainingQuantity <= BigDecimal.ZERO) {
                                     positions.remove(positionKey)
+                                } else {
+                                    positions[positionKey] = position.copy(
+                                        quantity = remainingQuantity,
+                                        leaderBuyQuantity = remainingLeaderBuyQuantity
+                                    )
                                 }
 
                                 // 记录交易到当前页列表
@@ -632,7 +647,8 @@ class BacktestExecutionService(
             val settlementPrice = avgPrice
 
             val settlementValue = quantity.multiply(settlementPrice)
-            val profitLoss = settlementValue.negate()
+            // Bug #39 Fix: profitLoss for closed settlement at avgPrice should be ~0
+            val profitLoss = settlementValue.subtract(quantity.multiply(avgPrice))
 
             balance += settlementValue
 
@@ -702,7 +718,8 @@ class BacktestExecutionService(
             if (balance > peakBalance) {
                 peakBalance = balance
             }
-            val drawdown = peakBalance - runningBalance
+            // Bug #39 Fix: use current balance, not runningBalance from previous iteration
+            val drawdown = peakBalance - balance
             if (drawdown > maxDrawdown) {
                 maxDrawdown = drawdown
             }

backend/src/main/kotlin/com/wrbug/polymarketbot/service/binance/BinanceKlineService.kt

@@ -91,12 +91,7 @@ class BinanceKlineService {
             }
         }.toSet()
         val wsKeysNeeded = parsed.map { (_, symbol, interval) -> "$symbol-$interval" }.toSet()
-        
-        // 检查是否有需要的 WebSocket 连接缺失（可能因网络问题断开）
-        val hasMissingConnection = wsKeysNeeded.any { it !in connectedWebSockets.keys }
-        
-        // 只有当集合相同且所有需要的连接都存在时才跳过
-        if (normalized == requiredMarketPrefixes.get() && !hasMissingConnection) return
+        if (normalized == requiredMarketPrefixes.get()) return
         requiredMarketPrefixes.set(normalized)
         synchronized(subscriptionLock) {
             connectedWebSockets.keys.toList().forEach { wsKey ->

backend/src/main/kotlin/com/wrbug/polymarketbot/service/common/PolymarketClobService.kt

@@ -401,7 +401,7 @@ class PolymarketClobService(
             Result.failure(e)
         }
     }
-
+    
     /**
      * 获取费率
      * 文档: https://docs.polymarket.com/developers/market-makers/maker-rebates-program#1-fetch-the-fee-rate

backend/src/main/kotlin/com/wrbug/polymarketbot/service/copytrading/orders/OrderPushService.kt

@@ -20,12 +20,7 @@ import com.wrbug.polymarketbot.repository.CopyTradingRepository
 import com.wrbug.polymarketbot.repository.LeaderRepository
 import com.wrbug.polymarketbot.constants.PolymarketConstants
 import com.wrbug.polymarketbot.service.common.MarketService
-import com.wrbug.polymarketbot.util.div
-import com.wrbug.polymarketbot.util.gt
-import com.wrbug.polymarketbot.util.multi
-import com.wrbug.polymarketbot.util.toSafeBigDecimal
 import org.springframework.stereotype.Service
-import java.math.BigDecimal
 import java.util.concurrent.ConcurrentHashMap
 
 /**
@@ -431,29 +426,20 @@ class OrderPushService(
                     // 获取市场信息（使用 MarketService，优先从数据库/缓存获取）
                     val market = marketService.getMarket(conditionId ?: openOrder.market)
 
-                    // 有成交时按公式计算实际成交价：original_size * price / size_matched，数量用 size_matched
-                    val sizeMatched = openOrder.sizeMatched.toSafeBigDecimal()
-                    val avgFilledPrice = if (sizeMatched.gt(BigDecimal.ZERO)) {
-                        openOrder.originalSize.toSafeBigDecimal()
-                            .multi(openOrder.price)
-                            .div(sizeMatched, 18)
-                    } else null
-
-                    // 转换为 DTO（展示数量用 size_matched）
+                    // 转换为 DTO
                     // 注意：createdAt 是 unix timestamp (Long)，需要转换为字符串
                     OrderDetailDto(
                         id = openOrder.id,
                         market = openOrder.market,
                         side = openOrder.side,
                         price = openOrder.price,
-                        size = openOrder.originalSize,
-                        filled = openOrder.sizeMatched,  // 已成交数量用 size_matched
+                        size = openOrder.originalSize,  // 使用 original_size
+                        filled = openOrder.sizeMatched,  // 使用 size_matched
                         status = openOrder.status,
                         createdAt = openOrder.createdAt.toString(),  // unix timestamp 转换为字符串
                         marketName = market?.title,
                         marketSlug = market?.slug,  // 显示用的 slug
-                        marketIcon = market?.icon,
-                        avgFilledPrice = avgFilledPrice?.toPlainString()  // 实际成交价 = original_size*price/size_matched
+                        marketIcon = market?.icon
                     )
                 },
                 onFailure = { e ->

backend/src/main/kotlin/com/wrbug/polymarketbot/service/copytrading/statistics/OrderStatusUpdateService.kt

@@ -7,10 +7,8 @@ import com.wrbug.polymarketbot.service.common.MarketService
 import com.wrbug.polymarketbot.service.system.TelegramNotificationService
 import com.wrbug.polymarketbot.util.RetrofitFactory
 import com.wrbug.polymarketbot.util.CryptoUtils
-import com.wrbug.polymarketbot.util.div
-import com.wrbug.polymarketbot.util.gt
-import com.wrbug.polymarketbot.util.multi
 import com.wrbug.polymarketbot.util.toSafeBigDecimal
+import com.wrbug.polymarketbot.util.multi
 import kotlinx.coroutines.*
 import org.slf4j.LoggerFactory
 import org.springframework.boot.context.event.ApplicationReadyEvent
@@ -40,8 +38,7 @@ class OrderStatusUpdateService(
     private val cryptoUtils: CryptoUtils,
     private val trackingService: CopyOrderTrackingService,
     private val marketService: MarketService,  // 市场信息服务
-    private val telegramNotificationService: TelegramNotificationService?,
-    private val blockchainService: com.wrbug.polymarketbot.service.common.BlockchainService
+    private val telegramNotificationService: TelegramNotificationService?
 ) : ApplicationContextAware {
 
     private val logger = LoggerFactory.getLogger(OrderStatusUpdateService::class.java)
@@ -558,13 +555,11 @@ class OrderStatusUpdateService(
 
                         logger.info("更新卖出订单价格成功: orderId=${record.sellOrderId}, 原价格=${record.sellPrice}, 新价格=$actualSellPrice")
 
-                        // 发送通知（使用实际成交价）
+                        // 发送通知（使用实际价格）
                         sendSellOrderNotification(
                             record = updatedRecord,
                             actualPrice = actualSellPrice.toString(),
                             actualSize = record.totalMatchedQuantity.toString(),
-                            avgFilledPrice = actualSellPrice.toString(),
-                            filled = record.totalMatchedQuantity.toString(),
                             account = account,
                             copyTrading = copyTrading,
                             clobApi = clobApi,
@@ -593,13 +588,11 @@ class OrderStatusUpdateService(
 
                         logger.debug("卖出订单价格无需更新: orderId=${record.sellOrderId}, price=$actualSellPrice")
 
-                        // 发送通知（使用实际成交价）
+                        // 发送通知
                         sendSellOrderNotification(
                             record = updatedRecord,
                             actualPrice = actualSellPrice.toString(),
                             actualSize = record.totalMatchedQuantity.toString(),
-                            avgFilledPrice = actualSellPrice.toString(),
-                            filled = record.totalMatchedQuantity.toString(),
                             account = account,
                             copyTrading = copyTrading,
                             clobApi = clobApi,
@@ -851,24 +844,12 @@ class OrderStatusUpdateService(
                         logger.debug("买入订单数据无需更新: orderId=${order.buyOrderId}")
                     }
 
-                    // 有成交时按公式计算实际成交价：original_size * price / size_matched，数量用 size_matched
-                    val sizeMatchedDec = orderDetail.sizeMatched.toSafeBigDecimal()
-                    val avgFilledPriceStr = if (sizeMatchedDec.gt(BigDecimal.ZERO)) {
-                        orderDetail.originalSize.toSafeBigDecimal()
-                            .multi(orderDetail.price)
-                            .div(sizeMatchedDec, 18)
-                            .toPlainString()
-                    } else null
-                    val filledSize = orderDetail.sizeMatched
-
-                    // 发送通知（使用实际数据，优先展示平均成交价）
+                    // 发送通知（使用实际数据）
                     sendBuyOrderNotification(
                         order = updatedOrder,
                         actualPrice = actualPrice.toString(),
                         actualSize = actualSize.toString(),
                         actualOutcome = actualOutcome,
-                        avgFilledPrice = avgFilledPriceStr,
-                        filled = filledSize,
                         account = account,
                         copyTrading = copyTrading,
                         clobApi = clobApi,
@@ -895,8 +876,6 @@ class OrderStatusUpdateService(
         actualPrice: String? = null,
         actualSize: String? = null,
         actualOutcome: String? = null,
-        avgFilledPrice: String? = null,  // 平均成交价（有成交时用于 TG 展示）
-        filled: String? = null,  // 已成交数量（与 avgFilledPrice 一起用于金额计算）
         account: Account? = null,
         copyTrading: CopyTrading? = null,
         clobApi: PolymarketClobApi? = null,
@@ -951,24 +930,14 @@ class OrderStatusUpdateService(
                     null
                 }
 
-            // 查询可用余额
-            val availableBalance = try {
-                blockchainService.getUsdcBalance(finalAccount.walletAddress, finalAccount.proxyAddress).getOrNull()
-            } catch (e: Exception) {
-                logger.warn("查询可用余额失败: accountId=${finalAccount.id}, ${e.message}")
-                null
-            }
-
-            // 发送通知（优先使用平均成交价展示）
+            // 发送通知
             telegramNotificationService.sendOrderSuccessNotification(
                 orderId = order.buyOrderId,
                 marketTitle = marketTitle,
                 marketId = order.marketId,
                 marketSlug = market?.eventSlug,  // 跳转用的 slug
                 side = "BUY",
-                price = actualPrice ?: order.price.toString(),  // 限价，无 avgFilledPrice 时展示
-                avgFilledPrice = avgFilledPrice,
-                filled = filled,
+                price = actualPrice ?: order.price.toString(),  // 使用实际价格或临时价格
                 size = actualSize ?: order.quantity.toString(),  // 使用实际数量或临时数量
                 outcome = actualOutcome,  // 使用实际 outcome
                 accountName = finalAccount.accountName,
@@ -981,8 +950,7 @@ class OrderStatusUpdateService(
                 locale = locale,
                 leaderName = leaderName,
                 configName = configName,
-                orderTime = orderCreatedAt,  // 使用订单创建时间
-                availableBalance = availableBalance
+                orderTime = orderCreatedAt  // 使用订单创建时间
             )
 
             logger.info("买入订单通知已发送: orderId=${order.buyOrderId}, copyTradingId=${order.copyTradingId}")
@@ -1001,8 +969,6 @@ class OrderStatusUpdateService(
         actualPrice: String? = null,
         actualSize: String? = null,
         actualOutcome: String? = null,
-        avgFilledPrice: String? = null,  // 平均成交价（有成交时用于 TG 展示）
-        filled: String? = null,  // 已成交数量（与 avgFilledPrice 一起用于金额计算）
         account: Account? = null,
         copyTrading: CopyTrading? = null,
         clobApi: PolymarketClobApi? = null,
@@ -1057,24 +1023,14 @@ class OrderStatusUpdateService(
                     null
                 }
 
-            // 查询可用余额
-            val availableBalance = try {
-                blockchainService.getUsdcBalance(finalAccount.walletAddress, finalAccount.proxyAddress).getOrNull()
-            } catch (e: Exception) {
-                logger.warn("查询可用余额失败: accountId=${finalAccount.id}, ${e.message}")
-                null
-            }
-
-            // 发送通知（优先使用平均成交价展示）
+            // 发送通知
             telegramNotificationService.sendOrderSuccessNotification(
                 orderId = record.sellOrderId,
                 marketTitle = marketTitle,
                 marketId = record.marketId,
                 marketSlug = market?.eventSlug,  // 跳转用的 slug
                 side = "SELL",
-                price = actualPrice ?: record.sellPrice.toString(),  // 限价，无 avgFilledPrice 时展示
-                avgFilledPrice = avgFilledPrice,
-                filled = filled,
+                price = actualPrice ?: record.sellPrice.toString(),  // 使用实际价格或临时价格
                 size = actualSize ?: record.totalMatchedQuantity.toString(),  // 使用实际数量或临时数量
                 outcome = actualOutcome,  // 使用实际 outcome
                 accountName = finalAccount.accountName,
@@ -1087,8 +1043,7 @@ class OrderStatusUpdateService(
                 locale = locale,
                 leaderName = leaderName,
                 configName = configName,
-                orderTime = orderCreatedAt,  // 使用订单创建时间
-                availableBalance = availableBalance
+                orderTime = orderCreatedAt  // 使用订单创建时间
             )
 
             logger.info("卖出订单通知已发送: orderId=${record.sellOrderId}, copyTradingId=${record.copyTradingId}")

backend/src/main/kotlin/com/wrbug/polymarketbot/service/cryptotail/CryptoTailMonitorService.kt

@@ -147,8 +147,7 @@ class CryptoTailMonitorService(
 
             val account = accountRepository.findById(strategy.accountId).orElse(null)
             val nowSeconds = System.currentTimeMillis() / 1000
-            val periodStartUnix = request.periodStartUnix
-                ?: ((nowSeconds / strategy.intervalSeconds) * strategy.intervalSeconds)
+            val periodStartUnix = (nowSeconds / strategy.intervalSeconds) * strategy.intervalSeconds
 
             // 获取市场信息
             val slug = "${strategy.marketSlugPrefix}-$periodStartUnix"
@@ -208,9 +207,7 @@ class CryptoTailMonitorService(
                 tokenIdUp = tokenIds.getOrNull(0),
                 tokenIdDown = tokenIds.getOrNull(1),
                 currentTimestamp = System.currentTimeMillis(),
-                enabled = strategy.enabled,
-                amountMode = strategy.amountMode,
-                amountValue = strategy.amountValue.toPlainString()
+                enabled = strategy.enabled
             )
 
             Result.success(response)

backend/src/main/kotlin/com/wrbug/polymarketbot/service/cryptotail/CryptoTailOrderNotificationPollingService.kt

@@ -6,10 +6,6 @@ import com.wrbug.polymarketbot.repository.CryptoTailStrategyRepository
 import com.wrbug.polymarketbot.repository.CryptoTailStrategyTriggerRepository
 import com.wrbug.polymarketbot.service.common.MarketService
 import com.wrbug.polymarketbot.service.system.TelegramNotificationService
-import com.wrbug.polymarketbot.util.div
-import com.wrbug.polymarketbot.util.gt
-import com.wrbug.polymarketbot.util.multi
-import com.wrbug.polymarketbot.util.toSafeBigDecimal
 import com.wrbug.polymarketbot.util.CryptoUtils
 import com.wrbug.polymarketbot.util.RetrofitFactory
 import kotlinx.coroutines.CoroutineScope
@@ -24,7 +20,6 @@ import org.springframework.scheduling.annotation.Scheduled
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
 import jakarta.annotation.PreDestroy
-import java.math.BigDecimal
 
 /**
  * 加密价差策略订单 TG 通知轮询服务（与跟单一致）
@@ -133,15 +128,6 @@ class CryptoTailOrderNotificationPollingService(
         val market = marketService.getMarket(order.market)
         val marketTitle = trigger.marketTitle?.takeIf { it.isNotBlank() } ?: market?.title ?: order.market
         val orderTimeMs = if (order.createdAt < 1_000_000_000_000L) order.createdAt * 1000 else order.createdAt
-        // 实际成交价 = original_size * price / size_matched，数量用 size_matched
-        val sizeMatchedDec = order.sizeMatched.toSafeBigDecimal()
-        val avgFilledPriceStr = if (sizeMatchedDec.gt(BigDecimal.ZERO)) {
-            order.originalSize.toSafeBigDecimal()
-                .multi(order.price)
-                .div(sizeMatchedDec, 18)
-                .toPlainString()
-        } else null
-        val filledSize = order.sizeMatched
         telegramNotificationService.sendCryptoTailOrderSuccessNotification(
             orderId = orderId,
             marketTitle = marketTitle,
@@ -151,8 +137,6 @@ class CryptoTailOrderNotificationPollingService(
             outcome = order.outcome,
             price = order.price,
             size = order.originalSize,
-            avgFilledPrice = avgFilledPriceStr,
-            filled = filledSize,
             strategyName = strategy.name,
             accountName = account.accountName,
             walletAddress = account.walletAddress,

backend/src/main/kotlin/com/wrbug/polymarketbot/service/cryptotail/CryptoTailStrategyExecutionService.kt

@@ -3,9 +3,6 @@ package com.wrbug.polymarketbot.service.cryptotail
 import com.wrbug.polymarketbot.api.GammaEventBySlugResponse
 import com.wrbug.polymarketbot.api.NewOrderRequest
 import com.wrbug.polymarketbot.api.PolymarketClobApi
-import com.wrbug.polymarketbot.dto.CryptoTailManualOrderRequest
-import com.wrbug.polymarketbot.dto.CryptoTailManualOrderResponse
-import com.wrbug.polymarketbot.dto.ManualOrderDetails
 import com.wrbug.polymarketbot.entity.Account
 import com.wrbug.polymarketbot.entity.CryptoTailStrategy
 import com.wrbug.polymarketbot.entity.CryptoTailStrategyTrigger
@@ -46,6 +43,9 @@ private const val SPREAD_MAX_PRICE_ADJUSTMENT = "0.02"
 /** 数量小数位数，与 OrderSigningService 的 roundConfig.size 一致 */
 private const val SIZE_DECIMAL_SCALE = 2
 
+/** 单笔下单最小 USDC 金额（平台限制），RATIO 模式计算值低于此值时按此值下单 */
+private val MIN_ORDER_USDC = BigDecimal("1")
+
 /**
  * 周期内预置上下文：账户、解密凭证、费率、签名类型、CLOB 客户端；不含预签订单。
  * 触发时 FIXED/RATIO 均按 outcomeIndex 计算 size 并签名提交。
@@ -154,7 +154,7 @@ class CryptoTailStrategyExecutionService(
         }
         val signatureType = orderSigningService.getSignatureTypeForWalletType(account.walletType)
 
-        if (strategy.amountMode.uppercase() != "RATIO" && strategy.amountValue < BigDecimal("1")) return null
+        if (strategy.amountMode.uppercase() != "RATIO" && strategy.amountValue < MIN_ORDER_USDC) return null
 
         val ctx = PeriodContext(
             strategy = strategy,
@@ -337,29 +337,36 @@ class CryptoTailStrategyExecutionService(
         val ctx = getOrInvalidatePeriodContext(strategy, periodStartUnix)
 
         if (ctx != null) {
-            val amountUsdc = when (strategy.amountMode.uppercase()) {
+            var availableBalanceForRatio = BigDecimal.ZERO
+            var amountUsdc = when (strategy.amountMode.uppercase()) {
                 "RATIO" -> {
                     val balanceResult = accountService.getAccountBalance(ctx.account.id)
                     val availableBalance =
                         balanceResult.getOrNull()?.availableBalance?.toSafeBigDecimal() ?: BigDecimal.ZERO
+                    availableBalanceForRatio = availableBalance
                     availableBalance.multiply(strategy.amountValue).divide(BigDecimal("100"), 18, RoundingMode.DOWN)
                 }
 
                 else -> strategy.amountValue
             }
-            if (amountUsdc < BigDecimal("1")) {
-                saveTriggerRecord(
-                    strategy,
-                    periodStartUnix,
-                    marketTitle,
-                    outcomeIndex,
-                    triggerPrice,
-                    amountUsdc,
-                    null,
-                    "fail",
-                    "投入金额不足"
-                )
-                return
+            if (amountUsdc < MIN_ORDER_USDC) {
+                val amountMode = strategy.amountMode.uppercase()
+                if (amountMode == "RATIO" && availableBalanceForRatio >= MIN_ORDER_USDC) {
+                    amountUsdc = MIN_ORDER_USDC
+                } else {
+                    saveTriggerRecord(
+                        strategy,
+                        periodStartUnix,
+                        marketTitle,
+                        outcomeIndex,
+                        triggerPrice,
+                        amountUsdc,
+                        null,
+                        "fail",
+                        "投入金额不足"
+                    )
+                    return
+                }
             }
 
             val tokenId = tokenIds.getOrNull(outcomeIndex) ?: run {
@@ -414,8 +421,7 @@ class CryptoTailStrategyExecutionService(
                 outcomeIndex,
                 triggerPrice,
                 amountUsdc,
-                orderRequest,
-                triggerType = "AUTO"
+                orderRequest
             )
             return
         }
@@ -431,8 +437,7 @@ class CryptoTailStrategyExecutionService(
         outcomeIndex: Int,
         triggerPrice: BigDecimal,
         amountUsdc: BigDecimal,
-        orderRequest: NewOrderRequest,
-        triggerType: String = "AUTO"
+        orderRequest: NewOrderRequest
     ) {
         var failReason: String? = null
         try {
@@ -449,10 +454,9 @@ class CryptoTailStrategyExecutionService(
                         amountUsdc,
                         body.orderId,
                         "success",
-                        null,
-                        triggerType = triggerType
+                        null
                     )
-                    logger.info("加密价差策略下单成功: strategyId=${strategy.id}, periodStartUnix=$periodStartUnix, outcomeIndex=$outcomeIndex, orderId=${body.orderId}, triggerType=$triggerType")
+                    logger.info("加密价差策略下单成功: strategyId=${strategy.id}, periodStartUnix=$periodStartUnix, outcomeIndex=$outcomeIndex, orderId=${body.orderId}")
                     return
                 }
                 failReason = body.errorMsg ?: "unknown"
@@ -473,8 +477,7 @@ class CryptoTailStrategyExecutionService(
             amountUsdc,
             null,
             "fail",
-            failReason,
-            triggerType = triggerType
+            failReason
         )
         logger.error("加密价差策略下单失败: strategyId=${strategy.id}, periodStartUnix=$periodStartUnix, reason=$failReason")
     }
@@ -521,23 +524,28 @@ class CryptoTailStrategyExecutionService(
 
         val balanceResult = accountService.getAccountBalance(account.id)
         val availableBalance = balanceResult.getOrNull()?.availableBalance?.toSafeBigDecimal() ?: BigDecimal.ZERO
-        val amountUsdc = when (strategy.amountMode.uppercase()) {
+        var amountUsdc = when (strategy.amountMode.uppercase()) {
             "RATIO" -> availableBalance.multiply(strategy.amountValue).divide(BigDecimal("100"), 18, RoundingMode.DOWN)
             else -> strategy.amountValue
         }
-        if (amountUsdc < BigDecimal("1")) {
-            saveTriggerRecord(
-                strategy,
-                periodStartUnix,
-                marketTitle,
-                outcomeIndex,
-                triggerPrice,
-                amountUsdc,
-                null,
-                "fail",
-                "投入金额不足"
-            )
-            return
+        if (amountUsdc < MIN_ORDER_USDC) {
+            val amountMode = strategy.amountMode.uppercase()
+            if (amountMode == "RATIO" && availableBalance >= MIN_ORDER_USDC) {
+                amountUsdc = MIN_ORDER_USDC
+            } else {
+                saveTriggerRecord(
+                    strategy,
+                    periodStartUnix,
+                    marketTitle,
+                    outcomeIndex,
+                    triggerPrice,
+                    amountUsdc,
+                    null,
+                    "fail",
+                    "投入金额不足"
+                )
+                return
+            }
         }
 
         val tokenId = tokenIds.getOrNull(outcomeIndex) ?: run {
@@ -657,8 +665,7 @@ class CryptoTailStrategyExecutionService(
         amountUsdc: BigDecimal,
         orderId: String?,
         status: String,
-        failReason: String?,
-        triggerType: String = "AUTO"
+        failReason: String?
     ) {
         val record = CryptoTailStrategyTrigger(
             strategyId = strategy.id!!,
@@ -669,173 +676,11 @@ class CryptoTailStrategyExecutionService(
             amountUsdc = amountUsdc,
             orderId = orderId,
             status = status,
-            failReason = failReason,
-            triggerType = triggerType
+            failReason = failReason
         )
         triggerRepository.save(record)
     }
 
-    /**
-     * 手动下单：用户主动触发下单，不检查任何条件，仅检查当前周期是否已下单
-     */
-    suspend fun manualOrder(request: CryptoTailManualOrderRequest): Result<CryptoTailManualOrderResponse> {
-        return try {
-            val strategy = strategyRepository.findById(request.strategyId).orElse(null)
-                ?: return Result.failure(IllegalArgumentException("策略不存在"))
-
-            val outcomeIndex = if (request.direction.uppercase() == "UP") 0 else 1
-
-            if (outcomeIndex < 0 || outcomeIndex >= request.tokenIds.size) {
-                return Result.failure(IllegalArgumentException("outcomeIndex 越界"))
-            }
-
-            val price = request.price.toSafeBigDecimal()
-            if (price <= BigDecimal.ZERO || price > BigDecimal.ONE) {
-                return Result.failure(IllegalArgumentException("价格必须在 0~1 之间"))
-            }
-            val priceRounded = price.setScale(4, RoundingMode.UP)
-
-            val size = request.size.toSafeBigDecimal()
-            if (size < BigDecimal.ONE) {
-                return Result.failure(IllegalArgumentException("数量不能少于 1"))
-            }
-
-            val amountUsdc = priceRounded.multi(size).setScale(2, RoundingMode.HALF_UP)
-            if (amountUsdc < BigDecimal.ONE) {
-                return Result.failure(IllegalArgumentException("总金额不能少于 1 USDC"))
-            }
-
-            val mutex = getTriggerMutex(strategy.id!!, request.periodStartUnix)
-            mutex.withLock {
-                if (triggerRepository.findByStrategyIdAndPeriodStartUnix(
-                        strategy.id!!,
-                        request.periodStartUnix
-                    ) != null
-                ) {
-                    return@withLock Result.failure(IllegalArgumentException("当前周期已下单"))
-                }
-
-                var ctx = getOrInvalidatePeriodContext(strategy, request.periodStartUnix)
-                if (ctx == null) {
-                    ctx = ensurePeriodContext(
-                        strategy,
-                        request.periodStartUnix,
-                        request.tokenIds,
-                        request.marketTitle.ifBlank { null }
-                    )
-                }
-                if (ctx != null) {
-                    val tokenId = request.tokenIds.getOrNull(outcomeIndex)
-                        ?: return@withLock Result.failure(IllegalArgumentException("tokenIds 越界"))
-
-                    val priceStr = priceRounded.toPlainString()
-                    val sizeStr = size.toPlainString()
-                    val feeRateBps = ctx.feeRateByTokenId[tokenId] ?: "0"
-
-                    val signedOrder = orderSigningService.createAndSignOrder(
-                        privateKey = ctx.decryptedPrivateKey,
-                        makerAddress = ctx.account.proxyAddress,
-                        tokenId = tokenId,
-                        side = "BUY",
-                        price = priceStr,
-                        size = sizeStr,
-                        signatureType = ctx.signatureType,
-                        nonce = "0",
-                        feeRateBps = feeRateBps,
-                        expiration = "0"
-                    )
-
-                    val orderRequest = NewOrderRequest(
-                        order = signedOrder,
-                        owner = ctx.account.apiKey!!,
-                        orderType = "FAK",
-                        deferExec = false
-                    )
-
-                    val orderResult = submitOrderForManualOrder(
-                        ctx.clobApi,
-                        strategy,
-                        request.periodStartUnix,
-                        request.marketTitle,
-                        outcomeIndex,
-                        priceRounded,
-                        amountUsdc,
-                        orderRequest
-                    )
-
-                    orderResult.fold(
-                        onSuccess = { orderId ->
-                            Result.success(
-                                CryptoTailManualOrderResponse(
-                                    success = true,
-                                    orderId = orderId,
-                                    message = "下单成功",
-                                    orderDetails = ManualOrderDetails(
-                                        strategyId = strategy.id!!,
-                                        direction = request.direction,
-                                        price = priceStr,
-                                        size = sizeStr,
-                                        totalAmount = amountUsdc.toPlainString()
-                                    )
-                                )
-                            )
-                        },
-                        onFailure = { e ->
-                            Result.failure(e)
-                        }
-                    )
-                } else {
-                    Result.failure(IllegalArgumentException("账户未配置或凭证不足"))
-                }
-            }
-        } catch (e: Exception) {
-            logger.error("手动下单异常: strategyId=${request.strategyId}, ${e.message}", e)
-            Result.failure(e)
-        }
-    }
-
-    private suspend fun submitOrderForManualOrder(
-        clobApi: PolymarketClobApi,
-        strategy: CryptoTailStrategy,
-        periodStartUnix: Long,
-        marketTitle: String?,
-        outcomeIndex: Int,
-        price: BigDecimal,
-        amountUsdc: BigDecimal,
-        orderRequest: NewOrderRequest
-    ): Result<String> {
-        return try {
-            val response = clobApi.createOrder(orderRequest)
-            if (response.isSuccessful && response.body() != null) {
-                val body = response.body()!!
-                if (body.success && body.orderId != null) {
-                    saveTriggerRecord(
-                        strategy,
-                        periodStartUnix,
-                        marketTitle,
-                        outcomeIndex,
-                        price,
-                        amountUsdc,
-                        body.orderId,
-                        "success",
-                        null,
-                        triggerType = "MANUAL"
-                    )
-                    logger.info("手动下单成功: strategyId=${strategy.id}, periodStartUnix=$periodStartUnix, outcomeIndex=$outcomeIndex, orderId=${body.orderId}")
-                    Result.success(body.orderId)
-                } else {
-                    Result.failure(Exception(body.errorMsg ?: "unknown"))
-                }
-            } else {
-                val errorBody = response.errorBody()?.string().orEmpty()
-                Result.failure(Exception(errorBody.ifEmpty { "请求失败" }))
-            }
-        } catch (e: Exception) {
-            logger.error("手动下单异常: strategyId=${strategy.id}, periodStartUnix=$periodStartUnix", e)
-            Result.failure(e)
-        }
-    }
-
     @PreDestroy
     fun destroy() {
         // 清理所有周期上下文缓存，避免敏感信息（明文私钥、API Secret）在内存中保留

backend/src/main/kotlin/com/wrbug/polymarketbot/service/cryptotail/CryptoTailStrategyService.kt

@@ -9,7 +9,6 @@ import com.wrbug.polymarketbot.enums.SpreadDirection
 import com.wrbug.polymarketbot.repository.CryptoTailStrategyRepository
 import com.wrbug.polymarketbot.repository.CryptoTailStrategyTriggerRepository
 import com.wrbug.polymarketbot.event.CryptoTailStrategyChangedEvent
-import com.wrbug.polymarketbot.util.gt
 import com.wrbug.polymarketbot.util.toSafeBigDecimal
 import org.slf4j.LoggerFactory
 import org.springframework.context.ApplicationEventPublisher
@@ -221,61 +220,6 @@ class CryptoTailStrategyService(
         }
     }
 
-    fun getPnlCurve(request: CryptoTailPnlCurveRequest): Result<CryptoTailPnlCurveResponse> {
-        return try {
-            val strategy = strategyRepository.findById(request.strategyId).orElse(null)
-                ?: return Result.failure(IllegalArgumentException(ErrorCode.CRYPTO_TAIL_STRATEGY_NOT_FOUND.messageKey))
-            val start = request.startDate ?: 0L
-            val end = request.endDate ?: Long.MAX_VALUE
-            val triggers = triggerRepository.findResolvedByStrategyIdAndTimeRangeOrderBySettledAsc(
-                request.strategyId, start, end
-            )
-            var cumulative = BigDecimal.ZERO
-            var peak = BigDecimal.ZERO
-            var maxDrawdown = BigDecimal.ZERO
-            var winCountInRange = 0L
-            val curveData = triggers.map { t ->
-                val pnl = t.realizedPnl ?: BigDecimal.ZERO
-                cumulative = cumulative.add(pnl)
-                if (cumulative.gt(peak)) peak = cumulative
-                val drawdown = peak.subtract(cumulative)
-                if (drawdown.gt(maxDrawdown)) maxDrawdown = drawdown
-                if (t.winnerOutcomeIndex != null && t.outcomeIndex == t.winnerOutcomeIndex) winCountInRange++
-                val ts = t.settledAt ?: t.createdAt
-                CryptoTailPnlCurvePoint(
-                    timestamp = ts,
-                    cumulativePnl = cumulative.toPlainString(),
-                    pointPnl = pnl.toPlainString(),
-                    settledCount = 0L
-                )
-            }.mapIndexed { index, p ->
-                p.copy(settledCount = (index + 1).toLong())
-            }
-            val totalPnl = if (curveData.isEmpty()) BigDecimal.ZERO else curveData.last().cumulativePnl.toSafeBigDecimal()
-            val settledCountInRange = curveData.size.toLong()
-            val winRateStr = if (settledCountInRange > 0L) {
-                BigDecimal(winCountInRange).divide(BigDecimal(settledCountInRange), 4, java.math.RoundingMode.HALF_UP).toPlainString()
-            } else null
-            Result.success(
-                CryptoTailPnlCurveResponse(
-                    strategyId = request.strategyId,
-                    strategyName = strategy.name ?: strategy.marketSlugPrefix,
-                    totalRealizedPnl = totalPnl.toPlainString(),
-                    settledCount = settledCountInRange,
-                    winCount = winCountInRange,
-                    winRate = winRateStr,
-                    maxDrawdown = if (maxDrawdown.compareTo(BigDecimal.ZERO) > 0) maxDrawdown.toPlainString() else null,
-                    curveData = curveData
-                )
-            )
-        } catch (e: IllegalArgumentException) {
-            Result.failure(e)
-        } catch (e: Exception) {
-            logger.error("查询收益曲线失败: ${e.message}", e)
-            Result.failure(e)
-        }
-    }
-
     fun getTriggerRecords(request: CryptoTailStrategyTriggerListRequest): Result<CryptoTailStrategyTriggerListResponse> {
         return try {
             val page = PageRequest.of((request.page - 1).coerceAtLeast(0), request.pageSize.coerceIn(1, 100))

backend/src/main/kotlin/com/wrbug/polymarketbot/service/system/NotificationTemplateService.kt

@@ -1,457 +0,0 @@
-package com.wrbug.polymarketbot.service.system
-
-import com.wrbug.polymarketbot.dto.*
-import com.wrbug.polymarketbot.entity.NotificationTemplate
-import com.wrbug.polymarketbot.repository.NotificationTemplateRepository
-import org.slf4j.LoggerFactory
-import org.springframework.context.annotation.Lazy
-import org.springframework.stereotype.Service
-import org.springframework.transaction.annotation.Transactional
-
-/**
- * 消息模板服务
- * 负责管理消息模板、渲染模板、提供变量信息
- */
-@Service
-class NotificationTemplateService(
-    private val templateRepository: NotificationTemplateRepository,
-    @Lazy private val telegramNotificationService: TelegramNotificationService
-) {
-    private val logger = LoggerFactory.getLogger(NotificationTemplateService::class.java)
-
-    companion object {
-        // 模板类型定义
-        val TEMPLATE_TYPES = mapOf(
-            "ORDER_SUCCESS" to TemplateTypeInfoDto(
-                type = "ORDER_SUCCESS",
-                name = "订单成功通知",
-                description = "订单创建成功时发送的通知"
-            ),
-            "ORDER_FAILED" to TemplateTypeInfoDto(
-                type = "ORDER_FAILED",
-                name = "订单失败通知",
-                description = "订单创建失败时发送的通知"
-            ),
-            "ORDER_FILTERED" to TemplateTypeInfoDto(
-                type = "ORDER_FILTERED",
-                name = "订单过滤通知",
-                description = "订单被风控过滤时发送的通知"
-            ),
-            "CRYPTO_TAIL_SUCCESS" to TemplateTypeInfoDto(
-                type = "CRYPTO_TAIL_SUCCESS",
-                name = "加密价差策略成功通知",
-                description = "加密价差策略下单成功时发送的通知"
-            ),
-            "REDEEM_SUCCESS" to TemplateTypeInfoDto(
-                type = "REDEEM_SUCCESS",
-                name = "仓位赎回成功通知",
-                description = "仓位赎回成功时发送的通知"
-            ),
-            "REDEEM_NO_RETURN" to TemplateTypeInfoDto(
-                type = "REDEEM_NO_RETURN",
-                name = "仓位结算（无收益）通知",
-                description = "仓位结算但无收益时发送的通知"
-            )
-        )
-
-        // 变量分类
-        val VARIABLE_CATEGORIES = listOf(
-            TemplateVariableCategoryDto("common", 0),
-            TemplateVariableCategoryDto("order", 10),
-            TemplateVariableCategoryDto("copy_trading", 20),
-            TemplateVariableCategoryDto("redeem", 30),
-            TemplateVariableCategoryDto("error", 40),
-            TemplateVariableCategoryDto("filter", 50),
-            TemplateVariableCategoryDto("strategy", 60)
-        )
-
-        // 各模板类型可用的变量
-        val TEMPLATE_VARIABLES = mapOf(
-            "ORDER_SUCCESS" to listOf(
-                // 通用变量
-                TemplateVariableDto("account_name", "common", 1),
-                TemplateVariableDto("wallet_address", "common", 2),
-                TemplateVariableDto("time", "common", 3),
-                // 订单变量
-                TemplateVariableDto("order_id", "order", 10),
-                TemplateVariableDto("market_title", "order", 11),
-                TemplateVariableDto("market_link", "order", 12),
-                TemplateVariableDto("side", "order", 13),
-                TemplateVariableDto("outcome", "order", 14),
-                TemplateVariableDto("price", "order", 15),
-                TemplateVariableDto("quantity", "order", 16),
-                TemplateVariableDto("amount", "order", 17),
-                TemplateVariableDto("available_balance", "order", 18),
-                // 跟单变量
-                TemplateVariableDto("leader_name", "copy_trading", 21),
-                TemplateVariableDto("config_name", "copy_trading", 22)
-            ),
-            "ORDER_FAILED" to listOf(
-                // 通用变量
-                TemplateVariableDto("account_name", "common", 1),
-                TemplateVariableDto("wallet_address", "common", 2),
-                TemplateVariableDto("time", "common", 3),
-                // 订单变量
-                TemplateVariableDto("market_title", "order", 10),
-                TemplateVariableDto("market_link", "order", 11),
-                TemplateVariableDto("side", "order", 12),
-                TemplateVariableDto("outcome", "order", 13),
-                TemplateVariableDto("price", "order", 14),
-                TemplateVariableDto("quantity", "order", 15),
-                TemplateVariableDto("amount", "order", 16),
-                // 错误变量
-                TemplateVariableDto("error_message", "error", 20)
-            ),
-            "ORDER_FILTERED" to listOf(
-                // 通用变量
-                TemplateVariableDto("account_name", "common", 1),
-                TemplateVariableDto("wallet_address", "common", 2),
-                TemplateVariableDto("time", "common", 3),
-                // 订单变量
-                TemplateVariableDto("market_title", "order", 10),
-                TemplateVariableDto("market_link", "order", 11),
-                TemplateVariableDto("side", "order", 12),
-                TemplateVariableDto("outcome", "order", 13),
-                TemplateVariableDto("price", "order", 14),
-                TemplateVariableDto("quantity", "order", 15),
-                TemplateVariableDto("amount", "order", 16),
-                // 过滤变量
-                TemplateVariableDto("filter_type", "filter", 20),
-                TemplateVariableDto("filter_reason", "filter", 21)
-            ),
-            "CRYPTO_TAIL_SUCCESS" to listOf(
-                // 通用变量
-                TemplateVariableDto("account_name", "common", 1),
-                TemplateVariableDto("wallet_address", "common", 2),
-                TemplateVariableDto("time", "common", 3),
-                // 订单变量
-                TemplateVariableDto("order_id", "order", 10),
-                TemplateVariableDto("market_title", "order", 11),
-                TemplateVariableDto("market_link", "order", 12),
-                TemplateVariableDto("side", "order", 13),
-                TemplateVariableDto("outcome", "order", 14),
-                TemplateVariableDto("price", "order", 15),
-                TemplateVariableDto("quantity", "order", 16),
-                TemplateVariableDto("amount", "order", 17),
-                // 策略变量
-                TemplateVariableDto("strategy_name", "strategy", 20)
-            ),
-            "REDEEM_SUCCESS" to listOf(
-                // 通用变量
-                TemplateVariableDto("account_name", "common", 1),
-                TemplateVariableDto("wallet_address", "common", 2),
-                TemplateVariableDto("time", "common", 3),
-                // 赎回变量
-                TemplateVariableDto("transaction_hash", "redeem", 10),
-                TemplateVariableDto("total_value", "redeem", 11),
-                TemplateVariableDto("available_balance", "redeem", 12)
-            ),
-            "REDEEM_NO_RETURN" to listOf(
-                // 通用变量
-                TemplateVariableDto("account_name", "common", 1),
-                TemplateVariableDto("wallet_address", "common", 2),
-                TemplateVariableDto("time", "common", 3),
-                // 赎回变量
-                TemplateVariableDto("transaction_hash", "redeem", 10),
-                TemplateVariableDto("available_balance", "redeem", 11)
-            )
-        )
-
-        // 默认模板
-        val DEFAULT_TEMPLATES = mapOf(
-            "ORDER_SUCCESS" to """
-🚀 <b>订单创建成功</b>
-
-📊 <b>订单信息：</b>
-• 订单ID: <code>{{order_id}}</code>
-• 市场: <a href="{{market_link}}">{{market_title}}</a>
-• 市场方向: <b>{{outcome}}</b>
-• 方向: <b>{{side}}</b>
-• 价格: <code>{{price}}</code>
-• 数量: <code>{{quantity}}</code> shares
-• 金额: <code>{{amount}}</code> USDC
-• 账户: {{account_name}}
-• 可用余额: <code>{{available_balance}}</code> USDC
-
-⏰ 时间: <code>{{time}}</code>
-            """.trimIndent(),
-            "ORDER_FAILED" to """
-❌ <b>订单创建失败</b>
-
-📊 <b>订单信息：</b>
-• 市场: <a href="{{market_link}}">{{market_title}}</a>
-• 市场方向: <b>{{outcome}}</b>
-• 方向: <b>{{side}}</b>
-• 价格: <code>{{price}}</code>
-• 数量: <code>{{quantity}}</code> shares
-• 金额: <code>{{amount}}</code> USDC
-• 账户: {{account_name}}
-
-⚠️ <b>错误信息：</b>
-<code>{{error_message}}</code>
-
-⏰ 时间: <code>{{time}}</code>
-            """.trimIndent(),
-            "ORDER_FILTERED" to """
-🚫 <b>订单被过滤</b>
-
-📊 <b>订单信息：</b>
-• 市场: <a href="{{market_link}}">{{market_title}}</a>
-• 市场方向: <b>{{outcome}}</b>
-• 方向: <b>{{side}}</b>
-• 价格: <code>{{price}}</code>
-• 数量: <code>{{quantity}}</code> shares
-• 金额: <code>{{amount}}</code> USDC
-• 账户: {{account_name}}
-
-⚠️ <b>过滤类型：</b> <code>{{filter_type}}</code>
-
-📝 <b>过滤原因：</b>
-<code>{{filter_reason}}</code>
-
-⏰ 时间: <code>{{time}}</code>
-            """.trimIndent(),
-            "CRYPTO_TAIL_SUCCESS" to """
-🚀 <b>加密价差策略下单成功</b>
-
-📊 <b>订单信息：</b>
-• 订单ID: <code>{{order_id}}</code>
-• 策略: {{strategy_name}}
-• 市场: <a href="{{market_link}}">{{market_title}}</a>
-• 市场方向: <b>{{outcome}}</b>
-• 方向: <b>{{side}}</b>
-• 价格: <code>{{price}}</code>
-• 数量: <code>{{quantity}}</code> shares
-• 金额: <code>{{amount}}</code> USDC
-• 账户: {{account_name}}
-
-⏰ 时间: <code>{{time}}</code>
-            """.trimIndent(),
-            "REDEEM_SUCCESS" to """
-💸 <b>仓位赎回成功</b>
-
-📊 <b>赎回信息：</b>
-• 账户: {{account_name}}
-• 交易哈希: <code>{{transaction_hash}}</code>
-• 赎回总价值: <code>{{total_value}}</code> USDC
-• 可用余额: <code>{{available_balance}}</code> USDC
-
-⏰ 时间: <code>{{time}}</code>
-            """.trimIndent(),
-            "REDEEM_NO_RETURN" to """
-📋 <b>仓位已结算（无收益）</b>
-
-📊 <b>结算信息：</b>
-<i>市场已结算，您的预测未命中，赎回价值为 0。</i>
-
-• 账户: {{account_name}}
-• 交易哈希: <code>{{transaction_hash}}</code>
-• 可用余额: <code>{{available_balance}}</code> USDC
-
-⏰ 时间: <code>{{time}}</code>
-            """.trimIndent()
-        )
-    }
-
-    /**
-     * 获取所有模板类型
-     */
-    fun getTemplateTypes(): List<TemplateTypeInfoDto> {
-        return TEMPLATE_TYPES.values.toList()
-    }
-
-    /**
-     * 获取所有模板列表
-     */
-    fun getAllTemplates(): List<NotificationTemplateDto> {
-        return templateRepository.findAll().map { it.toDto() }
-    }
-
-    /**
-     * 获取单个模板
-     */
-    fun getTemplate(templateType: String): NotificationTemplateDto? {
-        return templateRepository.findByTemplateType(templateType)?.toDto()
-            ?: DEFAULT_TEMPLATES[templateType]?.let {
-                NotificationTemplateDto(
-                    templateType = templateType,
-                    templateContent = it,
-                    isDefault = true
-                )
-            }
-    }
-
-    /**
-     * 获取模板可用变量
-     */
-    fun getTemplateVariables(templateType: String): TemplateVariablesResponse? {
-        if (!TEMPLATE_TYPES.containsKey(templateType)) return null
-        val variables = TEMPLATE_VARIABLES[templateType] ?: emptyList()
-
-        // 获取使用的分类
-        val usedCategories = variables.map { it.category }.toSet()
-        val categories = VARIABLE_CATEGORIES.filter { usedCategories.contains(it.key) }
-
-        return TemplateVariablesResponse(
-            templateType = templateType,
-            categories = categories,
-            variables = variables
-        )
-    }
-
-    /**
-     * 更新模板
-     */
-    @Transactional
-    fun updateTemplate(templateType: String, content: String): NotificationTemplateDto {
-        val template = templateRepository.findByTemplateType(templateType)
-        val now = System.currentTimeMillis()
-
-        return if (template != null) {
-            template.templateContent = content
-            template.isDefault = false
-            template.updatedAt = now
-            templateRepository.save(template).toDto()
-        } else {
-            val newTemplate = NotificationTemplate(
-                templateType = templateType,
-                templateContent = content,
-                isDefault = false,
-                createdAt = now,
-                updatedAt = now
-            )
-            templateRepository.save(newTemplate).toDto()
-        }
-    }
-
-    /**
-     * 重置模板为默认
-     */
-    @Transactional
-    fun resetTemplate(templateType: String): NotificationTemplateDto? {
-        val defaultContent = DEFAULT_TEMPLATES[templateType] ?: return null
-        val template = templateRepository.findByTemplateType(templateType)
-        val now = System.currentTimeMillis()
-
-        return if (template != null) {
-            template.templateContent = defaultContent
-            template.isDefault = true
-            template.updatedAt = now
-            templateRepository.save(template).toDto()
-        } else {
-            val newTemplate = NotificationTemplate(
-                templateType = templateType,
-                templateContent = defaultContent,
-                isDefault = true,
-                createdAt = now,
-                updatedAt = now
-            )
-            templateRepository.save(newTemplate).toDto()
-        }
-    }
-
-    /**
-     * 渲染模板（按类型取模板内容后替换变量）
-     * 优化：先解析模版中需要的变量，只替换这些变量，未提供的变量使用 "-" 占位
-     */
-    fun renderTemplate(templateType: String, variables: Map<String, String>): String {
-        val template = getTemplate(templateType)
-        val content = template?.templateContent ?: DEFAULT_TEMPLATES[templateType] ?: ""
-        return renderTemplateContent(content, variables)
-    }
-
-    /**
-     * 对给定模板内容做变量替换（不查库）
-     * 优化：先解析模版中的变量占位符，只替换这些变量，未提供的变量使用 "-" 占位
-     */
-    fun renderTemplateContent(content: String, variables: Map<String, String>): String {
-        // 先解析模版中需要的变量
-        val requiredVariables = extractTemplateVariables(content)
-        
-        var result = content
-        // 只替换模版中实际使用的变量
-        requiredVariables.forEach { varName ->
-            val value = variables[varName]
-            result = result.replace("{{$varName}}", value ?: "-")
-        }
-        return result
-    }
-
-    /**
-     * 解析模版中使用的变量名
-     * @return 变量名列表（去重）
-     */
-    private fun extractTemplateVariables(content: String): Set<String> {
-        val regex = Regex("\\{\\{([^}]+)}}")
-        return regex.findAll(content)
-            .map { it.groupValues[1].trim() }
-            .toSet()
-    }
-
-    /**
-     * 根据模版需要的变量过滤输入变量
-     * 只保留模版中实际使用的变量，避免不必要的数据获取
-     */
-    fun filterVariablesForTemplate(templateType: String, variables: Map<String, String>): Map<String, String> {
-        val template = getTemplate(templateType)
-        val content = template?.templateContent ?: DEFAULT_TEMPLATES[templateType] ?: return emptyMap()
-        val requiredVariables = extractTemplateVariables(content)
-        return variables.filterKeys { it in requiredVariables }
-    }
-
-    /**
-     * 发送测试消息
-     */
-    suspend fun sendTestMessage(templateType: String, content: String? = null): Boolean {
-        val templateContent = content ?: getTemplate(templateType)?.templateContent ?: return false
-        val testVariables = generateTestVariables(templateType)
-        val message = renderTemplateContent(templateContent, testVariables)
-        return try {
-            telegramNotificationService.sendMessage(message)
-            true
-        } catch (e: Exception) {
-            logger.error("发送测试消息失败: ${e.message}", e)
-            false
-        }
-    }
-
-    /**
-     * 生成测试变量数据
-     */
-    private fun generateTestVariables(templateType: String): Map<String, String> {
-        return mapOf(
-            "account_name" to "测试账户",
-            "wallet_address" to "0x1234...5678",
-            "time" to "2024-01-15 12:30:00",
-            "order_id" to "12345678",
-            "market_title" to "测试市场标题",
-            "market_link" to "https://polymarket.com/event/test",
-            "side" to "买入",
-            "outcome" to "YES",
-            "price" to "0.55",
-            "quantity" to "100",
-            "amount" to "55.00",
-            "available_balance" to "1000.00",
-            "leader_name" to "测试Leader",
-            "config_name" to "测试配置",
-            "error_message" to "余额不足",
-            "filter_type" to "价差过大",
-            "filter_reason" to "当前市场价差为 5%，超过设定的 3% 限制",
-            "strategy_name" to "BTC价差策略",
-            "transaction_hash" to "0xabcd...efgh",
-            "total_value" to "100.00"
-        )
-    }
-
-    /**
-     * Entity 转 DTO
-     */
-    private fun NotificationTemplate.toDto() = NotificationTemplateDto(
-        id = id,
-        templateType = templateType,
-        templateContent = templateContent,
-        isDefault = isDefault,
-        createdAt = createdAt,
-        updatedAt = updatedAt
-    )
-}

backend/src/main/kotlin/com/wrbug/polymarketbot/service/system/TelegramNotificationService.kt

@@ -26,7 +26,6 @@ import java.util.concurrent.TimeUnit
 @Service
 class TelegramNotificationService(
     private val notificationConfigService: NotificationConfigService,
-    private val notificationTemplateService: NotificationTemplateService,
     private val objectMapper: ObjectMapper,
     private val messageSource: MessageSource
 ) {
@@ -86,9 +85,7 @@ class TelegramNotificationService(
         marketId: String? = null,
         marketSlug: String? = null,
         side: String,
-        price: String? = null,  // 订单限价（可选）
-        avgFilledPrice: String? = null,  // 平均成交价（可选，有成交时优先展示）
-        filled: String? = null,  // 已成交数量（可选，与 avgFilledPrice 一起时用于金额计算）
+        price: String? = null,  // 订单价格（可选，如果提供则直接使用）
         size: String? = null,  // 订单数量（可选，如果提供则直接使用）
         outcome: String? = null,  // 市场方向（可选，如果提供则直接使用）
         accountName: String? = null,
@@ -101,8 +98,7 @@ class TelegramNotificationService(
         locale: java.util.Locale? = null,
         leaderName: String? = null,  // Leader 名称（备注）
         configName: String? = null,  // 跟单配置名
-        orderTime: Long? = null,  // 订单创建时间（毫秒时间戳），用于通知中的时间显示
-        availableBalance: String? = null  // 可用余额（可选）
+        orderTime: Long? = null  // 订单创建时间（毫秒时间戳），用于通知中的时间显示
     ) {
         // 1. 如果提供了 orderId，检查是否已发送过通知（去重）
         if (orderId != null) {
@@ -132,21 +128,14 @@ class TelegramNotificationService(
             java.util.Locale("zh", "CN")  // 默认简体中文
         }
         
-        // 优先使用平均成交价（实际成交价），其次传入的限价，若未提供则从订单详情获取
-        var actualPrice: String? = avgFilledPrice?.takeIf { it.isNotBlank() } ?: price
+        // 优先使用传入的价格和数量，如果没有提供则尝试从订单详情获取
+        var actualPrice: String? = price
         var actualSize: String? = size
         var actualSide: String = side
         var actualOutcome: String? = outcome
-
-        // 有平均成交价时，已成交数量优先用 filled，用于金额计算
-        val sizeForAmount: String? = if (avgFilledPrice != null && avgFilledPrice.isNotBlank() && filled != null && filled.isNotBlank()) {
-            filled
-        } else {
-            null
-        }
         
-        // 如果价格、数量或市场方向未提供，尝试从订单详情获取
-        if ((actualPrice == null || actualSize == null || actualOutcome == null) && orderId != null && clobApi != null && apiKey != null && apiSecret != null && apiPassphrase != null && walletAddressForApi != null) {
+        // 如果价格或数量未提供，尝试从订单详情获取
+        if ((actualPrice == null || actualSize == null) && orderId != null && clobApi != null && apiKey != null && apiSecret != null && apiPassphrase != null && walletAddressForApi != null) {
             try {
                 val orderResponse = clobApi.getOrder(orderId)
                 if (orderResponse.isSuccessful) {
@@ -158,8 +147,7 @@ class TelegramNotificationService(
                         if (actualSize == null) {
                             actualSize = order.originalSize  // 使用 originalSize 作为订单数量
                         }
-                        // 注意：不覆盖 side，因为传入的 side（BUY/SELL）是正确的
-                        // actualSide = order.side  // 不要使用订单详情中的 side，因为它可能不准确
+                        actualSide = order.side  // 使用订单详情中的 side
                         if (actualOutcome == null) {
                             actualOutcome = order.outcome  // 使用订单详情中的 outcome（市场方向）
                         }
@@ -177,28 +165,19 @@ class TelegramNotificationService(
         
         // 如果仍然没有获取到实际值，使用默认值（这种情况不应该发生，但为了兼容性保留）
         val finalPrice = actualPrice ?: "0"
-        // 有实际成交价时展示数量用 size_matched（filled），否则用订单数量（original_size）
-        val finalSize = if (avgFilledPrice != null && avgFilledPrice.isNotBlank() && filled != null && filled.isNotBlank()) {
-            filled
-        } else {
-            actualSize ?: "0"
-        }
-        // 金额计算：有实际成交价和已成交数量时用二者乘积，否则用展示价格×订单数量
-        val sizeForCalc = sizeForAmount?.takeIf { it.isNotBlank() } ?: finalSize
+        val finalSize = actualSize ?: "0"
         
         // 计算订单金额 = price × size（USDC）
         val amount = try {
             val priceDecimal = finalPrice.toSafeBigDecimal()
-            val sizeDecimal = sizeForCalc.toSafeBigDecimal()
+            val sizeDecimal = finalSize.toSafeBigDecimal()
             priceDecimal.multiply(sizeDecimal).toString()
         } catch (e: Exception) {
             logger.warn("计算订单金额失败: ${e.message}", e)
             null
         }
 
-        val unknownAccount = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", currentLocale).orEmpty().ifEmpty { "未知账户" }
-        val calculateFailed = messageSource.getMessage("notification.order.calculate_failed", null, "计算失败", currentLocale).orEmpty().ifEmpty { "计算失败" }
-        val vars = buildOrderSuccessVariables(
+        val message = buildOrderSuccessMessage(
             orderId = orderId,
             marketTitle = marketTitle,
             marketId = marketId,
@@ -213,12 +192,8 @@ class TelegramNotificationService(
             locale = currentLocale,
             leaderName = leaderName,
             configName = configName,
-            orderTime = orderTime,
-            availableBalance = availableBalance,
-            unknownAccount = unknownAccount,
-            calculateFailed = calculateFailed
+            orderTime = orderTime
         )
-        val message = notificationTemplateService.renderTemplate("ORDER_SUCCESS", vars)
         sendMessage(message)
     }
 
@@ -257,9 +232,7 @@ class TelegramNotificationService(
             null
         }
 
-        val unknownAccount = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", currentLocale).orEmpty().ifEmpty { "未知账户" }
-        val calculateFailed = messageSource.getMessage("notification.order.calculate_failed", null, "计算失败", currentLocale).orEmpty().ifEmpty { "计算失败" }
-        val vars = buildOrderFailureVariables(
+        val message = buildOrderFailureMessage(
             marketTitle = marketTitle,
             marketId = marketId,
             marketSlug = marketSlug,
@@ -271,65 +244,11 @@ class TelegramNotificationService(
             errorMessage = errorMessage,
             accountName = accountName,
             walletAddress = walletAddress,
-            locale = currentLocale,
-            unknownAccount = unknownAccount,
-            calculateFailed = calculateFailed
+            locale = currentLocale
         )
-        val message = notificationTemplateService.renderTemplate("ORDER_FAILED", vars)
         sendMessage(message)
     }
 
-    /**
-     * 构建订单失败通知的变量 Map
-     */
-    private fun buildOrderFailureVariables(
-        marketTitle: String,
-        marketId: String?,
-        marketSlug: String?,
-        side: String,
-        outcome: String?,
-        price: String,
-        size: String,
-        amount: String?,
-        errorMessage: String,
-        accountName: String?,
-        walletAddress: String?,
-        locale: java.util.Locale,
-        unknownAccount: String,
-        calculateFailed: String
-    ): Map<String, String> {
-        val sideDisplay = when (side.uppercase()) {
-            "BUY" -> messageSource.getMessage("notification.order.side.buy", null, "买入", locale).orEmpty().ifEmpty { "买入" }
-            "SELL" -> messageSource.getMessage("notification.order.side.sell", null, "卖出", locale).orEmpty().ifEmpty { "卖出" }
-            else -> side
-        }
-        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
-        val marketLink = when {
-            !marketSlug.isNullOrBlank() -> "https://polymarket.com/event/$marketSlug"
-            !marketId.isNullOrBlank() && marketId.startsWith("0x") -> "https://polymarket.com/condition/$marketId"
-            else -> ""
-        }
-        val amountDisplay = amount?.let { am ->
-            try {
-                val amountDecimal = am.toSafeBigDecimal()
-                (if (amountDecimal.scale() > 4) amountDecimal.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else amountDecimal.stripTrailingZeros()).toPlainString()
-            } catch (e: Exception) { am }
-        } ?: calculateFailed
-        val shortError = if (errorMessage.length > 500) errorMessage.substring(0, 500) + "..." else errorMessage
-        return mapOf(
-            "market_title" to marketTitle.replace("<", "&lt;").replace(">", "&gt;"),
-            "market_link" to marketLink,
-            "side" to sideDisplay,
-            "outcome" to (outcome?.replace("<", "&lt;")?.replace(">", "&gt;") ?: ""),
-            "price" to formatPrice(price),
-            "quantity" to formatQuantity(size),
-            "amount" to amountDisplay,
-            "account_name" to accountInfo,
-            "error_message" to shortError.replace("<", "&lt;").replace(">", "&gt;"),
-            "time" to DateUtils.formatDateTime()
-        )
-    }
-
     /**
      * 发送订单被过滤通知
      * @param locale 语言设置（可选，如果提供则使用，否则使用 LocaleContextHolder 获取）
@@ -366,9 +285,7 @@ class TelegramNotificationService(
             null
         }
 
-        val unknownAccount = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", currentLocale).orEmpty().ifEmpty { "未知账户" }
-        val calculateFailed = messageSource.getMessage("notification.order.calculate_failed", null, "计算失败", currentLocale).orEmpty().ifEmpty { "计算失败" }
-        val vars = buildOrderFilteredVariables(
+        val message = buildOrderFilteredMessage(
             marketTitle = marketTitle,
             marketId = marketId,
             marketSlug = marketSlug,
@@ -381,75 +298,13 @@ class TelegramNotificationService(
             filterType = filterType,
             accountName = accountName,
             walletAddress = walletAddress,
-            locale = currentLocale,
-            unknownAccount = unknownAccount,
-            calculateFailed = calculateFailed
+            locale = currentLocale
         )
-        val message = notificationTemplateService.renderTemplate("ORDER_FILTERED", vars)
         sendMessage(message)
     }
 
-    private fun buildOrderFilteredVariables(
-        marketTitle: String,
-        marketId: String?,
-        marketSlug: String?,
-        side: String,
-        outcome: String?,
-        price: String,
-        size: String,
-        amount: String?,
-        filterReason: String,
-        filterType: String,
-        accountName: String?,
-        walletAddress: String?,
-        locale: java.util.Locale,
-        unknownAccount: String,
-        calculateFailed: String
-    ): Map<String, String> {
-        val sideDisplay = when (side.uppercase()) {
-            "BUY" -> messageSource.getMessage("notification.order.side.buy", null, "买入", locale).orEmpty().ifEmpty { "买入" }
-            "SELL" -> messageSource.getMessage("notification.order.side.sell", null, "卖出", locale).orEmpty().ifEmpty { "卖出" }
-            else -> side
-        }
-        val filterTypeDisplay = when (filterType.uppercase()) {
-            "ORDER_DEPTH" -> messageSource.getMessage("notification.filter.type.order_depth", null, "订单深度不足", locale).orEmpty().ifEmpty { "订单深度不足" }
-            "SPREAD" -> messageSource.getMessage("notification.filter.type.spread", null, "价差过大", locale).orEmpty().ifEmpty { "价差过大" }
-            "ORDERBOOK_DEPTH" -> messageSource.getMessage("notification.filter.type.orderbook_depth", null, "订单簿深度不足", locale).orEmpty().ifEmpty { "订单簿深度不足" }
-            "PRICE_VALIDITY" -> messageSource.getMessage("notification.filter.type.price_validity", null, "价格不合理", locale).orEmpty().ifEmpty { "价格不合理" }
-            "MARKET_STATUS" -> messageSource.getMessage("notification.filter.type.market_status", null, "市场状态不可交易", locale).orEmpty().ifEmpty { "市场状态不可交易" }
-            else -> filterType
-        }
-        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
-        val marketLink = when {
-            !marketSlug.isNullOrBlank() -> "https://polymarket.com/event/$marketSlug"
-            !marketId.isNullOrBlank() && marketId.startsWith("0x") -> "https://polymarket.com/condition/$marketId"
-            else -> ""
-        }
-        val amountDisplay = amount?.let { am ->
-            try {
-                (am.toSafeBigDecimal().let { if (it.scale() > 4) it.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else it.stripTrailingZeros() }.toPlainString())
-            } catch (e: Exception) { am }
-        } ?: calculateFailed
-        return mapOf(
-            "market_title" to marketTitle.replace("<", "&lt;").replace(">", "&gt;"),
-            "market_link" to marketLink,
-            "side" to sideDisplay,
-            "outcome" to (outcome?.replace("<", "&lt;")?.replace(">", "&gt;") ?: ""),
-            "price" to formatPrice(price),
-            "quantity" to formatQuantity(size),
-            "amount" to amountDisplay,
-            "account_name" to accountInfo,
-            "filter_type" to filterTypeDisplay,
-            "filter_reason" to filterReason.replace("<", "&lt;").replace(">", "&gt;"),
-            "time" to DateUtils.formatDateTime()
-        )
-    }
-
     /**
      * 发送加密价差策略下单成功通知（与跟单一致：在收到 WS 订单推送时匹配价差策略订单后调用）
-     * @param price 订单限价
-     * @param avgFilledPrice 平均成交价（可选，有成交时优先展示）
-     * @param filled 已成交数量（可选，与 avgFilledPrice 一起时用于金额计算）
      */
     suspend fun sendCryptoTailOrderSuccessNotification(
         orderId: String?,
@@ -460,8 +315,6 @@ class TelegramNotificationService(
         outcome: String? = null,
         price: String,
         size: String,
-        avgFilledPrice: String? = null,
-        filled: String? = null,
         strategyName: String? = null,
         accountName: String? = null,
         walletAddress: String? = null,
@@ -486,95 +339,33 @@ class TelegramNotificationService(
             logger.warn("获取语言设置失败，使用默认语言: ${e.message}", e)
             java.util.Locale("zh", "CN")
         }
-        val displayPrice = avgFilledPrice?.takeIf { it.isNotBlank() } ?: price
-        val hasAvgFilled = avgFilledPrice != null && avgFilledPrice.isNotBlank() && filled != null && filled.isNotBlank()
-        val sizeForAmount = if (hasAvgFilled) filled else size
-        val quantityDisplay = if (hasAvgFilled) filled else size  // 有实际成交价时展示数量用 size_matched
         val amount = try {
-            val priceDecimal = displayPrice.toSafeBigDecimal()
-            val sizeDecimal = sizeForAmount.toSafeBigDecimal()
+            val priceDecimal = price.toSafeBigDecimal()
+            val sizeDecimal = size.toSafeBigDecimal()
             priceDecimal.multiply(sizeDecimal).toString()
         } catch (e: Exception) {
             logger.warn("计算订单金额失败: ${e.message}", e)
             null
         }
-        val unknown = messageSource.getMessage("common.unknown", null, "未知", currentLocale).orEmpty().ifEmpty { "未知" }
-        val unknownAccount = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", currentLocale).orEmpty().ifEmpty { "未知账户" }
-        val calculateFailed = messageSource.getMessage("notification.order.calculate_failed", null, "计算失败", currentLocale).orEmpty().ifEmpty { "计算失败" }
-        val vars = buildCryptoTailOrderSuccessVariables(
+        val message = buildCryptoTailOrderSuccessMessage(
             orderId = orderId,
             marketTitle = marketTitle,
             marketId = marketId,
             marketSlug = marketSlug,
             side = side,
             outcome = outcome,
-            price = displayPrice,
-            size = quantityDisplay.orEmpty(),
+            price = price,
+            size = size,
             amount = amount,
             strategyName = strategyName,
             accountName = accountName,
             walletAddress = walletAddress,
-            orderTime = orderTime,
-            unknown = unknown,
-            unknownAccount = unknownAccount,
-            calculateFailed = calculateFailed,
-            locale = currentLocale
+            locale = currentLocale,
+            orderTime = orderTime
         )
-        val message = notificationTemplateService.renderTemplate("CRYPTO_TAIL_SUCCESS", vars)
         sendMessage(message)
     }
 
-    private fun buildCryptoTailOrderSuccessVariables(
-        orderId: String?,
-        marketTitle: String,
-        marketId: String?,
-        marketSlug: String?,
-        side: String,
-        outcome: String?,
-        price: String,
-        size: String,
-        amount: String?,
-        strategyName: String?,
-        accountName: String?,
-        walletAddress: String?,
-        orderTime: Long?,
-        unknown: String,
-        unknownAccount: String,
-        calculateFailed: String,
-        locale: java.util.Locale
-    ): Map<String, String> {
-        val sideDisplay = when (side.uppercase()) {
-            "BUY" -> messageSource.getMessage("notification.order.side.buy", null, "买入", locale).orEmpty().ifEmpty { "买入" }
-            "SELL" -> messageSource.getMessage("notification.order.side.sell", null, "卖出", locale).orEmpty().ifEmpty { "卖出" }
-            else -> side
-        }
-        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
-        val time = if (orderTime != null) DateUtils.formatDateTime(orderTime) else DateUtils.formatDateTime()
-        val marketLink = when {
-            !marketSlug.isNullOrBlank() -> "https://polymarket.com/event/$marketSlug"
-            !marketId.isNullOrBlank() && marketId.startsWith("0x") -> "https://polymarket.com/condition/$marketId"
-            else -> ""
-        }
-        val amountDisplay = amount?.let { am ->
-            try {
-                (am.toSafeBigDecimal().let { if (it.scale() > 4) it.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else it.stripTrailingZeros() }.toPlainString())
-            } catch (e: Exception) { am }
-        } ?: calculateFailed
-        return mapOf(
-            "order_id" to (orderId ?: unknown),
-            "market_title" to marketTitle.replace("<", "&lt;").replace(">", "&gt;"),
-            "market_link" to marketLink,
-            "side" to sideDisplay,
-            "outcome" to (outcome?.replace("<", "&lt;")?.replace(">", "&gt;") ?: ""),
-            "price" to formatPrice(price),
-            "quantity" to formatQuantity(size),
-            "amount" to amountDisplay,
-            "account_name" to accountInfo,
-            "strategy_name" to (strategyName?.takeIf { it.isNotBlank() } ?: unknown),
-            "time" to time
-        )
-    }
-
     /**
      * 构建订单被过滤消息
      */
@@ -957,76 +748,6 @@ class TelegramNotificationService(
         }
     }
 
-    /**
-     * 构建订单成功通知的变量 Map（供模板渲染）
-     */
-    private fun buildOrderSuccessVariables(
-        orderId: String?,
-        marketTitle: String,
-        marketId: String?,
-        marketSlug: String?,
-        side: String,
-        outcome: String?,
-        price: String,
-        size: String,
-        amount: String?,
-        accountName: String?,
-        walletAddress: String?,
-        locale: java.util.Locale,
-        leaderName: String?,
-        configName: String?,
-        orderTime: Long?,
-        availableBalance: String?,
-        unknownAccount: String,
-        calculateFailed: String
-    ): Map<String, String> {
-        val sideDisplay = when (side.uppercase()) {
-            "BUY" -> messageSource.getMessage("notification.order.side.buy", null, "买入", locale).orEmpty().ifEmpty { "买入" }
-            "SELL" -> messageSource.getMessage("notification.order.side.sell", null, "卖出", locale).orEmpty().ifEmpty { "卖出" }
-            else -> side
-        }
-        val unknown = messageSource.getMessage("common.unknown", null, "未知", locale).orEmpty().ifEmpty { "未知" }
-        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
-        val time = if (orderTime != null) DateUtils.formatDateTime(orderTime) else DateUtils.formatDateTime()
-        val marketLink = when {
-            !marketSlug.isNullOrBlank() -> "https://polymarket.com/event/$marketSlug"
-            !marketId.isNullOrBlank() && marketId.startsWith("0x") -> "https://polymarket.com/condition/$marketId"
-            else -> ""
-        }
-        val amountDisplay = when {
-            amount != null -> try {
-                val amountDecimal = amount.toSafeBigDecimal()
-                val formatted = if (amountDecimal.scale() > 4) amountDecimal.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else amountDecimal.stripTrailingZeros()
-                formatted.toPlainString()
-            } catch (e: Exception) { amount ?: calculateFailed }
-            else -> calculateFailed
-        }
-        val availableBalanceDisplay = if (!availableBalance.isNullOrBlank()) {
-            try {
-                val balanceDecimal = availableBalance.toSafeBigDecimal()
-                val formatted = if (balanceDecimal.scale() > 4) balanceDecimal.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else balanceDecimal.stripTrailingZeros()
-                formatted.toPlainString()
-            } catch (e: Exception) { availableBalance ?: "" }
-        } else { "" }
-        val escapedMarketTitle = marketTitle.replace("<", "&lt;").replace(">", "&gt;")
-        val escapedOutcome = outcome?.replace("<", "&lt;")?.replace(">", "&gt;") ?: ""
-        return mapOf(
-            "order_id" to (orderId ?: unknown),
-            "market_title" to escapedMarketTitle,
-            "market_link" to marketLink,
-            "side" to sideDisplay,
-            "outcome" to escapedOutcome,
-            "price" to formatPrice(price),
-            "quantity" to formatQuantity(size),
-            "amount" to amountDisplay,
-            "account_name" to accountInfo,
-            "available_balance" to availableBalanceDisplay,
-            "leader_name" to (leaderName ?: ""),
-            "config_name" to (configName ?: ""),
-            "time" to time
-        )
-    }
-
     /**
      * 构建订单成功消息
      */
@@ -1045,8 +766,7 @@ class TelegramNotificationService(
         locale: java.util.Locale,
         leaderName: String? = null,  // Leader 名称（备注）
         configName: String? = null,  // 跟单配置名
-        orderTime: Long? = null,  // 订单创建时间（毫秒时间戳）
-        availableBalance: String? = null  // 可用余额
+        orderTime: Long? = null  // 订单创建时间（毫秒时间戳）
     ): String {
         
         // 获取多语言文本
@@ -1061,7 +781,6 @@ class TelegramNotificationService(
         val amountLabel = messageSource.getMessage("notification.order.amount", null, "金额", locale)
         val accountLabel = messageSource.getMessage("notification.order.account", null, "账户", locale)
         val timeLabel = messageSource.getMessage("notification.order.time", null, "时间", locale)
-        val availableBalanceLabel = messageSource.getMessage("notification.order.available_balance", null, "可用余额", locale)
         val unknown = messageSource.getMessage("common.unknown", null, "未知", locale)
         val unknownAccount: String = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", locale) ?: "未知账户"
         val calculateFailed = messageSource.getMessage("notification.order.calculate_failed", null, "计算失败", locale)
@@ -1160,23 +879,6 @@ class TelegramNotificationService(
         val priceDisplay = formatPrice(price)
         val sizeDisplay = formatQuantity(size)
 
-        // 格式化可用余额
-        val availableBalanceDisplay = if (!availableBalance.isNullOrBlank()) {
-            try {
-                val balanceDecimal = availableBalance.toSafeBigDecimal()
-                val formatted = if (balanceDecimal.scale() > 4) {
-                    balanceDecimal.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros()
-                } else {
-                    balanceDecimal.stripTrailingZeros()
-                }
-                "\n• $availableBalanceLabel: <code>${formatted.toPlainString()}</code> USDC"
-            } catch (e: Exception) {
-                "\n• $availableBalanceLabel: <code>$availableBalance</code> USDC"
-            }
-        } else {
-            ""
-        }
-
         return """$icon <b>$orderCreatedSuccess</b>
 
 📊 <b>$orderInfo：</b>
@@ -1186,7 +888,7 @@ class TelegramNotificationService(
 • $priceLabel: <code>$priceDisplay</code>
 • $quantityLabel: <code>$sizeDisplay</code> shares
 • $amountLabel: <code>$amountDisplay</code> USDC
-• $accountLabel: $escapedAccountInfo$escapedCopyTradingInfo$availableBalanceDisplay
+• $accountLabel: $escapedAccountInfo$escapedCopyTradingInfo
 
 ⏰ $timeLabel: <code>$time</code>"""
     }
@@ -1393,7 +1095,6 @@ class TelegramNotificationService(
     /**
      * 发送仓位赎回通知
      * @param locale 语言设置（可选，如果提供则使用，否则使用 LocaleContextHolder 获取）
-     * @param availableBalance 可用余额（可选）
      */
     suspend fun sendRedeemNotification(
         accountName: String?,
@@ -1401,8 +1102,7 @@ class TelegramNotificationService(
         transactionHash: String,
         totalRedeemedValue: String,
         positions: List<com.wrbug.polymarketbot.dto.RedeemedPositionInfo>,
-        locale: java.util.Locale? = null,
-        availableBalance: String? = null
+        locale: java.util.Locale? = null
     ) {
         // 获取语言设置（优先使用传入的 locale，否则从 LocaleContextHolder 获取）
         val currentLocale = locale ?: try {
@@ -1412,46 +1112,16 @@ class TelegramNotificationService(
             java.util.Locale("zh", "CN")  // 默认简体中文
         }
         
-        val unknownAccount = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", currentLocale) ?: "未知账户"
-        val vars = buildRedeemSuccessVariables(
+        val message = buildRedeemMessage(
             accountName = accountName,
             walletAddress = walletAddress,
             transactionHash = transactionHash,
             totalRedeemedValue = totalRedeemedValue,
-            availableBalance = availableBalance,
-            unknownAccount = unknownAccount
+            positions = positions,
+            locale = currentLocale
         )
-        val message = notificationTemplateService.renderTemplate("REDEEM_SUCCESS", vars)
         sendMessage(message)
     }
-
-    private fun buildRedeemSuccessVariables(
-        accountName: String?,
-        walletAddress: String?,
-        transactionHash: String,
-        totalRedeemedValue: String,
-        availableBalance: String?,
-        unknownAccount: String
-    ): Map<String, String> {
-        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
-        val totalValueDisplay = try {
-            val d = totalRedeemedValue.toSafeBigDecimal()
-            (if (d.scale() > 4) d.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else d.stripTrailingZeros()).toPlainString()
-        } catch (e: Exception) { totalRedeemedValue }
-        val availableBalanceDisplay = availableBalance?.let { ab ->
-            try {
-                val d = ab.toSafeBigDecimal()
-                (if (d.scale() > 4) d.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else d.stripTrailingZeros()).toPlainString()
-            } catch (e: Exception) { ab }
-        } ?: ""
-        return mapOf(
-            "account_name" to accountInfo,
-            "transaction_hash" to transactionHash.replace("<", "&lt;").replace(">", "&gt;"),
-            "total_value" to totalValueDisplay,
-            "available_balance" to availableBalanceDisplay,
-            "time" to DateUtils.formatDateTime()
-        )
-    }
     
     /**
      * 构建仓位赎回消息
@@ -1462,8 +1132,7 @@ class TelegramNotificationService(
         transactionHash: String,
         totalRedeemedValue: String,
         positions: List<com.wrbug.polymarketbot.dto.RedeemedPositionInfo>,
-        locale: java.util.Locale,
-        availableBalance: String? = null
+        locale: java.util.Locale
     ): String {
         // 获取多语言文本
         val redeemSuccess = messageSource.getMessage("notification.redeem.success", null, "仓位赎回成功", locale)
@@ -1476,7 +1145,6 @@ class TelegramNotificationService(
         val quantityLabel = messageSource.getMessage("notification.order.quantity", null, "数量", locale)
         val valueLabel = messageSource.getMessage("notification.order.amount", null, "金额", locale)
         val timeLabel = messageSource.getMessage("notification.order.time", null, "时间", locale)
-        val availableBalanceLabel = messageSource.getMessage("notification.redeem.available_balance", null, "可用余额", locale)
         val unknownAccount: String = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", locale) ?: "未知账户"
         
         // 构建账户信息（格式：账户名(钱包地址)）
@@ -1518,152 +1186,19 @@ class TelegramNotificationService(
             "  • ${position.marketId.substring(0, 8)}... (${position.side}): $quantityDisplay shares = $valueDisplay USDC"
         }
         
-        // 格式化可用余额
-        val availableBalanceDisplay = if (!availableBalance.isNullOrBlank()) {
-            try {
-                val balanceDecimal = availableBalance.toSafeBigDecimal()
-                val formatted = if (balanceDecimal.scale() > 4) {
-                    balanceDecimal.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros()
-                } else {
-                    balanceDecimal.stripTrailingZeros()
-                }
-                "\n• $availableBalanceLabel: <code>${formatted.toPlainString()}</code> USDC"
-            } catch (e: Exception) {
-                "\n• $availableBalanceLabel: <code>$availableBalance</code> USDC"
-            }
-        } else {
-            ""
-        }
-        
         return """💸 <b>$redeemSuccess</b>
 
 📊 <b>$redeemInfo：</b>
 • $accountLabel: $escapedAccountInfo
 • $transactionHashLabel: <code>$escapedTxHash</code>
-• $totalValueLabel: <code>$totalValueDisplay</code> USDC$availableBalanceDisplay
+• $totalValueLabel: <code>$totalValueDisplay</code> USDC
 
 📦 <b>$positionsLabel：</b>
 $positionsText
 
 ⏰ $timeLabel: <code>$time</code>"""
     }
-
-    /**
-     * 发送仓位已结算（无收益）通知
-     * 用于输的仓位，赎回价值为 0 的情况
-     */
-    suspend fun sendRedeemNoReturnNotification(
-        accountName: String?,
-        walletAddress: String?,
-        transactionHash: String,
-        positions: List<com.wrbug.polymarketbot.dto.RedeemedPositionInfo>,
-        locale: java.util.Locale? = null,
-        availableBalance: String? = null
-    ) {
-        val currentLocale = locale ?: try {
-            LocaleContextHolder.getLocale()
-        } catch (e: Exception) {
-            logger.warn("获取语言设置失败，使用默认语言: ${e.message}", e)
-            java.util.Locale("zh", "CN")
-        }
-
-        val unknownAccount = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", currentLocale) ?: "未知账户"
-        val vars = buildRedeemNoReturnVariables(
-            accountName = accountName,
-            walletAddress = walletAddress,
-            transactionHash = transactionHash,
-            availableBalance = availableBalance,
-            unknownAccount = unknownAccount
-        )
-        val message = notificationTemplateService.renderTemplate("REDEEM_NO_RETURN", vars)
-        sendMessage(message)
-    }
-
-    private fun buildRedeemNoReturnVariables(
-        accountName: String?,
-        walletAddress: String?,
-        transactionHash: String,
-        availableBalance: String?,
-        unknownAccount: String
-    ): Map<String, String> {
-        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
-        val availableBalanceDisplay = availableBalance?.let { ab ->
-            try {
-                val d = ab.toSafeBigDecimal()
-                (if (d.scale() > 4) d.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else d.stripTrailingZeros()).toPlainString()
-            } catch (e: Exception) { ab }
-        } ?: ""
-        return mapOf(
-            "account_name" to accountInfo,
-            "transaction_hash" to transactionHash.replace("<", "&lt;").replace(">", "&gt;"),
-            "available_balance" to availableBalanceDisplay,
-            "time" to DateUtils.formatDateTime()
-        )
-    }
-
-    /**
-     * 构建仓位已结算（无收益）消息
-     */
-    private fun buildRedeemNoReturnMessage(
-        accountName: String?,
-        walletAddress: String?,
-        transactionHash: String,
-        positions: List<com.wrbug.polymarketbot.dto.RedeemedPositionInfo>,
-        locale: java.util.Locale,
-        availableBalance: String? = null
-    ): String {
-        val noReturnTitle = messageSource.getMessage("notification.redeem.no_return.title", null, "仓位已结算（无收益）", locale)
-        val noReturnInfo = messageSource.getMessage("notification.redeem.no_return.info", null, "结算信息", locale)
-        val noReturnMessage = messageSource.getMessage("notification.redeem.no_return.message", null, "市场已结算，您的预测未命中，赎回价值为 0。", locale)
-        val accountLabel = messageSource.getMessage("notification.order.account", null, "账户", locale)
-        val transactionHashLabel = messageSource.getMessage("notification.redeem.transaction_hash", null, "交易哈希", locale)
-        val positionsLabel = messageSource.getMessage("notification.redeem.no_return.positions", null, "结算仓位", locale)
-        val timeLabel = messageSource.getMessage("notification.order.time", null, "时间", locale)
-        val availableBalanceLabel = messageSource.getMessage("notification.redeem.available_balance", null, "可用余额", locale)
-        val unknownAccount: String = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", locale) ?: "未知账户"
-
-        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
-        val time = DateUtils.formatDateTime()
-
-        val escapedAccountInfo = accountInfo.replace("<", "&lt;").replace(">", "&gt;")
-        val escapedTxHash = transactionHash.replace("<", "&lt;").replace(">", "&gt;")
-
-        val positionsText = positions.joinToString("\n") { position ->
-            val quantityDisplay = formatQuantity(position.quantity)
-            "  • ${position.marketId.substring(0, 8)}... (${position.side}): $quantityDisplay shares"
-        }
-
-        // 格式化可用余额
-        val availableBalanceDisplay = if (!availableBalance.isNullOrBlank()) {
-            try {
-                val balanceDecimal = availableBalance.toSafeBigDecimal()
-                val formatted = if (balanceDecimal.scale() > 4) {
-                    balanceDecimal.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros()
-                } else {
-                    balanceDecimal.stripTrailingZeros()
-                }
-                "\n• $availableBalanceLabel: <code>${formatted.toPlainString()}</code> USDC"
-            } catch (e: Exception) {
-                "\n• $availableBalanceLabel: <code>$availableBalance</code> USDC"
-            }
-        } else {
-            ""
-        }
-
-        return """📋 <b>$noReturnTitle</b>
-
-📊 <b>$noReturnInfo：</b>
-<i>$noReturnMessage</i>
-
-• $accountLabel: $escapedAccountInfo
-• $transactionHashLabel: <code>$escapedTxHash</code>$availableBalanceDisplay
-
-📦 <b>$positionsLabel：</b>
-$positionsText
-
-⏰ $timeLabel: <code>$time</code>"""
-    }
-
+    
     /**
      * 脱敏显示地址（只显示前6位和后4位）
      */

backend/src/main/resources/db/migration/V39__add_trigger_type_to_crypto_tail_trigger.sql

@@ -1,5 +0,0 @@
--- 添加触发类型字段到加密价差策略触发记录表
--- AUTO: 自动下单触发
--- MANUAL: 手动下单触发
-ALTER TABLE crypto_tail_strategy_trigger 
-ADD COLUMN trigger_type VARCHAR(20) DEFAULT 'AUTO' COMMENT '触发类型：AUTO（自动）或 MANUAL（手动）';

backend/src/main/resources/db/migration/V40__create_notification_templates.sql

@@ -1,97 +0,0 @@
--- 消息模板表
-CREATE TABLE notification_templates (
-    id BIGINT AUTO_INCREMENT PRIMARY KEY,
-    template_type VARCHAR(50) NOT NULL COMMENT '模板类型',
-    template_content TEXT NOT NULL COMMENT '模板内容，支持 {{variable}} 变量',
-    is_default TINYINT(1) DEFAULT 0 COMMENT '是否使用默认模板（0=自定义，1=默认）',
-    created_at BIGINT NOT NULL,
-    updated_at BIGINT NOT NULL,
-    UNIQUE KEY uk_template_type (template_type)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='消息推送模板';
-
--- 插入默认模板
-INSERT INTO notification_templates (template_type, template_content, is_default, created_at, updated_at) VALUES
-('ORDER_SUCCESS', '🚀 <b>订单创建成功</b>
-
-📊 <b>订单信息：</b>
-• 订单ID: <code>{{order_id}}</code>
-• 市场: <a href="{{market_link}}">{{market_title}}</a>
-• 市场方向: <b>{{outcome}}</b>
-• 方向: <b>{{side}}</b>
-• 价格: <code>{{price}}</code>
-• 数量: <code>{{quantity}}</code> shares
-• 金额: <code>{{amount}}</code> USDC
-• 账户: {{account_name}}
-• 可用余额: <code>{{available_balance}}</code> USDC
-
-⏰ 时间: <code>{{time}}</code>', 1, UNIX_TIMESTAMP() * 1000, UNIX_TIMESTAMP() * 1000),
-
-('ORDER_FAILED', '❌ <b>订单创建失败</b>
-
-📊 <b>订单信息：</b>
-• 市场: <a href="{{market_link}}">{{market_title}}</a>
-• 市场方向: <b>{{outcome}}</b>
-• 方向: <b>{{side}}</b>
-• 价格: <code>{{price}}</code>
-• 数量: <code>{{quantity}}</code> shares
-• 金额: <code>{{amount}}</code> USDC
-• 账户: {{account_name}}
-
-⚠️ <b>错误信息：</b>
-<code>{{error_message}}</code>
-
-⏰ 时间: <code>{{time}}</code>', 1, UNIX_TIMESTAMP() * 1000, UNIX_TIMESTAMP() * 1000),
-
-('ORDER_FILTERED', '🚫 <b>订单被过滤</b>
-
-📊 <b>订单信息：</b>
-• 市场: <a href="{{market_link}}">{{market_title}}</a>
-• 市场方向: <b>{{outcome}}</b>
-• 方向: <b>{{side}}</b>
-• 价格: <code>{{price}}</code>
-• 数量: <code>{{quantity}}</code> shares
-• 金额: <code>{{amount}}</code> USDC
-• 账户: {{account_name}}
-
-⚠️ <b>过滤类型：</b> <code>{{filter_type}}</code>
-
-📝 <b>过滤原因：</b>
-<code>{{filter_reason}}</code>
-
-⏰ 时间: <code>{{time}}</code>', 1, UNIX_TIMESTAMP() * 1000, UNIX_TIMESTAMP() * 1000),
-
-('CRYPTO_TAIL_SUCCESS', '🚀 <b>加密价差策略下单成功</b>
-
-📊 <b>订单信息：</b>
-• 订单ID: <code>{{order_id}}</code>
-• 策略: {{strategy_name}}
-• 市场: <a href="{{market_link}}">{{market_title}}</a>
-• 市场方向: <b>{{outcome}}</b>
-• 方向: <b>{{side}}</b>
-• 价格: <code>{{price}}</code>
-• 数量: <code>{{quantity}}</code> shares
-• 金额: <code>{{amount}}</code> USDC
-• 账户: {{account_name}}
-
-⏰ 时间: <code>{{time}}</code>', 1, UNIX_TIMESTAMP() * 1000, UNIX_TIMESTAMP() * 1000),
-
-('REDEEM_SUCCESS', '💸 <b>仓位赎回成功</b>
-
-📊 <b>赎回信息：</b>
-• 账户: {{account_name}}
-• 交易哈希: <code>{{transaction_hash}}</code>
-• 赎回总价值: <code>{{total_value}}</code> USDC
-• 可用余额: <code>{{available_balance}}</code> USDC
-
-⏰ 时间: <code>{{time}}</code>', 1, UNIX_TIMESTAMP() * 1000, UNIX_TIMESTAMP() * 1000),
-
-('REDEEM_NO_RETURN', '📋 <b>仓位已结算（无收益）</b>
-
-📊 <b>结算信息：</b>
-<i>市场已结算，您的预测未命中，赎回价值为 0。</i>
-
-• 账户: {{account_name}}
-• 交易哈希: <code>{{transaction_hash}}</code>
-• 可用余额: <code>{{available_balance}}</code> USDC
-
-⏰ 时间: <code>{{time}}</code>', 1, UNIX_TIMESTAMP() * 1000, UNIX_TIMESTAMP() * 1000);

backend/src/main/resources/i18n/messages_en.properties

@@ -13,18 +13,9 @@ notification.order.quantity=Quantity
 notification.order.amount=Amount
 notification.order.account=Account
 notification.order.time=Time
-notification.order.available_balance=Available Balance
 notification.order.error_info=Error Information
 notification.order.unknown_account=Unknown Account
 notification.order.calculate_failed=Calculation Failed
-notification.order.filtered=Order Filtered
-notification.order.filter_reason=Filter Reason
-notification.order.filter_type=Filter Type
-notification.filter.type.order_depth=Insufficient Order Depth
-notification.filter.type.spread=Spread Too Large
-notification.filter.type.orderbook_depth=Insufficient Orderbook Depth
-notification.filter.type.price_validity=Invalid Price
-notification.filter.type.market_status=Market Not Tradable
 notification.tail.order.success=Crypto spread strategy order success
 notification.tail.strategy=Strategy
 notification.redeem.success=Position Redeemed Successfully
@@ -35,13 +26,6 @@ notification.redeem.position_count=Position Count
 notification.redeem.positions=Redeemed Positions
 notification.redeem.account=Account
 notification.redeem.time=Time
-notification.redeem.available_balance=Available Balance
-
-# Position Settled (No Return)
-notification.redeem.no_return.title=Position Settled (No Return)
-notification.redeem.no_return.info=Settlement Information
-notification.redeem.no_return.message=Market settled. Your prediction was incorrect. Redemption value is 0.
-notification.redeem.no_return.positions=Settled Positions
 
 # Auto Redeem related notifications
 notification.auto_redeem.disabled.title=Auto Redeem Disabled

backend/src/main/resources/i18n/messages_zh_CN.properties

@@ -13,18 +13,9 @@ notification.order.quantity=数量
 notification.order.amount=金额
 notification.order.account=账户
 notification.order.time=时间
-notification.order.available_balance=可用余额
 notification.order.error_info=错误信息
 notification.order.unknown_account=未知账户
 notification.order.calculate_failed=计算失败
-notification.order.filtered=订单被过滤
-notification.order.filter_reason=过滤原因
-notification.order.filter_type=过滤类型
-notification.filter.type.order_depth=订单深度不足
-notification.filter.type.spread=价差过大
-notification.filter.type.orderbook_depth=订单簿深度不足
-notification.filter.type.price_validity=价格不合理
-notification.filter.type.market_status=市场状态不可交易
 notification.tail.order.success=加密价差策略下单成功
 notification.tail.strategy=策略
 notification.redeem.success=仓位赎回成功
@@ -35,13 +26,6 @@ notification.redeem.position_count=仓位数量
 notification.redeem.positions=赎回仓位
 notification.redeem.account=账户
 notification.redeem.time=时间
-notification.redeem.available_balance=可用余额
-
-# 仓位已结算（无收益）
-notification.redeem.no_return.title=仓位已结算（无收益）
-notification.redeem.no_return.info=结算信息
-notification.redeem.no_return.message=市场已结算，您的预测未命中，赎回价值为 0。
-notification.redeem.no_return.positions=结算仓位
 
 # 自动赎回相关通知
 notification.auto_redeem.disabled.title=自动赎回未开启

backend/src/main/resources/i18n/messages_zh_TW.properties

@@ -13,18 +13,9 @@ notification.order.quantity=數量
 notification.order.amount=金額
 notification.order.account=賬戶
 notification.order.time=時間
-notification.order.available_balance=可用餘額
 notification.order.error_info=錯誤信息
 notification.order.unknown_account=未知賬戶
 notification.order.calculate_failed=計算失敗
-notification.order.filtered=訂單被過濾
-notification.order.filter_reason=過濾原因
-notification.order.filter_type=過濾類型
-notification.filter.type.order_depth=訂單深度不足
-notification.filter.type.spread=價差過大
-notification.filter.type.orderbook_depth=訂單簿深度不足
-notification.filter.type.price_validity=價格不合理
-notification.filter.type.market_status=市場狀態不可交易
 notification.tail.order.success=加密價差策略下單成功
 notification.tail.strategy=策略
 notification.redeem.success=倉位贖回成功
@@ -35,13 +26,6 @@ notification.redeem.position_count=倉位數量
 notification.redeem.positions=贖回倉位
 notification.redeem.account=賬戶
 notification.redeem.time=時間
-notification.redeem.available_balance=可用餘額
-
-# 倉位已結算（無收益）
-notification.redeem.no_return.title=倉位已結算（無收益）
-notification.redeem.no_return.info=結算信息
-notification.redeem.no_return.message=市場已結算，您的預測未命中，贖回價值為 0。
-notification.redeem.no_return.positions=結算倉位
 
 # 自動贖回相關通知
 notification.auto_redeem.disabled.title=自動贖回未開啟

create-release.sh

@@ -346,3 +346,4 @@ main() {
 
 # 执行主函数
 main "$@"
+

deploy-interactive-README.md

@@ -1,209 +1,4 @@
-# PolyHermes One-Click Deployment Script / PolyHermes 一键部署脚本使用说明
-
-[English](#english) | [中文](#中文)
-
----
-
-<a name="english"></a>
-## English
-
-## ✨ Core Features
-
-- **Run from any directory** - No need to download source code
-- **Online images only** - Pull official images from Docker Hub
-- **Auto-download config** - Download the latest `docker-compose.prod.yml` from GitHub
-- **Interactive configuration** - User-friendly Q&A style configuration wizard
-- **Auto-generate secrets** - All sensitive configurations will auto-generate secure random values on Enter
-
-## 🚀 Quick Start
-
-### One-Click Installation (Recommended)
-
-**Using curl (Recommended):**
-```bash
-mkdir -p ~/polyhermes && cd ~/polyhermes && curl -fsSL https://raw.githubusercontent.com/WrBug/PolyHermes/main/deploy-interactive.sh -o deploy.sh && chmod +x deploy.sh && ./deploy.sh
-```
-
-**Using wget:**
-```bash
-mkdir -p ~/polyhermes && cd ~/polyhermes && wget -O deploy.sh https://raw.githubusercontent.com/WrBug/PolyHermes/main/deploy-interactive.sh && chmod +x deploy.sh && ./deploy.sh
-```
-
-This command will automatically:
-- 📁 Create a dedicated working directory `~/polyhermes`
-- 📥 Download the deployment script
-- ✅ Check Docker environment
-- ⚙️ Configure all parameters interactively (press Enter for defaults)
-- 🔐 Auto-generate secure random secrets
-- 🚀 Download latest images and deploy
-
-**Or run directly via pipe (without saving file):**
-```bash
-# curl method
-mkdir -p ~/polyhermes && cd ~/polyhermes && curl -fsSL https://raw.githubusercontent.com/WrBug/PolyHermes/main/deploy-interactive.sh | bash
-
-# wget method
-mkdir -p ~/polyhermes && cd ~/polyhermes && wget -qO- https://raw.githubusercontent.com/WrBug/PolyHermes/main/deploy-interactive.sh | bash
-```
-
-### Method 1: Download and Run Script Directly
-
-```bash
-# Download script
-curl -O https://raw.githubusercontent.com/WrBug/PolyHermes/main/deploy-interactive.sh
-
-# Add execute permission
-chmod +x deploy-interactive.sh
-
-# Run
-./deploy-interactive.sh
-```
-
-### Method 2: Run in Project Directory
-
-```bash
-git clone https://github.com/WrBug/PolyHermes.git
-cd PolyHermes
-./deploy-interactive.sh
-```
-
-## 📝 Usage Flow
-
-After running the script, you will be guided through the following steps:
-
-```
-Step 1: Environment Check  → Check Docker/Docker Compose
-Step 2: Configuration       → Interactive input (press Enter for defaults)
-Step 3: Get Deploy Config   → Download docker-compose.prod.yml from GitHub
-Step 4: Generate Env File   → Auto-generate .env
-Step 5: Pull Docker Images  → Pull latest images from Docker Hub
-Step 6: Deploy Services     → Start containers
-Step 7: Health Check        → Verify services are running properly
-```
-
-## ⚡ Simplest Usage
-
-**Press Enter for all configuration items to use default values**, the script will automatically:
-- Use port 80 (application) and 3307 (MySQL)
-- Generate 32-character database password
-- Generate 128-character JWT secret
-- Generate 64-character admin reset key
-- Generate 64-character encryption key
-- Configure reasonable log levels
-
-### Interactive Example
-
-The script will prompt you for configuration one by one, **press Enter to skip and use default values**:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  Step 2: Configuration
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-💡 All configurations are optional, press Enter to use default or auto-generated values
-
-⚠ Secret config: Press Enter to auto-generate secure random secrets
-⚠ Other config: Press Enter to use default values in parentheses
-
-【Basic Configuration】
-Will configure: Server port, MySQL port, Timezone
-➤ Server port [Default: 80]: ⏎
-➤ MySQL port (external access) [Default: 3307]: ⏎
-➤ Timezone [Default: Asia/Shanghai]: ⏎
-
-【Database Configuration】
-Will configure: Database username, Database password
-➤ Database username [Default: root]: ⏎
-➤ Database password [Enter to auto-generate]: ⏎
-[✓] Database password auto-generated (32 characters)
-
-【Security Configuration】
-Will configure: JWT secret, Admin password reset key, Data encryption key
-➤ JWT secret [Enter to auto-generate]: ⏎
-[✓] JWT secret auto-generated (128 characters)
-➤ Admin password reset key [Enter to auto-generate]: ⏎
-[✓] Admin reset key auto-generated (64 characters)
-➤ Encryption key (for API Key encryption) [Enter to auto-generate]: ⏎
-[✓] Encryption key auto-generated (64 characters)
-
-【Log Configuration】
-Will configure: Root log level, Application log level
-Available levels: TRACE, DEBUG, INFO, WARN, ERROR, OFF
-➤ Root log level (third-party libs) [Default: WARN]: ⏎
-➤ Application log level [Default: INFO]: ⏎
-
-【Other Configuration】
-Will configure: Runtime environment, Auto-update policy, GitHub repo
-➤ Spring Profile [Default: prod]: ⏎
-➤ Allow prerelease updates (true/false) [Default: false]: ⏎
-➤ GitHub repository [Default: WrBug/PolyHermes]: ⏎
-```
-
-## 🔧 Files Generated by Script
-
-After running, the script will generate in the current directory:
-
-1. **docker-compose.prod.yml** - Docker Compose config downloaded from GitHub (always latest)
-2. **.env** - Environment variables file auto-generated based on your configuration
-
-These two files contain all the configuration needed to run PolyHermes.
-
-## 🌐 Post-Deployment Management
-
-### Quick Update (Recommended)
-
-If you already have configuration files, running the script again will detect and ask:
-
-```bash
-./deploy-interactive.sh
-```
-
-```
-【Existing Configuration Detected】
-Found existing .env configuration file
-
-Use existing configuration to update images directly? [Y/n]: ⏎
-```
-
-- **Press Enter or input Y**: Use existing config, pull latest images and update
-- **Input N**: Reconfigure (existing config will be backed up)
-
-### Manual Management Commands
-
-```bash
-# View service status
-docker compose -f docker-compose.prod.yml ps
-
-# View logs
-docker compose -f docker-compose.prod.yml logs -f
-
-# Restart services
-docker compose -f docker-compose.prod.yml restart
-
-# Stop services
-docker compose -f docker-compose.prod.yml down
-
-# Update to latest version
-docker pull wrbug/polyhermes:latest
-docker compose -f docker-compose.prod.yml up -d
-```
-
-## 🔐 Security Recommendations
-
-- **Protect .env file**: Contains sensitive information, never commit to version control
-- **Backup database regularly**: Data is stored in Docker volume `mysql-data`
-- **Configure HTTPS for production**: Recommend using Nginx or Caddy as reverse proxy
-
-## 📞 Support
-
-- [GitHub Repository](https://github.com/WrBug/PolyHermes)
-- [Issue Feedback](https://github.com/WrBug/PolyHermes/issues)
-- [Full Deployment Documentation](docs/zh/DEPLOYMENT_GUIDE.md)
-
----
-
-<a name="中文"></a>
-## 中文
+# PolyHermes 一键部署脚本使用说明
 
 ## ✨ 核心特性
 

deploy-interactive.sh

@@ -1,19 +1,18 @@
 #!/bin/bash
 
 # ========================================
-# PolyHermes Interactive Deploy Script
 # PolyHermes 交互式一键部署脚本
 # ========================================
-# Features / 功能：
-# - Interactive env config / 交互式配置环境变量
-# - Auto-generate secrets / 自动生成安全密钥
-# - Deploy via Docker Hub images / 使用 Docker Hub 线上镜像部署
-# - Config check and rollback / 支持配置预检和回滚
+# 功能：
+# - 交互式配置环境变量
+# - 自动生成安全密钥
+# - 使用 Docker Hub 线上镜像部署
+# - 支持配置预检和回滚
 # ========================================
 
 set -e
 
-# Colors / 颜色输出
+# 颜色输出
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
@@ -21,14 +20,7 @@ BLUE='\033[0;34m'
 CYAN='\033[0;36m'
 NC='\033[0m' # No Color
 
-# Language: LANG=zh* → prompts in Chinese only; else show "中文 / English"
-# 语言：LANG 为 zh* 时仅中文，否则显示「中文 / English」
-USE_ZH_ONLY=false
-case "${LANG:-}" in
-    zh*) USE_ZH_ONLY=true ;;
-esac
-
-# Print functions / 打印函数
+# 打印函数
 info() {
     echo -e "${GREEN}[✓]${NC} $1"
 }
@@ -45,17 +37,6 @@ title() {
     echo -e "${CYAN}${1}${NC}"
 }
 
-# Bilingual: 中文 / English (or Chinese only when LANG=zh*)
-bilingual() {
-    local zh="$1"
-    local en="$2"
-    if [ "$USE_ZH_ONLY" = true ]; then
-        echo "$zh"
-    else
-        echo "$zh / $en"
-    fi
-}
-
 # 生成随机密钥
 generate_secret() {
     local length=${1:-32}
@@ -66,57 +47,54 @@ generate_secret() {
     fi
 }
 
-# 生成随机端口号（10000-60000之间）/ Generate random port (10000-60000)
+# 生成随机端口号（10000-60000之间）
 generate_random_port() {
     echo $((10000 + RANDOM % 50001))
 }
 
-# 读取用户输入（支持默认值）/ Read user input (with default)
+# 读取用户输入（支持默认值）
 read_input() {
     local prompt="$1"
     local default="$2"
     local is_secret="$3"
     local value=""
     
+    # 构建提示信息（不使用颜色，因为 read -p 可能不支持）
     local prompt_text=""
     if [ -n "$default" ]; then
         if [ "$is_secret" = "secret" ]; then
-            if [ "$USE_ZH_ONLY" = true ]; then
-                prompt_text="${prompt} [回车自动生成]: "
-            else
-                prompt_text="${prompt} [Enter to auto-generate]: "
-            fi
+            prompt_text="${prompt} [回车自动生成]: "
         else
-            if [ "$USE_ZH_ONLY" = true ]; then
-                prompt_text="${prompt} [默认: ${default}]: "
-            else
-                prompt_text="${prompt} [Default: ${default}]: "
-            fi
+            prompt_text="${prompt} [默认: ${default}]: "
         fi
     else
         prompt_text="${prompt}: "
     fi
     
+    # 使用 read -p 确保提示正确显示
     read -r -p "$prompt_text" value
     
+    # 如果用户没有输入，使用默认值
     if [ -z "$value" ]; then
         if [ "$is_secret" = "secret" ] && [ -z "$default" ]; then
+            # 自动生成密钥
             case "$prompt" in
-                *JWT*|*jwt*)
+                *JWT*)
                     value=$(generate_secret 64)
-                    info "$(bilingual "已自动生成 JWT 密钥（128字符）" "JWT secret auto-generated (128 chars)")" >&2
+                    # 输出到 stderr，避免被捕获到返回值中
+                    info "已自动生成 JWT 密钥（128字符）" >&2
                     ;;
-                *管理员*|*ADMIN*|*admin*|*reset*|*Reset*)
+                *管理员*|*ADMIN*)
                     value=$(generate_secret 32)
-                    info "$(bilingual "已自动生成管理员重置密钥（64字符）" "Admin reset key auto-generated (64 chars)")" >&2
+                    info "已自动生成管理员重置密钥（64字符）" >&2
                     ;;
-                *加密*|*CRYPTO*|*crypto*|*Encryption*)
+                *加密*|*CRYPTO*)
                     value=$(generate_secret 32)
-                    info "$(bilingual "已自动生成加密密钥（64字符）" "Encryption key auto-generated (64 chars)")" >&2
+                    info "已自动生成加密密钥（64字符）" >&2
                     ;;
-                *数据库密码*|*DB_PASSWORD*|*database*|*Database*)
+                *数据库密码*|*DB_PASSWORD*)
                     value=$(generate_secret 16)
-                    info "$(bilingual "已自动生成数据库密码（32字符）" "Database password auto-generated (32 chars)")" >&2
+                    info "已自动生成数据库密码（32字符）" >&2
                     ;;
                 *)
                     value="$default"
@@ -130,115 +108,126 @@ read_input() {
     echo "$value"
 }
 
-# 检查 Docker 环境 / Check Docker environment
+# 检查 Docker 环境
 check_docker() {
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  $(bilingual "步骤 1: 环境检查" "Step 1: Environment Check")"
+    title "  步骤 1: 环境检查"
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     
+    # 检查 Docker
     if ! command -v docker &> /dev/null; then
-        error "$(bilingual "Docker 未安装" "Docker is not installed")"
+        error "Docker 未安装"
         echo ""
-        info "$(bilingual "请先安装 Docker：" "Please install Docker first:")"
+        info "请先安装 Docker："
         info "  macOS: brew install docker"
         info "  Ubuntu/Debian: apt-get install docker.io"
         info "  CentOS/RHEL: yum install docker"
         exit 1
     fi
-    info "$(bilingual "Docker 已安装" "Docker installed"): $(docker --version | head -1)"
+    info "Docker 已安装: $(docker --version | head -1)"
     
+    # 检查 Docker Compose
     if docker compose version &> /dev/null 2>&1; then
-        info "$(bilingual "Docker Compose 已安装" "Docker Compose installed"): $(docker compose version)"
+        info "Docker Compose 已安装: $(docker compose version)"
     elif command -v docker-compose &> /dev/null; then
-        info "$(bilingual "Docker Compose 已安装" "Docker Compose installed"): $(docker-compose --version)"
+        info "Docker Compose 已安装: $(docker-compose --version)"
     else
-        error "$(bilingual "Docker Compose 未安装" "Docker Compose is not installed")"
+        error "Docker Compose 未安装"
         echo ""
-        info "$(bilingual "请先安装 Docker Compose：" "Please install Docker Compose:")"
+        info "请先安装 Docker Compose："
         info "  https://docs.docker.com/compose/install/"
         exit 1
     fi
     
+    # 检查 Docker 守护进程
     if ! docker info &> /dev/null; then
-        error "$(bilingual "Docker 守护进程未运行" "Docker daemon is not running")"
-        info "$(bilingual "请启动 Docker 服务：" "Please start Docker:")"
-        info "  $(bilingual "macOS: 打开 Docker Desktop" "macOS: Open Docker Desktop")"
+        error "Docker 守护进程未运行"
+        info "请启动 Docker 服务："
+        info "  macOS: 打开 Docker Desktop"
         info "  Linux: systemctl start docker"
         exit 1
     fi
-    info "$(bilingual "Docker 守护进程运行正常" "Docker daemon is running")"
+    info "Docker 守护进程运行正常"
     
     echo ""
 }
 
-# 交互式配置收集 / Interactive configuration
+# 交互式配置收集
 collect_configuration() {
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  $(bilingual "步骤 2: 配置收集" "Step 2: Configuration")"
+    title "  步骤 2: 配置收集"
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     echo ""
-    info "$(bilingual "💡 所有配置项均为可选，直接按回车即可使用默认值或自动生成" "💡 All options are optional, press Enter for default or auto-generated values")"
+    info "💡 所有配置项均为可选，直接按回车即可使用默认值或自动生成"
     echo ""
-    warn "$(bilingual "密钥配置：回车将自动生成安全的随机密钥" "Secrets: Enter to auto-generate secure random keys")"
-    warn "$(bilingual "其他配置：回车将使用括号中的默认值" "Other: Enter to use default value in brackets")"
+    warn "密钥配置：回车将自动生成安全的随机密钥"
+    warn "其他配置：回车将使用括号中的默认值"
     echo ""
     
-    title "$(bilingual "【基础配置】" "【Basic】")"
-    echo -e "${CYAN}$(bilingual "将配置：服务器端口、MySQL端口、时区" "Server port, MySQL port, Timezone")${NC}"
+    # 基础配置
+    title "【基础配置】"
+    echo -e "${CYAN}将配置：服务器端口、MySQL端口、时区${NC}"
+    # 生成随机端口作为默认值
     DEFAULT_PORT=$(generate_random_port)
-    SERVER_PORT=$(read_input "$(bilingual "➤ 服务器端口" "➤ Server port")" "$DEFAULT_PORT")
-    MYSQL_PORT=$(read_input "$(bilingual "➤ MySQL 端口（外部访问）" "➤ MySQL port (external)")" "3307")
-    TZ=$(read_input "$(bilingual "➤ 时区" "➤ Timezone")" "Asia/Shanghai")
+    SERVER_PORT=$(read_input "➤ 服务器端口" "$DEFAULT_PORT")
+    MYSQL_PORT=$(read_input "➤ MySQL 端口（外部访问）" "3307")
+    TZ=$(read_input "➤ 时区" "Asia/Shanghai")
     echo ""
     
-    title "$(bilingual "【数据库配置】" "【Database】")"
-    echo -e "${CYAN}$(bilingual "将配置：数据库用户名、数据库密码" "Database username, password")${NC}"
-    echo -e "${YELLOW}$(bilingual "💡 提示：密码留空将自动生成 32 字符的安全随机密码" "💡 Leave password empty to auto-generate 32-char password")${NC}"
-    DB_USERNAME=$(read_input "$(bilingual "➤ 数据库用户名" "➤ Database username")" "root")
-    DB_PASSWORD=$(read_input "$(bilingual "➤ 数据库密码" "➤ Database password")" "" "secret")
+    # 数据库配置
+    title "【数据库配置】"
+    echo -e "${CYAN}将配置：数据库用户名、数据库密码${NC}"
+    echo -e "${YELLOW}💡 提示：密码留空将自动生成 32 字符的安全随机密码${NC}"
+    DB_USERNAME=$(read_input "➤ 数据库用户名" "root")
+    DB_PASSWORD=$(read_input "➤ 数据库密码" "" "secret")
     echo ""
     
-    title "$(bilingual "【安全配置】" "【Security】")"
-    echo -e "${CYAN}$(bilingual "将配置：JWT密钥、管理员密码重置密钥、数据加密密钥" "JWT secret, Admin reset key, Encryption key")${NC}"
-    echo -e "${YELLOW}$(bilingual "💡 提示：留空将自动生成高强度随机密钥（推荐）" "💡 Leave empty to auto-generate strong keys (recommended)")${NC}"
-    JWT_SECRET=$(read_input "$(bilingual "➤ JWT 密钥" "➤ JWT secret")" "" "secret")
-    ADMIN_RESET_PASSWORD_KEY=$(read_input "$(bilingual "➤ 管理员密码重置密钥" "➤ Admin password reset key")" "" "secret")
-    CRYPTO_SECRET_KEY=$(read_input "$(bilingual "➤ 加密密钥（用于加密 API Key）" "➤ Encryption key (for API Key)")" "" "secret")
+    # 安全配置
+    title "【安全配置】"
+    echo -e "${CYAN}将配置：JWT密钥、管理员密码重置密钥、数据加密密钥${NC}"
+    echo -e "${YELLOW}💡 提示：留空将自动生成高强度随机密钥（推荐）${NC}"
+    JWT_SECRET=$(read_input "➤ JWT 密钥" "" "secret")
+    ADMIN_RESET_PASSWORD_KEY=$(read_input "➤ 管理员密码重置密钥" "" "secret")
+    CRYPTO_SECRET_KEY=$(read_input "➤ 加密密钥（用于加密 API Key）" "" "secret")
     echo ""
     
-    title "$(bilingual "【日志配置】" "【Logging】")"
-    echo -e "${CYAN}$(bilingual "将配置：Root日志级别、应用日志级别" "Root log level, App log level")${NC}"
-    echo -e "${YELLOW}$(bilingual "可选级别: TRACE, DEBUG, INFO, WARN, ERROR, OFF" "Levels: TRACE, DEBUG, INFO, WARN, ERROR, OFF")${NC}"
-    LOG_LEVEL_ROOT=$(read_input "$(bilingual "➤ Root 日志级别（第三方库）" "➤ Root log level (3rd party)")" "WARN")
-    LOG_LEVEL_APP=$(read_input "$(bilingual "➤ 应用日志级别" "➤ App log level")" "INFO")
+    # 日志配置
+    title "【日志配置】"
+    echo -e "${CYAN}将配置：Root日志级别、应用日志级别${NC}"
+    echo -e "${YELLOW}可选级别: TRACE, DEBUG, INFO, WARN, ERROR, OFF${NC}"
+    LOG_LEVEL_ROOT=$(read_input "➤ Root 日志级别（第三方库）" "WARN")
+    LOG_LEVEL_APP=$(read_input "➤ 应用日志级别" "INFO")
     echo ""
     
+    # 自动设置不需要用户输入的配置
     SPRING_PROFILES_ACTIVE="prod"
     ALLOW_PRERELEASE="false"
     GITHUB_REPO="WrBug/PolyHermes"
 }
 
-# 下载 docker-compose.prod.yml（如果不存在）/ Download docker-compose.prod.yml if missing
+# 下载 docker-compose.prod.yml（如果不存在）
 download_docker_compose_file() {
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  $(bilingual "步骤 3: 获取部署配置" "Step 3: Get Deploy Config")"
+    title "  步骤 3: 获取部署配置"
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     
     if [ -f "docker-compose.prod.yml" ]; then
-        info "$(bilingual "检测到现有 docker-compose.prod.yml，跳过下载" "Existing docker-compose.prod.yml found, skip download")"
+        info "检测到现有 docker-compose.prod.yml，跳过下载"
         echo ""
         return 0
     fi
     
-    info "$(bilingual "正在从 GitHub 下载 docker-compose.prod.yml..." "Downloading docker-compose.prod.yml from GitHub...")"
+    info "正在从 GitHub 下载 docker-compose.prod.yml..."
     
+    # GitHub raw 文件链接
     local compose_url="https://raw.githubusercontent.com/WrBug/PolyHermes/main/docker-compose.prod.yml"
     
+    # 尝试下载
     if curl -fsSL "$compose_url" -o docker-compose.prod.yml; then
-        info "$(bilingual "docker-compose.prod.yml 下载成功" "docker-compose.prod.yml downloaded")"
+        info "docker-compose.prod.yml 下载成功"
     else
-        error "$(bilingual "docker-compose.prod.yml 下载失败" "Failed to download docker-compose.prod.yml")"
-        warn "$(bilingual "请检查网络连接或手动下载：" "Check network or download manually:")"
+        error "docker-compose.prod.yml 下载失败"
+        warn "请检查网络连接或手动下载："
         warn "  $compose_url"
         exit 1
     fi
@@ -246,26 +235,28 @@ download_docker_compose_file() {
     echo ""
 }
 
-# 生成 .env 文件 / Generate .env file
+# 生成 .env 文件
 generate_env_file() {
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  $(bilingual "步骤 4: 生成环境变量文件" "Step 4: Generate .env")"
+    title "  步骤 4: 生成环境变量文件"
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     
+    # 备份现有 .env 文件
     if [ -f ".env" ]; then
         BACKUP_FILE=".env.backup.$(date +%Y%m%d_%H%M%S)"
         cp .env "$BACKUP_FILE"
-        warn "$(bilingual "已备份现有配置文件到" "Backed up existing config to"): $BACKUP_FILE"
+        warn "已备份现有配置文件到: $BACKUP_FILE"
     fi
     
+    # 生成新的 .env 文件
     cat > .env <<EOF
 # ========================================
-# PolyHermes Production Config / 生产环境配置
-# Generated / 生成时间: $(date '+%Y-%m-%d %H:%M:%S')
+# PolyHermes 生产环境配置
+# 生成时间: $(date '+%Y-%m-%d %H:%M:%S')
 # ========================================
 
 # ============================================
-# Basic / 基础配置
+# 基础配置
 # ============================================
 TZ=${TZ}
 SPRING_PROFILES_ACTIVE=${SPRING_PROFILES_ACTIVE}
@@ -273,107 +264,112 @@ SERVER_PORT=${SERVER_PORT}
 MYSQL_PORT=${MYSQL_PORT}
 
 # ============================================
-# Database / 数据库配置
+# 数据库配置
 # ============================================
 DB_URL=jdbc:mysql://mysql:3306/polyhermes?useSSL=false&serverTimezone=UTC&characterEncoding=utf8&allowPublicKeyRetrieval=true
 DB_USERNAME=${DB_USERNAME}
 DB_PASSWORD=${DB_PASSWORD}
 
 # ============================================
-# Security (keep safe) / 安全配置（请妥善保管）
+# 安全配置（请妥善保管）
 # ============================================
 JWT_SECRET=${JWT_SECRET}
 ADMIN_RESET_PASSWORD_KEY=${ADMIN_RESET_PASSWORD_KEY}
 CRYPTO_SECRET_KEY=${CRYPTO_SECRET_KEY}
 
 # ============================================
-# Logging / 日志配置
+# 日志配置
 # ============================================
 LOG_LEVEL_ROOT=${LOG_LEVEL_ROOT}
 LOG_LEVEL_APP=${LOG_LEVEL_APP}
 
 # ============================================
-# Other / 其他配置
+# 其他配置
 # ============================================
 ALLOW_PRERELEASE=${ALLOW_PRERELEASE}
 GITHUB_REPO=${GITHUB_REPO}
 EOF
     
-    info "$(bilingual "配置文件已生成" "Config file generated"): .env"
+    info "配置文件已生成: .env"
     echo ""
     
-    title "$(bilingual "【配置摘要】" "【Config Summary】")"
-    echo "  $(bilingual "服务器端口" "Server port"): ${SERVER_PORT}"
-    echo "  $(bilingual "MySQL 端口" "MySQL port"): ${MYSQL_PORT}"
-    echo "  $(bilingual "时区" "Timezone"): ${TZ}"
-    echo "  $(bilingual "数据库用户" "DB user"): ${DB_USERNAME}"
-    echo "  $(bilingual "数据库密码" "DB password"): ${DB_PASSWORD:0:8}... $(bilingual "(已隐藏)" "(hidden)")"
-    echo "  $(bilingual "JWT 密钥" "JWT secret"): ${JWT_SECRET:0:16}... $(bilingual "(已隐藏)" "(hidden)")"
-    echo "  $(bilingual "管理员重置密钥" "Admin reset key"): ${ADMIN_RESET_PASSWORD_KEY:0:16}... $(bilingual "(已隐藏)" "(hidden)")"
-    echo "  $(bilingual "加密密钥" "Encryption key"): ${CRYPTO_SECRET_KEY:0:16}... $(bilingual "(已隐藏)" "(hidden)")"
-    echo "  $(bilingual "日志级别" "Log level"): Root=${LOG_LEVEL_ROOT}, App=${LOG_LEVEL_APP}"
+    # 显示配置摘要
+    title "【配置摘要】"
+    echo "  服务器端口: ${SERVER_PORT}"
+    echo "  MySQL 端口: ${MYSQL_PORT}"
+    echo "  时区: ${TZ}"
+    echo "  数据库用户: ${DB_USERNAME}"
+    echo "  数据库密码: ${DB_PASSWORD:0:8}... (已隐藏)"
+    echo "  JWT 密钥: ${JWT_SECRET:0:16}... (已隐藏)"
+    echo "  管理员重置密钥: ${ADMIN_RESET_PASSWORD_KEY:0:16}... (已隐藏)"
+    echo "  加密密钥: ${CRYPTO_SECRET_KEY:0:16}... (已隐藏)"
+    echo "  日志级别: Root=${LOG_LEVEL_ROOT}, App=${LOG_LEVEL_APP}"
     echo ""
 }
 
-# 拉取镜像 / Pull images
+# 拉取镜像
 pull_images() {
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  $(bilingual "步骤 5: 拉取 Docker 镜像" "Step 5: Pull Docker Images")"
+    title "  步骤 5: 拉取 Docker 镜像"
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     
-    info "$(bilingual "正在从 Docker Hub 拉取最新镜像..." "Pulling latest images from Docker Hub...")"
+    info "正在从 Docker Hub 拉取最新镜像..."
     
+    # 拉取应用镜像
     if docker pull wrbug/polyhermes:latest; then
-        info "$(bilingual "应用镜像拉取成功" "App image pulled"): wrbug/polyhermes:latest"
+        info "应用镜像拉取成功: wrbug/polyhermes:latest"
     else
-        error "$(bilingual "应用镜像拉取失败" "Failed to pull app image")"
-        warn "$(bilingual "可能的原因：" "Possible reasons:")"
-        warn "  1. $(bilingual "网络连接问题" "Network issue")"
-        warn "  2. $(bilingual "Docker Hub 服务异常" "Docker Hub unavailable")"
-        warn "  3. $(bilingual "镜像不存在" "Image not found")"
+        error "应用镜像拉取失败"
+        warn "可能的原因："
+        warn "  1. 网络连接问题"
+        warn "  2. Docker Hub 服务异常"
+        warn "  3. 镜像不存在"
         exit 1
     fi
     
+    # 拉取 MySQL 镜像
     if docker pull mysql:8.2; then
-        info "$(bilingual "MySQL 镜像拉取成功" "MySQL image pulled"): mysql:8.2"
+        info "MySQL 镜像拉取成功: mysql:8.2"
     else
-        warn "$(bilingual "MySQL 镜像拉取失败，将在启动时自动下载" "MySQL pull failed, will download on start")"
+        warn "MySQL 镜像拉取失败，将在启动时自动下载"
     fi
     
     echo ""
 }
 
-# 部署服务 / Deploy services
+# 部署服务
 deploy_services() {
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  $(bilingual "步骤 6: 部署服务" "Step 6: Deploy Services")"
+    title "  步骤 6: 部署服务"
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     
+    # 停止现有服务
     if docker compose -f docker-compose.prod.yml ps -q 2>/dev/null | grep -q .; then
-        warn "$(bilingual "检测到正在运行的服务，正在停止..." "Stopping existing services...")"
+        warn "检测到正在运行的服务，正在停止..."
         docker compose -f docker-compose.prod.yml down
-        info "$(bilingual "已停止现有服务" "Stopped existing services")"
+        info "已停止现有服务"
     fi
     
-    info "$(bilingual "正在启动服务..." "Starting services...")"
+    # 启动服务
+    info "正在启动服务..."
     if docker compose -f docker-compose.prod.yml up -d; then
-        info "$(bilingual "服务启动成功" "Services started")"
+        info "服务启动成功"
     else
-        error "$(bilingual "服务启动失败" "Failed to start services")"
-        error "$(bilingual "请检查日志" "Check logs"): docker compose -f docker-compose.prod.yml logs"
+        error "服务启动失败"
+        error "请检查日志: docker compose -f docker-compose.prod.yml logs"
         exit 1
     fi
     
     echo ""
 }
 
-# 健康检查 / Health check
+# 健康检查
 health_check() {
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  $(bilingual "步骤 7: 健康检查" "Step 7: Health Check")"
+    title "  步骤 7: 健康检查"
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     
-    info "$(bilingual "等待服务启动（最多等待 60 秒）..." "Waiting for services (up to 60s)...")"
+    info "等待服务启动（最多等待 60 秒）..."
     
     local max_attempts=12
     local attempt=0
@@ -381,11 +377,13 @@ health_check() {
     while [ $attempt -lt $max_attempts ]; do
         attempt=$((attempt + 1))
         
+        # 检查容器状态
         if docker compose -f docker-compose.prod.yml ps | grep -q "Up"; then
-            info "$(bilingual "容器运行正常" "Containers are up")"
+            info "容器运行正常"
             
+            # 检查应用是否响应
             if curl -s -o /dev/null -w "%{http_code}" http://localhost:${SERVER_PORT} | grep -q "200\|302\|401"; then
-                info "$(bilingual "应用响应正常" "App is responding")"
+                info "应用响应正常"
                 echo ""
                 return 0
             fi
@@ -396,76 +394,79 @@ health_check() {
     done
     
     echo ""
-    warn "$(bilingual "健康检查超时，请手动检查服务状态" "Health check timeout, please check services manually")"
-    warn "$(bilingual "查看日志" "View logs"): docker compose -f docker-compose.prod.yml logs -f"
+    warn "健康检查超时，请手动检查服务状态"
+    warn "查看日志: docker compose -f docker-compose.prod.yml logs -f"
     echo ""
 }
 
-# 显示部署信息 / Show deployment info
+# 显示部署信息
 show_deployment_info() {
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  $(bilingual "部署完成！" "Deployment Complete!")"
+    title "  部署完成！"
     title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     echo ""
     
-    info "$(bilingual "访问地址" "Access URL"): ${GREEN}http://localhost:${SERVER_PORT}${NC}"
+    info "访问地址: ${GREEN}http://localhost:${SERVER_PORT}${NC}"
     echo ""
     
-    title "$(bilingual "【常用命令】" "【Common Commands】")"
-    echo -e "  $(bilingual "查看服务状态" "Status"): ${CYAN}docker compose -f docker-compose.prod.yml ps${NC}"
-    echo -e "  $(bilingual "查看日志" "Logs"): ${CYAN}docker compose -f docker-compose.prod.yml logs -f${NC}"
-    echo -e "  $(bilingual "停止服务" "Stop"): ${CYAN}docker compose -f docker-compose.prod.yml down${NC}"
-    echo -e "  $(bilingual "重启服务" "Restart"): ${CYAN}docker compose -f docker-compose.prod.yml restart${NC}"
-    echo -e "  $(bilingual "更新镜像" "Update"): ${CYAN}docker pull wrbug/polyhermes:latest && docker compose -f docker-compose.prod.yml up -d${NC}"
+    title "【常用命令】"
+    echo -e "  查看服务状态: ${CYAN}docker compose -f docker-compose.prod.yml ps${NC}"
+    echo -e "  查看日志: ${CYAN}docker compose -f docker-compose.prod.yml logs -f${NC}"
+    echo -e "  停止服务: ${CYAN}docker compose -f docker-compose.prod.yml down${NC}"
+    echo -e "  重启服务: ${CYAN}docker compose -f docker-compose.prod.yml restart${NC}"
+    echo -e "  更新镜像: ${CYAN}docker pull wrbug/polyhermes:latest && docker compose -f docker-compose.prod.yml up -d${NC}"
     echo ""
     
-    title "$(bilingual "【数据库连接信息】" "【Database Connection】")"
-    echo -e "  $(bilingual "主机" "Host"): ${CYAN}localhost${NC}"
-    echo -e "  $(bilingual "端口" "Port"): ${CYAN}${MYSQL_PORT}${NC}"
-    echo -e "  $(bilingual "数据库" "Database"): ${CYAN}polyhermes${NC}"
-    echo -e "  $(bilingual "用户名" "Username"): ${CYAN}${DB_USERNAME}${NC}"
-    echo -e "  $(bilingual "密码" "Password"): ${CYAN}${DB_PASSWORD}${NC}"
+    title "【数据库连接信息】"
+    echo -e "  主机: ${CYAN}localhost${NC}"
+    echo -e "  端口: ${CYAN}${MYSQL_PORT}${NC}"
+    echo -e "  数据库: ${CYAN}polyhermes${NC}"
+    echo -e "  用户名: ${CYAN}${DB_USERNAME}${NC}"
+    echo -e "  密码: ${CYAN}${DB_PASSWORD}${NC}"
     echo ""
     
-    title "$(bilingual "【管理员重置密钥】" "【Admin Reset Key】")"
-    echo -e "  $(bilingual "重置密钥" "Reset key"): ${CYAN}${ADMIN_RESET_PASSWORD_KEY}${NC}"
-    echo -e "  ${YELLOW}$(bilingual "💡 此密钥用于重置管理员密码，请妥善保管" "💡 Keep this key safe; it is used to reset admin password")${NC}"
+    title "【管理员重置密钥】"
+    echo -e "  重置密钥: ${CYAN}${ADMIN_RESET_PASSWORD_KEY}${NC}"
+    echo -e "  ${YELLOW}💡 此密钥用于重置管理员密码，请妥善保管${NC}"
     echo ""
     
-    warn "$(bilingual "重要提示：" "Important:")"
-    warn "  1. $(bilingual "请妥善保管 .env 文件，勿提交到版本控制系统" "Keep .env secure; do not commit to version control")"
-    warn "  2. $(bilingual "定期备份数据库数据（位于 Docker volume: polyhermes_mysql-data）" "Back up DB regularly (Docker volume: polyhermes_mysql-data)")"
-    warn "  3. $(bilingual "生产环境建议配置反向代理（如 Nginx）并启用 HTTPS" "Use a reverse proxy (e.g. Nginx) and HTTPS in production")"
+    warn "重要提示："
+    warn "  1. 请妥善保管 .env 文件，勿提交到版本控制系统"
+    warn "  2. 定期备份数据库数据（位于 Docker volume: polyhermes_mysql-data）"
+    warn "  3. 生产环境建议配置反向代理（如 Nginx）并启用 HTTPS"
     echo ""
 }
 
-# 主函数 / Main
+# 主函数
 main() {
     clear
     
     echo ""
     title "========================================="
-    title "   $(bilingual "PolyHermes 交互式一键部署脚本" "PolyHermes Interactive Deploy")   "
+    title "   PolyHermes 交互式一键部署脚本   "
     title "========================================="
     echo ""
     
+    # 执行部署流程
     check_docker
     
+    # 检查是否已存在 .env 文件
     if [ -f ".env" ]; then
         echo ""
-        title "$(bilingual "【检测到现有配置】" "【Existing Config Found】")"
-        info "$(bilingual "发现已存在的 .env 配置文件" "Found existing .env file")"
+        title "【检测到现有配置】"
+        info "发现已存在的 .env 配置文件"
         echo ""
-        echo -ne "${YELLOW}$(bilingual "是否使用现有配置直接更新镜像？[Y/n]" "Use existing config to update images? [Y/n]"): ${NC}"
+        echo -ne "${YELLOW}是否使用现有配置直接更新镜像？[Y/n]: ${NC}"
         read -r use_existing
         use_existing=${use_existing:-Y}
         
         if [[ "$use_existing" =~ ^[Yy]$ ]]; then
-            info "$(bilingual "将使用现有配置，跳过配置步骤" "Using existing config, skipping configuration")"
+            info "将使用现有配置，跳过配置步骤"
             echo ""
+            # 从现有 .env 文件读取必要的变量
             source .env 2>/dev/null || true
         else
-            warn "$(bilingual "将重新配置，现有配置将被备份" "Will reconfigure; existing config will be backed up")"
+            warn "将重新配置，现有配置将被备份"
             echo ""
             collect_configuration
         fi
@@ -475,18 +476,21 @@ main() {
     
     download_docker_compose_file
     
+    # 只有在重新配置时才生成新的 .env 文件
     if [[ ! "$use_existing" =~ ^[Yy]$ ]] || [ ! -f ".env" ]; then
         generate_env_file
     fi
     
+    # 确认部署
     echo ""
-    title "$(bilingual "【确认部署】" "【Confirm Deploy】")"
-    echo -ne "${YELLOW}$(bilingual "是否开始部署？[Y/n]（回车默认为是）" "Start deployment? [Y/n] (Enter = Yes)"): ${NC}"
+    title "【确认部署】"
+    echo -ne "${YELLOW}是否开始部署？[Y/n]（回车默认为是）: ${NC}"
     read -r confirm
     
+    # 默认为 Y，只有明确输入 n/N 才取消
     confirm=${confirm:-Y}
     if [[ "$confirm" =~ ^[Nn]$ ]]; then
-        warn "$(bilingual "部署已取消" "Deployment cancelled")"
+        warn "部署已取消"
         exit 0
     fi
     
@@ -496,11 +500,11 @@ main() {
     health_check
     show_deployment_info
     
-    info "$(bilingual "部署流程已完成！" "Deployment finished!")"
+    info "部署流程已完成！"
 }
 
-# 捕获 Ctrl+C / Handle Ctrl+C
-trap 'echo ""; warn "$(bilingual "部署已中断" "Deployment interrupted")"; exit 1' INT
+# 捕获 Ctrl+C
+trap 'echo ""; warn "部署已中断"; exit 1' INT
 
-# 运行主函数 / Run main
+# 运行主函数
 main "$@"

frontend/src/App.tsx

@@ -29,7 +29,6 @@ import CopyTradingSellOrders from './pages/CopyTradingSellOrders'
 import CopyTradingMatchedOrders from './pages/CopyTradingMatchedOrders'
 import FilteredOrdersList from './pages/FilteredOrdersList'
 import SystemSettings from './pages/SystemSettings'
-import NotificationSettingsPage from './pages/NotificationSettingsPage'
 import ApiHealthStatus from './pages/ApiHealthStatus'
 import RpcNodeSettings from './pages/RpcNodeSettings'
 import Announcements from './pages/Announcements'
@@ -117,37 +116,28 @@ function App() {
       }
     }
     
-    // 实际成交价 = original_size*price/size_matched；有成交时数量用 size_matched
-    const size = orderDetail ? orderDetail.size : order.original_size
-    const filled = orderDetail ? orderDetail.filled : order.size_matched
-    const sizeNum = parseFloat(size).toFixed(2)
-    const filledNum = parseFloat(filled).toFixed(2)
-    const hasFilled = parseFloat(filled) > 0
-    const price = orderDetail
-      ? (orderDetail.avgFilledPrice ?? orderDetail.price)
-      : (hasFilled
-          ? (parseFloat(order.original_size) * parseFloat(order.price) / parseFloat(order.size_matched)).toString()
-          : order.price)
-    const priceStr = parseFloat(price).toFixed(4)
+    // 优先使用订单详情中的数据，如果没有则使用 WebSocket 消息中的数据
+    const price = orderDetail ? parseFloat(orderDetail.price).toFixed(4) : parseFloat(order.price).toFixed(4)
+    const size = orderDetail ? parseFloat(orderDetail.size).toFixed(2) : parseFloat(order.original_size).toFixed(2)
+    const filled = orderDetail ? parseFloat(orderDetail.filled).toFixed(2) : parseFloat(order.size_matched).toFixed(2)
     const status = orderDetail?.status || 'UNKNOWN'
-    // 有成交时展示数量用 size_matched（filled），否则用 original_size
-    const displaySize = (orderDetail?.avgFilledPrice || (orderDetail == null && hasFilled)) ? filledNum : sizeNum
-
+    
     // 构建描述信息
-    let description = `${t('order.market')}: ${marketName}\n${sideText} ${displaySize} @ ${priceStr}`
+    let description = `${t('order.market')}: ${marketName}\n${sideText} ${size} @ ${price}`
     
     // 如果有订单详情，显示更详细的信息
     if (orderDetail) {
       description += `\n${t('order.status')}: ${status}`
-      if (parseFloat(filledNum) > 0) {
-        description += ` | ${t('order.filled')}: ${filledNum}`
+      if (parseFloat(filled) > 0) {
+        description += ` | ${t('order.filled')}: ${filled}`
       }
-      const remaining = (parseFloat(sizeNum) - parseFloat(filledNum)).toFixed(2)
+      const remaining = (parseFloat(size) - parseFloat(filled)).toFixed(2)
       if (parseFloat(remaining) > 0) {
         description += ` | ${t('order.remaining')}: ${remaining}`
       }
     } else if (order.type === 'UPDATE' && parseFloat(order.size_matched) > 0) {
-      description += `\n${t('order.filled')}: ${filledNum}`
+      // 如果没有订单详情，使用 WebSocket 消息中的已成交数量
+      description += `\n${t('order.filled')}: ${filled}`
     }
     
     // 根据订单类型选择通知类型
@@ -278,7 +268,6 @@ function App() {
           <Route path="/users" element={<ProtectedRoute><UserList /></ProtectedRoute>} />
           <Route path="/announcements" element={<ProtectedRoute><Announcements /></ProtectedRoute>} />
           <Route path="/system-settings" element={<ProtectedRoute><SystemSettings /></ProtectedRoute>} />
-          <Route path="/system-settings/notification" element={<ProtectedRoute><NotificationSettingsPage /></ProtectedRoute>} />
           <Route path="/system-settings/rpc-nodes" element={<ProtectedRoute><RpcNodeSettings /></ProtectedRoute>} />          <Route path="/system-settings/api-health" element={<ProtectedRoute><ApiHealthStatus /></ProtectedRoute>} />
           
           {/* 默认重定向到登录页 */}

frontend/src/components/Layout.tsx

@@ -207,11 +207,6 @@ const Layout: React.FC<LayoutProps> = ({ children }) => {
           icon: <SettingOutlined />,
           label: t('menu.systemOverview') || '通用设置'
         },
-        {
-          key: '/system-settings/notification',
-          icon: <NotificationOutlined />,
-          label: t('menu.notifications') || '消息推送设置'
-        },
         {
           key: '/system-settings/rpc-nodes',
           icon: <ApiOutlined />,

frontend/src/locales/en/common.json

@@ -42,8 +42,7 @@
     "pageOf": "Page",
     "ascending": "Ascending",
     "descending": "Descending",
-    "day": "day",
-    "orders": "orders"
+    "day": "day"
   },
   "account": {
     "title": "Account Management",
@@ -177,8 +176,7 @@
     "updateFailed": "Failed to update account",
     "getDetailFailedForEdit": "Failed to get account detail",
     "loading": "Loading...",
-    "fetchFailed": "Failed to get account list",
-    "noData": "No account data"
+    "fetchFailed": "Failed to get account list"
   },
   "accountImport": {
     "title": "Import Account",
@@ -662,8 +660,7 @@
     "deleteSuccess": "User deleted successfully",
     "deleteFailed": "Failed to delete user",
     "deleteConfirm": "Are you sure you want to delete this user?",
-    "total": "Total {{total}} items",
-    "noData": "No user data"
+    "total": "Total {{total}} items"
   },
   "statistics": {
     "title": "Statistics",
@@ -1124,9 +1121,7 @@
     "updateStatusFailed": "Failed to update copy trading status",
     "deleteSuccess": "Copy trading deleted successfully",
     "deleteFailed": "Failed to delete copy trading",
-    "deleteConfirm": "Are you sure you want to delete this copy trading relationship?",
-    "profitRate": "Profit Rate",
-    "noData": "No copy trading configuration"
+    "deleteConfirm": "Are you sure you want to delete this copy trading relationship?"
   },
   "notificationSettings": {
     "title": "Notification Settings",
@@ -1167,95 +1162,7 @@
     "getChatIdsFailed": "Failed to get Chat IDs",
     "getChatIdsNoToken": "Please enter Bot Token first",
     "getChatIdsNoMessage": "Chat ID not found, please send a message to the bot first (e.g., /start), then retry",
-    "getChatIdsButton": "Get Chat ID",
-    "botConfig": "Bot Configuration",
-    "templateConfig": "Template Configuration",
-    "templates": {
-      "title": "Message Template Configuration",
-      "templateType": "Template Type",
-      "templateContent": "Template Content",
-      "isDefault": "Default Template",
-      "isCustom": "Custom Template",
-      "resetToDefault": "Reset to Default",
-      "resetConfirm": "Are you sure you want to reset to default? Your custom content will be lost.",
-      "resetSuccess": "Reset successfully",
-      "resetFailed": "Reset failed",
-      "saveSuccess": "Saved successfully",
-      "saveFailed": "Save failed",
-      "testSuccess": "Test message sent successfully, please check Telegram",
-      "testFailed": "Failed to send test message",
-      "variables": "Available Variables",
-      "clickToCopy": "Click to copy",
-      "copied": "Copied",
-      "commonVariables": "Common Variables",
-      "orderVariables": "Order Variables",
-      "copyTradingVariables": "Copy Trading Variables",
-      "redeemVariables": "Redeem Variables",
-      "errorVariables": "Error Variables",
-      "filterVariables": "Filter Variables",
-      "strategyVariables": "Strategy Variables",
-      "contentPlaceholder": "Enter template content here, use {{variable}} to insert dynamic content",
-      "variableLabels": {
-        "account_name": "Account Name",
-        "wallet_address": "Wallet Address",
-        "time": "Time",
-        "order_id": "Order ID",
-        "market_title": "Market Title",
-        "market_link": "Market Link",
-        "side": "Side",
-        "outcome": "Outcome",
-        "price": "Price",
-        "quantity": "Quantity",
-        "amount": "Amount",
-        "available_balance": "Available Balance",
-        "leader_name": "Leader Name",
-        "config_name": "Copy Trading Config Name",
-        "error_message": "Error Message",
-        "filter_type": "Filter Type",
-        "filter_reason": "Filter Reason",
-        "strategy_name": "Strategy Name",
-        "transaction_hash": "Transaction Hash",
-        "total_value": "Total Redeem Value"
-      },
-      "variableDescriptions": {
-        "account_name": "Account name executing the order",
-        "wallet_address": "Wallet address (masked)",
-        "time": "Notification send time",
-        "order_id": "Unique order identifier",
-        "market_title": "Market/Event name",
-        "market_link": "Polymarket market link",
-        "side": "Order direction (Buy/Sell)",
-        "outcome": "Market outcome (YES/NO, etc.)",
-        "price": "Order price",
-        "quantity": "Order quantity (shares)",
-        "amount": "Order amount (USDC)",
-        "available_balance": "Account available balance (USDC)",
-        "leader_name": "Leader name/alias being copied",
-        "config_name": "Copy trading configuration name",
-        "error_message": "Order failure reason",
-        "filter_type": "Type of order filter",
-        "filter_reason": "Detailed reason for order filtering",
-        "strategy_name": "Crypto spread strategy name",
-        "transaction_hash": "Redeem transaction hash",
-        "total_value": "Total redeem value (USDC)"
-      }
-    },
-    "templateTypes": {
-      "ORDER_SUCCESS": "Order Success",
-      "ORDER_FAILED": "Order Failed",
-      "ORDER_FILTERED": "Order Filtered",
-      "CRYPTO_TAIL_SUCCESS": "Crypto Spread Strategy Success",
-      "REDEEM_SUCCESS": "Position Redeem Success",
-      "REDEEM_NO_RETURN": "Position Settled (No Return)"
-    },
-    "templateTypeDescriptions": {
-      "ORDER_SUCCESS": "Notification sent when order is successfully created",
-      "ORDER_FAILED": "Notification sent when order creation fails",
-      "ORDER_FILTERED": "Notification sent when order is filtered by risk control",
-      "CRYPTO_TAIL_SUCCESS": "Notification sent when crypto spread strategy order succeeds",
-      "REDEEM_SUCCESS": "Notification sent when position is successfully redeemed",
-      "REDEEM_NO_RETURN": "Notification sent when position is settled with no return"
-    }
+    "getChatIdsButton": "Get Chat ID"
   },
   "telegramConfig": {
     "title": "Telegram Configuration Guide",
@@ -1444,8 +1351,6 @@
     "title": "Backtest",
     "taskName": "Task Name",
     "leader": "Leader",
-    "balance": "Balance (Init→Final)",
-    "profit": "Profit (Amount/Rate)",
     "initialBalance": "Initial Balance",
     "backtestDays": "Backtest Days",
     "status": "Status",
@@ -1494,7 +1399,6 @@
     "createCopyTradingSuccess": "Copy trading config created successfully",
     "noTasks": "No backtest tasks",
     "noTrades": "No trade records",
-    "noData": "No backtest data",
     "fetchTasksFailed": "Failed to fetch task list",
     "fetchTaskDetailFailed": "Failed to fetch task detail",
     "fetchTradesFailed": "Failed to fetch trade records",
@@ -1592,9 +1496,7 @@
       "strategyName": "Strategy Name",
       "account": "Account",
       "market": "Market",
-      "marketAndTime": "Market / Time",
       "timeWindow": "Time Window",
-      "config": "Config",
       "priceRange": "Price Range",
       "amountMode": "Amount Mode",
       "ratio": "Ratio",
@@ -1607,7 +1509,6 @@
       "disable": "Disable",
       "delete": "Delete",
       "viewTriggers": "Orders",
-      "viewPnlCurve": "PnL Curve",
       "deleteConfirm": "Delete this strategy?",
       "fetchFailed": "Failed to fetch list",
       "configGuide": "Configuration Guide"
@@ -1675,20 +1576,6 @@
       "emptySuccess": "No success records",
       "emptyFail": "No failed records",
       "totalCount": "{count} record(s)"
-    },
-    "pnlCurve": {
-      "title": "PnL Curve",
-      "totalPnl": "Total PnL",
-      "settledCount": "Settled",
-      "winRate": "Win Rate",
-      "maxDrawdown": "Max Drawdown",
-      "timeRange": "Time Range",
-      "today": "Today",
-      "last7Days": "Last 7 Days",
-      "last30Days": "Last 30 Days",
-      "all": "All",
-      "customRange": "Custom",
-      "empty": "No settled orders yet, cannot show PnL curve"
     }
   },
   "cryptoTailMonitor": {
@@ -1757,49 +1644,6 @@
       "switchToLatest": "Switch to Latest Period",
       "periodEnded": "Current period has ended",
       "newPeriodAvailable": "New period has started"
-    },
-    "manualOrder": {
-      "title": "Manual Order",
-      "buttonUp": "Buy Up",
-      "buttonDown": "Buy Down",
-      "confirmTitle": "Manual Order Confirmation",
-      "marketTitle": "Market Title",
-      "direction": "Direction",
-      "directionUp": "Up",
-      "directionDown": "Down",
-      "orderPrice": "Order Price",
-      "orderSize": "Order Size",
-      "totalAmount": "Total Amount",
-      "account": "Account",
-      "cancel": "Cancel",
-      "confirm": "Confirm Order",
-      "orderUnit": "USDC",
-      "sizeUnit": "shares",
-      "statusNotOrdered": "Not Ordered",
-      "statusOrdered": "This period has been ordered",
-      "statusOrderedAuto": "This period has been auto-ordered",
-      "statusOrderedManual": "This period has been manually ordered",
-      "errorInsufficientBalance": "Insufficient account balance, available: {balance} USDC",
-      "errorPriceOutOfRange": "Price must be between 0 and 1",
-      "errorMinSize": "Size cannot be less than 1 share",
-      "errorExceedsBalance": "Total amount exceeds available balance",
-      "errorPriceRequired": "Please enter order price",
-      "errorSizeRequired": "Please enter order size",
-      "success": "Manual order successful",
-      "failed": "Manual order failed: {{reason}}",
-      "errorSigning": "Signing failed: {reason}",
-      "errorNetwork": "Network error, please try again later",
-      "priceNotLoaded": "Price data not loaded",
-      "insufficientBalance": "Insufficient balance, available amount less than 1 USDC",
-      "fetchBalanceFailed": "Failed to fetch account balance",
-      "availableBalance": "Available Balance",
-      "fetchLatestPrice": "Latest Price",
-      "priceUpdated": "Price updated",
-      "maxSize": "Max",
-      "invalidPriceOrBalance": "Invalid price or balance",
-      "insufficientBalanceForMax": "Insufficient balance for max size",
-      "maxSizeUpdated": "Updated to max size",
-      "periodChanged": "Period has changed, popup closed"
     }
   }
 }

frontend/src/locales/zh-CN/common.json

@@ -42,8 +42,7 @@
     "copyFailed": "复制失败",
     "ascending": "升序",
     "descending": "降序",
-    "day": "天",
-    "orders": "单"
+    "day": "天"
   },
   "login": {
     "title": "登录",
@@ -177,8 +176,7 @@
     "updateFailed": "更新账户失败",
     "getDetailFailedForEdit": "获取账户详情失败",
     "loading": "加载中...",
-    "fetchFailed": "获取账户列表失败",
-    "noData": "暂无账户数据"
+    "fetchFailed": "获取账户列表失败"
   },
   "accountImport": {
     "title": "导入账户",
@@ -662,8 +660,7 @@
     "deleteSuccess": "删除用户成功",
     "deleteFailed": "删除用户失败",
     "deleteConfirm": "确定要删除这个用户吗？",
-    "total": "共 {{total}} 条",
-    "noData": "暂无用户数据"
+    "total": "共 {{total}} 条"
   },
   "statistics": {
     "title": "统计信息",
@@ -1124,9 +1121,7 @@
     "updateStatusFailed": "更新跟单状态失败",
     "deleteSuccess": "删除跟单成功",
     "deleteFailed": "删除跟单失败",
-    "deleteConfirm": "确定要删除这个跟单关系吗？",
-    "profitRate": "收益率",
-    "noData": "暂无跟单配置"
+    "deleteConfirm": "确定要删除这个跟单关系吗？"
   },
   "notificationSettings": {
     "title": "消息推送设置",
@@ -1167,95 +1162,7 @@
     "getChatIdsFailed": "获取 Chat IDs 失败",
     "getChatIdsNoToken": "请先填写 Bot Token",
     "getChatIdsNoMessage": "未找到 Chat ID，请先向机器人发送一条消息（如 /start），然后重试",
-    "getChatIdsButton": "获取 Chat ID",
-    "botConfig": "机器人配置",
-    "templateConfig": "模板配置",
-    "templates": {
-      "title": "消息模板配置",
-      "templateType": "模板类型",
-      "templateContent": "模板内容",
-      "isDefault": "默认模板",
-      "isCustom": "自定义模板",
-      "resetToDefault": "重置为默认",
-      "resetConfirm": "确定要重置为默认模板吗？您的自定义内容将丢失。",
-      "resetSuccess": "重置成功",
-      "resetFailed": "重置失败",
-      "saveSuccess": "保存成功",
-      "saveFailed": "保存失败",
-      "testSuccess": "测试消息发送成功，请检查 Telegram",
-      "testFailed": "测试消息发送失败",
-      "variables": "可用变量",
-      "clickToCopy": "点击复制",
-      "copied": "已复制",
-      "commonVariables": "通用变量",
-      "orderVariables": "订单变量",
-      "copyTradingVariables": "跟单变量",
-      "redeemVariables": "赎回变量",
-      "errorVariables": "错误变量",
-      "filterVariables": "过滤变量",
-      "strategyVariables": "策略变量",
-      "contentPlaceholder": "在此输入模板内容，使用 {{变量名}} 插入动态内容",
-      "variableLabels": {
-        "account_name": "账户名称",
-        "wallet_address": "钱包地址",
-        "time": "时间",
-        "order_id": "订单ID",
-        "market_title": "市场标题",
-        "market_link": "市场链接",
-        "side": "方向",
-        "outcome": "市场方向",
-        "price": "价格",
-        "quantity": "数量",
-        "amount": "金额",
-        "available_balance": "可用余额",
-        "leader_name": "Leader 名称",
-        "config_name": "跟单配置名",
-        "error_message": "错误信息",
-        "filter_type": "过滤类型",
-        "filter_reason": "过滤原因",
-        "strategy_name": "策略名称",
-        "transaction_hash": "交易哈希",
-        "total_value": "赎回总价值"
-      },
-      "variableDescriptions": {
-        "account_name": "执行订单的账户名称",
-        "wallet_address": "钱包地址（已脱敏）",
-        "time": "通知发送时间",
-        "order_id": "订单唯一标识",
-        "market_title": "市场/事件名称",
-        "market_link": "Polymarket 市场链接",
-        "side": "订单方向（买入/卖出）",
-        "outcome": "市场方向（YES/NO 等）",
-        "price": "订单价格",
-        "quantity": "订单数量（shares）",
-        "amount": "订单金额（USDC）",
-        "available_balance": "账户可用余额（USDC）",
-        "leader_name": "跟单的 Leader 名称/备注",
-        "config_name": "跟单配置名称",
-        "error_message": "订单失败原因",
-        "filter_type": "订单被过滤的类型",
-        "filter_reason": "订单被过滤的详细原因",
-        "strategy_name": "加密价差策略名称",
-        "transaction_hash": "赎回交易的哈希值",
-        "total_value": "赎回的总价值（USDC）"
-      }
-    },
-    "templateTypes": {
-      "ORDER_SUCCESS": "订单成功通知",
-      "ORDER_FAILED": "订单失败通知",
-      "ORDER_FILTERED": "订单过滤通知",
-      "CRYPTO_TAIL_SUCCESS": "加密价差策略成功通知",
-      "REDEEM_SUCCESS": "仓位赎回成功通知",
-      "REDEEM_NO_RETURN": "仓位结算（无收益）通知"
-    },
-    "templateTypeDescriptions": {
-      "ORDER_SUCCESS": "订单创建成功时发送的通知",
-      "ORDER_FAILED": "订单创建失败时发送的通知",
-      "ORDER_FILTERED": "订单被风控过滤时发送的通知",
-      "CRYPTO_TAIL_SUCCESS": "加密价差策略下单成功时发送的通知",
-      "REDEEM_SUCCESS": "仓位赎回成功时发送的通知",
-      "REDEEM_NO_RETURN": "仓位结算但无收益时发送的通知"
-    }
+    "getChatIdsButton": "获取 Chat ID"
   },
   "telegramConfig": {
     "title": "Telegram 配置说明",
@@ -1444,8 +1351,6 @@
     "title": "回测",
     "taskName": "任务名称",
     "leader": "Leader",
-    "balance": "资金 (初始→最终)",
-    "profit": "收益 (金额/比例)",
     "initialBalance": "初始资金",
     "backtestDays": "回测天数",
     "status": "状态",
@@ -1494,7 +1399,6 @@
     "createCopyTradingSuccess": "跟单配置创建成功",
     "noTasks": "暂无回测任务",
     "noTrades": "暂无交易记录",
-    "noData": "暂无回测数据",
     "fetchTasksFailed": "获取任务列表失败",
     "fetchTaskDetailFailed": "获取任务详情失败",
     "fetchTradesFailed": "获取交易记录失败",
@@ -1592,9 +1496,7 @@
       "strategyName": "策略名称",
       "account": "账户",
       "market": "关联市场",
-      "marketAndTime": "市场/时间",
       "timeWindow": "时间区间",
-      "config": "配置",
       "priceRange": "价格区间",
       "amountMode": "投入方式",
       "ratio": "比例",
@@ -1607,7 +1509,6 @@
       "disable": "停用",
       "delete": "删除",
       "viewTriggers": "订单",
-      "viewPnlCurve": "收益曲线",
       "deleteConfirm": "确定删除该策略？",
       "fetchFailed": "获取列表失败",
       "configGuide": "配置指南"
@@ -1675,20 +1576,6 @@
       "emptySuccess": "暂无成功记录",
       "emptyFail": "暂无失败记录",
       "totalCount": "共 {count} 条"
-    },
-    "pnlCurve": {
-      "title": "收益曲线",
-      "totalPnl": "总收益",
-      "settledCount": "已结算笔数",
-      "winRate": "胜率",
-      "maxDrawdown": "最大回撤",
-      "timeRange": "时间范围",
-      "today": "今日",
-      "last7Days": "近7天",
-      "last30Days": "近30天",
-      "all": "全部",
-      "customRange": "自定义",
-      "empty": "暂无已结算订单，无法展示收益曲线"
     }
   },
   "cryptoTailMonitor": {
@@ -1757,49 +1644,6 @@
       "switchToLatest": "切换到最新周期",
       "periodEnded": "当前周期已结束",
       "newPeriodAvailable": "新周期已开始"
-    },
-    "manualOrder": {
-      "title": "手动下单",
-      "buttonUp": "买入 Up",
-      "buttonDown": "买入 Down",
-      "confirmTitle": "手动下单确认",
-      "marketTitle": "市场标题",
-      "direction": "方向",
-      "directionUp": "Up",
-      "directionDown": "Down",
-      "orderPrice": "下单价格",
-      "orderSize": "下单数量",
-      "totalAmount": "总金额",
-      "account": "账户",
-      "cancel": "取消",
-      "confirm": "确认下单",
-      "orderUnit": "USDC",
-      "sizeUnit": "张",
-      "statusNotOrdered": "未下单",
-      "statusOrdered": "本周期已下单",
-      "statusOrderedAuto": "本周期已自动下单",
-      "statusOrderedManual": "本周期已手动下单",
-      "errorInsufficientBalance": "账户余额不足，可用余额：{{balance}} USDC",
-      "errorPriceOutOfRange": "价格必须在 0~1 之间",
-      "errorMinSize": "数量不能少于 1 张",
-      "errorExceedsBalance": "总金额超过可用余额",
-      "errorPriceRequired": "请输入下单价格",
-      "errorSizeRequired": "请输入下单数量",
-      "success": "手动下单成功",
-      "failed": "手动下单失败：{{reason}}",
-      "errorSigning": "签名失败：{{reason}}",
-      "errorNetwork": "网络错误，请稍后重试",
-      "priceNotLoaded": "价格数据未加载",
-      "insufficientBalance": "余额不足，可用金额少于 1 USDC",
-      "fetchBalanceFailed": "获取账户余额失败",
-      "availableBalance": "可用余额",
-      "fetchLatestPrice": "获取最新价",
-      "priceUpdated": "价格已更新",
-      "maxSize": "最大",
-      "invalidPriceOrBalance": "价格或余额无效",
-      "insufficientBalanceForMax": "余额不足以购买最大数量",
-      "maxSizeUpdated": "已更新为最大数量",
-      "periodChanged": "周期已切换，弹窗已关闭"
     }
   }
 }

frontend/src/locales/zh-TW/common.json

@@ -42,8 +42,7 @@
     "pageOf": "第",
     "ascending": "升序",
     "descending": "降序",
-    "day": "天",
-    "orders": "單"
+    "day": "天"
   },
   "account": {
     "title": "賬戶管理",
@@ -177,8 +176,7 @@
     "updateFailed": "更新賬戶失敗",
     "getDetailFailedForEdit": "獲取賬戶詳情失敗",
     "loading": "加載中...",
-    "fetchFailed": "獲取賬戶列表失敗",
-    "noData": "暫無賬戶數據"
+    "fetchFailed": "獲取賬戶列表失敗"
   },
   "accountImport": {
     "title": "導入賬戶",
@@ -662,8 +660,7 @@
     "deleteSuccess": "刪除用戶成功",
     "deleteFailed": "刪除用戶失敗",
     "deleteConfirm": "確定要刪除這個用戶嗎？",
-    "total": "共 {{total}} 條",
-    "noData": "暫無用戶數據"
+    "total": "共 {{total}} 條"
   },
   "statistics": {
     "title": "統計信息",
@@ -1124,9 +1121,7 @@
     "updateStatusFailed": "更新跟單狀態失敗",
     "deleteSuccess": "刪除跟單成功",
     "deleteFailed": "刪除跟單失敗",
-    "deleteConfirm": "確定要刪除這個跟單關係嗎？",
-    "profitRate": "收益率",
-    "noData": "暫無跟單配置"
+    "deleteConfirm": "確定要刪除這個跟單關係嗎？"
   },
   "notificationSettings": {
     "title": "消息推送設置",
@@ -1167,95 +1162,7 @@
     "getChatIdsFailed": "獲取 Chat IDs 失敗",
     "getChatIdsNoToken": "請先填寫 Bot Token",
     "getChatIdsNoMessage": "未找到 Chat ID，請先向機器人發送一條消息（如 /start），然後重試",
-    "getChatIdsButton": "獲取 Chat ID",
-    "botConfig": "機器人配置",
-    "templateConfig": "模板配置",
-    "templates": {
-      "title": "消息模板配置",
-      "templateType": "模板類型",
-      "templateContent": "模板內容",
-      "isDefault": "默認模板",
-      "isCustom": "自定義模板",
-      "resetToDefault": "重置為默認",
-      "resetConfirm": "確定要重置為默認模板嗎？您的自定義內容將丟失。",
-      "resetSuccess": "重置成功",
-      "resetFailed": "重置失敗",
-      "saveSuccess": "保存成功",
-      "saveFailed": "保存失敗",
-      "testSuccess": "測試消息發送成功，請檢查 Telegram",
-      "testFailed": "測試消息發送失敗",
-      "variables": "可用變量",
-      "clickToCopy": "點擊複製",
-      "copied": "已複製",
-      "commonVariables": "通用變量",
-      "orderVariables": "訂單變量",
-      "copyTradingVariables": "跟單變量",
-      "redeemVariables": "贖回變量",
-      "errorVariables": "錯誤變量",
-      "filterVariables": "過濾變量",
-      "strategyVariables": "策略變量",
-      "contentPlaceholder": "在此輸入模板內容，使用 {{變量名}} 插入動態內容",
-      "variableLabels": {
-        "account_name": "賬戶名稱",
-        "wallet_address": "錢包地址",
-        "time": "時間",
-        "order_id": "訂單ID",
-        "market_title": "市場標題",
-        "market_link": "市場鏈接",
-        "side": "方向",
-        "outcome": "市場方向",
-        "price": "價格",
-        "quantity": "數量",
-        "amount": "金額",
-        "available_balance": "可用餘額",
-        "leader_name": "Leader 名稱",
-        "config_name": "跟單配置名",
-        "error_message": "錯誤信息",
-        "filter_type": "過濾類型",
-        "filter_reason": "過濾原因",
-        "strategy_name": "策略名稱",
-        "transaction_hash": "交易哈希",
-        "total_value": "贖回總價值"
-      },
-      "variableDescriptions": {
-        "account_name": "執行訂單的賬戶名稱",
-        "wallet_address": "錢包地址（已脫敏）",
-        "time": "通知發送時間",
-        "order_id": "訂單唯一標識",
-        "market_title": "市場/事件名稱",
-        "market_link": "Polymarket 市場鏈接",
-        "side": "訂單方向（買入/賣出）",
-        "outcome": "市場方向（YES/NO 等）",
-        "price": "訂單價格",
-        "quantity": "訂單數量（shares）",
-        "amount": "訂單金額（USDC）",
-        "available_balance": "賬戶可用餘額（USDC）",
-        "leader_name": "跟單的 Leader 名稱/備註",
-        "config_name": "跟單配置名稱",
-        "error_message": "訂單失敗原因",
-        "filter_type": "訂單被過濾的類型",
-        "filter_reason": "訂單被過濾的詳細原因",
-        "strategy_name": "加密價差策略名稱",
-        "transaction_hash": "贖回交易的哈希值",
-        "total_value": "贖回的總價值（USDC）"
-      }
-    },
-    "templateTypes": {
-      "ORDER_SUCCESS": "訂單成功通知",
-      "ORDER_FAILED": "訂單失敗通知",
-      "ORDER_FILTERED": "訂單過濾通知",
-      "CRYPTO_TAIL_SUCCESS": "加密價差策略成功通知",
-      "REDEEM_SUCCESS": "倉位贖回成功通知",
-      "REDEEM_NO_RETURN": "倉位結算（無收益）通知"
-    },
-    "templateTypeDescriptions": {
-      "ORDER_SUCCESS": "訂單創建成功時發送的通知",
-      "ORDER_FAILED": "訂單創建失敗時發送的通知",
-      "ORDER_FILTERED": "訂單被風控過濾時發送的通知",
-      "CRYPTO_TAIL_SUCCESS": "加密價差策略下單成功時發送的通知",
-      "REDEEM_SUCCESS": "倉位贖回成功時發送的通知",
-      "REDEEM_NO_RETURN": "倉位結算但無收益時發送的通知"
-    }
+    "getChatIdsButton": "獲取 Chat ID"
   },
   "telegramConfig": {
     "title": "Telegram 配置說明",
@@ -1444,8 +1351,6 @@
     "title": "回測",
     "taskName": "任務名稱",
     "leader": "Leader",
-    "balance": "資金 (初始→最終)",
-    "profit": "收益 (金額/比例)",
     "initialBalance": "初始資金",
     "backtestDays": "回測天數",
     "status": "狀態",
@@ -1494,7 +1399,6 @@
     "createCopyTradingSuccess": "跟單配置創建成功",
     "noTasks": "暫無回測任務",
     "noTrades": "暫無交易記錄",
-    "noData": "暫無回測數據",
     "fetchTasksFailed": "獲取任務列表失敗",
     "fetchTaskDetailFailed": "獲取任務詳情失敗",
     "fetchTradesFailed": "獲取交易記錄失敗",
@@ -1592,9 +1496,7 @@
       "strategyName": "策略名稱",
       "account": "賬戶",
       "market": "關聯市場",
-      "marketAndTime": "市場/時間",
       "timeWindow": "時間區間",
-      "config": "配置",
       "priceRange": "價格區間",
       "amountMode": "投入方式",
       "ratio": "比例",
@@ -1607,7 +1509,6 @@
       "disable": "停用",
       "delete": "刪除",
       "viewTriggers": "訂單",
-      "viewPnlCurve": "收益曲線",
       "deleteConfirm": "確定刪除該策略？",
       "fetchFailed": "獲取列表失敗",
       "configGuide": "配置指南"
@@ -1675,20 +1576,6 @@
       "emptySuccess": "暫無成功記錄",
       "emptyFail": "暫無失敗記錄",
       "totalCount": "共 {count} 條"
-    },
-    "pnlCurve": {
-      "title": "收益曲線",
-      "totalPnl": "總收益",
-      "settledCount": "已結算筆數",
-      "winRate": "勝率",
-      "maxDrawdown": "最大回撤",
-      "timeRange": "時間範圍",
-      "today": "今日",
-      "last7Days": "近7天",
-      "last30Days": "近30天",
-      "all": "全部",
-      "customRange": "自定義",
-      "empty": "暫無已結算訂單，無法展示收益曲線"
     }
   },
   "cryptoTailMonitor": {
@@ -1757,49 +1644,6 @@
       "switchToLatest": "切換到最新週期",
       "periodEnded": "當前週期已結束",
       "newPeriodAvailable": "新週期已開始"
-    },
-    "manualOrder": {
-      "title": "手動下單",
-      "buttonUp": "買入 Up",
-      "buttonDown": "買入 Down",
-      "confirmTitle": "手動下單確認",
-      "marketTitle": "市場標題",
-      "direction": "方向",
-      "directionUp": "Up",
-      "directionDown": "Down",
-      "orderPrice": "下單價格",
-      "orderSize": "下單數量",
-      "totalAmount": "總金額",
-      "account": "賬戶",
-      "cancel": "取消",
-      "confirm": "確認下單",
-      "orderUnit": "USDC",
-      "sizeUnit": "張",
-      "statusNotOrdered": "未下單",
-      "statusOrdered": "本週期已下單",
-      "statusOrderedAuto": "本週期已自動下單",
-      "statusOrderedManual": "本週期已手動下單",
-      "errorInsufficientBalance": "賬戶餘額不足，可用餘額：{balance} USDC",
-      "errorPriceOutOfRange": "價格必須在 0~1 之間",
-      "errorMinSize": "數量不能少於 1 張",
-      "errorExceedsBalance": "總金額超過可用餘額",
-      "errorPriceRequired": "請輸入下單價格",
-      "errorSizeRequired": "請輸入下單數量",
-      "success": "手動下單成功",
-      "failed": "手動下單失敗：{{reason}}",
-      "errorSigning": "簽名失敗：{reason}",
-      "errorNetwork": "網絡錯誤，請稍後重試",
-      "priceNotLoaded": "價格數據未加載",
-      "insufficientBalance": "餘額不足，可用金額少於 1 USDC",
-      "fetchBalanceFailed": "獲取賬戶餘額失敗",
-      "availableBalance": "可用餘額",
-      "fetchLatestPrice": "獲取最新價",
-      "priceUpdated": "價格已更新",
-      "maxSize": "最大",
-      "invalidPriceOrBalance": "價格或餘額無效",
-      "insufficientBalanceForMax": "餘額不足以購買最大數量",
-      "maxSizeUpdated": "已更新為最大數量",
-      "periodChanged": "週期已切換，彈窗已關閉"
     }
   }
 }

frontend/src/pages/AccountList.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useState } from 'react'
-import { Card, Table, Button, Space, Tag, Popconfirm, message, Typography, Spin, Modal, Descriptions, Divider, Form, Input, Alert, Tooltip, List, Empty } from 'antd'
-import { PlusOutlined, ReloadOutlined, EditOutlined, CopyOutlined, EyeOutlined, DeleteOutlined, WalletOutlined } from '@ant-design/icons'
+import { Card, Table, Button, Space, Tag, Popconfirm, message, Typography, Spin, Modal, Descriptions, Divider, Form, Input, Alert } from 'antd'
+import { PlusOutlined, ReloadOutlined, EditOutlined, CopyOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import { useAccountStore } from '../store/accountStore'
 import type { Account } from '../types'
@@ -331,49 +331,23 @@ const AccountList: React.FC = () => {
     {
       title: t('accountList.action'),
       key: 'action',
-      width: 140,
       render: (_: any, record: Account) => (
-        <Space size={4}>
-          <Tooltip title={t('accountList.detail')}>
-            <div
-              onClick={() => handleShowDetail(record)}
-              style={{
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-                width: '32px',
-                height: '32px',
-                cursor: 'pointer',
-                borderRadius: '6px',
-                transition: 'background-color 0.2s'
-              }}
-              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
-              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-            >
-              <EyeOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-            </div>
-          </Tooltip>
-
-          <Tooltip title={t('accountList.edit')}>
-            <div
-              onClick={() => handleShowEdit(record)}
-              style={{
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-                width: '32px',
-                height: '32px',
-                cursor: 'pointer',
-                borderRadius: '6px',
-                transition: 'background-color 0.2s'
-              }}
-              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
-              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-            >
-              <EditOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-            </div>
-          </Tooltip>
-
+        <Space size="small">
+          <Button
+            type="link"
+            size="small"
+            onClick={() => handleShowDetail(record)}
+          >
+            {t('accountList.detail')}
+          </Button>
+          <Button
+            type="link"
+            size="small"
+            icon={<EditOutlined />}
+            onClick={() => handleShowEdit(record)}
+          >
+            {t('accountList.edit')}
+          </Button>
           <Popconfirm
             title={t('accountList.deleteConfirm')}
             description={
@@ -386,24 +360,142 @@ const AccountList: React.FC = () => {
             cancelText={t('common.cancel')}
             okButtonProps={{ danger: true }}
           >
-            <Tooltip title={t('accountList.delete')}>
-              <div
-                style={{
-                  display: 'flex',
-                  alignItems: 'center',
-                  justifyContent: 'center',
-                  width: '32px',
-                  height: '32px',
-                  cursor: 'pointer',
-                  borderRadius: '6px',
-                  transition: 'background-color 0.2s'
-                }}
-                onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#fff1f0'}
-                onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-              >
-                <DeleteOutlined style={{ fontSize: '16px', color: '#ff4d4f' }} />
+            <Button type="link" size="small" danger>
+              {t('accountList.delete')}
+            </Button>
+          </Popconfirm>
+        </Space>
+      )
+    }
+  ]
+
+  const mobileColumns = [
+    {
+      title: t('accountList.accountName'),
+      key: 'info',
+      render: (_: any, record: Account) => {
+        return (
+          <div style={{ padding: '8px 0' }}>
+            <div style={{
+              fontWeight: 'bold',
+              marginBottom: '8px',
+              fontSize: '16px'
+            }}>
+              {record.accountName || `${t('accountList.accountName')} ${record.id}`}
+            </div>
+            <div style={{
+              fontSize: '11px',
+              color: '#666',
+              marginBottom: '8px',
+              wordBreak: 'break-all',
+              fontFamily: 'monospace',
+              lineHeight: '1.4'
+            }}>
+              <div style={{ marginBottom: '4px' }}>
+                <strong>{t('accountList.walletAddress')}:</strong> {record.walletAddress ? `${record.walletAddress.slice(0, 6)}...${record.walletAddress.slice(-4)}` : '-'}
+                <Button
+                  type="text"
+                  size="small"
+                  icon={<CopyOutlined />}
+                  onClick={(e) => {
+                    e.stopPropagation()
+                    handleCopy(record.walletAddress)
+                  }}
+                  style={{ marginLeft: '4px', padding: '0 4px' }}
+                />
               </div>
-            </Tooltip>
+              <div style={{ marginBottom: '4px' }}>
+                <strong>{t('accountList.proxyAddress')}:</strong> {record.proxyAddress ? `${record.proxyAddress.slice(0, 6)}...${record.proxyAddress.slice(-4)}` : '-'}
+                <Button
+                  type="text"
+                  size="small"
+                  icon={<CopyOutlined />}
+                  onClick={(e) => {
+                    e.stopPropagation()
+                    handleCopy(record.proxyAddress)
+                  }}
+                  style={{ marginLeft: '4px', padding: '0 4px' }}
+                />
+              </div>
+              {record.walletType && (
+                <div style={{ marginBottom: '4px' }}>
+                  <strong>{t('accountList.walletType')}:</strong>{' '}
+                  <Tag color={record.walletType.toLowerCase() === 'magic' ? 'purple' : 'blue'} style={{ marginLeft: '4px' }}>
+                    {record.walletType.toLowerCase() === 'magic' ? 'Magic' : 'Safe'}
+                  </Tag>
+                </div>
+              )}
+            </div>
+            <div style={{
+              fontSize: '14px',
+              fontWeight: '500',
+              color: '#1890ff'
+            }}>
+              {t('accountList.totalBalance')}: {balanceLoading[record.id] ? (
+                <Spin size="small" style={{ marginLeft: '4px' }} />
+              ) : balanceMap[record.id]?.total && balanceMap[record.id].total !== '-' ? (
+                `${formatUSDC(balanceMap[record.id].total)} USDC`
+              ) : (
+                '-'
+              )}
+            </div>
+            {balanceMap[record.id] && balanceMap[record.id].available !== '-' && (
+              <div style={{
+                fontSize: '12px',
+                color: '#666',
+                marginTop: '4px'
+              }}>
+                {t('accountList.available')}: {formatUSDC(balanceMap[record.id].available)} USDC | {t('accountList.position')}: {formatUSDC(balanceMap[record.id].position)} USDC
+              </div>
+            )}
+          </div>
+        )
+      }
+    },
+    {
+      title: t('accountList.action'),
+      key: 'action',
+      width: 100,
+      render: (_: any, record: Account) => (
+        <Space direction="vertical" size="small" style={{ width: '100%' }}>
+          <Button
+            type="primary"
+            size="small"
+            block
+            onClick={() => handleShowDetail(record)}
+            style={{ minHeight: '32px' }}
+          >
+            {t('accountList.viewDetail')}
+          </Button>
+          <Button
+            size="small"
+            block
+            icon={<EditOutlined />}
+            onClick={() => handleShowEdit(record)}
+            style={{ minHeight: '32px' }}
+          >
+            {t('accountList.edit')}
+          </Button>
+          <Popconfirm
+            title={t('accountList.deleteConfirm')}
+            description={
+              record.apiKeyConfigured
+                ? t('accountList.deleteConfirmDesc')
+                : t('accountList.deleteConfirmDescSimple')
+            }
+            onConfirm={() => handleDelete(record)}
+            okText={t('accountList.deleteConfirmOk')}
+            cancelText={t('common.cancel')}
+            okButtonProps={{ danger: true }}
+          >
+            <Button
+              size="small"
+              block
+              danger
+              style={{ minHeight: '32px' }}
+            >
+              {t('accountList.delete')}
+            </Button>
           </Popconfirm>
         </Space>
       )
@@ -427,15 +519,16 @@ const AccountList: React.FC = () => {
         <Title level={isMobile ? 3 : 2} style={{ margin: 0, fontSize: isMobile ? '18px' : undefined }}>
           {t('accountList.title')}
         </Title>
-        <Tooltip title={t('accountList.importAccount')}>
-          <Button
-            type="primary"
-            icon={<PlusOutlined />}
-            onClick={() => setAccountImportModalVisible(true)}
-            size={isMobile ? 'middle' : 'large'}
-            style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}
-          />
-        </Tooltip>
+        <Button
+          type="primary"
+          icon={<PlusOutlined />}
+          onClick={() => setAccountImportModalVisible(true)}
+          size={isMobile ? 'middle' : 'large'}
+          block={isMobile}
+          style={isMobile ? { minHeight: '44px' } : undefined}
+        >
+          {t('accountList.importAccount')}
+        </Button>
       </div>
 
       <Card style={{
@@ -443,156 +536,21 @@ const AccountList: React.FC = () => {
         borderRadius: isMobile ? '0' : undefined
       }}>
         {isMobile ? (
-          loading ? (
-            <div style={{ textAlign: 'center', padding: '40px' }}>
-              <Spin size="large" />
-            </div>
-          ) : accounts.length === 0 ? (
-            <Empty description={t('accountList.noData')} />
-          ) : (
-            <List
-              dataSource={accounts}
-              renderItem={(account) => {
-                const balance = balanceMap[account.id]
-
-                return (
-                  <Card
-                    key={account.id}
-                    style={{
-                      marginBottom: '10px',
-                      borderRadius: '10px',
-                      boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
-                      border: '1px solid #e8e8e8',
-                      overflow: 'hidden'
-                    }}
-                    bodyStyle={{ padding: '0' }}
-                  >
-                    {/* 头部区域 */}
-                    <div style={{
-                      padding: '10px 12px',
-                      background: 'var(--ant-color-primary, #1677ff)',
-                      color: '#fff'
-                    }}>
-                      <div style={{ fontSize: '15px', fontWeight: '600', marginBottom: '2px', display: 'flex', alignItems: 'center', gap: '6px' }}>
-                        <WalletOutlined style={{ fontSize: '14px' }} />
-                        <span>{account.accountName || `${t('accountList.accountName')} ${account.id}`}</span>
-                      </div>
-                      <div style={{ fontSize: '10px', opacity: '0.85', fontFamily: 'monospace', display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
-                        <span>{account.walletAddress ? `${account.walletAddress.slice(0, 6)}...${account.walletAddress.slice(-4)}` : '-'}</span>
-                        <Button
-                          type="text"
-                          size="small"
-                          icon={<CopyOutlined style={{ fontSize: '12px', color: 'rgba(255,255,255,0.85)' }} />}
-                          onClick={() => handleCopy(account.walletAddress)}
-                          style={{ padding: '0 4px', height: 'auto' }}
-                        />
-                      </div>
-                    </div>
-
-                    {/* 资产区域 */}
-                    <div style={{
-                      padding: '8px 12px',
-                      backgroundColor: '#fafafa',
-                      borderBottom: '1px solid #f0f0f0',
-                      minHeight: '42px',
-                      display: 'flex',
-                      alignItems: 'center'
-                    }}>
-                      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', width: '100%' }}>
-                        <div>
-                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
-                            {t('accountList.totalBalance')}
-                          </div>
-                          <div style={{ fontSize: '14px', fontWeight: '600', color: '#52c41a' }}>
-                            {balance?.total && balance.total !== '-' ? `${formatUSDC(balance.total)} USDC` : '- USDC'}
-                          </div>
-                        </div>
-                        <div style={{ textAlign: 'right' }}>
-                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
-                            {t('accountList.walletType')}
-                          </div>
-                          <div style={{ fontSize: '12px' }}>
-                            {account.walletType ? (
-                              <Tag color={account.walletType.toLowerCase() === 'magic' ? 'purple' : 'blue'} style={{ margin: 0 }}>
-                                {account.walletType.toLowerCase() === 'magic' ? 'Magic' : 'Safe'}
-                              </Tag>
-                            ) : '-'}
-                          </div>
-                        </div>
-                      </div>
-                    </div>
-
-                    {/* 地址信息区域 */}
-                    <div style={{
-                      padding: '8px 12px',
-                      fontSize: '11px',
-                      color: '#8c8c8c',
-                      borderBottom: '1px solid #f0f0f0'
-                    }}>
-                      <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
-                        <span>{t('accountList.proxyAddress')}: {account.proxyAddress ? `${account.proxyAddress.slice(0, 6)}...${account.proxyAddress.slice(-4)}` : '-'}</span>
-                        <Button
-                          type="text"
-                          size="small"
-                          icon={<CopyOutlined style={{ fontSize: '12px' }} />}
-                          onClick={() => handleCopy(account.proxyAddress)}
-                          style={{ padding: '0 4px', height: 'auto' }}
-                        />
-                      </div>
-                    </div>
-
-                    {/* 图标操作栏 */}
-                    <div style={{
-                      padding: '8px 12px',
-                      display: 'flex',
-                      justifyContent: 'space-around',
-                      alignItems: 'center'
-                    }}>
-                      <Tooltip title={t('accountList.detail')}>
-                        <div
-                          onClick={() => handleShowDetail(account)}
-                          style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
-                        >
-                          <EyeOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                          <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('accountList.detail')}</span>
-                        </div>
-                      </Tooltip>
-
-                      <Tooltip title={t('accountList.edit')}>
-                        <div
-                          onClick={() => handleShowEdit(account)}
-                          style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
-                        >
-                          <EditOutlined style={{ fontSize: '18px', color: '#52c41a' }} />
-                          <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('accountList.edit')}</span>
-                        </div>
-                      </Tooltip>
-
-                      <Popconfirm
-                        title={t('accountList.deleteConfirm')}
-                        description={
-                          account.apiKeyConfigured
-                            ? t('accountList.deleteConfirmDesc')
-                            : t('accountList.deleteConfirmDescSimple')
-                        }
-                        onConfirm={() => handleDelete(account)}
-                        okText={t('accountList.deleteConfirmOk')}
-                        cancelText={t('common.cancel')}
-                        okButtonProps={{ danger: true }}
-                      >
-                        <Tooltip title={t('accountList.delete')}>
-                          <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                            <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
-                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('accountList.delete')}</span>
-                          </div>
-                        </Tooltip>
-                      </Popconfirm>
-                    </div>
-                  </Card>
-                )
-              }}
-            />
-          )
+          <Table
+            dataSource={accounts}
+            columns={mobileColumns}
+            rowKey="id"
+            loading={loading}
+            pagination={{
+              pageSize: 10,
+              showSizeChanger: false,
+              simple: true,
+              size: 'small'
+            }}
+            scroll={{ x: 'max-content' }}
+            size="small"
+            style={{ fontSize: '14px' }}
+          />
         ) : (
           <Table
             dataSource={accounts}

frontend/src/pages/BacktestChart.tsx

@@ -10,6 +10,8 @@ interface BacktestChartProps {
   }[]
 }
 
+// Bug #39 Note: This chart currently displays cash balance (balanceAfter), not total equity.
+// A true equity curve (cash + position value) would require an equityAfter field in the trade records.
 const BacktestChart: React.FC<BacktestChartProps> = ({ trades }) => {
   const { t } = useTranslation()
   const chartRef = useRef<HTMLDivElement>(null)

frontend/src/pages/BacktestList.tsx

@@ -1,6 +1,6 @@
 import { useState, useEffect } from 'react'
 import { useSearchParams } from 'react-router-dom'
-import { Table, Card, Button, Select, Tag, Space, Modal, message, Row, Col, Form, Input, InputNumber, Switch, Statistic, Descriptions, List, Empty, Spin, Tooltip, Popconfirm } from 'antd'
+import { Table, Card, Button, Select, Tag, Space, Modal, message, Row, Col, Form, Input, InputNumber, Switch, Statistic, Descriptions } from 'antd'
 import { useTranslation } from 'react-i18next'
 import { PlusOutlined, ReloadOutlined, DeleteOutlined, StopOutlined, EyeOutlined, RedoOutlined, CopyOutlined, SyncOutlined } from '@ant-design/icons'
 import { formatUSDC } from '../utils'
@@ -118,35 +118,49 @@ const BacktestList: React.FC = () => {
   }
 
   // 删除任务
-  const handleDelete = async (id: number) => {
-    try {
-      const response = await backtestService.delete({ id })
-      if (response.data.code === 0) {
-        message.success(t('backtest.deleteSuccess'))
-        fetchTasks()
-      } else {
-        message.error(response.data.msg || t('backtest.deleteFailed'))
+  const handleDelete = (id: number) => {
+    Modal.confirm({
+      title: t('backtest.deleteConfirm'),
+      okText: t('common.confirm'),
+      cancelText: t('common.cancel'),
+      onOk: async () => {
+        try {
+          const response = await backtestService.delete({ id })
+          if (response.data.code === 0) {
+            message.success(t('backtest.deleteSuccess'))
+            fetchTasks()
+          } else {
+            message.error(response.data.msg || t('backtest.deleteFailed'))
+          }
+        } catch (error) {
+          console.error('Failed to delete backtest task:', error)
+          message.error(t('backtest.deleteFailed'))
+        }
       }
-    } catch (error) {
-      console.error('Failed to delete backtest task:', error)
-      message.error(t('backtest.deleteFailed'))
-    }
+    })
   }
 
   // 停止任务
-  const handleStop = async (id: number) => {
-    try {
-      const response = await backtestService.stop({ id })
-      if (response.data.code === 0) {
-        message.success(t('backtest.stopSuccess'))
-        fetchTasks()
-      } else {
-        message.error(response.data.msg || t('backtest.stopFailed'))
+  const handleStop = (id: number) => {
+    Modal.confirm({
+      title: t('backtest.stopConfirm'),
+      okText: t('common.confirm'),
+      cancelText: t('common.cancel'),
+      onOk: async () => {
+        try {
+          const response = await backtestService.stop({ id })
+          if (response.data.code === 0) {
+            message.success(t('backtest.stopSuccess'))
+            fetchTasks()
+          } else {
+            message.error(response.data.msg || t('backtest.stopFailed'))
+          }
+        } catch (error) {
+          console.error('Failed to stop backtest task:', error)
+          message.error(t('backtest.stopFailed'))
+        }
       }
-    } catch (error) {
-      console.error('Failed to stop backtest task:', error)
-      message.error(t('backtest.stopFailed'))
-    }
+    })
   }
 
   // 按配置重新测试（仅已完成任务）
@@ -488,227 +502,168 @@ const BacktestList: React.FC = () => {
       title: t('backtest.taskName'),
       dataIndex: 'taskName',
       key: 'taskName',
-      width: isMobile ? 120 : 140,
-      ellipsis: true
+      width: isMobile ? 120 : 150
     },
     {
       title: t('backtest.leader'),
       dataIndex: 'leaderName',
       key: 'leaderName',
-      width: isMobile ? 100 : 120,
-      ellipsis: true,
+      width: isMobile ? 100 : 150,
       render: (_: any, record: BacktestTaskDto) => record.leaderName || `Leader ${record.leaderId}`
     },
     {
-      title: t('backtest.balance'),
-      key: 'balance',
-      width: 160,
-      render: (_: any, record: BacktestTaskDto) => (
-        <div>
-          <div style={{ fontSize: 12, color: '#8c8c8c' }}>{formatUSDC(record.initialBalance)}</div>
-          <div style={{ fontWeight: 500 }}>{record.finalBalance ? formatUSDC(record.finalBalance) : '-'}</div>
-        </div>
-      )
+      title: t('backtest.initialBalance'),
+      dataIndex: 'initialBalance',
+      key: 'initialBalance',
+      width: 120,
+      render: (value: string) => formatUSDC(value)
     },
     {
-      title: t('backtest.profit'),
-      key: 'profit',
-      width: 140,
-      render: (_: any, record: BacktestTaskDto) => {
-        const profitAmount = record.profitAmount ? parseFloat(record.profitAmount) : null
-        const profitRate = record.profitRate ? parseFloat(record.profitRate) : null
-        const color = profitAmount !== null ? (profitAmount >= 0 ? '#52c41a' : '#ff4d4f') : undefined
-        return (
-          <div>
-            <div style={{ fontWeight: 500, color }}>
-              {profitAmount !== null ? formatUSDC(record.profitAmount) : '-'}
-            </div>
-            <div style={{ fontSize: 12, color }}>
-              {profitRate !== null ? `${record.profitRate}%` : '-'}
-            </div>
-          </div>
-        )
-      }
+      title: t('backtest.finalBalance'),
+      dataIndex: 'finalBalance',
+      key: 'finalBalance',
+      width: 120,
+      render: (value: string | null) => value ? formatUSDC(value) : '-'
+    },
+    {
+      title: t('backtest.profitAmount'),
+      dataIndex: 'profitAmount',
+      key: 'profitAmount',
+      width: 120,
+      render: (value: string | null) => value ? (
+        <span style={{ color: parseFloat(value) >= 0 ? '#52c41a' : '#ff4d4f' }}>
+          {formatUSDC(value)}
+        </span>
+      ) : '-'
+    },
+    {
+      title: t('backtest.profitRate'),
+      dataIndex: 'profitRate',
+      key: 'profitRate',
+      width: 100,
+      render: (value: string | null) => value ? (
+        <span style={{ color: parseFloat(value) >= 0 ? '#52c41a' : '#ff4d4f' }}>
+          {value}%
+        </span>
+      ) : '-'
+    },
+    {
+      title: t('backtest.backtestDays'),
+      dataIndex: 'backtestDays',
+      key: 'backtestDays',
+      width: 100,
+      render: (value: number) => `${value} ${t('common.day')}`
     },
     {
       title: t('backtest.status'),
       dataIndex: 'status',
       key: 'status',
-      width: 130,
-      render: (status: string, record: BacktestTaskDto) => {
-        const isRunning = status === 'RUNNING' || status === 'PENDING'
-        return (
-          <div>
-            <Tag color={getStatusColor(status)}>{getStatusText(status)}</Tag>
-            {isRunning && record.progress !== undefined && (
-              <div style={{ marginTop: 4, fontSize: 11, color: '#8c8c8c' }}>
-                {record.progress}%
-              </div>
-            )}
+      width: 100,
+      render: (status: string) => (
+        <Tag color={getStatusColor(status)}>{getStatusText(status)}</Tag>
+      )
+    },
+    {
+      title: t('backtest.progress'),
+      dataIndex: 'progress',
+      key: 'progress',
+      width: 120,
+      render: (progress: number) => (
+        <div style={{ width: '100%' }}>
+          <div style={{ marginBottom: 4 }}>{progress}%</div>
+          <div style={{ width: '100%', height: 6, backgroundColor: '#f0f0f0', borderRadius: 3 }}>
+            <div
+              style={{
+                width: `${progress}%`,
+                height: '100%',
+                backgroundColor: progress === 100 ? '#52c41a' : '#1890ff',
+                borderRadius: 3,
+                transition: 'width 0.3s ease'
+              }}
+            />
           </div>
-        )
-      }
+        </div>
+      )
     },
     {
       title: t('backtest.totalTrades'),
       dataIndex: 'totalTrades',
       key: 'totalTrades',
-      width: 80,
-      align: 'center' as const
+      width: 100
     },
     {
       title: t('backtest.createdAt'),
       dataIndex: 'createdAt',
       key: 'createdAt',
-      width: isMobile ? 150 : 150,
+      width: isMobile ? 150 : 180,
       render: (timestamp: number) => new Date(timestamp).toLocaleString()
     },
     {
       title: t('common.actions'),
       key: 'actions',
       fixed: isMobile ? false : ('right' as const),
-      width: isMobile ? 100 : 180,
+      width: isMobile ? 100 : 150,
       render: (_: any, record: BacktestTaskDto) => (
-        <Space size={4}>
-          <Tooltip title={t('common.viewDetail')}>
-            <div
-              onClick={() => handleViewDetail(record.id)}
-              style={{
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-                width: '32px',
-                height: '32px',
-                cursor: 'pointer',
-                borderRadius: '6px',
-                transition: 'background-color 0.2s'
-              }}
-              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
-              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-            >
-              <EyeOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-            </div>
-          </Tooltip>
-
+        <Space size="small">
+          <Button
+            type="link"
+            size="small"
+            icon={<EyeOutlined />}
+            onClick={() => handleViewDetail(record.id)}
+          >
+            {t('common.viewDetail')}
+          </Button>
           {record.status === 'COMPLETED' && (
             <>
-              <Tooltip title={t('backtest.rerun')}>
-                <div
-                  onClick={() => handleRerun(record)}
-                  style={{
-                    display: 'flex',
-                    alignItems: 'center',
-                    justifyContent: 'center',
-                    width: '32px',
-                    height: '32px',
-                    cursor: 'pointer',
-                    borderRadius: '6px',
-                    transition: 'background-color 0.2s'
-                  }}
-                  onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
-                  onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-                >
-                  <SyncOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-                </div>
-              </Tooltip>
-              <Tooltip title={t('backtest.createCopyTrading')}>
-                <div
-                  onClick={() => handleCreateCopyTrading(record)}
-                  style={{
-                    display: 'flex',
-                    alignItems: 'center',
-                    justifyContent: 'center',
-                    width: '32px',
-                    height: '32px',
-                    cursor: 'pointer',
-                    borderRadius: '6px',
-                    transition: 'background-color 0.2s'
-                  }}
-                  onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
-                  onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-                >
-                  <CopyOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-                </div>
-              </Tooltip>
+              <Button
+                type="link"
+                size="small"
+                icon={<SyncOutlined />}
+                onClick={() => handleRerun(record)}
+              >
+                {t('backtest.rerun')}
+              </Button>
+              <Button
+                type="link"
+                size="small"
+                icon={<CopyOutlined />}
+                onClick={() => handleCreateCopyTrading(record)}
+              >
+                {t('backtest.createCopyTrading')}
+              </Button>
             </>
           )}
-
           {record.status === 'RUNNING' && (
-            <Popconfirm
-              title={t('backtest.stopConfirm')}
-              onConfirm={() => handleStop(record.id)}
-              okText={t('common.confirm')}
-              cancelText={t('common.cancel')}
+            <Button
+              type="link"
+              size="small"
+              danger
+              icon={<StopOutlined />}
+              onClick={() => handleStop(record.id)}
             >
-              <Tooltip title={t('backtest.stop')}>
-                <div
-                  style={{
-                    display: 'flex',
-                    alignItems: 'center',
-                    justifyContent: 'center',
-                    width: '32px',
-                    height: '32px',
-                    cursor: 'pointer',
-                    borderRadius: '6px',
-                    transition: 'background-color 0.2s'
-                  }}
-                  onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
-                  onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-                >
-                  <StopOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-                </div>
-              </Tooltip>
-            </Popconfirm>
+              {t('backtest.stop')}
+            </Button>
           )}
-
           {(record.status === 'STOPPED' || record.status === 'FAILED') && (
-            <Tooltip title={t('backtest.retry')}>
-              <div
-                onClick={() => handleRetry(record.id)}
-                style={{
-                  display: 'flex',
-                  alignItems: 'center',
-                  justifyContent: 'center',
-                  width: '32px',
-                  height: '32px',
-                  cursor: 'pointer',
-                  borderRadius: '6px',
-                  transition: 'background-color 0.2s'
-                }}
-                onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
-                onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-              >
-                <RedoOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-              </div>
-            </Tooltip>
-          )}
-
-          {(record.status === 'PENDING' || record.status === 'COMPLETED' || record.status === 'STOPPED' || record.status === 'FAILED') && (
-            <Popconfirm
-              title={t('backtest.deleteConfirm')}
-              onConfirm={() => handleDelete(record.id)}
-              okText={t('common.confirm')}
-              cancelText={t('common.cancel')}
+            <Button
+              type="link"
+              size="small"
+              icon={<RedoOutlined />}
+              onClick={() => handleRetry(record.id)}
             >
-              <Tooltip title={t('common.delete')}>
-                <div
-                  style={{
-                    display: 'flex',
-                    alignItems: 'center',
-                    justifyContent: 'center',
-                    width: '32px',
-                    height: '32px',
-                    cursor: 'pointer',
-                    borderRadius: '6px',
-                    transition: 'background-color 0.2s'
-                  }}
-                  onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#fff1f0'}
-                  onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-                >
-                  <DeleteOutlined style={{ fontSize: '16px', color: '#ff4d4f' }} />
-                </div>
-              </Tooltip>
-            </Popconfirm>
+              {t('backtest.retry')}
+            </Button>
+          )}
+          {(record.status === 'PENDING' || record.status === 'COMPLETED' || record.status === 'STOPPED' || record.status === 'FAILED') && (
+            <Button
+              type="link"
+              size="small"
+              danger
+              icon={<DeleteOutlined />}
+              onClick={() => handleDelete(record.id)}
+            >
+              {t('common.delete')}
+            </Button>
           )}
         </Space>
       )
@@ -716,205 +671,94 @@ const BacktestList: React.FC = () => {
   ]
 
   return (
-    <div style={{ padding: isMobile ? 0 : 24 }}>
-      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px', flexWrap: 'wrap', gap: '12px', padding: isMobile ? '0 8px' : 0 }}>
-        <h2 style={{ margin: 0, fontSize: isMobile ? '20px' : '24px' }}>{t('backtest.title')}</h2>
-        <Space size={8}>
-          <Tooltip title={t('backtest.createTask')}>
-            <Button
-              type="primary"
-              icon={<PlusOutlined />}
-              onClick={handleCreate}
-              size={isMobile ? 'middle' : 'large'}
-              style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}
-            />
-          </Tooltip>
-          <Tooltip title={t('common.refresh')}>
-            <Button icon={<ReloadOutlined />} onClick={handleRefresh} loading={loading} size={isMobile ? 'middle' : 'large'} style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px' }} />
-          </Tooltip>
-        </Space>
-      </div>
-
-      <Card style={{ borderRadius: '12px', boxShadow: '0 2px 8px rgba(0,0,0,0.08)', border: '1px solid #e8e8e8' }} bodyStyle={{ padding: isMobile ? '12px' : '24px' }}>
+    <div style={{ padding: 24 }}>
+      <Card>
         <Space direction="vertical" size="large" style={{ width: '100%' }}>
-          {/* 筛选栏 */}
-          <Row gutter={[16, 16]} style={{ marginBottom: isMobile ? 12 : 0 }}>
-            <Col xs={24} sm={12} md={6}>
-              <LeaderSelect
-                style={{ width: '100%' }}
-                placeholder={t('backtest.leader')}
-                allowClear
-                value={leaderIdFilter}
-                onChange={(value) => setLeaderIdFilter(value)}
-                leaders={leaders}
-              />
+          {/* 头部操作栏 */}
+          <Row justify="space-between" align="middle" gutter={[16, 16]}>
+            <Col xs={24} sm={24} md={12} lg={16}>
+              <Space size="middle" direction={isMobile ? 'vertical' : 'horizontal'} style={{ width: isMobile ? '100%' : 'auto' }}>
+                <LeaderSelect
+                  style={{ width: isMobile ? '100%' : 180 }}
+                  placeholder={t('backtest.leader')}
+                  allowClear
+                  value={leaderIdFilter}
+                  onChange={(value) => setLeaderIdFilter(value)}
+                  leaders={leaders}
+                />
+                <Select
+                  style={{ width: isMobile ? '100%' : 150 }}
+                  placeholder={t('backtest.status')}
+                  allowClear
+                  onChange={(value) => setStatusFilter(value)}
+                  value={statusFilter}
+                >
+                  <Select.Option value="PENDING">{t('backtest.statusPending')}</Select.Option>
+                  <Select.Option value="RUNNING">{t('backtest.statusRunning')}</Select.Option>
+                  <Select.Option value="COMPLETED">{t('backtest.statusCompleted')}</Select.Option>
+                  <Select.Option value="STOPPED">{t('backtest.statusStopped')}</Select.Option>
+                  <Select.Option value="FAILED">{t('backtest.statusFailed')}</Select.Option>
+                </Select>
+                <Select
+                  style={{ width: isMobile ? '100%' : 150 }}
+                  placeholder={t('backtest.sortBy')}
+                  onChange={(value) => setSortBy(value)}
+                  value={sortBy}
+                >
+                  <Select.Option value="profitAmount">{t('backtest.profitAmount')}</Select.Option>
+                  <Select.Option value="profitRate">{t('backtest.profitRate')}</Select.Option>
+                  <Select.Option value="createdAt">{t('backtest.createdAt')}</Select.Option>
+                </Select>
+                <Select
+                  style={{ width: isMobile ? '100%' : 120 }}
+                  placeholder={t('backtest.sortOrder')}
+                  onChange={(value) => setSortOrder(value)}
+                  value={sortOrder}
+                >
+                  <Select.Option value="asc">{t('common.ascending')}</Select.Option>
+                  <Select.Option value="desc">{t('common.descending')}</Select.Option>
+                </Select>
+              </Space>
             </Col>
-            <Col xs={24} sm={12} md={6}>
-              <Select
-                style={{ width: '100%' }}
-                placeholder={t('backtest.status')}
-                allowClear
-                onChange={(value) => setStatusFilter(value)}
-                value={statusFilter}
-              >
-                <Select.Option value="PENDING">{t('backtest.statusPending')}</Select.Option>
-                <Select.Option value="RUNNING">{t('backtest.statusRunning')}</Select.Option>
-                <Select.Option value="COMPLETED">{t('backtest.statusCompleted')}</Select.Option>
-                <Select.Option value="STOPPED">{t('backtest.statusStopped')}</Select.Option>
-                <Select.Option value="FAILED">{t('backtest.statusFailed')}</Select.Option>
-              </Select>
-            </Col>
-            <Col xs={24} sm={12} md={6}>
-              <Select style={{ width: '100%' }} placeholder={t('backtest.sortBy')} onChange={(value) => setSortBy(value)} value={sortBy}>
-                <Select.Option value="profitAmount">{t('backtest.profitAmount')}</Select.Option>
-                <Select.Option value="profitRate">{t('backtest.profitRate')}</Select.Option>
-                <Select.Option value="createdAt">{t('backtest.createdAt')}</Select.Option>
-              </Select>
-            </Col>
-            <Col xs={24} sm={12} md={6}>
-              <Select style={{ width: '100%' }} placeholder={t('backtest.sortOrder')} onChange={(value) => setSortOrder(value)} value={sortOrder}>
-                <Select.Option value="asc">{t('common.ascending')}</Select.Option>
-                <Select.Option value="desc">{t('common.descending')}</Select.Option>
-              </Select>
+            <Col xs={24} sm={24} md={12} lg={8} style={{ textAlign: isMobile ? 'left' : 'right' }}>
+              <Space style={{ width: isMobile ? '100%' : 'auto' }}>
+                <Button
+                  type="primary"
+                  icon={<PlusOutlined />}
+                  onClick={handleCreate}
+                  style={{ flex: isMobile ? 1 : undefined }}
+                >
+                  {isMobile ? t('common.create') : t('backtest.createTask')}
+                </Button>
+                <Button
+                  icon={<ReloadOutlined />}
+                  onClick={handleRefresh}
+                  loading={loading}
+                  style={{ flex: isMobile ? 1 : undefined }}
+                >
+                  {t('common.refresh')}
+                </Button>
+              </Space>
             </Col>
           </Row>
 
-          {/* 数据：移动端卡片 / 桌面端表格 */}
-          {isMobile ? (
-            <>
-              {loading ? (
-                <div style={{ textAlign: 'center', padding: '40px' }}>
-                  <Spin size="large" />
-                </div>
-              ) : tasks.length === 0 ? (
-                <Empty description={t('backtest.noData') || t('common.noData')} />
-              ) : (
-                <List
-                  dataSource={tasks}
-                  renderItem={(task) => (
-                    <Card
-                      key={task.id}
-                      style={{
-                        marginBottom: '10px',
-                        borderRadius: '10px',
-                        boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
-                        border: '1px solid #e8e8e8',
-                        overflow: 'hidden'
-                      }}
-                      bodyStyle={{ padding: 0 }}
-                    >
-                      <div style={{
-                        padding: '10px 12px',
-                        background: 'var(--ant-color-primary, #1677ff)',
-                        color: '#fff'
-                      }}>
-                        <div style={{ fontSize: '15px', fontWeight: '600', marginBottom: '2px' }}>{task.taskName}</div>
-                        <div style={{ fontSize: '12px', opacity: '0.9' }}>{task.leaderName || `Leader ${task.leaderId}`}</div>
-                      </div>
-                      <div style={{ padding: '8px 12px', backgroundColor: '#fafafa', borderBottom: '1px solid #f0f0f0', display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
-                        <div>
-                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>{t('backtest.profitAmount')}</div>
-                          {task.profitAmount != null ? (
-                            <div style={{ fontSize: '14px', fontWeight: '600', color: parseFloat(task.profitAmount) >= 0 ? '#52c41a' : '#ff4d4f' }}>{formatUSDC(task.profitAmount)} USDC</div>
-                          ) : (
-                            <div style={{ fontSize: '14px', color: '#8c8c8c' }}>-</div>
-                          )}
-                        </div>
-                        <div style={{ textAlign: 'right' }}>
-                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>{t('backtest.profitRate')}</div>
-                          {task.profitRate != null ? (
-                            <div style={{ fontSize: '14px', fontWeight: '600', color: parseFloat(task.profitRate) >= 0 ? '#52c41a' : '#ff4d4f' }}>{task.profitRate}%</div>
-                          ) : (
-                            <div style={{ fontSize: '14px', color: '#8c8c8c' }}>-</div>
-                          )}
-                        </div>
-                        <div style={{ textAlign: 'right' }}>
-                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>{t('backtest.status')}</div>
-                          <Tag color={getStatusColor(task.status)}>{getStatusText(task.status)}</Tag>
-                        </div>
-                      </div>
-                      <div style={{ padding: '6px 12px', fontSize: '11px', color: '#8c8c8c', borderBottom: '1px solid #f0f0f0' }}>
-                        {t('backtest.initialBalance')}: {formatUSDC(task.initialBalance)} · {t('backtest.backtestDays')}: {task.backtestDays} {t('common.day')} · {t('backtest.progress')}: {task.progress}%
-                      </div>
-                      <div style={{ padding: '8px 12px', display: 'flex', justifyContent: 'space-around', alignItems: 'center', flexWrap: 'wrap', gap: 4 }}>
-                        <Tooltip title={t('common.viewDetail')}>
-                          <div onClick={() => handleViewDetail(task.id)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                            <EyeOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.viewDetail')}</span>
-                          </div>
-                        </Tooltip>
-                        {task.status === 'COMPLETED' && (
-                          <>
-                            <Tooltip title={t('backtest.rerun')}>
-                              <div onClick={() => handleRerun(task)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                                <SyncOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                                <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('backtest.rerun')}</span>
-                              </div>
-                            </Tooltip>
-                            <Tooltip title={t('backtest.createCopyTrading')}>
-                              <div onClick={() => handleCreateCopyTrading(task)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                                <CopyOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                                <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('backtest.createCopyTrading')}</span>
-                              </div>
-                            </Tooltip>
-                          </>
-                        )}
-                        {task.status === 'RUNNING' && (
-                          <Tooltip title={t('backtest.stop')}>
-                            <div onClick={() => handleStop(task.id)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                              <StopOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('backtest.stop')}</span>
-                            </div>
-                          </Tooltip>
-                        )}
-                        {(task.status === 'STOPPED' || task.status === 'FAILED') && (
-                          <Tooltip title={t('backtest.retry')}>
-                            <div onClick={() => handleRetry(task.id)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                              <RedoOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('backtest.retry')}</span>
-                            </div>
-                          </Tooltip>
-                        )}
-                        {(task.status === 'PENDING' || task.status === 'COMPLETED' || task.status === 'STOPPED' || task.status === 'FAILED') && (
-                          <Tooltip title={t('common.delete')}>
-                            <div onClick={() => handleDelete(task.id)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                              <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
-                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.delete')}</span>
-                            </div>
-                          </Tooltip>
-                        )}
-                      </div>
-                    </Card>
-                  )}
-                />
-              )}
-              {/* 移动端分页 */}
-              {!loading && tasks.length > 0 && total > size && (
-                <div style={{ display: 'flex', justifyContent: 'center', marginTop: 16 }}>
-                  <Button size="small" disabled={page <= 1} onClick={() => setPage(p => Math.max(1, p - 1))}>{t('common.prev')}</Button>
-                  <span style={{ margin: '0 12px', lineHeight: '24px' }}>{page} / {Math.ceil(total / size)}</span>
-                  <Button size="small" disabled={page >= Math.ceil(total / size)} onClick={() => setPage(p => p + 1)}>{t('common.next')}</Button>
-                </div>
-              )}
-            </>
-          ) : (
-            <Table
-              columns={columns}
-              dataSource={tasks}
-              rowKey="id"
-              loading={loading}
-              pagination={{
-                current: page,
-                pageSize: size,
-                total,
-                showSizeChanger: false,
-                showTotal: (totalCount) => `${t('common.total')} ${totalCount} ${t('common.items')}`,
-                onChange: (newPage) => setPage(newPage),
-                simple: isMobile
-              }}
-              scroll={{ x: 1000 }}
-            />
-          )}
+          {/* 数据表格 */}
+          <Table
+            columns={columns}
+            dataSource={tasks}
+            rowKey="id"
+            loading={loading}
+            pagination={{
+              current: page,
+              pageSize: size,
+              total,
+              showSizeChanger: false,
+              showTotal: (total) => `${t('common.total')} ${total} ${t('common.items')}`,
+              onChange: (newPage) => setPage(newPage),
+              simple: isMobile
+            }}
+            scroll={isMobile ? { x: 1200 } : { x: 1400 }}
+          />
         </Space>
       </Card>
 

frontend/src/pages/CopyTradingList.tsx

@@ -1,7 +1,7 @@
 import { useEffect, useState } from 'react'
 import { useSearchParams } from 'react-router-dom'
-import { Card, Table, Button, Space, Tag, Popconfirm, Switch, message, Select, Dropdown, Spin, List, Empty, Tooltip } from 'antd'
-import { PlusOutlined, DeleteOutlined, BarChartOutlined, UnorderedListOutlined, ArrowUpOutlined, ArrowDownOutlined, EditOutlined, WalletOutlined, UserOutlined } from '@ant-design/icons'
+import { Card, Table, Button, Space, Tag, Popconfirm, Switch, message, Select, Dropdown, Divider, Spin } from 'antd'
+import { PlusOutlined, DeleteOutlined, BarChartOutlined, UnorderedListOutlined, ArrowUpOutlined, ArrowDownOutlined, EditOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import type { MenuProps } from 'antd'
 import { apiService } from '../services/api'
@@ -297,7 +297,7 @@ const CopyTradingList: React.FC = () => {
     {
       title: t('common.actions') || '操作',
       key: 'action',
-      width: isMobile ? 100 : 160,
+      width: isMobile ? 100 : 200,
       fixed: 'right' as const,
       render: (_: any, record: CopyTrading) => {
         const menuItems: MenuProps['items'] = [
@@ -321,101 +321,61 @@ const CopyTradingList: React.FC = () => {
             }
           }
         ]
-
+        
         return (
-          <Space size={4}>
-            <Tooltip title={t('common.edit') || '编辑'}>
-              <div
-                onClick={() => {
-                  setEditModalCopyTradingId(record.id.toString())
-                  setEditModalOpen(true)
-                }}
-                style={{
-                  display: 'flex',
-                  alignItems: 'center',
-                  justifyContent: 'center',
-                  width: '32px',
-                  height: '32px',
-                  cursor: 'pointer',
-                  borderRadius: '6px',
-                  transition: 'background-color 0.2s'
-                }}
-                onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#f0f0f0' }}
-                onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
-              >
-                <EditOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-              </div>
-            </Tooltip>
-
-            <Tooltip title={t('copyTradingList.statistics') || '统计'}>
-              <div
-                onClick={() => {
-                  setStatisticsModalCopyTradingId(record.id.toString())
-                  setStatisticsModalOpen(true)
-                }}
-                style={{
-                  display: 'flex',
-                  alignItems: 'center',
-                  justifyContent: 'center',
-                  width: '32px',
-                  height: '32px',
-                  cursor: 'pointer',
-                  borderRadius: '6px',
-                  transition: 'background-color 0.2s'
-                }}
-                onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#f0f0f0' }}
-                onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
-              >
-                <BarChartOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-              </div>
-            </Tooltip>
-
+          <Space size={isMobile ? 'small' : 'middle'} wrap>
+            {!isMobile && (
+              <>
+                <Button
+                  type="link"
+                  size="small"
+                  icon={<EditOutlined />}
+                  onClick={() => {
+                    setEditModalCopyTradingId(record.id.toString())
+                    setEditModalOpen(true)
+                  }}
+                >
+                  {t('common.edit') || '编辑'}
+                </Button>
+                <Button
+                  type="link"
+                  size="small"
+                  icon={<BarChartOutlined />}
+                  onClick={() => {
+                    setStatisticsModalCopyTradingId(record.id.toString())
+                    setStatisticsModalOpen(true)
+                  }}
+                >
+                  {t('copyTradingList.statistics') || '统计'}
+                </Button>
+              </>
+            )}
             <Dropdown menu={{ items: menuItems }} trigger={['click']}>
-              <Tooltip title={t('copyTradingList.orders') || '订单'}>
-                <div
-                  style={{
-                    display: 'flex',
-                    alignItems: 'center',
-                    justifyContent: 'center',
-                    width: '32px',
-                    height: '32px',
-                    cursor: 'pointer',
-                    borderRadius: '6px',
-                    transition: 'background-color 0.2s'
-                  }}
-                  onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#f0f0f0' }}
-                  onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
-                >
-                  <UnorderedListOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-                </div>
-              </Tooltip>
+              <Button
+                type="link"
+                size="small"
+                icon={<UnorderedListOutlined />}
+              >
+                {isMobile ? '' : (t('copyTradingList.orders') || '订单')}
+              </Button>
             </Dropdown>
-
-            <Popconfirm
-              title={t('copyTradingList.deleteConfirm') || '确定要删除这个跟单关系吗？'}
-              onConfirm={() => handleDelete(record.id)}
-              okText={t('common.confirm') || '确定'}
-              cancelText={t('common.cancel') || '取消'}
-            >
-              <Tooltip title={t('common.delete') || '删除'}>
-                <div
-                  style={{
-                    display: 'flex',
-                    alignItems: 'center',
-                    justifyContent: 'center',
-                    width: '32px',
-                    height: '32px',
-                    cursor: 'pointer',
-                    borderRadius: '6px',
-                    transition: 'background-color 0.2s'
-                  }}
-                  onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#fff1f0' }}
-                  onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
+            {!isMobile && (
+              <Popconfirm
+                title={t('copyTradingList.deleteConfirm') || '确定要删除这个跟单关系吗？'}
+                onConfirm={() => handleDelete(record.id)}
+                okText={t('common.confirm') || '确定'}
+                cancelText={t('common.cancel') || '取消'}
+              >
+                <Button
+                  type="link"
+                  size="small"
+                  danger
+                  icon={<DeleteOutlined />}
                 >
-                  <DeleteOutlined style={{ fontSize: '16px', color: '#ff4d4f' }} />
-                </div>
-              </Tooltip>
-            </Popconfirm>
+                  {t('common.delete') || '删除'}
+                </Button>
+              </Popconfirm>
+            )}
           </Space>
         )
       }
@@ -424,21 +384,19 @@ const CopyTradingList: React.FC = () => {
   
   return (
     <div>
-      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px', flexWrap: 'wrap', gap: '12px' }}>
-        <h2 style={{ margin: 0, fontSize: isMobile ? '20px' : '24px' }}>{t('copyTradingList.title') || '跟单配置管理'}</h2>
-        <Tooltip title={t('copyTradingList.addCopyTrading') || '新增跟单'}>
+      <Card>
+        <div style={{ marginBottom: 16, display: 'flex', justifyContent: 'space-between', alignItems: 'center', flexWrap: 'wrap', gap: 16 }}>
+          <h2 style={{ margin: 0 }}>{t('copyTradingList.title') || '跟单配置管理'}</h2>
           <Button
             type="primary"
             icon={<PlusOutlined />}
             onClick={() => setAddModalOpen(true)}
-            size={isMobile ? 'middle' : 'large'}
-            style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}
-          />
-        </Tooltip>
-      </div>
-
-      <Card style={{ borderRadius: '12px', boxShadow: '0 2px 8px rgba(0,0,0,0.08)', border: '1px solid #e8e8e8' }} bodyStyle={{ padding: isMobile ? '12px' : '24px' }}>
-        <div style={{ marginBottom: 16, display: 'flex', gap: 12, flexWrap: 'wrap' }}>
+          >
+            {t('copyTradingList.addCopyTrading') || '新增跟单'}
+          </Button>
+        </div>
+        
+        <div style={{ marginBottom: 16, display: 'flex', gap: 16, flexWrap: 'wrap' }}>
           <Select
             placeholder={t('copyTradingList.filterWallet') || '筛选钱包'}
             allowClear
@@ -463,14 +421,14 @@ const CopyTradingList: React.FC = () => {
           />
           
           <Select
-            placeholder={t('common.status') || '状态'}
+            placeholder="筛选状态"
             allowClear
             style={{ width: isMobile ? '100%' : 150 }}
             value={filters.enabled}
             onChange={(value) => setFilters({ ...filters, enabled: value !== undefined ? value : undefined })}
           >
-            <Option value={true}>{t('common.enabled') || '开启'}</Option>
-            <Option value={false}>{t('common.disabled') || '停止'}</Option>
+            <Option value={true}>开启</Option>
+            <Option value={false}>停止</Option>
           </Select>
         </div>
         
@@ -482,180 +440,207 @@ const CopyTradingList: React.FC = () => {
                 <Spin size="large" />
               </div>
             ) : copyTradings.length === 0 ? (
-              <Empty description={t('copyTradingList.noData') || '暂无跟单配置'} />
+              <div style={{ textAlign: 'center', padding: '40px', color: '#999' }}>
+                暂无跟单配置
+              </div>
             ) : (
-              <List
-                dataSource={copyTradings}
-                renderItem={(record) => {
+              <div style={{ display: 'flex', flexDirection: 'column', gap: '12px' }}>
+                {copyTradings.map((record) => {
                   const stats = statisticsMap[record.id]
+                  const date = new Date(record.createdAt)
+                  const formattedDate = date.toLocaleString('zh-CN', {
+                    year: 'numeric',
+                    month: '2-digit',
+                    day: '2-digit',
+                    hour: '2-digit',
+                    minute: '2-digit'
+                  })
                   
                   return (
                     <Card
                       key={record.id}
                       style={{
-                        marginBottom: '10px',
-                        borderRadius: '10px',
-                        boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
-                        border: '1px solid #e8e8e8',
-                        overflow: 'hidden'
+                        borderRadius: '12px',
+                        boxShadow: '0 2px 8px rgba(0,0,0,0.08)',
+                        border: '1px solid #e8e8e8'
                       }}
-                      bodyStyle={{ padding: '0' }}
+                      bodyStyle={{ padding: '16px' }}
                     >
-                      {/* 头部区域 - 配置名称 */}
-                      <div style={{
-                        padding: '10px 12px',
-                        background: 'var(--ant-color-primary, #1677ff)',
-                        color: '#fff'
-                      }}>
-                        <div style={{ fontSize: '15px', fontWeight: '600', marginBottom: '2px', display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
-                          <span>{record.configName || t('copyTradingList.configNameNotProvided') || '未提供'}</span>
+                      {/* 基本信息 */}
+                      <div style={{ marginBottom: '12px' }}>
+                        <div style={{ 
+                          fontSize: '18px', 
+                          fontWeight: 'bold', 
+                          marginBottom: '8px',
+                          color: '#1890ff'
+                        }}>
+                          {record.configName || t('copyTradingList.configNameNotProvided') || '未提供'}
+                        </div>
+                        <div style={{ 
+                          fontSize: '14px', 
+                          marginBottom: '8px',
+                          color: '#666'
+                        }}>
+                          {record.copyMode === 'RATIO' 
+                            ? `${t('copyTradingList.ratioMode') || '比例'} ${(parseFloat(record.copyRatio || '0') * 100).toFixed(2).replace(/\.0+$/, '')}%`
+                            : `${t('copyTradingList.fixedAmountMode') || '固定'} ${formatUSDC(record.fixedAmount || '0')}`
+                          }
+                        </div>
+                        <div style={{ display: 'flex', flexWrap: 'wrap', gap: '6px', alignItems: 'center', justifyContent: 'space-between' }}>
+                          <Tag color={record.enabled ? 'green' : 'red'}>
+                            {record.enabled ? '启用' : '禁用'}
+                          </Tag>
                           <Switch
                             checked={record.enabled}
                             onChange={() => handleToggleStatus(record)}
-                            checkedChildren={t('copyTradingList.enabled') || '开启'}
-                            unCheckedChildren={t('copyTradingList.disabled') || '停止'}
+                            checkedChildren="开启"
+                            unCheckedChildren="停止"
                             size="small"
                           />
                         </div>
-                        <div style={{ fontSize: '12px', opacity: '0.9' }}>
-                          {record.copyMode === 'RATIO' 
-                            ? `${t('copyTradingList.ratioMode') || '比例'} ${(parseFloat(record.copyRatio || '0') * 100).toFixed(0).replace(/\.0+$/, '')}%`
-                            : `${t('copyTradingList.fixedAmountMode') || '固定'} ${formatUSDC(record.fixedAmount || '0')} USDC`
-                          }
+                      </div>
+                      
+                      <Divider style={{ margin: '12px 0' }} />
+                      
+                      {/* 账户信息 */}
+                      <div style={{ marginBottom: '12px' }}>
+                        <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>账户</div>
+                        <div style={{ fontSize: '14px', fontWeight: '500' }}>
+                          {record.accountName || `账户 ${record.accountId}`}
+                        </div>
+                        <div style={{ fontSize: '12px', color: '#999', marginTop: '2px' }}>
+                          {record.walletAddress.slice(0, 6)}...{record.walletAddress.slice(-4)}
                         </div>
                       </div>
-
-                      {/* 盈亏区域 - 常驻显示 */}
-                      <div style={{
-                        padding: '8px 12px',
-                        backgroundColor: '#fafafa',
-                        borderBottom: '1px solid #f0f0f0',
-                        minHeight: '42px',
-                        display: 'flex',
-                        alignItems: 'center'
-                      }}>
-                        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', width: '100%' }}>
-                          <div>
-                            <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
-                              {t('copyTradingList.totalPnl') || '总盈亏'}
-                            </div>
-                            {stats ? (
-                              <div style={{ 
-                                fontSize: '14px', 
-                                fontWeight: '600',
-                                color: getPnlColor(stats.totalPnl),
-                                display: 'flex',
-                                alignItems: 'center',
-                                gap: '4px'
-                              }}>
-                                {getPnlIcon(stats.totalPnl)}
-                                {formatUSDC(stats.totalPnl)} USDC
-                              </div>
-                            ) : loadingStatistics.has(record.id) ? (
-                              <Spin size="small" />
-                            ) : (
-                              <div style={{ fontSize: '14px', color: '#8c8c8c' }}>-</div>
-                            )}
-                          </div>
-                          {stats && (
-                            <div style={{ textAlign: 'right' }}>
-                              <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
-                                {t('copyTradingList.profitRate') || '收益率'}
-                              </div>
-                              <div style={{ 
-                                fontSize: '12px', 
-                                fontWeight: '500',
-                                color: getPnlColor(stats.totalPnlPercent)
-                              }}>
-                                {formatPercent(stats.totalPnlPercent)}
-                              </div>
-                            </div>
-                          )}
+                      
+                      {/* Leader 信息 */}
+                      <div style={{ marginBottom: '12px' }}>
+                        <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>Leader</div>
+                        <div style={{ fontSize: '14px', fontWeight: '500' }}>
+                          {record.leaderName || `Leader ${record.leaderId}`}
+                        </div>
+                        <div style={{ fontSize: '12px', color: '#999', marginTop: '2px' }}>
+                          {record.leaderAddress.slice(0, 6)}...{record.leaderAddress.slice(-4)}
                         </div>
                       </div>
-
-                      {/* 账户和Leader信息区域 */}
-                      <div style={{
-                        padding: '8px 12px',
-                        fontSize: '11px',
-                        color: '#8c8c8c',
-                        borderBottom: '1px solid #f0f0f0'
-                      }}>
-                        <div style={{ display: 'flex', alignItems: 'center', marginBottom: '4px' }}>
-                          <WalletOutlined style={{ fontSize: '12px', marginRight: '4px', color: '#1890ff' }} />
-                          <span>{t('copyTradingList.wallet') || '账户'}: {record.accountName || `#${record.accountId}`}</span>
+                      
+                      {/* 总盈亏 */}
+                      {stats && (
+                        <div style={{ marginBottom: '12px' }}>
+                          <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>总盈亏</div>
+                          <div style={{ 
+                            fontSize: '16px', 
+                            fontWeight: 'bold',
+                            color: getPnlColor(stats.totalPnl),
+                            display: 'flex',
+                            alignItems: 'center',
+                            gap: '4px'
+                          }}>
+                            {getPnlIcon(stats.totalPnl)}
+                            {formatUSDC(stats.totalPnl)} USDC
+                          </div>
+                          <div style={{ 
+                            fontSize: '12px', 
+                            color: getPnlColor(stats.totalPnlPercent),
+                            marginTop: '4px'
+                          }}>
+                            {formatPercent(stats.totalPnlPercent)}
+                          </div>
                         </div>
-                        <div style={{ display: 'flex', alignItems: 'center' }}>
-                          <UserOutlined style={{ fontSize: '12px', marginRight: '4px', color: '#722ed1' }} />
-                          <span>Leader: {record.leaderName || `#${record.leaderId}`}</span>
+                      )}
+                      
+                      {loadingStatistics.has(record.id) && (
+                        <div style={{ marginBottom: '12px', fontSize: '12px', color: '#999' }}>
+                          加载统计中...
+                        </div>
+                      )}
+                      
+                      {/* 创建时间 */}
+                      <div style={{ marginBottom: '16px' }}>
+                        <div style={{ fontSize: '12px', color: '#999' }}>
+                          创建时间: {formattedDate}
                         </div>
                       </div>
-
-                      {/* 图标操作栏 */}
-                      <div style={{
-                        padding: '8px 12px',
-                        display: 'flex',
-                        justifyContent: 'space-around',
-                        alignItems: 'center'
-                      }}>
-                        <Tooltip title={t('common.edit') || '编辑'}>
-                          <div
-                            onClick={() => {
-                              setEditModalCopyTradingId(record.id.toString())
-                              setEditModalOpen(true)
-                            }}
-                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
+                      
+                      {/* 操作按钮 */}
+                      <div style={{ display: 'flex', gap: '8px', flexWrap: 'wrap' }}>
+                        <Button
+                          type="primary"
+                          size="small"
+                          icon={<EditOutlined />}
+                          onClick={() => {
+                            setEditModalCopyTradingId(record.id.toString())
+                            setEditModalOpen(true)
+                          }}
+                          style={{ flex: 1, minWidth: '80px' }}
+                        >
+                          {t('common.edit') || '编辑'}
+                        </Button>
+                        <Button
+                          size="small"
+                          icon={<BarChartOutlined />}
+                          onClick={() => {
+                            setStatisticsModalCopyTradingId(record.id.toString())
+                            setStatisticsModalOpen(true)
+                          }}
+                          style={{ flex: 1, minWidth: '80px' }}
+                        >
+                          {t('copyTradingList.statistics') || '统计'}
+                        </Button>
+                        <Dropdown 
+                          menu={{ 
+                            items: [
+                              {
+                                key: 'matchedOrders',
+                                label: t('copyTradingList.matchedOrders') || '已成交订单',
+                                icon: <UnorderedListOutlined />,
+                                onClick: () => {
+                                  setOrdersModalCopyTradingId(record.id.toString())
+                                  setOrdersModalTab('buy')
+                                  setOrdersModalOpen(true)
+                                }
+                              },
+                              {
+                                key: 'filteredOrders',
+                                label: t('copyTradingList.filteredOrders') || '已过滤订单',
+                                icon: <UnorderedListOutlined />,
+                                onClick: () => {
+                                  setFilteredOrdersModalCopyTradingId(record.id.toString())
+                                  setFilteredOrdersModalOpen(true)
+                                }
+                              }
+                            ]
+                          }} 
+                          trigger={['click']}
+                        >
+                          <Button
+                            size="small"
+                            icon={<UnorderedListOutlined />}
+                            style={{ flex: 1, minWidth: '80px' }}
                           >
-                            <EditOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.edit') || '编辑'}</span>
-                          </div>
-                        </Tooltip>
-
-                        <Tooltip title={t('copyTradingList.statistics') || '统计'}>
-                          <div
-                            onClick={() => {
-                              setStatisticsModalCopyTradingId(record.id.toString())
-                              setStatisticsModalOpen(true)
-                            }}
-                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
-                          >
-                            <BarChartOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('copyTradingList.statistics') || '统计'}</span>
-                          </div>
-                        </Tooltip>
-
-                        <Tooltip title={t('copyTradingList.orders') || '订单'}>
-                          <div
-                            onClick={() => {
-                              setOrdersModalCopyTradingId(record.id.toString())
-                              setOrdersModalTab('buy')
-                              setOrdersModalOpen(true)
-                            }}
-                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
-                          >
-                            <UnorderedListOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('copyTradingList.orders') || '订单'}</span>
-                          </div>
-                        </Tooltip>
-
+                            {t('copyTradingList.orders') || '订单'}
+                          </Button>
+                        </Dropdown>
                         <Popconfirm
                           title={t('copyTradingList.deleteConfirm') || '确定要删除这个跟单关系吗？'}
                           onConfirm={() => handleDelete(record.id)}
                           okText={t('common.confirm') || '确定'}
                           cancelText={t('common.cancel') || '取消'}
                         >
-                          <Tooltip title={t('common.delete') || '删除'}>
-                            <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                              <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
-                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.delete') || '删除'}</span>
-                            </div>
-                          </Tooltip>
+                          <Button
+                            danger
+                            size="small"
+                            icon={<DeleteOutlined />}
+                            style={{ flex: 1, minWidth: '80px' }}
+                          >
+                            {t('common.delete') || '删除'}
+                          </Button>
                         </Popconfirm>
                       </div>
                     </Card>
                   )
-                }}
-              />
+                })}
+              </div>
             )}
           </div>
         ) : (

frontend/src/pages/CryptoTailMonitor.tsx

@@ -12,13 +12,9 @@ import {
   Alert,
   Radio,
   Button,
-  Tooltip,
-  Modal,
-  InputNumber,
-  message
+  Tooltip
 } from 'antd'
-import { Popup as AntdMobilePopup } from 'antd-mobile'
-import { ClockCircleOutlined, SyncOutlined, InfoCircleOutlined, ShoppingCartOutlined } from '@ant-design/icons'
+import { ClockCircleOutlined, SyncOutlined, InfoCircleOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import { useMediaQuery } from 'react-responsive'
 import * as echarts from 'echarts'
@@ -34,10 +30,6 @@ import type {
 
 const { Title, Text } = Typography
 
-// localStorage keys
-const PERIOD_SWITCH_MODE_KEY = 'cryptoTailMonitor_periodSwitchMode'
-const SELECTED_STRATEGY_ID_KEY = 'cryptoTailMonitor_selectedStrategyId'
-
 /** 分时图数据点：时间戳、BTC 价格 USDC、市场 Up/Down 价格 0-1 */
 interface PriceDataPoint {
   time: number
@@ -54,11 +46,8 @@ const CryptoTailMonitor: React.FC = () => {
   const [strategies, setStrategies] = useState<CryptoTailStrategyDto[]>([])
   const [strategiesLoading, setStrategiesLoading] = useState(false)
 
-  // 选中的策略（从 localStorage 恢复）
-  const [selectedStrategyId, setSelectedStrategyId] = useState<number | null>(() => {
-    const cached = localStorage.getItem(SELECTED_STRATEGY_ID_KEY)
-    return cached != null ? parseInt(cached, 10) : null
-  })
+  // 选中的策略
+  const [selectedStrategyId, setSelectedStrategyId] = useState<number | null>(null)
 
   // 监控数据
   const [initData, setInitData] = useState<CryptoTailMonitorInitResponse | null>(null)
@@ -72,10 +61,9 @@ const CryptoTailMonitor: React.FC = () => {
   const marketChartRef = useRef<HTMLDivElement>(null)
   const marketChartInstance = useRef<echarts.ECharts | null>(null)
   const lastPeriodStartRef = useRef<number | null>(null)
-  const selectedStrategyIdRef = useRef<number | null>(null)
-  useEffect(() => {
-    selectedStrategyIdRef.current = selectedStrategyId
-  }, [selectedStrategyId])
+
+  // localStorage key for period switch mode
+  const PERIOD_SWITCH_MODE_KEY = 'cryptoTailMonitor_periodSwitchMode'
 
   // 记录首次数据进入时间（用于中途进入时的横轴起点）
   const [firstDataTime, setFirstDataTime] = useState<number | null>(null)
@@ -96,38 +84,6 @@ const CryptoTailMonitor: React.FC = () => {
   // 标记当前是否在查看旧周期（手动模式下）
   const [isViewingOldPeriod, setIsViewingOldPeriod] = useState<boolean>(false)
 
-  // 手动下单状态
-  const [manualOrderModal, setManualOrderModal] = useState<{
-    visible: boolean
-    direction: 'UP' | 'DOWN'
-    price: string
-    size: string
-    totalAmount: string
-    bestBid: string
-    availableBalance: string
-    periodStartUnix: number | null
-  }>({
-    visible: false,
-    direction: 'UP',
-    price: '',
-    size: '',
-    totalAmount: '',
-    bestBid: '',
-    availableBalance: '',
-    periodStartUnix: null
-  })
-  const [ordering, setOrdering] = useState(false)
-
-  // 检测周期切换，关闭弹窗并提示用户
-  useEffect(() => {
-    if (manualOrderModal.visible && manualOrderModal.periodStartUnix != null && pushData) {
-      if (pushData.periodStartUnix !== manualOrderModal.periodStartUnix) {
-        message.warning(t('cryptoTailMonitor.manualOrder.periodChanged'))
-        handleCloseManualOrderModal()
-      }
-    }
-  }, [pushData?.periodStartUnix, manualOrderModal.visible, manualOrderModal.periodStartUnix])
-
   // 获取策略列表
   useEffect(() => {
     const fetchStrategies = async () => {
@@ -135,18 +91,10 @@ const CryptoTailMonitor: React.FC = () => {
       try {
         const res = await apiService.cryptoTailStrategy.list({ enabled: true })
         if (res.data.code === 0 && res.data.data) {
-          const strategyList = res.data.data.list ?? []
-          setStrategies(strategyList)
-          // 从 localStorage 恢复选中的策略
-          const cachedId = localStorage.getItem(SELECTED_STRATEGY_ID_KEY)
-          const cachedStrategyId = cachedId != null ? parseInt(cachedId, 10) : null
-          // 检查缓存的策略是否在列表中
-          const isValidCached = cachedStrategyId != null && strategyList.some(s => s.id === cachedStrategyId)
-          if (isValidCached) {
-            setSelectedStrategyId(cachedStrategyId)
-          } else if (strategyList.length > 0) {
-            // 自动选择第一个策略
-            setSelectedStrategyId(strategyList[0].id)
+          setStrategies(res.data.data.list ?? [])
+          // 自动选择第一个策略
+          if (res.data.data.list?.length > 0 && !selectedStrategyId) {
+            setSelectedStrategyId(res.data.data.list[0].id)
           }
         }
       } catch (e) {
@@ -158,13 +106,6 @@ const CryptoTailMonitor: React.FC = () => {
     fetchStrategies()
   }, [])
 
-  // 保存选中的策略到 localStorage
-  useEffect(() => {
-    if (selectedStrategyId != null) {
-      localStorage.setItem(SELECTED_STRATEGY_ID_KEY, String(selectedStrategyId))
-    }
-  }, [selectedStrategyId])
-
   // 初始化监控数据
   useEffect(() => {
     if (!selectedStrategyId) {
@@ -186,7 +127,7 @@ const CryptoTailMonitor: React.FC = () => {
       setPendingPeriodData(null)
       setIsViewingOldPeriod(false)
       try {
-        const res = await apiService.cryptoTailStrategy.monitorInit({ strategyId: selectedStrategyId })
+        const res = await apiService.cryptoTailStrategy.monitorInit(selectedStrategyId)
         if (res.data.code === 0 && res.data.data) {
           setInitData(res.data.data)
         } else {
@@ -231,23 +172,11 @@ const CryptoTailMonitor: React.FC = () => {
     const lastPeriod = lastPeriodStartRef.current
 
     if (pushPeriod != null && pushPeriod !== lastPeriod) {
-      // 新周期到来：重新拉取 init（含 tokenIds），再更新状态
+      // 新周期到来
       lastPeriodStartRef.current = pushPeriod
-      const marketTitle = (data as { marketTitle?: string }).marketTitle
-      const applyFreshInit = (fresh: CryptoTailMonitorInitResponse) => {
-        if (selectedStrategyIdRef.current !== fresh.strategyId) return
-        const merged: CryptoTailMonitorInitResponse = {
-          ...fresh,
-          periodStartUnix: pushPeriod,
-          marketTitle: marketTitle ?? fresh.marketTitle ?? ''
-        }
-        if (periodSwitchMode === 'manual' && lastPeriod != null) {
-          setPendingPeriodData(p => p ? { ...p, initData: merged } : null)
-        } else {
-          setInitData(merged)
-        }
-      }
+
       if (periodSwitchMode === 'manual' && lastPeriod != null) {
+        // 手动模式：保存新周期数据到 pending，保留当前显示
         setPendingPeriodData({
           periodStartUnix: pushPeriod,
           priceHistory: [newPoint],
@@ -255,35 +184,26 @@ const CryptoTailMonitor: React.FC = () => {
           pushData: data
         })
         setIsViewingOldPeriod(true)
-        apiService.cryptoTailStrategy.monitorInit({ strategyId: selectedStrategyId!, periodStartUnix: pushPeriod }).then(res => {
-          if (res.data?.code === 0 && res.data?.data) applyFreshInit(res.data.data)
-          else {
-            setInitData(prev => {
-              if (prev) setPendingPeriodData(p => p ? { ...p, initData: { ...prev, periodStartUnix: pushPeriod, marketTitle: marketTitle ?? prev.marketTitle ?? '' } } : null)
-              return prev ?? null
-            })
+        // 更新 pending 数据的 initData
+        setInitData(prev => {
+          if (prev) {
+            setPendingPeriodData(p => p ? { ...p, initData: { ...prev, periodStartUnix: pushPeriod, marketTitle: (data as { marketTitle?: string }).marketTitle ?? prev.marketTitle } } : null)
           }
-        }).catch(() => {
-          setInitData(prev => {
-            if (prev) setPendingPeriodData(p => p ? { ...p, initData: { ...prev, periodStartUnix: pushPeriod, marketTitle: marketTitle ?? prev.marketTitle ?? '' } } : null)
-            return prev ?? null
-          })
+          return prev
         })
       } else {
-        if (lastPeriod != null) setHasSwitchedPeriod(true)
+        // 自动模式或首次推送：直接切换
+        if (lastPeriod != null) {
+          setHasSwitchedPeriod(true)
+        }
         setFirstDataTime(newPoint.time)
+        setInitData(prev => prev ? { ...prev, periodStartUnix: pushPeriod, marketTitle: (data as { marketTitle?: string }).marketTitle ?? prev.marketTitle } : null)
         setPriceHistory([newPoint])
         setPushData(data)
         setIsViewingOldPeriod(false)
         setPendingPeriodData(null)
-        apiService.cryptoTailStrategy.monitorInit({ strategyId: selectedStrategyId!, periodStartUnix: pushPeriod }).then(res => {
-          if (res.data?.code === 0 && res.data?.data) applyFreshInit(res.data.data)
-          else setInitData(prev => prev ? { ...prev, periodStartUnix: pushPeriod, marketTitle: marketTitle ?? prev.marketTitle ?? '' } : null)
-        }).catch(() => {
-          setInitData(prev => prev ? { ...prev, periodStartUnix: pushPeriod, marketTitle: marketTitle ?? prev.marketTitle ?? '' } : null)
-        })
+        return
       }
-      return
     } else {
       // 同周期：追加数据
       if (periodSwitchMode === 'manual' && isViewingOldPeriod && pendingPeriodData) {
@@ -789,188 +709,6 @@ const CryptoTailMonitor: React.FC = () => {
   const spreadBelowThreshold = currentSpread != null && currentSpread !== '' && minSpreadLineNum.length > 0 &&
     parseFloat(currentSpread) < Math.min(...minSpreadLineNum)
 
-  // 手动下单：打开弹窗
-  const handleOpenManualOrderModal = async (direction: 'UP' | 'DOWN') => {
-    if (!pushData) {
-      message.warning(t('cryptoTailMonitor.manualOrder.priceNotLoaded'))
-      return
-    }
-    const bestBid = direction === 'UP' ? pushData.currentPriceUp : pushData.currentPriceDown
-    if (!bestBid) {
-      message.warning(t('cryptoTailMonitor.manualOrder.priceNotLoaded'))
-      return
-    }
-    // 计算默认价格：最优 bid × 1.1，限制在 0~0.99 之间
-    const rawPrice = parseFloat(bestBid) * 1.1
-    const defaultPrice = Math.min(0.99, Math.max(0, rawPrice))
-    
-    // 获取账户余额
-    let availableBalance = '0'
-    if (initData?.accountId) {
-      try {
-        const balanceRes = await apiService.accounts.balance({ accountId: initData.accountId })
-        if (balanceRes.data.code === 0 && balanceRes.data.data?.availableBalance) {
-          availableBalance = balanceRes.data.data.availableBalance
-        }
-      } catch (e) {
-        console.error('获取账户余额失败:', e)
-      }
-    }
-    
-    // 使用策略配置的金额
-    let defaultAmountUsdc = 10
-    if (initData?.amountMode === 'FIXED' && initData?.amountValue) {
-      defaultAmountUsdc = parseFloat(initData.amountValue)
-    } else if (initData?.amountMode === 'RATIO' && initData?.amountValue) {
-      // RATIO 模式：按比例计算
-      const balanceNum = parseFloat(availableBalance)
-      const ratio = parseFloat(initData.amountValue || '10')
-      defaultAmountUsdc = balanceNum * ratio / 100
-      // 至少保留 1 USDC
-      if (defaultAmountUsdc < 1) {
-        message.warning(t('cryptoTailMonitor.manualOrder.insufficientBalance'))
-        return
-      }
-    }
-    
-    // 计算默认数量（保留2位小数，用于手动下单）
-    let defaultSize = (defaultAmountUsdc / defaultPrice).toFixed(2)
-    // 确保至少 1 张
-    if (parseFloat(defaultSize) < 1) {
-      defaultSize = '1.00'
-    }
-    
-    // 重新计算总金额（基于实际数量）
-    const defaultTotalAmount = (defaultPrice * parseFloat(defaultSize)).toFixed(2)
-    
-    setManualOrderModal({
-      visible: true,
-      direction,
-      price: defaultPrice.toFixed(4),
-      size: defaultSize,
-      totalAmount: defaultTotalAmount,
-      bestBid,
-      availableBalance,
-      periodStartUnix: pushData.periodStartUnix
-    })
-  }
-
-  // 获取最新价
-  const handleFetchLatestPrice = async () => {
-    if (!pushData) {
-      message.warning(t('cryptoTailMonitor.manualOrder.priceNotLoaded'))
-      return
-    }
-    const latestPrice = manualOrderModal.direction === 'UP' 
-      ? pushData.currentPriceUp 
-      : pushData.currentPriceDown
-    if (!latestPrice) {
-      message.warning(t('cryptoTailMonitor.manualOrder.priceNotLoaded'))
-      return
-    }
-    const price = Math.min(0.99, parseFloat(latestPrice))
-    const size = parseFloat(manualOrderModal.size)
-    const totalAmount = (price * size).toFixed(2)
-    setManualOrderModal({ 
-      ...manualOrderModal, 
-      price: price.toFixed(4),
-      totalAmount 
-    })
-    message.success(t('cryptoTailMonitor.manualOrder.priceUpdated'))
-  }
-
-  const handleCloseManualOrderModal = () => {
-    setManualOrderModal({
-      visible: false,
-      direction: 'UP',
-      price: '',
-      size: '',
-      totalAmount: '',
-      bestBid: '',
-      availableBalance: '',
-      periodStartUnix: null
-    })
-  }
-
-  const handlePriceChange = (value: number | null) => {
-    if (value === null) return
-    const clamped = Math.min(0.99, Math.max(0, value))
-    const price = clamped.toFixed(4)
-    const size = parseFloat(manualOrderModal.size)
-    const totalAmount = (clamped * size).toFixed(2)
-    setManualOrderModal({ ...manualOrderModal, price, totalAmount })
-  }
-
-  const handleSizeChange = (value: number | null) => {
-    if (value === null) return
-    const size = value.toFixed(2)
-    const priceRaw = parseFloat(manualOrderModal.price)
-    const price = Math.min(0.99, Math.max(0, priceRaw))
-    const totalAmount = (price * value).toFixed(2)
-    setManualOrderModal({ ...manualOrderModal, size, totalAmount, price: price.toFixed(4) })
-  }
-
-  // 计算最大数量（截位处理）
-  const handleMaxSize = () => {
-    const price = parseFloat(manualOrderModal.price)
-    const balance = parseFloat(manualOrderModal.availableBalance)
-    
-    if (price <= 0 || balance <= 0) {
-      message.warning(t('cryptoTailMonitor.manualOrder.invalidPriceOrBalance'))
-      return
-    }
-    
-    // 最大数量 = 余额 / 价格，保留2位小数
-    let maxSize = Math.floor((balance / price) * 100) / 100
-    
-    // 确保至少 1 张
-    if (maxSize < 1) {
-      message.warning(t('cryptoTailMonitor.manualOrder.insufficientBalanceForMax'))
-      return
-    }
-    
-    const totalAmount = (price * maxSize).toFixed(2)
-    setManualOrderModal({ 
-      ...manualOrderModal, 
-      size: maxSize.toFixed(2),
-      totalAmount 
-    })
-    message.success(t('cryptoTailMonitor.manualOrder.maxSizeUpdated'))
-  }
-
-  const handleManualOrder = async () => {
-    if (!initData || !pushData) return
-    try {
-      setOrdering(true)
-      const tokenIds: string[] = []
-      if (initData.tokenIdUp) tokenIds.push(initData.tokenIdUp)
-      if (initData.tokenIdDown) tokenIds.push(initData.tokenIdDown)
-      const request = {
-        strategyId: initData.strategyId,
-        periodStartUnix: pushData.periodStartUnix,
-        direction: manualOrderModal.direction,
-        price: Math.min(0.99, Math.max(0, parseFloat(manualOrderModal.price) || 0)).toFixed(4),
-        size: manualOrderModal.size,
-        marketTitle: pushData.marketTitle || initData.marketTitle,
-        tokenIds
-      }
-      const res = await apiService.cryptoTailStrategy.manualOrder(request)
-      if (res.data.code === 0 && res.data.data?.success) {
-        message.success(t('cryptoTailMonitor.manualOrder.success'))
-        handleCloseManualOrderModal()
-      } else {
-        const reason = res.data.msg?.trim() || 'unknown'
-        message.error(t('cryptoTailMonitor.manualOrder.failed', { reason }))
-      }
-    } catch (error: unknown) {
-      const err = error as { response?: { data?: { msg?: string } }; message?: string }
-      const reason = err?.response?.data?.msg?.trim() ?? err?.message?.trim() ?? 'unknown'
-      message.error(t('cryptoTailMonitor.manualOrder.failed', { reason }))
-    } finally {
-      setOrdering(false)
-    }
-  }
-
   return (
     <div style={{ padding: isMobile ? 12 : 24 }}>
       <Title level={2} style={{ marginBottom: 16, fontSize: isMobile ? 20 : 24 }}>
@@ -979,22 +717,18 @@ const CryptoTailMonitor: React.FC = () => {
 
       {/* 顶部控制区 */}
       <Card style={{ marginBottom: 16 }}>
-        <Space direction={isMobile ? 'vertical' : 'horizontal'} size="middle" style={{ width: '100%' }}>
-          <Space direction={isMobile ? 'vertical' : 'horizontal'} size="small" style={{ width: isMobile ? '100%' : 'auto' }}>
+        <Space wrap size="middle">
+          <Space>
             <Text strong>{t('cryptoTailMonitor.selectStrategy')}</Text>
             <Select
-              style={{ minWidth: isMobile ? '100%' : 300, width: isMobile ? '100%' : 'auto' }}
+              style={{ minWidth: isMobile ? 200 : 300 }}
               loading={strategiesLoading}
               value={selectedStrategyId}
               onChange={(id) => setSelectedStrategyId(id)}
               placeholder={t('cryptoTailMonitor.selectStrategyPlaceholder')}
-              popupMatchSelectWidth={false}
-              dropdownStyle={{ minWidth: isMobile ? 280 : 'auto', wordWrap: 'break-word', whiteSpace: 'normal' }}
-              optionLabelProp="label"
               options={strategies.map(s => ({
                 label: `${s.name || s.marketSlugPrefix} (${s.intervalSeconds === 300 ? '5m' : '15m'})`,
-                value: s.id,
-                style: { whiteSpace: 'normal', wordWrap: 'break-word' }
+                value: s.id
               }))}
             />
           </Space>
@@ -1180,63 +914,29 @@ const CryptoTailMonitor: React.FC = () => {
             />
           </Card>
 
-          {/* 手动下单 */}
-          {!isMobile ? (
-            <Card title={t('cryptoTailMonitor.manualOrder.title')} style={{ marginTop: 16 }}>
-              <Row gutter={16}>
-                <Col span={12}>
-                  <Button
-                    type="primary"
-                    icon={<ShoppingCartOutlined />}
-                    disabled={!pushData || pushData.triggered || pushData.periodEnded}
-                    onClick={() => handleOpenManualOrderModal('UP')}
-                    loading={ordering}
-                    block
-                    style={{ backgroundColor: '#1890ff', borderColor: '#1890ff' }}
-                  >
-                    {t('cryptoTailMonitor.manualOrder.buttonUp')} {pushData?.currentPriceUp ? `(${formatNumber(pushData.currentPriceUp, 2)})` : ''}
-                  </Button>
-                </Col>
-                <Col span={12}>
-                  <Button
-                    type="primary"
-                    icon={<ShoppingCartOutlined />}
-                    disabled={!pushData || pushData.triggered || pushData.periodEnded}
-                    onClick={() => handleOpenManualOrderModal('DOWN')}
-                    loading={ordering}
-                    block
-                    style={{ backgroundColor: '#fa8c16', borderColor: '#fa8c16' }}
-                  >
-                    {t('cryptoTailMonitor.manualOrder.buttonDown')} {pushData?.currentPriceDown ? `(${formatNumber(pushData.currentPriceDown, 2)})` : ''}
-                  </Button>
-                </Col>
-              </Row>
-            </Card>
-          ) : null}
-
           {/* 策略信息 */}
           <Card title={t('cryptoTailMonitor.strategyInfo.title')} style={{ marginTop: 16 }}>
-            <Row gutter={[16, isMobile ? 12 : 8]}>
-              <Col xs={24} sm={24} md={12}>
+            <Row gutter={[16, 8]}>
+              <Col span={12}>
                 <Text type="secondary">{t('cryptoTailMonitor.strategyInfo.market')}: </Text>
                 <Text>{pushData?.marketTitle ?? initData.marketTitle}</Text>
               </Col>
-              <Col xs={24} sm={24} md={12}>
+              <Col span={12}>
                 <Text type="secondary">{t('cryptoTailMonitor.strategyInfo.interval')}: </Text>
                 <Text>{initData.intervalSeconds === 300 ? '5m' : '15m'}</Text>
               </Col>
-              <Col xs={24} sm={24} md={12}>
+              <Col span={12}>
                 <Text type="secondary">{t('cryptoTailMonitor.strategyInfo.account')}: </Text>
                 <Text>{initData.accountName || `#${initData.accountId}`}</Text>
               </Col>
-              <Col xs={24} sm={24} md={12}>
+              <Col span={12}>
                 <Text type="secondary">{t('cryptoTailMonitor.strategyInfo.spreadMode')}: </Text>
                 <Text>{initData.minSpreadMode}</Text>
                 {initData.minSpreadMode === 'FIXED' && initData.minSpreadValue && (
                   <Text> ({formatNumber(initData.minSpreadValue, 4)})</Text>
                 )}
               </Col>
-              <Col xs={24} sm={24} md={12}>
+              <Col span={12}>
                 <Text type="secondary">{t('cryptoTailMonitor.strategyInfo.spreadDirection')}: </Text>
                 <Text>{(initData.spreadDirection ?? 'MIN') === 'MAX' ? t('cryptoTailMonitor.stat.configuredSpreadMax') : t('cryptoTailMonitor.stat.configuredSpreadMin')}</Text>
               </Col>
@@ -1244,298 +944,6 @@ const CryptoTailMonitor: React.FC = () => {
           </Card>
         </>
       )}
-
-      {/* 手动下单确认弹窗 - 桌面端使用 Modal */}
-      {!isMobile && (
-        <Modal
-          title={t('cryptoTailMonitor.manualOrder.confirmTitle')}
-          open={manualOrderModal.visible}
-          onCancel={handleCloseManualOrderModal}
-          footer={[
-            <Button key="cancel" onClick={handleCloseManualOrderModal}>
-              {t('cryptoTailMonitor.manualOrder.cancel')}
-            </Button>,
-            <Button
-              key="confirm"
-              type="primary"
-              onClick={handleManualOrder}
-              loading={ordering}
-              style={
-                manualOrderModal.direction === 'UP'
-                  ? { backgroundColor: '#1890ff', borderColor: '#1890ff' }
-                  : { backgroundColor: '#fa8c16', borderColor: '#fa8c16' }
-              }
-            >
-              {t('cryptoTailMonitor.manualOrder.confirm')}
-            </Button>
-          ]}
-          width={480}
-        >
-          {initData && (
-            <Space direction="vertical" style={{ width: '100%' }} size={16}>
-              <Row gutter={[12, 8]}>
-                <Col span={24}>
-                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
-                    {t('cryptoTailMonitor.manualOrder.marketTitle')}
-                  </Text>
-                  <Text>{pushData?.marketTitle ?? initData.marketTitle}</Text>
-                </Col>
-                <Col span={24}>
-                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
-                    {t('cryptoTailMonitor.manualOrder.direction')}
-                  </Text>
-                  <Text
-                    strong
-                    style={{
-                      color: manualOrderModal.direction === 'UP' ? '#1890ff' : '#fa8c16'
-                    }}
-                  >
-                    {manualOrderModal.direction === 'UP'
-                      ? t('cryptoTailMonitor.manualOrder.directionUp')
-                      : t('cryptoTailMonitor.manualOrder.directionDown')}
-                  </Text>
-                </Col>
-                <Col span={24}>
-                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
-                    {t('cryptoTailMonitor.manualOrder.availableBalance')}
-                  </Text>
-                  <Text strong style={{ fontSize: 16, color: '#52c41a' }}>
-                    {manualOrderModal.availableBalance ? formatNumber(manualOrderModal.availableBalance, 2) : '-'} {t('cryptoTailMonitor.manualOrder.orderUnit')}
-                  </Text>
-                </Col>
-                <Col span={24}>
-                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
-                    {t('cryptoTailMonitor.manualOrder.orderPrice')} ({t('cryptoTailMonitor.manualOrder.orderUnit')})
-                  </Text>
-                  <Space.Compact style={{ width: '100%' }}>
-                    <InputNumber
-                      style={{ width: '100%' }}
-                      value={manualOrderModal.price ? parseFloat(manualOrderModal.price) : undefined}
-                      onChange={handlePriceChange}
-                      min={0}
-                      max={1}
-                      step={0.0001}
-                      precision={4}
-                      placeholder="0.0000"
-                    />
-                    <Button onClick={handleFetchLatestPrice} icon={<SyncOutlined />}>
-                      {t('cryptoTailMonitor.manualOrder.fetchLatestPrice')}
-                    </Button>
-                  </Space.Compact>
-                </Col>
-                <Col span={24}>
-                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
-                    {t('cryptoTailMonitor.manualOrder.orderSize')} ({t('cryptoTailMonitor.manualOrder.sizeUnit')})
-                  </Text>
-                  <Space.Compact style={{ width: '100%' }}>
-                    <InputNumber
-                      style={{ width: '100%' }}
-                      value={manualOrderModal.size ? parseFloat(manualOrderModal.size) : undefined}
-                      onChange={handleSizeChange}
-                      min={1}
-                      precision={2}
-                      placeholder="1"
-                    />
-                    <Button onClick={handleMaxSize} type="primary" ghost>
-                      {t('cryptoTailMonitor.manualOrder.maxSize')}
-                    </Button>
-                  </Space.Compact>
-                </Col>
-                <Col span={24}>
-                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
-                    {t('cryptoTailMonitor.manualOrder.totalAmount')}
-                  </Text>
-                  <Text strong style={{ fontSize: 16 }}>
-                    {manualOrderModal.totalAmount} {t('cryptoTailMonitor.manualOrder.orderUnit')}
-                  </Text>
-                </Col>
-                <Col span={24}>
-                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
-                    {t('cryptoTailMonitor.manualOrder.account')}
-                  </Text>
-                  <Text>{initData.accountName || `#${initData.accountId}`}</Text>
-                </Col>
-              </Row>
-            </Space>
-          )}
-        </Modal>
-      )}
-
-      {/* 移动端 BottomSheet 弹窗 */}
-      {isMobile && (
-        <AntdMobilePopup
-          visible={manualOrderModal.visible}
-          onMaskClick={handleCloseManualOrderModal}
-          onClose={handleCloseManualOrderModal}
-          bodyStyle={{
-            borderRadius: '16px 16px 0 0',
-            padding: '12px 16px',
-            maxHeight: '70vh',
-            overflow: 'auto'
-          }}
-        >
-          {initData && (
-            <div>
-              {/* 标题栏 */}
-              <div style={{
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'space-between',
-                marginBottom: 12
-              }}>
-                <Text strong style={{ fontSize: 16 }}>
-                  {t('cryptoTailMonitor.manualOrder.confirmTitle')}
-                </Text>
-                <Button type="text" onClick={handleCloseManualOrderModal} style={{ padding: 0, fontSize: 18 }}>
-                  ✕
-                </Button>
-              </div>
-
-              {/* 市场信息 + 方向 + 余额（一行） */}
-              <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 10, flexWrap: 'wrap', gap: 8 }}>
-                <div style={{ flex: '1 1 auto', minWidth: 0 }}>
-                  <Text type="secondary" style={{ fontSize: 12 }}>{t('cryptoTailMonitor.manualOrder.marketTitle')}: </Text>
-                  <Text style={{ fontSize: 13 }} ellipsis>{pushData?.marketTitle ?? initData.marketTitle}</Text>
-                </div>
-                <Text
-                  strong
-                  style={{
-                    fontSize: 14,
-                    color: manualOrderModal.direction === 'UP' ? '#1890ff' : '#fa8c16'
-                  }}
-                >
-                  {manualOrderModal.direction === 'UP'
-                    ? t('cryptoTailMonitor.manualOrder.directionUp')
-                    : t('cryptoTailMonitor.manualOrder.directionDown')}
-                </Text>
-              </div>
-
-              {/* 可用余额 */}
-              <div style={{ marginBottom: 10 }}>
-                <Text type="secondary" style={{ fontSize: 12 }}>
-                  {t('cryptoTailMonitor.manualOrder.availableBalance')}: 
-                </Text>
-                <Text strong style={{ fontSize: 14, color: '#52c41a', marginLeft: 4 }}>
-                  {manualOrderModal.availableBalance ? formatNumber(manualOrderModal.availableBalance, 2) : '-'} {t('cryptoTailMonitor.manualOrder.orderUnit')}
-                </Text>
-              </div>
-
-              {/* 价格输入 */}
-              <div style={{ marginBottom: 10 }}>
-                <Text type="secondary" style={{ display: 'block', marginBottom: 2, fontSize: 12 }}>
-                  {t('cryptoTailMonitor.manualOrder.orderPrice')}
-                </Text>
-                <Space.Compact style={{ width: '100%' }}>
-                  <InputNumber
-                    style={{ width: '100%', height: 36 }}
-                    value={manualOrderModal.price ? parseFloat(manualOrderModal.price) : undefined}
-                    onChange={handlePriceChange}
-                    min={0}
-                    max={1}
-                    step={0.0001}
-                    precision={4}
-                    placeholder="0.0000"
-                  />
-                  <Button onClick={handleFetchLatestPrice} icon={<SyncOutlined />} style={{ height: 36, fontSize: 12 }}>
-                    {t('cryptoTailMonitor.manualOrder.fetchLatestPrice')}
-                  </Button>
-                </Space.Compact>
-              </div>
-
-              {/* 数量输入 */}
-              <div style={{ marginBottom: 10 }}>
-                <Text type="secondary" style={{ display: 'block', marginBottom: 2, fontSize: 12 }}>
-                  {t('cryptoTailMonitor.manualOrder.orderSize')}
-                </Text>
-                <Space.Compact style={{ width: '100%' }}>
-                  <InputNumber
-                    style={{ width: '100%', height: 36 }}
-                    value={manualOrderModal.size ? parseFloat(manualOrderModal.size) : undefined}
-                    onChange={handleSizeChange}
-                    min={1}
-                    precision={2}
-                    placeholder="1"
-                  />
-                  <Button onClick={handleMaxSize} type="primary" ghost style={{ height: 36, fontSize: 12 }}>
-                    {t('cryptoTailMonitor.manualOrder.maxSize')}
-                  </Button>
-                </Space.Compact>
-              </div>
-
-              {/* 总金额 + 账户（一行） */}
-              <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 12 }}>
-                <div>
-                  <Text type="secondary" style={{ fontSize: 12 }}>{t('cryptoTailMonitor.manualOrder.totalAmount')}: </Text>
-                  <Text strong style={{ fontSize: 16, marginLeft: 4 }}>
-                    {manualOrderModal.totalAmount} {t('cryptoTailMonitor.manualOrder.orderUnit')}
-                  </Text>
-                </div>
-                <div>
-                  <Text type="secondary" style={{ fontSize: 12 }}>{t('cryptoTailMonitor.manualOrder.account')}: </Text>
-                  <Text style={{ fontSize: 12 }}>{initData.accountName || `#${initData.accountId}`}</Text>
-                </div>
-              </div>
-
-              {/* 确认按钮 */}
-              <Button
-                type="primary"
-                block
-                onClick={handleManualOrder}
-                loading={ordering}
-                style={{
-                  height: 44,
-                  borderRadius: 8,
-                  backgroundColor: manualOrderModal.direction === 'UP' ? '#1890ff' : '#fa8c16',
-                  borderColor: manualOrderModal.direction === 'UP' ? '#1890ff' : '#fa8c16'
-                }}
-              >
-                {t('cryptoTailMonitor.manualOrder.confirm')}
-              </Button>
-            </div>
-          )}
-        </AntdMobilePopup>
-      )}
-
-      {/* 移动端底部悬浮按钮 */}
-      {isMobile && (
-        <div
-          style={{
-            position: 'fixed',
-            bottom: 0,
-            left: 0,
-            right: 0,
-            zIndex: 1000,
-            padding: '12px 16px',
-            background: 'rgba(255, 255, 255, 0.95)',
-            backdropFilter: 'blur(10px)',
-            borderTop: '1px solid #f0f0f0',
-            boxShadow: '0 -2px 8px rgba(0, 0, 0, 0.06)'
-          }}
-        >
-          <div style={{ display: 'flex', width: '100%', gap: 0 }}>
-            <Button
-              type="primary"
-              icon={<ShoppingCartOutlined />}
-              disabled={!pushData || pushData.triggered || pushData.periodEnded}
-              onClick={() => handleOpenManualOrderModal('UP')}
-              loading={ordering}
-              style={{ flex: 1, backgroundColor: '#1890ff', borderColor: '#1890ff', height: 44, borderRadius: '6px 0 0 6px' }}
-            >
-              {t('cryptoTailMonitor.manualOrder.buttonUp')} {pushData?.currentPriceUp ? `(${formatNumber(pushData.currentPriceUp, 2)})` : ''}
-            </Button>
-            <Button
-              type="primary"
-              icon={<ShoppingCartOutlined />}
-              disabled={!pushData || pushData.triggered || pushData.periodEnded}
-              onClick={() => handleOpenManualOrderModal('DOWN')}
-              loading={ordering}
-              style={{ flex: 1, backgroundColor: '#fa8c16', borderColor: '#fa8c16', height: 44, borderRadius: '0 6px 6px 0' }}
-            >
-              {t('cryptoTailMonitor.manualOrder.buttonDown')} {pushData?.currentPriceDown ? `(${formatNumber(pushData.currentPriceDown, 2)})` : ''}
-            </Button>
-          </div>
-        </div>
-      )}
     </div>
   )
 }

frontend/src/pages/CryptoTailPnlCurveModal.tsx

@@ -1,149 +0,0 @@
-import { useEffect, useRef } from 'react'
-import { Modal, Row, Col, Statistic, Button, Space, Empty } from 'antd'
-import { useTranslation } from 'react-i18next'
-import { useMediaQuery } from 'react-responsive'
-import dayjs from 'dayjs'
-import * as echarts from 'echarts'
-import type { EChartsOption } from 'echarts'
-import { formatUSDC } from '../utils'
-import type { CryptoTailPnlCurveResponse } from '../types'
-
-export interface CryptoTailPnlCurveModalProps {
-  open: boolean
-  onClose: () => void
-  data: CryptoTailPnlCurveResponse | null
-  loading: boolean
-  strategyName: string
-  preset: 'today' | '7d' | '30d' | 'all'
-  onPresetChange: (preset: 'today' | '7d' | '30d' | 'all') => void
-  onRefresh: () => void
-}
-
-const CryptoTailPnlCurveModal: React.FC<CryptoTailPnlCurveModalProps> = (props) => {
-  const { open, onClose, data, loading, strategyName, preset, onPresetChange, onRefresh } = props
-  const { t } = useTranslation()
-  const isMobile = useMediaQuery({ maxWidth: 768 })
-  const chartRef = useRef<HTMLDivElement>(null)
-  const chartInstance = useRef<echarts.ECharts | null>(null)
-
-  useEffect(() => {
-    if (!open || !data?.curveData?.length || !chartRef.current) return
-    if (chartInstance.current) {
-      const dom = chartInstance.current.getDom()
-      if (!dom || !document.contains(dom)) {
-        chartInstance.current.dispose()
-        chartInstance.current = null
-      }
-    }
-    if (!chartInstance.current) chartInstance.current = echarts.init(chartRef.current)
-    const option: EChartsOption = {
-      tooltip: {
-        trigger: 'axis',
-        formatter: (params: unknown) => {
-          const arr = params as Array<{ value: [number, number] }>
-          const v = arr[0]?.value
-          if (!v) return ''
-          const d = data.curveData.find((p) => p.timestamp === v[0])
-          if (!d) return ''
-          return dayjs(v[0]).format('YYYY-MM-DD HH:mm') + '<br/>' + t('cryptoTailStrategy.pnlCurve.totalPnl') + ': ' + formatUSDC(d.cumulativePnl) + ' USDC'
-        }
-      },
-      grid: { left: '3%', right: '4%', bottom: '3%', top: '10%', containLabel: true },
-      xAxis: { type: 'time' },
-      yAxis: { type: 'value', axisLabel: { formatter: (val: number) => String(val) + ' USDC' } },
-      series: [{
-        name: t('cryptoTailStrategy.pnlCurve.totalPnl'),
-        type: 'line',
-        data: data.curveData.map((p) => [p.timestamp, parseFloat(p.cumulativePnl)]),
-        smooth: preset === 'all',
-        symbol: 'circle',
-        symbolSize: 4,
-        lineStyle: { width: 2, color: '#1890ff' },
-        areaStyle: {
-          color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
-            { offset: 0, color: 'rgba(24, 144, 255, 0.3)' },
-            { offset: 1, color: 'rgba(24, 144, 255, 0.05)' }
-          ])
-        }
-      }]
-    }
-    chartInstance.current.setOption(option, true)
-    chartInstance.current.resize()
-  }, [open, data, preset, t])
-
-  useEffect(() => {
-    if (!open) {
-      chartInstance.current?.dispose()
-      chartInstance.current = null
-    }
-  }, [open])
-
-  useEffect(() => {
-    if (!open || !chartInstance.current) return
-    const handleResize = () => chartInstance.current?.resize()
-    window.addEventListener('resize', handleResize)
-    return () => window.removeEventListener('resize', handleResize)
-  }, [open])
-
-  const pnlColor = (value: string | null | undefined): string | undefined => {
-    if (value == null || value === '') return undefined
-    const num = parseFloat(value)
-    if (Number.isNaN(num)) return undefined
-    if (num > 0) return '#52c41a'
-    if (num < 0) return '#ff4d4f'
-    return undefined
-  }
-
-  return (
-    <Modal
-      title={t('cryptoTailStrategy.pnlCurve.title') + ' - ' + strategyName}
-      open={open}
-      onCancel={onClose}
-      footer={null}
-      width={Math.min(800, window.innerWidth - 48)}
-      destroyOnClose
-    >
-      <Row gutter={[16, 16]} style={{ marginBottom: 16 }}>
-        <Col xs={12} sm={6}>
-          <Statistic
-            title={t('cryptoTailStrategy.pnlCurve.totalPnl')}
-            value={data?.totalRealizedPnl != null ? formatUSDC(data.totalRealizedPnl) : '-'}
-            suffix="USDC"
-            valueStyle={{ color: pnlColor(data?.totalRealizedPnl ?? null) }}
-          />
-        </Col>
-        <Col xs={12} sm={6}>
-          <Statistic title={t('cryptoTailStrategy.pnlCurve.settledCount')} value={data?.settledCount ?? 0} />
-        </Col>
-        <Col xs={12} sm={6}>
-          <Statistic
-            title={t('cryptoTailStrategy.pnlCurve.winRate')}
-            value={data?.winRate != null ? (Number(data.winRate) * 100).toFixed(1) + '%' : '-'}
-          />
-        </Col>
-        <Col xs={12} sm={6}>
-          <Statistic
-            title={t('cryptoTailStrategy.pnlCurve.maxDrawdown')}
-            value={data?.maxDrawdown != null ? '-' + formatUSDC(data.maxDrawdown) : '-'}
-            suffix="USDC"
-            valueStyle={{ color: data?.maxDrawdown ? '#ff4d4f' : undefined }}
-          />
-        </Col>
-      </Row>
-      <Space wrap style={{ marginBottom: 16 }}>
-        <Button size="small" type={preset === 'today' ? 'primary' : 'default'} onClick={() => onPresetChange('today')}>{t('cryptoTailStrategy.pnlCurve.today')}</Button>
-        <Button size="small" type={preset === '7d' ? 'primary' : 'default'} onClick={() => onPresetChange('7d')}>{t('cryptoTailStrategy.pnlCurve.last7Days')}</Button>
-        <Button size="small" type={preset === '30d' ? 'primary' : 'default'} onClick={() => onPresetChange('30d')}>{t('cryptoTailStrategy.pnlCurve.last30Days')}</Button>
-        <Button size="small" type={preset === 'all' ? 'primary' : 'default'} onClick={() => onPresetChange('all')}>{t('cryptoTailStrategy.pnlCurve.all')}</Button>
-        <Button size="small" onClick={onRefresh} loading={loading}>{t('common.refresh')}</Button>
-      </Space>
-      {!data && loading
-        ? <div style={{ height: 320, display: 'flex', alignItems: 'center', justifyContent: 'center' }}>{t('common.loading')}</div>
-        : !data?.curveData?.length
-          ? <Empty description={t('cryptoTailStrategy.pnlCurve.empty')} style={{ marginTop: 24 }} />
-          : <div ref={chartRef} style={{ width: '100%', height: isMobile ? 260 : 320 }} />}
-    </Modal>
-  )
-}
-
-export default CryptoTailPnlCurveModal

frontend/src/pages/CryptoTailStrategyList.tsx

@@ -21,19 +21,19 @@ import {
   Tabs,
   DatePicker,
   Empty,
-  Typography
+  Typography,
+  Divider
 } from 'antd'
 import type { Dayjs } from 'dayjs'
 import dayjs from 'dayjs'
-import { PlusOutlined, EditOutlined, UnorderedListOutlined, LineChartOutlined, InfoCircleOutlined, WarningOutlined, CalendarOutlined, FileTextOutlined, DeleteOutlined } from '@ant-design/icons'
+import { PlusOutlined, EditOutlined, UnorderedListOutlined, InfoCircleOutlined, WarningOutlined, CalendarOutlined, FileTextOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import { useMediaQuery } from 'react-responsive'
 import { apiService } from '../services/api'
 import { useAccountStore } from '../store/accountStore'
-import type { CryptoTailStrategyDto, CryptoTailStrategyTriggerDto, CryptoTailMarketOptionDto, CryptoTailPnlCurveResponse } from '../types'
+import type { CryptoTailStrategyDto, CryptoTailStrategyTriggerDto, CryptoTailMarketOptionDto } from '../types'
 import { formatUSDC, formatNumber } from '../utils'
 import { getVersionInfo } from '../utils/version'
-import CryptoTailPnlCurveModal from './CryptoTailPnlCurveModal'
 
 const CryptoTailStrategyList: React.FC = () => {
   const { t, i18n } = useTranslation()
@@ -59,14 +59,6 @@ const CryptoTailStrategyList: React.FC = () => {
   const [triggersLoading, setTriggersLoading] = useState(false)
   const [form] = Form.useForm()
 
-  const [pnlCurveModalOpen, setPnlCurveModalOpen] = useState(false)
-  const [pnlCurveStrategyId, setPnlCurveStrategyId] = useState<number | null>(null)
-  const [pnlCurveStrategyName, setPnlCurveStrategyName] = useState('')
-  const [pnlCurvePreset, setPnlCurvePreset] = useState<'today' | '7d' | '30d' | 'all'>('all')
-  const [pnlCurveCustomRange, setPnlCurveCustomRange] = useState<[Dayjs | null, Dayjs | null]>([null, null])
-  const [pnlCurveData, setPnlCurveData] = useState<CryptoTailPnlCurveResponse | null>(null)
-  const [pnlCurveLoading, setPnlCurveLoading] = useState(false)
-
   /** 币安 API 健康状态：仅保留「不可用」的项，用于强提醒 */
   const [binanceUnhealthy, setBinanceUnhealthy] = useState<Array<{ name: string; message: string }>>([])
   const [binanceCheckLoading, setBinanceCheckLoading] = useState(false)
@@ -336,61 +328,6 @@ const CryptoTailStrategyList: React.FC = () => {
     await loadTriggerRecords(strategyId, 'success', { page: 1, pageSize: 20, dateRange: [null, null] })
   }
 
-  const getPnlCurveTimeRange = (): { startDate?: number; endDate?: number } => {
-    if (pnlCurvePreset === 'all') return {}
-    const now = dayjs()
-    if (pnlCurvePreset === 'today') {
-      return { startDate: now.startOf('day').valueOf(), endDate: now.valueOf() }
-    }
-    if (pnlCurvePreset === '7d') {
-      return { startDate: now.subtract(7, 'day').startOf('day').valueOf(), endDate: now.valueOf() }
-    }
-    if (pnlCurvePreset === '30d') {
-      return { startDate: now.subtract(30, 'day').startOf('day').valueOf(), endDate: now.valueOf() }
-    }
-    if (pnlCurveCustomRange[0] != null && pnlCurveCustomRange[1] != null) {
-      return {
-        startDate: pnlCurveCustomRange[0].startOf('day').valueOf(),
-        endDate: pnlCurveCustomRange[1].endOf('day').valueOf()
-      }
-    }
-    return {}
-  }
-
-  const loadPnlCurve = async () => {
-    if (pnlCurveStrategyId == null) return
-    setPnlCurveLoading(true)
-    try {
-      const { startDate, endDate } = getPnlCurveTimeRange()
-      const res = await apiService.cryptoTailStrategy.pnlCurve({
-        strategyId: pnlCurveStrategyId,
-        startDate,
-        endDate
-      })
-      if (res.data.code === 0 && res.data.data) {
-        setPnlCurveData(res.data.data)
-      }
-    } catch (e) {
-      console.error('Failed to load PnL curve:', e)
-    } finally {
-      setPnlCurveLoading(false)
-    }
-  }
-
-  const openPnlCurve = (record: CryptoTailStrategyDto) => {
-    setPnlCurveStrategyId(record.id)
-    setPnlCurveStrategyName(record.name ?? record.marketTitle ?? record.marketSlugPrefix ?? '')
-    setPnlCurvePreset('all')
-    setPnlCurveCustomRange([null, null])
-    setPnlCurveModalOpen(true)
-  }
-
-  useEffect(() => {
-    if (pnlCurveModalOpen && pnlCurveStrategyId != null) {
-      loadPnlCurve()
-    }
-  }, [pnlCurveModalOpen, pnlCurveStrategyId, pnlCurvePreset, pnlCurveCustomRange])
-
   const onTriggerTabChange = (key: string) => {
     const next = key === 'success' ? 'success' : 'fail'
     setTriggerTab(next)
@@ -452,7 +389,7 @@ const CryptoTailStrategyList: React.FC = () => {
       title: t('common.status'),
       dataIndex: 'enabled',
       key: 'enabled',
-      width: 72,
+      width: 80,
       render: (enabled: boolean, record: CryptoTailStrategyDto) => (
         <Switch
           checked={enabled}
@@ -465,8 +402,7 @@ const CryptoTailStrategyList: React.FC = () => {
       title: t('cryptoTailStrategy.list.strategyName'),
       dataIndex: 'name',
       key: 'name',
-      width: isMobile ? 100 : 140,
-      ellipsis: true,
+      width: isMobile ? 100 : 160,
       render: (name: string | undefined, r: CryptoTailStrategyDto) => (
         <Typography.Text strong style={{ wordBreak: 'break-word', whiteSpace: 'normal' }}>
           {name || (r.marketTitle ?? r.marketSlugPrefix) || '-'}
@@ -477,8 +413,7 @@ const CryptoTailStrategyList: React.FC = () => {
       title: t('cryptoTailStrategy.list.account'),
       dataIndex: 'accountId',
       key: 'accountId',
-      width: isMobile ? 90 : 100,
-      ellipsis: true,
+      width: isMobile ? 90 : 120,
       render: (_: unknown, r: CryptoTailStrategyDto) => (
         <Typography.Text type="secondary" style={{ wordBreak: 'break-word', whiteSpace: 'normal' }}>
           {getAccountLabel(r.accountId)}
@@ -486,149 +421,99 @@ const CryptoTailStrategyList: React.FC = () => {
       )
     },
     {
-      title: t('cryptoTailStrategy.list.marketAndTime'),
-      key: 'marketAndTime',
-      width: isMobile ? 120 : 180,
+      title: t('cryptoTailStrategy.list.market'),
+      key: 'market',
+      width: isMobile ? 120 : 200,
       render: (_: unknown, r: CryptoTailStrategyDto) => (
-        <div>
-          <Typography.Text style={{ wordBreak: 'break-word', whiteSpace: 'normal', display: 'block' }}>
-            {marketOptions.find((m) => m.slug === r.marketSlugPrefix)?.title ?? r.marketTitle ?? r.marketSlugPrefix ?? '-'}
-          </Typography.Text>
-          <Typography.Text type="secondary" style={{ fontSize: 12, wordBreak: 'break-word', whiteSpace: 'pre-line' }}>
-            {formatTimeWindow(r.windowStartSeconds, r.windowEndSeconds, false)}
-          </Typography.Text>
-        </div>
+        <Typography.Text style={{ wordBreak: 'break-word', whiteSpace: 'normal' }}>
+          {marketOptions.find((m) => m.slug === r.marketSlugPrefix)?.title ?? r.marketTitle ?? r.marketSlugPrefix ?? '-'}
+        </Typography.Text>
       )
     },
     {
-      title: t('cryptoTailStrategy.list.config'),
-      key: 'config',
-      width: isMobile ? 100 : 140,
+      title: t('cryptoTailStrategy.list.timeWindow'),
+      key: 'timeWindow',
+      width: isMobile ? 100 : 120,
       render: (_: unknown, r: CryptoTailStrategyDto) => (
-        <div>
-          <Typography.Text type="secondary" style={{ fontSize: 12, display: 'block' }}>
-            {formatPriceRange(r.minPrice, r.maxPrice)}
-          </Typography.Text>
-          <Typography.Text type="secondary" style={{ fontSize: 12 }}>
-            {(r.amountMode?.toUpperCase() ?? '') === 'RATIO'
-              ? `${t('cryptoTailStrategy.list.ratio')} ${formatNumber(r.amountValue, 2) || '0'}%`
-              : `${t('cryptoTailStrategy.list.fixed')} ${formatUSDC(r.amountValue)}`}
-          </Typography.Text>
-        </div>
+        <Typography.Text type="secondary" style={{ wordBreak: 'break-word', whiteSpace: 'pre-line' }}>
+          {formatTimeWindow(r.windowStartSeconds, r.windowEndSeconds)}
+        </Typography.Text>
+      )
+    },
+    {
+      title: t('cryptoTailStrategy.list.priceRange'),
+      key: 'priceRange',
+      width: isMobile ? 90 : 120,
+      render: (_: unknown, r: CryptoTailStrategyDto) => (
+        <Typography.Text type="secondary" style={{ wordBreak: 'break-word', whiteSpace: 'normal' }}>
+          {formatPriceRange(r.minPrice, r.maxPrice)}
+        </Typography.Text>
+      )
+    },
+    {
+      title: t('cryptoTailStrategy.list.amountMode'),
+      key: 'amountMode',
+      width: isMobile ? 90 : 120,
+      render: (_: unknown, r: CryptoTailStrategyDto) => (
+        <Typography.Text type="secondary" style={{ wordBreak: 'break-word', whiteSpace: 'normal' }}>
+          {(r.amountMode?.toUpperCase() ?? '') === 'RATIO'
+            ? `${t('cryptoTailStrategy.list.ratio')} ${formatNumber(r.amountValue, 2) || '0'}%`
+            : `${t('cryptoTailStrategy.list.fixed')} ${formatUSDC(r.amountValue)} USDC`}
+        </Typography.Text>
       )
     },
     {
       title: t('cryptoTailStrategy.list.totalRealizedPnl'),
-      key: 'pnl',
+      key: 'totalRealizedPnl',
       width: isMobile ? 90 : 120,
       render: (_: unknown, r: CryptoTailStrategyDto) => {
-        const text = r.totalRealizedPnl != null ? formatUSDC(r.totalRealizedPnl) : '-'
+        const text = r.totalRealizedPnl != null ? `${formatUSDC(r.totalRealizedPnl)} USDC` : '-'
         const color = pnlColor(r.totalRealizedPnl)
-        return (
-          <div>
-            {color ? (
-              <Typography.Text style={{ color, fontWeight: 500 }}>{text}</Typography.Text>
-            ) : (
-              <Typography.Text type="secondary">{text}</Typography.Text>
-            )}
-            <Typography.Text type="secondary" style={{ fontSize: 12, display: 'block' }}>
-              {r.winRate != null ? `${(Number(r.winRate) * 100).toFixed(1)}%` : '-'}
-            </Typography.Text>
-          </div>
+        return color ? (
+          <Typography.Text style={{ color, fontWeight: 500 }}>{text}</Typography.Text>
+        ) : (
+          <Typography.Text type="secondary">{text}</Typography.Text>
         )
       }
     },
+    {
+      title: t('cryptoTailStrategy.list.winRate'),
+      key: 'winRate',
+      width: isMobile ? 70 : 90,
+      render: (_: unknown, r: CryptoTailStrategyDto) =>
+        r.winRate != null ? (
+          <Tag color="blue">{(Number(r.winRate) * 100).toFixed(1)}%</Tag>
+        ) : (
+          <Typography.Text type="secondary">-</Typography.Text>
+        )
+    },
     {
       title: t('cryptoTailStrategy.list.actions'),
       key: 'actions',
-      width: isMobile ? 120 : 140,
+      width: isMobile ? 120 : 200,
       fixed: 'right' as const,
       render: (_: unknown, record: CryptoTailStrategyDto) => (
-        <Space size={4}>
-          <Tooltip title={t('cryptoTailStrategy.list.edit')}>
-            <div
-              onClick={() => openEditModal(record)}
-              style={{
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-                width: '32px',
-                height: '32px',
-                cursor: 'pointer',
-                borderRadius: '6px',
-                transition: 'background-color 0.2s'
-              }}
-              onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#f0f0f0' }}
-              onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
-            >
-              <EditOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-            </div>
-          </Tooltip>
-
-          <Tooltip title={t('cryptoTailStrategy.list.viewTriggers')}>
-            <div
-              onClick={() => openTriggers(record.id)}
-              style={{
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-                width: '32px',
-                height: '32px',
-                cursor: 'pointer',
-                borderRadius: '6px',
-                transition: 'background-color 0.2s'
-              }}
-              onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#f0f0f0' }}
-              onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
-            >
-              <UnorderedListOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-            </div>
-          </Tooltip>
-
-          <Tooltip title={t('cryptoTailStrategy.list.viewPnlCurve')}>
-            <div
-              onClick={() => openPnlCurve(record)}
-              style={{
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-                width: '32px',
-                height: '32px',
-                cursor: 'pointer',
-                borderRadius: '6px',
-                transition: 'background-color 0.2s'
-              }}
-              onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#f0f0f0' }}
-              onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
-            >
-              <LineChartOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-            </div>
-          </Tooltip>
-
+        <Space size="small" wrap>
+          <Button type="link" size="small" icon={<EditOutlined />} onClick={() => openEditModal(record)}>
+            {t('cryptoTailStrategy.list.edit')}
+          </Button>
+          <Button
+            type="link"
+            size="small"
+            icon={<UnorderedListOutlined />}
+            onClick={() => openTriggers(record.id)}
+          >
+            {t('cryptoTailStrategy.list.viewTriggers')}
+          </Button>
           <Popconfirm
             title={t('cryptoTailStrategy.list.deleteConfirm')}
             onConfirm={() => handleDelete(record.id)}
             okText={t('common.confirm')}
             cancelText={t('common.cancel')}
           >
-            <Tooltip title={t('cryptoTailStrategy.list.delete')}>
-              <div
-                style={{
-                  display: 'flex',
-                  alignItems: 'center',
-                  justifyContent: 'center',
-                  width: '32px',
-                  height: '32px',
-                  cursor: 'pointer',
-                  borderRadius: '6px',
-                  transition: 'background-color 0.2s'
-                }}
-                onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#fff1f0' }}
-                onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
-              >
-                <DeleteOutlined style={{ fontSize: '16px', color: '#ff4d4f' }} />
-              </div>
-            </Tooltip>
+            <Button type="link" size="small" danger>
+              {t('cryptoTailStrategy.list.delete')}
+            </Button>
           </Popconfirm>
         </Space>
       )
@@ -658,28 +543,17 @@ const CryptoTailStrategyList: React.FC = () => {
   }
 
   return (
-    <div style={{ padding: isMobile ? 0 : 24 }}>
-      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px', flexWrap: 'wrap', gap: '12px', padding: isMobile ? '0 8px' : 0 }}>
-        <div style={{ display: 'flex', alignItems: 'center', gap: 12, flexWrap: 'wrap' }}>
-          <h2 style={{ margin: 0, fontSize: isMobile ? '20px' : '24px' }}>{t('cryptoTailStrategy.list.title')}</h2>
-          <Button
-            type="link"
-            icon={<FileTextOutlined />}
-            onClick={() => window.open(getGuideUrl(), '_blank')}
-            style={{ padding: 0, height: 'auto', fontSize: isMobile ? 14 : 16 }}
-          >
-            {t('cryptoTailStrategy.list.configGuide')}
-          </Button>
-        </div>
-        <Tooltip title={t('cryptoTailStrategy.list.addStrategy')}>
-          <Button
-            type="primary"
-            icon={<PlusOutlined />}
-            onClick={openAddModal}
-            size={isMobile ? 'middle' : 'large'}
-            style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}
-          />
-        </Tooltip>
+    <div style={{ padding: isMobile ? 12 : 24 }}>
+      <div style={{ display: 'flex', alignItems: 'center', gap: 12, marginBottom: 16, flexWrap: 'wrap' }}>
+        <h1 style={{ margin: 0, fontSize: isMobile ? 20 : 24 }}>{t('cryptoTailStrategy.list.title')}</h1>
+        <Button
+          type="link"
+          icon={<FileTextOutlined />}
+          onClick={() => window.open(getGuideUrl(), '_blank')}
+          style={{ padding: 0, height: 'auto', fontSize: isMobile ? 14 : 16 }}
+        >
+          {t('cryptoTailStrategy.list.configGuide')}
+        </Button>
       </div>
       {binanceUnhealthy.length > 0 && list.some((s) => s.enabled) && (
         <Alert
@@ -709,17 +583,20 @@ const CryptoTailStrategyList: React.FC = () => {
               </Button>
             </div>
           }
-          style={{ marginBottom: 16, margin: isMobile ? '0 8px 16px' : undefined }}
+          style={{ marginBottom: 16 }}
         />
       )}
       <Alert
         type="warning"
         showIcon
         message={t('cryptoTailStrategy.list.walletTip')}
-        style={{ marginBottom: 16, margin: isMobile ? '0 8px 16px' : undefined }}
+        style={{ marginBottom: 16 }}
       />
-      <Card style={{ borderRadius: isMobile ? 0 : '12px', boxShadow: '0 2px 8px rgba(0,0,0,0.08)', border: isMobile ? 'none' : '1px solid #e8e8e8' }} styles={{ body: { padding: isMobile ? 12 : 24 } }}>
+      <Card>
         <div style={{ marginBottom: 16, display: 'flex', flexWrap: 'wrap', gap: 8, alignItems: 'center' }}>
+          <Button type="primary" icon={<PlusOutlined />} onClick={openAddModal}>
+            {t('cryptoTailStrategy.list.addStrategy')}
+          </Button>
           <Select
             placeholder={t('cryptoTailStrategy.form.selectAccount')}
             allowClear
@@ -742,86 +619,86 @@ const CryptoTailStrategyList: React.FC = () => {
         </div>
         <Spin spinning={loading}>
           {isMobile ? (
-            <div style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
-              {list.map((item) => {
-                const accountLabel = getAccountLabel(item.accountId)
-                const marketTitle = marketOptions.find((m) => m.slug === item.marketSlugPrefix)?.title ?? item.marketTitle ?? item.marketSlugPrefix ?? '-'
-                return (
-                  <Card
-                    key={item.id}
-                    style={{
-                      marginBottom: 0,
-                      borderRadius: '10px',
-                      boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
-                      border: '1px solid #e8e8e8',
-                      overflow: 'hidden'
-                    }}
-                    bodyStyle={{ padding: 0 }}
-                  >
-                    <div style={{
-                      padding: '10px 12px',
-                      background: item.enabled ? 'var(--ant-color-primary, #1677ff)' : 'var(--ant-color-fill-secondary, #f0f0f0)',
-                      color: item.enabled ? '#fff' : 'var(--ant-color-text-secondary, #666)'
-                    }}>
-                      <div style={{ fontSize: '15px', fontWeight: '600', display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
-                        <span style={{ wordBreak: 'break-word', whiteSpace: 'normal' }}>{item.name || marketTitle || '-'}</span>
-                        <Switch checked={item.enabled} onChange={() => handleToggle(item)} size="small" />
-                      </div>
-                    </div>
-                    <div style={{ padding: '8px 12px', backgroundColor: '#fafafa', borderBottom: '1px solid #f0f0f0' }}>
-                      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
-                        <div>
-                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>{t('cryptoTailStrategy.list.totalRealizedPnl')}</div>
-                          {item.totalRealizedPnl != null ? (
-                            <div style={{ fontSize: '14px', fontWeight: '600', color: pnlColor(item.totalRealizedPnl) }}>{formatUSDC(item.totalRealizedPnl)} USDC</div>
-                          ) : (
-                            <div style={{ fontSize: '14px', color: '#8c8c8c' }}>-</div>
-                          )}
-                        </div>
-                        <div style={{ textAlign: 'right' }}>
-                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>{t('cryptoTailStrategy.list.winRate')}</div>
-                          {item.winRate != null ? <Tag color="blue" style={{ margin: 0 }}>{(Number(item.winRate) * 100).toFixed(1)}%</Tag> : <span style={{ fontSize: '12px', color: '#8c8c8c' }}>-</span>}
-                        </div>
-                      </div>
-                    </div>
-                    <div style={{ padding: '6px 12px', fontSize: '11px', color: '#8c8c8c', borderBottom: '1px solid #f0f0f0' }}>
-                      <div>{t('cryptoTailStrategy.list.account')}: {accountLabel}</div>
-                      <div>{t('cryptoTailStrategy.list.market')}: {marketTitle}</div>
-                    </div>
-                    <div style={{ padding: '6px 12px', fontSize: '11px', color: '#8c8c8c', borderBottom: '1px solid #f0f0f0' }}>
-                      {t('cryptoTailStrategy.list.timeWindow')}: {formatTimeWindow(item.windowStartSeconds, item.windowEndSeconds, false)} · {t('cryptoTailStrategy.list.priceRange')}: {formatPriceRange(item.minPrice, item.maxPrice)}
-                    </div>
-                    <div style={{ padding: '8px 12px', display: 'flex', justifyContent: 'space-around', alignItems: 'center' }}>
-                      <Tooltip title={t('cryptoTailStrategy.list.edit')}>
-                        <div onClick={() => openEditModal(item)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                          <EditOutlined style={{ fontSize: '18px', color: '#52c41a' }} />
-                          <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('cryptoTailStrategy.list.edit')}</span>
-                        </div>
-                      </Tooltip>
-                      <Tooltip title={t('cryptoTailStrategy.list.viewTriggers')}>
-                        <div onClick={() => openTriggers(item.id)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                          <UnorderedListOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                          <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('cryptoTailStrategy.list.viewTriggers')}</span>
-                        </div>
-                      </Tooltip>
-                      <Tooltip title={t('cryptoTailStrategy.list.viewPnlCurve')}>
-                        <div onClick={() => openPnlCurve(item)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                          <LineChartOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                          <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('cryptoTailStrategy.list.viewPnlCurve')}</span>
-                        </div>
-                      </Tooltip>
-                      <Popconfirm title={t('cryptoTailStrategy.list.deleteConfirm')} onConfirm={() => handleDelete(item.id)} okText={t('common.confirm')} cancelText={t('common.cancel')}>
-                        <Tooltip title={t('cryptoTailStrategy.list.delete')}>
-                          <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                            <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
-                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('cryptoTailStrategy.list.delete')}</span>
-                          </div>
-                        </Tooltip>
-                      </Popconfirm>
-                    </div>
-                  </Card>
-                )
-              })}
+            <div style={{ display: 'flex', flexDirection: 'column', gap: 16 }}>
+              {list.map((item) => (
+                <Card
+                  key={item.id}
+                  size="small"
+                  styles={{ body: { padding: 16 } }}
+                  style={{ borderLeft: `3px solid ${item.enabled ? 'var(--ant-colorSuccess)' : 'var(--ant-colorBorder)'}` }}
+                >
+                  <Typography.Text strong style={{ fontSize: 15, wordBreak: 'break-word', whiteSpace: 'normal', display: 'block', marginBottom: 8 }}>
+                    {item.name || (item.marketTitle ?? item.marketSlugPrefix) || '-'}
+                  </Typography.Text>
+                  <Typography.Text type="secondary" style={{ display: 'block', marginBottom: 4, fontSize: 13, wordBreak: 'break-word', whiteSpace: 'normal' }}>
+                    {t('cryptoTailStrategy.list.account')}: {getAccountLabel(item.accountId)}
+                  </Typography.Text>
+                  <Typography.Text type="secondary" style={{ display: 'block', marginBottom: 8, fontSize: 13, wordBreak: 'break-word', whiteSpace: 'normal' }}>
+                    {marketOptions.find((m) => m.slug === item.marketSlugPrefix)?.title ?? item.marketSlugPrefix ?? '-'}
+                  </Typography.Text>
+                  <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '6px 16px', marginBottom: 12 }}>
+                    <Typography.Text type="secondary" style={{ fontSize: 12, wordBreak: 'break-word', whiteSpace: 'normal' }}>
+                      {t('cryptoTailStrategy.list.timeWindow')}
+                    </Typography.Text>
+                    <Typography.Text style={{ fontSize: 12 }}>{formatTimeWindow(item.windowStartSeconds, item.windowEndSeconds, false)}</Typography.Text>
+                    <Typography.Text type="secondary" style={{ fontSize: 12, wordBreak: 'break-word', whiteSpace: 'normal' }}>
+                      {t('cryptoTailStrategy.list.priceRange')}
+                    </Typography.Text>
+                    <Typography.Text style={{ fontSize: 12, wordBreak: 'break-word', whiteSpace: 'normal' }}>{formatPriceRange(item.minPrice, item.maxPrice)}</Typography.Text>
+                    <Typography.Text type="secondary" style={{ fontSize: 12, wordBreak: 'break-word', whiteSpace: 'normal' }}>
+                      {t('cryptoTailStrategy.list.amountMode')}
+                    </Typography.Text>
+                    <Typography.Text style={{ fontSize: 12, wordBreak: 'break-word', whiteSpace: 'normal' }}>
+                      {(item.amountMode?.toUpperCase() ?? '') === 'RATIO'
+                        ? `${t('cryptoTailStrategy.list.ratio')} ${formatNumber(item.amountValue, 2) || '0'}%`
+                        : `${t('cryptoTailStrategy.list.fixed')} ${formatUSDC(item.amountValue)} USDC`}
+                    </Typography.Text>
+                  </div>
+                  <Divider style={{ margin: '10px 0' }} />
+                  <Space wrap style={{ marginBottom: 12 }}>
+                    <Typography.Text type="secondary" style={{ fontSize: 12 }}>
+                      {t('cryptoTailStrategy.list.totalRealizedPnl')}:{' '}
+                    </Typography.Text>
+                    {item.totalRealizedPnl != null ? (
+                      <Typography.Text style={{ color: pnlColor(item.totalRealizedPnl) ?? undefined, fontWeight: 500, fontSize: 12 }}>
+                        {formatUSDC(item.totalRealizedPnl)} USDC
+                      </Typography.Text>
+                    ) : (
+                      <Typography.Text type="secondary" style={{ fontSize: 12 }}>-</Typography.Text>
+                    )}
+                    {item.winRate != null && (
+                      <>
+                        <Typography.Text type="secondary" style={{ fontSize: 12 }}>·</Typography.Text>
+                        <Tag color="blue" style={{ margin: 0 }}>{t('cryptoTailStrategy.list.winRate')} {(Number(item.winRate) * 100).toFixed(1)}%</Tag>
+                      </>
+                    )}
+                  </Space>
+                  <Divider style={{ margin: '10px 0' }} />
+                  <Space wrap size="small">
+                    <Switch
+                      checked={item.enabled}
+                      onChange={() => handleToggle(item)}
+                      size="small"
+                    />
+                    <Button type="link" size="small" icon={<EditOutlined />} onClick={() => openEditModal(item)}>
+                      {t('cryptoTailStrategy.list.edit')}
+                    </Button>
+                    <Button type="link" size="small" icon={<UnorderedListOutlined />} onClick={() => openTriggers(item.id)}>
+                      {t('cryptoTailStrategy.list.viewTriggers')}
+                    </Button>
+                    <Popconfirm
+                      title={t('cryptoTailStrategy.list.deleteConfirm')}
+                      onConfirm={() => handleDelete(item.id)}
+                      okText={t('common.confirm')}
+                      cancelText={t('common.cancel')}
+                    >
+                      <Button type="link" size="small" danger>
+                        {t('cryptoTailStrategy.list.delete')}
+                      </Button>
+                    </Popconfirm>
+                  </Space>
+                </Card>
+              ))}
             </div>
           ) : (
             <Table
@@ -829,7 +706,7 @@ const CryptoTailStrategyList: React.FC = () => {
               columns={columns}
               dataSource={list}
               pagination={{ pageSize: 20 }}
-              scroll={{ x: 720 }}
+              scroll={{ x: 900 }}
             />
           )}
         </Spin>
@@ -858,17 +735,6 @@ const CryptoTailStrategyList: React.FC = () => {
         <p>{t('cryptoTailStrategy.redeemRequiredModal.description')}</p>
       </Modal>
 
-      <CryptoTailPnlCurveModal
-        open={pnlCurveModalOpen}
-        onClose={() => setPnlCurveModalOpen(false)}
-        data={pnlCurveData}
-        loading={pnlCurveLoading}
-        strategyName={pnlCurveStrategyName}
-        preset={pnlCurvePreset}
-        onPresetChange={setPnlCurvePreset}
-        onRefresh={loadPnlCurve}
-      />
-
       <Modal
         title={editingId ? t('cryptoTailStrategy.form.update') : t('cryptoTailStrategy.form.create')}
         open={formModalOpen}

frontend/src/pages/LeaderList.tsx

@@ -1,7 +1,7 @@
 import { useEffect, useState } from 'react'
 import { useNavigate } from 'react-router-dom'
-import { Card, Table, Button, Space, Tag, Popconfirm, message, List, Empty, Spin, Divider, Typography, Modal, Descriptions, Statistic, Row, Col, Tooltip, Badge } from 'antd'
-import { PlusOutlined, EditOutlined, DeleteOutlined, GlobalOutlined, EyeOutlined, ReloadOutlined, WalletOutlined, CopyOutlined, LineChartOutlined } from '@ant-design/icons'
+import { Card, Table, Button, Space, Tag, Popconfirm, message, List, Empty, Spin, Divider, Typography, Modal, Descriptions, Statistic, Row, Col } from 'antd'
+import { PlusOutlined, EditOutlined, DeleteOutlined, GlobalOutlined, EyeOutlined, ReloadOutlined, WalletOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import { apiService } from '../services/api'
 import type { Leader, LeaderBalanceResponse } from '../types'
@@ -225,11 +225,11 @@ const LeaderList: React.FC = () => {
       title: t('leaderList.leaderName'),
       dataIndex: 'leaderName',
       key: 'leaderName',
-      width: 200,
+      width: 150,
       render: (text: string, record: Leader) => (
         <Space direction="vertical" size={0}>
           <Text strong style={{ fontSize: '14px' }}>{text || `Leader ${record.id}`}</Text>
-          <Text type="secondary" style={{ fontSize: '12px', fontFamily: 'monospace' }}>{record.leaderAddress}</Text>
+          <Text type="secondary" style={{ fontSize: '12px' }}>{record.leaderAddress}</Text>
         </Space>
       )
     },
@@ -237,155 +237,76 @@ const LeaderList: React.FC = () => {
       title: t('leaderList.remark'),
       dataIndex: 'remark',
       key: 'remark',
-      width: 180,
+      width: 200,
       ellipsis: true,
       render: (remark: string | undefined) => {
         if (!remark) return <Text type="secondary">-</Text>
-        return <Text ellipsis={{ tooltip: remark }} style={{ maxWidth: 160 }}>{remark}</Text>
+        return <Text ellipsis={{ tooltip: remark }} style={{ maxWidth: 180 }}>{remark}</Text>
       }
     },
     {
       title: t('leaderDetail.availableBalance'),
       key: 'balance',
-      width: 180,
+      width: 150,
       render: (_: any, record: Leader) => {
         const balance = balanceMap[record.id]
         if (!balance) return <Spin size="small" />
-        return (
-          <Space direction="vertical" size={0}>
-            <Text style={{ color: '#52c41a', fontSize: '14px', fontWeight: '500' }}>
-              {balance.available === '-' ? '-' : `${formatUSDC(balance.available)} USDC`}
-            </Text>
-            <Text type="secondary" style={{ fontSize: '12px' }}>
-              {t('leaderDetail.positionBalance')}: {formatUSDC(balance.position)}
-            </Text>
-          </Space>
-        )
+        const displayText = balance.available === '-' ? '-' : `${formatUSDC(balance.available)} USDC`
+        return <Text style={{ color: '#1890ff', fontSize: '14px' }}>{displayText}</Text>
       }
     },
+    {
+      title: t('leaderList.copyTradingCount'),
+      dataIndex: 'copyTradingCount',
+      key: 'copyTradingCount',
+      width: 100,
+      render: (count: number, record: Leader) => (
+        <Button
+          type="link"
+          size="small"
+          onClick={() => navigate(`/copy-trading?leaderId=${record.id}`)}
+          disabled={count === 0}
+          style={{ padding: 0 }}
+        >
+          <Tag color="cyan">{count}</Tag>
+        </Button>
+      )
+    },
+    {
+      title: t('leaderList.backtestCount'),
+      dataIndex: 'backtestCount',
+      key: 'backtestCount',
+      width: 100,
+      render: (count: number, record: Leader) => (
+        <Button
+          type="link"
+          size="small"
+          onClick={() => navigate(`/backtest?leaderId=${record.id}`)}
+          disabled={count === 0}
+          style={{ padding: 0 }}
+        >
+          <Tag color="purple">{count}</Tag>
+        </Button>
+      )
+    },
     {
       title: t('common.actions'),
       key: 'action',
-      width: 200,
+      width: isMobile ? 180 : 250,
       fixed: 'right' as const,
       render: (_: any, record: Leader) => (
-        <Space size={4}>
-          <Tooltip title={t('common.viewDetail')}>
-            <div
-              onClick={() => handleShowDetail(record)}
-              style={{
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-                width: '32px',
-                height: '32px',
-                cursor: 'pointer',
-                borderRadius: '6px',
-                transition: 'background-color 0.2s'
-              }}
-              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
-              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-            >
-              <EyeOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-            </div>
-          </Tooltip>
-
+        <Space size="small" wrap>
+          <Button type="link" size="small" icon={<EyeOutlined />} onClick={() => handleShowDetail(record)}>
+            {t('common.viewDetail')}
+          </Button>
           {record.website && (
-            <Tooltip title={t('leaderList.openWebsite')}>
-              <div
-                onClick={() => window.open(record.website, '_blank', 'noopener,noreferrer')}
-                style={{
-                  display: 'flex',
-                  alignItems: 'center',
-                  justifyContent: 'center',
-                  width: '32px',
-                  height: '32px',
-                  cursor: 'pointer',
-                  borderRadius: '6px',
-                  transition: 'background-color 0.2s'
-                }}
-                onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
-                onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-              >
-                <GlobalOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-              </div>
-            </Tooltip>
+            <Button type="link" size="small" icon={<GlobalOutlined />} onClick={() => window.open(record.website, '_blank', 'noopener,noreferrer')}>
+              {t('leaderList.openWebsite')}
+            </Button>
           )}
-
-          <Tooltip title={t('common.edit')}>
-            <div
-              onClick={() => navigate(`/leaders/edit?id=${record.id}`)}
-              style={{
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-                width: '32px',
-                height: '32px',
-                cursor: 'pointer',
-                borderRadius: '6px',
-                transition: 'background-color 0.2s'
-              }}
-              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
-              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-            >
-              <EditOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-            </div>
-          </Tooltip>
-
-          <Tooltip title={`${t('leaderList.viewCopyTradings')} (${record.copyTradingCount})`}>
-            <div
-              onClick={() => {
-                if (record.copyTradingCount > 0) {
-                  navigate(`/copy-trading?leaderId=${record.id}`)
-                }
-              }}
-              style={{
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-                width: '32px',
-                height: '32px',
-                cursor: record.copyTradingCount === 0 ? 'not-allowed' : 'pointer',
-                borderRadius: '6px',
-                opacity: record.copyTradingCount === 0 ? 0.4 : 1,
-                transition: 'background-color 0.2s'
-              }}
-              onMouseEnter={(e) => record.copyTradingCount > 0 && (e.currentTarget.style.backgroundColor = '#f0f0f0')}
-              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-            >
-              <Badge count={record.copyTradingCount} size="small" offset={[-4, -4]}>
-                <CopyOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-              </Badge>
-            </div>
-          </Tooltip>
-
-          <Tooltip title={`${t('leaderList.viewBacktests')} (${record.backtestCount})`}>
-            <div
-              onClick={() => {
-                if (record.backtestCount > 0) {
-                  navigate(`/backtest?leaderId=${record.id}`)
-                }
-              }}
-              style={{
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-                width: '32px',
-                height: '32px',
-                cursor: record.backtestCount === 0 ? 'not-allowed' : 'pointer',
-                borderRadius: '6px',
-                opacity: record.backtestCount === 0 ? 0.4 : 1,
-                transition: 'background-color 0.2s'
-              }}
-              onMouseEnter={(e) => record.backtestCount > 0 && (e.currentTarget.style.backgroundColor = '#f0f0f0')}
-              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-            >
-              <Badge count={record.backtestCount} size="small" offset={[-4, -4]}>
-                <LineChartOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-              </Badge>
-            </div>
-          </Tooltip>
-
+          <Button type="link" size="small" icon={<EditOutlined />} onClick={() => navigate(`/leaders/edit?id=${record.id}`)}>
+            {t('common.edit')}
+          </Button>
           <Popconfirm
             title={t('leaderList.deleteConfirm')}
             description={record.copyTradingCount > 0 ? t('leaderList.deleteConfirmDesc', { count: record.copyTradingCount }) : undefined}
@@ -393,24 +314,9 @@ const LeaderList: React.FC = () => {
             okText={t('common.confirm')}
             cancelText={t('common.cancel')}
           >
-            <Tooltip title={t('common.delete')}>
-              <div
-                style={{
-                  display: 'flex',
-                  alignItems: 'center',
-                  justifyContent: 'center',
-                  width: '32px',
-                  height: '32px',
-                  cursor: 'pointer',
-                  borderRadius: '6px',
-                  transition: 'background-color 0.2s'
-                }}
-                onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#fff1f0'}
-                onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-              >
-                <DeleteOutlined style={{ fontSize: '16px', color: '#ff4d4f' }} />
-              </div>
-            </Tooltip>
+            <Button type="link" size="small" danger icon={<DeleteOutlined />}>
+              {t('common.delete')}
+            </Button>
           </Popconfirm>
         </Space>
       )
@@ -421,9 +327,9 @@ const LeaderList: React.FC = () => {
     <div>
       <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px', flexWrap: 'wrap', gap: '12px' }}>
         <h2 style={{ margin: 0, fontSize: isMobile ? '20px' : '24px' }}>{t('leaderList.title')}</h2>
-        <Tooltip title={t('leaderList.addLeader')}>
-          <Button type="primary" icon={<PlusOutlined />} onClick={() => navigate('/leaders/add')} size={isMobile ? 'middle' : 'large'} style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }} />
-        </Tooltip>
+        <Button type="primary" icon={<PlusOutlined />} onClick={() => navigate('/leaders/add')} size={isMobile ? 'middle' : 'large'} style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}>
+          {t('leaderList.addLeader')}
+        </Button>
       </div>
 
       <Card style={{ borderRadius: '12px', boxShadow: '0 2px 8px rgba(0,0,0,0.08)', border: '1px solid #e8e8e8' }} bodyStyle={{ padding: isMobile ? '12px' : '24px' }}>
@@ -442,145 +348,69 @@ const LeaderList: React.FC = () => {
                   const balance = balanceMap[leader.id]
 
                   return (
-                    <Card
-                      key={leader.id}
-                      style={{
-                        marginBottom: '10px',
-                        borderRadius: '10px',
-                        boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
-                        border: '1px solid #e8e8e8',
-                        overflow: 'hidden'
-                      }}
-                      bodyStyle={{ padding: '0' }}
-                    >
-                      {/* 头部区域 - 名称和地址 */}
-                      <div style={{
-                        padding: '10px 12px',
-                        background: 'var(--ant-color-primary, #1677ff)',
-                        color: '#fff'
-                      }}>
-                        <div style={{ fontSize: '15px', fontWeight: '600', marginBottom: '2px', display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
-                          <span>{leader.leaderName || `Leader ${leader.id}`}</span>
-                          {leader.website && (
-                            <GlobalOutlined
-                              style={{ fontSize: '13px', cursor: 'pointer', opacity: 0.8 }}
-                              onClick={() => window.open(leader.website, '_blank', 'noopener,noreferrer')}
-                            />
-                          )}
+                    <Card key={leader.id} style={{ marginBottom: '16px', borderRadius: '12px', boxShadow: '0 2px 6px rgba(0,0,0,0.06)', border: '1px solid #f0f0f0' }} bodyStyle={{ padding: '16px' }}>
+                      <div style={{ marginBottom: '12px' }}>
+                        <div style={{ fontSize: '16px', fontWeight: 'bold', marginBottom: '6px', color: '#1890ff' }}>
+                          {leader.leaderName || `Leader ${leader.id}`}
                         </div>
-                        <div style={{ fontSize: '10px', opacity: '0.85', fontFamily: 'monospace', wordBreak: 'break-all' }}>
+                        <div style={{ fontSize: '12px', color: '#666', fontFamily: 'monospace', wordBreak: 'break-all' }}>
                           {leader.leaderAddress}
                         </div>
                       </div>
 
-                      {/* 资产区域 - 常驻显示 */}
-                      <div style={{
-                        padding: '8px 12px',
-                        backgroundColor: '#fafafa',
-                        borderBottom: '1px solid #f0f0f0',
-                        minHeight: '42px',
-                        display: 'flex',
-                        alignItems: 'center'
-                      }}>
-                        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', width: '100%' }}>
-                          <div>
-                            <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
-                              {t('leaderDetail.availableBalance')}
-                            </div>
-                            <div style={{ fontSize: '14px', fontWeight: '600', color: '#52c41a' }}>
-                              {balance?.available && balance.available !== '-' ? `${formatUSDC(balance.available)} USDC` : '- USDC'}
-                            </div>
+                      {balance && (
+                        <div style={{ marginBottom: '12px', padding: '12px', backgroundColor: '#f6ffed', borderRadius: '8px', border: '1px solid #b7eb8f' }}>
+                          <div style={{ fontSize: '13px', color: '#52c41a', fontWeight: 'bold', marginBottom: '4px' }}>
+                            {t('leaderDetail.availableBalance')}: {balance.available === '-' ? '-' : `${formatUSDC(balance.available)} USDC`}
                           </div>
-                          <div style={{ textAlign: 'right' }}>
-                            <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
-                              {t('leaderDetail.positionBalance')}
-                            </div>
-                            <div style={{ fontSize: '14px', fontWeight: '500', color: '#722ed1' }}>
-                              {balance?.position && balance.position !== '-' ? formatUSDC(balance.position) : '-'}
-                            </div>
+                          <div style={{ fontSize: '11px', color: '#666' }}>
+                            {t('leaderDetail.positionBalance')}: {formatUSDC(balance.position)}
                           </div>
                         </div>
-                      </div>
-
-                      {/* 备注区域 */}
-                      {leader.remark && (
-                        <div style={{
-                          padding: '6px 12px',
-                          backgroundColor: '#fffbe6',
-                          borderBottom: '1px solid #ffe58f',
-                          fontSize: '11px',
-                          color: '#8c8c8c'
-                        }}>
-                          <span style={{ color: '#d48806' }}>{t('leaderList.remark')}：</span>
-                          <span>{leader.remark}</span>
-                        </div>
                       )}
 
-                      {/* 图标操作栏 */}
-                      <div style={{
-                        padding: '8px 12px',
-                        display: 'flex',
-                        justifyContent: 'space-around',
-                        alignItems: 'center'
-                      }}>
-                        <Tooltip title={t('common.viewDetail')}>
-                          <div
-                            onClick={() => handleShowDetail(leader)}
-                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
-                          >
-                            <EyeOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.viewDetail')}</span>
-                          </div>
-                        </Tooltip>
+                      <Divider style={{ margin: '12px 0' }} />
 
-                        <Tooltip title={t('common.edit')}>
-                          <div
-                            onClick={() => navigate(`/leaders/edit?id=${leader.id}`)}
-                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
-                          >
-                            <EditOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.edit')}</span>
-                          </div>
-                        </Tooltip>
+                      <div style={{ display: 'flex', gap: '8px', marginBottom: '12px', flexWrap: 'wrap' }}>
+                        <Button
+                          type="default"
+                          size="small"
+                          onClick={() => navigate(`/copy-trading?leaderId=${leader.id}`)}
+                          disabled={leader.copyTradingCount === 0}
+                          style={{ borderRadius: '6px', padding: '8px 16px' }}
+                        >
+                          {t('leaderList.viewCopyTradings')} ({leader.copyTradingCount})
+                        </Button>
+                        <Button
+                          type="default"
+                          size="small"
+                          onClick={() => navigate(`/backtest?leaderId=${leader.id}`)}
+                          disabled={leader.backtestCount === 0}
+                          style={{ borderRadius: '6px', padding: '8px 16px' }}
+                        >
+                          {t('leaderList.viewBacktests')} ({leader.backtestCount})
+                        </Button>
+                      </div>
 
-                        <Tooltip title={t('leaderList.viewCopyTradings')}>
-                          <div
-                            onClick={() => navigate(`/copy-trading?leaderId=${leader.id}`)}
-                            style={{
-                              display: 'flex',
-                              flexDirection: 'column',
-                              alignItems: 'center',
-                              cursor: leader.copyTradingCount === 0 ? 'not-allowed' : 'pointer',
-                              padding: '4px 8px',
-                              opacity: leader.copyTradingCount === 0 ? 0.4 : 1
-                            }}
-                          >
-                            <Badge count={leader.copyTradingCount} size="small" offset={[-2, -2]}>
-                              <CopyOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                            </Badge>
-                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('leaderList.viewCopyTradings')}</span>
-                          </div>
-                        </Tooltip>
-
-                        <Tooltip title={t('leaderList.viewBacktests')}>
-                          <div
-                            onClick={() => navigate(`/backtest?leaderId=${leader.id}`)}
-                            style={{
-                              display: 'flex',
-                              flexDirection: 'column',
-                              alignItems: 'center',
-                              cursor: leader.backtestCount === 0 ? 'not-allowed' : 'pointer',
-                              padding: '4px 8px',
-                              opacity: leader.backtestCount === 0 ? 0.4 : 1
-                            }}
-                          >
-                            <Badge count={leader.backtestCount} size="small" offset={[-2, -2]}>
-                              <LineChartOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                            </Badge>
-                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('leaderList.viewBacktests')}</span>
-                          </div>
-                        </Tooltip>
+                      {leader.remark && (
+                        <div style={{ marginBottom: '12px' }}>
+                          <Text type="secondary" style={{ fontSize: '12px' }}>{t('leaderList.remark')}：</Text>
+                          <Text style={{ fontSize: '12px', marginLeft: '4px' }}>{leader.remark}</Text>
+                        </div>
+                      )}
 
+                      <div style={{ display: 'flex', gap: '8px', flexWrap: 'wrap' }}>
+                        <Button type="primary" size="small" icon={<EyeOutlined />} onClick={() => handleShowDetail(leader)} style={{ flex: 1, minWidth: '80px', borderRadius: '6px', padding: '8px 16px' }}>
+                          {t('common.viewDetail')}
+                        </Button>
+                        {leader.website && (
+                          <Button type="default" size="small" icon={<GlobalOutlined />} onClick={() => window.open(leader.website, '_blank', 'noopener,noreferrer')} style={{ flex: 1, minWidth: '80px', borderRadius: '6px', padding: '8px 16px' }}>
+                            {t('leaderList.openWebsite')}
+                          </Button>
+                        )}
+                        <Button type="default" size="small" icon={<EditOutlined />} onClick={() => navigate(`/leaders/edit?id=${leader.id}`)} style={{ flex: 1, minWidth: '80px', borderRadius: '6px', padding: '8px 16px' }}>
+                          {t('common.edit')}
+                        </Button>
                         <Popconfirm
                           title={t('leaderList.deleteConfirm')}
                           description={leader.copyTradingCount > 0 ? t('leaderList.deleteConfirmDesc', { count: leader.copyTradingCount }) : undefined}
@@ -588,12 +418,9 @@ const LeaderList: React.FC = () => {
                           okText={t('common.confirm')}
                           cancelText={t('common.cancel')}
                         >
-                          <Tooltip title={t('common.delete')}>
-                            <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                              <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
-                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.delete')}</span>
-                            </div>
-                          </Tooltip>
+                          <Button type="primary" danger size="small" icon={<DeleteOutlined />} style={{ flex: 1, minWidth: '80px', borderRadius: '6px', padding: '8px 16px' }}>
+                            {t('common.delete')}
+                          </Button>
                         </Popconfirm>
                       </div>
                     </Card>

frontend/src/pages/NotificationSettingsPage.tsx

@@ -1,718 +0,0 @@
-import React, { useEffect, useState, useCallback } from 'react'
-import { Card, Table, Button, Space, Tag, Popconfirm, message, Typography, Modal, Form, Input, Switch, Tooltip, Row, Col, Tabs } from 'antd'
-import { PlusOutlined, EditOutlined, DeleteOutlined, SendOutlined, ReloadOutlined, CheckOutlined, RobotOutlined, FormOutlined } from '@ant-design/icons'
-import { useTranslation } from 'react-i18next'
-import { apiService } from '../services/api'
-import type { NotificationConfig, NotificationConfigRequest, NotificationConfigUpdateRequest, NotificationTemplate, TemplateTypeInfo, TemplateVariablesResponse, TemplateVariable } from '../types'
-import { useMediaQuery } from 'react-responsive'
-import { TelegramConfigForm } from '../components/notifications'
-import TextArea from 'antd/es/input/TextArea'
-
-const { Title, Text, Paragraph } = Typography
-
-const variableTagStyle: React.CSSProperties = {
-  display: 'inline-flex',
-  alignItems: 'center',
-  cursor: 'pointer',
-  marginBottom: 6,
-  marginRight: 6,
-  borderRadius: 6,
-  padding: '4px 10px',
-  fontSize: 12,
-  transition: 'all 0.2s ease',
-  border: '1px solid #e8e8e8',
-  background: '#ffffff',
-  color: 'rgba(0, 0, 0, 0.65)',
-}
-
-const variableTagHoverStyle: React.CSSProperties = {
-  borderColor: '#1890ff',
-  background: '#e6f7ff',
-  color: '#1890ff',
-  transform: 'translateY(-1px)',
-  boxShadow: '0 2px 4px rgba(24, 144, 255, 0.2)',
-}
-
-/**
- * 变量分类标签映射
- */
-const CATEGORY_LABELS: Record<string, string> = {
-  common: 'notificationSettings.templates.commonVariables',
-  order: 'notificationSettings.templates.orderVariables',
-  copy_trading: 'notificationSettings.templates.copyTradingVariables',
-  redeem: 'notificationSettings.templates.redeemVariables',
-  error: 'notificationSettings.templates.errorVariables',
-  filter: 'notificationSettings.templates.filterVariables',
-  strategy: 'notificationSettings.templates.strategyVariables'
-}
-
-const NotificationSettingsPage: React.FC = () => {
-  const { t } = useTranslation()
-  const isMobile = useMediaQuery({ maxWidth: 768 })
-
-  // 机器人配置相关状态
-  const [configs, setConfigs] = useState<NotificationConfig[]>([])
-  const [loading, setLoading] = useState(false)
-  const [modalVisible, setModalVisible] = useState(false)
-  const [editingConfig, setEditingConfig] = useState<NotificationConfig | null>(null)
-  const [form] = Form.useForm()
-  const [testLoading, setTestLoading] = useState(false)
-
-  // 模板配置相关状态
-  const [templateTypes, setTemplateTypes] = useState<TemplateTypeInfo[]>([])
-  const [selectedTemplateType, setSelectedTemplateType] = useState<string>('ORDER_SUCCESS')
-  const [currentTemplate, setCurrentTemplate] = useState<NotificationTemplate | null>(null)
-  const [templateVariables, setTemplateVariables] = useState<TemplateVariablesResponse | null>(null)
-  const [templateContent, setTemplateContent] = useState('')
-  const [testTemplateLoading, setTestTemplateLoading] = useState(false)
-
-  // 加载机器人配置
-  useEffect(() => {
-    fetchConfigs()
-  }, [])
-
-  // 加载模板类型
-  useEffect(() => {
-    fetchTemplateTypes()
-  }, [])
-
-  // 当选中的模板类型改变时，加载模板详情和变量
-  useEffect(() => {
-    if (selectedTemplateType) {
-      fetchTemplateDetail(selectedTemplateType)
-      fetchTemplateVariables(selectedTemplateType)
-    }
-  }, [selectedTemplateType])
-
-  const fetchConfigs = async () => {
-    setLoading(true)
-    try {
-      const response = await apiService.notifications.list({ type: 'telegram' })
-      if (response.data.code === 0 && response.data.data) {
-        setConfigs(response.data.data)
-      } else {
-        message.error(response.data.msg || t('notificationSettings.fetchFailed'))
-      }
-    } catch (error: any) {
-      message.error(error.message || t('notificationSettings.fetchFailed'))
-    } finally {
-        setLoading(false)
-      }
-  }
-
-  const fetchTemplateTypes = async () => {
-    try {
-      const response = await apiService.notifications.getTemplateTypes()
-      if (response.data.code === 0 && response.data.data) {
-        setTemplateTypes(response.data.data)
-      }
-    } catch (error) {
-        console.error('获取模板类型失败:', error)
-      }
-  }
-
-  const fetchTemplateDetail = async (templateType: string) => {
-    try {
-      const response = await apiService.notifications.getTemplateDetail({ templateType })
-      if (response.data.code === 0 && response.data.data) {
-        setCurrentTemplate(response.data.data)
-        setTemplateContent(response.data.data.templateContent)
-      }
-    } catch (error) {
-        console.error('获取模板详情失败:', error)
-      }
-  }
-
-  const fetchTemplateVariables = async (templateType: string) => {
-    try {
-      const response = await apiService.notifications.getTemplateVariables({ templateType })
-      if (response.data.code === 0 && response.data.data) {
-        setTemplateVariables(response.data.data)
-      }
-    } catch (error) {
-        console.error('获取模板变量失败:', error)
-      }
-  }
-
-  // 机器人配置相关方法
-  const handleCreate = () => {
-    setEditingConfig(null)
-    form.resetFields()
-    form.setFieldsValue({
-      type: 'telegram',
-      enabled: true,
-      config: {
-        botToken: '',
-        chatIds: []
-      }
-    })
-    setModalVisible(true)
-  }
-
-  const handleEdit = (config: NotificationConfig) => {
-    setEditingConfig(config)
-    let botToken = ''
-    let chatIds = ''
-
-    if (config.config) {
-      if ('data' in config.config && config.config.data) {
-        const data = config.config.data as any
-        botToken = data.botToken || ''
-        if (data.chatIds) {
-          if (Array.isArray(data.chatIds)) {
-            chatIds = data.chatIds.join(',')
-          } else if (typeof data.chatIds === 'string') {
-            chatIds = data.chatIds
-          }
-        }
-      } else {
-        if ('botToken' in config.config) {
-          botToken = (config.config as any).botToken || ''
-        }
-        if ('chatIds' in config.config) {
-          const ids = (config.config as any).chatIds
-          if (Array.isArray(ids)) {
-            chatIds = ids.join(',')
-          } else if (typeof ids === 'string') {
-            chatIds = ids
-          }
-        }
-      }
-    }
-
-    form.setFieldsValue({
-      type: config.type,
-      name: config.name,
-      enabled: config.enabled,
-      config: {
-        botToken: botToken,
-        chatIds: chatIds
-      }
-    })
-    setModalVisible(true)
-  }
-
-  const handleDelete = async (id: number) => {
-    try {
-      const response = await apiService.notifications.delete({ id })
-      if (response.data.code === 0) {
-        message.success(t('notificationSettings.deleteSuccess'))
-        fetchConfigs()
-      } else {
-        message.error(response.data.msg || t('notificationSettings.deleteFailed'))
-      }
-    } catch (error: any) {
-      message.error(error.message || t('notificationSettings.deleteFailed'))
-    }
-  }
-
-  const handleUpdateEnabled = async (id: number, enabled: boolean) => {
-    try {
-      const response = await apiService.notifications.updateEnabled({ id, enabled })
-      if (response.data.code === 0) {
-        message.success(enabled ? t('notificationSettings.enableSuccess') : t('notificationSettings.disableSuccess'))
-        fetchConfigs()
-      } else {
-        message.error(response.data.msg || t('notificationSettings.updateStatusFailed'))
-      }
-    } catch (error: any) {
-      message.error(error.message || t('notificationSettings.updateStatusFailed'))
-    }
-  }
-
-  const handleTest = async () => {
-    setTestLoading(true)
-    try {
-      const response = await apiService.notifications.test({ message: '这是一条测试消息' })
-      if (response.data.code === 0 && response.data.data) {
-        message.success(t('notificationSettings.testSuccess'))
-      } else {
-        message.error(response.data.msg || t('notificationSettings.testFailed'))
-      }
-    } catch (error: any) {
-      message.error(error.message || t('notificationSettings.testFailed'))
-    } finally {
-      setTestLoading(false)
-    }
-  }
-
-  const handleSubmit = async () => {
-    try {
-      const values = await form.validateFields()
-      const chatIds = typeof values.config.chatIds === 'string'
-        ? values.config.chatIds.split(',').map((id: string) => id.trim()).filter((id: string) => id)
-        : values.config.chatIds || []
-
-      const configData: NotificationConfigRequest | NotificationConfigUpdateRequest = {
-        type: values.type,
-        name: values.name,
-        enabled: values.enabled,
-        config: {
-          botToken: values.config.botToken,
-          chatIds: chatIds
-        }
-      }
-
-      if (editingConfig?.id) {
-        const updateData = {
-          ...configData,
-          id: editingConfig.id
-        } as NotificationConfigUpdateRequest
-        const response = await apiService.notifications.update(updateData)
-        if (response.data.code === 0) {
-          message.success(t('notificationSettings.updateSuccess'))
-          setModalVisible(false)
-          fetchConfigs()
-        } else {
-          message.error(response.data.msg || t('notificationSettings.updateFailed'))
-        }
-      } else {
-        const response = await apiService.notifications.create(configData)
-        if (response.data.code === 0) {
-          message.success(t('notificationSettings.createSuccess'))
-          setModalVisible(false)
-          fetchConfigs()
-        } else {
-          message.error(response.data.msg || t('notificationSettings.createFailed'))
-        }
-      }
-    } catch (error: any) {
-      if (error.errorFields) {
-        return
-      }
-      message.error(error.message || t('message.error'))
-    }
-  }
-
-  const getConfigFormComponent = (type: string) => {
-    switch (type?.toLowerCase()) {
-      case 'telegram':
-        return <TelegramConfigForm form={form} />
-      default:
-        return null
-    }
-  }
-
-  // 模板配置相关方法
-  const handleTemplateTypeChange = (type: string) => {
-    setSelectedTemplateType(type)
-  }
-
-  const handleTemplateContentChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
-    setTemplateContent(e.target.value)
-  }
-
-  const handleSaveTemplate = async () => {
-    try {
-      const response = await apiService.notifications.updateTemplate({
-        templateType: selectedTemplateType,
-        templateContent: templateContent
-      })
-      if (response.data.code === 0) {
-        message.success(t('notificationSettings.templates.saveSuccess'))
-        fetchTemplateDetail(selectedTemplateType)
-      } else {
-        message.error(response.data.msg || t('notificationSettings.templates.saveFailed'))
-      }
-    } catch (error: any) {
-      message.error(error.message || t('notificationSettings.templates.saveFailed'))
-    }
-  }
-
-  const handleResetTemplate = async () => {
-    try {
-      const response = await apiService.notifications.resetTemplate({
-        templateType: selectedTemplateType
-      })
-      if (response.data.code === 0) {
-        message.success(t('notificationSettings.templates.resetSuccess'))
-        fetchTemplateDetail(selectedTemplateType)
-      } else {
-        message.error(response.data.msg || t('notificationSettings.templates.resetFailed'))
-      }
-    } catch (error: any) {
-      message.error(error.message || t('notificationSettings.templates.resetFailed'))
-    }
-  }
-
-  const handleTestTemplate = async () => {
-    setTestTemplateLoading(true)
-    try {
-      const response = await apiService.notifications.testTemplate({
-        templateType: selectedTemplateType,
-        templateContent: templateContent
-      })
-      if (response.data.code === 0 && response.data.data) {
-        message.success(t('notificationSettings.templates.testSuccess'))
-      } else {
-        message.error(response.data.msg || t('notificationSettings.templates.testFailed'))
-      }
-    } catch (error: any) {
-      message.error(error.message || t('notificationSettings.templates.testFailed'))
-    } finally {
-      setTestTemplateLoading(false)
-    }
-  }
-
-  const handleCopyVariable = useCallback((variable: string) => {
-    const text = `{{${variable}}}`
-
-    if (navigator.clipboard && window.isSecureContext) {
-      navigator.clipboard.writeText(text).then(() => {
-        message.success(t('notificationSettings.templates.copied'))
-      }).catch(() => {
-        fallbackCopy(text)
-      })
-    } else {
-      fallbackCopy(text)
-    }
-
-    function fallbackCopy(text: string) {
-      const textArea = document.createElement('textarea')
-      textArea.value = text
-      textArea.style.position = 'fixed'
-      textArea.style.left = '-9999px'
-      textArea.style.top = '-9999px'
-      document.body.appendChild(textArea)
-      textArea.focus()
-      textArea.select()
-      try {
-        document.execCommand('copy')
-        message.success(t('notificationSettings.templates.copied'))
-      } catch {
-        message.error(t('common.copyFailed'))
-      }
-      document.body.removeChild(textArea)
-    }
-  }, [t])
-
-  const [variableHoverKey, setVariableHoverKey] = useState<string | null>(null)
-
-  const renderVariableItem = (variable: TemplateVariable) => {
-    const isHover = variableHoverKey === variable.key
-    const label = t(`notificationSettings.templates.variableLabels.${variable.key}`)
-    const description = t(`notificationSettings.templates.variableDescriptions.${variable.key}`)
-    const variableElement = (
-      <span
-        role="button"
-        tabIndex={0}
-        style={{ ...variableTagStyle, ...(isHover && !isMobile ? variableTagHoverStyle : {}) }}
-        onClick={() => handleCopyVariable(variable.key)}
-        onMouseEnter={() => !isMobile && setVariableHoverKey(variable.key)}
-        onMouseLeave={() => !isMobile && setVariableHoverKey(null)}
-        onKeyDown={(e) => e.key === 'Enter' && handleCopyVariable(variable.key)}
-      >
-        <span style={{ fontFamily: 'monospace' }}>{label}</span>
-      </span>
-    )
-
-    if (isMobile) {
-      return (
-        <span key={variable.key} style={{ display: 'inline-block' }}>
-          {variableElement}
-        </span>
-      )
-    }
-
-    return (
-      <Tooltip key={variable.key} title={description || `{{${variable.key}}}`} placement="top">
-        {variableElement}
-      </Tooltip>
-    )
-  }
-
-  const renderVariablesPanel = () => {
-    if (!templateVariables) return null
-
-    return (
-      <Card
-        size="small"
-        title={
-          <span style={{ fontSize: 13, fontWeight: 500 }}>
-            {t('notificationSettings.templates.variables')}
-          </span>
-        }
-        style={{ height: '100%', borderRadius: 8 }}
-        bodyStyle={{ padding: '12px 16px', maxHeight: 420, overflowY: 'auto' }}
-      >
-        {templateVariables.categories.map(category => {
-          const categoryVariables = templateVariables.variables.filter(v => v.category === category.key)
-          if (categoryVariables.length === 0) return null
-          return (
-            <div key={category.key} style={{ marginBottom: 16 }}>
-              <Text type="secondary" style={{ marginBottom: 8, display: 'block', fontSize: 12 }}>
-                {t(CATEGORY_LABELS[category.key])}
-              </Text>
-              <div style={{ display: 'flex', flexWrap: 'wrap' }}>
-                {categoryVariables.sort((a, b) => a.sortOrder - b.sortOrder).map(renderVariableItem)}
-              </div>
-            </div>
-          )
-        })}
-        <Paragraph type="secondary" style={{ marginTop: 12, marginBottom: 0, fontSize: 11, textAlign: 'center' }}>
-          {t('notificationSettings.templates.clickToCopy')}
-        </Paragraph>
-      </Card>
-    )
-  }
-
-  // 机器人配置表格列
-  const configColumns = [
-    {
-      title: t('notificationSettings.configName'),
-      dataIndex: 'name',
-      key: 'name',
-    },
-    {
-      title: t('notificationSettings.type'),
-      dataIndex: 'type',
-      key: 'type',
-      render: (type: string) => <Tag color="blue">{type.toUpperCase()}</Tag>
-    },
-    {
-      title: t('notificationSettings.status'),
-      dataIndex: 'enabled',
-      key: 'enabled',
-      render: (enabled: boolean) => (
-        <Tag color={enabled ? 'green' : 'default'}>
-          {enabled ? t('notificationSettings.enabledStatus') : t('notificationSettings.disabledStatus')}
-        </Tag>
-      )
-    },
-    {
-      title: t('notificationSettings.chatIds'),
-      key: 'chatIds',
-      render: (_: any, record: NotificationConfig) => {
-        let chatIds: string[] = []
-        if (record.config) {
-          if ('data' in record.config && record.config.data) {
-            const data = (record.config as any).data
-            if (data.chatIds) {
-              if (Array.isArray(data.chatIds)) {
-                chatIds = data.chatIds.filter((id: any) => id && String(id).trim())
-              } else if (typeof data.chatIds === 'string') {
-                chatIds = data.chatIds.split(',').map((id: string) => id.trim()).filter((id: string) => id)
-              }
-            }
-          } else if ('chatIds' in record.config) {
-            const ids = (record.config as any).chatIds
-            if (Array.isArray(ids)) {
-              chatIds = ids.filter((id: any) => id && String(id).trim())
-            } else if (typeof ids === 'string') {
-              chatIds = (ids as string).split(',').map((id: string) => id.trim()).filter((id: string) => id)
-            }
-          }
-        }
-        return chatIds.length > 0 ? (
-          <Text type="secondary" style={{ fontSize: '12px' }}>
-            {chatIds.join(', ')}
-          </Text>
-        ) : (
-          <Text type="danger" style={{ fontSize: '12px' }}>{t('notificationSettings.chatIdsNotConfigured')}</Text>
-        )
-      }
-    },
-    {
-      title: t('common.actions'),
-      key: 'action',
-      width: isMobile ? 120 : 200,
-      render: (_: any, record: NotificationConfig) => (
-        <Space size="small" wrap>
-          <Button
-            type="link"
-            size="small"
-            icon={<EditOutlined />}
-            onClick={() => handleEdit(record)}
-          >
-            {t('notificationSettings.edit')}
-          </Button>
-          <Switch
-            checked={record.enabled}
-            size="small"
-            onChange={(checked) => handleUpdateEnabled(record.id!, checked)}
-          />
-          <Button
-            type="link"
-            size="small"
-            icon={<SendOutlined />}
-            loading={testLoading}
-            onClick={handleTest}
-          >
-            {t('notificationSettings.test')}
-          </Button>
-          <Popconfirm
-            title={t('notificationSettings.deleteConfirm')}
-            onConfirm={() => handleDelete(record.id!)}
-            okText={t('common.confirm')}
-            cancelText={t('common.cancel')}
-          >
-            <Button
-              type="link"
-              danger
-              size="small"
-              icon={<DeleteOutlined />}
-            >
-              {t('notificationSettings.delete')}
-            </Button>
-          </Popconfirm>
-        </Space>
-      )
-    }
-  ]
-
-  const templateTypeTabItems = templateTypes.map(type => ({
-    key: type.type,
-    label: (
-      <Tooltip title={t(`notificationSettings.templateTypeDescriptions.${type.type}`)} placement="top">
-        <span>{t(`notificationSettings.templateTypes.${type.type}`)}</span>
-      </Tooltip>
-    ),
-  }))
-
-  return (
-    <div>
-      <div style={{ marginBottom: '16px' }}>
-        <Title level={2} style={{ margin: 0 }}>{t('notificationSettings.title')}</Title>
-      </div>
-
-      {/* 机器人配置 */}
-      <Card
-        title={
-          <Space>
-            <RobotOutlined />
-            <span>{t('notificationSettings.botConfig')}</span>
-          </Space>
-        }
-        style={{ marginBottom: '16px' }}
-        extra={
-          <Button type="primary" icon={<PlusOutlined />} onClick={handleCreate}>
-            {t('notificationSettings.addConfig')}
-          </Button>
-        }
-      >
-        <Table
-          columns={configColumns}
-          dataSource={configs}
-          loading={loading}
-          rowKey="id"
-          pagination={false}
-          scroll={{ x: isMobile ? 600 : 'auto' }}
-        />
-      </Card>
-
-      {/* 模板配置 */}
-      <Card
-        title={
-          <Space>
-            <FormOutlined />
-            <span>{t('notificationSettings.templateConfig')}</span>
-          </Space>
-        }
-        style={{ marginBottom: '16px' }}
-      >
-        <Tabs
-          activeKey={selectedTemplateType}
-          onChange={handleTemplateTypeChange}
-          items={templateTypeTabItems}
-          style={{ marginBottom: 16 }}
-          tabBarStyle={{ marginBottom: 0 }}
-          type={isMobile ? 'line' : 'card'}
-          size={isMobile ? 'small' : 'middle'}
-        />
-        
-        <Row gutter={[16, 16]}>
-          <Col xs={24} sm={24} md={17}>
-            <Card size="small" bordered={false} style={{ background: '#fafafa', marginBottom: 12, borderRadius: 8 }} bodyStyle={{ padding: '10px 16px' }}>
-              <div style={{ display: 'flex', flexWrap: 'wrap', gap: 8, alignItems: 'center', justifyContent: 'space-between' }}>
-                <Space wrap size="small">
-                  <Text type="secondary" style={{ fontSize: 13 }}>{t('notificationSettings.templates.templateContent')}</Text>
-                  {currentTemplate && (
-                    <Tag color={currentTemplate.isDefault ? 'green' : 'blue'} style={{ margin: 0 }}>
-                      {currentTemplate.isDefault ? t('notificationSettings.templates.isDefault') : t('notificationSettings.templates.isCustom')}
-                    </Tag>
-                  )}
-                </Space>
-                <Space wrap size="small">
-                  <Popconfirm
-                    title={t('notificationSettings.templates.resetConfirm')}
-                    onConfirm={handleResetTemplate}
-                    okText={t('common.confirm')}
-                    cancelText={t('common.cancel')}
-                  >
-                    <Button size="small" icon={<ReloadOutlined />}>
-                      {t('notificationSettings.templates.resetToDefault')}
-                    </Button>
-                  </Popconfirm>
-                  <Button size="small" type="primary" icon={<CheckOutlined />} onClick={handleSaveTemplate}>
-                    {t('common.save')}
-                  </Button>
-                  <Button size="small" icon={<SendOutlined />} loading={testTemplateLoading} onClick={handleTestTemplate}>
-                    {t('notificationSettings.test')}
-                  </Button>
-                </Space>
-              </div>
-            </Card>
-            <TextArea
-              value={templateContent}
-              onChange={handleTemplateContentChange}
-              rows={isMobile ? 15 : 16}
-              style={{ fontFamily: 'monospace', fontSize: 13, borderRadius: 8, resize: 'none' }}
-              placeholder={t('notificationSettings.templates.contentPlaceholder')}
-            />
-          </Col>
-          <Col xs={24} sm={24} md={7}>
-            {renderVariablesPanel()}
-          </Col>
-        </Row>
-      </Card>
-
-      <Modal
-        title={editingConfig ? t('notificationSettings.editConfig') : t('notificationSettings.addConfig')}
-        open={modalVisible}
-        onOk={handleSubmit}
-        onCancel={() => setModalVisible(false)}
-        width={isMobile ? '90%' : 600}
-        okText={t('common.confirm')}
-        cancelText={t('common.cancel')}
-      >
-        <Form
-          form={form}
-          layout="vertical"
-        >
-          <Form.Item
-            name="type"
-            label={t('notificationSettings.type')}
-            rules={[{ required: true, message: t('notificationSettings.typeRequired') }]}
-          >
-            <Input disabled value="telegram" />
-          </Form.Item>
-          <Form.Item
-            name="name"
-            label={t('notificationSettings.configName')}
-            rules={[{ required: true, message: t('notificationSettings.configNameRequired') }]}
-          >
-            <Input placeholder={t('notificationSettings.configNamePlaceholder')} />
-          </Form.Item>
-          <Form.Item
-            name="enabled"
-            label={t('notificationSettings.enabled')}
-            valuePropName="checked"
-          >
-            <Switch />
-          </Form.Item>
-          <Form.Item shouldUpdate={(prevValues, currentValues) => {
-            return prevValues.type !== currentValues.type ||
-                   prevValues.config !== currentValues.config
-          }}>
-            {() => {
-              const currentType = form.getFieldValue('type') || 'telegram'
-              return getConfigFormComponent(currentType)
-            }}
-          </Form.Item>
-        </Form>
-      </Modal>
-    </div>
-  )
-}
-
-export default NotificationSettingsPage

frontend/src/pages/PositionList.tsx

@@ -833,7 +833,7 @@ const PositionList: React.FC = () => {
     )
   }
 
-  // 根据仓位类型动态生成列（优化后的紧凑布局）
+  // 根据仓位类型动态生成列（历史仓位不显示当前价格、当前价值、状态列）
   const columns = useMemo(() => {
     const baseColumns: any[] = [
       {
@@ -853,6 +853,7 @@ const PositionList: React.FC = () => {
                 objectFit: 'cover'
               }}
               onError={(e) => {
+                // 图片加载失败时隐藏
                 e.currentTarget.style.display = 'none'
               }}
             />
@@ -875,7 +876,7 @@ const PositionList: React.FC = () => {
           </div>
         ),
         fixed: isMobile ? ('left' as const) : undefined,
-        width: isMobile ? 120 : 160
+        width: isMobile ? 150 : 200
       },
       {
         title: '市场',
@@ -923,7 +924,7 @@ const PositionList: React.FC = () => {
             </div>
           )
         },
-        width: isMobile ? 180 : 220
+        width: isMobile ? 200 : 250
       },
       {
         title: '方向',
@@ -932,76 +933,136 @@ const PositionList: React.FC = () => {
         render: (side: string) => (
           <Tag color={getSideColor(side)}>{side}</Tag>
         ),
-        width: 70
+        width: 80
       },
       {
-        title: '持仓',
-        key: 'position',
-        render: (_: any, record: AccountPosition) => (
-          <div>
-            <div style={{ fontWeight: '500' }}>{formatNumber(record.quantity, 4)}</div>
-            <div style={{ fontSize: '12px', color: '#999' }}>@{formatNumber(record.avgPrice, 4)}</div>
-          </div>
-        ),
+        title: '数量',
+        dataIndex: 'quantity',
+        key: 'quantity',
+        render: (quantity: string) => formatNumber(quantity, 4),
         align: 'right' as const,
         width: 100
       },
+      {
+        title: '平均价格',
+        dataIndex: 'avgPrice',
+        key: 'avgPrice',
+        render: (price: string) => formatNumber(price, 4),
+        align: 'right' as const,
+        width: 120
+      },
       {
         title: '开仓价值',
         dataIndex: 'initialValue',
         key: 'initialValue',
         render: (value: string) => (
-          <span>{formatUSDC(value)} USDC</span>
+          <span>
+            {formatUSDC(value)} USDC
+          </span>
         ),
         align: 'right' as const,
-        width: 110
+        width: 120
       },
     ]
 
-    // 只有当前仓位才显示当前价值/盈亏合并列
+    // 只有当前仓位才显示当前价格和当前价值列
     if (positionFilter === 'current') {
-      baseColumns.push({
-        title: '当前价值 / 盈亏',
-        key: 'valueAndPnl',
-        render: (_: any, record: AccountPosition) => {
-          const pnlNum = parseFloat(record.pnl || '0')
-          const realizedPnl = record.realizedPnl ? parseFloat(record.realizedPnl) : null
-          const percentRealizedPnl = record.percentRealizedPnl ? parseFloat(record.percentRealizedPnl) : null
+      baseColumns.push(
+        {
+          title: '当前价格',
+          dataIndex: 'currentPrice',
+          key: 'currentPrice',
+          render: (price: string) => formatNumber(price, 4),
+          align: 'right' as const,
+          width: 120
+        },
+        {
+          title: '当前价值',
+          dataIndex: 'currentValue',
+          key: 'currentValue',
+          render: (value: string) => (
+            <span style={{ fontWeight: 'bold' }}>
+              {formatUSDC(value)} USDC
+            </span>
+          ),
+          align: 'right' as const,
+          width: 120,
+          sorter: (a: AccountPosition, b: AccountPosition) => {
+            const valA = parseFloat(a.currentValue || '0')
+            const valB = parseFloat(b.currentValue || '0')
+            return valA - valB
+          },
+          defaultSortOrder: 'descend' as const
+        }
+      )
+    }
 
-          return (
-            <div>
-              <div style={{ fontWeight: '600', marginBottom: '2px' }}>
-                {formatUSDC(record.currentValue)} USDC
-              </div>
-              <div style={{
-                fontSize: '13px',
-                color: pnlNum >= 0 ? '#3f8600' : '#cf1322',
-                fontWeight: '500'
-              }}>
-                {pnlNum >= 0 ? '+' : ''}{formatUSDC(record.pnl)} ({formatPercent(record.percentPnl)})
-              </div>
-              {realizedPnl !== null && (
+    // 只有当前仓位才显示盈亏和已实现盈亏列
+    if (positionFilter === 'current') {
+      baseColumns.push(
+        {
+          title: '盈亏',
+          dataIndex: 'pnl',
+          key: 'pnl',
+          render: (pnl: string, record: AccountPosition) => {
+            const pnlNum = parseFloat(pnl || '0')
+            const percentPnl = parseFloat(record.percentPnl || '0')
+            return (
+              <div>
                 <div style={{
-                  fontSize: '11px',
-                  color: '#999',
-                  marginTop: '2px'
+                  color: pnlNum >= 0 ? '#3f8600' : '#cf1322',
+                  fontWeight: 'bold'
                 }}>
-                  已实现: {realizedPnl >= 0 ? '+' : ''}{formatUSDC(record.realizedPnl)}
-                  {percentRealizedPnl !== null && ` (${formatPercent(record.percentRealizedPnl)})`}
+                  {pnlNum >= 0 ? '+' : ''}{formatUSDC(pnl)} USDC
                 </div>
-              )}
-            </div>
-          )
+                <div style={{
+                  fontSize: '12px',
+                  color: percentPnl >= 0 ? '#3f8600' : '#cf1322'
+                }}>
+                  {formatPercent(record.percentPnl)}
+                </div>
+              </div>
+            )
+          },
+          align: 'right' as const,
+          width: 150,
+          sorter: (a: AccountPosition, b: AccountPosition) => {
+            const pnlA = parseFloat(a.pnl || '0')
+            const pnlB = parseFloat(b.pnl || '0')
+            return pnlA - pnlB
+          }
         },
-        align: 'right' as const,
-        width: 160,
-        sorter: (a: AccountPosition, b: AccountPosition) => {
-          const valA = parseFloat(a.currentValue || '0')
-          const valB = parseFloat(b.currentValue || '0')
-          return valA - valB
-        },
-        defaultSortOrder: 'descend' as const
-      })
+        {
+          title: '已实现盈亏',
+          dataIndex: 'realizedPnl',
+          key: 'realizedPnl',
+          render: (realizedPnl: string | undefined, record: AccountPosition) => {
+            if (!realizedPnl) return '-'
+            const pnlNum = parseFloat(realizedPnl)
+            const percentPnl = parseFloat(record.percentRealizedPnl || '0')
+            return (
+              <div>
+                <div style={{
+                  color: pnlNum >= 0 ? '#3f8600' : '#cf1322',
+                  fontWeight: 'bold'
+                }}>
+                  {pnlNum >= 0 ? '+' : ''}{formatUSDC(realizedPnl)} USDC
+                </div>
+                {record.percentRealizedPnl && (
+                  <div style={{
+                    fontSize: '12px',
+                    color: percentPnl >= 0 ? '#3f8600' : '#cf1322'
+                  }}>
+                    {formatPercent(record.percentRealizedPnl)}
+                  </div>
+                )}
+              </div>
+            )
+          },
+          align: 'right' as const,
+          width: 150
+        }
+      )
     }
 
     // 只有当前仓位才显示操作列
@@ -1023,7 +1084,7 @@ const PositionList: React.FC = () => {
             )}
           </Space>
         ),
-        width: 80,
+        width: 150,
         fixed: isMobile ? ('right' as const) : undefined
       })
     }

frontend/src/pages/SystemSettings.tsx

@@ -1,11 +1,11 @@
 import { useEffect, useState } from 'react'
-import { useNavigate } from 'react-router-dom'
-import { Card, Form, Button, Switch, Input, InputNumber, message, Typography, Space, Alert, Select } from 'antd'
-import { SaveOutlined, CheckCircleOutlined, ReloadOutlined, GlobalOutlined, NotificationOutlined, KeyOutlined, LinkOutlined, RightOutlined } from '@ant-design/icons'
+import { Card, Form, Button, Switch, Input, InputNumber, message, Typography, Space, Alert, Select, Table, Tag, Popconfirm, Modal } from 'antd'
+import { SaveOutlined, CheckCircleOutlined, ReloadOutlined, GlobalOutlined, NotificationOutlined, KeyOutlined, LinkOutlined, PlusOutlined, EditOutlined, DeleteOutlined, SendOutlined } from '@ant-design/icons'
 import { apiService } from '../services/api'
 import { useMediaQuery } from 'react-responsive'
 import { useTranslation } from 'react-i18next'
-import type { SystemConfig, BuilderApiKeyUpdateRequest } from '../types'
+import type { SystemConfig, BuilderApiKeyUpdateRequest, NotificationConfig, NotificationConfigRequest, NotificationConfigUpdateRequest } from '../types'
+import { TelegramConfigForm } from '../components/notifications'
 import SystemUpdate from './SystemUpdate'
 
 const { Title, Text, Paragraph } = Typography
@@ -33,13 +33,20 @@ interface ProxyCheckResponse {
 const SystemSettings: React.FC = () => {
   const { t, i18n: i18nInstance } = useTranslation()
   const isMobile = useMediaQuery({ maxWidth: 768 })
-  const navigate = useNavigate()
 
   // 第一部分：多语言
   const [languageForm] = Form.useForm()
   const [currentLang, setCurrentLang] = useState<string>('auto')
 
-  // 第二部分：Relayer配置
+  // 第二部分：消息推送设置
+  const [notificationConfigs, setNotificationConfigs] = useState<NotificationConfig[]>([])
+  const [notificationLoading, setNotificationLoading] = useState(false)
+  const [notificationModalVisible, setNotificationModalVisible] = useState(false)
+  const [editingNotificationConfig, setEditingNotificationConfig] = useState<NotificationConfig | null>(null)
+  const [notificationForm] = Form.useForm()
+  const [testLoading, setTestLoading] = useState(false)
+
+  // 第三部分：Relayer配置
   const [relayerForm] = Form.useForm()
   const [autoRedeemForm] = Form.useForm()
   const [systemConfig, setSystemConfig] = useState<SystemConfig | null>(null)
@@ -60,6 +67,7 @@ const SystemSettings: React.FC = () => {
     languageForm.setFieldsValue({ language: savedLanguage })
 
     // 加载其他配置
+    fetchNotificationConfigs()
     fetchSystemConfig()
     fetchProxyConfig()
   }, [])
@@ -95,7 +103,246 @@ const SystemSettings: React.FC = () => {
     }
   }
 
-  // ==================== 第二部分：Relayer配置 ====================
+  // ==================== 第二部分：消息推送设置 ====================
+  const fetchNotificationConfigs = async () => {
+    setNotificationLoading(true)
+    try {
+      const response = await apiService.notifications.list({ type: 'telegram' })
+      if (response.data.code === 0 && response.data.data) {
+        setNotificationConfigs(response.data.data)
+      } else {
+        message.error(response.data.msg || t('notificationSettings.fetchFailed'))
+      }
+    } catch (error: any) {
+      message.error(error.message || t('notificationSettings.fetchFailed'))
+    } finally {
+      setNotificationLoading(false)
+    }
+  }
+
+  const handleNotificationCreate = () => {
+    setEditingNotificationConfig(null)
+    notificationForm.resetFields()
+    notificationForm.setFieldsValue({
+      type: 'telegram',
+      enabled: true,
+      config: {
+        botToken: '',
+        chatIds: []
+      }
+    })
+    setNotificationModalVisible(true)
+  }
+
+  const handleNotificationEdit = (config: NotificationConfig) => {
+    setEditingNotificationConfig(config)
+
+    let botToken = ''
+    let chatIds = ''
+
+    if (config.config) {
+      if ('data' in config.config && config.config.data) {
+        const data = config.config.data as any
+        botToken = data.botToken || ''
+        if (data.chatIds) {
+          if (Array.isArray(data.chatIds)) {
+            chatIds = data.chatIds.join(',')
+          } else if (typeof data.chatIds === 'string') {
+            chatIds = data.chatIds
+          }
+        }
+      } else {
+        if ('botToken' in config.config) {
+          botToken = (config.config as any).botToken || ''
+        }
+        if ('chatIds' in config.config) {
+          const ids = (config.config as any).chatIds
+          if (Array.isArray(ids)) {
+            chatIds = ids.join(',')
+          } else if (typeof ids === 'string') {
+            chatIds = ids
+          }
+        }
+      }
+    }
+
+    notificationForm.setFieldsValue({
+      type: config.type,
+      name: config.name,
+      enabled: config.enabled,
+      config: {
+        botToken: botToken,
+        chatIds: chatIds
+      }
+    })
+    setNotificationModalVisible(true)
+  }
+
+  const handleNotificationDelete = async (id: number) => {
+    try {
+      const response = await apiService.notifications.delete({ id })
+      if (response.data.code === 0) {
+        message.success(t('notificationSettings.deleteSuccess'))
+        fetchNotificationConfigs()
+      } else {
+        message.error(response.data.msg || t('notificationSettings.deleteFailed'))
+      }
+    } catch (error: any) {
+      message.error(error.message || t('notificationSettings.deleteFailed'))
+    }
+  }
+
+  const handleNotificationUpdateEnabled = async (id: number, enabled: boolean) => {
+    try {
+      const response = await apiService.notifications.updateEnabled({ id, enabled })
+      if (response.data.code === 0) {
+        message.success(enabled ? t('notificationSettings.enableSuccess') : t('notificationSettings.disableSuccess'))
+        fetchNotificationConfigs()
+      } else {
+        message.error(response.data.msg || t('notificationSettings.updateStatusFailed'))
+      }
+    } catch (error: any) {
+      message.error(error.message || t('notificationSettings.updateStatusFailed'))
+    }
+  }
+
+  const handleNotificationTest = async () => {
+    setTestLoading(true)
+    try {
+      const response = await apiService.notifications.test({ message: '这是一条测试消息' })
+      if (response.data.code === 0 && response.data.data) {
+        message.success(t('notificationSettings.testSuccess'))
+      } else {
+        message.error(response.data.msg || t('notificationSettings.testFailed'))
+      }
+    } catch (error: any) {
+      message.error(error.message || t('notificationSettings.testFailed'))
+    } finally {
+      setTestLoading(false)
+    }
+  }
+
+  const handleNotificationSubmit = async () => {
+    try {
+      const values = await notificationForm.validateFields()
+
+      const chatIds = typeof values.config.chatIds === 'string'
+        ? values.config.chatIds.split(',').map((id: string) => id.trim()).filter((id: string) => id)
+        : values.config.chatIds || []
+
+      const configData: NotificationConfigRequest | NotificationConfigUpdateRequest = {
+        type: values.type,
+        name: values.name,
+        enabled: values.enabled,
+        config: {
+          botToken: values.config.botToken,
+          chatIds: chatIds
+        }
+      }
+
+      if (editingNotificationConfig?.id) {
+        const updateData = {
+          ...configData,
+          id: editingNotificationConfig.id
+        } as NotificationConfigUpdateRequest
+
+        const response = await apiService.notifications.update(updateData)
+        if (response.data.code === 0) {
+          message.success(t('notificationSettings.updateSuccess'))
+          setNotificationModalVisible(false)
+          fetchNotificationConfigs()
+        } else {
+          message.error(response.data.msg || t('notificationSettings.updateFailed'))
+        }
+      } else {
+        const response = await apiService.notifications.create(configData)
+        if (response.data.code === 0) {
+          message.success(t('notificationSettings.createSuccess'))
+          setNotificationModalVisible(false)
+          fetchNotificationConfigs()
+        } else {
+          message.error(response.data.msg || t('notificationSettings.createFailed'))
+        }
+      }
+    } catch (error: any) {
+      if (error.errorFields) {
+        return
+      }
+      message.error(error.message || t('message.error'))
+    }
+  }
+
+  const notificationColumns = [
+    {
+      title: t('notificationSettings.configName'),
+      dataIndex: 'name',
+      key: 'name',
+    },
+    {
+      title: t('notificationSettings.type'),
+      dataIndex: 'type',
+      key: 'type',
+      render: (type: string) => <Tag color="blue">{type.toUpperCase()}</Tag>
+    },
+    {
+      title: t('notificationSettings.status'),
+      dataIndex: 'enabled',
+      key: 'enabled',
+      render: (enabled: boolean) => (
+        <Tag color={enabled ? 'green' : 'default'}>
+          {enabled ? t('notificationSettings.enabledStatus') : t('notificationSettings.disabledStatus')}
+        </Tag>
+      )
+    },
+    {
+      title: t('common.actions'),
+      key: 'action',
+      width: isMobile ? 120 : 200,
+      render: (_: any, record: NotificationConfig) => (
+        <Space size="small" wrap>
+          <Button
+            type="link"
+            size="small"
+            icon={<EditOutlined />}
+            onClick={() => handleNotificationEdit(record)}
+          >
+            {t('notificationSettings.edit')}
+          </Button>
+          <Switch
+            checked={record.enabled}
+            size="small"
+            onChange={(checked) => handleNotificationUpdateEnabled(record.id!, checked)}
+          />
+          <Button
+            type="link"
+            size="small"
+            icon={<SendOutlined />}
+            loading={testLoading}
+            onClick={handleNotificationTest}
+          >
+            {t('notificationSettings.test')}
+          </Button>
+          <Popconfirm
+            title={t('notificationSettings.deleteConfirm')}
+            onConfirm={() => handleNotificationDelete(record.id!)}
+            okText={t('common.confirm')}
+            cancelText={t('common.cancel')}
+          >
+            <Button
+              type="link"
+              danger
+              size="small"
+              icon={<DeleteOutlined />}
+            >
+              {t('notificationSettings.delete')}
+            </Button>
+          </Popconfirm>
+        </Space>
+      )
+    }
+  ]
+
+  // ==================== 第三部分：Relayer配置 ====================
   const fetchSystemConfig = async () => {
     try {
       const response = await apiService.systemConfig.get()
@@ -304,7 +551,7 @@ const SystemSettings: React.FC = () => {
         </Form>
       </Card>
 
-      {/* 第二部分：消息推送设置（独立页面入口） */}
+      {/* 第二部分：消息推送设置 */}
       <Card
         title={
           <Space>
@@ -316,24 +563,73 @@ const SystemSettings: React.FC = () => {
         extra={
           <Button
             type="primary"
-            icon={<RightOutlined />}
-            onClick={() => navigate('/system-settings/notification')}
+            icon={<PlusOutlined />}
+            onClick={handleNotificationCreate}
           >
-            {t('notificationSettings.title')}
+            {t('notificationSettings.addConfig')}
           </Button>
         }
       >
-        <Paragraph type="secondary" style={{ marginBottom: 16 }}>
-          {t('notificationSettings.botConfig')}、{t('notificationSettings.templateConfig')}等请在独立页面中配置。
-        </Paragraph>
-        <Button
-          type="link"
-          icon={<RightOutlined />}
-          onClick={() => navigate('/system-settings/notification')}
-          style={{ padding: 0 }}
+        <Table
+          columns={notificationColumns}
+          dataSource={notificationConfigs}
+          loading={notificationLoading}
+          rowKey="id"
+          pagination={false}
+          scroll={{ x: isMobile ? 600 : 'auto' }}
+        />
+
+        <Modal
+          title={editingNotificationConfig ? t('notificationSettings.editConfig') : t('notificationSettings.addConfig')}
+          open={notificationModalVisible}
+          onOk={handleNotificationSubmit}
+          onCancel={() => setNotificationModalVisible(false)}
+          width={isMobile ? '90%' : 600}
+          okText={t('common.confirm')}
+          cancelText={t('common.cancel')}
         >
-          {t('notificationSettings.title')} →
-        </Button>
+          <Form
+            form={notificationForm}
+            layout="vertical"
+          >
+            <Form.Item
+              name="type"
+              label={t('notificationSettings.type')}
+              rules={[{ required: true, message: t('notificationSettings.typeRequired') }]}
+            >
+              <Input disabled value="telegram" />
+            </Form.Item>
+
+            <Form.Item
+              name="name"
+              label={t('notificationSettings.configName')}
+              rules={[{ required: true, message: t('notificationSettings.configNameRequired') }]}
+            >
+              <Input placeholder={t('notificationSettings.configNamePlaceholder')} />
+            </Form.Item>
+
+            <Form.Item
+              name="enabled"
+              label={t('notificationSettings.enabled')}
+              valuePropName="checked"
+            >
+              <Switch />
+            </Form.Item>
+
+            <Form.Item shouldUpdate={(prevValues, currentValues) => {
+              return prevValues.type !== currentValues.type ||
+                prevValues.config !== currentValues.config
+            }}>
+              {() => {
+                const currentType = notificationForm.getFieldValue('type') || 'telegram'
+                if (currentType === 'telegram') {
+                  return <TelegramConfigForm form={notificationForm} />
+                }
+                return null
+              }}
+            </Form.Item>
+          </Form>
+        </Modal>
       </Card>
 
       {/* 第三部分：Relayer配置 */}

frontend/src/pages/TemplateList.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useState } from 'react'
 import { useNavigate } from 'react-router-dom'
-import { Card, Table, Button, Space, Tag, Popconfirm, message, Input, Modal, Form, Radio, InputNumber, Switch, Divider, Spin, Empty, List, Tooltip } from 'antd'
+import { Card, Table, Button, Space, Tag, Popconfirm, message, Input, Modal, Form, Radio, InputNumber, Switch, Divider, Spin } from 'antd'
 import { PlusOutlined, EditOutlined, DeleteOutlined, CopyOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import { apiService } from '../services/api'
@@ -212,50 +212,25 @@ const TemplateList: React.FC = () => {
     {
       title: t('common.actions') || '操作',
       key: 'action',
-      width: isMobile ? 120 : 120,
-      fixed: 'right' as const,
+      width: isMobile ? 120 : 200,
       render: (_: any, record: CopyTradingTemplate) => (
-        <Space size={4}>
-          <Tooltip title={t('common.edit') || '编辑'}>
-            <div
-              onClick={() => navigate(`/templates/edit/${record.id}`)}
-              style={{
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-                width: '32px',
-                height: '32px',
-                cursor: 'pointer',
-                borderRadius: '6px',
-                transition: 'background-color 0.2s'
-              }}
-              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
-              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-            >
-              <EditOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-            </div>
-          </Tooltip>
-
-          <Tooltip title={t('templateList.copy') || '复制'}>
-            <div
-              onClick={() => handleCopy(record)}
-              style={{
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-                width: '32px',
-                height: '32px',
-                cursor: 'pointer',
-                borderRadius: '6px',
-                transition: 'background-color 0.2s'
-              }}
-              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
-              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-            >
-              <CopyOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
-            </div>
-          </Tooltip>
-
+        <Space size="small">
+          <Button
+            type="link"
+            size="small"
+            icon={<EditOutlined />}
+            onClick={() => navigate(`/templates/edit/${record.id}`)}
+          >
+            {t('common.edit') || '编辑'}
+          </Button>
+          <Button
+            type="link"
+            size="small"
+            icon={<CopyOutlined />}
+            onClick={() => handleCopy(record)}
+          >
+            {t('templateList.copy') || '复制'}
+          </Button>
           <Popconfirm
             title={t('templateList.deleteConfirm') || '确定要删除这个模板吗？'}
             description={t('templateList.deleteConfirmDesc') || '删除后无法恢复，请确保没有跟单关系在使用该模板'}
@@ -263,24 +238,14 @@ const TemplateList: React.FC = () => {
             okText={t('common.confirm') || '确定'}
             cancelText={t('common.cancel') || '取消'}
           >
-            <Tooltip title={t('common.delete') || '删除'}>
-              <div
-                style={{
-                  display: 'flex',
-                  alignItems: 'center',
-                  justifyContent: 'center',
-                  width: '32px',
-                  height: '32px',
-                  cursor: 'pointer',
-                  borderRadius: '6px',
-                  transition: 'background-color 0.2s'
-                }}
-                onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#fff1f0'}
-                onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
-              >
-                <DeleteOutlined style={{ fontSize: '16px', color: '#ff4d4f' }} />
-              </div>
-            </Tooltip>
+            <Button
+              type="link"
+              size="small"
+              danger
+              icon={<DeleteOutlined />}
+            >
+              {t('common.delete') || '删除'}
+            </Button>
           </Popconfirm>
         </Space>
       )
@@ -289,29 +254,26 @@ const TemplateList: React.FC = () => {
   
   return (
     <div>
-      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px', flexWrap: 'wrap', gap: '12px' }}>
-        <h2 style={{ margin: 0, fontSize: isMobile ? '20px' : '24px' }}>{t('templateList.title') || '跟单模板管理'}</h2>
-        <Space size={8}>
-          <Search
-            placeholder={t('templateList.searchPlaceholder') || '搜索模板名称'}
-            allowClear
-            style={{ width: isMobile ? 120 : 200 }}
-            onSearch={setSearchText}
-            onChange={(e) => setSearchText(e.target.value)}
-          />
-          <Tooltip title={t('templateList.addTemplate') || '新增模板'}>
+      <Card>
+        <div style={{ marginBottom: 16, display: 'flex', justifyContent: 'space-between', alignItems: 'center', flexWrap: 'wrap', gap: 16 }}>
+          <h2 style={{ margin: 0 }}>{t('templateList.title') || '跟单模板管理'}</h2>
+          <Space>
+            <Search
+              placeholder={t('templateList.searchPlaceholder') || '搜索模板名称'}
+              allowClear
+              style={{ width: isMobile ? 150 : 250 }}
+              onSearch={setSearchText}
+              onChange={(e) => setSearchText(e.target.value)}
+            />
             <Button
               type="primary"
               icon={<PlusOutlined />}
               onClick={() => navigate('/templates/add')}
-              size={isMobile ? 'middle' : 'large'}
-              style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}
-            />
-          </Tooltip>
-        </Space>
-      </div>
-
-      <Card style={{ borderRadius: '12px', boxShadow: '0 2px 8px rgba(0,0,0,0.08)', border: '1px solid #e8e8e8' }} bodyStyle={{ padding: isMobile ? '12px' : '24px' }}>
+            >
+              {t('templateList.addTemplate') || '新增模板'}
+            </Button>
+          </Space>
+        </div>
         
         {isMobile ? (
           // 移动端卡片布局
@@ -321,133 +283,116 @@ const TemplateList: React.FC = () => {
                 <Spin size="large" />
               </div>
             ) : filteredTemplates.length === 0 ? (
-              <Empty description={t('templateList.noData') || '暂无模板数据'} />
+              <div style={{ textAlign: 'center', padding: '40px', color: '#999' }}>
+                {t('templateList.noData') || '暂无模板数据'}
+              </div>
             ) : (
-              <List
-                dataSource={filteredTemplates}
-                renderItem={(template) => {
+              <div style={{ display: 'flex', flexDirection: 'column', gap: '12px' }}>
+                {filteredTemplates.map((template) => {
+                  const date = new Date(template.createdAt)
+                  const formattedDate = date.toLocaleString(i18n.language || 'zh-CN', {
+                    year: 'numeric',
+                    month: '2-digit',
+                    day: '2-digit',
+                    hour: '2-digit',
+                    minute: '2-digit'
+                  })
+                  
                   return (
                     <Card
                       key={template.id}
                       style={{
-                        marginBottom: '10px',
-                        borderRadius: '10px',
-                        boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
-                        border: '1px solid #e8e8e8',
-                        overflow: 'hidden'
+                        borderRadius: '12px',
+                        boxShadow: '0 2px 8px rgba(0,0,0,0.08)',
+                        border: '1px solid #e8e8e8'
                       }}
-                      bodyStyle={{ padding: '0' }}
+                      bodyStyle={{ padding: '16px' }}
                     >
-                      {/* 头部区域 - 模板名称 */}
-                      <div style={{
-                        padding: '10px 12px',
-                        background: 'var(--ant-color-primary, #1677ff)',
-                        color: '#fff'
-                      }}>
-                        <div style={{ fontSize: '15px', fontWeight: '600', marginBottom: '2px' }}>
+                      {/* 模板名称和模式 */}
+                      <div style={{ marginBottom: '12px' }}>
+                        <div style={{ 
+                          fontSize: '16px', 
+                          fontWeight: 'bold', 
+                          marginBottom: '8px',
+                          color: '#1890ff'
+                        }}>
                           {template.templateName}
                         </div>
-                        <div style={{ fontSize: '12px', opacity: '0.9' }}>
+                        <div style={{ display: 'flex', flexWrap: 'wrap', gap: '6px', alignItems: 'center' }}>
+                          <Tag color={template.copyMode === 'RATIO' ? 'blue' : 'green'}>
+                            {template.copyMode === 'RATIO' ? (t('templateList.ratioMode') || '比例模式') : (t('templateList.fixedAmountMode') || '固定金额模式')}
+                          </Tag>
+                          <Tag color={template.supportSell ? 'green' : 'red'}>
+                            {template.supportSell ? (t('templateList.supportSell') || '跟单卖出') : (t('templateList.notSupportSell') || '不跟单卖出')}
+                          </Tag>
+                        </div>
+                      </div>
+                      
+                      <Divider style={{ margin: '12px 0' }} />
+                      
+                      {/* 跟单配置 */}
+                      <div style={{ marginBottom: '12px' }}>
+                        <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('templateList.copyConfig') || '跟单配置'}</div>
+                        <div style={{ fontSize: '14px', fontWeight: '500' }}>
                           {template.copyMode === 'RATIO' 
-                            ? `${t('templateList.ratioMode') || '比例模式'} ${(parseFloat(template.copyRatio || '0') * 100).toFixed(0).replace(/\.0+$/, '')}%`
-                            : `${t('templateList.fixedAmountMode') || '固定金额'} ${formatUSDC(template.fixedAmount || '0')} USDC`
+                            ? `${t('templateList.ratio') || '比例'} ${template.copyRatio}x`
+                            : template.fixedAmount 
+                              ? `${t('templateList.fixedAmount') || '固定'} ${formatUSDC(template.fixedAmount)} USDC`
+                              : '-'
                           }
                         </div>
                       </div>
-
-                      {/* 配置信息区域 */}
-                      <div style={{
-                        padding: '8px 12px',
-                        backgroundColor: '#fafafa',
-                        borderBottom: '1px solid #f0f0f0',
-                        minHeight: '42px',
-                        display: 'flex',
-                        alignItems: 'center'
-                      }}>
-                        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', width: '100%' }}>
-                          <div>
-                            <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
-                              {t('templateList.supportSell') || '跟单卖出'}
-                            </div>
-                            <div style={{ fontSize: '12px', fontWeight: '500' }}>
-                              <Tag color={template.supportSell ? 'green' : 'red'} style={{ margin: 0, fontSize: '10px' }}>
-                                {template.supportSell ? (t('common.yes') || '是') : (t('common.no') || '否')}
-                              </Tag>
-                            </div>
-                          </div>
-                          <div style={{ textAlign: 'right' }}>
-                            <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
-                              {t('templateList.maxDailyOrders') || '每日最大'}
-                            </div>
-                            <div style={{ fontSize: '12px', fontWeight: '500', color: '#1890ff' }}>
-                              {template.maxDailyOrders} {t('common.orders') || '单'}
-                            </div>
-                          </div>
-                        </div>
-                      </div>
-
-                      {/* 金额限制区域（仅比例模式显示） */}
+                      
+                      {/* 其他配置信息 */}
                       {template.copyMode === 'RATIO' && (
-                        <div style={{
-                          padding: '6px 12px',
-                          fontSize: '11px',
-                          color: '#8c8c8c',
-                          borderBottom: '1px solid #f0f0f0'
-                        }}>
-                          <span style={{ color: '#d48806' }}>{t('templateList.amountLimit') || '金额限制'}: </span>
-                          {template.maxOrderSize && (
-                            <span>{t('templateList.max') || '最大'} {formatUSDC(template.maxOrderSize)} USDC</span>
-                          )}
-                          {template.maxOrderSize && template.minOrderSize && <span> | </span>}
-                          {template.minOrderSize && (
-                            <span>{t('templateList.min') || '最小'} {formatUSDC(template.minOrderSize)} USDC</span>
-                          )}
-                          {!template.maxOrderSize && !template.minOrderSize && <span style={{ color: '#bfbfbf' }}>{t('templateList.notSet') || '未设置'}</span>}
+                        <div style={{ marginBottom: '12px' }}>
+                          <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('templateList.amountLimit') || '金额限制'}</div>
+                          <div style={{ fontSize: '13px', color: '#333' }}>
+                            {template.maxOrderSize && (
+                              <span>{t('templateList.max') || '最大'}: {formatUSDC(template.maxOrderSize)} USDC</span>
+                            )}
+                            {template.maxOrderSize && template.minOrderSize && <span> | </span>}
+                            {template.minOrderSize && (
+                              <span>{t('templateList.min') || '最小'}: {formatUSDC(template.minOrderSize)} USDC</span>
+                            )}
+                            {!template.maxOrderSize && !template.minOrderSize && <span style={{ color: '#999' }}>{t('templateList.notSet') || '未设置'}</span>}
+                          </div>
                         </div>
                       )}
-
-                      {/* 创建时间 */}
-                      <div style={{
-                        padding: '6px 12px',
-                        fontSize: '11px',
-                        color: '#8c8c8c'
-                      }}>
-                        {t('common.createdAt') || '创建时间'}: {new Date(template.createdAt).toLocaleString(i18n.language || 'zh-CN', {
-                          year: 'numeric',
-                          month: '2-digit',
-                          day: '2-digit',
-                          hour: '2-digit',
-                          minute: '2-digit'
-                        })}
+                      
+                      <div style={{ marginBottom: '12px' }}>
+                        <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('templateList.otherConfig') || '其他配置'}</div>
+                        <div style={{ fontSize: '13px', color: '#333' }}>
+                          {t('templateList.maxDailyOrders') || '每日最大订单'}: {template.maxDailyOrders} | {t('templateList.priceTolerance') || '价格容忍度'}: {template.priceTolerance}%
+                        </div>
                       </div>
-
-                      {/* 图标操作栏 */}
-                      <div style={{
-                        padding: '8px 12px',
-                        display: 'flex',
-                        justifyContent: 'space-around',
-                        alignItems: 'center'
-                      }}>
-                        <Tooltip title={t('common.edit') || '编辑'}>
-                          <div
-                            onClick={() => navigate(`/templates/edit/${template.id}`)}
-                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
-                          >
-                            <EditOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.edit') || '编辑'}</span>
-                          </div>
-                        </Tooltip>
-
-                        <Tooltip title={t('templateList.copy') || '复制'}>
-                          <div
-                            onClick={() => handleCopy(template)}
-                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
-                          >
-                            <CopyOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('templateList.copy') || '复制'}</span>
-                          </div>
-                        </Tooltip>
-
+                      
+                      {/* 创建时间 */}
+                      <div style={{ marginBottom: '16px' }}>
+                        <div style={{ fontSize: '12px', color: '#999' }}>
+                          {t('common.createdAt') || '创建时间'}: {formattedDate}
+                        </div>
+                      </div>
+                      
+                      {/* 操作按钮 */}
+                      <div style={{ display: 'flex', gap: '8px', flexWrap: 'wrap' }}>
+                        <Button
+                          type="primary"
+                          size="small"
+                          icon={<EditOutlined />}
+                          onClick={() => navigate(`/templates/edit/${template.id}`)}
+                          style={{ flex: 1, minWidth: '80px' }}
+                        >
+                          {t('common.edit') || '编辑'}
+                        </Button>
+                        <Button
+                          size="small"
+                          icon={<CopyOutlined />}
+                          onClick={() => handleCopy(template)}
+                          style={{ flex: 1, minWidth: '80px' }}
+                        >
+                          {t('templateList.copy') || '复制'}
+                        </Button>
                         <Popconfirm
                           title={t('templateList.deleteConfirm') || '确定要删除这个模板吗？'}
                           description={t('templateList.deleteConfirmDesc') || '删除后无法恢复，请确保没有跟单关系在使用该模板'}
@@ -455,18 +400,20 @@ const TemplateList: React.FC = () => {
                           okText={t('common.confirm') || '确定'}
                           cancelText={t('common.cancel') || '取消'}
                         >
-                          <Tooltip title={t('common.delete') || '删除'}>
-                            <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                              <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
-                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.delete') || '删除'}</span>
-                            </div>
-                          </Tooltip>
+                          <Button
+                            danger
+                            size="small"
+                            icon={<DeleteOutlined />}
+                            style={{ flex: 1, minWidth: '80px' }}
+                          >
+                            {t('common.delete') || '删除'}
+                          </Button>
                         </Popconfirm>
                       </div>
                     </Card>
                   )
-                }}
-              />
+                })}
+              </div>
             )}
           </div>
         ) : (

frontend/src/pages/UserList.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useState } from 'react'
-import { Card, Table, Button, Space, Tag, Popconfirm, message, Typography, Modal, Form, Input, List, Empty, Tooltip, Spin } from 'antd'
-import { PlusOutlined, ReloadOutlined, DeleteOutlined, EditOutlined, UserOutlined, KeyOutlined } from '@ant-design/icons'
+import { Card, Table, Button, Space, Tag, Popconfirm, message, Typography, Modal, Form, Input } from 'antd'
+import { PlusOutlined, ReloadOutlined, DeleteOutlined, EditOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import { apiService } from '../services/api'
 import { useMediaQuery } from 'react-responsive'
@@ -219,164 +219,46 @@ const UserList: React.FC = () => {
 
   return (
     <div>
-      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px', flexWrap: 'wrap', gap: '12px' }}>
-        <Title level={isMobile ? 4 : 3} style={{ margin: 0, fontSize: isMobile ? '18px' : undefined }}>{t('userList.title') || '用户管理'}</Title>
-        <Space size={8} wrap>
-          <Button
-            icon={<KeyOutlined />}
-            onClick={() => setUpdateOwnPasswordModalVisible(true)}
-            size={isMobile ? 'middle' : 'large'}
-            style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px' }}
-          >
-            {isMobile ? (t('userList.updateMyPassword') || '改密') : (t('userList.updateMyPassword') || '修改我的密码')}
-          </Button>
-          <Button
-            icon={<ReloadOutlined />}
-            onClick={fetchUsers}
-            loading={loading}
-            size={isMobile ? 'middle' : 'large'}
-            style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px' }}
-          >
-            {t('common.refresh') || '刷新'}
-          </Button>
-          {isDefaultUser && (
-            <Tooltip title={t('userList.addUser') || '新增用户'}>
+      <Card>
+        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '16px' }}>
+          <Title level={4} style={{ margin: 0 }}>{t('userList.title') || '用户管理'}</Title>
+          <Space>
+            <Button
+              icon={<EditOutlined />}
+              onClick={() => setUpdateOwnPasswordModalVisible(true)}
+            >
+              {t('userList.updateMyPassword') || '修改我的密码'}
+            </Button>
+            <Button
+              icon={<ReloadOutlined />}
+              onClick={fetchUsers}
+              loading={loading}
+            >
+              {t('common.refresh') || '刷新'}
+            </Button>
+            {isDefaultUser && (
               <Button
                 type="primary"
                 icon={<PlusOutlined />}
                 onClick={() => setCreateModalVisible(true)}
-                size={isMobile ? 'middle' : 'large'}
-                style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}
-              />
-            </Tooltip>
-          )}
-        </Space>
-      </div>
-
-      <Card style={{ borderRadius: '12px', boxShadow: '0 2px 8px rgba(0,0,0,0.08)', border: '1px solid #e8e8e8' }} bodyStyle={{ padding: isMobile ? '12px' : '24px' }}>
-        {isMobile ? (
-          // 移动端卡片布局
-          <div>
-            {loading ? (
-              <div style={{ textAlign: 'center', padding: '40px' }}>
-                <Spin size="large" />
-              </div>
-            ) : users.length === 0 ? (
-              <Empty description={t('userList.noData') || '暂无用户数据'} />
-            ) : (
-              <List
-                dataSource={users}
-                renderItem={(user) => (
-                  <Card
-                    key={user.id}
-                    style={{
-                      marginBottom: '10px',
-                      borderRadius: '10px',
-                      boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
-                      border: '1px solid #e8e8e8',
-                      overflow: 'hidden'
-                    }}
-                    bodyStyle={{ padding: '0' }}
-                  >
-                    {/* 头部区域 - 用户名 */}
-                    <div style={{
-                      padding: '10px 12px',
-                      background: 'var(--ant-color-primary, #1677ff)',
-                      color: '#fff'
-                    }}>
-                      <div style={{ fontSize: '15px', fontWeight: '600', marginBottom: '2px', display: 'flex', alignItems: 'center', gap: '6px' }}>
-                        <UserOutlined style={{ fontSize: '14px' }} />
-                        <span>{user.username}</span>
-                      </div>
-                      <div style={{ fontSize: '12px', opacity: '0.9' }}>
-                        ID: {user.id}
-                      </div>
-                    </div>
-
-                    {/* 角色信息区域 */}
-                    <div style={{
-                      padding: '8px 12px',
-                      backgroundColor: '#fafafa',
-                      borderBottom: '1px solid #f0f0f0',
-                      minHeight: '42px',
-                      display: 'flex',
-                      alignItems: 'center'
-                    }}>
-                      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', width: '100%' }}>
-                        <div>
-                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
-                            {t('userList.role') || '角色'}
-                          </div>
-                          <Tag color={user.isDefault ? 'red' : 'blue'} style={{ margin: 0 }}>
-                            {user.isDefault ? (t('userList.defaultAccount') || '默认账户') : (t('userList.normalUser') || '普通用户')}
-                          </Tag>
-                        </div>
-                        <div style={{ textAlign: 'right' }}>
-                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
-                            {t('common.createdAt') || '创建时间'}
-                          </div>
-                          <div style={{ fontSize: '12px', fontWeight: '500', color: '#666' }}>
-                            {new Date(user.createdAt).toLocaleDateString(i18n.language || 'zh-CN')}
-                          </div>
-                        </div>
-                      </div>
-                    </div>
-
-                    {/* 操作区域（仅管理员可见） */}
-                    {isDefaultUser && !user.isDefault && (
-                      <div style={{
-                        padding: '8px 12px',
-                        display: 'flex',
-                        justifyContent: 'space-around',
-                        alignItems: 'center'
-                      }}>
-                        <Tooltip title={t('userList.updatePassword') || '修改密码'}>
-                          <div
-                            onClick={() => {
-                              setSelectedUser(user)
-                              setUpdatePasswordModalVisible(true)
-                            }}
-                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
-                          >
-                            <KeyOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
-                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('userList.updatePassword') || '改密'}</span>
-                          </div>
-                        </Tooltip>
-
-                        <Popconfirm
-                          title={t('userList.deleteConfirm') || '确定要删除这个用户吗？'}
-                          onConfirm={() => handleDelete(user)}
-                          okText={t('common.confirm') || '确定'}
-                          cancelText={t('common.cancel') || '取消'}
-                        >
-                          <Tooltip title={t('common.delete') || '删除'}>
-                            <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
-                              <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
-                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.delete') || '删除'}</span>
-                            </div>
-                          </Tooltip>
-                        </Popconfirm>
-                      </div>
-                    )}
-                  </Card>
-                )}
-              />
+              >
+                {t('userList.addUser') || '新增用户'}
+              </Button>
             )}
-          </div>
-        ) : (
-          <Table
-            columns={columns}
-            dataSource={users}
-            rowKey="id"
-            loading={loading}
-            pagination={{
-              pageSize: isMobile ? 10 : 20,
-              showSizeChanger: !isMobile,
-              showTotal: (total) => t('userList.total', { total }) || `共 ${total} 条`
-            }}
-            scroll={isMobile ? { x: 600 } : undefined}
-          />
-        )}
+          </Space>
+        </div>
+        <Table
+          columns={columns}
+          dataSource={users}
+          rowKey="id"
+          loading={loading}
+          pagination={{
+            pageSize: isMobile ? 10 : 20,
+            showSizeChanger: !isMobile,
+            showTotal: (total) => t('userList.total', { total }) || `共 ${total} 条`
+          }}
+          scroll={isMobile ? { x: 600 } : undefined}
+        />
       </Card>
 
       {/* 创建用户弹窗 */}

frontend/src/services/api.ts

@@ -1,5 +1,5 @@
 import axios, { AxiosInstance, AxiosError } from 'axios'
-import type { ApiResponse, NotificationConfig, NotificationConfigRequest, NotificationConfigUpdateRequest, NotificationTemplate, TemplateTypeInfo, TemplateVariablesResponse } from '../types'
+import type { ApiResponse, NotificationConfig, NotificationConfigRequest, NotificationConfigUpdateRequest } from '../types'
 import { getToken, setToken, removeToken } from '../utils'
 import { wsManager } from './websocket'
 import i18n from '../i18n/config'
@@ -494,26 +494,14 @@ export const apiService = {
       endDate?: number
     }) =>
       apiClient.post<ApiResponse<{ list: import('../types').CryptoTailStrategyTriggerDto[]; total: number }>>('/crypto-tail-strategy/triggers', data),
-    pnlCurve: (data: import('../types').CryptoTailPnlCurveRequest) =>
-      apiClient.post<ApiResponse<import('../types').CryptoTailPnlCurveResponse>>('/crypto-tail-strategy/pnl-curve', data),
     marketOptions: () =>
       apiClient.post<ApiResponse<import('../types').CryptoTailMarketOptionDto[]>>('/crypto-tail-strategy/market-options', {}),
     autoMinSpread: (data: { intervalSeconds: number }) =>
       apiClient.post<ApiResponse<import('../types').CryptoTailAutoMinSpreadResponse>>('/crypto-tail-strategy/auto-min-spread', data),
-    monitorInit: (data: { strategyId: number; periodStartUnix?: number }) =>
-      apiClient.post<ApiResponse<import('../types').CryptoTailMonitorInitResponse>>('/crypto-tail-strategy/monitor/init', data),
-    manualOrder: (data: {
-      strategyId: number
-      periodStartUnix: number
-      direction: 'UP' | 'DOWN'
-      price: string
-      size: string
-      marketTitle: string
-      tokenIds: string[]
-    }) =>
-      apiClient.post<ApiResponse<import('../types').CryptoTailManualOrderResponse>>('/crypto-tail-strategy/manual-order', data)
+    monitorInit: (strategyId: number) =>
+      apiClient.post<ApiResponse<import('../types').CryptoTailMonitorInitResponse>>('/crypto-tail-strategy/monitor/init', { strategyId })
   },
-
+  
   /**
    * 订单管理 API
    */
@@ -686,51 +674,7 @@ export const apiService = {
      * 获取 Telegram Chat IDs
      */
     getTelegramChatIds: (data: { botToken: string }) =>
-      apiClient.post<ApiResponse<string[]>>('/system/notifications/telegram/get-chat-ids', data),
-
-    // ==================== 模板相关 API ====================
-
-    /**
-     * 获取所有模板类型
-     */
-    getTemplateTypes: () =>
-      apiClient.post<ApiResponse<TemplateTypeInfo[]>>('/system/notifications/templates/types', {}),
-
-    /**
-     * 获取所有模板列表
-     */
-    getTemplates: () =>
-      apiClient.post<ApiResponse<NotificationTemplate[]>>('/system/notifications/templates/list', {}),
-
-    /**
-     * 获取单个模板详情
-     */
-    getTemplateDetail: (data: { templateType: string }) =>
-      apiClient.post<ApiResponse<NotificationTemplate>>('/system/notifications/templates/detail', data),
-
-    /**
-     * 获取模板可用变量
-     */
-    getTemplateVariables: (data: { templateType: string }) =>
-      apiClient.post<ApiResponse<TemplateVariablesResponse>>('/system/notifications/templates/variables', data),
-
-    /**
-     * 更新模板
-     */
-    updateTemplate: (data: { templateType: string; templateContent: string }) =>
-      apiClient.post<ApiResponse<NotificationTemplate>>('/system/notifications/templates/update', data),
-
-    /**
-     * 重置模板为默认
-     */
-    resetTemplate: (data: { templateType: string }) =>
-      apiClient.post<ApiResponse<NotificationTemplate>>('/system/notifications/templates/reset', data),
-
-    /**
-     * 发送模板测试消息
-     */
-    testTemplate: (data: { templateType: string; templateContent?: string }) =>
-      apiClient.post<ApiResponse<boolean>>('/system/notifications/templates/test', data)
+      apiClient.post<ApiResponse<string[]>>('/system/notifications/telegram/get-chat-ids', data)
   },
   
   /**

frontend/src/types/index.ts

@@ -580,13 +580,12 @@ export interface OrderMessage {
 
 /**
  * 订单详情（通过 API 获取）
- * price 为订单限价，avgFilledPrice 为平均成交价（有成交时优先用于展示）
  */
 export interface OrderDetail {
   id: string  // 订单 ID
   market: string  // 市场 ID (condition ID)
   side: string  // BUY/SELL
-  price: string  // 订单限价
+  price: string  // 价格
   size: string  // 订单大小
   filled: string  // 已成交数量
   status: string  // 订单状态
@@ -594,7 +593,6 @@ export interface OrderDetail {
   marketName?: string  // 市场名称
   marketSlug?: string  // 市场 slug
   marketIcon?: string  // 市场图标
-  avgFilledPrice?: string  // 平均成交价（有成交时优先展示）
 }
 
 /**
@@ -1099,33 +1097,6 @@ export interface CryptoTailStrategyTriggerDto {
   createdAt: number
 }
 
-/** 收益曲线请求 */
-export interface CryptoTailPnlCurveRequest {
-  strategyId: number
-  startDate?: number
-  endDate?: number
-}
-
-/** 收益曲线单点 */
-export interface CryptoTailPnlCurvePoint {
-  timestamp: number
-  cumulativePnl: string
-  pointPnl: string
-  settledCount: number
-}
-
-/** 收益曲线响应 */
-export interface CryptoTailPnlCurveResponse {
-  strategyId: number
-  strategyName: string
-  totalRealizedPnl: string
-  settledCount: number
-  winCount: number
-  winRate: string | null
-  maxDrawdown: string | null
-  curveData: CryptoTailPnlCurvePoint[]
-}
-
 /**
  * 加密价差策略市场选项
  */
@@ -1185,10 +1156,6 @@ export interface CryptoTailMonitorInitResponse {
   currentTimestamp: number
   /** 是否启用 */
   enabled: boolean
-  /** 投入金额模式: FIXED or RATIO */
-  amountMode?: string
-  /** 投入金额数值 */
-  amountValue?: string
 }
 
 /**
@@ -1236,76 +1203,3 @@ export interface CryptoTailMonitorPushData {
   /** 周期是否已结束 */
   periodEnded: boolean
 }
-
-export interface CryptoTailManualOrderResponse {
-  /** 是否成功 */
-  success: boolean
-  /** 订单ID */
-  orderId?: string
-  /** 提示消息 */
-  message: string
-  /** 下单详情 */
-  orderDetails?: ManualOrderDetails
-}
-
-export interface ManualOrderDetails {
-  /** 策略ID */
-  strategyId: number
-  /** 方向 */
-  direction: string
-  /** 下单价格 */
-  price: string
-  /** 下单数量 */
-  size: string
-  /** 总金额 */
-  totalAmount: string
-}
-
-// ==================== 消息模板相关类型 ====================
-
-/**
- * 消息模板
- */
-export interface NotificationTemplate {
-  id?: number
-  templateType: string  // 模板类型
-  templateContent: string  // 模板内容
-  isDefault: boolean  // 是否使用默认模板
-  createdAt?: number
-  updatedAt?: number
-}
-
-/**
- * 模板类型信息
- */
-export interface TemplateTypeInfo {
-  type: string  // 模板类型
-  name: string  // 类型名称
-  description: string  // 类型描述
-}
-
-/**
- * 模板变量
- */
-export interface TemplateVariable {
-  key: string  // 变量名
-  category: string  // 分类
-  sortOrder: number  // 排序顺序
-}
-
-/**
- * 模板变量分类
- */
-export interface TemplateVariableCategory {
-  key: string  // 分类 key
-  sortOrder: number  // 排序顺序
-}
-
-/**
- * 模板变量列表响应
- */
-export interface TemplateVariablesResponse {
-  templateType: string  // 模板类型
-  categories: TemplateVariableCategory[]  // 分类列表
-  variables: TemplateVariable[]  // 变量列表
-}