#dfs

Junjie

1 天以前 852664df1caf38831793b341edcada9dd7b6c22a

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

@@ -27,6 +27,8 @@
import com.zy.asrs.service.StationCycleCapacityService;
import com.zy.asrs.service.StationPathPolicyService;
import com.zy.core.News;
import lombok.extern.slf4j.Slf4j;
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;
@@ -52,8 +54,11 @@
import java.util.LinkedHashMap;

@Component
@Slf4j
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;
@@ -75,6 +80,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,
@@ -90,26 +113,74 @@
                                                                 Integer endStationId,
                                                                 Integer currentTaskNo,
                                                                 Double pathLenFactor) {
        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        StationPathSearchContext context = buildStationPathSearchContext(
                startStationId,
                endStationId,
                resolvedPolicy,
                StationPathCalcMode.REROUTE
        );
        if (context.allList.isEmpty()) {
            return new ArrayList<>();
        }
        long totalStartNs = System.nanoTime();
        log.info("站点路径候选计算入口，startStationId={}，endStationId={}，taskNo={}，pathLenFactor={}",
                startStationId, endStationId, currentTaskNo, pathLenFactor);
        try {
            StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
            log.info("站点路径候选策略解析完成，startStationId={}，endStationId={}，taskNo={}，matchedRule={}，ruleCode={}，profileCode={}，costMs={}",
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    resolvedPolicy != null && resolvedPolicy.matchedRule(),
                    resolvedPolicy == null || resolvedPolicy.getRuleEntity() == null ? null : resolvedPolicy.getRuleEntity().getRuleCode(),
                    resolvedPolicy == null ? null : resolvedPolicy.getDefaultProfileCode(),
                    elapsedMillis(totalStartNs));
            StationPathRuntimeSnapshot runtimeSnapshot = loadStationPathRuntimeSnapshot(currentTaskNo);
            List<NavigateNode> shortFallbackPath = buildRerouteShortFallbackPath(
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    resolvedPolicy,
                    runtimeSnapshot
            );
            StationPathSearchContext context = buildStationPathSearchContext(
                    startStationId,
                    endStationId,
                    resolvedPolicy,
                    StationPathCalcMode.REROUTE,
                    runtimeSnapshot
            );
            if (context.allList.isEmpty()) {
                List<List<NavigateNode>> fallbackCandidateList = normalizeCandidatePaths(Collections.singletonList(shortFallbackPath));
                log.warn("站点路径候选计算结束，原因=empty_search_context，startStationId={}，endStationId={}，taskNo={}，fallbackCandidateCount={}，fallbackPath={}，totalCostMs={}",
                        startStationId,
                        endStationId,
                        currentTaskNo,
                        fallbackCandidateList.size(),
                        JSON.toJSONString(extractStationIdList(shortFallbackPath)),
                        elapsedMillis(totalStartNs));
                return fallbackCandidateList;
            }

        List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(
                context.allList,
                context.resolvedPolicy,
                currentTaskNo,
                pathLenFactor,
                startStationId,
                endStationId
        );
        return normalizeCandidatePaths(orderedPathList);
            long orderStartNs = System.nanoTime();
            List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(
                    context.allList,
                    context.resolvedPolicy,
                    currentTaskNo,
                    pathLenFactor,
                    startStationId,
                    endStationId,
                    runtimeSnapshot
            );
            List<List<NavigateNode>> candidatePathList = appendShortFallbackCandidate(orderedPathList, shortFallbackPath);
            List<List<NavigateNode>> normalizedPathList = normalizeCandidatePaths(candidatePathList);
            log.info("站点路径候选计算结束，startStationId={}，endStationId={}，taskNo={}，rawCandidateCount={}，orderedPathCount={}，fallbackPathLen={}，normalizedPathCount={}，orderCostMs={}，totalCostMs={}",
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    context.allList.size(),
                    orderedPathList == null ? null : orderedPathList.size(),
                    shortFallbackPath == null ? 0 : shortFallbackPath.size(),
                    normalizedPathList.size(),
                    elapsedMillis(orderStartNs),
                    elapsedMillis(totalStartNs));
            return normalizedPathList;
        } catch (Exception e) {
            log.error("站点路径候选计算异常，startStationId={}，endStationId={}，taskNo={}，pathLenFactor={}，costMs={}",
                    startStationId, endStationId, currentTaskNo, pathLenFactor, elapsedMillis(totalStartNs), e);
            throw e;
        }
    }

    public Map<Integer, Set<Integer>> loadUndirectedStationGraphSnapshot() {
@@ -130,34 +201,61 @@
                                                   Integer currentTaskNo,
                                                   Double pathLenFactor,
                                                   StationPathCalcMode calcMode) {
        long totalStartNs = System.nanoTime();
        Map<String, Long> stepCostMap = new LinkedHashMap<>();
        String pathSource = "fallback";
        int candidateCount = 0;
        List<NavigateNode> resultPath = new ArrayList<>();

        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(
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    pathLenFactor,
                    calcMode,
                    resolvedPolicy
                    resolvedPolicy,
                    runtimeSnapshot
            );
            stepCostMap.put("directPath", elapsedMillis(stepStartNs));
            if (!directPath.isEmpty()) {
                return normalizeStationPath(directPath);
                pathSource = "direct";
                resultPath = normalizeStationPath(directPath);
                logStationPathCalcSlow(startStationId, endStationId, currentTaskNo, pathLenFactor, calcMode, pathSource, candidateCount, resultPath.size(), stepCostMap, totalStartNs);
                return resultPath;
            }
        }

        stepStartNs = System.nanoTime();
        StationPathSearchContext context = buildStationPathSearchContext(
                startStationId,
                endStationId,
                resolvedPolicy,
                calcMode
                calcMode,
                runtimeSnapshot
        );
        stepCostMap.put("buildSearchContext", elapsedMillis(stepStartNs));
        if (context.allList.isEmpty()) {
            logStationPathCalcSlow(startStationId, endStationId, currentTaskNo, pathLenFactor, calcMode, "empty", candidateCount, 0, stepCostMap, totalStartNs);
            return new ArrayList<>();
        }
        candidateCount = context.allList.size();
        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);
        return normalizeStationPath(list);
                : findStationBestPathTwoStage(context.allList, context.resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId, runtimeSnapshot);
        stepCostMap.put("selectBestPath", elapsedMillis(stepStartNs));
        pathSource = calcMode == StationPathCalcMode.REACHABILITY ? "reachability" : "twoStage";
        resultPath = normalizeStationPath(list);
        logStationPathCalcSlow(startStationId, endStationId, currentTaskNo, pathLenFactor, calcMode, pathSource, candidateCount, resultPath.size(), stepCostMap, totalStartNs);
        return resultPath;
    }

    public List<NavigateNode> calcByTrackSiteNo(int lev, Integer startTrackSiteNo, Integer endTrackSiteNo) {
@@ -276,18 +374,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<>();
        }
