From 9ed9cd2e6f619c84732ae6715699b160c404684c Mon Sep 17 00:00:00 2001
From: Junjie <fallin.jie@qq.com>
Date: 星期二, 24 三月 2026 12:42:19 +0800
Subject: [PATCH] #V5 beta

---
 src/main/java/com/zy/core/model/command/StationCommand.java                    |    3 
 src/main/java/com/zy/core/utils/StationOperateProcessUtils.java                |  154 ++++
 src/main/java/com/zy/core/move/StationMoveSession.java                         |   64 ++
 src/main/java/com/zy/core/thread/impl/v5/StationMoveSegmentExecutor.java       |   18 
 src/main/java/com/zy/core/thread/impl/ZyStationV4Thread.java                   |    5 
 src/main/java/com/zy/core/move/StationMoveTriggerType.java                     |    9 
 src/main/java/com/zy/core/thread/impl/station/StationSegmentExecutor.java      |  456 +++++++++++++++
 src/main/java/com/zy/core/move/StationMoveDispatchMode.java                    |    8 
 src/main/java/com/zy/core/move/StationMoveSessionRegistry.java                 |  243 ++++++++
 src/main/java/com/zy/core/move/StationMoveCoordinator.java                     |  357 ++++++++++++
 src/main/java/com/zy/core/thread/impl/station/StationSegmentExecutionPlan.java |   15 
 src/main/java/com/zy/core/thread/impl/station/StationSegmentPlanner.java       |   96 +++
 src/main/java/com/zy/core/enums/RedisKeyType.java                              |    1 
 src/main/java/com/zy/core/thread/impl/v5/StationV5SegmentExecutor.java         |  298 ----------
 14 files changed, 1,417 insertions(+), 310 deletions(-)

diff --git a/src/main/java/com/zy/core/enums/RedisKeyType.java b/src/main/java/com/zy/core/enums/RedisKeyType.java
index 3a60047..fef34ca 100644
--- a/src/main/java/com/zy/core/enums/RedisKeyType.java
+++ b/src/main/java/com/zy/core/enums/RedisKeyType.java
@@ -47,6 +47,7 @@
     STATION_RUN_BLOCK_TASK_LOOP_STATE_("station_run_block_task_loop_state_"),
     CHECK_STATION_IDLE_RECOVER_LIMIT_("check_station_idle_recover_limit_"),
     STATION_COMMAND_DISPATCH_DEDUP_("station_command_dispatch_dedup_"),
+    STATION_MOVE_SESSION_("station_move_session_"),
     CHECK_SHALLOW_LOC_STATUS_LIMIT("check_shallow_loc_status_limit_"),
     GENERATE_ENABLE_IN_STATION_DATA_LIMIT("generate_enable_in_station_data_limit_"),
     GENERATE_STATION_BACK_LIMIT("generate_station_back_limit_"),
diff --git a/src/main/java/com/zy/core/model/command/StationCommand.java b/src/main/java/com/zy/core/model/command/StationCommand.java
index 262abc8..32ef7aa 100644
--- a/src/main/java/com/zy/core/model/command/StationCommand.java
+++ b/src/main/java/com/zy/core/model/command/StationCommand.java
@@ -40,4 +40,7 @@
 
     private Integer traceVersion;
 
+    // 鍚屼竴 task 鐨� MOVE 璺敱鐗堟湰锛岀敤浜庢帶鍒堕噸涓嬪彂鍜屾棫璺緞澶辨晥
+    private Integer routeVersion;
+
 }
