feat(v54): add strategies table, migration script, 9 CRUD API endpoints

backend/main.py

@@ -2179,3 +2179,545 @@ async def strategy_plaza_trades(
         strategy_id, limit
     )
     return {"trades": [dict(r) for r in rows]}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# V5.4 Strategy Factory API
+# ─────────────────────────────────────────────────────────────────────────────
+import uuid as _uuid
+from typing import Optional
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+# ── Pydantic Models ──────────────────────────────────────────────────────────
+
+class StrategyCreateRequest(BaseModel):
+    display_name: str = Field(..., min_length=1, max_length=50)
+    symbol: str
+    direction: str = "both"
+    initial_balance: float = 10000.0
+    cvd_fast_window: str = "30m"
+    cvd_slow_window: str = "4h"
+    weight_direction: int = 55
+    weight_env: int = 25
+    weight_aux: int = 15
+    weight_momentum: int = 5
+    entry_score: int = 75
+    gate_obi_enabled: bool = True
+    obi_threshold: float = 0.3
+    gate_whale_enabled: bool = True
+    whale_cvd_threshold: float = 0.0
+    gate_vol_enabled: bool = True
+    atr_percentile_min: int = 20
+    gate_spot_perp_enabled: bool = False
+    spot_perp_threshold: float = 0.002
+    sl_atr_multiplier: float = 1.5
+    tp1_ratio: float = 0.75
+    tp2_ratio: float = 1.5
+    timeout_minutes: int = 240
+    flip_threshold: int = 80
+    description: Optional[str] = None
+
+    @field_validator("symbol")
+    @classmethod
+    def validate_symbol(cls, v):
+        allowed = {"BTCUSDT", "ETHUSDT", "SOLUSDT", "XRPUSDT"}
+        if v not in allowed:
+            raise ValueError(f"symbol must be one of {allowed}")
+        return v
+
+    @field_validator("direction")
+    @classmethod
+    def validate_direction(cls, v):
+        if v not in {"long_only", "short_only", "both"}:
+            raise ValueError("direction must be long_only, short_only, or both")
+        return v
+
+    @field_validator("cvd_fast_window")
+    @classmethod
+    def validate_cvd_fast(cls, v):
+        if v not in {"5m", "15m", "30m"}:
+            raise ValueError("cvd_fast_window must be 5m, 15m, or 30m")
+        return v
+
+    @field_validator("cvd_slow_window")
+    @classmethod
+    def validate_cvd_slow(cls, v):
+        if v not in {"30m", "1h", "4h"}:
+            raise ValueError("cvd_slow_window must be 30m, 1h, or 4h")
+        return v
+
+    @field_validator("weight_direction")
+    @classmethod
+    def validate_w_dir(cls, v):
+        if not 10 <= v <= 80:
+            raise ValueError("weight_direction must be 10-80")
+        return v
+
+    @field_validator("weight_env")
+    @classmethod
+    def validate_w_env(cls, v):
+        if not 5 <= v <= 60:
+            raise ValueError("weight_env must be 5-60")
+        return v
+
+    @field_validator("weight_aux")
+    @classmethod
+    def validate_w_aux(cls, v):
+        if not 0 <= v <= 40:
+            raise ValueError("weight_aux must be 0-40")
+        return v
+
+    @field_validator("weight_momentum")
+    @classmethod
+    def validate_w_mom(cls, v):
+        if not 0 <= v <= 20:
+            raise ValueError("weight_momentum must be 0-20")
+        return v
+
+    @model_validator(mode="after")
+    def validate_weights_sum(self):
+        total = self.weight_direction + self.weight_env + self.weight_aux + self.weight_momentum
+        if total != 100:
+            raise ValueError(f"Weights must sum to 100, got {total}")
+        return self
+
+    @field_validator("entry_score")
+    @classmethod
+    def validate_entry_score(cls, v):
+        if not 60 <= v <= 95:
+            raise ValueError("entry_score must be 60-95")
+        return v
+
+    @field_validator("obi_threshold")
+    @classmethod
+    def validate_obi(cls, v):
+        if not 0.1 <= v <= 0.9:
+            raise ValueError("obi_threshold must be 0.1-0.9")
+        return v
+
+    @field_validator("whale_cvd_threshold")
+    @classmethod
+    def validate_whale(cls, v):
+        if not -1.0 <= v <= 1.0:
+            raise ValueError("whale_cvd_threshold must be -1.0 to 1.0")
+        return v
+
+    @field_validator("atr_percentile_min")
+    @classmethod
+    def validate_atr_pct(cls, v):
+        if not 5 <= v <= 80:
+            raise ValueError("atr_percentile_min must be 5-80")
+        return v
+
+    @field_validator("spot_perp_threshold")
+    @classmethod
+    def validate_spot_perp(cls, v):
+        if not 0.0005 <= v <= 0.01:
+            raise ValueError("spot_perp_threshold must be 0.0005-0.01")
+        return v
+
+    @field_validator("sl_atr_multiplier")
+    @classmethod
+    def validate_sl(cls, v):
+        if not 0.5 <= v <= 3.0:
+            raise ValueError("sl_atr_multiplier must be 0.5-3.0")
+        return v
+
+    @field_validator("tp1_ratio")
+    @classmethod
+    def validate_tp1(cls, v):
+        if not 0.3 <= v <= 2.0:
+            raise ValueError("tp1_ratio must be 0.3-2.0")
+        return v
+
+    @field_validator("tp2_ratio")
+    @classmethod
+    def validate_tp2(cls, v):
+        if not 0.5 <= v <= 4.0:
+            raise ValueError("tp2_ratio must be 0.5-4.0")
+        return v
+
+    @field_validator("timeout_minutes")
+    @classmethod
+    def validate_timeout(cls, v):
+        if not 30 <= v <= 1440:
+            raise ValueError("timeout_minutes must be 30-1440")
+        return v
+
+    @field_validator("flip_threshold")
+    @classmethod
+    def validate_flip(cls, v):
+        if not 60 <= v <= 95:
+            raise ValueError("flip_threshold must be 60-95")
+        return v
+
+    @field_validator("initial_balance")
+    @classmethod
+    def validate_balance(cls, v):
+        if v < 1000:
+            raise ValueError("initial_balance must be >= 1000")
+        return v
+
+
+class StrategyUpdateRequest(BaseModel):
+    """Partial update - all fields optional"""
+    display_name: Optional[str] = Field(None, min_length=1, max_length=50)
+    direction: Optional[str] = None
+    cvd_fast_window: Optional[str] = None
+    cvd_slow_window: Optional[str] = None
+    weight_direction: Optional[int] = None
+    weight_env: Optional[int] = None
+    weight_aux: Optional[int] = None
+    weight_momentum: Optional[int] = None
+    entry_score: Optional[int] = None
+    gate_obi_enabled: Optional[bool] = None
+    obi_threshold: Optional[float] = None
+    gate_whale_enabled: Optional[bool] = None
+    whale_cvd_threshold: Optional[float] = None
+    gate_vol_enabled: Optional[bool] = None
+    atr_percentile_min: Optional[int] = None
+    gate_spot_perp_enabled: Optional[bool] = None
+    spot_perp_threshold: Optional[float] = None
+    sl_atr_multiplier: Optional[float] = None
+    tp1_ratio: Optional[float] = None
+    tp2_ratio: Optional[float] = None
+    timeout_minutes: Optional[int] = None
+    flip_threshold: Optional[int] = None
+    description: Optional[str] = None
+
+
+class AddBalanceRequest(BaseModel):
+    amount: float = Field(..., gt=0)
+
+
+class DeprecateRequest(BaseModel):
+    confirm: bool
+
+
+# ── Helper ──────────────────────────────────────────────────────────────────
+
+async def _get_strategy_or_404(strategy_id: str) -> dict:
+    row = await async_fetchrow(
+        "SELECT * FROM strategies WHERE strategy_id=$1",
+        strategy_id
+    )
+    if not row:
+        raise HTTPException(status_code=404, detail="Strategy not found")
+    return dict(row)
+
+
+def _strategy_row_to_card(row: dict) -> dict:
+    """Convert a strategies row to a card-level response (no config params)"""
+    return {
+        "strategy_id": str(row["strategy_id"]),
+        "display_name": row["display_name"],
+        "status": row["status"],
+        "symbol": row["symbol"],
+        "direction": row["direction"],
+        "started_at": int(row["created_at"].timestamp() * 1000) if row.get("created_at") else 0,
+        "initial_balance": row["initial_balance"],
+        "current_balance": row["current_balance"],
+        "net_usdt": round(row["current_balance"] - row["initial_balance"], 2),
+        "deprecated_at": int(row["deprecated_at"].timestamp() * 1000) if row.get("deprecated_at") else None,
+        "last_run_at": int(row["last_run_at"].timestamp() * 1000) if row.get("last_run_at") else None,
+        "schema_version": row["schema_version"],
+    }
+
+
+def _strategy_row_to_detail(row: dict) -> dict:
+    """Full detail including all config params"""
+    base = _strategy_row_to_card(row)
+    base.update({
+        "cvd_fast_window": row["cvd_fast_window"],
+        "cvd_slow_window": row["cvd_slow_window"],
+        "weight_direction": row["weight_direction"],
+        "weight_env": row["weight_env"],
+        "weight_aux": row["weight_aux"],
+        "weight_momentum": row["weight_momentum"],
+        "entry_score": row["entry_score"],
+        "gate_obi_enabled": row["gate_obi_enabled"],
+        "obi_threshold": row["obi_threshold"],
+        "gate_whale_enabled": row["gate_whale_enabled"],
+        "whale_cvd_threshold": row["whale_cvd_threshold"],
+        "gate_vol_enabled": row["gate_vol_enabled"],
+        "atr_percentile_min": row["atr_percentile_min"],
+        "gate_spot_perp_enabled": row["gate_spot_perp_enabled"],
+        "spot_perp_threshold": row["spot_perp_threshold"],
+        "sl_atr_multiplier": row["sl_atr_multiplier"],
+        "tp1_ratio": row["tp1_ratio"],
+        "tp2_ratio": row["tp2_ratio"],
+        "timeout_minutes": row["timeout_minutes"],
+        "flip_threshold": row["flip_threshold"],
+        "description": row.get("description"),
+        "created_at": int(row["created_at"].timestamp() * 1000) if row.get("created_at") else 0,
+        "updated_at": int(row["updated_at"].timestamp() * 1000) if row.get("updated_at") else 0,
+    })
+    return base
+
+
+async def _get_strategy_trade_stats(strategy_id: str) -> dict:
+    """Fetch trade statistics for a strategy by strategy_id"""
+    rows = await async_fetch(
+        """SELECT status, pnl_r, tp1_hit, entry_ts, exit_ts
+           FROM paper_trades
+           WHERE strategy_id=$1 AND status != 'active'
+           ORDER BY entry_ts DESC""",
+        strategy_id
+    )
+    if not rows:
+        return {
+            "trade_count": 0, "win_rate": 0.0,
+            "avg_win_r": 0.0, "avg_loss_r": 0.0,
+            "open_positions": 0,
+            "pnl_usdt_24h": 0.0, "pnl_r_24h": 0.0,
+            "last_trade_at": None,
+        }
+
+    total = len(rows)
+    wins = [r for r in rows if (r["pnl_r"] or 0) > 0]
+    losses = [r for r in rows if (r["pnl_r"] or 0) < 0]
+    win_rate = round(len(wins) / total * 100, 1) if total else 0.0
+    avg_win = round(sum(r["pnl_r"] for r in wins) / len(wins), 3) if wins else 0.0
+    avg_loss = round(sum(r["pnl_r"] for r in losses) / len(losses), 3) if losses else 0.0
+    last_trade_at = rows[0]["exit_ts"] if rows else None
+
+    # 24h stats
+    cutoff_ms = int((datetime.utcnow() - timedelta(hours=24)).timestamp() * 1000)
+    rows_24h = [r for r in rows if (r["exit_ts"] or 0) >= cutoff_ms]
+    pnl_r_24h = round(sum(r["pnl_r"] or 0 for r in rows_24h), 3)
+    pnl_usdt_24h = round(pnl_r_24h * 200, 2)
+
+    # Open positions
+    open_rows = await async_fetch(
+        "SELECT COUNT(*) as cnt FROM paper_trades WHERE strategy_id=$1 AND status='active'",
+        strategy_id
+    )
+    open_positions = open_rows[0]["cnt"] if open_rows else 0
+
+    return {
+        "trade_count": total,
+        "win_rate": win_rate,
+        "avg_win_r": avg_win,
+        "avg_loss_r": avg_loss,
+        "open_positions": open_positions,
+        "pnl_usdt_24h": pnl_usdt_24h,
+        "pnl_r_24h": pnl_r_24h,
+        "last_trade_at": last_trade_at,
+    }
+
+
+# ── Endpoints ────────────────────────────────────────────────────────────────
+
+@app.post("/api/strategies")
+async def create_strategy(body: StrategyCreateRequest, user: dict = Depends(get_current_user)):
+    """创建新策略实例"""
+    new_id = str(_uuid.uuid4())
+    await async_execute(
+        """INSERT INTO strategies (
+            strategy_id, display_name, schema_version, status,
+            symbol, direction,
+            cvd_fast_window, cvd_slow_window,
+            weight_direction, weight_env, weight_aux, weight_momentum,
+            entry_score,
+            gate_obi_enabled, obi_threshold,
+            gate_whale_enabled, whale_cvd_threshold,
+            gate_vol_enabled, atr_percentile_min,
+            gate_spot_perp_enabled, spot_perp_threshold,
+            sl_atr_multiplier, tp1_ratio, tp2_ratio,
+            timeout_minutes, flip_threshold,
+            initial_balance, current_balance,
+            description
+        ) VALUES (
+            $1,$2,1,'running',
+            $3,$4,$5,$6,
+            $7,$8,$9,$10,
+            $11,
+            $12,$13,$14,$15,$16,$17,$18,$19,
+            $20,$21,$22,$23,$24,
+            $25,$25,$26
+        )""",
+        new_id, body.display_name,
+        body.symbol, body.direction, body.cvd_fast_window, body.cvd_slow_window,
+        body.weight_direction, body.weight_env, body.weight_aux, body.weight_momentum,
+        body.entry_score,
+        body.gate_obi_enabled, body.obi_threshold,
+        body.gate_whale_enabled, body.whale_cvd_threshold,
+        body.gate_vol_enabled, body.atr_percentile_min,
+        body.gate_spot_perp_enabled, body.spot_perp_threshold,
+        body.sl_atr_multiplier, body.tp1_ratio, body.tp2_ratio,
+        body.timeout_minutes, body.flip_threshold,
+        body.initial_balance, body.description
+    )
+    row = await async_fetchrow("SELECT * FROM strategies WHERE strategy_id=$1", new_id)
+    return {"ok": True, "strategy": _strategy_row_to_detail(dict(row))}
+
+
+@app.get("/api/strategies")
+async def list_strategies(
+    include_deprecated: bool = False,
+    user: dict = Depends(get_current_user)
+):
+    """获取策略列表"""
+    if include_deprecated:
+        rows = await async_fetch("SELECT * FROM strategies ORDER BY created_at ASC")
+    else:
+        rows = await async_fetch(
+            "SELECT * FROM strategies WHERE status != 'deprecated' ORDER BY created_at ASC"
+        )
+    result = []
+    for row in rows:
+        d = _strategy_row_to_card(dict(row))
+        stats = await _get_strategy_trade_stats(str(row["strategy_id"]))
+        d.update(stats)
+        result.append(d)
+    return {"strategies": result}
+
+
+@app.get("/api/strategies/{sid}")
+async def get_strategy(sid: str, user: dict = Depends(get_current_user)):
+    """获取单个策略详情（含完整参数配置）"""
+    row = await _get_strategy_or_404(sid)
+    detail = _strategy_row_to_detail(row)
+    stats = await _get_strategy_trade_stats(sid)
+    detail.update(stats)
+    return {"strategy": detail}
+
+
+@app.patch("/api/strategies/{sid}")
+async def update_strategy(sid: str, body: StrategyUpdateRequest, user: dict = Depends(get_current_user)):
+    """更新策略参数（Partial Update）"""
+    row = await _get_strategy_or_404(sid)
+    if row["status"] == "deprecated":
+        raise HTTPException(status_code=403, detail="Cannot modify a deprecated strategy")
+
+    # Build SET clause dynamically from non-None fields
+    updates = body.model_dump(exclude_none=True)
+    if not updates:
+        raise HTTPException(status_code=400, detail="No fields to update")
+
+    # Validate weights sum if any weight is being changed
+    weight_fields = {"weight_direction", "weight_env", "weight_aux", "weight_momentum"}
+    if weight_fields & set(updates.keys()):
+        w_dir = updates.get("weight_direction", row["weight_direction"])
+        w_env = updates.get("weight_env", row["weight_env"])
+        w_aux = updates.get("weight_aux", row["weight_aux"])
+        w_mom = updates.get("weight_momentum", row["weight_momentum"])
+        if w_dir + w_env + w_aux + w_mom != 100:
+            raise HTTPException(status_code=400, detail=f"Weights must sum to 100, got {w_dir+w_env+w_aux+w_mom}")
+
+    # Validate individual field ranges
+    validators = {
+        "direction": lambda v: v in {"long_only", "short_only", "both"},
+        "cvd_fast_window": lambda v: v in {"5m", "15m", "30m"},
+        "cvd_slow_window": lambda v: v in {"30m", "1h", "4h"},
+        "weight_direction": lambda v: 10 <= v <= 80,
+        "weight_env": lambda v: 5 <= v <= 60,
+        "weight_aux": lambda v: 0 <= v <= 40,
+        "weight_momentum": lambda v: 0 <= v <= 20,
+        "entry_score": lambda v: 60 <= v <= 95,
+        "obi_threshold": lambda v: 0.1 <= v <= 0.9,
+        "whale_cvd_threshold": lambda v: -1.0 <= v <= 1.0,
+        "atr_percentile_min": lambda v: 5 <= v <= 80,
+        "spot_perp_threshold": lambda v: 0.0005 <= v <= 0.01,
+        "sl_atr_multiplier": lambda v: 0.5 <= v <= 3.0,
+        "tp1_ratio": lambda v: 0.3 <= v <= 2.0,
+        "tp2_ratio": lambda v: 0.5 <= v <= 4.0,
+        "timeout_minutes": lambda v: 30 <= v <= 1440,
+        "flip_threshold": lambda v: 60 <= v <= 95,
+    }
+    for field, val in updates.items():
+        if field in validators and not validators[field](val):
+            raise HTTPException(status_code=400, detail=f"Invalid value for {field}: {val}")
+
+    # Execute update
+    set_parts = [f"{k}=${i+2}" for i, k in enumerate(updates.keys())]
+    set_parts.append(f"updated_at=NOW()")
+    sql = f"UPDATE strategies SET {', '.join(set_parts)} WHERE strategy_id=$1"
+    await async_execute(sql, sid, *updates.values())
+
+    updated = await async_fetchrow("SELECT * FROM strategies WHERE strategy_id=$1", sid)
+    return {"ok": True, "strategy": _strategy_row_to_detail(dict(updated))}
+
+
+@app.post("/api/strategies/{sid}/pause")
+async def pause_strategy(sid: str, user: dict = Depends(get_current_user)):
+    """暂停策略（停止开新仓，不影响现有持仓）"""
+    row = await _get_strategy_or_404(sid)
+    if row["status"] == "deprecated":
+        raise HTTPException(status_code=403, detail="Cannot pause a deprecated strategy")
+    if row["status"] == "paused":
+        return {"ok": True, "message": "Already paused"}
+    await async_execute(
+        "UPDATE strategies SET status='paused', status_changed_at=NOW(), updated_at=NOW() WHERE strategy_id=$1",
+        sid
+    )
+    return {"ok": True, "status": "paused"}
+
+
+@app.post("/api/strategies/{sid}/resume")
+async def resume_strategy(sid: str, user: dict = Depends(get_current_user)):
+    """恢复策略"""
+    row = await _get_strategy_or_404(sid)
+    if row["status"] == "running":
+        return {"ok": True, "message": "Already running"}
+    await async_execute(
+        "UPDATE strategies SET status='running', status_changed_at=NOW(), updated_at=NOW() WHERE strategy_id=$1",
+        sid
+    )
+    return {"ok": True, "status": "running"}
+
+
+@app.post("/api/strategies/{sid}/deprecate")
+async def deprecate_strategy(sid: str, body: DeprecateRequest, user: dict = Depends(get_current_user)):
+    """废弃策略（数据永久保留，可重新启用）"""
+    if not body.confirm:
+        raise HTTPException(status_code=400, detail="Must set confirm=true to deprecate")
+    row = await _get_strategy_or_404(sid)
+    if row["status"] == "deprecated":
+        return {"ok": True, "message": "Already deprecated"}
+    await async_execute(
+        """UPDATE strategies
+           SET status='deprecated', deprecated_at=NOW(),
+               status_changed_at=NOW(), updated_at=NOW()
+           WHERE strategy_id=$1""",
+        sid
+    )
+    return {"ok": True, "status": "deprecated"}
+
+
+@app.post("/api/strategies/{sid}/restore")
+async def restore_strategy(sid: str, user: dict = Depends(get_current_user)):
+    """重新启用废弃策略（继续原有余额和历史数据）"""
+    row = await _get_strategy_or_404(sid)
+    if row["status"] != "deprecated":
+        raise HTTPException(status_code=400, detail="Strategy is not deprecated")
+    await async_execute(
+        """UPDATE strategies
+           SET status='running', deprecated_at=NULL,
+               status_changed_at=NOW(), updated_at=NOW()
+           WHERE strategy_id=$1""",
+        sid
+    )
+    return {"ok": True, "status": "running"}
+
+
+@app.post("/api/strategies/{sid}/add-balance")
+async def add_balance(sid: str, body: AddBalanceRequest, user: dict = Depends(get_current_user)):
+    """追加余额（initial_balance 和 current_balance 同步增加）"""
+    row = await _get_strategy_or_404(sid)
+    if row["status"] == "deprecated":
+        raise HTTPException(status_code=403, detail="Cannot add balance to a deprecated strategy")
+    new_initial = round(row["initial_balance"] + body.amount, 2)
+    new_current = round(row["current_balance"] + body.amount, 2)
+    await async_execute(
+        """UPDATE strategies
+           SET initial_balance=$2, current_balance=$3, updated_at=NOW()
+           WHERE strategy_id=$1""",
+        sid, new_initial, new_current
+    )
+    return {
+        "ok": True,
+        "initial_balance": new_initial,
+        "current_balance": new_current,
+        "added": body.amount,
+    }

