fix: filter auto tune out station limits

Junjie

2026-04-27 cd04aa8b887e82ec664e42f0bc353c079be1d2c5

 src/main/java/com/zy/common/utils/NavigateUtils.java

@@ -27,6 +27,7 @@
import com.zy.asrs.service.StationCycleCapacityService;
import com.zy.asrs.service.StationPathPolicyService;
import com.zy.core.News;
import org.springframework.scheduling.annotation.Scheduled;
import com.zy.core.model.StationObjModel;
import com.zy.core.model.command.StationCommand;
import com.zy.core.enums.StationCommandType;
@@ -55,6 +56,7 @@
public class NavigateUtils {

    private static final long STATION_PATH_SLOW_LOG_THRESHOLD_MS = 500L;
    private static final long STATION_PATH_RUNTIME_SNAPSHOT_TTL_MS = 2000L;
    private static final double CONGESTION_BUSY_BASE = 1.0d;
    private static final double CONGESTION_ISSUED_RESERVE_BASE = 0.75d;
    private static final double CONGESTION_PENDING_QUEUE_BASE = 0.45d;
@@ -76,6 +78,24 @@
    @Autowired
    private StationTaskTraceRegistry stationTaskTraceRegistry;

    private volatile CachedStationPathRuntimeSnapshot cachedRuntimeSnapshot;

    private volatile CachedLoopMergeGuardContext cachedLoopMergeGuardContext;

    @Scheduled(fixedDelay = 1500, initialDelay = 3000)
    public void refreshStationPathCaches() {
        try {
            BaseRuntimeSnapshot snapshot = buildBaseRuntimeSnapshot(null);
            cachedRuntimeSnapshot = new CachedStationPathRuntimeSnapshot(System.currentTimeMillis(), snapshot);
        } catch (Exception ignore) {
        }
        try {
            LoopMergeGuardContext context = buildLoopMergeGuardContext();
            cachedLoopMergeGuardContext = new CachedLoopMergeGuardContext(System.currentTimeMillis(), context);
        } catch (Exception ignore) {
        }
    }

    public List<NavigateNode> calcOptimalPathByStationId(Integer startStationId,
                                                         Integer endStationId,
                                                         Integer currentTaskNo,
@@ -92,11 +112,13 @@
                                                                 Integer currentTaskNo,
                                                                 Double pathLenFactor) {
        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        StationPathRuntimeSnapshot runtimeSnapshot = loadStationPathRuntimeSnapshot(currentTaskNo);
        StationPathSearchContext context = buildStationPathSearchContext(
                startStationId,
                endStationId,
                resolvedPolicy,
                StationPathCalcMode.REROUTE
                StationPathCalcMode.REROUTE,
                runtimeSnapshot
        );
        if (context.allList.isEmpty()) {
            return new ArrayList<>();
@@ -108,7 +130,8 @@
                currentTaskNo,
                pathLenFactor,
                startStationId,
                endStationId
                endStationId,
                runtimeSnapshot
        );
        return normalizeCandidatePaths(orderedPathList);
    }
@@ -140,6 +163,9 @@
        long stepStartNs = System.nanoTime();
        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        stepCostMap.put("resolvePolicy", elapsedMillis(stepStartNs));
        stepStartNs = System.nanoTime();
        StationPathRuntimeSnapshot runtimeSnapshot = loadStationPathRuntimeSnapshot(currentTaskNo);
        stepCostMap.put("loadRuntimeSnapshot", elapsedMillis(stepStartNs));
        if (calcMode != StationPathCalcMode.REROUTE) {
            stepStartNs = System.nanoTime();
            List<NavigateNode> directPath = findStationDirectPath(
@@ -148,7 +174,8 @@
                    currentTaskNo,
                    pathLenFactor,
                    calcMode,
                    resolvedPolicy
                    resolvedPolicy,
                    runtimeSnapshot
            );
            stepCostMap.put("directPath", elapsedMillis(stepStartNs));
            if (!directPath.isEmpty()) {
@@ -164,7 +191,8 @@
                startStationId,
                endStationId,
                resolvedPolicy,
                calcMode
                calcMode,
                runtimeSnapshot
        );
        stepCostMap.put("buildSearchContext", elapsedMillis(stepStartNs));
        if (context.allList.isEmpty()) {
@@ -175,7 +203,7 @@
        stepStartNs = System.nanoTime();
        List<NavigateNode> list = calcMode == StationPathCalcMode.REACHABILITY
                ? findStationReachablePath(context.allList, context.resolvedPolicy, startStationId, endStationId)
                : findStationBestPathTwoStage(context.allList, context.resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId);
                : findStationBestPathTwoStage(context.allList, context.resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId, runtimeSnapshot);
        stepCostMap.put("selectBestPath", elapsedMillis(stepStartNs));
        pathSource = calcMode == StationPathCalcMode.REACHABILITY ? "reachability" : "twoStage";
        resultPath = normalizeStationPath(list);
@@ -299,18 +327,24 @@
                                                     Integer currentTaskNo,
                                                     Double pathLenFactor,
                                                     StationPathCalcMode calcMode,
                                                     StationPathResolvedPolicy resolvedPolicy) {
                                                     StationPathResolvedPolicy resolvedPolicy,
                                                     StationPathRuntimeSnapshot runtimeSnapshot) {
        if (!supportsDirectPathMode(calcMode, resolvedPolicy, pathLenFactor)) {
            return new ArrayList<>();
        }

        long totalStartNs = System.nanoTime();
        Map<String, Long> stepCostMap = new LinkedHashMap<>();
        long stepStartNs = System.nanoTime();
        DirectStationPathContext context = buildDirectStationPathContext(
                startStationId,
                endStationId,
                currentTaskNo,
                calcMode,
                resolvedPolicy
                resolvedPolicy,
                runtimeSnapshot
        );
        stepCostMap.put("buildDirectContext", elapsedMillis(stepStartNs));
        if (context == null) {
            return new ArrayList<>();
        }
@@ -321,6 +355,7 @@
                endStationId,
                calcMode.name());

        stepStartNs = System.nanoTime();
        DirectPathSearchResult searchResult = searchDirectPathWithFallback(
                context,
                true,
@@ -336,23 +371,30 @@
                News.info("[WCS Debug] 站点路径快速计算已降级，忽略关键途经点约束后重试");
            }
        }
        stepCostMap.put("searchDirectPath", elapsedMillis(stepStartNs));
        if (searchResult.path.isEmpty()) {
            logDirectPathSlow(startStationId, endStationId, currentTaskNo, calcMode, pathLenFactor, 0, stepCostMap, totalStartNs);
            return new ArrayList<>();
        }