diff --git a/src/main/java/com/zy/core/move/StationMoveCoordinator.java b/src/main/java/com/zy/core/move/StationMoveCoordinator.java
new file mode 100644
index 0000000..1adc417
--- /dev/null
+++ b/src/main/java/com/zy/core/move/StationMoveCoordinator.java
@@ -0,0 +1,357 @@
+package com.zy.core.move;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.serializer.SerializerFeature;
+import com.zy.common.utils.RedisUtil;
+import com.zy.core.enums.RedisKeyType;
+import com.zy.core.model.command.StationCommand;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+@Component
+public class StationMoveCoordinator {
+
+    private static final int SESSION_EXPIRE_SECONDS = 60 * 60 * 24;
+
+    @Autowired
+    private StationMoveSessionRegistry sessionRegistry;
+    @Autowired
+    private RedisUtil redisUtil;
+
+    public StationMoveSession loadSession(Integer taskNo) {
+        if (sessionRegistry == null) {
+            return null;
+        }
+        return sessionRegistry.load(taskNo);
+    }
+
+    public boolean isActiveRoute(Integer taskNo, Integer routeVersion) {
+        return sessionRegistry != null && sessionRegistry.isActiveRoute(taskNo, routeVersion);
+    }
+
+    public void markSegmentIssued(Integer taskNo, Integer routeVersion) {
+        if (sessionRegistry != null) {
+            sessionRegistry.markSegmentIssued(taskNo, routeVersion);
+        }
+    }
+
+    public void updateCurrentStation(Integer taskNo, Integer routeVersion, Integer currentStationId) {
+        if (sessionRegistry != null) {
+            sessionRegistry.updateCurrentStation(taskNo, routeVersion, currentStationId);
+        }
+    }
+
+    public void markCancelled(Integer taskNo, Integer routeVersion, Integer currentStationId, String cancelReason) {
+        updateTerminal(taskNo, routeVersion, currentStationId, StationMoveSession.STATUS_CANCELLED, cancelReason);
+    }
+
+    public void markBlocked(Integer taskNo, Integer routeVersion, Integer currentStationId) {
+        updateTerminal(taskNo, routeVersion, currentStationId, StationMoveSession.STATUS_BLOCKED, null);
+    }
+
+    public void markTimeout(Integer taskNo, Integer routeVersion, Integer currentStationId) {
+        updateTerminal(taskNo, routeVersion, currentStationId, StationMoveSession.STATUS_TIMEOUT, null);
+    }
+
+    public void markFinished(Integer taskNo, Integer routeVersion, Integer currentStationId) {
+        updateTerminal(taskNo, routeVersion, currentStationId, StationMoveSession.STATUS_FINISHED, null);
+    }
+
+    public void markCancelPending(Integer taskNo, String cancelReason) {
+        StationMoveSession session = loadSession(taskNo);
+        if (session == null || !session.isActive()) {
+            return;
+        }
+        session.setStatus(StationMoveSession.STATUS_CANCEL_PENDING);
+        session.setCancelReason(cancelReason);
+        saveSession(session);
+    }
+
+    public boolean shouldSuppressDispatch(Integer taskNo, Integer currentStationId, StationCommand candidateCommand) {
+        if (taskNo == null || taskNo <= 0 || currentStationId == null || candidateCommand == null) {
+            return false;
+        }
+
+        StationMoveSession session = loadSession(taskNo);
+        if (session == null || !session.isActive()) {
+            return false;
+        }
+
+        String candidateSignature = buildPathSignature(candidateCommand);
+        if (!isBlank(candidateSignature) && Objects.equals(candidateSignature, session.getPathSignature())) {
+            return true;
+        }
+
+        if (Objects.equals(currentStationId, session.getNextDecisionStationId())) {
+            return false;
+        }
+
+        return session.containsStation(currentStationId);
+    }
+
+    public StationMoveSession recordDispatch(Integer taskNo,
+                                             Integer dispatchStationId,
+                                             String triggerName,
+                                             StationCommand command,
+                                             boolean circleRoute) {
+        if (taskNo == null || taskNo <= 0 || command == null) {
+            return null;
+        }
+
+        StationMoveSession current = loadSession(taskNo);
+        long now = System.currentTimeMillis();
+        String pathSignature = buildPathSignature(command);
+        List<Integer> fullPathStationIds = resolveFullPathStationIds(command);
+        boolean reuseCurrent = current != null
+                && current.isActive()
+                && Objects.equals(current.getDispatchStationId(), dispatchStationId)
+                && Objects.equals(current.getNextDecisionStationId(), command.getTargetStaNo())
+                && Objects.equals(current.getPathSignature(), pathSignature);
+
+        StationMoveSession session = reuseCurrent ? current : new StationMoveSession();
+        if (!reuseCurrent) {
+            session.setRouteVersion(current == null || current.getRouteVersion() == null
+                    ? 1
+                    : current.getRouteVersion() + 1);
+            session.setCreatedAt(now);
+        } else if (session.getRouteVersion() == null) {
+            session.setRouteVersion(1);
+        }
+
+        session.setTaskNo(taskNo);
+        session.setThreadImpl(resolveThreadImpl(triggerName));
+        session.setCurrentStationId(dispatchStationId);
+        session.setBusinessTargetStationId(command.getTargetStaNo());
+        session.setCurrentRouteTargetStationId(command.getTargetStaNo());
+        session.setTriggerType(resolveTriggerType(triggerName, circleRoute));
+        session.setDispatchMode(resolveDispatchMode(triggerName, circleRoute));
+        session.setStatus(StationMoveSession.STATUS_RUNNING);
+        session.setDispatchStationId(dispatchStationId);
+        session.setNextDecisionStationId(command.getTargetStaNo());
+        session.setFullPathStationIds(fullPathStationIds);
+        session.setPathSignature(pathSignature);
+        session.setCancelReason(null);
+        session.setUpdatedAt(now);
+        session.setLastIssuedAt(now);
+
+        command.setRouteVersion(session.getRouteVersion());
+        saveSession(session);
+
+        if (circleRoute) {
+            saveLegacyCircleCommand(taskNo, command);
+        } else {
+            clearLegacyCircleCommand(taskNo);
+        }
+
+        return session;
+    }
+
+    public StationMoveSession cancelSession(Integer taskNo) {
+        StationMoveSession session = loadSession(taskNo);
+        if (session == null) {
+            clearLegacyCircleCommand(taskNo);
+            return null;
+        }
+        session.setStatus(StationMoveSession.STATUS_CANCELLED);
+        session.setCancelReason("reroute_cancelled");
+        saveSession(session);
+        clearLegacyCircleCommand(taskNo);
+        return session;
+    }
+
+    public StationMoveSession finishSession(Integer taskNo) {
+        StationMoveSession session = loadSession(taskNo);
+        if (session == null) {
+            clearLegacyCircleCommand(taskNo);
+            return null;
+        }
+        session.setStatus(StationMoveSession.STATUS_FINISHED);
+        saveSession(session);
+        clearLegacyCircleCommand(taskNo);
+        return session;
+    }
+
+    public String buildPathSignature(StationCommand command) {
+        if (command == null) {
+            return "";
+        }
+        Map<String, Object> signature = new LinkedHashMap<>();
+        signature.put("commandType", command.getCommandType() == null ? null : command.getCommandType().name());
+        signature.put("stationId", command.getStationId());
+        signature.put("targetStaNo", command.getTargetStaNo());
+        signature.put("navigatePath", copyIntegerList(command.getNavigatePath()));
+        signature.put("liftTransferPath", copyIntegerList(command.getLiftTransferPath()));
+        signature.put("originalNavigatePath", copyIntegerList(command.getOriginalNavigatePath()));
+        return JSON.toJSONString(signature, SerializerFeature.DisableCircularReferenceDetect);
+    }
+
+    public String buildPathSignatureHash(StationCommand command) {
+        String signature = buildPathSignature(command);
+        if (isBlank(signature)) {
+            return "";
+        }
+        return digest(signature);
+    }
+
+    private void updateTerminal(Integer taskNo,
+                                Integer routeVersion,
+                                Integer currentStationId,
+                                String status,
+                                String cancelReason) {
+        if (sessionRegistry == null) {
+            return;
+        }
+        StationMoveSession session = sessionRegistry.load(taskNo);
+        if (session == null || !Objects.equals(session.getRouteVersion(), routeVersion)) {
+            return;
+        }
+        session.setCurrentStationId(currentStationId);
+        session.setStatus(status);
+        session.setCancelReason(cancelReason);
+        saveSession(session);
+        if (StationMoveSession.STATUS_CANCELLED.equals(status)
+                || StationMoveSession.STATUS_BLOCKED.equals(status)
+                || StationMoveSession.STATUS_TIMEOUT.equals(status)
+                || StationMoveSession.STATUS_FINISHED.equals(status)) {
+            clearLegacyCircleCommand(taskNo);
+        }
+    }
+
+    private void saveSession(StationMoveSession session) {
+        if (sessionRegistry != null) {
+            sessionRegistry.save(session);
+        }
+    }
+
+    private void saveLegacyCircleCommand(Integer taskNo, StationCommand command) {
+        if (redisUtil == null || taskNo == null || taskNo <= 0 || command == null) {
+            return;
+        }
+        redisUtil.set(RedisKeyType.WATCH_CIRCLE_STATION_.key + taskNo,
+                JSON.toJSONString(command, SerializerFeature.DisableCircularReferenceDetect),
+                SESSION_EXPIRE_SECONDS);
+    }
+
+    private void clearLegacyCircleCommand(Integer taskNo) {
+        if (redisUtil == null || taskNo == null || taskNo <= 0) {
+            return;
+        }
+        redisUtil.del(RedisKeyType.WATCH_CIRCLE_STATION_.key + taskNo);
+    }
+
+    private List<Integer> resolveFullPathStationIds(StationCommand command) {
+        if (command == null) {
+            return new ArrayList<>();
+        }
+        List<Integer> source = command.getOriginalNavigatePath();
+        if (source == null || source.isEmpty()) {
+            source = command.getNavigatePath();
+        }
+        if (source != null && !source.isEmpty()) {
+            return new ArrayList<>(source);
+        }
+        List<Integer> path = new ArrayList<>();
+        if (command.getStationId() != null) {
+            path.add(command.getStationId());
+        }
+        if (command.getTargetStaNo() != null && !Objects.equals(command.getTargetStaNo(), command.getStationId())) {
+            path.add(command.getTargetStaNo());
+        }
+        return path;
+    }
+
+    private List<Integer> copyIntegerList(List<Integer> source) {
+        if (source == null || source.isEmpty()) {
+            return Collections.emptyList();
+        }
+        return new ArrayList<>(source);
+    }
+
+    private String resolveThreadImpl(String triggerName) {
+        if (triggerName == null) {
+            return null;
+        }
+        if (triggerName.contains("crn")) {
+            return "crn";
+        }
+        if (triggerName.contains("watchCircle")) {
+            return "station";
+        }
+        if (triggerName.contains("checkStationRunBlock")) {
+            return "station";
+        }
+        if (triggerName.contains("checkStationIdleRecover")) {
+            return "station";
+        }
+        if (triggerName.contains("checkStationOutOrder")) {
+            return "station";
+        }
+        return triggerName;
+    }
+
+    private StationMoveTriggerType resolveTriggerType(String triggerName, boolean circleRoute) {
+        if (circleRoute) {
+            return StationMoveTriggerType.WATCH_CIRCLE;
+        }
+        if (triggerName == null) {
+            return StationMoveTriggerType.INITIAL_OUTBOUND;
+        }
+        if (triggerName.contains("checkStationOutOrder")) {
+            return StationMoveTriggerType.OUT_ORDER;
+        }
+        if (triggerName.contains("watchCircle")) {
+            return StationMoveTriggerType.WATCH_CIRCLE;
+        }
+        if (triggerName.contains("checkStationRunBlock")) {
+            return StationMoveTriggerType.RUN_BLOCK;
+        }
+        if (triggerName.contains("checkStationIdleRecover")) {
+            return StationMoveTriggerType.IDLE_RECOVER;
+        }
+        return StationMoveTriggerType.INITIAL_OUTBOUND;
+    }
+
+    private StationMoveDispatchMode resolveDispatchMode(String triggerName, boolean circleRoute) {
+        if (circleRoute) {
+            return StationMoveDispatchMode.CIRCLE;
+        }
+        if (triggerName != null && triggerName.contains("checkStationRunBlock")) {
+            return StationMoveDispatchMode.RUN_BLOCK_REROUTE;
+        }
+        if (triggerName != null && triggerName.contains("checkStationIdleRecover")) {
+            return StationMoveDispatchMode.IDLE_RECOVER_REROUTE;
+        }
+        return StationMoveDispatchMode.DIRECT;
+    }
+
+    private boolean isBlank(String value) {
+        return value == null || value.trim().isEmpty();
+    }
+
+    private String digest(String value) {
+        try {
+            MessageDigest digest = MessageDigest.getInstance("SHA-256");
+            byte[] bytes = digest.digest(value.getBytes(StandardCharsets.UTF_8));
+            StringBuilder builder = new StringBuilder(bytes.length * 2);
+            for (byte b : bytes) {
+                String hex = Integer.toHexString(b & 0xff);
+                if (hex.length() == 1) {
+                    builder.append('0');
+                }
+                builder.append(hex);
+            }
+            return builder.toString();
+        } catch (Exception ignore) {
+            return Integer.toHexString(value.hashCode());
+        }
+    }
+}
diff --git a/src/main/java/com/zy/core/move/StationMoveDispatchMode.java b/src/main/java/com/zy/core/move/StationMoveDispatchMode.java
new file mode 100644
index 0000000..6fce095
--- /dev/null
+++ b/src/main/java/com/zy/core/move/StationMoveDispatchMode.java
@@ -0,0 +1,8 @@
+package com.zy.core.move;
+
+public enum StationMoveDispatchMode {
+    DIRECT,
+    CIRCLE,
+    RUN_BLOCK_REROUTE,
+    IDLE_RECOVER_REROUTE
+}
diff --git a/src/main/java/com/zy/core/move/StationMoveSession.java b/src/main/java/com/zy/core/move/StationMoveSession.java
new file mode 100644
index 0000000..fbd953a
--- /dev/null
+++ b/src/main/java/com/zy/core/move/StationMoveSession.java
@@ -0,0 +1,64 @@
+package com.zy.core.move;
+
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+public class StationMoveSession {
+
+    public static final String STATUS_WAITING = "WAITING";
+    public static final String STATUS_RUNNING = "RUNNING";
+    public static final String STATUS_CANCEL_PENDING = "CANCEL_PENDING";
+    public static final String STATUS_CANCELLED = "CANCELLED";
+    public static final String STATUS_BLOCKED = "BLOCKED";
+    public static final String STATUS_TIMEOUT = "TIMEOUT";
+    public static final String STATUS_FINISHED = "FINISHED";
+
+    private Integer taskNo;
+
+    private Integer routeVersion;
+
+    private String threadImpl;
+
+    private Integer currentStationId;
+
+    private StationMoveTriggerType triggerType;
+
+    private StationMoveDispatchMode dispatchMode;
+
+    private String status;
+
+    private Integer dispatchStationId;
+
+    private Integer businessTargetStationId;
+
+    private Integer currentRouteTargetStationId;
+
+    private Integer nextDecisionStationId;
+
+    private List<Integer> fullPathStationIds = new ArrayList<>();
+
+    private String pathSignature;
+
+    private String cancelReason;
+
+    private Long createdAt;
+
+    private Long updatedAt;
+
+    private Long lastIssuedAt;
+
+    public boolean isActive() {
+        return STATUS_WAITING.equals(status)
+                || STATUS_RUNNING.equals(status)
+                || STATUS_CANCEL_PENDING.equals(status);
+    }
+
+    public boolean containsStation(Integer stationId) {
+        return stationId != null
+                && fullPathStationIds != null
+                && fullPathStationIds.contains(stationId);
+    }
+}
diff --git a/src/main/java/com/zy/core/move/StationMoveSessionRegistry.java b/src/main/java/com/zy/core/move/StationMoveSessionRegistry.java
new file mode 100644
index 0000000..82bdad5
--- /dev/null
+++ b/src/main/java/com/zy/core/move/StationMoveSessionRegistry.java
@@ -0,0 +1,243 @@
+package com.zy.core.move;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.serializer.SerializerFeature;
+import com.zy.common.utils.RedisUtil;
+import com.zy.core.enums.RedisKeyType;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+@Component
+public class StationMoveSessionRegistry {
+
+    private static final int SESSION_EXPIRE_SECONDS = 60 * 60 * 24;
+
+    @Autowired
+    private RedisUtil redisUtil;
+
+    public synchronized StationMoveSession load(Integer taskNo) {
+        if (taskNo == null || taskNo <= 0 || redisUtil == null) {
+            return null;
+        }
+        Object sessionObj = redisUtil.get(buildKey(taskNo));
+        if (sessionObj == null) {
+            return null;
+        }
+        try {
+            return JSON.parseObject(String.valueOf(sessionObj), StationMoveSession.class);
+        } catch (Exception ignore) {
+            return null;
+        }
+    }
+
+    public synchronized void save(StationMoveSession session) {
+        if (session == null || session.getTaskNo() == null || session.getTaskNo() <= 0 || redisUtil == null) {
+            return;
+        }
+        long now = System.currentTimeMillis();
+        if (session.getCreatedAt() == null || session.getCreatedAt() <= 0L) {
+            session.setCreatedAt(now);
+        }
+        session.setUpdatedAt(now);
+        redisUtil.set(buildKey(session.getTaskNo()),
+                JSON.toJSONString(session, SerializerFeature.DisableCircularReferenceDetect),
+                SESSION_EXPIRE_SECONDS);
+    }
+
+    public synchronized void delete(Integer taskNo) {
+        if (taskNo == null || taskNo <= 0 || redisUtil == null) {
+            return;
+        }
+        redisUtil.del(buildKey(taskNo));
+    }
+
+    public synchronized boolean isActiveRoute(Integer taskNo, Integer routeVersion) {
+        StationMoveSession session = load(taskNo);
+        return session != null
+                && session.isActive()
+                && routeVersion != null
+                && Objects.equals(routeVersion, session.getRouteVersion());
+    }
+
+    public synchronized boolean shouldSkipOutOrderDecision(Integer taskNo, Integer currentStationId) {
+        StationMoveSession session = load(taskNo);
+        if (session == null || !session.isActive() || currentStationId == null) {
+            return false;
+        }
+        List<Integer> fullPathStationIds = session.getFullPathStationIds();
+        if (fullPathStationIds == null || !fullPathStationIds.contains(currentStationId)) {
+            return false;
+        }
+        if (StationMoveDispatchMode.CIRCLE == session.getDispatchMode()) {
+            return true;
+        }
+        return !Objects.equals(currentStationId, session.getCurrentRouteTargetStationId());
+    }
+
+    public synchronized boolean isCircleDecisionStation(Integer taskNo, Integer currentStationId) {
+        StationMoveSession session = load(taskNo);
+        return session != null
+                && session.isActive()
+                && StationMoveDispatchMode.CIRCLE == session.getDispatchMode()
+                && currentStationId != null
+                && Objects.equals(currentStationId, session.getNextDecisionStationId());
+    }
+
+    public synchronized boolean isCircleTransitStation(Integer taskNo, Integer currentStationId) {
+        StationMoveSession session = load(taskNo);
+        if (session == null
+                || !session.isActive()
+                || StationMoveDispatchMode.CIRCLE != session.getDispatchMode()
+                || currentStationId == null
+                || Objects.equals(currentStationId, session.getNextDecisionStationId())) {
+            return false;
+        }
+        List<Integer> fullPathStationIds = session.getFullPathStationIds();
+        return fullPathStationIds != null && fullPathStationIds.contains(currentStationId);
+    }
+
+    public synchronized StationMoveSession registerPlan(Integer taskNo,
+                                                        String threadImpl,
+                                                        Integer currentStationId,
+                                                        Integer businessTargetStationId,
+                                                        StationMoveTriggerType triggerType,
+                                                        StationMoveDispatchMode dispatchMode,
+                                                        Integer currentRouteTargetStationId,
+                                                        Integer nextDecisionStationId,
+                                                        List<Integer> fullPathStationIds,
+                                                        boolean cancelActive,
+                                                        String cancelReason) {
+        if (taskNo == null || taskNo <= 0) {
+            return null;
+        }
+        StationMoveSession current = load(taskNo);
+        StationMoveSession next = new StationMoveSession();
+        next.setTaskNo(taskNo);
+        next.setThreadImpl(threadImpl);
+        next.setRouteVersion(current == null || current.getRouteVersion() == null ? 1 : current.getRouteVersion() + 1);
+        next.setCurrentStationId(currentStationId);
+        next.setBusinessTargetStationId(businessTargetStationId);
+        next.setTriggerType(triggerType);
+        next.setDispatchMode(dispatchMode);
+        next.setCurrentRouteTargetStationId(currentRouteTargetStationId);
+        next.setNextDecisionStationId(nextDecisionStationId);
+        next.setStatus(StationMoveSession.STATUS_WAITING);
+        next.setCancelReason(cancelReason);
+        next.setFullPathStationIds(copyIntegerList(fullPathStationIds));
+        next.setPathSignature(buildPathSignature(fullPathStationIds));
+        save(next);
+        return next;
+    }
+
+    public synchronized boolean isSameActivePath(Integer taskNo, List<Integer> fullPathStationIds) {
+        StationMoveSession session = load(taskNo);
+        if (session == null || !session.isActive()) {
+            return false;
+        }
+        return Objects.equals(session.getPathSignature(), buildPathSignature(fullPathStationIds));
+    }
+
+    public synchronized void markSegmentIssued(Integer taskNo, Integer routeVersion) {
+        StationMoveSession session = load(taskNo);
+        if (session == null || !Objects.equals(session.getRouteVersion(), routeVersion)) {
+            return;
+        }
+        session.setStatus(StationMoveSession.STATUS_RUNNING);
+        session.setLastIssuedAt(System.currentTimeMillis());
+        save(session);
+    }
+
+    public synchronized void updateCurrentStation(Integer taskNo, Integer routeVersion, Integer currentStationId) {
+        StationMoveSession session = load(taskNo);
+        if (session == null || !Objects.equals(session.getRouteVersion(), routeVersion)) {
+            return;
+        }
+        session.setCurrentStationId(currentStationId);
+        if (!StationMoveSession.STATUS_CANCEL_PENDING.equals(session.getStatus())) {
+            session.setStatus(StationMoveSession.STATUS_RUNNING);
+        }
+        save(session);
+    }
+
+    public synchronized void markCancelPending(Integer taskNo, String cancelReason) {
+        StationMoveSession session = load(taskNo);
+        if (session == null || !session.isActive()) {
+            return;
+        }
+        session.setStatus(StationMoveSession.STATUS_CANCEL_PENDING);
+        session.setCancelReason(cancelReason);
+        save(session);
+    }
+
+    public synchronized void markCancelled(Integer taskNo, Integer routeVersion, Integer currentStationId, String cancelReason) {
+        updateTerminal(taskNo, routeVersion, currentStationId, StationMoveSession.STATUS_CANCELLED, cancelReason);
+    }
+
+    public synchronized void markBlocked(Integer taskNo, Integer routeVersion, Integer currentStationId) {
+        updateTerminal(taskNo, routeVersion, currentStationId, StationMoveSession.STATUS_BLOCKED, null);
+    }
+
+    public synchronized void markTimeout(Integer taskNo, Integer routeVersion, Integer currentStationId) {
+        updateTerminal(taskNo, routeVersion, currentStationId, StationMoveSession.STATUS_TIMEOUT, null);
+    }
+
+    public synchronized void markFinished(Integer taskNo, Integer routeVersion, Integer currentStationId) {
+        updateTerminal(taskNo, routeVersion, currentStationId, StationMoveSession.STATUS_FINISHED, null);
+    }
+
+    public synchronized StationMoveSession buildCircleSessionCommandSource(Integer taskNo) {
+        StationMoveSession session = load(taskNo);
+        if (session == null || !session.isActive() || StationMoveDispatchMode.CIRCLE != session.getDispatchMode()) {
+            return null;
+        }
+        return session;
+    }
+
+    private void updateTerminal(Integer taskNo,
+                                Integer routeVersion,
+                                Integer currentStationId,
+                                String status,
+                                String cancelReason) {
+        StationMoveSession session = load(taskNo);
+        if (session == null || !Objects.equals(session.getRouteVersion(), routeVersion)) {
+            return;
+        }
+        session.setCurrentStationId(currentStationId);
+        session.setStatus(status);
+        session.setCancelReason(cancelReason);
+        save(session);
+    }
+
+    private String buildKey(Integer taskNo) {
+        return RedisKeyType.STATION_MOVE_SESSION_.key + taskNo;
+    }
+
+    private String buildPathSignature(List<Integer> fullPathStationIds) {
+        if (fullPathStationIds == null || fullPathStationIds.isEmpty()) {
+            return "";
+        }
+        StringBuilder builder = new StringBuilder();
+        for (Integer stationId : fullPathStationIds) {
+            if (stationId == null) {
+                continue;
+            }
+            if (builder.length() > 0) {
+                builder.append("->");
+            }
+            builder.append(stationId);
+        }
+        return builder.toString();
+    }
+
+    private List<Integer> copyIntegerList(List<Integer> source) {
+        List<Integer> result = new ArrayList<>();
+        if (source != null) {
+            result.addAll(source);
+        }
+        return result;
+    }
+}
diff --git a/src/main/java/com/zy/core/move/StationMoveTriggerType.java b/src/main/java/com/zy/core/move/StationMoveTriggerType.java
new file mode 100644
index 0000000..afcd2a3
--- /dev/null
+++ b/src/main/java/com/zy/core/move/StationMoveTriggerType.java
@@ -0,0 +1,9 @@
+package com.zy.core.move;
+
+public enum StationMoveTriggerType {
+    INITIAL_OUTBOUND,
+    OUT_ORDER,
+    WATCH_CIRCLE,
+    RUN_BLOCK,
+    IDLE_RECOVER
+}
diff --git a/src/main/java/com/zy/core/thread/impl/ZyStationV4Thread.java b/src/main/java/com/zy/core/thread/impl/ZyStationV4Thread.java
index 1a8a4b7..d8ec936 100644
--- a/src/main/java/com/zy/core/thread/impl/ZyStationV4Thread.java
+++ b/src/main/java/com/zy/core/thread/impl/ZyStationV4Thread.java
@@ -30,6 +30,7 @@
 import com.zy.core.network.DeviceConnectPool;
 import com.zy.core.network.ZyStationConnectDriver;
 import com.zy.core.network.entity.ZyStationStatusEntity;
