src/main/java/com/xcong/excoin/modules/gateApi/GateCommandConsumer.java

@@ -73,6 +73,42 @@
                    log.info("[Gate] 远程参数已持久化");
                    break;

                case "CANCEL_LONG_TP_SL":
                    strategy.cancelLongTakeProfitAndStopLoss();
                    message = "已取消多仓止盈止损";
                    log.info("[Gate] 远程取消多仓止盈止损");
                    break;

                case "CANCEL_SHORT_TP_SL":
                    strategy.cancelShortTakeProfitAndStopLoss();
                    message = "已取消空仓止盈止损";
                    log.info("[Gate] 远程取消空仓止盈止损");
                    break;

                case "REBUILD_LONG_TP_SL":
                    strategy.rebuildLongTakeProfitAndStopLoss();
                    message = "已生成多仓止盈止损";
                    log.info("[Gate] 远程生成多仓止盈止损");
                    break;

                case "REBUILD_SHORT_TP_SL":
                    strategy.rebuildShortTakeProfitAndStopLoss();
                    message = "已生成空仓止盈止损";
                    log.info("[Gate] 远程生成空仓止盈止损");
                    break;

                case "CLOSE_LONG":
                    strategy.closeLongPosition();
                    message = "已提交多单平仓";
                    log.info("[Gate] 远程多单平仓");
                    break;

                case "CLOSE_SHORT":
                    strategy.closeShortPosition();
                    message = "已提交空单平仓";
                    log.info("[Gate] 远程空单平仓");
                    break;

                default:
                    success = false;
                    message = "未知指令类型: " + cmd.getCommandType();

 src/main/java/com/xcong/excoin/modules/gateApi/GateConfig.java

@@ -130,6 +130,12 @@

    /** 止盈挂单模式：off=关闭 / concentrated=集中止盈 / dispersed=分散止盈，默认 off */
    private final String placeExcessTakeProfit;
    /** 自定义止损开关：true=启用自定义止损触发价（多空各挂一单），false=使用默认阶梯止损。默认 false */
    private final boolean dualStopLossEnabled;
    /** 多仓自定义止损触发价（价格跌至该值触发平多），null/0=未设置 */
    private final BigDecimal longStopLossPrice;
    /** 空仓自定义止损触发价（价格涨至该值触发平空），null/0=未设置 */
    private final BigDecimal shortStopLossPrice;
    /** 网格绝对步长（shortBaseEntryPrice × gridRate），运行时由队列生成逻辑设置 */
    private BigDecimal step;
    /** 网格元素列表，由队列初始化时同步填充，包含完整的多空仓挂单状态 */
@@ -171,6 +177,9 @@
        this.maxPositionPerSide = builder.maxPositionPerSide;
        this.addPositionStartThreshold = builder.addPositionStartThreshold;
        this.placeExcessTakeProfit = builder.placeExcessTakeProfit;
        this.dualStopLossEnabled = builder.dualStopLossEnabled;
        this.longStopLossPrice = builder.longStopLossPrice;
        this.shortStopLossPrice = builder.shortStopLossPrice;
    }

    // ==================== REST/WS 地址 ====================
@@ -278,6 +287,12 @@
    public int getAddPositionStartThreshold() { return addPositionStartThreshold; }
    /** @return 止盈挂单模式：off=关闭 / concentrated=集中止盈 / dispersed=分散止盈 */
    public String getPlaceExcessTakeProfit() { return placeExcessTakeProfit; }
    /** @return 自定义止损开关：true=启用自定义止损触发价，false=使用默认阶梯止损 */
    public boolean isDualStopLossEnabled() { return dualStopLossEnabled; }
    /** @return 多仓自定义止损触发价，null/0=未设置 */
    public BigDecimal getLongStopLossPrice() { return longStopLossPrice; }
    /** @return 空仓自定义止损触发价，null/0=未设置 */
    public BigDecimal getShortStopLossPrice() { return shortStopLossPrice; }

    // ==================== 运行时参数 ====================