        stepStartNs = System.nanoTime();
        if (!isDirectPathValid(
                searchResult.path,
                context,
                searchResult.includeWaypoint,
                searchResult.includeSoftPreference)) {
            stepCostMap.put("validateDirectPath", elapsedMillis(stepStartNs));
            logDirectPathSlow(startStationId, endStationId, currentTaskNo, calcMode, pathLenFactor, searchResult.path.size(), stepCostMap, totalStartNs);
            return new ArrayList<>();
        }
        stepCostMap.put("validateDirectPath", elapsedMillis(stepStartNs));

        News.info("[WCS Debug] 站点路径快速计算完成，耗时：{}ms,startStationId={},endStationId={},mode={}",
                System.currentTimeMillis() - startTime,
                startStationId,
                endStationId,
                calcMode.name());
        logDirectPathSlow(startStationId, endStationId, currentTaskNo, calcMode, pathLenFactor, searchResult.path.size(), stepCostMap, totalStartNs);
        return searchResult.path;
    }

@@ -397,8 +439,12 @@
                return new ArrayList<>();
            }

            NavigateNode segmentStartNode = context.navigateSolution.findStationNavigateNode(context.stationMap, segmentStartStationId);
            NavigateNode segmentEndNode = context.navigateSolution.findStationNavigateNode(context.stationMap, segmentEndStationId);
            NavigateNode segmentStartNode = context.navigateMapIndex == null
                    ? context.navigateSolution.findStationNavigateNode(context.stationMap, segmentStartStationId)
                    : context.navigateSolution.findStationNavigateNode(context.navigateMapIndex, segmentStartStationId);
            NavigateNode segmentEndNode = context.navigateMapIndex == null
                    ? context.navigateSolution.findStationNavigateNode(context.stationMap, segmentEndStationId)
                    : context.navigateSolution.findStationNavigateNode(context.navigateMapIndex, segmentEndStationId);
            if (segmentStartNode == null || segmentEndNode == null) {
                return new ArrayList<>();
            }