+import com.zy.core.thread.impl.v5.StationMoveSegmentExecutor;
 import com.zy.core.utils.DeviceLogRedisKeyBuilder;
 import com.zy.system.entity.Config;
 import com.zy.system.service.ConfigService;
@@ -51,6 +52,7 @@
     private DeviceConfig deviceConfig;
     private RedisUtil redisUtil;
     private ZyStationConnectDriver zyStationConnectDriver;
+    private StationMoveSegmentExecutor segmentExecutor;
     private int deviceLogCollectTime = 200;
     private boolean initStatus = false;
     private long deviceDataLogTime = System.currentTimeMillis();
@@ -59,6 +61,7 @@
     public ZyStationV4Thread(DeviceConfig deviceConfig, RedisUtil redisUtil) {
         this.deviceConfig = deviceConfig;
         this.redisUtil = redisUtil;
+        this.segmentExecutor = new StationMoveSegmentExecutor(deviceConfig, redisUtil, this::sendCommand);
     }
 
     @Override
@@ -92,7 +95,7 @@
                     }
                     if (step == 2) {
                         StationCommand cmd = (StationCommand) task.getData();
-                        executor.submit(() -> executeMoveWithSeg(cmd));
+                        executor.submit(() -> segmentExecutor.execute(cmd));
                     }
                     Thread.sleep(100);
                 } catch (Exception e) {
diff --git a/src/main/java/com/zy/core/thread/impl/station/StationSegmentExecutionPlan.java b/src/main/java/com/zy/core/thread/impl/station/StationSegmentExecutionPlan.java
new file mode 100644
index 0000000..59f3f12
--- /dev/null
+++ b/src/main/java/com/zy/core/thread/impl/station/StationSegmentExecutionPlan.java
@@ -0,0 +1,15 @@
+package com.zy.core.thread.impl.station;
+
+import com.zy.core.model.command.StationCommand;
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+public class StationSegmentExecutionPlan {
+
+    private List<Integer> fullPathStationIds = new ArrayList<>();
+
+    private List<StationCommand> segmentCommands = new ArrayList<>();
+}
diff --git a/src/main/java/com/zy/core/thread/impl/station/StationSegmentExecutor.java b/src/main/java/com/zy/core/thread/impl/station/StationSegmentExecutor.java
new file mode 100644
index 0000000..3da25e3
--- /dev/null
+++ b/src/main/java/com/zy/core/thread/impl/station/StationSegmentExecutor.java
@@ -0,0 +1,456 @@
+package com.zy.core.thread.impl.station;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.core.common.Cools;
+import com.core.common.SpringUtils;
+import com.zy.asrs.domain.vo.StationTaskTraceSegmentVo;
+import com.zy.asrs.entity.DeviceConfig;
+import com.zy.common.utils.RedisUtil;
+import com.zy.core.cache.SlaveConnection;
+import com.zy.core.enums.RedisKeyType;
+import com.zy.core.enums.SlaveType;
+import com.zy.core.enums.StationCommandType;
+import com.zy.core.model.CommandResponse;
+import com.zy.core.model.command.StationCommand;
+import com.zy.core.model.protocol.StationProtocol;
+import com.zy.core.move.StationMoveCoordinator;
+import com.zy.core.trace.StationTaskTraceRegistry;
+import com.zy.system.entity.Config;
+import com.zy.system.service.ConfigService;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+public class StationSegmentExecutor {
+
+    private static final String CFG_STATION_COMMAND_SEGMENT_ADVANCE_RATIO = "stationCommandSegmentAdvanceRatio";
+    private static final double DEFAULT_STATION_COMMAND_SEGMENT_ADVANCE_RATIO = 0.3d;
+    private static final long CURRENT_STATION_TIMEOUT_MS = 1000L * 60L;
+
+    private final DeviceConfig deviceConfig;
+    private final RedisUtil redisUtil;
+    private final Function<StationCommand, CommandResponse> commandSender;
+    private final StationSegmentPlanner segmentPlanner = new StationSegmentPlanner();
+
+    public StationSegmentExecutor(DeviceConfig deviceConfig,
+                                  RedisUtil redisUtil,
+                                  Function<StationCommand, CommandResponse> commandSender) {
+        this.deviceConfig = deviceConfig;
+        this.redisUtil = redisUtil;
+        this.commandSender = commandSender;
+    }
+
+    public void execute(StationCommand original) {
+        if (original == null) {
+            return;
+        }
+        if (original.getCommandType() != StationCommandType.MOVE) {
+            commandSender.apply(original);
+            return;
+        }
+
+        StationSegmentExecutionPlan localPlan = segmentPlanner.buildPlan(original);
+        if (localPlan.getSegmentCommands().isEmpty()) {
+            return;
+        }
+
+        StationTaskTraceRegistry traceRegistry = SpringUtils.getBean(StationTaskTraceRegistry.class);
+        StationTaskTraceRegistry.TraceRegistration traceRegistration = traceRegistry == null
+                ? new StationTaskTraceRegistry.TraceRegistration()
+                : traceRegistry.registerPlan(original.getTaskNo(), deviceConfig.getThreadImpl(),
+                original.getStationId(), original.getStationId(), original.getTargetStaNo(),
+                localPlan.getFullPathStationIds(), buildTraceSegments(localPlan.getSegmentCommands()));
+        int traceVersion = traceRegistration.getTraceVersion() == null ? 1 : traceRegistration.getTraceVersion();
+        int pathOffset = traceRegistration.getPathOffset() == null ? 0 : traceRegistration.getPathOffset();
+        bindCommands(localPlan.getSegmentCommands(), traceVersion, pathOffset, original.getRouteVersion());
+        List<Integer> effectiveFullPath = traceRegistration.getFullPathStationIds() == null
+                || traceRegistration.getFullPathStationIds().isEmpty()
+                ? copyIntegerList(localPlan.getFullPathStationIds())
+                : copyIntegerList(traceRegistration.getFullPathStationIds());
+
+        StationCommand firstCommand = localPlan.getSegmentCommands().get(0);
+        if (!sendSegmentWithRetry(firstCommand, traceRegistry, traceVersion, null)) {
+            return;
+        }
+        if (traceRegistry != null) {
+            traceRegistry.markSegmentIssued(original.getTaskNo(), traceVersion, firstCommand,
+                    "FIRST_SEGMENT_SENT", "杈撻�佷换鍔￠娈典笅鍙戞垚鍔�", buildSegmentDetails(firstCommand));
+        }
+
+        long lastSeenAt = System.currentTimeMillis();
+        int segCursor = 0;
+        Integer lastCurrentStationId = null;
+        boolean firstRun = true;
+        while (true) {
+            try {
+                if (!isRouteActive(original.getTaskNo(), original.getRouteVersion())) {
+                    if (traceRegistry != null) {
+                        traceRegistry.markCancelled(original.getTaskNo(), traceVersion, lastCurrentStationId,
+                                buildDetails("reason", "route_version_replaced", "routeVersion", original.getRouteVersion()));
+                    }
+                    markCancelled(original.getTaskNo(), original.getRouteVersion(), lastCurrentStationId, "route_version_replaced");
+                    break;
+                }
+
+                Object cancel = redisUtil.get(RedisKeyType.DEVICE_STATION_MOVE_RESET.key + original.getTaskNo());
+                if (cancel != null) {
+                    if (traceRegistry != null) {
+                        traceRegistry.markCancelled(original.getTaskNo(), traceVersion, lastCurrentStationId,
+                                buildDetails("reason", "redis_cancel_signal", "routeVersion", original.getRouteVersion()));
+                    }
+                    markCancelled(original.getTaskNo(), original.getRouteVersion(), lastCurrentStationId, "redis_cancel_signal");
+                    break;
+                }
+
+                StationProtocol currentStation = findCurrentStationByTask(original.getTaskNo());
+                if (currentStation == null) {
+                    if (System.currentTimeMillis() - lastSeenAt > CURRENT_STATION_TIMEOUT_MS) {
+                        if (traceRegistry != null) {
+                            traceRegistry.markTimeout(original.getTaskNo(), traceVersion, lastCurrentStationId,
+                                    buildDetails("timeoutMs", CURRENT_STATION_TIMEOUT_MS, "routeVersion", original.getRouteVersion()));
+                        }
+                        markTimeout(original.getTaskNo(), original.getRouteVersion(), lastCurrentStationId);
+                        break;
+                    }
+                    Thread.sleep(500L);
+                    continue;
+                }
+
+                lastSeenAt = System.currentTimeMillis();
+                Integer previousCurrentStationId = lastCurrentStationId;
+                updateCurrentStation(original.getTaskNo(), original.getRouteVersion(), currentStation.getStationId());
+                if (traceRegistry != null) {
+                    traceRegistry.updateProgress(original.getTaskNo(), traceVersion, currentStation.getStationId(),
+                            equalsInteger(previousCurrentStationId, currentStation.getStationId()) ? null : "CURRENT_STATION_CHANGE",
+                            "杈撻�佷换鍔″綋鍓嶄綅缃凡鏇存柊",
+                            buildDetails("stationId", currentStation.getStationId(), "routeVersion", original.getRouteVersion()));
+                }
+                lastCurrentStationId = currentStation.getStationId();
+                if (!firstRun && currentStation.isRunBlock()) {
+                    if (traceRegistry != null) {
+                        traceRegistry.markBlocked(original.getTaskNo(), traceVersion, currentStation.getStationId(),
+                                buildDetails("blockedStationId", currentStation.getStationId(), "routeVersion", original.getRouteVersion()));
+                    }
+                    markBlocked(original.getTaskNo(), original.getRouteVersion(), currentStation.getStationId());
+                    break;
+                }
+
+                int currentIndex = effectiveFullPath.indexOf(currentStation.getStationId());
+                if (currentIndex < 0) {
+                    Thread.sleep(500L);
+                    firstRun = false;
+                    continue;
+                }
+
+                int remaining = effectiveFullPath.size() - currentIndex - 1;
+                if (remaining <= 0) {
+                    if (traceRegistry != null) {
+                        traceRegistry.markFinished(original.getTaskNo(), traceVersion, currentStation.getStationId(),
+                                buildDetails("targetStationId", original.getTargetStaNo(), "routeVersion", original.getRouteVersion()));
+                    }
+                    markFinished(original.getTaskNo(), original.getRouteVersion(), currentStation.getStationId());
+                    break;
+                }
+
+                StationCommand currentSegmentCommand = localPlan.getSegmentCommands().get(segCursor);
+                int currentSegEndIndex = safeIndex(currentSegmentCommand.getSegmentEndIndex());
+                int currentSegStartIndex = segCursor == 0
+                        ? 0
+                        : safeIndex(localPlan.getSegmentCommands().get(segCursor - 1).getSegmentEndIndex());
+                int segLen = currentSegEndIndex - currentSegStartIndex + 1;
+                int remainingSegment = Math.max(0, currentSegEndIndex - currentIndex);
+                int thresholdSegment = (int) Math.ceil(segLen * loadSegmentAdvanceRatio());
+                thresholdSegment = Math.max(1, thresholdSegment);
+                if (remainingSegment <= thresholdSegment
+                        && segCursor < localPlan.getSegmentCommands().size() - 1) {
+                    StationCommand nextCommand = localPlan.getSegmentCommands().get(segCursor + 1);
+                    if (sendSegmentWithRetry(nextCommand, traceRegistry, traceVersion, currentStation.getStationId())) {
+                        segCursor++;
+                        if (traceRegistry != null) {
+                            traceRegistry.markSegmentIssued(original.getTaskNo(), traceVersion, nextCommand,
+                                    "NEXT_SEGMENT_SENT", "杈撻�佷换鍔′笅涓�娈靛凡鎻愬墠涓嬪彂",
+                                    buildSegmentDetails(nextCommand));
+                        }
+                    } else {
+                        break;
+                    }
+                }
+                Thread.sleep(500L);
+                firstRun = false;
+            } catch (Exception ignore) {
+                break;
+            }
+        }
+    }
+
+    private boolean sendSegmentWithRetry(StationCommand command,
+                                         StationTaskTraceRegistry traceRegistry,
+                                         Integer traceVersion,
+                                         Integer currentStationId) {
+        while (true) {
+            if (!isRouteActive(command == null ? null : command.getTaskNo(), command == null ? null : command.getRouteVersion())) {
+                if (traceRegistry != null && command != null) {
+                    traceRegistry.markCancelled(command.getTaskNo(), traceVersion, currentStationId,
+                            buildDetails("reason", "route_version_replaced", "routeVersion", command.getRouteVersion()));
+                }
+                markCancelled(command == null ? null : command.getTaskNo(),
+                        command == null ? null : command.getRouteVersion(),
+                        currentStationId,
+                        "route_version_replaced");
+                return false;
+            }
+            if (isTaskMoveReset(command == null ? null : command.getTaskNo())) {
+                if (traceRegistry != null && command != null) {
+                    traceRegistry.markCancelled(command.getTaskNo(), traceVersion, currentStationId,
+                            buildDetails("reason", "redis_cancel_signal", "routeVersion", command.getRouteVersion()));
+                }
+                markCancelled(command == null ? null : command.getTaskNo(),
+                        command == null ? null : command.getRouteVersion(),
+                        currentStationId,
+                        "redis_cancel_signal");
+                return false;
+            }
+            CommandResponse commandResponse = commandSender.apply(command);
+            if (commandResponse == null) {
+                sleepQuietly(200L);
+                continue;
+            }
+            if (commandResponse.getResult()) {
+                markSegmentIssued(command == null ? null : command.getTaskNo(), command == null ? null : command.getRouteVersion());
+                return true;
+            }
+            sleepQuietly(200L);
+        }
+    }
+
+    private double loadSegmentAdvanceRatio() {
+        try {
+            ConfigService configService = SpringUtils.getBean(ConfigService.class);
+            if (configService == null) {
+                return DEFAULT_STATION_COMMAND_SEGMENT_ADVANCE_RATIO;
+            }
+            Config config = configService.getOne(new QueryWrapper<Config>()
+                    .eq("code", CFG_STATION_COMMAND_SEGMENT_ADVANCE_RATIO));
+            if (config == null || Cools.isEmpty(config.getValue())) {
+                return DEFAULT_STATION_COMMAND_SEGMENT_ADVANCE_RATIO;
+            }
+            return normalizeSegmentAdvanceRatio(config.getValue());
+        } catch (Exception ignore) {
+            return DEFAULT_STATION_COMMAND_SEGMENT_ADVANCE_RATIO;
+        }
+    }
+
+    private double normalizeSegmentAdvanceRatio(String valueText) {
+        if (valueText == null) {
+            return DEFAULT_STATION_COMMAND_SEGMENT_ADVANCE_RATIO;
+        }
+        String text = valueText.trim();
+        if (text.isEmpty()) {
+            return DEFAULT_STATION_COMMAND_SEGMENT_ADVANCE_RATIO;
+        }
+        if (text.endsWith("%")) {
+            text = text.substring(0, text.length() - 1).trim();
+        }
+        try {
+            double ratio = Double.parseDouble(text);
+            if (ratio > 1d && ratio <= 100d) {
+                ratio = ratio / 100d;
+            }
+            if (ratio < 0d) {
+                return 0d;
+            }
+            if (ratio > 1d) {
+                return 1d;
+            }
+            return ratio;
+        } catch (Exception ignore) {
+            return DEFAULT_STATION_COMMAND_SEGMENT_ADVANCE_RATIO;
+        }
+    }
+
+    private boolean isTaskMoveReset(Integer taskNo) {
+        if (taskNo == null || redisUtil == null) {
+            return false;
+        }
+        Object cancel = redisUtil.get(RedisKeyType.DEVICE_STATION_MOVE_RESET.key + taskNo);
+        return cancel != null;
+    }
+
+    private StationProtocol findCurrentStationByTask(Integer taskNo) {
+        try {
+            com.zy.asrs.service.DeviceConfigService deviceConfigService = SpringUtils.getBean(com.zy.asrs.service.DeviceConfigService.class);
+            if (deviceConfigService == null) {
+                return null;
+            }
+            List<DeviceConfig> devpList = deviceConfigService.list(new QueryWrapper<DeviceConfig>()
+                    .eq("device_type", String.valueOf(SlaveType.Devp)));
+            for (DeviceConfig dc : devpList) {
+                com.zy.core.thread.StationThread thread = (com.zy.core.thread.StationThread) SlaveConnection.get(SlaveType.Devp, dc.getDeviceNo());
+                if (thread == null) {
+                    continue;
+                }
+                Map<Integer, StationProtocol> statusMap = thread.getStatusMap();
+                if (statusMap == null || statusMap.isEmpty()) {
+                    continue;
+                }
+                for (StationProtocol protocol : statusMap.values()) {
+                    if (protocol.getTaskNo() != null && protocol.getTaskNo().equals(taskNo) && protocol.isLoading()) {
+                        return protocol;
+                    }
+                }
+            }
+        } catch (Exception ignore) {
+            return null;
+        }
+        return null;
+    }
+
+    private List<StationTaskTraceSegmentVo> buildTraceSegments(List<StationCommand> segmentCommands) {
+        List<StationTaskTraceSegmentVo> result = new ArrayList<>();
+        if (segmentCommands == null) {
+            return result;
+        }
+        for (StationCommand command : segmentCommands) {
+            if (command == null) {
+                continue;
+            }
+            StationTaskTraceSegmentVo item = new StationTaskTraceSegmentVo();
+            item.setSegmentNo(command.getSegmentNo());
+            item.setSegmentCount(command.getSegmentCount());
+            item.setStationId(command.getStationId());
+            item.setTargetStationId(command.getTargetStaNo());
+            item.setSegmentStartIndex(command.getSegmentStartIndex());
+            item.setSegmentEndIndex(command.getSegmentEndIndex());
+            item.setSegmentPath(copyIntegerList(command.getNavigatePath()));
+            item.setIssued(Boolean.FALSE);
+            result.add(item);
+        }
+        return result;
+    }
+
+    private void bindCommands(List<StationCommand> segmentCommands, int traceVersion, int pathOffset, Integer routeVersion) {
+        if (segmentCommands == null) {
+            return;
+        }
+        for (StationCommand command : segmentCommands) {
+            if (command == null) {
+                continue;
+            }
+            command.setTraceVersion(traceVersion);
+            command.setRouteVersion(routeVersion);
+            if (command.getSegmentStartIndex() != null) {
+                command.setSegmentStartIndex(command.getSegmentStartIndex() + pathOffset);
+            }
+            if (command.getSegmentEndIndex() != null) {
+                command.setSegmentEndIndex(command.getSegmentEndIndex() + pathOffset);
+            }
+        }
+    }
+
+    private Map<String, Object> buildSegmentDetails(StationCommand command) {
+        Map<String, Object> details = new LinkedHashMap<>();
+        if (command != null) {
+            details.put("segmentNo", command.getSegmentNo());
+            details.put("segmentCount", command.getSegmentCount());
+            details.put("segmentPath", copyIntegerList(command.getNavigatePath()));
+            details.put("segmentStartIndex", command.getSegmentStartIndex());
+            details.put("segmentEndIndex", command.getSegmentEndIndex());
+            details.put("traceVersion", command.getTraceVersion());
+            details.put("routeVersion", command.getRouteVersion());
+        }
+        return details;
+    }
+
+    private Map<String, Object> buildDetails(Object... keyValues) {
+        Map<String, Object> details = new LinkedHashMap<>();
+        if (keyValues == null) {
+            return details;
+        }
+        for (int i = 0; i + 1 < keyValues.length; i += 2) {
+            Object key = keyValues[i];
+            if (key != null) {
+                details.put(String.valueOf(key), keyValues[i + 1]);
+            }
+        }
+        return details;
+    }
+
+    private List<Integer> copyIntegerList(List<Integer> source) {
+        List<Integer> result = new ArrayList<>();
+        if (source != null) {
+            result.addAll(source);
+        }
+        return result;
+    }
+
+    private int safeIndex(Integer value) {
+        return value == null ? -1 : value;
+    }
+
+    private boolean equalsInteger(Integer a, Integer b) {
+        return a != null && a.equals(b);
+    }
+
+    private void sleepQuietly(long millis) {
+        try {
+            Thread.sleep(millis);
+        } catch (Exception ignore) {
+        }
+    }
+
+    private boolean isRouteActive(Integer taskNo, Integer routeVersion) {
+        // Legacy direct-enqueue commands (for example FakeProcess/stationInExecute)
+        // do not register a move session and therefore have no routeVersion.
+        // They should keep the historical behavior and execute normally.
+        if (taskNo == null || routeVersion == null) {
+            return true;
+        }
+        StationMoveCoordinator moveCoordinator = SpringUtils.getBean(StationMoveCoordinator.class);
+        return moveCoordinator == null || moveCoordinator.isActiveRoute(taskNo, routeVersion);
+    }
+
+    private void markSegmentIssued(Integer taskNo, Integer routeVersion) {
+        StationMoveCoordinator moveCoordinator = SpringUtils.getBean(StationMoveCoordinator.class);
+        if (moveCoordinator != null) {
+            moveCoordinator.markSegmentIssued(taskNo, routeVersion);
+        }
+    }
+
+    private void updateCurrentStation(Integer taskNo, Integer routeVersion, Integer currentStationId) {
+        StationMoveCoordinator moveCoordinator = SpringUtils.getBean(StationMoveCoordinator.class);
+        if (moveCoordinator != null) {
+            moveCoordinator.updateCurrentStation(taskNo, routeVersion, currentStationId);
+        }
+    }
+
+    private void markCancelled(Integer taskNo, Integer routeVersion, Integer currentStationId, String cancelReason) {
+        StationMoveCoordinator moveCoordinator = SpringUtils.getBean(StationMoveCoordinator.class);
+        if (moveCoordinator != null) {
+            moveCoordinator.markCancelled(taskNo, routeVersion, currentStationId, cancelReason);
+        }
+    }
+
+    private void markBlocked(Integer taskNo, Integer routeVersion, Integer currentStationId) {
+        StationMoveCoordinator moveCoordinator = SpringUtils.getBean(StationMoveCoordinator.class);
+        if (moveCoordinator != null) {
+            moveCoordinator.markBlocked(taskNo, routeVersion, currentStationId);
+        }
+    }
+
+    private void markTimeout(Integer taskNo, Integer routeVersion, Integer currentStationId) {
+        StationMoveCoordinator moveCoordinator = SpringUtils.getBean(StationMoveCoordinator.class);
+        if (moveCoordinator != null) {
+            moveCoordinator.markTimeout(taskNo, routeVersion, currentStationId);
+        }
+    }
+
+    private void markFinished(Integer taskNo, Integer routeVersion, Integer currentStationId) {
+        StationMoveCoordinator moveCoordinator = SpringUtils.getBean(StationMoveCoordinator.class);
+        if (moveCoordinator != null) {
+            moveCoordinator.markFinished(taskNo, routeVersion, currentStationId);
+        }
+    }
+}
diff --git a/src/main/java/com/zy/core/thread/impl/station/StationSegmentPlanner.java b/src/main/java/com/zy/core/thread/impl/station/StationSegmentPlanner.java
new file mode 100644
index 0000000..3c9328c
--- /dev/null
+++ b/src/main/java/com/zy/core/thread/impl/station/StationSegmentPlanner.java
@@ -0,0 +1,96 @@
+package com.zy.core.thread.impl.station;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.serializer.SerializerFeature;
+import com.zy.core.model.command.StationCommand;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public class StationSegmentPlanner {
+
+    public StationSegmentExecutionPlan buildPlan(StationCommand original) {
+        StationSegmentExecutionPlan plan = new StationSegmentExecutionPlan();
+        if (original == null) {
+            return plan;
+        }
+
+        List<Integer> path = copyIntegerList(original.getNavigatePath());
+        List<Integer> liftTransferPath = copyIntegerList(original.getLiftTransferPath());
+        Integer startStationId = original.getStationId();
+        Integer targetStationId = original.getTargetStaNo();
+
+        if ((path == null || path.isEmpty()) && Objects.equals(startStationId, targetStationId) && startStationId != null) {
+            path = new ArrayList<>();
+            path.add(startStationId);
+        }
+        if (path == null || path.isEmpty()) {
+            return plan;
+        }
+
+        plan.setFullPathStationIds(copyIntegerList(path));
+
+        int total = path.size();
+        List<Integer> segmentEndIndices = new ArrayList<>();
+        if (liftTransferPath != null) {
+            for (Integer liftTransferStationId : liftTransferPath) {
+                int endIndex = path.indexOf(liftTransferStationId);
+                if (endIndex <= 0) {
+                    continue;
+                }
+                if (segmentEndIndices.isEmpty() || endIndex > segmentEndIndices.get(segmentEndIndices.size() - 1)) {
+                    segmentEndIndices.add(endIndex);
+                }
+            }
+        }
+        if (segmentEndIndices.isEmpty() || !Objects.equals(segmentEndIndices.get(segmentEndIndices.size() - 1), total - 1)) {
+            segmentEndIndices.add(total - 1);
+        }
+
+        List<StationCommand> segmentCommands = new ArrayList<>();
+        int buildStartIdx = 0;
+        for (Integer endIdx : segmentEndIndices) {
+            if (endIdx == null || endIdx < buildStartIdx) {
+                continue;
+            }
+            List<Integer> segmentPath = new ArrayList<>(path.subList(buildStartIdx, endIdx + 1));
+            if (segmentPath.isEmpty()) {
+                buildStartIdx = endIdx + 1;
+                continue;
+            }
+
+            StationCommand segmentCommand = new StationCommand();
+            segmentCommand.setTaskNo(original.getTaskNo());
+            segmentCommand.setCommandType(original.getCommandType());
+            segmentCommand.setPalletSize(original.getPalletSize());
+            segmentCommand.setBarcode(original.getBarcode());
+            segmentCommand.setOriginalNavigatePath(copyIntegerList(path));
+            segmentCommand.setNavigatePath(segmentPath);
+            segmentCommand.setStationId(segmentPath.get(0));
+            segmentCommand.setTargetStaNo(segmentPath.get(segmentPath.size() - 1));
+            segmentCommand.setSegmentStartIndex(buildStartIdx);
+            segmentCommand.setSegmentEndIndex(endIdx);
+            segmentCommand.setRouteVersion(original.getRouteVersion());
+            segmentCommands.add(segmentCommand);
+
+            buildStartIdx = endIdx;
+        }
+
+        int segmentCount = segmentCommands.size();
+        for (int i = 0; i < segmentCommands.size(); i++) {
+            StationCommand segmentCommand = segmentCommands.get(i);
+            segmentCommand.setSegmentNo(i + 1);
+            segmentCommand.setSegmentCount(segmentCount);
+        }
+        plan.setSegmentCommands(segmentCommands);
+        return plan;
+    }
+
+    private List<Integer> copyIntegerList(List<Integer> source) {
+        if (source == null) {
+            return new ArrayList<>();
+        }
+        return JSON.parseArray(JSON.toJSONString(source, SerializerFeature.DisableCircularReferenceDetect), Integer.class);
+    }
+}
diff --git a/src/main/java/com/zy/core/thread/impl/v5/StationMoveSegmentExecutor.java b/src/main/java/com/zy/core/thread/impl/v5/StationMoveSegmentExecutor.java
new file mode 100644
index 0000000..d0a2618
--- /dev/null
+++ b/src/main/java/com/zy/core/thread/impl/v5/StationMoveSegmentExecutor.java
@@ -0,0 +1,18 @@
+package com.zy.core.thread.impl.v5;
+
+import com.zy.asrs.entity.DeviceConfig;
+import com.zy.common.utils.RedisUtil;
+import com.zy.core.model.CommandResponse;
+import com.zy.core.model.command.StationCommand;
+import com.zy.core.thread.impl.station.StationSegmentExecutor;
+
+import java.util.function.Function;
+
+public class StationMoveSegmentExecutor extends StationSegmentExecutor {
+
+    public StationMoveSegmentExecutor(DeviceConfig deviceConfig,
+                                      RedisUtil redisUtil,
+                                      Function<StationCommand, CommandResponse> commandSender) {
+        super(deviceConfig, redisUtil, commandSender);
+    }
+}
diff --git a/src/main/java/com/zy/core/thread/impl/v5/StationV5SegmentExecutor.java b/src/main/java/com/zy/core/thread/impl/v5/StationV5SegmentExecutor.java
index fecd517..c8a86fa 100644
--- a/src/main/java/com/zy/core/thread/impl/v5/StationV5SegmentExecutor.java
+++ b/src/main/java/com/zy/core/thread/impl/v5/StationV5SegmentExecutor.java
@@ -1,309 +1,17 @@
 package com.zy.core.thread.impl.v5;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.core.common.Cools;
-import com.core.common.SpringUtils;
-import com.zy.asrs.domain.vo.StationTaskTraceSegmentVo;
+
 import com.zy.asrs.entity.DeviceConfig;
 import com.zy.common.utils.RedisUtil;
-import com.zy.core.cache.SlaveConnection;
-import com.zy.core.enums.RedisKeyType;
-import com.zy.core.enums.SlaveType;
-import com.zy.core.enums.StationCommandType;
 import com.zy.core.model.CommandResponse;
 import com.zy.core.model.command.StationCommand;
-import com.zy.core.model.protocol.StationProtocol;
-import com.zy.core.trace.StationTaskTraceRegistry;
-import com.zy.system.entity.Config;
-import com.zy.system.service.ConfigService;
 
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
 import java.util.function.Function;
 
-public class StationV5SegmentExecutor {
-
-    private static final int NEXT_SEGMENT_ADVANCE_NODE_COUNT = 1;
-    private static final long CURRENT_STATION_TIMEOUT_MS = 1000L * 60L;
-
-    private final DeviceConfig deviceConfig;
-    private final RedisUtil redisUtil;
-    private final Function<StationCommand, CommandResponse> commandSender;
-    private final StationV5SegmentPlanner segmentPlanner = new StationV5SegmentPlanner();
+public class StationV5SegmentExecutor extends StationMoveSegmentExecutor {
 
     public StationV5SegmentExecutor(DeviceConfig deviceConfig,
                                     RedisUtil redisUtil,
                                     Function<StationCommand, CommandResponse> commandSender) {
-        this.deviceConfig = deviceConfig;
-        this.redisUtil = redisUtil;
-        this.commandSender = commandSender;
-    }
-
-    public void execute(StationCommand original) {
-        if (original == null) {
-            return;
-        }
-        if (original.getCommandType() != StationCommandType.MOVE) {
-            commandSender.apply(original);
-            return;
-        }
-
-        StationV5SegmentExecutionPlan localPlan = segmentPlanner.buildPlan(original);
-        if (localPlan.getSegmentCommands().isEmpty()) {
-            return;
-        }
-
-        StationTaskTraceRegistry traceRegistry = SpringUtils.getBean(StationTaskTraceRegistry.class);
-        StationTaskTraceRegistry.TraceRegistration traceRegistration = traceRegistry == null
-                ? new StationTaskTraceRegistry.TraceRegistration()
-                : traceRegistry.registerPlan(original.getTaskNo(), deviceConfig.getThreadImpl(),
-                original.getStationId(), original.getStationId(), original.getTargetStaNo(),
-                localPlan.getFullPathStationIds(), buildTraceSegments(localPlan.getSegmentCommands()));
-        int traceVersion = traceRegistration.getTraceVersion() == null ? 1 : traceRegistration.getTraceVersion();
-        int pathOffset = traceRegistration.getPathOffset() == null ? 0 : traceRegistration.getPathOffset();
-        bindCommands(localPlan.getSegmentCommands(), traceVersion, pathOffset);
-        List<Integer> effectiveFullPath = traceRegistration.getFullPathStationIds() == null
-                || traceRegistration.getFullPathStationIds().isEmpty()
-                ? copyIntegerList(localPlan.getFullPathStationIds())
-                : copyIntegerList(traceRegistration.getFullPathStationIds());
-
-        StationCommand firstCommand = localPlan.getSegmentCommands().get(0);
-        if (!sendSegmentWithRetry(firstCommand)) {
-            return;
-        }
-        if (traceRegistry != null) {
-            traceRegistry.markSegmentIssued(original.getTaskNo(), traceVersion, firstCommand,
-                    "FIRST_SEGMENT_SENT", "杈撻�佷换鍔￠娈典笅鍙戞垚鍔�", buildSegmentDetails(firstCommand));
-        }
-
-        long lastSeenAt = System.currentTimeMillis();
-        int segCursor = 0;
-        Integer lastCurrentStationId = null;
-        boolean firstRun = true;
-        while (true) {
-            try {
-                Object cancel = redisUtil.get(RedisKeyType.DEVICE_STATION_MOVE_RESET.key + original.getTaskNo());
-                if (cancel != null) {
-                    if (traceRegistry != null) {
-                        traceRegistry.markCancelled(original.getTaskNo(), traceVersion, lastCurrentStationId,
-                                buildDetails("reason", "redis_cancel_signal"));
-                    }
-                    break;
-                }
-
-                StationProtocol currentStation = findCurrentStationByTask(original.getTaskNo());
-                if (currentStation == null) {
-                    if (System.currentTimeMillis() - lastSeenAt > CURRENT_STATION_TIMEOUT_MS) {
-                        if (traceRegistry != null) {
-                            traceRegistry.markTimeout(original.getTaskNo(), traceVersion, lastCurrentStationId,
-                                    buildDetails("timeoutMs", CURRENT_STATION_TIMEOUT_MS));
-                        }
-                        break;
-                    }
-                    Thread.sleep(500L);
-                    continue;
-                }
-
-                lastSeenAt = System.currentTimeMillis();
-                Integer previousCurrentStationId = lastCurrentStationId;
-                if (traceRegistry != null) {
-                    traceRegistry.updateProgress(original.getTaskNo(), traceVersion, currentStation.getStationId(),
-                            equalsInteger(previousCurrentStationId, currentStation.getStationId()) ? null : "CURRENT_STATION_CHANGE",
-                            "杈撻�佷换鍔″綋鍓嶄綅缃凡鏇存柊",
-                            buildDetails("stationId", currentStation.getStationId()));
-                }
-                lastCurrentStationId = currentStation.getStationId();
-                if (!firstRun && currentStation.isRunBlock()) {
-                    if (traceRegistry != null) {
-                        traceRegistry.markBlocked(original.getTaskNo(), traceVersion, currentStation.getStationId(),
-                                buildDetails("blockedStationId", currentStation.getStationId()));
-                    }
-                    break;
-                }
-
-                int currentIndex = effectiveFullPath.indexOf(currentStation.getStationId());
-                if (currentIndex < 0) {
-                    Thread.sleep(500L);
-                    firstRun = false;
-                    continue;
-                }
-
-                int remaining = effectiveFullPath.size() - currentIndex - 1;
-                if (remaining <= 0) {
-                    if (traceRegistry != null) {
-                        traceRegistry.markFinished(original.getTaskNo(), traceVersion, currentStation.getStationId(),
-                                buildDetails("targetStationId", original.getTargetStaNo()));
-                    }
-                    break;
-                }
-
-                StationCommand currentSegmentCommand = localPlan.getSegmentCommands().get(segCursor);
-                int currentSegEndIndex = safeIndex(currentSegmentCommand.getSegmentEndIndex());
-                int remainingSegment = Math.max(0, currentSegEndIndex - currentIndex);
-                if (remainingSegment <= NEXT_SEGMENT_ADVANCE_NODE_COUNT
-                        && segCursor < localPlan.getSegmentCommands().size() - 1) {
-                    StationCommand nextCommand = localPlan.getSegmentCommands().get(segCursor + 1);
-                    if (sendSegmentWithRetry(nextCommand)) {
-                        segCursor++;
-                        if (traceRegistry != null) {
-                            traceRegistry.markSegmentIssued(original.getTaskNo(), traceVersion, nextCommand,
-                                    "NEXT_SEGMENT_SENT", "杈撻�佷换鍔′笅涓�娈靛凡鎻愬墠涓嬪彂",
-                                    buildSegmentDetails(nextCommand));
-                        }
-                    }
-                }
-                Thread.sleep(500L);
-                firstRun = false;
-            } catch (Exception ignore) {
-                break;
-            }
-        }
-    }
-
-    private boolean sendSegmentWithRetry(StationCommand command) {
-        while (true) {
-            if (isTaskMoveReset(command == null ? null : command.getTaskNo())) {
-                return false;
-            }
-            CommandResponse commandResponse = commandSender.apply(command);
-            if (commandResponse == null) {
-                sleepQuietly(200L);
-                continue;
-            }
-            if (commandResponse.getResult()) {
-                return true;
-            }
-            sleepQuietly(200L);
-        }
-    }
-
-    private boolean isTaskMoveReset(Integer taskNo) {
-        if (taskNo == null || redisUtil == null) {
-            return false;
-        }
-        Object cancel = redisUtil.get(RedisKeyType.DEVICE_STATION_MOVE_RESET.key + taskNo);
-        return cancel != null;
-    }
-
-    private StationProtocol findCurrentStationByTask(Integer taskNo) {
-        try {
-            com.zy.asrs.service.DeviceConfigService deviceConfigService = SpringUtils.getBean(com.zy.asrs.service.DeviceConfigService.class);
-            if (deviceConfigService == null) {
-                return null;
-            }
-            List<DeviceConfig> devpList = deviceConfigService.list(new QueryWrapper<DeviceConfig>()
-                    .eq("device_type", String.valueOf(SlaveType.Devp)));
-            for (DeviceConfig dc : devpList) {
-                com.zy.core.thread.StationThread thread = (com.zy.core.thread.StationThread) SlaveConnection.get(SlaveType.Devp, dc.getDeviceNo());
-                if (thread == null) {
-                    continue;
-                }
-                Map<Integer, StationProtocol> statusMap = thread.getStatusMap();
-                if (statusMap == null || statusMap.isEmpty()) {
-                    continue;
-                }
-                for (StationProtocol protocol : statusMap.values()) {
-                    if (protocol.getTaskNo() != null && protocol.getTaskNo().equals(taskNo) && protocol.isLoading()) {
-                        return protocol;
-                    }
-                }
-            }
-        } catch (Exception ignore) {
-            return null;
-        }
-        return null;
-    }
-
-    private List<StationTaskTraceSegmentVo> buildTraceSegments(List<StationCommand> segmentCommands) {
-        List<StationTaskTraceSegmentVo> result = new ArrayList<>();
-        if (segmentCommands == null) {
-            return result;
-        }
-        for (StationCommand command : segmentCommands) {
-            if (command == null) {
-                continue;
-            }
-            StationTaskTraceSegmentVo item = new StationTaskTraceSegmentVo();
-            item.setSegmentNo(command.getSegmentNo());
-            item.setSegmentCount(command.getSegmentCount());
-            item.setStationId(command.getStationId());
-            item.setTargetStationId(command.getTargetStaNo());
-            item.setSegmentStartIndex(command.getSegmentStartIndex());
-            item.setSegmentEndIndex(command.getSegmentEndIndex());
-            item.setSegmentPath(copyIntegerList(command.getNavigatePath()));
-            item.setIssued(Boolean.FALSE);
-            result.add(item);
-        }
-        return result;
-    }
-
-    private void bindCommands(List<StationCommand> segmentCommands, int traceVersion, int pathOffset) {
-        if (segmentCommands == null) {
-            return;
-        }
-        for (StationCommand command : segmentCommands) {
-            if (command == null) {
-                continue;
-            }
-            command.setTraceVersion(traceVersion);
-            if (command.getSegmentStartIndex() != null) {
-                command.setSegmentStartIndex(command.getSegmentStartIndex() + pathOffset);
-            }
-            if (command.getSegmentEndIndex() != null) {
-                command.setSegmentEndIndex(command.getSegmentEndIndex() + pathOffset);
-            }
-        }
-    }
-
-    private Map<String, Object> buildSegmentDetails(StationCommand command) {
-        Map<String, Object> details = new LinkedHashMap<>();
-        if (command != null) {
-            details.put("segmentNo", command.getSegmentNo());
-            details.put("segmentCount", command.getSegmentCount());
-            details.put("segmentPath", copyIntegerList(command.getNavigatePath()));
-            details.put("segmentStartIndex", command.getSegmentStartIndex());
-            details.put("segmentEndIndex", command.getSegmentEndIndex());
-            details.put("traceVersion", command.getTraceVersion());
-        }
-        return details;
-    }
-
-    private Map<String, Object> buildDetails(Object... keyValues) {
-        Map<String, Object> details = new LinkedHashMap<>();
-        if (keyValues == null) {
-            return details;
-        }
-        for (int i = 0; i + 1 < keyValues.length; i += 2) {
-            Object key = keyValues[i];
-            if (key != null) {
-                details.put(String.valueOf(key), keyValues[i + 1]);
-            }
-        }
-        return details;
-    }
-
-    private List<Integer> copyIntegerList(List<Integer> source) {
-        List<Integer> result = new ArrayList<>();
-        if (source == null) {
-            return result;
-        }
-        result.addAll(source);
-        return result;
-    }
-
-    private int safeIndex(Integer value) {
-        return value == null ? -1 : value;
-    }
-
-    private boolean equalsInteger(Integer a, Integer b) {
-        return a != null && a.equals(b);
-    }
-
-    private void sleepQuietly(long millis) {
-        try {
-            Thread.sleep(millis);
-        } catch (Exception ignore) {
-        }
+        super(deviceConfig, redisUtil, commandSender);
     }
 }
diff --git a/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java b/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
index ea10e5d..94b122b 100644
--- a/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
+++ b/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
@@ -19,6 +19,8 @@
 import com.zy.common.service.CommonService;
 import com.zy.common.utils.NavigateUtils;
 import com.zy.common.utils.RedisUtil;
+import com.zy.core.move.StationMoveCoordinator;
+import com.zy.core.move.StationMoveSession;
 import com.zy.core.News;
 import com.zy.core.cache.MessageQueue;
 import com.zy.core.cache.SlaveConnection;
@@ -74,6 +76,8 @@
     private StationTaskLoopService stationTaskLoopService;
     @Autowired
     private WrkAnalysisService wrkAnalysisService;
+    @Autowired
+    private StationMoveCoordinator stationMoveCoordinator;
 
     //鎵ц杈撻�佺珯鐐瑰叆搴撲换鍔�
     public synchronized void stationInExecute() {
@@ -252,7 +256,16 @@
                     wrkMast.setModiTime(now);
                     if (wrkMastService.updateById(wrkMast)) {
                         wrkAnalysisService.markOutboundStationStart(wrkMast, now);
-                        offerDevpCommandWithDedup(stationObjModel.getDeviceNo(), command, "crnStationOutExecute");
+                        boolean offered = offerDevpCommandWithDedup(stationObjModel.getDeviceNo(), command, "crnStationOutExecute");
+                        if (offered && stationMoveCoordinator != null) {
+                            stationMoveCoordinator.recordDispatch(
+                                    wrkMast.getWrkNo(),
+                                    stationProtocol.getStationId(),
+                                    "crnStationOutExecute",
+                                    command,
+                                    false
+                            );
+                        }
                         News.info("杈撻�佺珯鐐瑰嚭搴撳懡浠や笅鍙戞垚鍔燂紝绔欑偣鍙�={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationProtocol.getStationId(), wrkMast.getWrkNo(), JSON.toJSONString(command));
                         redisUtil.set(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId(), "lock", 5);
                         redisUtil.del(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo());
@@ -372,6 +385,9 @@
         if (wrkMast == null || wrkMast.getWrkNo() == null) {
             return;
         }
+        if (stationMoveCoordinator != null) {
+            stationMoveCoordinator.finishSession(wrkMast.getWrkNo());
+        }
         Date now = new Date();
         wrkMast.setWrkSts(WrkStsType.STATION_RUN_COMPLETE.sts);
         wrkMast.setIoTime(now);
@@ -419,6 +435,9 @@
                 }
 
                 if (complete) {
+                    if (stationMoveCoordinator != null) {
+                        stationMoveCoordinator.finishSession(wrkNo);
+                    }
                     wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                     wrkMast.setIoTime(new Date());
                     wrkMastService.updateById(wrkMast);
@@ -476,6 +495,9 @@
                                         stationProtocol.getTaskNo(),
                                         currentTaskBufferCommandCount);
                                 continue;
+                            }
+                            if (stationMoveCoordinator != null) {
+                                stationMoveCoordinator.cancelSession(wrkMast.getWrkNo());
                             }
                             //杩愯鍫靛锛岄噸鏂扮敵璇蜂换鍔�
                             String response = wmsOperateUtils.applyReassignTaskLocNo(wrkMast.getWrkNo(), stationProtocol.getStationId());
@@ -554,7 +576,19 @@
                                 }
 
                                 if (wrkMastService.updateById(wrkMast)) {
-                                    offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "checkStationRunBlock_direct");
+                                    boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "checkStationRunBlock_direct");
+                                    if (!offered) {
+                                        continue;
+                                    }
+                                    if (stationMoveCoordinator != null) {
+                                        stationMoveCoordinator.recordDispatch(
+                                                wrkMast.getWrkNo(),
+                                                stationProtocol.getStationId(),
+                                                "checkStationRunBlock_direct",
+                                                command,
+                                                false
+                                        );
+                                    }
                                 }
                             } else {
                                 News.error("璇锋眰WMS鎺ュ彛澶辫触锛侊紒锛乺esponse锛歿}", response);
@@ -592,9 +626,24 @@
                                 continue;
                             }
 