@@ -298,6 +402,7 @@
                endStationId,
                calcMode.name());

        stepStartNs = System.nanoTime();
        DirectPathSearchResult searchResult = searchDirectPathWithFallback(
                context,
                true,
@@ -313,23 +418,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;
    }

@@ -348,6 +460,54 @@
            return new DirectPathSearchResult(degradedPath, includeWaypoint, false);
        }
        return DirectPathSearchResult.empty(includeWaypoint, includeSoftPreference);
    }

    private List<NavigateNode> buildRerouteShortFallbackPath(Integer startStationId,
                                                             Integer endStationId,
                                                             Integer currentTaskNo,
                                                             StationPathResolvedPolicy resolvedPolicy,
                                                             StationPathRuntimeSnapshot runtimeSnapshot) {
        long startNs = System.nanoTime();
        try {
            List<NavigateNode> path = findStationDirectPath(
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    0.0d,
                    StationPathCalcMode.OPTIMAL,
                    resolvedPolicy,
                    runtimeSnapshot
            );
            List<NavigateNode> normalizedPath = normalizeStationPath(path);
            log.info("站点路径堵塞重规划短路径保底计算完成，startStationId={}，endStationId={}，taskNo={}，pathLen={}，path={}，costMs={}",
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    normalizedPath.size(),
                    JSON.toJSONString(extractStationIdList(normalizedPath)),
                    elapsedMillis(startNs));
            return normalizedPath;
        } catch (Exception e) {
            log.warn("站点路径堵塞重规划短路径保底计算失败，startStationId={}，endStationId={}，taskNo={}，costMs={}，error={}",
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    elapsedMillis(startNs),
                    e.toString());
            return new ArrayList<>();
        }
    }

    private List<List<NavigateNode>> appendShortFallbackCandidate(List<List<NavigateNode>> orderedPathList,
                                                                  List<NavigateNode> shortFallbackPath) {
        List<List<NavigateNode>> candidatePathList = new ArrayList<>();
        if (orderedPathList != null && !orderedPathList.isEmpty()) {
            candidatePathList.addAll(orderedPathList);
        }
        if (shortFallbackPath != null && !shortFallbackPath.isEmpty()) {
            candidatePathList.add(shortFallbackPath);
        }
        return candidatePathList;
    }

    private List<NavigateNode> searchDirectPath(DirectStationPathContext context,
@@ -374,8 +534,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<>();
            }
