zy-wcs-master.git

			@@ -7,8 +7,10 @@
			import java.util.LinkedHashSet;
			import java.util.List;
			import java.util.Map;
			import java.util.PriorityQueue;
			import java.util.Set;

			import com.zy.asrs.domain.path.StationPathCalcMode;
			import com.zy.asrs.domain.path.StationPathProfileConfig;
			import com.zy.asrs.domain.path.StationPathResolvedPolicy;
			import com.zy.asrs.domain.path.StationPathRuleConfig;
			@@ -32,6 +34,7 @@
			import org.springframework.stereotype.Component;

			import com.alibaba.fastjson.JSON;
			import com.alibaba.fastjson.JSONArray;
			import com.alibaba.fastjson.JSONObject;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import com.core.common.SpringUtils;
			@@ -51,6 +54,8 @@
			@Component
			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;
			@@ -72,112 +77,125 @@
			@Autowired
			private StationTaskTraceRegistry stationTaskTraceRegistry;

			public synchronized List<NavigateNode> calcByStationId(Integer startStationId, Integer endStationId) {
			return calcByStationId(startStationId, endStationId, null);
			private final Object runtimeSnapshotLock = new Object();
			private volatile CachedStationPathRuntimeSnapshot cachedRuntimeSnapshot;

			public List<NavigateNode> calcOptimalPathByStationId(Integer startStationId,
			Integer endStationId,
			Integer currentTaskNo,
			Double pathLenFactor) {
			return calcPathByStationId(startStationId, endStationId, currentTaskNo, pathLenFactor, StationPathCalcMode.OPTIMAL);
			}

			public synchronized List<NavigateNode> calcByStationId(Integer startStationId, Integer endStationId, Integer currentTaskNo) {
			BasStation startStation = basStationService.getById(startStationId);
			if (startStation == null) {
			throw new CoolException("未找到该起点对应的站点数据");
			}
			Integer lev = startStation.getStationLev();
			public List<NavigateNode> calcReachablePathByStationId(Integer startStationId, Integer endStationId) {
			return calcPathByStationId(startStationId, endStationId, null, null, StationPathCalcMode.REACHABILITY);
			}

			NavigateSolution navigateSolution = new NavigateSolution();
			List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(lev);

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

			NavigateNode endNode = navigateSolution.findStationNavigateNode(stationMap, endStationId);
			if (endNode == null) {
			throw new CoolException("未找到该终点对应的节点");
			}

			public List<List<NavigateNode>> calcCandidatePathByStationId(Integer startStationId,
			Integer endStationId,
			Integer currentTaskNo,
			Double pathLenFactor) {
			StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
			StationPathProfileConfig profileConfig = resolvedPolicy.getProfileConfig() == null
			? StationPathProfileConfig.defaultConfig()
			: resolvedPolicy.getProfileConfig();

			long startTime = System.currentTimeMillis();
			News.info("[WCS Debug] 站点路径开始计算,startStationId={},endStationId={}", startStationId, endStationId);
			int calcMaxDepth = safeInt(profileConfig.getCalcMaxDepth(), 120);
			int calcMaxPaths = safeInt(profileConfig.getCalcMaxPaths(), 500);
			int calcMaxCost = safeInt(profileConfig.getCalcMaxCost(), 300);
			List<Integer> guideStationSequence = buildGuideStationSequence(startStationId, endStationId, resolvedPolicy.getRuleConfig());
			List<List<NavigateNode>> allList = navigateSolution.allSimplePaths(
			stationMap,
			startNode,
			endNode,
			calcMaxDepth,
			calcMaxPaths,
			calcMaxCost,
			guideStationSequence
			StationPathRuntimeSnapshot runtimeSnapshot = loadStationPathRuntimeSnapshot(currentTaskNo);
			StationPathSearchContext context = buildStationPathSearchContext(
			startStationId,
			endStationId,
			resolvedPolicy,
			StationPathCalcMode.REROUTE,
			runtimeSnapshot
			);
			if (allList.isEmpty()) {
			// throw new CoolException("未找到该路径");
			if (context.allList.isEmpty()) {
			return new ArrayList<>();
			}
			Map<Integer, StationProtocol> statusMap = loadStationStatusMap();
			allList = filterNonAutoStationPaths(allList, statusMap);
			if (allList.isEmpty()) {
			News.info("[WCS Debug] 站点路径候选全部被过滤，存在非自动站点,startStationId={},endStationId={}", startStationId, endStationId);
			return new ArrayList<>();
			}
			News.info("[WCS Debug] 站点路径计算完成，耗时：{}ms", System.currentTimeMillis() - startTime);

			startTime = System.currentTimeMillis();
			News.info("[WCS Debug] 站点路径权重开始分析,startStationId={},endStationId={}", startStationId, endStationId);
			List<NavigateNode> list = findStationBestPathTwoStage(allList, resolvedPolicy, currentTaskNo);
			News.info("[WCS Debug] 站点路径权重分析完成，耗时：{}ms", System.currentTimeMillis() - startTime);
			List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(
			context.allList,
			context.resolvedPolicy,
			currentTaskNo,
			pathLenFactor,
			startStationId,
			endStationId,
			runtimeSnapshot
			);
			return normalizeCandidatePaths(orderedPathList);
			}

			//去重
			HashSet<Integer> set = new HashSet<>();
			List<NavigateNode> fitlerList = new ArrayList<>();
			for (NavigateNode navigateNode : list) {
			JSONObject valuObject = JSON.parseObject(navigateNode.getNodeValue());
			if (valuObject.containsKey("rgvCalcFlag")) {
			public Map<Integer, Set<Integer>> loadUndirectedStationGraphSnapshot() {
			Map<Integer, Set<Integer>> graph = loadUndirectedStationGraph();
			Map<Integer, Set<Integer>> snapshot = new HashMap<>();
			for (Map.Entry<Integer, Set<Integer>> entry : graph.entrySet()) {
			Integer stationId = entry.getKey();
			if (stationId == null) {
			continue;
			}
			if (set.add(valuObject.getInteger("stationId"))) {
			fitlerList.add(navigateNode);
			}
			snapshot.put(stationId, new LinkedHashSet<>(entry.getValue() == null ? Collections.emptySet() : entry.getValue()));
			}

			for (int i = 0; i < fitlerList.size(); i++) {
			NavigateNode currentNode = fitlerList.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) {}

			NavigateNode nextNode = (i + 1 < fitlerList.size()) ? fitlerList.get(i + 1) : null;
			NavigateNode prevNode = (i - 1 >= 0) ? fitlerList.get(i - 1) : null;

			HashMap<String, Object> result = searchInflectionPoint(currentNode, nextNode, prevNode);
			if (Boolean.parseBoolean(result.get("result").toString())) {
			currentNode.setIsInflectionPoint(true);
			currentNode.setDirection(result.get("direction").toString());
			}
			}

			return fitlerList;
			return snapshot;
			}

			public synchronized List<NavigateNode> calcByTrackSiteNo(int lev, Integer startTrackSiteNo, Integer endTrackSiteNo) {
			private List<NavigateNode> calcPathByStationId(Integer startStationId,
			Integer endStationId,
			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,
			runtimeSnapshot
			);
			stepCostMap.put("directPath", elapsedMillis(stepStartNs));
			if (!directPath.isEmpty()) {
			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,
			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, 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) {
			NavigateSolution navigateSolution = new NavigateSolution();
			List<List<NavigateNode>> rgvTrackMap = navigateSolution.getRgvTrackMap(lev);

			@@ -247,7 +265,7 @@
			return fitlerList;
			}

			public synchronized List<NavigateNode> findLiftStationList(int lev) {
			public List<NavigateNode> findLiftStationList(int lev) {
			NavigateSolution navigateSolution = new NavigateSolution();
			List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(lev);

			@@ -288,9 +306,517 @@
			return new StationPathResolvedPolicy();
			}

			private List<NavigateNode> findStationBestPathTwoStage(List<List<NavigateNode>> allList,
			StationPathResolvedPolicy resolvedPolicy,
			Integer currentTaskNo) {
			private List<NavigateNode> findStationDirectPath(Integer startStationId,
			Integer endStationId,
			Integer currentTaskNo,
			Double pathLenFactor,
			StationPathCalcMode calcMode,
			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,
			runtimeSnapshot
			);
			stepCostMap.put("buildDirectContext", elapsedMillis(stepStartNs));
			if (context == null) {
			return new ArrayList<>();
			}

			long startTime = System.currentTimeMillis();
			News.info("[WCS Debug] 站点路径快速计算开始,startStationId={},endStationId={},mode={}",
			startStationId,
			endStationId,
			calcMode.name());

			stepStartNs = System.nanoTime();
			DirectPathSearchResult searchResult = searchDirectPathWithFallback(
			context,
			true,
			calcMode == StationPathCalcMode.OPTIMAL
			);
			if (searchResult.path.isEmpty() && hasWaypoint(context.ruleConfig) && !strictWaypoint(context.ruleConfig)) {
			searchResult = searchDirectPathWithFallback(
			context,
			false,
			calcMode == StationPathCalcMode.OPTIMAL
			);
			if (!searchResult.path.isEmpty()) {
			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;
			}

			private DirectPathSearchResult searchDirectPathWithFallback(DirectStationPathContext context,
			boolean includeWaypoint,
			boolean includeSoftPreference) {
			List<NavigateNode> path = searchDirectPath(context, includeWaypoint, includeSoftPreference);
			if (!path.isEmpty()) {
			return new DirectPathSearchResult(path, includeWaypoint, includeSoftPreference);
			}
			if (includeSoftPreference && hasSoftPreference(context.ruleConfig) && allowSoftDegrade(context.ruleConfig)) {
			List<NavigateNode> degradedPath = searchDirectPath(context, includeWaypoint, false);
			if (!degradedPath.isEmpty()) {
			News.info("[WCS Debug] 站点路径快速计算已降级，忽略软偏好约束后重试");
			}
			return new DirectPathSearchResult(degradedPath, includeWaypoint, false);
			}
			return DirectPathSearchResult.empty(includeWaypoint, includeSoftPreference);
			}

			private List<NavigateNode> searchDirectPath(DirectStationPathContext context,
			boolean includeWaypoint,
			boolean includeSoftPreference) {
			List<Integer> guideStationSequence = buildDirectGuideStationSequence(
			context.startStationId,
			context.endStationId,
			context.ruleConfig,
			includeWaypoint,
			includeSoftPreference
			);
			if (guideStationSequence.isEmpty()) {
			guideStationSequence = new ArrayList<>();
			guideStationSequence.add(context.startStationId);
			guideStationSequence.add(context.endStationId);
			}

			List<NavigateNode> result = new ArrayList<>();
			for (int i = 1; i < guideStationSequence.size(); i++) {
			Integer segmentStartStationId = guideStationSequence.get(i - 1);
			Integer segmentEndStationId = guideStationSequence.get(i);
			if (segmentStartStationId == null \|\| segmentEndStationId == null) {
			return new ArrayList<>();
			}

			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<>();
			}

			List<NavigateNode> segmentPath = searchDirectPathSegment(
			context,
			segmentStartNode,
			segmentEndNode,
			includeSoftPreference
			);
			if (segmentPath.isEmpty()) {
			return new ArrayList<>();
			}
			mergeSegmentPath(result, segmentPath);
			}
			return result;
			}

			private List<NavigateNode> searchDirectPathSegment(DirectStationPathContext context,
			NavigateNode startNode,
			NavigateNode endNode,
			boolean includeSoftPreference) {
			PriorityQueue<DirectPathState> openQueue = new PriorityQueue<>((left, right) -> {
			int compare = Double.compare(left.fScore, right.fScore);
			if (compare != 0) {
			return compare;
			}
			return Double.compare(left.gScore, right.gScore);
			});
			Map<String, Double> bestScoreMap = new HashMap<>();
			DirectPathState startState = new DirectPathState(startNode, null, 0.0d, calcHeuristicScore(startNode, endNode));
			openQueue.offer(startState);
			bestScoreMap.put(buildDirectStateKey(startState), 0.0d);

			while (!openQueue.isEmpty()) {
			DirectPathState currentState = openQueue.poll();
			if (sameCoordinate(currentState.node, endNode)) {
			return buildDirectPath(currentState);
			}

			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;
			}

			double stepCost = calcDirectStepCost(
			context,
			currentState.parent == null ? null : currentState.parent.node,
			currentState.node,
			nextNode,
			endNode,
			includeSoftPreference
			);
			double nextGScore = currentState.gScore + stepCost;
			DirectPathState nextState = new DirectPathState(
			nextNode,
			currentState,
			nextGScore,
			nextGScore + calcHeuristicScore(nextNode, endNode)
			);
			String stateKey = buildDirectStateKey(nextState);
			Double recordedScore = bestScoreMap.get(stateKey);
			if (recordedScore != null && recordedScore <= nextGScore) {
			continue;
			}
			bestScoreMap.put(stateKey, nextGScore);
			openQueue.offer(nextState);
			}
			}
			return new ArrayList<>();
			}

			private boolean isDirectTransitionAllowed(DirectStationPathContext context,
			NavigateNode currentNode,
			NavigateNode nextNode,
			NavigateNode endNode) {
			if (nextNode == null) {
			return false;
			}
			Integer nextStationId = extractStationId(nextNode);
			Integer currentStationId = extractStationId(currentNode);
			Integer endStationId = extractStationId(endNode);

			if (nextStationId != null && !nextStationId.equals(endStationId)) {
			if (context.forbidStationIdSet.contains(nextStationId)) {
			return false;
			}
			StationProtocol protocol = context.statusMap.get(nextStationId);
			if (protocol != null && !protocol.isAutoing()) {
			return false;
			}
			if (context.globalPolicy.forceSkipPassOtherOutStation
			&& context.outStationIdSet.contains(nextStationId)
			&& !nextStationId.equals(context.startStationId)
			&& !nextStationId.equals(context.endStationId)) {
			return false;
			}
			}

			if (currentStationId != null && nextStationId != null) {
			String edgeKey = currentStationId + "->" + nextStationId;
			if (context.forbidEdgeSet.contains(edgeKey)) {
			return false;
			}
			}
			return true;
			}

			private double calcDirectStepCost(DirectStationPathContext context,
			NavigateNode prevNode,
			NavigateNode currentNode,
			NavigateNode nextNode,
			NavigateNode endNode,
			boolean includeSoftPreference) {
			double stepCost = safeDouble(context.profileConfig.getS1LenWeight(), 1.0d) * context.globalPolicy.lenWeightFactor;
			stepCost += safeDouble(context.profileConfig.getS1TurnWeight(), 3.0d)
			* calcDirectTurnPenalty(prevNode, currentNode, nextNode, endNode);
			stepCost += safeDouble(context.profileConfig.getS1LiftWeight(), 8.0d) * calcLiftTransferPenalty(nextNode);

			if (context.calcMode == StationPathCalcMode.REACHABILITY) {
			return Math.max(stepCost, 1.0d);
			}

			Integer stationId = extractStationId(nextNode);
			if (stationId != null) {
			double congWeightFactor = context.globalPolicy.congWeightFactor;
			stepCost += safeDouble(context.profileConfig.getS2BusyWeight(), 2.0d)
			* congWeightFactor
			* context.trafficSnapshot.congestionScoreMap.getOrDefault(stationId, 0.0d);
			stepCost += safeDouble(context.profileConfig.getS2QueueWeight(), 2.5d)
			* context.trafficSnapshot.queueDepthMap.getOrDefault(stationId, 0);
			stepCost += safeDouble(context.profileConfig.getS2WaitWeight(), 1.5d)
			* (context.trafficSnapshot.estimatedWaitSecondsMap.getOrDefault(stationId, 0.0d) / 60.0d);
			StationProtocol protocol = context.statusMap.get(stationId);
			if (protocol != null && protocol.isRunBlock()) {
			stepCost += safeDouble(context.profileConfig.getS2RunBlockWeight(), 10.0d);
			}
			stepCost += safeDouble(context.profileConfig.getS2LoopLoadWeight(), 12.0d)
			* context.stationLoopLoadMap.getOrDefault(stationId, 0.0d);
			if (context.outStationIdSet.contains(stationId)
			&& !stationId.equals(context.startStationId)
			&& !stationId.equals(context.endStationId)) {
			stepCost += context.globalPolicy.passOtherOutStationPenaltyWeight;
			}

			if (includeSoftPreference && context.softReferenceStationSet.contains(stationId)) {
			stepCost -= 0.25d;
			} else if (includeSoftPreference
			&& stationId != null
			&& !stationId.equals(context.startStationId)
			&& !stationId.equals(context.endStationId)
			&& !context.softReferenceStationSet.isEmpty()) {
			double softDeviationWeight = safeDouble(context.profileConfig.getS1SoftDeviationWeight(), 4.0d);
			if (context.ruleConfig.getSoft() != null && context.ruleConfig.getSoft().getDeviationWeight() != null) {
			softDeviationWeight = context.ruleConfig.getSoft().getDeviationWeight();
			}
			stepCost += softDeviationWeight;
			}
			}

			return Math.max(stepCost, 1.0d);
			}

			private int calcDirectTurnPenalty(NavigateNode prevNode,
			NavigateNode currentNode,
			NavigateNode nextNode,
			NavigateNode endNode) {
			if (prevNode == null \|\| currentNode == null \|\| nextNode == null) {
			return 0;
			}
			if (nextNode.getX() == prevNode.getX() \|\| nextNode.getY() == prevNode.getY()) {
			return 0;
			}
			return (endNode != null && (nextNode.getX() == endNode.getX() \|\| nextNode.getY() == endNode.getY())) ? 1 : 1;
			}

			private int calcLiftTransferPenalty(NavigateNode node) {
			if (node == null) {
			return 0;
			}
			return Boolean.TRUE.equals(node.getLiftTransfer()) ? 1 : 0;
			}

			private double calcHeuristicScore(NavigateNode currentNode, NavigateNode endNode) {
			if (currentNode == null \|\| endNode == null) {
			return 0.0d;
			}
			return Math.abs(endNode.getX() - currentNode.getX()) + Math.abs(endNode.getY() - currentNode.getY());
			}

			private boolean sameCoordinate(NavigateNode left, NavigateNode right) {
			return left != null
			&& right != null
			&& left.getX() == right.getX()
			&& left.getY() == right.getY();
			}

			private String buildDirectStateKey(DirectPathState state) {
			if (state == null \|\| state.node == null) {
			return "";
			}
			String currentKey = state.node.getX() + "_" + state.node.getY();
			if (state.parent == null \|\| state.parent.node == null) {
			return currentKey + "\|S";
			}
			return currentKey + "\|" + state.parent.node.getX() + "_" + state.parent.node.getY();
			}

			private List<NavigateNode> buildDirectPath(DirectPathState endState) {
			List<NavigateNode> path = new ArrayList<>();
			DirectPathState cursor = endState;
			while (cursor != null) {
			NavigateNode clonedNode = cursor.node == null ? null : cursor.node.clone();
			if (clonedNode != null) {
			path.add(clonedNode);
			}
			cursor = cursor.parent;
			}
			Collections.reverse(path);
			return path;
			}

			private void mergeSegmentPath(List<NavigateNode> target, List<NavigateNode> segmentPath) {
			if (target == null \|\| segmentPath == null \|\| segmentPath.isEmpty()) {
			return;
			}
			if (target.isEmpty()) {
			target.addAll(segmentPath);
			return;
			}
			for (int i = 0; i < segmentPath.size(); i++) {
			if (i == 0 && sameCoordinate(target.get(target.size() - 1), segmentPath.get(i))) {
			continue;
			}
			target.add(segmentPath.get(i));
			}
			}

			private List<Integer> buildDirectGuideStationSequence(Integer startStationId,
			Integer endStationId,
			StationPathRuleConfig ruleConfig,
			boolean includeWaypoint,
			boolean includeSoftPreference) {
			List<Integer> sequence = new ArrayList<>();
			appendGuideStation(sequence, startStationId);
			if (ruleConfig == null) {
			appendGuideStation(sequence, endStationId);
			return sequence;
			}

			if (includeSoftPreference) {
			List<Integer> preferredPath = safeList(ruleConfig.getSoft() == null ? null : ruleConfig.getSoft().getPreferredPath());
			if (!preferredPath.isEmpty() && startStationId.equals(preferredPath.get(0))) {
			for (int i = 1; i < preferredPath.size(); i++) {
			appendGuideStation(sequence, preferredPath.get(i));
			}
			if (sequence.get(sequence.size() - 1).equals(endStationId)) {
			return sequence;
			}
			sequence.clear();
			appendGuideStation(sequence, startStationId);
			}
			}

			if (includeWaypoint) {
			for (Integer stationId : safeList(ruleConfig.getWaypoint() == null ? null : ruleConfig.getWaypoint().getStations())) {
			appendGuideStation(sequence, stationId);
			}
			}
			if (includeSoftPreference) {
			for (Integer stationId : safeList(ruleConfig.getSoft() == null ? null : ruleConfig.getSoft().getKeyStations())) {
			appendGuideStation(sequence, stationId);
			}
			}
			appendGuideStation(sequence, endStationId);
			return sequence;
			}

			private boolean isDirectPathValid(List<NavigateNode> path,
			DirectStationPathContext context,
			boolean includeWaypoint,
			boolean includeSoftPreference) {
			if (path == null \|\| path.isEmpty()) {
			return false;
			}
			List<Integer> stationIdList = extractStationIdList(path);
			if (!matchHardConstraint(stationIdList, context.ruleConfig.getHard())) {
			return false;
			}
			if (includeWaypoint && !matchWaypointConstraint(stationIdList, context.ruleConfig.getWaypoint())) {
			return false;
			}
			if (includeSoftPreference && !matchSoftConstraint(stationIdList, context.ruleConfig.getSoft())) {
			return false;
			}
			if (!isLoopMergePathAllowed(
			path,
			context.statusMap,
			context.trafficSnapshot,
			context.loopMergeGuardContext,
			Collections.emptySet())) {
			return false;
			}

			if (context.globalPolicy.forceSkipPassOtherOutStation
			&& countPassOtherOutStations(path, context.outStationIdSet) > 0) {
			return false;
			}
			return true;
			}

			private boolean supportsDirectPathMode(StationPathCalcMode calcMode,
			StationPathResolvedPolicy resolvedPolicy,
			Double pathLenFactor) {
			if (calcMode == null \|\| calcMode == StationPathCalcMode.REROUTE) {
			return false;
			}
			if (calcMode == StationPathCalcMode.OPTIMAL && normalizePathLenFactor(pathLenFactor) > 0.0d) {
			return false;
			}
			StationPathRuleConfig ruleConfig = resolvedPolicy == null \|\| resolvedPolicy.getRuleConfig() == null
			? new StationPathRuleConfig()
			: resolvedPolicy.getRuleConfig();
			return safeList(ruleConfig.getHard() == null ? null : ruleConfig.getHard().getMustPassStations()).isEmpty()
			&& safeList(ruleConfig.getHard() == null ? null : ruleConfig.getHard().getMustPassEdges()).isEmpty();
			}

			private DirectStationPathContext buildDirectStationPathContext(Integer startStationId,
			Integer endStationId,
			Integer currentTaskNo,
			StationPathCalcMode calcMode,
			StationPathResolvedPolicy resolvedPolicy,
			StationPathRuntimeSnapshot runtimeSnapshot) {
			BasStation startStation = basStationService.getById(startStationId);
			if (startStation == null) {
			throw new CoolException("未找到该 " + startStationId + "起点对应的站点数据");
			}

			NavigateSolution navigateSolution = new NavigateSolution();
			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 + "终点对应的节点");
			}

			DirectStationPathContext context = new DirectStationPathContext();
			context.calcMode = calcMode;
			context.startStationId = startStationId;
			context.endStationId = endStationId;
			context.navigateSolution = navigateSolution;
			context.navigateMapIndex = navigateMapIndex;
			context.stationMap = stationMap;
			context.startNode = startNode;
			context.endNode = endNode;
			context.resolvedPolicy = resolvedPolicy == null ? new StationPathResolvedPolicy() : resolvedPolicy;
			context.ruleConfig = context.resolvedPolicy.getRuleConfig() == null
			? new StationPathRuleConfig()
			: context.resolvedPolicy.getRuleConfig();
			context.profileConfig = context.resolvedPolicy.getProfileConfig() == null
			? StationPathProfileConfig.defaultConfig()
			: context.resolvedPolicy.getProfileConfig();
			context.globalPolicy = loadPathGlobalPolicy(context.profileConfig);
			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())) {
			if (notBlank(edgeText)) {
			context.forbidEdgeSet.add(edgeText.replace(" ", ""));
			}
			}
			context.softReferenceStationSet = new HashSet<>(getSoftReferencePath(context.ruleConfig.getSoft()));
			return context;
			}

			private List<NavigateNode> findStationReachablePath(List<List<NavigateNode>> allList,
			StationPathResolvedPolicy resolvedPolicy,
			Integer startStationId,
			Integer endStationId) {
			if (allList == null \|\| allList.isEmpty()) {
			return new ArrayList<>();
			}
			@@ -298,11 +824,64 @@
			StationPathRuleConfig ruleConfig = resolvedPolicy.getRuleConfig() == null
			? new StationPathRuleConfig()
			: resolvedPolicy.getRuleConfig();

			List<List<NavigateNode>> filteredCandidates = applyRuleFilters(allList, ruleConfig, true);
			if (filteredCandidates.isEmpty() && hasWaypoint(ruleConfig) && !strictWaypoint(ruleConfig)) {
			filteredCandidates = applyRuleFilters(allList, ruleConfig, false);
			News.info("[WCS Debug] 站点路径可达性规则已降级，忽略关键途经点约束后重试");
			}
			if (filteredCandidates.isEmpty()) {
			if (resolvedPolicy.matchedRule()) {
			News.warn("站点路径规则命中但无可达路径，ruleCode={},startStationId={},endStationId={}",
			resolvedPolicy.getRuleEntity() == null ? "" : resolvedPolicy.getRuleEntity().getRuleCode(),
			startStationId, endStationId);
			return new ArrayList<>();
			}
			filteredCandidates = allList;
			}

			filteredCandidates.sort((left, right) -> compareReachabilityPath(left, right));
			return filteredCandidates.isEmpty() ? new ArrayList<>() : filteredCandidates.get(0);
			}

			private List<NavigateNode> findStationBestPathTwoStage(List<List<NavigateNode>> allList,
			StationPathResolvedPolicy resolvedPolicy,
			Integer currentTaskNo,
			Double pathLenFactor,
			Integer startStationId,
			Integer endStationId,
			StationPathRuntimeSnapshot runtimeSnapshot) {
			List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(allList, resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId, runtimeSnapshot);
			if (orderedPathList.isEmpty()) {
			return new ArrayList<>();
			}
			return orderedPathList.get(0);
			}

			private List<List<NavigateNode>> orderStationPathCandidates(List<List<NavigateNode>> allList,
			StationPathResolvedPolicy resolvedPolicy,
			Integer currentTaskNo,
			Double pathLenFactor,
			Integer startStationId,
			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();
			StationPathProfileConfig profileConfig = resolvedPolicy.getProfileConfig() == null
			? 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);
			@@ -325,16 +904,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;
			@@ -353,20 +936,22 @@
			if (metricsList.isEmpty()) {
			if (globalPolicy.forceSkipPassOtherOutStation && skippedByOtherOutStation > 0) {
			News.warn("[WCS Debug] 站点路径候选全部被过滤，因经过其他出库站点,startStationId={},endStationId={}",
			resolvedPolicy.getRuleEntity() == null ? null : resolvedPolicy.getRuleEntity().getStartStationId(),
			resolvedPolicy.getRuleEntity() == null ? null : resolvedPolicy.getRuleEntity().getEndStationId());
			startStationId, endStationId);
			} else if (skippedByLoopMergeGuard > 0) {
			News.warn("[WCS Debug] 站点路径候选全部被过滤，因分叉口插入环线主干会影响主干道,startStationId={},endStationId={}",
			resolvedPolicy.getRuleEntity() == null ? null : resolvedPolicy.getRuleEntity().getStartStationId(),
			resolvedPolicy.getRuleEntity() == null ? null : resolvedPolicy.getRuleEntity().getEndStationId());
			startStationId, endStationId);
			}
			return new ArrayList<>();
			}
			stepCostMap.put("buildMetrics", elapsedMillis(stepStartNs));

			metricsList.sort((a, b) -> compareDouble(a.staticCost, b.staticCost, a.turnCount, b.turnCount, a.pathLen, b.pathLen));
			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) {
			@@ -379,12 +964,57 @@
			}

			int topK = safeInt(profileConfig.getS1TopK(), 5);
			if (topK > 0 && stage1Selected.size() > topK) {
			stage1Selected = new ArrayList<>(stage1Selected.subList(0, topK));
			List<PathCandidateMetrics> primaryMetrics = new ArrayList<>(stage1Selected);
			List<PathCandidateMetrics> secondaryMetrics = new ArrayList<>();
			if (topK > 0 && primaryMetrics.size() > topK) {
			secondaryMetrics.addAll(primaryMetrics.subList(topK, primaryMetrics.size()));
			primaryMetrics = new ArrayList<>(primaryMetrics.subList(0, topK));
			}

			stage1Selected.sort((a, b) -> compareDouble(a.dynamicCost, b.dynamicCost, a.pathLen, b.pathLen, a.turnCount, b.turnCount));
			return stage1Selected.get(0).path;
			stepStartNs = System.nanoTime();
			primaryMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));
			secondaryMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));

			List<PathCandidateMetrics> remainingMetrics = new ArrayList<>();
			for (PathCandidateMetrics metrics : metricsList) {
			if (!stage1Selected.contains(metrics)) {
			remainingMetrics.add(metrics);
			}
			}
			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;
			}

			private void appendCandidatePathList(List<List<NavigateNode>> orderedPathList,
			List<PathCandidateMetrics> metricsList) {
			if (orderedPathList == null \|\| metricsList == null) {
			return;
			}
			for (PathCandidateMetrics metrics : metricsList) {
			if (metrics != null && metrics.path != null && !metrics.path.isEmpty()) {
			orderedPathList.add(metrics.path);
			}
			}
			}

			private List<List<NavigateNode>> applyRuleFilters(List<List<NavigateNode>> allList,
			@@ -637,9 +1267,9 @@
			double congWeightFactor = globalPolicy == null ? 1.0d : globalPolicy.congWeightFactor;
			double passOtherOutStationPenaltyWeight = globalPolicy == null ? 0.0d : globalPolicy.passOtherOutStationPenaltyWeight;

			metrics.staticCost =
			safeDouble(profileConfig.getS1LenWeight(), 1.0d) * lenWeightFactor * metrics.pathLen
			+ safeDouble(profileConfig.getS1TurnWeight(), 3.0d) * metrics.turnCount
			metrics.baseLengthWeight = safeDouble(profileConfig.getS1LenWeight(), 1.0d) * lenWeightFactor;
			metrics.otherStaticCost =
			safeDouble(profileConfig.getS1TurnWeight(), 3.0d) * metrics.turnCount
			+ safeDouble(profileConfig.getS1LiftWeight(), 8.0d) * metrics.liftTransferCount
			+ passOtherOutStationPenaltyWeight * metrics.passOtherOutStationCount
			+ softDeviationWeight * metrics.softDeviationCount;
			@@ -672,22 +1302,120 @@
			return count;
			}

			private int compareReachabilityPath(List<NavigateNode> left, List<NavigateNode> right) {
			int leftLen = left == null ? Integer.MAX_VALUE : left.size();
			int rightLen = right == null ? Integer.MAX_VALUE : right.size();
			int leftTurnCount = countTurnCount(left);
			int rightTurnCount = countTurnCount(right);
			int leftLiftCount = countLiftTransferCount(left);
			int rightLiftCount = countLiftTransferCount(right);
			return compareDouble(leftLen, rightLen, leftTurnCount, rightTurnCount, leftLiftCount, rightLiftCount);
			}

			private void applyPathLengthPreference(List<PathCandidateMetrics> metricsList,
			StationPathProfileConfig profileConfig,
			PathGlobalPolicy globalPolicy,
			Double pathLenFactor) {
			if (metricsList == null \|\| metricsList.isEmpty()) {
			return;
			}
			double normalizedFactor = normalizePathLenFactor(pathLenFactor);
			int minPathLen = Integer.MAX_VALUE;
			int maxPathLen = Integer.MIN_VALUE;
			for (PathCandidateMetrics metrics : metricsList) {
			if (metrics == null) {
			continue;
			}
			minPathLen = Math.min(minPathLen, metrics.pathLen);
			maxPathLen = Math.max(maxPathLen, metrics.pathLen);
			}
			if (minPathLen == Integer.MAX_VALUE \|\| maxPathLen == Integer.MIN_VALUE) {
			return;
			}
			double targetPathLen = normalizedFactor <= 0.0d \|\| maxPathLen <= minPathLen
			? minPathLen
			: minPathLen + normalizedFactor * (maxPathLen - minPathLen);
			for (PathCandidateMetrics metrics : metricsList) {
			if (metrics == null) {
			continue;
			}
			metrics.pathLenPreferenceDistance = normalizedFactor <= 0.0d
			? metrics.pathLen
			: Math.abs(metrics.pathLen - targetPathLen);
			metrics.staticCost = metrics.baseLengthWeight * metrics.pathLenPreferenceDistance + metrics.otherStaticCost;
			}
			}

			private int compareStaticCandidateMetrics(PathCandidateMetrics left,
			PathCandidateMetrics right,
			Double pathLenFactor) {
			if (left == right) {
			return 0;
			}
			if (left == null) {
			return 1;
			}
			if (right == null) {
			return -1;
			}
			int result = Double.compare(left.staticCost, right.staticCost);
			if (result != 0) {
			return result;
			}
			result = Double.compare(left.pathLenPreferenceDistance, right.pathLenPreferenceDistance);
			if (result != 0) {
			return result;
			}
			result = Integer.compare(left.turnCount, right.turnCount);
			if (result != 0) {
			return result;
			}
			return comparePathLenTie(left.pathLen, right.pathLen, pathLenFactor);
			}

			private int compareDynamicCandidateMetrics(PathCandidateMetrics left,
			PathCandidateMetrics right,
			Double pathLenFactor) {
			if (left == right) {
			return 0;
			}
			if (left == null) {
			return 1;
			}
			if (right == null) {
			return -1;
			}
			int result = Double.compare(left.dynamicCost, right.dynamicCost);
			if (result != 0) {
			return result;
			}
			result = Double.compare(left.pathLenPreferenceDistance, right.pathLenPreferenceDistance);
			if (result != 0) {
			return result;
			}
			result = comparePathLenTie(left.pathLen, right.pathLen, pathLenFactor);
			if (result != 0) {
			return result;
			}
			return Integer.compare(left.turnCount, right.turnCount);
			}

			private int comparePathLenTie(int leftPathLen, int rightPathLen, Double pathLenFactor) {
			double normalizedFactor = normalizePathLenFactor(pathLenFactor);
			if (normalizedFactor <= 0.0d) {
			return Integer.compare(leftPathLen, rightPathLen);
			}
			if (normalizedFactor >= 0.5d) {
			return Integer.compare(rightPathLen, leftPathLen);
			}
			return Integer.compare(leftPathLen, rightPathLen);
			}

			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;
			@@ -922,6 +1650,95 @@
			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();
			}
			synchronized (runtimeSnapshotLock) {
			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();
			}
			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 {
			@@ -1047,12 +1864,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;
			}
			@@ -1064,9 +1882,7 @@
			continue;
			}
			graph.computeIfAbsent(stationId, key -> new LinkedHashSet<>());
			List<NavigateNode> nextNodeList = navigateSolution.extend_current_node(stationMap, node);
			for (NavigateNode nextNode : safeList(nextNodeList)) {
			Integer nextStationId = extractStationId(nextNode);
			for (Integer nextStationId : navigateSolution.getConnectedStationIds(navigateMapIndex, stationId, node)) {
			if (nextStationId == null \|\| stationId.equals(nextStationId)) {
			continue;
			}
			@@ -1078,6 +1894,23 @@
			}
			}
			return graph;
			}

			private Set<Integer> resolveConnectedStationIds(Integer currentStationId, NavigateNode nextNode) {
			Set<Integer> stationIdSet = new LinkedHashSet<>();
			if (nextNode == 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);
			}
			}
			return stationIdSet;
			}

			private List<Integer> loadStationLevList() {
			@@ -1101,6 +1934,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<>();
			@@ -1119,8 +1958,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());
			@@ -1196,42 +2038,7 @@
			StationTrafficSnapshot trafficSnapshot,
			LoopMergeGuardContext loopMergeGuardContext,
			Set<LoopMergeEntry> mandatoryLoopMergeEntrySet) {
			if (path == null \|\| path.size() < 2 \|\| loopMergeGuardContext == null \|\| loopMergeGuardContext.loopStationIdSet.isEmpty()) {
			return true;
			}

			List<Integer> stationIdList = extractStationIdList(path);
			if (stationIdList.size() < 2) {
			return true;
			}

			for (int i = 1; i < stationIdList.size(); i++) {
			Integer prevStationId = stationIdList.get(i - 1);
			Integer currentStationId = stationIdList.get(i);
			if (prevStationId == null \|\| currentStationId == null) {
			continue;
			}
			if (loopMergeGuardContext.loopStationIdSet.contains(prevStationId)
			\|\| !loopMergeGuardContext.loopStationIdSet.contains(currentStationId)) {
			continue;
			}

			Set<Integer> trunkNeighborSet = loopMergeGuardContext.loopNeighborMap.getOrDefault(currentStationId, Collections.emptySet());
			if (trunkNeighborSet.size() < 2) {
			continue;
			}

			LoopMergeEntry currentEntry = new LoopMergeEntry(prevStationId, currentStationId);
			for (Integer trunkNeighborStationId : trunkNeighborSet) {
			if (isStationOccupiedForLoopMerge(trunkNeighborStationId, statusMap, trafficSnapshot)) {
			return false;
			}
			}
			boolean mandatoryEntry = mandatoryLoopMergeEntrySet != null && mandatoryLoopMergeEntrySet.contains(currentEntry);
			if (!mandatoryEntry && !isLoopTrunkVeryIdle(currentStationId, loopMergeGuardContext, statusMap, trafficSnapshot)) {
			return false;
			}
			}
			// 环线并入保护已停用：允许候选路径直接参与后续评分。
			return true;
			}

			@@ -1330,17 +2137,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) {
			@@ -1351,7 +2164,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);
			}
			@@ -1366,6 +2183,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,
			@@ -1396,7 +2262,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>()
			@@ -1754,12 +2620,467 @@
			return value == null ? defaultValue : value;
			}

			private double normalizePathLenFactor(Double pathLenFactor) {
			if (pathLenFactor == null) {
			return 0.0d;
			}
			if (pathLenFactor < 0.0d) {
			return 0.0d;
			}
			if (pathLenFactor > 1.0d) {
			return 1.0d;
			}
			return pathLenFactor;
			}

			private boolean notBlank(String text) {
			return text != null && !text.trim().isEmpty();
			}

			private StationPathSearchContext buildStationPathSearchContext(Integer startStationId,
			Integer endStationId,
			StationPathResolvedPolicy resolvedPolicy,
			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));

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

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

			NavigateNode endNode = navigateSolution.findStationNavigateNode(navigateMapIndex, endStationId);
			if (endNode == null) {
			throw new CoolException("未找到该终点对应的节点");
			}
			stepCostMap.put("loadStationMapAndNode", elapsedMillis(stepStartNs));

			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={}",
			startStationId,
			endStationId,
			calcMode == null ? "" : calcMode.name());
			int calcMaxDepth = safeInt(profileConfig.getCalcMaxDepth(), 120);
			int calcMaxPaths = safeInt(profileConfig.getCalcMaxPaths(), 500);
			int calcMaxCost = safeInt(profileConfig.getCalcMaxCost(), 300);
			List<Integer> guideStationSequence = buildGuideStationSequence(startStationId, endStationId, resolvedPolicy.getRuleConfig());
			stepStartNs = System.nanoTime();
			List<List<NavigateNode>> allList = navigateSolution.allSimplePaths(
			stationMap,
			startNode,
			endNode,
			calcMaxDepth,
			calcMaxPaths,
			calcMaxCost,
			guideStationSequence
			);
			stepCostMap.put("allSimplePaths", elapsedMillis(stepStartNs));
			rawCandidateCount = allList.size();
			if (allList.isEmpty()) {
			logStationPathSearchContextSlow(startStationId, endStationId, calcMode, lev, rawCandidateCount, filteredCandidateCount, stepCostMap, totalStartNs);
			return StationPathSearchContext.empty(resolvedPolicy);
			}
			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();
			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={}",
			System.currentTimeMillis() - startTime,
			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) {
			List<List<NavigateNode>> result = new ArrayList<>();
			if (orderedPathList == null \|\| orderedPathList.isEmpty()) {
			return result;
			}
			Set<String> seenPathSignatures = new LinkedHashSet<>();
			for (List<NavigateNode> path : orderedPathList) {
			List<NavigateNode> normalizedPath = normalizeStationPath(path);
			String pathSignature = buildPathSignature(normalizedPath);
			if (pathSignature.isEmpty() \|\| !seenPathSignatures.add(pathSignature)) {
			continue;
			}
			result.add(normalizedPath);
			}
			return result;
			}

			private List<NavigateNode> normalizeStationPath(List<NavigateNode> path) {
			List<NavigateNode> filterList = new ArrayList<>();
			Integer lastStationId = null;
			for (NavigateNode navigateNode : safeList(path)) {
			if (navigateNode == null) {
			continue;
			}
			if (Boolean.TRUE.equals(navigateNode.getRgvCalcFlag())) {
			continue;
			}
			Integer stationId = extractStationId(navigateNode);
			if (stationId == null) {
			continue;
			}
			// 仅压缩连续重复站点，保留环线重算场景下后续再次经过的同一站点。
			if (lastStationId != null && lastStationId.equals(stationId)) {
			continue;
			}
			lastStationId = stationId;
			NavigateNode clonedNode = navigateNode.clone();
			if (clonedNode == null) {
			continue;
			}
			filterList.add(clonedNode);
			}

			for (int i = 0; i < filterList.size(); i++) {
			NavigateNode currentNode = filterList.get(i);
			currentNode.setIsInflectionPoint(false);
			currentNode.setIsLiftTransferPoint(false);
			if (Boolean.TRUE.equals(currentNode.getLiftTransfer())) {
			currentNode.setIsLiftTransferPoint(true);
			}

			NavigateNode nextNode = (i + 1 < filterList.size()) ? filterList.get(i + 1) : null;
			NavigateNode prevNode = (i - 1 >= 0) ? filterList.get(i - 1) : null;

			HashMap<String, Object> searchResult = searchInflectionPoint(currentNode, nextNode, prevNode);
			if (Boolean.parseBoolean(searchResult.get("result").toString())) {
			currentNode.setIsInflectionPoint(true);
			currentNode.setDirection(searchResult.get("direction").toString());
			}
			}
			return filterList;
			}

			private String buildPathSignature(List<NavigateNode> path) {
			List<Integer> stationIdList = extractStationIdList(path);
			if (stationIdList.isEmpty()) {
			return "";
			}
			StringBuilder builder = new StringBuilder();
			for (Integer stationId : stationIdList) {
			if (stationId == null) {
			continue;
			}
			if (builder.length() > 0) {
			builder.append("->");
			}
			builder.append(stationId);
			}
			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;
			}

			private static class StationPathSearchContext {
			private final List<List<NavigateNode>> allList;
			private final StationPathResolvedPolicy resolvedPolicy;

			private StationPathSearchContext(List<List<NavigateNode>> allList,
			StationPathResolvedPolicy resolvedPolicy) {
			this.allList = allList == null ? new ArrayList<>() : allList;
			this.resolvedPolicy = resolvedPolicy == null ? new StationPathResolvedPolicy() : resolvedPolicy;
			}

			private static StationPathSearchContext empty(StationPathResolvedPolicy resolvedPolicy) {
			return new StationPathSearchContext(new ArrayList<>(), resolvedPolicy);
			}
			}

			private static class DirectStationPathContext {
			private StationPathCalcMode calcMode;
			private Integer startStationId;
			private Integer endStationId;
			private NavigateSolution navigateSolution;
			private NavigateSolution.NavigateMapIndex navigateMapIndex;
			private List<List<NavigateNode>> stationMap;
			private NavigateNode startNode;
			private NavigateNode endNode;
			private StationPathResolvedPolicy resolvedPolicy;
			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();
			private LoopMergeGuardContext loopMergeGuardContext = new LoopMergeGuardContext();
			private Set<Integer> outStationIdSet = new HashSet<>();
			private Set<Integer> forbidStationIdSet = new HashSet<>();
			private Set<String> forbidEdgeSet = new HashSet<>();
			private Set<Integer> softReferenceStationSet = new HashSet<>();
			}

			private static class DirectPathState {
			private final NavigateNode node;
			private final DirectPathState parent;
			private final double gScore;
			private final double fScore;

			private DirectPathState(NavigateNode node,
			DirectPathState parent,
			double gScore,
			double fScore) {
			this.node = node;
			this.parent = parent;
			this.gScore = gScore;
			this.fScore = fScore;
			}
			}

			private static class DirectPathSearchResult {
			private final List<NavigateNode> path;
			private final boolean includeWaypoint;
			private final boolean includeSoftPreference;

			private DirectPathSearchResult(List<NavigateNode> path,
			boolean includeWaypoint,
			boolean includeSoftPreference) {
			this.path = path == null ? new ArrayList<>() : path;
			this.includeWaypoint = includeWaypoint;
			this.includeSoftPreference = includeSoftPreference;
			}

			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 PathCandidateMetrics {
			@@ -1775,6 +3096,9 @@
			private int runBlockCount;
			private int softDeviationCount;
			private double loopPenalty;
			private double baseLengthWeight;
			private double otherStaticCost;
			private double pathLenPreferenceDistance;
			private double staticCost;
			private double dynamicCost;
			}
			@@ -1919,7 +3243,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 {
			@@ -1927,7 +3257,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;
			}