+                            if (stationMoveCoordinator != null) {
+                                stationMoveCoordinator.cancelSession(wrkMast.getWrkNo());
+                            }
                             resetSegmentMoveCommandsBeforeReroute(wrkMast.getWrkNo());
-                            offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "checkStationRunBlock_reroute");
+                            boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "checkStationRunBlock_reroute");
+                            if (!offered) {
+                                continue;
+                            }
                             syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderStationIds, dispatchDecision, command);
+                            if (stationMoveCoordinator != null) {
+                                stationMoveCoordinator.recordDispatch(
+                                        wrkMast.getWrkNo(),
+                                        stationProtocol.getStationId(),
+                                        "checkStationRunBlock_reroute",
+                                        command,
+                                        dispatchDecision != null && dispatchDecision.isCircle()
+                                );
+                            }
                             News.info("杈撻�佺珯鐐瑰牭濉炲悗閲嶆柊璁＄畻璺緞鍛戒护涓嬪彂鎴愬姛锛岀珯鐐瑰彿={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationProtocol.getStationId(), wrkMast.getWrkNo(), JSON.toJSONString(command));
                         }
                     }
@@ -696,13 +745,6 @@
                 if (countCurrentTaskBufferCommands(stationProtocol.getTaskBufferItems(), stationProtocol.getTaskNo()) > 0) {
                     continue;
                 }