@@ -390,6 +405,12 @@
        private int addPositionStartThreshold = 1;
        /** 止盈挂单模式：off=关闭 / concentrated=集中止盈 / dispersed=分散止盈，默认 off */
        private String placeExcessTakeProfit = EXCESS_TP_OFF;
        /** 自定义止损开关：true=启用自定义止损触发价，false=使用默认阶梯止损。默认 false */
        private boolean dualStopLossEnabled = false;
        /** 多仓自定义止损触发价，null=未设置 */
        private BigDecimal longStopLossPrice;
        /** 空仓自定义止损触发价，null=未设置 */
        private BigDecimal shortStopLossPrice;

        /** 设置 API Key */
        public Builder apiKey(String apiKey) { this.apiKey = apiKey; return this; }
@@ -453,6 +474,12 @@
        public Builder addPositionStartThreshold(int addPositionStartThreshold) { this.addPositionStartThreshold = addPositionStartThreshold; return this; }
        /** 设置止盈挂单模式：off / concentrated / dispersed */
        public Builder placeExcessTakeProfit(String placeExcessTakeProfit) { this.placeExcessTakeProfit = placeExcessTakeProfit; return this; }
        /** 设置自定义止损开关：true=启用自定义止损触发价 */
        public Builder dualStopLossEnabled(boolean dualStopLossEnabled) { this.dualStopLossEnabled = dualStopLossEnabled; return this; }
        /** 设置多仓自定义止损触发价 */
        public Builder longStopLossPrice(BigDecimal longStopLossPrice) { this.longStopLossPrice = longStopLossPrice; return this; }
        /** 设置空仓自定义止损触发价 */
        public Builder shortStopLossPrice(BigDecimal shortStopLossPrice) { this.shortStopLossPrice = shortStopLossPrice; return this; }

        public GateConfig build() {
            return new GateConfig(this);

 src/main/java/com/xcong/excoin/modules/gateApi/GateConfigDTO.java

@@ -71,6 +71,12 @@
    private int addPositionStartThreshold;
    /** 止盈挂单模式：off=关闭 / concentrated=集中止盈 / dispersed=分散止盈，默认 off */
    private String placeExcessTakeProfit;
    /** 自定义止损开关：true=启用自定义止损触发价，false=使用默认阶梯止损。null=未设置(默认false) */
    private Boolean dualStopLossEnabled;
    /** 多仓自定义止损触发价（价格跌至该值触发平多），null=未设置 */
    private BigDecimal longStopLossPrice;
    /** 空仓自定义止损触发价（价格涨至该值触发平空），null=未设置 */
    private BigDecimal shortStopLossPrice;

    /**
     * 从 GateConfig 构建 DTO（不暴露 apiSecret）。
@@ -104,6 +110,9 @@
                .maxPositionPerSide(config.getMaxPositionPerSide())
                .addPositionStartThreshold(config.getAddPositionStartThreshold())
                .placeExcessTakeProfit(config.getPlaceExcessTakeProfit())
                .dualStopLossEnabled(config.isDualStopLossEnabled())
                .longStopLossPrice(config.getLongStopLossPrice())
                .shortStopLossPrice(config.getShortStopLossPrice())
                .build();
    }

@@ -131,6 +140,9 @@
        m.put("maxPositionPerSide", maxPositionPerSide);
        m.put("addPositionStartThreshold", addPositionStartThreshold);
        m.put("placeExcessTakeProfit", placeExcessTakeProfit);
        m.put("dualStopLossEnabled", dualStopLossEnabled);
        m.put("longStopLossPrice", longStopLossPrice);
        m.put("shortStopLossPrice", shortStopLossPrice);
        return m;
    }

@@ -165,6 +177,9 @@
                .maxPositionPerSide(0)
                .addPositionStartThreshold(1)
                .placeExcessTakeProfit("off")
                .dualStopLossEnabled(false)
                .longStopLossPrice(null)
                .shortStopLossPrice(null)
                .build();
    }
}

 src/main/java/com/xcong/excoin/modules/gateApi/GateConfigPersistenceService.java

@@ -112,6 +112,9 @@
                .maxPositionPerSide(dto.getMaxPositionPerSide())
                .addPositionStartThreshold(dto.getAddPositionStartThreshold() >= 0 ? dto.getAddPositionStartThreshold() : 1)
                .placeExcessTakeProfit(normalizeTakeProfitMode(dto.getPlaceExcessTakeProfit()))
                .dualStopLossEnabled(nvl(dto.getDualStopLossEnabled(), false))
                .longStopLossPrice(dto.getLongStopLossPrice())
                .shortStopLossPrice(dto.getShortStopLossPrice())
                .build();
    }


 src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java

@@ -15,6 +15,7 @@
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

import com.xcong.excoin.modules.gateApi.wsHandler.handler.CandlestickChannelHandler;
@@ -148,6 +149,8 @@
    private volatile int lastLongStopLossGridId = Integer.MAX_VALUE;
    /** 最近触发止损的空头网格ID */
    private volatile int lastShortStopLossGridId = Integer.MAX_VALUE;
    /** 自定义止损模式激活标记：true=尚未发生第一次止损触发，第一次触发后置 false（触发未触发侧重挂默认） */
    private final AtomicBoolean dualStopLossModeActive = new AtomicBoolean(false);

    private volatile BigDecimal lastKlinePrice;
    private volatile BigDecimal markPrice = BigDecimal.ZERO;
@@ -354,12 +357,15 @@
        shortPositionSize = BigDecimal.ZERO;
        baseLongOpened = false;
        baseShortOpened = false;
        config.setBaseLongTraderParam(null);
        config.setBaseShortTraderParam(null);
        longActive = false;
        shortActive = false;
        accumulatedLongLossCount = 0;
        accumulatedShortLossCount = 0;
        lastLongStopLossGridId = Integer.MAX_VALUE;
        lastShortStopLossGridId = Integer.MAX_VALUE;
        dualStopLossModeActive.set(false);
        shortPriceQueue.clear();
        longPriceQueue.clear();
        totalShortPriceQueue.clear();
@@ -453,12 +459,14 @@
                        .entryOrderId(orderId)
                        .build();
                config.setBaseLongTraderParam(baseLongTp);
                tryGenerateQueues();
            }, null);
            executor.openShort(negate(size), (orderId) -> {
                TraderParam baseShortTp = TraderParam.builder()
                        .entryOrderId(orderId)
                        .build();
                config.setBaseShortTraderParam(baseShortTp);
                tryGenerateQueues();
            }, null);
            return;
        }