backend/migrate_v54.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+"""
+V5.4 Strategy Factory DB Migration Script
+- Creates `strategies` table
+- Adds strategy_id + strategy_name_snapshot to paper_trades, signal_indicators
+- Inserts existing 3 strategies with fixed UUIDs
+- Backfills strategy_id + strategy_name_snapshot for all existing records
+"""
+
+import os
+import sys
+import psycopg2
+from psycopg2.extras import execute_values
+
+PG_HOST = os.environ.get("PG_HOST", "10.106.0.3")
+PG_PASS = os.environ.get("PG_PASS", "arb_engine_2026")
+PG_USER = "arb"
+PG_DB = "arb_engine"
+
+# Fixed UUIDs for existing strategies (deterministic, easy to recognize)
+LEGACY_STRATEGY_MAP = {
+    "v53":        ("00000000-0000-0000-0000-000000000053", "V5.3 Standard"),
+    "v53_middle": ("00000000-0000-0000-0000-000000000054", "V5.3 Middle"),
+    "v53_fast":   ("00000000-0000-0000-0000-000000000055", "V5.3 Fast"),
+}
+
+# Default config values per strategy (from strategy JSON files)
+LEGACY_CONFIGS = {
+    "v53": {
+        "symbol": "BTCUSDT",  # multi-symbol, use BTC as representative
+        "cvd_fast_window": "30m",
+        "cvd_slow_window": "4h",
+        "weight_direction": 55,
+        "weight_env": 25,
+        "weight_aux": 15,
+        "weight_momentum": 5,
+        "entry_score": 75,
+        "sl_atr_multiplier": 1.0,
+        "tp1_ratio": 0.75,
+        "tp2_ratio": 1.5,
+        "timeout_minutes": 60,
+        "flip_threshold": 75,
+        "status": "running",
+        "initial_balance": 10000.0,
+    },
+    "v53_middle": {
+        "symbol": "BTCUSDT",
+        "cvd_fast_window": "15m",
+        "cvd_slow_window": "1h",
+        "weight_direction": 55,
+        "weight_env": 25,
+        "weight_aux": 15,
+        "weight_momentum": 5,
+        "entry_score": 75,
+        "sl_atr_multiplier": 1.0,
+        "tp1_ratio": 0.75,
+        "tp2_ratio": 1.5,
+        "timeout_minutes": 60,
+        "flip_threshold": 75,
+        "status": "running",
+        "initial_balance": 10000.0,
+    },
+    "v53_fast": {
+        "symbol": "BTCUSDT",
+        "cvd_fast_window": "5m",
+        "cvd_slow_window": "30m",
+        "weight_direction": 55,
+        "weight_env": 25,
+        "weight_aux": 15,
+        "weight_momentum": 5,
+        "entry_score": 75,
+        "sl_atr_multiplier": 1.0,
+        "tp1_ratio": 0.75,
+        "tp2_ratio": 1.5,
+        "timeout_minutes": 60,
+        "flip_threshold": 75,
+        "status": "running",
+        "initial_balance": 10000.0,
+    },
+}
+
+
+def get_conn():
+    return psycopg2.connect(
+        host=PG_HOST, user=PG_USER, password=PG_PASS, dbname=PG_DB
+    )
+
+
+def step1_create_strategies_table(cur):
+    print("[Step 1] Creating strategies table...")
+    cur.execute("""
+        CREATE TABLE IF NOT EXISTS strategies (
+            strategy_id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+            display_name        TEXT NOT NULL,
+            schema_version      INT NOT NULL DEFAULT 1,
+            status              TEXT NOT NULL DEFAULT 'running'
+                                CHECK (status IN ('running', 'paused', 'deprecated')),
+            status_changed_at   TIMESTAMP,
+            last_run_at         TIMESTAMP,
+            deprecated_at       TIMESTAMP,
+            symbol              TEXT NOT NULL
+                                CHECK (symbol IN ('BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'XRPUSDT')),
+            direction           TEXT NOT NULL DEFAULT 'both'
+                                CHECK (direction IN ('long_only', 'short_only', 'both')),
+            cvd_fast_window     TEXT NOT NULL DEFAULT '30m'
+                                CHECK (cvd_fast_window IN ('5m', '15m', '30m')),
+            cvd_slow_window     TEXT NOT NULL DEFAULT '4h'
+                                CHECK (cvd_slow_window IN ('30m', '1h', '4h')),
+            weight_direction    INT NOT NULL DEFAULT 55,
+            weight_env          INT NOT NULL DEFAULT 25,
+            weight_aux          INT NOT NULL DEFAULT 15,
+            weight_momentum     INT NOT NULL DEFAULT 5,
+            entry_score         INT NOT NULL DEFAULT 75,
+            gate_obi_enabled        BOOL NOT NULL DEFAULT TRUE,
+            obi_threshold           FLOAT NOT NULL DEFAULT 0.3,
+            gate_whale_enabled      BOOL NOT NULL DEFAULT TRUE,
+            whale_cvd_threshold     FLOAT NOT NULL DEFAULT 0.0,
+            gate_vol_enabled        BOOL NOT NULL DEFAULT TRUE,
+            atr_percentile_min      INT NOT NULL DEFAULT 20,
+            gate_spot_perp_enabled  BOOL NOT NULL DEFAULT FALSE,
+            spot_perp_threshold     FLOAT NOT NULL DEFAULT 0.002,
+            sl_atr_multiplier   FLOAT NOT NULL DEFAULT 1.5,
+            tp1_ratio           FLOAT NOT NULL DEFAULT 0.75,
+            tp2_ratio           FLOAT NOT NULL DEFAULT 1.5,
+            timeout_minutes     INT NOT NULL DEFAULT 240,
+            flip_threshold      INT NOT NULL DEFAULT 80,
+            initial_balance     FLOAT NOT NULL DEFAULT 10000.0,
+            current_balance     FLOAT NOT NULL DEFAULT 10000.0,
+            description         TEXT,
+            tags                TEXT[],
+            created_at          TIMESTAMP NOT NULL DEFAULT NOW(),
+            updated_at          TIMESTAMP NOT NULL DEFAULT NOW()
+        )
+    """)
+    cur.execute("CREATE INDEX IF NOT EXISTS idx_strategies_status ON strategies(status)")
+    cur.execute("CREATE INDEX IF NOT EXISTS idx_strategies_symbol ON strategies(symbol)")
+    cur.execute("CREATE INDEX IF NOT EXISTS idx_strategies_last_run ON strategies(last_run_at)")
+    print("[Step 1] Done.")
+
+
+def step2_add_columns(cur):
+    print("[Step 2] Adding strategy_id + strategy_name_snapshot columns...")
+    # paper_trades
+    for col, col_type in [
+        ("strategy_id", "UUID REFERENCES strategies(strategy_id)"),
+        ("strategy_name_snapshot", "TEXT"),
+    ]:
+        cur.execute(f"""
+            ALTER TABLE paper_trades
+            ADD COLUMN IF NOT EXISTS {col} {col_type}
+        """)
+    # signal_indicators
+    for col, col_type in [
+        ("strategy_id", "UUID REFERENCES strategies(strategy_id)"),
+        ("strategy_name_snapshot", "TEXT"),
+    ]:
+        cur.execute(f"""
+            ALTER TABLE signal_indicators
+            ADD COLUMN IF NOT EXISTS {col} {col_type}
+        """)
+    # Indexes
+    cur.execute("CREATE INDEX IF NOT EXISTS idx_paper_trades_strategy_id ON paper_trades(strategy_id)")
+    cur.execute("CREATE INDEX IF NOT EXISTS idx_si_strategy_id ON signal_indicators(strategy_id)")
+    print("[Step 2] Done.")
+
+
+def step3_insert_legacy_strategies(cur):
+    print("[Step 3] Inserting legacy strategies into strategies table...")
+    for strategy_name, (uuid, display_name) in LEGACY_STRATEGY_MAP.items():
+        cfg = LEGACY_CONFIGS[strategy_name]
+        # Compute current_balance from actual paper trades
+        cur.execute("""
+            SELECT
+                COALESCE(SUM(pnl_r) * 200, 0) as total_pnl_usdt
+            FROM paper_trades
+            WHERE strategy = %s AND status != 'active'
+        """, (strategy_name,))
+        row = cur.fetchone()
+        pnl_usdt = row[0] if row else 0
+        current_balance = round(cfg["initial_balance"] + pnl_usdt, 2)
+
+        cur.execute("""
+            INSERT INTO strategies (
+                strategy_id, display_name, schema_version, status,
+                symbol, direction,
+                cvd_fast_window, cvd_slow_window,
+                weight_direction, weight_env, weight_aux, weight_momentum,
+                entry_score,
+                gate_obi_enabled, obi_threshold,
+                gate_whale_enabled, whale_cvd_threshold,
+                gate_vol_enabled, atr_percentile_min,
+                gate_spot_perp_enabled, spot_perp_threshold,
+                sl_atr_multiplier, tp1_ratio, tp2_ratio,
+                timeout_minutes, flip_threshold,
+                initial_balance, current_balance,
+                description
+            ) VALUES (
+                %s, %s, 1, %s,
+                %s, 'both',
+                %s, %s,
+                %s, %s, %s, %s,
+                %s,
+                TRUE, 0.3,
+                TRUE, 0.0,
+                TRUE, 20,
+                FALSE, 0.002,
+                %s, %s, %s,
+                %s, %s,
+                %s, %s,
+                %s
+            )
+            ON CONFLICT (strategy_id) DO NOTHING
+        """, (
+            uuid, display_name, cfg["status"],
+            cfg["symbol"], cfg["cvd_fast_window"], cfg["cvd_slow_window"],
+            cfg["weight_direction"], cfg["weight_env"], cfg["weight_aux"], cfg["weight_momentum"],
+            cfg["entry_score"],
+            cfg["sl_atr_multiplier"], cfg["tp1_ratio"], cfg["tp2_ratio"],
+            cfg["timeout_minutes"], cfg["flip_threshold"],
+            cfg["initial_balance"], current_balance,
+            f"Migrated from V5.3 legacy strategy: {strategy_name}"
+        ))
+        print(f"  Inserted {strategy_name} → {uuid} (balance: {current_balance})")
+    print("[Step 3] Done.")
+
+
+def step4_backfill(cur):
+    print("[Step 4] Backfilling strategy_id + strategy_name_snapshot...")
+    for strategy_name, (uuid, display_name) in LEGACY_STRATEGY_MAP.items():
+        # paper_trades
+        cur.execute("""
+            UPDATE paper_trades
+            SET strategy_id = %s::uuid,
+                strategy_name_snapshot = %s
+            WHERE strategy = %s AND strategy_id IS NULL
+        """, (uuid, display_name, strategy_name))
+        count = cur.rowcount
+        print(f"  paper_trades [{strategy_name}]: {count} rows updated")
+
+        # signal_indicators
+        cur.execute("""
+            UPDATE signal_indicators
+            SET strategy_id = %s::uuid,
+                strategy_name_snapshot = %s
+            WHERE strategy = %s AND strategy_id IS NULL
+        """, (uuid, display_name, strategy_name))
+        count = cur.rowcount
+        print(f"  signal_indicators [{strategy_name}]: {count} rows updated")
+
+    print("[Step 4] Done.")
+
+
+def step5_verify(cur):
+    print("[Step 5] Verifying migration completeness...")
+    # Check strategies table
+    cur.execute("SELECT COUNT(*) FROM strategies")
+    n = cur.fetchone()[0]
+    print(f"  strategies table: {n} rows")
+
+    # Check NULL strategy_id in paper_trades (for known strategies)
+    cur.execute("""
+        SELECT strategy, COUNT(*) as cnt
+        FROM paper_trades
+        WHERE strategy IN ('v53', 'v53_middle', 'v53_fast')
+          AND strategy_id IS NULL
+        GROUP BY strategy
+    """)
+    rows = cur.fetchall()
+    if rows:
+        print(f"  WARNING: NULL strategy_id found in paper_trades:")
+        for r in rows:
+            print(f"    {r[0]}: {r[1]} rows")
+    else:
+        print("  paper_trades: all known strategies backfilled ✅")
+
+    # Check NULL in signal_indicators
+    cur.execute("""
+        SELECT strategy, COUNT(*) as cnt
+        FROM signal_indicators
+        WHERE strategy IN ('v53', 'v53_middle', 'v53_fast')
+          AND strategy_id IS NULL
+        GROUP BY strategy
+    """)
+    rows = cur.fetchall()
+    if rows:
+        print(f"  WARNING: NULL strategy_id found in signal_indicators:")
+        for r in rows:
+            print(f"    {r[0]}: {r[1]} rows")
+    else:
+        print("  signal_indicators: all known strategies backfilled ✅")
+
+    print("[Step 5] Done.")
+
+
+def main():
+    dry_run = "--dry-run" in sys.argv
+    if dry_run:
+        print("=== DRY RUN MODE (no changes will be committed) ===")
+
+    conn = get_conn()
+    conn.autocommit = False
+    cur = conn.cursor()
+
+    try:
+        step1_create_strategies_table(cur)
+        step2_add_columns(cur)
+        step3_insert_legacy_strategies(cur)
+        step4_backfill(cur)
+        step5_verify(cur)
+
+        if dry_run:
+            conn.rollback()
+            print("\n=== DRY RUN: rolled back all changes ===")
+        else:
+            conn.commit()
+            print("\n=== Migration completed successfully ✅ ===")
+    except Exception as e:
+        conn.rollback()
+        print(f"\n=== ERROR: {e} ===")
+        raise
+    finally:
+        cur.close()
+        conn.close()
+
+
+if __name__ == "__main__":
+    main()