-                if (isWatchingCircleTransit(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
-                    continue;
-                }
-
-                if (isWatchingCircleArrival(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
-                    continue;
-                }
 
                 Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
                 OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
@@ -727,12 +769,28 @@
                     News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
                     continue;
                 }
+                if (stationMoveCoordinator != null
+                        && stationMoveCoordinator.shouldSuppressDispatch(wrkMast.getWrkNo(), stationProtocol.getStationId(), command)) {
+                    continue;
+                }
                 if (!tryAcquireOutOrderDispatchLock(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
                     continue;
                 }
                 resetSegmentMoveCommandsBeforeReroute(wrkMast.getWrkNo());
+                boolean offered = offerDevpCommandWithDedup(stationObjModel.getDeviceNo(), command, "checkStationOutOrder");
+                if (!offered) {
+                    continue;
+                }
                 syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderStationIds, dispatchDecision, command);
-                offerDevpCommandWithDedup(stationObjModel.getDeviceNo(), command, "checkStationOutOrder");
+                if (stationMoveCoordinator != null) {
+                    stationMoveCoordinator.recordDispatch(
+                            wrkMast.getWrkNo(),
+                            stationProtocol.getStationId(),
+                            "checkStationOutOrder",
+                            command,
+                            dispatchDecision != null && dispatchDecision.isCircle()
+                    );
+                }
                 News.info(dispatchDecision.isCircle() ? "{}浠诲姟杩涜缁曞湀" : "{}浠诲姟鐩存帴鍘荤洰鏍囩偣", wrkMast.getWrkNo());
             }
         }