@@ -416,7 +580,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;
@@ -554,23 +720,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) {
@@ -721,16 +874,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 + "终点 对应的节点");
        }
@@ -740,6 +895,7 @@
        context.startStationId = startStationId;
        context.endStationId = endStationId;
        context.navigateSolution = navigateSolution;
        context.navigateMapIndex = navigateMapIndex;
        context.stationMap = stationMap;
        context.startNode = startNode;
        context.endNode = endNode;
@@ -751,11 +907,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())) {
@@ -803,8 +960,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<>();
        }
@@ -816,11 +974,15 @@
                                                                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()) {
            return new ArrayList<>();
        }

        long stepStartNs = System.nanoTime();
        StationPathRuleConfig ruleConfig = resolvedPolicy.getRuleConfig() == null
                ? new StationPathRuleConfig()
                : resolvedPolicy.getRuleConfig();
@@ -828,7 +990,9 @@
                ? StationPathProfileConfig.defaultConfig()
                : resolvedPolicy.getProfileConfig();
        PathGlobalPolicy globalPolicy = loadPathGlobalPolicy(profileConfig);
        stepCostMap.put("loadPolicyConfig", elapsedMillis(stepStartNs));

        stepStartNs = System.nanoTime();
        List<List<NavigateNode>> filteredCandidates = applyRuleFilters(allList, ruleConfig, true);
        if (filteredCandidates.isEmpty() && hasWaypoint(ruleConfig) && !strictWaypoint(ruleConfig)) {
            filteredCandidates = applyRuleFilters(allList, ruleConfig, false);
@@ -851,16 +1015,20 @@
            }
            filteredCandidates = allList;
        }
        stepCostMap.put("filterCandidates", elapsedMillis(stepStartNs));

        Map<Integer, StationProtocol> statusMap = loadStationStatusMap();
        Map<Integer, Double> stationLoopLoadMap = loadStationLoopLoadMap();
        StationTrafficSnapshot trafficSnapshot = loadStationTrafficSnapshot(statusMap, currentTaskNo);
        LoopMergeGuardContext loopMergeGuardContext = loadLoopMergeGuardContext();
        stepStartNs = System.nanoTime();
        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;
        int skippedByLoopMergeGuard = 0;
        stepStartNs = System.nanoTime();
        for (List<NavigateNode> path : filteredCandidates) {
            if (path == null || path.isEmpty()) {
                continue;
@@ -886,12 +1054,15 @@
            }
            return new ArrayList<>();
        }
        stepCostMap.put("buildMetrics", elapsedMillis(stepStartNs));

        stepStartNs = System.nanoTime();
        applyPathLengthPreference(metricsList, profileConfig, globalPolicy, pathLenFactor);
        metricsList.sort((a, b) -> compareStaticCandidateMetrics(a, b, pathLenFactor));
        PathCandidateMetrics preferred = metricsList.get(0);
        int maxLen = (int) Math.ceil(preferred.pathLen * safeDouble(profileConfig.getS1MaxLenRatio(), 1.15d));
        int maxTurns = preferred.turnCount + safeInt(profileConfig.getS1MaxTurnDiff(), 1);
        stepCostMap.put("stage1StaticSort", elapsedMillis(stepStartNs));

        List<PathCandidateMetrics> stage1Selected = new ArrayList<>();
        for (PathCandidateMetrics metrics : metricsList) {
@@ -911,6 +1082,7 @@
            primaryMetrics = new ArrayList<>(primaryMetrics.subList(0, topK));
        }

        stepStartNs = System.nanoTime();
        primaryMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));
        secondaryMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));