@@ -439,7 +485,9 @@
                return buildDirectPath(currentState);
            }

            List<NavigateNode> nextNodeList = context.navigateSolution.extend_current_node(context.stationMap, currentState.node);
            List<NavigateNode> nextNodeList = context.navigateMapIndex == null
                    ? context.navigateSolution.extend_current_node(context.stationMap, currentState.node)
                    : context.navigateSolution.getNeighborNodes(context.navigateMapIndex, currentState.node);
            for (NavigateNode nextNode : safeList(nextNodeList)) {
                if (!isDirectTransitionAllowed(context, currentState.node, nextNode, endNode)) {
                    continue;
@@ -577,23 +625,10 @@
    }

    private int calcLiftTransferPenalty(NavigateNode node) {
        if (node == null || node.getNodeValue() == null) {
        if (node == null) {
            return 0;
        }
        try {
            JSONObject valueObject = JSON.parseObject(node.getNodeValue());
            if (valueObject == null) {
                return 0;
            }
            Object isLiftTransfer = valueObject.get("isLiftTransfer");
            if (isLiftTransfer == null) {
                return 0;
            }
            String text = String.valueOf(isLiftTransfer);
            return ("1".equals(text) || "true".equalsIgnoreCase(text)) ? 1 : 0;
        } catch (Exception ignore) {
            return 0;
        }
        return Boolean.TRUE.equals(node.getLiftTransfer()) ? 1 : 0;
    }

    private double calcHeuristicScore(NavigateNode currentNode, NavigateNode endNode) {
@@ -744,16 +779,18 @@
                                                                   Integer endStationId,
                                                                   Integer currentTaskNo,
                                                                   StationPathCalcMode calcMode,
                                                                   StationPathResolvedPolicy resolvedPolicy) {
                                                                   StationPathResolvedPolicy resolvedPolicy,
                                                                   StationPathRuntimeSnapshot runtimeSnapshot) {
        BasStation startStation = basStationService.getById(startStationId);
        if (startStation == null) {
            throw new CoolException("未找到该 " + startStationId + "起点 对应的站点数据");
        }

        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(startStation.getStationLev());
        NavigateNode startNode = navigateSolution.findStationNavigateNode(stationMap, startStationId);
        NavigateNode endNode = navigateSolution.findStationNavigateNode(stationMap, endStationId);
        NavigateSolution.NavigateMapIndex navigateMapIndex = navigateSolution.getStationMapIndex(startStation.getStationLev());
        List<List<NavigateNode>> stationMap = navigateMapIndex == null ? new ArrayList<>() : navigateMapIndex.getNavigateMap();
        NavigateNode startNode = navigateSolution.findStationNavigateNode(navigateMapIndex, startStationId);
        NavigateNode endNode = navigateSolution.findStationNavigateNode(navigateMapIndex, endStationId);
        if (startNode == null || endNode == null) {
            throw new CoolException("未找到该 " + startStationId + "起点 或 " + endStationId + "终点 对应的节点");
        }
@@ -763,6 +800,7 @@
        context.startStationId = startStationId;
        context.endStationId = endStationId;
        context.navigateSolution = navigateSolution;
        context.navigateMapIndex = navigateMapIndex;
        context.stationMap = stationMap;
        context.startNode = startNode;
        context.endNode = endNode;
@@ -774,11 +812,12 @@
                ? StationPathProfileConfig.defaultConfig()
                : context.resolvedPolicy.getProfileConfig();
        context.globalPolicy = loadPathGlobalPolicy(context.profileConfig);
        context.statusMap = loadStationStatusMap();
        context.stationLoopLoadMap = loadStationLoopLoadMap();
        context.trafficSnapshot = loadStationTrafficSnapshot(context.statusMap, currentTaskNo);
        context.loopMergeGuardContext = loadLoopMergeGuardContext();
        context.outStationIdSet = loadAllOutStationIdSet();
        context.runtimeSnapshot = runtimeSnapshot == null ? StationPathRuntimeSnapshot.empty() : runtimeSnapshot;
        context.statusMap = context.runtimeSnapshot.statusMap;
        context.stationLoopLoadMap = context.runtimeSnapshot.stationLoopLoadMap;
        context.trafficSnapshot = context.runtimeSnapshot.trafficSnapshot;
        context.loopMergeGuardContext = context.runtimeSnapshot.loopMergeGuardContext;
        context.outStationIdSet = context.runtimeSnapshot.outStationIdSet;
        context.forbidStationIdSet = new HashSet<>(safeList(context.ruleConfig.getHard() == null ? null : context.ruleConfig.getHard().getForbidStations()));
        context.forbidEdgeSet = new HashSet<>();
        for (String edgeText : safeList(context.ruleConfig.getHard() == null ? null : context.ruleConfig.getHard().getForbidEdges())) {
@@ -826,8 +865,9 @@
                                                           Integer currentTaskNo,
                                                           Double pathLenFactor,
                                                           Integer startStationId,
                                                           Integer endStationId) {
        List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(allList, resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId);
                                                           Integer endStationId,
                                                           StationPathRuntimeSnapshot runtimeSnapshot) {
        List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(allList, resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId, runtimeSnapshot);
        if (orderedPathList.isEmpty()) {
            return new ArrayList<>();
        }
@@ -839,7 +879,8 @@
                                                                Integer currentTaskNo,
                                                                Double pathLenFactor,
                                                                Integer startStationId,
                                                                Integer endStationId) {
                                                                Integer endStationId,
                                                                StationPathRuntimeSnapshot runtimeSnapshot) {
        long totalStartNs = System.nanoTime();
        Map<String, Long> stepCostMap = new LinkedHashMap<>();
        if (allList == null || allList.isEmpty()) {
@@ -882,12 +923,12 @@
        stepCostMap.put("filterCandidates", elapsedMillis(stepStartNs));

        stepStartNs = System.nanoTime();
        Map<Integer, StationProtocol> statusMap = loadStationStatusMap();
        Map<Integer, Double> stationLoopLoadMap = loadStationLoopLoadMap();
        StationTrafficSnapshot trafficSnapshot = loadStationTrafficSnapshot(statusMap, currentTaskNo);
        LoopMergeGuardContext loopMergeGuardContext = loadLoopMergeGuardContext();
        Map<Integer, StationProtocol> statusMap = runtimeSnapshot == null ? Collections.emptyMap() : runtimeSnapshot.statusMap;
        Map<Integer, Double> stationLoopLoadMap = runtimeSnapshot == null ? Collections.emptyMap() : runtimeSnapshot.stationLoopLoadMap;
        StationTrafficSnapshot trafficSnapshot = runtimeSnapshot == null ? new StationTrafficSnapshot() : runtimeSnapshot.trafficSnapshot;
        LoopMergeGuardContext loopMergeGuardContext = runtimeSnapshot == null ? new LoopMergeGuardContext() : runtimeSnapshot.loopMergeGuardContext;
        Set<LoopMergeEntry> mandatoryLoopMergeEntrySet = resolveMandatoryLoopMergeEntrySet(filteredCandidates, loopMergeGuardContext);
        Set<Integer> outStationIdSet = loadAllOutStationIdSet();
        Set<Integer> outStationIdSet = runtimeSnapshot == null ? Collections.emptySet() : runtimeSnapshot.outStationIdSet;
        stepCostMap.put("loadDynamicContext", elapsedMillis(stepStartNs));
        List<PathCandidateMetrics> metricsList = new ArrayList<>();
        int skippedByOtherOutStation = 0;
@@ -1389,19 +1430,8 @@
    private int countLiftTransferCount(List<NavigateNode> path) {
        int count = 0;
        for (NavigateNode node : safeList(path)) {
            try {
                JSONObject valueObject = JSON.parseObject(node.getNodeValue());
                if (valueObject == null) {
                    continue;
                }
                Object isLiftTransfer = valueObject.get("isLiftTransfer");
                if (isLiftTransfer != null) {
                    String text = String.valueOf(isLiftTransfer);
                    if ("1".equals(text) || "true".equalsIgnoreCase(text)) {
                        count++;
                    }
                }
            } catch (Exception ignore) {
            if (node != null && Boolean.TRUE.equals(node.getLiftTransfer())) {
                count++;
            }
        }
        return count;
@@ -1636,6 +1666,94 @@
        return statusMap;
    }

    private StationPathRuntimeSnapshot loadStationPathRuntimeSnapshot(Integer currentTaskNo) {
        long totalStartNs = System.nanoTime();
        Map<String, Long> stepCostMap = new LinkedHashMap<>();

        long stepStartNs = System.nanoTime();
        BaseRuntimeSnapshot baseRuntimeSnapshot = loadBaseRuntimeSnapshot(stepCostMap);
        stepCostMap.put("loadBaseSnapshot", elapsedMillis(stepStartNs));
        if (baseRuntimeSnapshot == null) {
            logRuntimeSnapshotSlow(currentTaskNo, false, stepCostMap, totalStartNs);
            return StationPathRuntimeSnapshot.empty();
        }

        stepStartNs = System.nanoTime();
        StationTrafficSnapshot trafficSnapshot = buildStationTrafficSnapshot(
                baseRuntimeSnapshot.statusMap,
                currentTaskNo,
                baseRuntimeSnapshot.activeTraceList
        );
        stepCostMap.put("buildTrafficSnapshot", elapsedMillis(stepStartNs));
        logRuntimeSnapshotSlow(currentTaskNo, baseRuntimeSnapshot.cacheHit, stepCostMap, totalStartNs);
        return new StationPathRuntimeSnapshot(
                baseRuntimeSnapshot.statusMap,
                baseRuntimeSnapshot.stationLoopLoadMap,
                trafficSnapshot,
                baseRuntimeSnapshot.loopMergeGuardContext,
                baseRuntimeSnapshot.outStationIdSet
        );
    }

    private BaseRuntimeSnapshot loadBaseRuntimeSnapshot(Map<String, Long> stepCostMap) {
        long now = System.currentTimeMillis();
        CachedStationPathRuntimeSnapshot cachedSnapshot = cachedRuntimeSnapshot;
        if (cachedSnapshot != null && now - cachedSnapshot.cacheAtMs <= STATION_PATH_RUNTIME_SNAPSHOT_TTL_MS) {
            if (stepCostMap != null) {
                stepCostMap.put("baseSnapshotCacheHit", 0L);
            }
            return cachedSnapshot.baseRuntimeSnapshot.toCacheHitSnapshot();
        }
        // 缓存过期：用过期缓存兜底（@Scheduled 定时任务会很快刷新），避免多线程阻塞
        if (cachedSnapshot != null) {
            if (stepCostMap != null) {
                stepCostMap.put("baseSnapshotStale", 0L);
            }
            return cachedSnapshot.baseRuntimeSnapshot.toCacheHitSnapshot();
        }
        // 极端情况：从未有过缓存（启动首次调用），同步构建
        long stepStartNs = System.nanoTime();
        BaseRuntimeSnapshot baseRuntimeSnapshot = buildBaseRuntimeSnapshot(stepCostMap);
        if (stepCostMap != null) {
            stepCostMap.put("buildBaseSnapshot", elapsedMillis(stepStartNs));
        }
        cachedRuntimeSnapshot = new CachedStationPathRuntimeSnapshot(System.currentTimeMillis(), baseRuntimeSnapshot);
        return baseRuntimeSnapshot;
    }

    private BaseRuntimeSnapshot buildBaseRuntimeSnapshot(Map<String, Long> stepCostMap) {
        long stepStartNs = System.nanoTime();
        Map<Integer, StationProtocol> statusMap = Collections.unmodifiableMap(new LinkedHashMap<>(loadStationStatusMap()));
        if (stepCostMap != null) {
            stepCostMap.put("loadStatusMap", elapsedMillis(stepStartNs));
        }

        stepStartNs = System.nanoTime();
        Map<Integer, Double> stationLoopLoadMap = Collections.unmodifiableMap(new LinkedHashMap<>(loadStationLoopLoadMap()));
        if (stepCostMap != null) {
            stepCostMap.put("loadLoopLoadMap", elapsedMillis(stepStartNs));
        }

        stepStartNs = System.nanoTime();
        LoopMergeGuardContext loopMergeGuardContext = loadLoopMergeGuardContext();
        if (stepCostMap != null) {
            stepCostMap.put("loadLoopMergeGuard", elapsedMillis(stepStartNs));
        }

        stepStartNs = System.nanoTime();
        Set<Integer> outStationIdSet = Collections.unmodifiableSet(new LinkedHashSet<>(loadAllOutStationIdSet()));
        if (stepCostMap != null) {
            stepCostMap.put("loadOutStationSet", elapsedMillis(stepStartNs));
        }

        stepStartNs = System.nanoTime();
        List<StationTaskTraceVo> activeTraceList = Collections.unmodifiableList(new ArrayList<>(loadPlanningActiveTraceList(statusMap, stepCostMap)));
        if (stepCostMap != null) {
            stepCostMap.put("loadActiveTraceList", elapsedMillis(stepStartNs));
        }
        return new BaseRuntimeSnapshot(false, statusMap, stationLoopLoadMap, loopMergeGuardContext, outStationIdSet, activeTraceList);
    }

    private Map<Integer, Double> loadStationLoopLoadMap() {
        Map<Integer, Double> stationLoopLoadMap = new HashMap<>();
        try {
@@ -1663,6 +1781,22 @@
    }

    private LoopMergeGuardContext loadLoopMergeGuardContext() {
        long now = System.currentTimeMillis();
        CachedLoopMergeGuardContext cached = cachedLoopMergeGuardContext;
        if (cached != null && now - cached.cacheAtMs <= STATION_PATH_RUNTIME_SNAPSHOT_TTL_MS) {
            return new LoopMergeGuardContext(cached.context);
        }
        // 缓存过期：用过期缓存兜底（@Scheduled 定时任务会很快刷新）
        if (cached != null) {
            return new LoopMergeGuardContext(cached.context);
        }
        // 极端情况：从未有过缓存，同步构建
        LoopMergeGuardContext context = buildLoopMergeGuardContext();
        cachedLoopMergeGuardContext = new CachedLoopMergeGuardContext(System.currentTimeMillis(), context);
        return new LoopMergeGuardContext(context);
    }

    private LoopMergeGuardContext buildLoopMergeGuardContext() {
        LoopMergeGuardContext context = new LoopMergeGuardContext();
        try {
            if (stationCycleCapacityService == null) {
@@ -1761,12 +1895,13 @@
            if (lev == null) {
                continue;
            }
            List<List<NavigateNode>> stationMap;
            NavigateSolution.NavigateMapIndex navigateMapIndex;
            try {
                stationMap = navigateSolution.getStationMap(lev);
                navigateMapIndex = navigateSolution.getStationMapIndex(lev);
            } catch (Exception ignore) {
                continue;
            }
            List<List<NavigateNode>> stationMap = navigateMapIndex == null ? new ArrayList<>() : navigateMapIndex.getNavigateMap();
            if (stationMap == null || stationMap.isEmpty()) {
                continue;
            }
@@ -1778,16 +1913,13 @@
                        continue;
                    }
                    graph.computeIfAbsent(stationId, key -> new LinkedHashSet<>());
                    List<NavigateNode> nextNodeList = navigateSolution.extend_current_node(stationMap, node);
                    for (NavigateNode nextNode : safeList(nextNodeList)) {
                        for (Integer nextStationId : resolveConnectedStationIds(stationId, nextNode)) {
                            if (nextStationId == null || stationId.equals(nextStationId)) {
                                continue;
                            }
                            graph.computeIfAbsent(nextStationId, key -> new LinkedHashSet<>());
                            graph.get(stationId).add(nextStationId);
                            graph.get(nextStationId).add(stationId);
                    for (Integer nextStationId : navigateSolution.getConnectedStationIds(navigateMapIndex, stationId, node)) {
                        if (nextStationId == null || stationId.equals(nextStationId)) {
                            continue;
                        }
                        graph.computeIfAbsent(nextStationId, key -> new LinkedHashSet<>());
                        graph.get(stationId).add(nextStationId);
                        graph.get(nextStationId).add(stationId);
                    }
                }
            }
@@ -1797,27 +1929,17 @@

    private Set<Integer> resolveConnectedStationIds(Integer currentStationId, NavigateNode nextNode) {
        Set<Integer> stationIdSet = new LinkedHashSet<>();
        if (nextNode == null || nextNode.getNodeValue() == null) {
        if (nextNode == null) {
            return stationIdSet;
        }
        try {
            JSONObject value = JSON.parseObject(nextNode.getNodeValue());
            if (value == null) {
                return stationIdSet;
        Integer directStationId = extractStationId(nextNode);
        if (directStationId != null && !directStationId.equals(currentStationId)) {
            stationIdSet.add(directStationId);
        }
        for (Integer bridgeStationId : safeList(nextNode.getBridgeStationIds())) {
            if (bridgeStationId != null && !bridgeStationId.equals(currentStationId)) {
                stationIdSet.add(bridgeStationId);
            }
            Integer directStationId = value.getInteger("stationId");
            if (directStationId != null && !directStationId.equals(currentStationId)) {
                stationIdSet.add(directStationId);
            }
            JSONArray bridgeStationIds = value.getJSONArray("bridgeStationIds");
            if (bridgeStationIds != null) {
                for (Integer bridgeStationId : bridgeStationIds.toJavaList(Integer.class)) {
                    if (bridgeStationId != null && !bridgeStationId.equals(currentStationId)) {
                        stationIdSet.add(bridgeStationId);
                    }
                }
            }
        } catch (Exception ignore) {
        }
        return stationIdSet;
    }
@@ -1843,6 +1965,12 @@
    }

    private StationTrafficSnapshot loadStationTrafficSnapshot(Map<Integer, StationProtocol> statusMap, Integer currentTaskNo) {
        return buildStationTrafficSnapshot(statusMap, currentTaskNo, loadPlanningActiveTraceList(statusMap));
    }

    private StationTrafficSnapshot buildStationTrafficSnapshot(Map<Integer, StationProtocol> statusMap,
                                                              Integer currentTaskNo,
                                                              List<StationTaskTraceVo> activeTraceList) {
        StationTrafficSnapshot snapshot = new StationTrafficSnapshot();
        Map<Integer, Integer> busyMap = new HashMap<>();
        Map<Integer, Integer> issuedReserveMap = new HashMap<>();
@@ -1861,8 +1989,11 @@
            }
        }

        for (StationTaskTraceVo traceVo : loadActiveTraceList(currentTaskNo, statusMap)) {
        for (StationTaskTraceVo traceVo : safeList(activeTraceList)) {
            if (traceVo == null) {
                continue;
            }
            if (currentTaskNo != null && currentTaskNo.equals(traceVo.getTaskNo())) {
                continue;
            }
            List<Integer> pendingStationIds = distinctPositiveStationIds(traceVo.getPendingStationIds());
@@ -2037,17 +2168,23 @@
        return false;
    }

    private List<StationTaskTraceVo> loadActiveTraceList(Integer currentTaskNo, Map<Integer, StationProtocol> statusMap) {
    private List<StationTaskTraceVo> loadPlanningActiveTraceList(Map<Integer, StationProtocol> statusMap) {
        return loadPlanningActiveTraceList(statusMap, null);
    }

    private List<StationTaskTraceVo> loadPlanningActiveTraceList(Map<Integer, StationProtocol> statusMap,
                                                                   Map<String, Long> stepCostMap) {
        Map<Integer, StationTaskTraceVo> traceMap = new LinkedHashMap<>();
        if (stationTaskTraceRegistry != null) {
            try {
                List<StationTaskTraceVo> traceList = stationTaskTraceRegistry.listLatestTraces();
                long stepStartNs = System.nanoTime();
                List<StationTaskTraceVo> traceList = stationTaskTraceRegistry.listPlanningActiveTraceSnapshots();
                if (stepCostMap != null) {
                    stepCostMap.put("loadRegistryTraces", elapsedMillis(stepStartNs));
                }
                if (traceList != null) {
                    for (StationTaskTraceVo traceVo : traceList) {
                        if (!isPlanningActiveTrace(traceVo)) {
                            continue;
                        }
                        if (currentTaskNo != null && currentTaskNo.equals(traceVo.getTaskNo())) {
                            continue;
                        }
                        if (traceVo.getTaskNo() != null) {
@@ -2058,7 +2195,11 @@
            } catch (Exception ignore) {
            }
        }
        Map<Integer, StationTaskTraceVo> fallbackTraceMap = loadFallbackActiveTraceMap(currentTaskNo, statusMap, traceMap.keySet());
        long stepStartNs = System.nanoTime();
        Map<Integer, StationTaskTraceVo> fallbackTraceMap = buildProtocolFallbackTraceMap(statusMap, traceMap.keySet());
        if (stepCostMap != null) {
            stepCostMap.put("loadFallbackTraces", elapsedMillis(stepStartNs));
        }
        if (!fallbackTraceMap.isEmpty()) {
            traceMap.putAll(fallbackTraceMap);
        }
@@ -2073,6 +2214,55 @@
        return StationTaskTraceRegistry.STATUS_WAITING.equals(status)
                || StationTaskTraceRegistry.STATUS_RUNNING.equals(status)
                || StationTaskTraceRegistry.STATUS_REROUTED.equals(status);
    }

    private Map<Integer, StationTaskTraceVo> buildProtocolFallbackTraceMap(Map<Integer, StationProtocol> statusMap,
                                                                            Set<Integer> existingTaskNoSet) {
        if (statusMap == null || statusMap.isEmpty()) {
            return Collections.emptyMap();
        }
        Map<Integer, StationTaskTraceVo> result = new LinkedHashMap<>();
        for (StationProtocol protocol : statusMap.values()) {
            if (protocol == null || protocol.getTaskNo() == null || protocol.getTaskNo() <= 0) {
                continue;
            }
            if (!Boolean.TRUE.equals(protocol.isLoading())) {
                continue;
            }
            if (existingTaskNoSet != null && existingTaskNoSet.contains(protocol.getTaskNo())) {
                continue;
            }
            Integer stationId = protocol.getStationId();
            Integer targetStaNo = protocol.getTargetStaNo();
            if (stationId == null || targetStaNo == null || stationId.equals(targetStaNo)) {
                continue;
            }
            List<Integer> path = new ArrayList<>();
            path.add(stationId);
            path.add(targetStaNo);
            List<Integer> pendingStationIds = new ArrayList<>();
            pendingStationIds.add(targetStaNo);
            StationTaskTraceVo vo = new StationTaskTraceVo();
            vo.setTaskNo(protocol.getTaskNo());
            vo.setThreadImpl("PROTOCOL_FALLBACK");
            vo.setStatus(StationTaskTraceRegistry.STATUS_RUNNING);
            vo.setTraceVersion(1);
            vo.setStartStationId(stationId);
            vo.setCurrentStationId(stationId);
            vo.setFinalTargetStationId(targetStaNo);
            vo.setFullPathStationIds(path);
            vo.setIssuedStationIds(path);
            vo.setPassedStationIds(Collections.emptyList());
            vo.setPendingStationIds(pendingStationIds);
            vo.setLatestIssuedSegmentPath(path);
            vo.setSegmentList(Collections.emptyList());
            vo.setIssuedSegmentCount(0);
            vo.setTotalSegmentCount(1);
            vo.setUpdatedAt(System.currentTimeMillis());
            vo.setEvents(Collections.emptyList());
            result.put(protocol.getTaskNo(), vo);
        }
        return result;
    }

    private Map<Integer, StationTaskTraceVo> loadFallbackActiveTraceMap(Integer currentTaskNo,
@@ -2103,7 +2293,7 @@
        }

        List<Integer> taskNoList = new ArrayList<>(activeTaskProtocolMap.keySet());
        int limit = Math.max(50, taskNoList.size() * 8);
        int limit = Math.max(taskNoList.size(), taskNoList.size() * 2);
        List<BasStationOpt> optList;
        try {
            optList = basStationOptService.list(new QueryWrapper<BasStationOpt>()
@@ -2481,7 +2671,8 @@
    private StationPathSearchContext buildStationPathSearchContext(Integer startStationId,
                                                                   Integer endStationId,
                                                                   StationPathResolvedPolicy resolvedPolicy,
                                                                   StationPathCalcMode calcMode) {
                                                                   StationPathCalcMode calcMode,
                                                                   StationPathRuntimeSnapshot runtimeSnapshot) {
        long totalStartNs = System.nanoTime();
        Map<String, Long> stepCostMap = new LinkedHashMap<>();
        int rawCandidateCount = 0;
@@ -2497,14 +2688,15 @@

        stepStartNs = System.nanoTime();
        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(lev);
        NavigateSolution.NavigateMapIndex navigateMapIndex = navigateSolution.getStationMapIndex(lev);
        List<List<NavigateNode>> stationMap = navigateMapIndex == null ? new ArrayList<>() : navigateMapIndex.getNavigateMap();

        NavigateNode startNode = navigateSolution.findStationNavigateNode(stationMap, startStationId);
        NavigateNode startNode = navigateSolution.findStationNavigateNode(navigateMapIndex, startStationId);
        if (startNode == null) {
            throw new CoolException("未找到该 起点 对应的节点");
        }

        NavigateNode endNode = navigateSolution.findStationNavigateNode(stationMap, endStationId);
        NavigateNode endNode = navigateSolution.findStationNavigateNode(navigateMapIndex, endStationId);
        if (endNode == null) {
            throw new CoolException("未找到该 终点 对应的节点");
        }
@@ -2542,7 +2734,7 @@
            return StationPathSearchContext.empty(resolvedPolicy);
        }
        stepStartNs = System.nanoTime();
        Map<Integer, StationProtocol> statusMap = loadStationStatusMap();
        Map<Integer, StationProtocol> statusMap = runtimeSnapshot == null ? Collections.emptyMap() : runtimeSnapshot.statusMap;
        allList = filterNonAutoStationPaths(allList, statusMap);
        stepCostMap.put("filterNonAutoStation", elapsedMillis(stepStartNs));
        filteredCandidateCount = allList.size();
@@ -2641,6 +2833,44 @@
                totalCostMs);
    }

    private void logDirectPathSlow(Integer startStationId,
                                   Integer endStationId,
                                   Integer currentTaskNo,
                                   StationPathCalcMode calcMode,
                                   Double pathLenFactor,
                                   int pathNodeCount,
                                   Map<String, Long> stepCostMap,
                                   long totalStartNs) {
        long totalCostMs = elapsedMillis(totalStartNs);
        if (totalCostMs < STATION_PATH_SLOW_LOG_THRESHOLD_MS) {
            return;
        }
        News.warn("站点路径快速计算耗时较长，startStationId={}，endStationId={}，taskNo={}，mode={}，pathLenFactor={}，pathNodeCount={}，stepCosts={}，totalCost={}ms",
                startStationId,
                endStationId,
                currentTaskNo,
                calcMode == null ? "" : calcMode.name(),
                pathLenFactor,
                pathNodeCount,
                JSON.toJSONString(stepCostMap),
                totalCostMs);
    }

    private void logRuntimeSnapshotSlow(Integer currentTaskNo,
                                        boolean cacheHit,
                                        Map<String, Long> stepCostMap,
                                        long totalStartNs) {
        long totalCostMs = elapsedMillis(totalStartNs);
        if (totalCostMs < STATION_PATH_SLOW_LOG_THRESHOLD_MS) {
            return;
        }
        News.warn("站点路径运行时快照加载耗时较长，taskNo={}，cacheHit={}，stepCosts={}，totalCost={}ms",
                currentTaskNo,
                cacheHit,
                JSON.toJSONString(stepCostMap),
                totalCostMs);
    }

    private long elapsedMillis(long startNs) {
        long elapsedNs = System.nanoTime() - startNs;
        return elapsedNs <= 0L ? 0L : elapsedNs / 1_000_000L;
@@ -2670,16 +2900,10 @@
            if (navigateNode == null) {
                continue;
            }
            JSONObject valueObject;
            try {
                valueObject = JSON.parseObject(navigateNode.getNodeValue());
            } catch (Exception ignore) {
            if (Boolean.TRUE.equals(navigateNode.getRgvCalcFlag())) {
                continue;
            }
            if (valueObject == null || valueObject.containsKey("rgvCalcFlag")) {
                continue;
            }
            Integer stationId = valueObject.getInteger("stationId");
            Integer stationId = extractStationId(navigateNode);
            if (stationId == null) {
                continue;
            }
@@ -2699,19 +2923,8 @@
            NavigateNode currentNode = filterList.get(i);
            currentNode.setIsInflectionPoint(false);
            currentNode.setIsLiftTransferPoint(false);

            try {
                JSONObject valueObject = JSON.parseObject(currentNode.getNodeValue());
                if (valueObject != null) {
                    Object isLiftTransfer = valueObject.get("isLiftTransfer");
                    if (isLiftTransfer != null) {
                        String isLiftTransferStr = isLiftTransfer.toString();
                        if ("1".equals(isLiftTransferStr) || "true".equalsIgnoreCase(isLiftTransferStr)) {
                            currentNode.setIsLiftTransferPoint(true);
                        }
                    }
                }
            } catch (Exception ignore) {
            if (Boolean.TRUE.equals(currentNode.getLiftTransfer())) {
                currentNode.setIsLiftTransferPoint(true);
            }

            NavigateNode nextNode = (i + 1 < filterList.size()) ? filterList.get(i + 1) : null;
@@ -2744,6 +2957,14 @@
        return builder.toString();
    }

    private boolean parseBooleanFlag(Object value) {
        if (value == null) {
            return false;
        }
        String text = String.valueOf(value);
        return "1".equals(text) || "true".equalsIgnoreCase(text);
    }

    private <T> List<T> safeList(List<T> list) {
        return list == null ? Collections.emptyList() : list;
    }
@@ -2768,6 +2989,7 @@
        private Integer startStationId;
        private Integer endStationId;
        private NavigateSolution navigateSolution;
        private NavigateSolution.NavigateMapIndex navigateMapIndex;
        private List<List<NavigateNode>> stationMap;
        private NavigateNode startNode;
        private NavigateNode endNode;
@@ -2775,6 +2997,7 @@
        private StationPathRuleConfig ruleConfig;
        private StationPathProfileConfig profileConfig;
        private PathGlobalPolicy globalPolicy;
        private StationPathRuntimeSnapshot runtimeSnapshot = StationPathRuntimeSnapshot.empty();
        private Map<Integer, StationProtocol> statusMap = new HashMap<>();
        private Map<Integer, Double> stationLoopLoadMap = new HashMap<>();
        private StationTrafficSnapshot trafficSnapshot = new StationTrafficSnapshot();
@@ -2818,6 +3041,86 @@
        private static DirectPathSearchResult empty(boolean includeWaypoint,
                                                    boolean includeSoftPreference) {
            return new DirectPathSearchResult(new ArrayList<>(), includeWaypoint, includeSoftPreference);
        }
    }

    private static class StationPathRuntimeSnapshot {
        private final Map<Integer, StationProtocol> statusMap;
        private final Map<Integer, Double> stationLoopLoadMap;
        private final StationTrafficSnapshot trafficSnapshot;
        private final LoopMergeGuardContext loopMergeGuardContext;
        private final Set<Integer> outStationIdSet;

        private StationPathRuntimeSnapshot(Map<Integer, StationProtocol> statusMap,
                                           Map<Integer, Double> stationLoopLoadMap,
                                           StationTrafficSnapshot trafficSnapshot,
                                           LoopMergeGuardContext loopMergeGuardContext,
                                           Set<Integer> outStationIdSet) {
            this.statusMap = statusMap == null ? Collections.emptyMap() : statusMap;
            this.stationLoopLoadMap = stationLoopLoadMap == null ? Collections.emptyMap() : stationLoopLoadMap;
            this.trafficSnapshot = trafficSnapshot == null ? new StationTrafficSnapshot() : trafficSnapshot;
            this.loopMergeGuardContext = loopMergeGuardContext == null ? new LoopMergeGuardContext() : loopMergeGuardContext;
            this.outStationIdSet = outStationIdSet == null ? Collections.emptySet() : outStationIdSet;
        }

        private static StationPathRuntimeSnapshot empty() {
            return new StationPathRuntimeSnapshot(Collections.emptyMap(),
                    Collections.emptyMap(),
                    new StationTrafficSnapshot(),
                    new LoopMergeGuardContext(),
                    Collections.emptySet());
        }
    }

    private static class BaseRuntimeSnapshot {
        private final boolean cacheHit;
        private final Map<Integer, StationProtocol> statusMap;
        private final Map<Integer, Double> stationLoopLoadMap;
        private final LoopMergeGuardContext loopMergeGuardContext;
        private final Set<Integer> outStationIdSet;
        private final List<StationTaskTraceVo> activeTraceList;

        private BaseRuntimeSnapshot(boolean cacheHit,
                                    Map<Integer, StationProtocol> statusMap,
                                    Map<Integer, Double> stationLoopLoadMap,
                                    LoopMergeGuardContext loopMergeGuardContext,
                                    Set<Integer> outStationIdSet,
                                    List<StationTaskTraceVo> activeTraceList) {
            this.cacheHit = cacheHit;
            this.statusMap = statusMap == null ? Collections.emptyMap() : statusMap;
            this.stationLoopLoadMap = stationLoopLoadMap == null ? Collections.emptyMap() : stationLoopLoadMap;
            this.loopMergeGuardContext = loopMergeGuardContext == null ? new LoopMergeGuardContext() : loopMergeGuardContext;
            this.outStationIdSet = outStationIdSet == null ? Collections.emptySet() : outStationIdSet;
            this.activeTraceList = activeTraceList == null ? Collections.emptyList() : activeTraceList;
        }

        private BaseRuntimeSnapshot toCacheHitSnapshot() {
            return new BaseRuntimeSnapshot(true,
                    statusMap,
                    stationLoopLoadMap,
                    loopMergeGuardContext,
                    outStationIdSet,
                    activeTraceList);
        }
    }

    private static class CachedStationPathRuntimeSnapshot {
        private final long cacheAtMs;
        private final BaseRuntimeSnapshot baseRuntimeSnapshot;

        private CachedStationPathRuntimeSnapshot(long cacheAtMs, BaseRuntimeSnapshot baseRuntimeSnapshot) {
            this.cacheAtMs = cacheAtMs;
            this.baseRuntimeSnapshot = baseRuntimeSnapshot;
        }
    }

    private static class CachedLoopMergeGuardContext {
        private final long cacheAtMs;
        private final LoopMergeGuardContext context;

        private CachedLoopMergeGuardContext(long cacheAtMs, LoopMergeGuardContext context) {
            this.cacheAtMs = cacheAtMs;
            this.context = context;
        }
    }

@@ -2874,6 +3177,16 @@
    private static class LoopMergeGuardContext {
        private final Set<Integer> loopStationIdSet = new HashSet<>();
        private final Map<Integer, Set<Integer>> loopNeighborMap = new HashMap<>();

        private LoopMergeGuardContext() {
        }

        private LoopMergeGuardContext(LoopMergeGuardContext source) {
            this.loopStationIdSet.addAll(source.loopStationIdSet);
            for (Map.Entry<Integer, Set<Integer>> entry : source.loopNeighborMap.entrySet()) {
                this.loopNeighborMap.put(entry.getKey(), new LinkedHashSet<>(entry.getValue()));
            }
        }
    }

    private static class LoopMergeEntry {
@@ -2981,7 +3294,13 @@
    }

    private Integer extractStationId(NavigateNode node) {
        if (node == null || node.getNodeValue() == null) {
        if (node == null) {
            return null;
        }
        if (node.getStationId() != null) {
            return node.getStationId();
        }
        if (node.getNodeValue() == null) {
            return null;
        }
        try {
@@ -2989,7 +3308,16 @@
            if (value == null) {
                return null;
            }
            return value.getInteger("stationId");
            node.setStationId(value.getInteger("stationId"));
            JSONArray bridgeStationIds = value.getJSONArray("bridgeStationIds");
            if (bridgeStationIds != null) {
                node.setBridgeStationIds(bridgeStationIds.toJavaList(Integer.class));
            } else {
                node.setBridgeStationIds(Collections.emptyList());
            }
            node.setLiftTransfer(parseBooleanFlag(value.get("isLiftTransfer")));
            node.setRgvCalcFlag(value.containsKey("rgvCalcFlag"));
            return node.getStationId();
        } catch (Exception ignore) {}
        return null;
    }