@@ -872,17 +880,27 @@
     *   <li>状态切换为 ACTIVE</li>
     * </ol>
     */
    private void tryGenerateQueues() {
        if (baseLongOpened && baseShortOpened) {
    private synchronized void tryGenerateQueues() {
        // 幂等保护：生成队列后 state 切换为 ACTIVE，避免多线程重复执行
        if (state != StrategyState.OPENING) {
            return;
        }
        TraderParam baseLongTraderParam = config.getBaseLongTraderParam();
        TraderParam baseShortTraderParam = config.getBaseShortTraderParam();
        // 需同时满足：多空基底均已成交，且两个下单参数(orderId)均已通过下单成功回调拿到。
        // IOC 市价单成交后 WS 持仓推送可能先于 REST 下单响应返回，必须等参数就绪再生成队列。
        if (!(baseLongOpened && baseShortOpened)
                || baseLongTraderParam == null || baseShortTraderParam == null) {
            return;
        }
        {
            generateShortQueue();
            generateLongQueue();
            updateGridElements();

            GridElement baseGridElement = GridElement.findById(0);
            TraderParam baseLongTraderParam = config.getBaseLongTraderParam();
            baseGridElement.setLongOrderId(baseLongTraderParam.getEntryOrderId());
            baseGridElement.setHasLongOrder(true);
            TraderParam baseShortTraderParam = config.getBaseShortTraderParam();
            baseGridElement.setShortOrderId(baseShortTraderParam.getEntryOrderId());
            baseGridElement.setHasShortOrder(true);

@@ -960,56 +978,182 @@
//                );
//            }

            int shortTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
            for (int id = 2; id <= shortTime; id++) {
                GridElement elem = GridElement.findById(id);
                if (elem == null) {
                    continue;
                }
                BigDecimal triggerPrice = elem.getGridPrice();
                String size = config.getQuantity();
                int finalId = id;
                executor.placeTakeProfit(
                        triggerPrice,
                        FuturesPriceTrigger.RuleEnum.NUMBER_1,
                        ORDER_TYPE_CLOSE_SHORT,
                        size,
                        profitId -> {
                            elem.addShortStopLossOrderId(profitId);
                            GridElement.refreshIndices();
                            log.info("[Gate] 空仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
                        }
                );
            if (config.isDualStopLossEnabled()) {
                placeCustomStopLosses();
            } else {
                placeDefaultStopLossLadders();
            }

            state = StrategyState.ACTIVE;
        }
    }

    // ========== 自定义止损（按触发价各挂一单） ==========

            int longTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
            for (int id = -2; id >= -longTime; id--) {
                GridElement elem = GridElement.findById(id);
                if (elem == null) {
                    continue;
                }
                BigDecimal triggerPrice = elem.getGridPrice();
                String size = config.getQuantity();
                int finalId = id;
    /**
     * 自定义止损初始化：按多空止损触发价匹配最近网格，各挂一张覆盖全仓位（baseQuantity）的止损单。
     * 多仓止损：NUMBER_2（价格 ≤ 触发价平多），空仓止损：NUMBER_1（价格 ≥ 触发价平空）。
     */
    private void placeCustomStopLosses() {
        dualStopLossModeActive.set(true);
        String baseQty = config.getBaseQuantity();
        BigDecimal longPrice = config.getLongStopLossPrice();
        BigDecimal shortPrice = config.getShortStopLossPrice();

        if (longPrice != null && longPrice.compareTo(BigDecimal.ZERO) > 0) {
            GridElement longElem = findNearestGridElementByPrice(longPrice);
            if (longElem != null) {
                BigDecimal triggerPrice = longElem.getGridPrice();
                executor.placeTakeProfit(
                        triggerPrice,
                        FuturesPriceTrigger.RuleEnum.NUMBER_2,
                        ORDER_TYPE_CLOSE_LONG,
                        negate(size),
                        negate(baseQty),
                        profitId -> {
                            elem.addLongStopLossOrderId(profitId);
                            longElem.addLongStopLossOrderId(profitId);
                            GridElement.refreshIndices();
                            log.info("[Gate] 多仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
                            log.info("[Gate] 自定义多仓止损已挂, 目标价:{}, 匹配gridId:{}, 触发价:{}, stopLossId:{}",
                                    longPrice, longElem.getId(), triggerPrice, profitId);
                        }
                );
            } else {
                log.warn("[Gate] 自定义多仓止损价:{} 未匹配到任何网格", longPrice);
            }

            log.info("[Gate] 止损止盈单已全部挂完, 空仓止损:2~{}, 多仓止损:-2~-{}", shortTime, longTime);

            state = StrategyState.ACTIVE;
        }

        if (shortPrice != null && shortPrice.compareTo(BigDecimal.ZERO) > 0) {
            GridElement shortElem = findNearestGridElementByPrice(shortPrice);
            if (shortElem != null) {
                BigDecimal triggerPrice = shortElem.getGridPrice();
                executor.placeTakeProfit(
                        triggerPrice,
                        FuturesPriceTrigger.RuleEnum.NUMBER_1,
                        ORDER_TYPE_CLOSE_SHORT,
                        baseQty,
                        profitId -> {
                            shortElem.addShortStopLossOrderId(profitId);
                            GridElement.refreshIndices();
                            log.info("[Gate] 自定义空仓止损已挂, 目标价:{}, 匹配gridId:{}, 触发价:{}, stopLossId:{}",
                                    shortPrice, shortElem.getId(), triggerPrice, profitId);
                        }
                );
            } else {
                log.warn("[Gate] 自定义空仓止损价:{} 未匹配到任何网格", shortPrice);
            }
        }
        log.info("[Gate] 自定义止损初始化完成, 多仓止损价:{}, 空仓止损价:{}", longPrice, shortPrice);
    }

    /**
     * 默认止损阶梯（原有逻辑）：空仓从 ID=2 向上、多仓从 ID=-2 向下，各挂 baseQuantity/quantity 格、每格 quantity 张。
     */
    private void placeDefaultStopLossLadders() {
        placeDefaultShortStopLossLadder();
        placeDefaultLongStopLossLadder();
        int shortTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
        int longTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
        log.info("[Gate] 止损止盈单已全部挂完, 空仓止损:2~{}, 多仓止损:-2~-{}", shortTime, longTime);
    }

    /**
     * 默认空仓止损阶梯：从 ID=2 向上挂，每格 quantity 张，NUMBER_1（价格 ≥ 触发价平空）。
     */
    private void placeDefaultShortStopLossLadder() {
        int shortTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
        for (int id = 2; id <= shortTime; id++) {
            GridElement elem = GridElement.findById(id);
            if (elem == null) {
                continue;
            }
            BigDecimal triggerPrice = elem.getGridPrice();
            String size = config.getQuantity();
            int finalId = id;
            executor.placeTakeProfit(
                    triggerPrice,
                    FuturesPriceTrigger.RuleEnum.NUMBER_1,
                    ORDER_TYPE_CLOSE_SHORT,
                    size,
                    profitId -> {
                        elem.addShortStopLossOrderId(profitId);
                        GridElement.refreshIndices();
                        log.info("[Gate] 空仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
                    }
            );
        }
    }

    /**
     * 默认多仓止损阶梯：从 ID=-2 向下挂，每格 quantity 张，NUMBER_2（价格 ≤ 触发价平多）。
     */
    private void placeDefaultLongStopLossLadder() {
        int longTime = Integer.parseInt(config.getBaseQuantity()) / Integer.parseInt(config.getQuantity()) + 1;
        for (int id = -2; id >= -longTime; id--) {
            GridElement elem = GridElement.findById(id);
            if (elem == null) {
                continue;
            }
            BigDecimal triggerPrice = elem.getGridPrice();
            String size = config.getQuantity();
            int finalId = id;
            executor.placeTakeProfit(
                    triggerPrice,
                    FuturesPriceTrigger.RuleEnum.NUMBER_2,
                    ORDER_TYPE_CLOSE_LONG,
                    negate(size),
                    profitId -> {
                        elem.addLongStopLossOrderId(profitId);
                        GridElement.refreshIndices();
                        log.info("[Gate] 多仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
                    }
            );
        }
    }

    /**
     * 按「价格 → 最近网格」匹配：返回 gridPrice 与目标价绝对值差最小的网格元素。
     */
    private GridElement findNearestGridElementByPrice(BigDecimal price) {
        if (price == null || price.compareTo(BigDecimal.ZERO) <= 0) {
            return null;
        }
        GridElement nearest = null;
        BigDecimal minDiff = null;
        for (GridElement e : config.getGridElements()) {
            BigDecimal diff = e.getGridPrice().subtract(price).abs();
            if (minDiff == null || diff.compareTo(minDiff) < 0) {
                minDiff = diff;
                nearest = e;
            }
        }
        return nearest;
    }

    /**
     * 只取消空仓止损单（保留空仓止盈），用于自定义止损首次触发时重挂未触发侧。
     */
    private void cancelAllShortStopLossesOnly() {
        for (GridElement e : config.getGridElements()) {
            for (String slId : new ArrayList<>(e.getShortStopLossOrderIds())) {
                executor.cancelConditionalOrder(slId, oid -> {});
            }
            e.clearShortStopLossOrderIds();
        }
        GridElement.refreshIndices();
        log.info("[Gate] 已提交取消所有空仓止损（保留止盈）");
    }

    /**
     * 只取消多仓止损单（保留多仓止盈），用于自定义止损首次触发时重挂未触发侧。
     */
    private void cancelAllLongStopLossesOnly() {
        for (GridElement e : config.getGridElements()) {
            for (String slId : new ArrayList<>(e.getLongStopLossOrderIds())) {
                executor.cancelConditionalOrder(slId, oid -> {});
            }
            e.clearLongStopLossOrderIds();
        }
        GridElement.refreshIndices();
        log.info("[Gate] 已提交取消所有多仓止损（保留止盈）");
    }

    /**
@@ -1509,6 +1653,13 @@
            }
        }

        // 自定义止损模式：第一次止损触发时，取消未触发侧（空仓）自定义止损单并重挂默认阶梯
        if (config.isDualStopLossEnabled() && dualStopLossModeActive.compareAndSet(true, false)) {
            cancelAllShortStopLossesOnly();
            placeDefaultShortStopLossLadder();
            log.info("[Gate] 自定义止损首次触发(多仓), 已取消空仓自定义止损并重挂默认阶梯");
        }

    }

    private void handleShortStopLossTriggered(GridElement gridElement, String orderId) {
@@ -1559,6 +1710,13 @@
                    log.info("[Gate] 空仓止损触发, 取消gridId:{}的空单,{}", cancelGridId, cancelOrderId);
                });
            }
        }

        // 自定义止损模式：第一次止损触发时，取消未触发侧（多仓）自定义止损单并重挂默认阶梯
        if (config.isDualStopLossEnabled() && dualStopLossModeActive.compareAndSet(true, false)) {
            cancelAllLongStopLossesOnly();
            placeDefaultLongStopLossLadder();
            log.info("[Gate] 自定义止损首次触发(空仓), 已取消多仓自定义止损并重挂默认阶梯");
        }
    }

@@ -2114,6 +2272,178 @@
    /** 注入WS客户端，用于订阅状态检查 */
    public void setWsClient(GateKlineWebSocketClient wsClient) { this.wsClient = wsClient; }

    // ========== 手动控制（Station 指令） ==========

    /**
     * 手动取消多仓止盈 + 止损挂单，并同步清理对应 GridElement 的挂单记录。
     */
    public void cancelLongTakeProfitAndStopLoss() {
        submitManualTask(this::cancelAllLongTakeProfitsAndStopLosses);
    }

    /**
     * 手动取消空仓止盈 + 止损挂单，并同步清理对应 GridElement 的挂单记录。
     */
    public void cancelShortTakeProfitAndStopLoss() {
        submitManualTask(this::cancelAllShortTakeProfitsAndStopLosses);
    }

    /**
     * 手动重新生成多仓止盈 + 止损挂单，逻辑与挂单成交（onAutoOrder）一致：
     * 先撤多仓所有止盈止损，再按交易所最新持仓重挂止损阶梯，超额部分挂止盈到空仓第一止损位。
     */
    public void rebuildLongTakeProfitAndStopLoss() {
        submitManualTask(() -> {
            cancelAllLongTakeProfitsAndStopLosses();
            int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue());
            if (posSize <= 0) {
                log.warn("[Gate] 生成多仓止盈止损失败：无多仓持仓");
                return;
            }
            extendLongStopLoss(posSize, 0);
            if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
                placeExcessTakeProfit(posSize, true);
            } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
                placeDispersedTakeProfit(posSize, true, 0);
            }
            log.info("[Gate] 生成多仓止盈止损完成, 仓位:{}张", posSize);
        });
    }

    /**
     * 手动重新生成空仓止盈 + 止损挂单，逻辑与挂单成交（onAutoOrder）一致：
     * 先撤空仓所有止盈止损，再按交易所最新持仓重挂止损阶梯，超额部分挂止盈到多仓第一止损位。
     */
    public void rebuildShortTakeProfitAndStopLoss() {
        submitManualTask(() -> {
            cancelAllShortTakeProfitsAndStopLosses();
            int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue());
            if (posSize <= 0) {
                log.warn("[Gate] 生成空仓止盈止损失败：无空仓持仓");
                return;
            }
            extendShortStopLoss(posSize, 0);
            if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
                placeExcessTakeProfit(posSize, false);
            } else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
                placeDispersedTakeProfit(posSize, false, 0);
            }
            log.info("[Gate] 生成空仓止盈止损完成, 仓位:{}张", posSize);
        });
    }

    /**
     * 多单平仓：市价平掉多仓 → 撤多仓所有挂单并更新 GridElement → 交由价格驱动（onKline→processGrid）重新入场。
     */
    public void closeLongPosition() {
        submitManualTask(() -> closePositionByMode(Position.ModeEnum.DUAL_LONG, true));
    }

    /**
     * 空单平仓：市价平掉空仓 → 撤空仓所有挂单并更新 GridElement → 交由价格驱动（onKline→processGrid）重新入场。
     */
    public void closeShortPosition() {
        submitManualTask(() -> closePositionByMode(Position.ModeEnum.DUAL_SHORT, false));
    }

    /**
     * 统一提交手动操作任务。策略停止（executor 已关闭）时直接忽略，避免 RejectedExecutionException。
     */
    private void submitManualTask(Runnable task) {
        if (state == StrategyState.STOPPED) {
            log.warn("[Gate] 策略已停止，忽略手动操作");
            return;
        }
        executor.submitTask(task);
    }

    /**
     * 按持仓模式市价平仓（reduceOnly + IOC），随后撤该方向所有挂单（止盈/止损/入场单）、
     * 更新 GridElement，并清空 active 与持仓量标记，让价格驱动在下一根 K 线重新挂入场单。
     *
     * @param mode   持仓模式（DUAL_LONG / DUAL_SHORT）
     * @param isLong true=多仓，false=空仓
     */
    private void closePositionByMode(Position.ModeEnum mode, boolean isLong) {
        String sideLabel = isLong ? "多" : "空";
        // 1. 市价平掉对应方向仓位
        try {
            Position pos = queryPosition(mode);
            if (pos != null) {
                String sizeStr = pos.getSize();
                long size = Long.parseLong(sizeStr);
                if (size != 0) {
                    Position.ModeEnum posMode = pos.getMode();
                    FuturesOrder closeOrder = new FuturesOrder();
                    closeOrder.setContract(config.getContract());
                    closeOrder.setPrice("0");
                    closeOrder.setTif(FuturesOrder.TifEnum.IOC);
                    closeOrder.setReduceOnly(true);
                    if (posMode != null && posMode.getValue() != null && posMode.getValue().contains("dual")) {
                        closeOrder.setSize("0");
                        closeOrder.setClose(false);
                        closeOrder.setAutoSize(size > 0 ? FuturesOrder.AutoSizeEnum.LONG : FuturesOrder.AutoSizeEnum.SHORT);
                    } else {
                        closeOrder.setSize(size > 0 ? String.valueOf(-size) : String.valueOf(Math.abs(size)));
                    }
                    closeOrder.setText("t-grid-manual-close");
                    futuresApi.createFuturesOrder(SETTLE, closeOrder, null);
                    log.info("[Gate] 手动平{}仓, size:{}, mode:{}", sideLabel, sizeStr, posMode);
                }
            }
        } catch (Exception e) {
            log.warn("[Gate] 手动平{}仓失败", sideLabel, e);
        }

        // 2. 撤该方向所有挂单 + 更新 GridElement
        if (isLong) {
            cancelAllLongTakeProfitsAndStopLosses();
            cancelAllLongEntryOrders();
            longActive = false;
            longPositionSize = BigDecimal.ZERO;
        } else {
            cancelAllShortTakeProfitsAndStopLosses();
            cancelAllShortEntryOrders();
            shortActive = false;
            shortPositionSize = BigDecimal.ZERO;
        }
        log.info("[Gate] {}仓已平仓并清理挂单，交由价格驱动重新入场", sideLabel);
    }

    /**
     * 取消所有多仓入场单（条件开仓单），并清空 GridElement 的多仓挂单记录。
     */
    private void cancelAllLongEntryOrders() {
        for (GridElement e : config.getGridElements()) {
            for (String oid : new ArrayList<>(e.getLongOrderIds())) {
                executor.cancelConditionalOrder(oid, o -> {});
            }
            e.getLongTraderParam().setEntryOrderId(null);
            e.getLongTraderParam().setEntryOrderPlaced(false);
            e.setHasLongOrder(false);
            e.clearLongOrderIds();
        }
        GridElement.refreshIndices();
        log.info("[Gate] 已提交取消所有多仓入场单");
    }

    /**
     * 取消所有空仓入场单（条件开仓单），并清空 GridElement 的空仓挂单记录。
     */
    private void cancelAllShortEntryOrders() {
        for (GridElement e : config.getGridElements()) {
            for (String oid : new ArrayList<>(e.getShortOrderIds())) {
                executor.cancelConditionalOrder(oid, o -> {});
            }
            e.getShortTraderParam().setEntryOrderId(null);
            e.getShortTraderParam().setEntryOrderPlaced(false);
            e.setHasShortOrder(false);
            e.clearShortOrderIds();
        }
        GridElement.refreshIndices();
        log.info("[Gate] 已提交取消所有空仓入场单");
    }

    // ========== 止损查表辅助方法 ==========

    /** 找到第一个有多仓止损单的网格（首个匹配即返回） */

 src/main/java/com/xcong/excoin/modules/station/model/GateCommand.java

@@ -15,7 +15,12 @@
public class GateCommand {
    /** 指令唯一 ID（用于 ACK 对应） */
    private String commandId;
    /** START / STOP / UPDATE_CONFIG */
    /**
     * START / STOP / UPDATE_CONFIG /
     * CANCEL_LONG_TP_SL（取消多仓止盈止损）/ CANCEL_SHORT_TP_SL（取消空仓止盈止损）/
     * REBUILD_LONG_TP_SL（生成多仓止盈止损）/ REBUILD_SHORT_TP_SL（生成空仓止盈止损）/
     * CLOSE_LONG（多单平仓）/ CLOSE_SHORT（空单平仓）
     */
    private String commandType;
    /** 目标 apiKey 的 MD5 */
    private String apiKeyMd5;

 src/main/resources/static/gate-config.html

@@ -133,6 +133,13 @@
            <div class="form-group"><label>单边最大仓位量（张）</label><input id="maxPositionPerSide" type="number" placeholder="0（不限制）"></div>
            <div class="form-group"><label>加仓启动阈值（次）</label><input id="addPositionStartThreshold" type="number" placeholder="1（前N次止损不加仓）"></div>
            <div class="form-group"><label>止盈挂单</label><select id="placeExcessTakeProfit"><option value="off" selected>关闭</option><option value="concentrated">集中止盈</option><option value="dispersed">分散止盈</option></select></div>
            <!-- ===== 自定义止损配置 ===== -->
            <div class="form-group full" style="margin-top:6px;border-top:1px solid var(--border);padding-top:8px">
                <label style="font-size:13px;font-weight:600;color:var(--text)">自定义止损（开启后按触发价各挂一单，忽略默认阶梯）</label>
            </div>
            <div class="form-group"><label>自定义止损开关</label><select id="dualStopLossEnabled"><option value="false" selected>关闭</option><option value="true">开启</option></select></div>
            <div class="form-group"><label>多仓止损触发价</label><input id="longStopLossPrice" placeholder="如 2540（价格跌至触发平多）"></div>
            <div class="form-group"><label>空仓止损触发价</label><input id="shortStopLossPrice" placeholder="如 2650（价格涨至触发平空）"></div>
        </form>
    </div>

@@ -209,7 +216,8 @@
        // 文件不存在 → 用默认值填充，用户可编辑后保存
        fillForm({ gridRate:0.005, expectedProfit:0.15, maxLoss:1.5,
            baseQuantity:'2', quantity:'2', maxPositionSize:4, stopLossCount:0, takeProfitGridSpan:2, priceDriveEnabled: true, rounds: 0,
            stopLossCountMode:'dual', addPositionInterval:3, addPositionQuantity:1, maxPositionPerSide:0, addPositionStartThreshold:1, placeExcessTakeProfit: 'off' });
            stopLossCountMode:'dual', addPositionInterval:3, addPositionQuantity:1, maxPositionPerSide:0, addPositionStartThreshold:1, placeExcessTakeProfit: 'off',
            dualStopLossEnabled: false, longStopLossPrice: null, shortStopLossPrice: null });
        toast('未找到配置，已加载默认值，编辑后请保存', 'success');
    }
    currentApiKey = key;