@@ -807,12 +865,28 @@
                     News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
                     continue;
                 }
+                if (stationMoveCoordinator != null
+                        && stationMoveCoordinator.shouldSuppressDispatch(wrkMast.getWrkNo(), stationProtocol.getStationId(), command)) {
+                    continue;
+                }
                 if (!tryAcquireOutOrderDispatchLock(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
                     continue;
                 }
                 resetSegmentMoveCommandsBeforeReroute(wrkMast.getWrkNo());
+                boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "watchCircleStation");
+                if (!offered) {
+                    continue;
+                }
                 syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderList, dispatchDecision, command);
-                offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "watchCircleStation");
+                if (stationMoveCoordinator != null) {
+                    stationMoveCoordinator.recordDispatch(
+                            wrkMast.getWrkNo(),
+                            stationProtocol.getStationId(),
+                            "watchCircleStation",
+                            command,
+                            dispatchDecision != null && dispatchDecision.isCircle()
+                    );
+                }
             }
         }
     }
@@ -1283,11 +1357,33 @@
     }
 
     private boolean isWatchingCircleArrival(Integer wrkNo, Integer stationId) {
+        if (stationMoveCoordinator != null) {
+            StationMoveSession session = stationMoveCoordinator.loadSession(wrkNo);
+            if (session != null && session.isActive() && stationId != null) {
+                if (stationId.equals(session.getNextDecisionStationId())) {
+                    return true;
+                }
+                if (session.containsStation(stationId)) {
+                    return false;
+                }
+            }
+        }
         StationCommand command = getWatchCircleCommand(wrkNo);
         return command != null && stationId != null && stationId.equals(command.getTargetStaNo());
     }
 
     private boolean isWatchingCircleTransit(Integer wrkNo, Integer stationId) {
+        if (stationMoveCoordinator != null) {
+            StationMoveSession session = stationMoveCoordinator.loadSession(wrkNo);
+            if (session != null && session.isActive() && stationId != null) {
+                if (stationId.equals(session.getNextDecisionStationId())) {
+                    return false;
+                }
+                if (session.containsStation(stationId)) {
+                    return true;
+                }
+            }
+        }
         StationCommand command = getWatchCircleCommand(wrkNo);
         if (command == null || stationId == null || Objects.equals(stationId, command.getTargetStaNo())) {
             return false;
@@ -1376,6 +1472,9 @@
             return;
         }
 
+        if (stationMoveCoordinator != null) {
+            stationMoveCoordinator.cancelSession(stationProtocol.getTaskNo());
+        }
         redisUtil.set(RedisKeyType.CHECK_STATION_IDLE_RECOVER_LIMIT_.key + stationProtocol.getTaskNo(), "lock", STATION_IDLE_RECOVER_LIMIT_SECONDS);
         resetSegmentMoveCommandsBeforeReroute(stationProtocol.getTaskNo());
         int clearedCommandCount = clearIssuedMoveCommandsDuringIdleStay(idleTrack, stationProtocol.getTaskNo(), stationProtocol.getStationId());
@@ -1392,8 +1491,20 @@
             return;
         }
 