@@ -921,11 +1093,26 @@
            }
        }
        remainingMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));
        stepCostMap.put("stage2DynamicSort", elapsedMillis(stepStartNs));

        stepStartNs = System.nanoTime();
        List<List<NavigateNode>> orderedPathList = new ArrayList<>();
        appendCandidatePathList(orderedPathList, primaryMetrics);
        appendCandidatePathList(orderedPathList, secondaryMetrics);
        appendCandidatePathList(orderedPathList, remainingMetrics);
        stepCostMap.put("buildOrderedPaths", elapsedMillis(stepStartNs));
        logStationPathOrderSlow(startStationId,
                endStationId,
                currentTaskNo,
                pathLenFactor,
                allList.size(),
                filteredCandidates.size(),
                metricsList.size(),
                orderedPathList.size(),
                skippedByLoopMergeGuard,
                skippedByOtherOutStation,
                stepCostMap,
                totalStartNs);
        return orderedPathList;
    }

@@ -1338,19 +1525,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;
@@ -1585,6 +1761,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 {
@@ -1612,6 +1876,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) {
@@ -1710,12 +1990,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;
            }
@@ -1727,16 +2008,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);
                    }
                }
            }
@@ -1746,27 +2024,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;
    }
@@ -1792,6 +2060,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<>();
@@ -1810,8 +2084,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());
@@ -1986,17 +2263,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) {
@@ -2007,7 +2290,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);
        }