@@ -235,6 +243,9 @@
    byId('maxPositionPerSide').value = d.maxPositionPerSide ?? 0;
    byId('addPositionStartThreshold').value = d.addPositionStartThreshold ?? 1;
    byId('placeExcessTakeProfit').value = normalizeTpMode(d.placeExcessTakeProfit);
    byId('dualStopLossEnabled').value = (d.dualStopLossEnabled === true || d.dualStopLossEnabled === 'true') ? 'true' : 'false';
    byId('longStopLossPrice').value = d.longStopLossPrice || '';
    byId('shortStopLossPrice').value = d.shortStopLossPrice || '';
}

function collectForm() {
@@ -255,7 +266,10 @@
        addPositionQuantity: intVal(byId('addPositionQuantity').value, 1),
        maxPositionPerSide: intVal(byId('maxPositionPerSide').value, 0),
        addPositionStartThreshold: intVal(byId('addPositionStartThreshold').value, 1),
        placeExcessTakeProfit: byId('placeExcessTakeProfit').value
        placeExcessTakeProfit: byId('placeExcessTakeProfit').value,
        dualStopLossEnabled: byId('dualStopLossEnabled').value === 'true',
        longStopLossPrice: parseFloat(byId('longStopLossPrice').value) || null,
        shortStopLossPrice: parseFloat(byId('shortStopLossPrice').value) || null
    };
}
function intVal(str, fallback) {