-        offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "checkStationIdleRecover");
+        boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "checkStationIdleRecover");
+        if (!offered) {
+            return;
+        }
         syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderList, dispatchDecision, command);
+        if (stationMoveCoordinator != null) {
+            stationMoveCoordinator.recordDispatch(
+                    wrkMast.getWrkNo(),
+                    stationProtocol.getStationId(),
+                    "checkStationIdleRecover",
+                    command,
+                    dispatchDecision != null && dispatchDecision.isCircle()
+            );
+        }
         saveStationTaskIdleTrack(new StationTaskIdleTrack(wrkMast.getWrkNo(), stationProtocol.getStationId(), System.currentTimeMillis()));
         News.info("杈撻�佺珯鐐逛换鍔″仠鐣檣}绉掓湭杩愯锛屽凡閲嶆柊璁＄畻璺緞骞堕噸鍚繍琛岋紝绔欑偣鍙�={}锛岀洰鏍囩珯={}锛屽伐浣滃彿={}锛屾竻鐞嗘棫鍒嗘鍛戒护鏁�={}锛屽懡浠ゆ暟鎹�={}",
                 STATION_IDLE_RECOVER_SECONDS, stationProtocol.getStationId(), moveStaNo, wrkMast.getWrkNo(), clearedCommandCount, JSON.toJSONString(command));
@@ -1469,8 +1580,23 @@
 
     private String buildStationCommandDispatchDedupKey(Integer deviceNo, StationCommand command) {
         return RedisKeyType.STATION_COMMAND_DISPATCH_DEDUP_.key
+                + deviceNo + "_"
                 + command.getTaskNo() + "_"
-                + command.getStationId();
+                + command.getStationId() + "_"
+                + (stationMoveCoordinator == null ? Integer.toHexString(buildFallbackPathSignature(command).hashCode())
+                : stationMoveCoordinator.buildPathSignatureHash(command));
+    }
+
+    private String buildFallbackPathSignature(StationCommand command) {
+        if (command == null) {
+            return "";
+        }
+        return String.valueOf(command.getCommandType())
+                + "_" + command.getStationId()
+                + "_" + command.getTargetStaNo()
+                + "_" + command.getNavigatePath()
+                + "_" + command.getLiftTransferPath()
+                + "_" + command.getOriginalNavigatePath();
     }
 
     private int clearIssuedMoveCommandsDuringIdleStay(StationTaskIdleTrack idleTrack,

--
Gitblit v1.9.1