@@ -2022,6 +2309,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,
@@ -2052,7 +2388,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>()
@@ -2430,29 +2766,54 @@
    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;
        int filteredCandidateCount = 0;

        long stepStartNs = System.nanoTime();
        BasStation startStation = basStationService.getById(startStationId);
        if (startStation == null) {
            throw new CoolException("未找到该 起点 对应的站点数据");
        }
        Integer lev = startStation.getStationLev();
        stepCostMap.put("loadStartStation", elapsedMillis(stepStartNs));
        log.info("站点路径搜索上下文加载起点完成，startStationId={}，endStationId={}，mode={}，lev={}，costMs={}",
                startStationId, endStationId, calcMode, lev, stepCostMap.get("loadStartStation"));

        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("未找到该 终点 对应的节点");
        }
        stepCostMap.put("loadStationMapAndNode", elapsedMillis(stepStartNs));
        log.info("站点路径搜索上下文加载地图完成，startStationId={}，endStationId={}，mode={}，mapRows={}，startNode=({},{})，endNode=({},{})，costMs={}",
                startStationId,
                endStationId,
                calcMode,
                stationMap.size(),
                startNode.getX(),
                startNode.getY(),
                endNode.getX(),
                endNode.getY(),
                stepCostMap.get("loadStationMapAndNode"));

        stepStartNs = System.nanoTime();
        StationPathProfileConfig profileConfig = resolvedPolicy.getProfileConfig() == null
                ? StationPathProfileConfig.defaultConfig()
                : resolvedPolicy.getProfileConfig();
        stepCostMap.put("loadProfileConfig", elapsedMillis(stepStartNs));

        long startTime = System.currentTimeMillis();
        News.info("[WCS Debug] 站点路径开始计算,startStationId={},endStationId={},mode={}",
@@ -2460,9 +2821,18 @@
                endStationId,
                calcMode == null ? "" : calcMode.name());
        int calcMaxDepth = safeInt(profileConfig.getCalcMaxDepth(), 120);
        int calcMaxPaths = safeInt(profileConfig.getCalcMaxPaths(), 500);
        int calcMaxPaths = safeInt(profileConfig.getCalcMaxPaths(), 50);
        int calcMaxCost = safeInt(profileConfig.getCalcMaxCost(), 300);
        List<Integer> guideStationSequence = buildGuideStationSequence(startStationId, endStationId, resolvedPolicy.getRuleConfig());
        log.info("站点路径候选枚举开始，startStationId={}，endStationId={}，mode={}，calcMaxDepth={}，calcMaxPaths={}，calcMaxCost={}，guideStationSequence={}",
                startStationId,
                endStationId,
                calcMode,
                calcMaxDepth,
                calcMaxPaths,
                calcMaxCost,
                JSON.toJSONString(guideStationSequence));
        stepStartNs = System.nanoTime();
        List<List<NavigateNode>> allList = navigateSolution.allSimplePaths(
                stationMap,
                startNode,
@@ -2472,13 +2842,34 @@
                calcMaxCost,
                guideStationSequence
        );
        stepCostMap.put("allSimplePaths", elapsedMillis(stepStartNs));
        rawCandidateCount = allList.size();
        log.info("站点路径候选枚举完成，startStationId={}，endStationId={}，mode={}，rawCandidateCount={}，costMs={}",
                startStationId,
                endStationId,
                calcMode,
                rawCandidateCount,
                stepCostMap.get("allSimplePaths"));
        if (allList.isEmpty()) {
            logStationPathSearchContextSlow(startStationId, endStationId, calcMode, lev, rawCandidateCount, filteredCandidateCount, stepCostMap, totalStartNs);
            return StationPathSearchContext.empty(resolvedPolicy);
        }
        Map<Integer, StationProtocol> statusMap = loadStationStatusMap();
        stepStartNs = System.nanoTime();
        Map<Integer, StationProtocol> statusMap = runtimeSnapshot == null ? Collections.emptyMap() : runtimeSnapshot.statusMap;
        allList = filterNonAutoStationPaths(allList, statusMap);
        stepCostMap.put("filterNonAutoStation", elapsedMillis(stepStartNs));
        filteredCandidateCount = allList.size();
        log.info("站点路径候选自动状态过滤完成，startStationId={}，endStationId={}，mode={}，rawCandidateCount={}，filteredCandidateCount={}，statusCount={}，costMs={}",
                startStationId,
                endStationId,
                calcMode,
                rawCandidateCount,
                filteredCandidateCount,
                statusMap.size(),
                stepCostMap.get("filterNonAutoStation"));
        if (allList.isEmpty()) {
            News.info("[WCS Debug] 站点路径候选全部被过滤，存在非自动站点,startStationId={},endStationId={}", startStationId, endStationId);
            logStationPathSearchContextSlow(startStationId, endStationId, calcMode, lev, rawCandidateCount, filteredCandidateCount, stepCostMap, totalStartNs);
            return StationPathSearchContext.empty(resolvedPolicy);
        }
        News.info("[WCS Debug] 站点路径计算完成，耗时：{}ms,startStationId={},endStationId={},mode={}",
@@ -2486,7 +2877,132 @@
                startStationId,
                endStationId,
                calcMode == null ? "" : calcMode.name());
        logStationPathSearchContextSlow(startStationId, endStationId, calcMode, lev, rawCandidateCount, filteredCandidateCount, stepCostMap, totalStartNs);
        return new StationPathSearchContext(allList, resolvedPolicy);
    }

    private void logStationPathCalcSlow(Integer startStationId,
                                        Integer endStationId,
                                        Integer currentTaskNo,
                                        Double pathLenFactor,
                                        StationPathCalcMode calcMode,
                                        String pathSource,
                                        int candidateCount,
                                        int resultPathLen,
                                        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={}，pathSource={}，pathLenFactor={}，candidateCount={}，resultPathLen={}，stepCosts={}，totalCost={}ms",
                startStationId,
                endStationId,
                currentTaskNo,
                calcMode == null ? "" : calcMode.name(),
                pathSource,
                pathLenFactor,
                candidateCount,
                resultPathLen,
                JSON.toJSONString(stepCostMap),
                totalCostMs);
    }

    private void logStationPathOrderSlow(Integer startStationId,
                                         Integer endStationId,
                                         Integer currentTaskNo,
                                         Double pathLenFactor,
                                         int candidateCount,
                                         int filteredCandidateCount,
                                         int metricsCount,
                                         int orderedPathCount,
                                         int skippedByLoopMergeGuard,
                                         int skippedByOtherOutStation,
                                         Map<String, Long> stepCostMap,
                                         long totalStartNs) {
        long totalCostMs = elapsedMillis(totalStartNs);
        if (totalCostMs < STATION_PATH_SLOW_LOG_THRESHOLD_MS) {
            return;
        }
        News.warn("站点路径候选排序耗时较长，startStationId={}，endStationId={}，taskNo={}，pathLenFactor={}，candidateCount={}，filteredCandidateCount={}，metricsCount={}，orderedPathCount={}，skippedByLoopMergeGuard={}，skippedByOtherOutStation={}，stepCosts={}，totalCost={}ms",
                startStationId,
                endStationId,
                currentTaskNo,
                pathLenFactor,
                candidateCount,
                filteredCandidateCount,
                metricsCount,
                orderedPathCount,
                skippedByLoopMergeGuard,
                skippedByOtherOutStation,
                JSON.toJSONString(stepCostMap),
                totalCostMs);
    }

    private void logStationPathSearchContextSlow(Integer startStationId,
                                                 Integer endStationId,
                                                 StationPathCalcMode calcMode,
                                                 Integer lev,
                                                 int rawCandidateCount,
                                                 int filteredCandidateCount,
                                                 Map<String, Long> stepCostMap,
                                                 long totalStartNs) {
        long totalCostMs = elapsedMillis(totalStartNs);
        if (totalCostMs < STATION_PATH_SLOW_LOG_THRESHOLD_MS) {
            return;
        }
        News.warn("站点路径候选生成耗时较长，startStationId={}，endStationId={}，lev={}，mode={}，rawCandidateCount={}，filteredCandidateCount={}，stepCosts={}，totalCost={}ms",
                startStationId,
                endStationId,
                lev,
                calcMode == null ? "" : calcMode.name(),
                rawCandidateCount,
                filteredCandidateCount,
                JSON.toJSONString(stepCostMap),
                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;
    }

    private List<List<NavigateNode>> normalizeCandidatePaths(List<List<NavigateNode>> orderedPathList) {
@@ -2513,16 +3029,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;
            }
@@ -2542,19 +3052,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;
@@ -2587,6 +3086,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;
    }
@@ -2611,6 +3118,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;
@@ -2618,6 +3126,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();
@@ -2661,6 +3170,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;
        }
    }

@@ -2717,6 +3306,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 {
@@ -2824,7 +3423,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 {
@@ -2832,7 +3437,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;
    }