优化

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/controller/DeliveryTransferController.java

@@ -6,6 +6,10 @@ import com.baiyue.common.security.AuthenticatedUser;
 import com.baiyue.lastleg.delivery.dto.DeliveryRequests;
 import com.baiyue.lastleg.delivery.dto.DeliveryResponses;
 import com.baiyue.lastleg.delivery.service.DeliveryTransferService;
+import com.baiyue.lastleg.delivery.service.DispatchDeliveryService;
+import com.baiyue.lastleg.dispatch.port.DispatchContracts.*;
+import com.baiyue.lastleg.dispatch.port.DispatchDeliveryModels.*;
+import com.baiyue.lastleg.dispatch.port.DispatchTypes.ActorMode;
 import com.baiyue.lastleg.security.OverseasPermissions;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,23 +26,34 @@ import org.springframework.web.server.ResponseStatusException;
 @Tag(name = "Outbound and delivery")
 public class DeliveryTransferController {
     @Resource private DeliveryTransferService service;
+    @Resource private DispatchDeliveryService dispatchDelivery;
 
+    /** 只读辅助入口复用同一整车组合预览，不保留单客户报价协议。 */
     @GetMapping("/dispatches/{dispatchNo}/external-freight")
     @PreAuthorize("hasAuthority('" + OverseasPermissions.DISPATCH_LIST + "')")
-    public ApiResponse<com.baiyue.lastleg.fleet.trip.FleetBookingFreight.Preview> externalFreight(
+    public ApiResponse<java.util.List<PreviewGroup>> externalFreight(
         @AuthenticationPrincipal AuthenticatedUser user, @PathVariable String dispatchNo) {
         requirePlatform(user);
-        return ApiResponse.success(service.externalFreight(dispatchNo));
+        return ApiResponse.success(dispatchDelivery.preview(actor(user),dispatchNo).groups());
     }
 
+    /** 一次快照提供全部客户目的地、费用证据及既有安排的完整数组。 */
+    @GetMapping("/dispatches/{dispatchNo}/delivery-arrangement")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.DISPATCH_LIST + "')")
+    public ApiResponse<ArrangementPreview> arrangement(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo) {
+        requirePlatform(user);
+        return ApiResponse.success(dispatchDelivery.preview(actor(user),dispatchNo));
+    }
+
+    /** 平台一次安排本车全部客户，身份只从认证上下文获取。 */
     @PostMapping("/dispatches/{dispatchNo}/transfer-delivery")
     @PreAuthorize("hasAuthority('" + OverseasPermissions.DISPATCH_TRANSFER_DELIVERY + "')")
-    @Operation(summary = "Create one pending outbound order and one delivery order per destination FBA warehouse")
-    public ApiResponse<DeliveryResponses.TransferResult> transfer(
+    @Operation(summary = "按真实客户生成出库单并按客户目的地生成派送单")
+    public ApiResponse<CommandResult> transfer(
         @AuthenticationPrincipal AuthenticatedUser user, @PathVariable String dispatchNo,
-        @Valid @RequestBody DeliveryRequests.Transfer request) {
+        @Valid @RequestBody ArrangeDelivery request) {
         requirePlatform(user);
-        return ApiResponse.success(service.platformTransfer(dispatchNo, operator(user), request));
+        return ApiResponse.success(dispatchDelivery.arrange(actor(user),dispatchNo,request));
     }
 
     @PostMapping("/outbound-orders/one-click-dropship")
@@ -160,6 +175,8 @@ public class DeliveryTransferController {
     private String operator(AuthenticatedUser user) {
         return user.userId() == null ? user.username() : String.valueOf(user.userId());
     }
+    /** 平台安排不能使用请求体提供的客户或操作者身份。 */
+    private Actor actor(AuthenticatedUser user) { return new Actor(operator(user),ActorMode.PLATFORM,null); }
     private String listScope(AuthenticatedUser user, String requestedCustomer) {
         requirePlatform(user);
         return requestedCustomer == null || requestedCustomer.isBlank() ? null : requestedCustomer.trim();

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/controller/MerchantDeliveryController.java

@@ -31,14 +31,6 @@ public class MerchantDeliveryController {
         return ApiResponse.success(service.deliveryPage(customer(user), query));
     }
 
-    @PostMapping
-    @PreAuthorize("hasAuthority('" + OverseasPermissions.MERCHANT_DELIVERY_CREATE + "')")
-    public ApiResponse<DeliveryResponses.TransferResult> create(@AuthenticationPrincipal AuthenticatedUser user,
-                                                                 @RequestParam String dispatchNo,
-                                                                 @Valid @RequestBody DeliveryRequests.Transfer request) {
-        return ApiResponse.success(service.merchantTransfer(customer(user), dispatchNo, operator(user), request));
-    }
-
     @GetMapping("/{deliveryNo}")
     @PreAuthorize("hasAuthority('" + OverseasPermissions.MERCHANT_DELIVERY_LIST + "')")
     public ApiResponse<DeliveryResponses.DeliveryDetail> detail(@AuthenticationPrincipal AuthenticatedUser user,
@@ -71,5 +63,4 @@ public class MerchantDeliveryController {
         if (!"MERCHANT".equals(user.appCode()) || user.tenantId() <= 0L) throw new ResponseStatusException(HttpStatus.FORBIDDEN, "Merchant identity is required");
         return String.valueOf(user.tenantId());
     }
-    private String operator(AuthenticatedUser user) { return user.userId() == null ? user.username() : String.valueOf(user.userId()); }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/controller/PlatformDeliveryFeeCoverageController.java

@@ -2,8 +2,10 @@ package com.baiyue.lastleg.delivery.controller;
 
 import com.baiyue.common.core.api.ApiResponse;
 import com.baiyue.common.security.AuthenticatedUser;
-import com.baiyue.lastleg.delivery.dto.DeliveryFeeCoverageModels;
-import com.baiyue.lastleg.delivery.service.DeliveryFeeCoverageService;
+import com.baiyue.lastleg.delivery.service.DispatchDeliveryService;
+import com.baiyue.lastleg.dispatch.port.DispatchContracts.Actor;
+import com.baiyue.lastleg.dispatch.port.DispatchTypes.ActorMode;
+import com.baiyue.lastleg.dispatch.port.DispatchDeliveryModels.PreviewGroup;
 import com.baiyue.lastleg.security.OverseasPermissions;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.HttpStatus;
@@ -16,13 +18,15 @@ import org.springframework.web.server.ResponseStatusException;
 @RequiredArgsConstructor
 @RequestMapping("/api/platform/v1/last-leg/dispatches")
 public class PlatformDeliveryFeeCoverageController {
-    private final DeliveryFeeCoverageService service;
+    private final DispatchDeliveryService service;
+    /** 原费辅助查询复用真实整车分组，不能再从头部推定单客户。 */
     @GetMapping("/{dispatchNo}/fee-coverage")
     @PreAuthorize("hasAuthority('" + OverseasPermissions.DISPATCH_LIST + "')")
-    public ApiResponse<DeliveryFeeCoverageModels.Preview> preview(@AuthenticationPrincipal AuthenticatedUser user,
+    public ApiResponse<java.util.List<PreviewGroup>> preview(@AuthenticationPrincipal AuthenticatedUser user,
         @PathVariable String dispatchNo) {
         if (user == null || user.tenantId() == null) throw new ResponseStatusException(HttpStatus.UNAUTHORIZED);
         if (!"PLATFORM".equals(user.appCode()) || user.tenantId() != 0L) throw new ResponseStatusException(HttpStatus.FORBIDDEN);
-        return ApiResponse.success(service.preview(dispatchNo));
+        String operator=user.userId()==null?user.username():user.userId().toString();
+        return ApiResponse.success(service.preview(new Actor(operator,ActorMode.PLATFORM,null),dispatchNo).groups());
     }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/dto/DeliveryFeeCoverageModels.java

@@ -9,10 +9,6 @@ public final class DeliveryFeeCoverageModels {
     private DeliveryFeeCoverageModels() { }
     public record Cargo(Long dispatchItemId, Long warehousePalletId, String palletNo, Long orderId,
         String sourceRegion, String sourceInboundId, String inboundCode, long packages, String dispatchInboundCode) { }
-    public record Preview(String dispatchNo, boolean sourceComplete, String blockReason, String cargoHash,
-        List<Cargo> cargo, List<FinanceFeeCoverageClient.Fee> feeSources) { }
-    public record Selection(@NotNull @Positive Long financeFeeId, @Min(1) int sourceVersion,
-        @NotBlank @Size(max=128) String sourceHash, @NotEmpty @Size(max=3) List<@NotBlank @Pattern(regexp="DELIVERY_FEE|LOADING_FEE|APPOINTMENT_FEE") String> services) { }
     public record Reference(FinanceFeeCoverageClient.Fee source, List<String> services) { }
     public record Evidence(String cargoHash, List<Cargo> cargo, List<Reference> references, String operatorId, Instant confirmedAt) { }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/dto/DeliveryRequests.java

@@ -6,7 +6,6 @@ import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Size;
 import jakarta.validation.Valid;
-import com.baiyue.lastleg.delivery.dto.DeliveryFeeCoverageModels.Selection;
 import java.util.List;
 import java.util.Collections;
 import java.math.BigDecimal;
@@ -16,46 +15,6 @@ import java.time.LocalDate;
 public final class DeliveryRequests {
     private DeliveryRequests() {}
 
-    public record Transfer(@NotBlank @Size(max = 255) String idempotencyKey,
-                           @NotNull LocalDateTime plannedDeliveryAt,
-                           @NotBlank @Size(max = 32) String deliveryMethod,
-                           @Size(max = 128) String waybillNo,
-                           @Size(max = 255) String carrierName,
-                           @NotBlank @Size(max = 64) String pickupMethod,
-                           @NotBlank @Size(max = 64) String loadingType,
-                           @Size(max = 64) String vehicleType,
-                           @jakarta.validation.constraints.Pattern(regexp = "15托|30托") String vehicleSize,
-                           @Size(max = 128) String driverName,
-                           @Size(max = 64) String driverPhone,
-                           @Size(max = 64) String vehiclePlate,
-                           @Size(max = 128) String appointmentAccount,
-                           @Size(max = 128) String sellerName,
-                           @Size(max = 1000) String remark,
-                           @NotNull @Valid @Size(max = 20) List<FeeItem> fees,
-                           @Size(max = 64) String externalFreightHash,
-                           @Size(max = 64) String feeCoverageCargoHash,
-                           @Size(max = 2000) List<@NotNull @Valid Selection> feeCoverage) {}
-
-    public record FeeItem(@NotBlank @Size(max = 64) String feeType,
-                          @NotBlank @Size(max = 128) String feeName,
-                          @NotBlank @jakarta.validation.constraints.Pattern(regexp = "RECEIVABLE|PAYABLE") String direction,
-                          @NotBlank @jakarta.validation.constraints.Pattern(regexp = "CNY|USD") String currency,
-                          @NotNull @jakarta.validation.constraints.DecimalMin(value = "0.00", inclusive = false) BigDecimal amount,
-                          @Min(1) Long supplierId,
-                          @Size(max = 200) String supplierName,
-                          @Size(max = 32) String supplierCategory,
-                          @jakarta.validation.constraints.Pattern(regexp = "ON_ACCOUNT|DIRECT_PAID") String settlementMode,
-                          LocalDateTime paidAt,
-                          @jakarta.validation.constraints.Pattern(regexp = "ONLINE|BANK_TRANSFER|CASH|OTHER") String paymentMethod,
-                          @Size(max = 128) String paymentReferenceNo,
-                          @Size(max = 20) List<@NotBlank String> paymentVoucherFileIds,
-                          @jakarta.validation.constraints.DecimalMin(value = "0.00", inclusive = false) BigDecimal chargeableQuantity,
-                          @Size(max = 32) String quantityUnit,
-                          @jakarta.validation.constraints.DecimalMin(value = "0.00", inclusive = false) BigDecimal unitPrice,
-                          LocalDate periodStart,
-                          LocalDate periodEnd,
-                          @Size(max = 500) String remark) {}
-
     public record Query(@Min(1) long page, @Min(1) @Max(200) long size,
                         String documentNo, String lxCode, String warehouseId, String status,
                         String dispatchNo, String waybillNo, String vehiclePlate,

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/dto/DeliveryResponses.java

@@ -8,14 +8,6 @@ import com.fasterxml.jackson.annotation.JsonInclude;
 public final class DeliveryResponses {
     private DeliveryResponses() {}
 
-    public record TransferDelivery(String deliveryNo, String deliveryStatus,
-                                   String destinationWarehouseId, String destinationWarehouseCode,
-                                   String destinationWarehouseName, int palletCount, int packageCount) {}
-
-    public record TransferResult(String dispatchNo, String outboundNo, String outboundStatus,
-                                 int palletCount, int packageCount,
-                                 List<TransferDelivery> deliveries, boolean replayed) {}
-
     public record OutboundRow(Long id, String outboundNo, String dispatchNo, String overseasWarehouseId, String lxCodes,
                               String status, int palletCount, int packageCount, BigDecimal grossWeightKg,
                               BigDecimal volumeWeightKg, BigDecimal volumeCbm,

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/entity/DeliveryFactsChanged.java

@@ -0,0 +1,23 @@
+package com.baiyue.lastleg.delivery.entity;
+
+import lombok.Data;
+import java.time.LocalDateTime;
+
+/** 签收事务内保存的本地待汇总事实，不携带整车已完成结论。 */
+@Data
+public class DeliveryFactsChanged {
+    private Long id;
+    private String customerId;
+    private Long dispatchId;
+    private String dispatchNo;
+    private Long deliveryId;
+    private String deliveryNo;
+    private Long deliveryVersion;
+    private String factsHash;
+    private LocalDateTime occurredAt;
+    private String state;
+    private Integer attemptCount;
+    private LocalDateTime nextAttemptAt;
+    private String lastErrorCode;
+    private LocalDateTime processedAt;
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/entity/DispatchDeliveryArrangement.java

@@ -0,0 +1,21 @@
+package com.baiyue.lastleg.delivery.entity;
+
+import lombok.Data;
+import java.time.LocalDateTime;
+
+/** 每趟车唯一安排事实，保留完整客户结果及真实来源。 */
+@Data
+public class DispatchDeliveryArrangement {
+    private Long id;
+    private Long dispatchOrderId;
+    private String dispatchNo;
+    private String arrangementKey;
+    private String businessHash;
+    private String cargoHash;
+    private String loadingCompletionHash;
+    private String originalCommandKey;
+    private String originalOperatorId;
+    private String resultJson;
+    private String cargoJson;
+    private LocalDateTime createdAt;
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/entity/OutboundPalletItem.java

@@ -16,6 +16,14 @@ public class OutboundPalletItem {
     private Long id;
     private String customerId;
     private Long outboundOrderId;
+    /** 排车出库明确关联原作业明细，不从托盘展示字段猜来源。 */
+    private Long dispatchItemId;
+    /** 对应本次真实PDA拣货归属，作为客户和数量核对的不可变来源。 */
+    private Long sourceAttributionId;
+    private Long sourceOrderId;
+    private Long sourceInventoryPositionId;
+    private Long sourceReturnReceiptId;
+    private Long sourceReturnCartonId;
     private Long warehousePalletId;
     private String palletNo;
     private String destinationWarehouseId;

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/mapper/DeliveryFactsChangedMapper.java

@@ -0,0 +1,58 @@
+package com.baiyue.lastleg.delivery.mapper;
+
+import com.baiyue.lastleg.delivery.entity.DeliveryFactsChanged;
+import org.apache.ibatis.annotations.*;
+import java.time.LocalDateTime;
+import java.util.List;
+
+/** 本地签收信号的唯一写入、扫描、确认及失败记录。 */
+@Mapper
+public interface DeliveryFactsChangedMapper {
+    /** 同一派送版本只登记一次，不覆盖首次不可变事实。 */
+    @Insert("""
+        INSERT INTO ll_delivery_facts_changed
+          (id,customer_id,dispatch_id,dispatch_no,delivery_id,delivery_no,delivery_version,facts_hash,
+           occurred_at,state,attempt_count,next_attempt_at)
+        VALUES (#{id},#{customerId},#{dispatchId},#{dispatchNo},#{deliveryId},#{deliveryNo},
+                #{deliveryVersion},#{factsHash},#{occurredAt},'PENDING',0,#{occurredAt})
+        ON DUPLICATE KEY UPDATE id=id
+        """)
+    int insertOnce(DeliveryFactsChanged fact);
+
+    /** 唯一键等待后读取当前已保存事实，不能用旧快照确认异载荷重放。 */
+    @Select("""
+        SELECT * FROM ll_delivery_facts_changed
+        WHERE customer_id=#{customerId} AND delivery_id=#{deliveryId} AND delivery_version=#{version}
+        """)
+    DeliveryFactsChanged find(@Param("customerId") String customerId, @Param("deliveryId") long deliveryId,
+                             @Param("version") long version);
+
+    /** 按已扫描信号身份读取，不取得父级之前的子行锁。 */
+    @Select("SELECT * FROM ll_delivery_facts_changed WHERE id=#{id}")
+    DeliveryFactsChanged findById(@Param("id") long id);
+
+    /** 普通读候选，不在申请整车父锁之前锁定信号行。 */
+    @Select("""
+        SELECT * FROM ll_delivery_facts_changed
+        WHERE state='PENDING' AND next_attempt_at<=#{now}
+        ORDER BY next_attempt_at,id LIMIT #{limit}
+        """)
+    List<DeliveryFactsChanged> pending(@Param("now") LocalDateTime now, @Param("limit") int limit);
+
+    /** 父级汇总同事务仅确认指定的已核对信号，不能吞掉之后产生的版本。 */
+    @Update("""
+        UPDATE ll_delivery_facts_changed SET state='PROCESSED',processed_at=#{now},last_error_code=NULL
+        WHERE id=#{id} AND dispatch_id=#{dispatchId} AND state='PENDING'
+        """)
+    int acknowledge(@Param("id") long id, @Param("dispatchId") long dispatchId,
+                    @Param("now") LocalDateTime now);
+
+    /** 汇总回滚后以独立短事务记录退避，不改成已完成。 */
+    @Update("""
+        UPDATE ll_delivery_facts_changed
+        SET attempt_count=attempt_count+1,last_error_code=#{errorCode},next_attempt_at=GREATEST(next_attempt_at,#{nextAttemptAt})
+        WHERE id=#{id} AND state='PENDING'
+        """)
+    int failed(@Param("id") long id, @Param("errorCode") String errorCode,
+               @Param("nextAttemptAt") LocalDateTime nextAttemptAt);
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/mapper/DeliveryOrderMapper.java

@@ -9,6 +9,18 @@ import java.util.List;
 
 @Mapper
 public interface DeliveryOrderMapper extends BaseMapper<DeliveryOrder> {
+    /** 整车签收事实使用完整真实客户单据集合。 */
+    @Select("SELECT * FROM ll_delivery_order WHERE dispatch_order_id=#{dispatchId} ORDER BY LENGTH(customer_id),customer_id,id")
+    List<DeliveryOrder> findAllByDispatch(@Param("dispatchId") long dispatchId);
+
+    /** 取得全部出库锁后一次取得全部派送锁，禁止逐客户混取来源锁。 */
+    @Select("SELECT * FROM ll_delivery_order WHERE dispatch_order_id=#{dispatchId} ORDER BY LENGTH(customer_id),customer_id,id FOR UPDATE")
+    List<DeliveryOrder> lockAllByDispatch(@Param("dispatchId") long dispatchId);
+
+    /** 服务内签收信号按整车及派送号定位真实客户，不接受浏览器客户范围。 */
+    @Select("SELECT * FROM ll_delivery_order WHERE dispatch_no=#{dispatchNo} AND delivery_no=#{deliveryNo}")
+    List<DeliveryOrder> findForSignal(@Param("dispatchNo") String dispatchNo, @Param("deliveryNo") String deliveryNo);
+
     @Select("SELECT * FROM ll_delivery_order WHERE customer_id=#{customerId} AND outbound_order_id=#{outboundOrderId} ORDER BY id")
     List<DeliveryOrder> findByOutbound(@Param("customerId") String customerId, @Param("outboundOrderId") Long outboundOrderId);
     @Select("SELECT * FROM ll_delivery_order WHERE customer_id=#{customerId} AND delivery_no=#{deliveryNo} LIMIT 1")

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/mapper/DeliverySourceEvidenceMapper.java

@@ -18,18 +18,22 @@ public interface DeliverySourceEvidenceMapper {
         "WHERE customer_id=#{customerId} AND source_region='FIRSTLEG' AND id=#{orderId} FOR UPDATE")
     Source lockSource(@Param("customerId") String customerId, @Param("orderId") long orderId);
 
+    /** 从本客户真实扫码及逐票归属定位共享整车任务，不依赖不存在的任务头客户。 */
     @Select("SELECT DISTINCT t.dispatch_order_id FROM ll_dispatch_pda_pick_order a " +
         "JOIN ll_dispatch_pda_pick p ON p.customer_id=a.customer_id AND p.id=a.pick_id " +
-        "JOIN ll_dispatch_pda_task t ON t.customer_id=p.customer_id AND t.id=p.task_id " +
+        "JOIN ll_dispatch_pda_task t ON t.id=p.task_id " +
         "WHERE a.customer_id=#{customerId} AND a.order_id=#{orderId} ORDER BY t.dispatch_order_id")
     List<Long> dispatchIds(@Param("customerId") String customerId, @Param("orderId") long orderId);
 
     @Select("SELECT d.id AS delivery_id,d.dispatch_order_id AS dispatch_id,d.delivery_group_key AS group_key," +
-        "d.package_count AS packages,d.signed_packages,d.signed_at,ds.depart_at AS departed_at FROM ll_delivery_order d " +
-        "LEFT JOIN ll_dispatch_order ds ON ds.customer_id=d.customer_id AND ds.id=d.dispatch_order_id " +
+        "d.package_count AS packages,d.signed_packages,d.signed_at,ds.departed_at AS departed_at FROM ll_delivery_order d " +
+        "LEFT JOIN ll_dispatch_order ds ON ds.id=d.dispatch_order_id " +
+        "AND EXISTS (SELECT 1 FROM ll_dispatch_item di_member WHERE di_member.dispatch_order_id=ds.id AND di_member.customer_id=d.customer_id) " +
         "WHERE d.customer_id=#{customerId} AND d.dispatch_order_id=#{dispatchId} ORDER BY d.id")
+    /** 头部不再代表单客户；由真实货物客户成员证明派送归属，保持单据客户过滤。 */
     List<Delivery> deliveries(@Param("customerId") String customerId, @Param("dispatchId") long dispatchId);
 
+    /** 共享任务下只读取同一真实客户的扫码、订单和回仓凭据，卸货组沿原权威规则生成。 */
     @Select("SELECT a.id AS attribution_id,t.dispatch_order_id AS dispatch_id," +
         "CASE WHEN di.destination_type='PRIVATE' AND NULLIF(TRIM(di.delivery_address),'') IS NOT NULL " +
         "THEN CONCAT('PRIVATE:',TRIM(di.delivery_address),':',TRIM(COALESCE(di.postal_code,''))) " +
@@ -38,7 +42,7 @@ public interface DeliverySourceEvidenceMapper {
         "WHEN NULLIF(TRIM(di.destination_warehouse_id),'') IS NOT NULL THEN CONCAT('ID:',TRIM(di.destination_warehouse_id)) ELSE NULL END AS group_key," +
         "a.order_id,a.packages,a.receipt_id,a.return_receipt_id,r.inventory_ledger_id AS return_ledger_id,r.received_packages AS return_packages FROM ll_dispatch_pda_pick_order a " +
         "JOIN ll_dispatch_pda_pick p ON p.customer_id=a.customer_id AND p.id=a.pick_id " +
-        "JOIN ll_dispatch_pda_task t ON t.customer_id=p.customer_id AND t.id=p.task_id " +
+        "JOIN ll_dispatch_pda_task t ON t.id=p.task_id " +
         "LEFT JOIN ll_dispatch_item di ON di.customer_id=p.customer_id AND di.id=p.dispatch_item_id AND di.dispatch_order_id=t.dispatch_order_id " +
         "LEFT JOIN ll_return_stock_receipt r ON r.customer_id=a.customer_id AND r.id=a.return_receipt_id AND r.order_id=a.order_id " +
         "AND EXISTS (SELECT 1 FROM ll_inventory_ledger rl JOIN ll_exception_order re ON re.customer_id=rl.customer_id " +

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/mapper/DispatchDeliveryArrangementMapper.java

@@ -0,0 +1,26 @@
+package com.baiyue.lastleg.delivery.mapper;
+
+import com.baiyue.lastleg.delivery.entity.DispatchDeliveryArrangement;
+import org.apache.ibatis.annotations.*;
+
+/** 整车唯一安排事实的持久化，不以客户出库头替代整车身份。 */
+@Mapper
+public interface DispatchDeliveryArrangementMapper {
+    /** 普通读组合预览中的当前安排事实。 */
+    @Select("SELECT * FROM ll_dispatch_delivery_arrangement WHERE dispatch_order_id=#{dispatchId}")
+    DispatchDeliveryArrangement find(@Param("dispatchId") long dispatchId);
+
+    /** 调用方先持共同父锁，再读取唯一安排。 */
+    @Select("SELECT * FROM ll_dispatch_delivery_arrangement WHERE dispatch_order_id=#{dispatchId} FOR UPDATE")
+    DispatchDeliveryArrangement lock(@Param("dispatchId") long dispatchId);
+
+    /** 单车、安排号及首次请求键均由唯一约束防重复。 */
+    @Insert("""
+        INSERT INTO ll_dispatch_delivery_arrangement
+          (id,dispatch_order_id,dispatch_no,arrangement_key,business_hash,cargo_hash,loading_completion_hash,
+           original_command_key,original_operator_id,result_json,cargo_json,created_at)
+        VALUES (#{id},#{dispatchOrderId},#{dispatchNo},#{arrangementKey},#{businessHash},#{cargoHash},
+                #{loadingCompletionHash},#{originalCommandKey},#{originalOperatorId},#{resultJson},#{cargoJson},#{createdAt})
+        """)
+    int insert(DispatchDeliveryArrangement arrangement);
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/mapper/OutboundOrderMapper.java

@@ -9,6 +9,14 @@ import java.util.List;
 
 @Mapper
 public interface OutboundOrderMapper extends BaseMapper<OutboundOrder> {
+    /** 整车跨客户读取全部出库单，不用第一张代表全车。 */
+    @Select("SELECT * FROM ll_outbound_order WHERE dispatch_order_id=#{dispatchId} ORDER BY LENGTH(customer_id),customer_id,id")
+    List<OutboundOrder> findAllByDispatch(@Param("dispatchId") long dispatchId);
+
+    /** 父锁后先收齐所有客户出库锁，再锁派送和来源。 */
+    @Select("SELECT * FROM ll_outbound_order WHERE dispatch_order_id=#{dispatchId} ORDER BY LENGTH(customer_id),customer_id,id FOR UPDATE")
+    List<OutboundOrder> lockAllByDispatch(@Param("dispatchId") long dispatchId);
+
     @Select("SELECT * FROM ll_outbound_order WHERE customer_id=#{customerId} AND outbound_no=#{outboundNo} LIMIT 1")
     OutboundOrder findByNo(@Param("customerId") String customerId, @Param("outboundNo") String outboundNo);
     @Select("SELECT * FROM ll_outbound_order WHERE outbound_no=#{outboundNo} LIMIT 1")

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/model/DeliveryCargoGroups.java

@@ -0,0 +1,98 @@
+package com.baiyue.lastleg.delivery.model;
+
+import com.baiyue.lastleg.dispatch.port.DispatchContracts.CargoLine;
+import com.baiyue.lastleg.dispatch.port.DispatchContracts.Context;
+import com.baiyue.lastleg.dispatch.port.DispatchContracts.Destination;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Component;
+import org.springframework.web.server.ResponseStatusException;
+import java.security.MessageDigest;
+import java.util.*;
+
+/** 整车按真实客户与目的地拆分，物理托盘和来源行分别统计。 */
+@Component
+public class DeliveryCargoGroups {
+    private final ObjectMapper json;
+
+    /** 使用服务统一序列化器计算稳定业务摘要。 */
+    public DeliveryCargoGroups(ObjectMapper json) { this.json=json; }
+
+    /** 本域分组结果不作为另一套公网DTO或跨域Entity。 */
+    public record Group(String key,String customerId,String customerName,Destination destination,
+                        String cargoHash,List<CargoLine> cargo,long packages,long palletCount) { }
+
+    /** 只接受完整真实拣货来源，不从展示入仓码或计划数补齐事实。 */
+    public List<Group> groups(Context context) {
+        if (context==null || context.counts()==null || context.cargo()==null || context.cargo().isEmpty())
+            throw conflict("排车单没有真实待派送货物");
+        var groups=new TreeMap<String,List<CargoLine>>();
+        var attributions=new HashSet<Long>();
+        var palletDestinations=new HashMap<Long,String>();
+        for (var row:context.cargo()) {
+            if (row==null || row.dispatchItemId()==null || row.dispatchItemId()<=0 || blank(row.customerId()) || "0".equals(row.customerId())
+                || row.orderId()==null || row.orderId()<=0 || row.packages()<=0 || row.pickId()==null || row.pickId()<=0 || row.attributionId()==null || row.attributionId()<=0
+                || blank(row.sourceKey()) || row.destination()==null || blank(row.destination().key()))
+                throw conflict("货物缺少真实客户、拣货或来源归属");
+            if ("RETURN_RELABEL".equals(row.sourceStage())
+                ? row.returnCartonId()==null || row.returnCartonId()<=0
+                : row.inventoryPositionId()==null || row.inventoryPositionId()<=0)
+                throw conflict("本次拣货缺少实际库存仓位或退货箱来源");
+            if (!attributions.add(row.attributionId())) throw conflict("本次派送包含重复拣货来源");
+            if (blank(row.destination().type()) || !Set.of("FBA","PRIVATE").contains(row.destination().type()))
+                throw conflict("货物派送目的地类型不完整");
+            if (row.warehousePalletId()!=null) {
+                var previous=palletDestinations.putIfAbsent(row.warehousePalletId(),row.destination().key());
+                if (previous!=null && !previous.equals(row.destination().key())) throw conflict("同一实物托盘不同目的地须先拆托");
+            }
+            if ("FBA".equals(row.destination().type()) && blank(row.destination().warehouseCode())
+                || "PRIVATE".equals(row.destination().type()) && blank(row.destination().address()))
+                throw conflict("货物缺少真实目的仓或派送地址");
+            groups.computeIfAbsent(groupKey(row.customerId(),row.destination()),ignored->new ArrayList<>()).add(row);
+        }
+        long total=context.cargo().stream().mapToLong(CargoLine::packages).reduce(0,Math::addExact);
+        if (!context.pickingReconciled() || total!=context.counts().packageCount()
+            || total!=context.counts().pickedPackageCount() && total!=context.counts().shippedPackageCount())
+            throw conflict("实际拣货来源与本车箱数尚未核平");
+        var result=new ArrayList<Group>();
+        for (var entry:groups.entrySet()) {
+            var rows=entry.getValue().stream().sorted(Comparator.comparing(CargoLine::dispatchItemId)
+                .thenComparing(CargoLine::attributionId)).toList();
+            var first=rows.get(0);
+            if (rows.stream().anyMatch(row->!Objects.equals(row.destination(),first.destination())))
+                throw conflict("同组货物的目的地信息不一致，请核对后安排");
+            long packages=rows.stream().mapToLong(CargoLine::packages).reduce(0,Math::addExact);
+            long pallets=rows.stream().map(CargoLine::warehousePalletId).filter(Objects::nonNull).distinct().count();
+            result.add(new Group(entry.getKey(),first.customerId(),first.customerName(),first.destination(),
+                hash(rows),rows,packages,pallets));
+        }
+        return List.copyOf(result);
+    }
+
+    /** 客户是组身份的一部分，同目的仓的其他客户永不合单。 */
+    public String groupKey(String customerId,Destination destination) {
+        return hash(List.of(customerId,destination.key()));
+    }
+
+    /** 本地派送来源证明沿用单据分组键，明确映射既有FBA和私人地址语义。 */
+    public String documentGroupKey(Destination destination) {
+        if ("PRIVATE".equals(destination.type()) && !blank(destination.address()))
+            return "PRIVATE:"+destination.address().trim()+":"+Objects.toString(destination.postalCode(),"").trim();
+        if ("FBA".equals(destination.type()) && !blank(destination.warehouseCode()))
+            return "CODE:"+destination.warehouseCode().trim().toUpperCase(Locale.ROOT);
+        throw conflict("派送目的地缺少真实业务标识");
+    }
+
+    /** 摘要仅使用规范化领域值，不包含操作者或偶然集合遍历顺序。 */
+    public String hash(Object value) {
+        try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(json.writeValueAsBytes(value))); }
+        catch (java.security.NoSuchAlgorithmException | com.fasterxml.jackson.core.JsonProcessingException error) {
+            throw new IllegalStateException("派送业务摘要生成失败",error);
+        }
+    }
+
+    /** 缺失业务事实直接阻断，不用内部编号回退展示。 */
+    private static boolean blank(String value) { return value==null || value.isBlank(); }
+    /** 业务冲突不产生部分单据。 */
+    private static ResponseStatusException conflict(String reason) { return new ResponseStatusException(HttpStatus.CONFLICT,reason); }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/model/NormalDeliveryCompletionPolicy.java

@@ -0,0 +1,53 @@
+package com.baiyue.lastleg.delivery.model;
+
+import com.baiyue.lastleg.dispatch.port.DispatchContracts.Context;
+import com.baiyue.lastleg.dispatch.port.DispatchDeliveryModels.*;
+import org.springframework.stereotype.Component;
+import java.time.Instant;
+import java.util.*;
+
+/** 五阶段只接受原实发全部正常签收，不将真实退回当作签收数量。 */
+@Component
+public class NormalDeliveryCompletionPolicy {
+    private final DeliveryCargoGroups hashes;
+
+    /** 复用本域确定性摘要器，不申请历史来源订单锁。 */
+    public NormalDeliveryCompletionPolicy(DeliveryCargoGroups hashes) { this.hashes=hashes; }
+
+    /** 按已安排单据精确集合和原实发数量核对，空集合不算完成。 */
+    public NormalDeliveryFacts evaluate(Context context,ArrangementResult arrangement,List<NormalDeliveryFact> actual,Instant now) {
+        var reasons=new ArrayList<String>();
+        var expected=arrangement==null?List.<DeliveryReference>of():arrangement.deliveries();
+        var seen=new HashMap<String,NormalDeliveryFact>();
+        if (context.departedAt()==null || now==null || context.departedAt().isAfter(now)) reasons.add("尚无有效实际发车事实");
+        if (expected==null || expected.isEmpty()) reasons.add("缺少本车已安排派送单");
+        for (var fact:actual) if (fact==null || fact.deliveryNo()==null || seen.putIfAbsent(fact.deliveryNo(),fact)!=null)
+            reasons.add("派送事实缺失或重复");
+        var expectedNos=expected==null?List.<String>of():expected.stream().map(DeliveryReference::deliveryNo).sorted().toList();
+        if (new HashSet<>(expectedNos).size()!=expectedNos.size() || !seen.keySet().equals(new HashSet<>(expectedNos)))
+            reasons.add("派送单未精确覆盖本车安排");
+        long total=0; Instant completedAt=null;
+        if (expected!=null) for (var reference:expected) {
+            var fact=seen.get(reference.deliveryNo());
+            if (fact==null) continue;
+            if (!Objects.equals(fact.customerId(),reference.customerId()) || !Objects.equals(fact.groupKey(),reference.groupKey())
+                || !Objects.equals(fact.outboundNo(),reference.outboundNo()) || fact.originalPackages()!=reference.packageCount())
+                reasons.add("派送客户、目的地或原实发来源不一致");
+            total=Math.addExact(total,fact.originalPackages());
+            // full签收字段是原运输事实；签后另退不重开，但签剩余/拒收/无签收永不冒充原全签。
+            if (!fact.outboundCompleted() || fact.status()==null || !Set.of("DELIVERED","RETURN_PENDING","RETURNED").contains(fact.status()) || fact.originalPackages()<=0
+                || fact.signedPackages()!=fact.originalPackages() || fact.signedAt()==null)
+                reasons.add("仍有货物未正常全部签收，异常或退回不能代替签收");
+            else if (context.departedAt()==null || fact.signedAt().isBefore(context.departedAt())
+                || now==null || fact.signedAt().isAfter(now)) reasons.add("签收时间与真实发车事实不一致");
+            else if (completedAt==null || fact.signedAt().isAfter(completedAt)) completedAt=fact.signedAt();
+        }
+        if (total<=0 || context.counts()==null || total!=context.counts().shippedPackageCount())
+            reasons.add("签收单据未完整覆盖本趟真实实发箱数");
+        var sorted=actual.stream().filter(Objects::nonNull).sorted(Comparator.comparing(NormalDeliveryFact::customerId,Comparator.nullsFirst(String::compareTo))
+            .thenComparing(NormalDeliveryFact::deliveryNo,Comparator.nullsFirst(String::compareTo))).toList();
+        boolean normal=reasons.isEmpty();
+        return new NormalDeliveryFacts(context.dispatchNo(),hashes.hash(Arrays.asList(context.dispatchNo(),expectedNos,sorted)),
+            normal,normal?completedAt:null,expectedNos,sorted,reasons.stream().distinct().toList());
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/repository/DeliveryCancellationRepository.java

@@ -0,0 +1,95 @@
+package com.baiyue.lastleg.delivery.repository;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baiyue.lastleg.delivery.entity.*;
+import com.baiyue.lastleg.delivery.mapper.*;
+import com.baiyue.lastleg.entity.LastlegOrder;
+import com.baiyue.lastleg.entity.LastlegOrderStatusHistory;
+import com.baiyue.lastleg.mapper.*;
+import com.baiyue.lastleg.relabel.entity.RelabelApplication;
+import com.baiyue.lastleg.relabel.mapper.RelabelApplicationMapper;
+import com.baiyue.lastleg.returnreceipt.entity.ReturnInventoryCarton;
+import com.baiyue.lastleg.returnreceipt.mapper.ReturnInventoryCartonMapper;
+import com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder;
+import com.baiyue.lastleg.transfer.mapper.WarehouseTransferOrderMapper;
+import org.springframework.stereotype.Repository;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Objects;
+
+/** 未执行出库取消的数据访问，业务资格与费用撤销仍由Service编排。 */
+@Repository
+public class DeliveryCancellationRepository {
+    private final OutboundOrderMapper outbounds;
+    private final OutboundPalletItemMapper items;
+    private final DeliveryOrderMapper deliveries;
+    private final OutboundPdaTaskMapper tasks;
+    private final DeliveryOperationMapper operations;
+    private final RelabelApplicationMapper relabels;
+    private final ReturnInventoryCartonMapper cartons;
+    private final WarehouseTransferOrderMapper transfers;
+    private final LastlegOrderMapper sources;
+    private final LastlegOrderStatusHistoryMapper histories;
+
+    /** 装配原领域Mapper，不能将SQL搬到取消Service。 */
+    public DeliveryCancellationRepository(OutboundOrderMapper outbounds,OutboundPalletItemMapper items,DeliveryOrderMapper deliveries,
+        OutboundPdaTaskMapper tasks,DeliveryOperationMapper operations,RelabelApplicationMapper relabels,
+        ReturnInventoryCartonMapper cartons,WarehouseTransferOrderMapper transfers,LastlegOrderMapper sources,LastlegOrderStatusHistoryMapper histories) {
+        this.outbounds=outbounds;this.items=items;this.deliveries=deliveries;this.tasks=tasks;this.operations=operations;
+        this.relabels=relabels;this.cartons=cartons;this.transfers=transfers;this.sources=sources;this.histories=histories;
+    }
+    /** 先普通定位真实父身份。 */
+    public OutboundOrder find(String no) { return outbounds.findGlobalByNo(no); }
+    /** 父级协调完成后才申请出库锁。 */
+    public OutboundOrder lock(String no) { return outbounds.lockGlobalByNo(no); }
+    /** 独立换标出库保留其原域确认锁。 */
+    public RelabelApplication lockRelabel(OutboundOrder order) { return relabels.lockByOutbound(order.getCustomerId(),order.getOutboundNo()); }
+    /** 子明细始终按出库客户读取。 */
+    public List<OutboundPalletItem> items(OutboundOrder order) { return items.findByOutbound(order.getCustomerId(),order.getId()); }
+    /** 一次取得本出库全部派送锁，不边持来源锁边锁下一张派送。 */
+    public List<DeliveryOrder> deliveries(OutboundOrder order) { return deliveries.lockByOutbound(order.getCustomerId(),order.getId()); }
+    /** 退货实际箱必须在原域锁内核对。 */
+    public ReturnInventoryCarton lockCarton(String mark) { return cartons.lockMark(mark); }
+    /** 只释放尚未执行的预留箱，不生成退库流水。 */
+    public void save(ReturnInventoryCarton value) { cartons.updateById(value); }
+    /** 更新已锁派送取消状态。 */
+    public void save(DeliveryOrder value) { deliveries.updateById(value); }
+    /** PDA任务与出库同事务取消。 */
+    public OutboundPdaTask task(OutboundOrder value) { return tasks.lockByOutbound(value.getCustomerId(),value.getId()); }
+    /** 保存已锁任务状态。 */
+    public void save(OutboundPdaTask value) { tasks.updateById(value); }
+    /** 保存已锁出库状态。 */
+    public void save(OutboundOrder value) { outbounds.updateById(value); }
+    /** 保存尚未执行的出库明细状态。 */
+    public void save(OutboundPalletItem value) { items.updateById(value); }
+    /** 锁原转仓单以恢复其明确业务状态。 */
+    public WarehouseTransferOrder lockTransfer(String customer,String no) { return transfers.lockNo(customer,no); }
+    /** 保存转仓恢复状态。 */
+    public void save(WarehouseTransferOrder value) { transfers.updateById(value); }
+    /** 相关来源在费用锁前以数字ID顺序锁定。 */
+    public LastlegOrder lockSource(String customer,long id) { return sources.lockById(customer,id); }
+    /** 来源候选一次读齐并固定顺序，不能按展示入仓码挑一票。 */
+    public List<LastlegOrder> sources(String customer,String outboundNo) {
+        return sources.selectList(new LambdaQueryWrapper<LastlegOrder>().eq(LastlegOrder::getCustomerId,customer)
+            .eq(LastlegOrder::getOutboundOrderNo,outboundNo).orderByAsc(LastlegOrder::getId));
+    }
+    /** 按真实转换历史恢复，而非统一写某个旧状态。 */
+    public LastlegOrderStatusHistory previous(String customer,long id,List<String> events) {
+        return histories.selectOne(new LambdaQueryWrapper<LastlegOrderStatusHistory>().eq(LastlegOrderStatusHistory::getCustomerId,customer)
+            .eq(LastlegOrderStatusHistory::getOrderId,id).in(LastlegOrderStatusHistory::getEventId,events)
+            .orderByAsc(LastlegOrderStatusHistory::getCreatedAt,LastlegOrderStatusHistory::getId).last("LIMIT 1"));
+    }
+    /** 显式清空业务关联并增加版本，防止MyBatis跳过null留下旧单号。 */
+    public boolean restore(LastlegOrder value,String outboundNo,String status,String subStatus,LocalDateTime now) {
+        return sources.update(null,new LambdaUpdateWrapper<LastlegOrder>().eq(LastlegOrder::getId,value.getId())
+            .eq(LastlegOrder::getCustomerId,value.getCustomerId()).eq(LastlegOrder::getOutboundOrderNo,outboundNo)
+            .set(LastlegOrder::getCurrentStatus,status).set(LastlegOrder::getSubOrderStatus,subStatus)
+            .set(LastlegOrder::getOutboundOrderNo,null).set(LastlegOrder::getDeliveryOrderNo,null)
+            .set(LastlegOrder::getVersion,Objects.requireNonNullElse(value.getVersion(),0)+1).set(LastlegOrder::getUpdatedAt,now))==1;
+    }
+    /** 保存不可变取消历史。 */
+    public void history(LastlegOrderStatusHistory value) { histories.insert(value); }
+    /** 完整原因由业务层分段保存，不截断丢失。 */
+    public void operation(DeliveryOperation value) { operations.insert(value); }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/repository/DeliveryDocumentRepository.java

@@ -0,0 +1,65 @@
+package com.baiyue.lastleg.delivery.repository;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baiyue.lastleg.delivery.entity.*;
+import com.baiyue.lastleg.delivery.mapper.*;
+import com.baiyue.lastleg.delivery.model.DeliveryReturnReceiptFact;
+import com.baiyue.lastleg.delivery.model.SourceDeliveryCompletionPolicy;
+import com.baiyue.lastleg.entity.LastlegOrder;
+import com.baiyue.lastleg.mapper.LastlegOrderMapper;
+import org.springframework.stereotype.Repository;
+import java.util.Collection;
+import java.util.List;
+
+/** 派送资料及签收关联的数据访问，业务事务和来源证明由Service编排。 */
+@Repository
+public class DeliveryDocumentRepository {
+    private final DeliveryOrderMapper orders;
+    private final OutboundOrderMapper outbounds;
+    private final DeliveryDocumentRevisionMapper revisions;
+    private final DeliveryOperationMapper operations;
+    private final LastlegOrderMapper sources;
+    private final DeliverySourceEvidenceMapper evidence;
+
+    /** 装配各表Mapper，不在资料服务直接访问持久化接口。 */
+    public DeliveryDocumentRepository(DeliveryOrderMapper orders, OutboundOrderMapper outbounds,
+        DeliveryDocumentRevisionMapper revisions, DeliveryOperationMapper operations,
+        LastlegOrderMapper sources, DeliverySourceEvidenceMapper evidence) {
+        this.orders=orders; this.outbounds=outbounds; this.revisions=revisions;
+        this.operations=operations; this.sources=sources; this.evidence=evidence;
+    }
+
+    /** 客户和派送号共同定位资料单。 */
+    public DeliveryOrder find(String customerId, String no) { return orders.findByNo(customerId,no); }
+    /** 签收先锁自己的派送，随后才能申请来源订单锁。 */
+    public DeliveryOrder lock(String customerId, String no) { return orders.lockByNo(customerId,no); }
+    /** 出库事实普通读，避免在派送锁之后反向申请出库锁。 */
+    public OutboundOrder outbound(String customerId, String no) { return outbounds.findByNo(customerId,no); }
+    /** 读取当前资料命令以保持原请求重放语义。 */
+    public DeliveryDocumentRevision command(String customerId,long id,String key) { return revisions.findCommand(customerId,id,key); }
+    /** 保存已校验的资料和签收字段。 */
+    public void save(DeliveryOrder order) { orders.updateById(order); }
+    /** 同事务保存不可变资料版本。 */
+    public void revision(DeliveryDocumentRevision revision) { revisions.insert(revision); }
+    /** 同事务保存业务历史。 */
+    public void operation(DeliveryOperation operation) { operations.insert(operation); }
+    /** 读取资料版本历史，不暴露其他客户附件。 */
+    public List<DeliveryDocumentRevision> history(String customerId,long id) { return revisions.history(customerId,id); }
+    /** 签收仍需拒绝未完成的真实退回流程。 */
+    public long activeReturns(String customerId,long id) { return operations.activeReturns(customerId,id); }
+    /** 只读取本派送的真实退回入账事实。 */
+    public List<DeliveryReturnReceiptFact> returns(String customerId,long id) { return operations.returnReceipts(customerId,id); }
+    /** 拣货来源按真实客户与整车读取，不拿当前订单指针替代历史。 */
+    public List<SourceDeliveryCompletionPolicy.Pick> picks(String customerId,long dispatchId) { return evidence.picks(customerId,dispatchId); }
+    /** 批量读取候选来源，再由Service复核客户归属。 */
+    public List<LastlegOrder> sourceOrders(Collection<Long> ids) { return ids.isEmpty()?List.of():sources.selectBatchIds(ids); }
+    /** 非头程本地单据仍读取其本客户的既有当前关系。 */
+    public List<LastlegOrder> locallyLinked(String customerId,String deliveryNo) {
+        return sources.selectList(new LambdaQueryWrapper<LastlegOrder>().eq(LastlegOrder::getCustomerId,customerId)
+            .eq(LastlegOrder::getDeliveryOrderNo,deliveryNo));
+    }
+    /** 来源锁由证明服务持有后重新读取当前行，避免旧快照覆盖。 */
+    public LastlegOrder source(long id) { return sources.selectById(id); }
+    /** 只保存Service根据真实来源签收证明得到的子状态。 */
+    public void saveSource(LastlegOrder order) { sources.updateById(order); }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/repository/DeliveryFactsChangedRepository.java

@@ -0,0 +1,50 @@
+package com.baiyue.lastleg.delivery.repository;
+
+import com.baiyue.lastleg.delivery.entity.DeliveryFactsChanged;
+import com.baiyue.lastleg.delivery.mapper.DeliveryFactsChangedMapper;
+import com.baiyue.lastleg.delivery.mapper.DeliveryOrderMapper;
+import com.baiyue.lastleg.delivery.entity.DeliveryOrder;
+import org.springframework.stereotype.Repository;
+import java.time.LocalDateTime;
+import java.util.List;
+
+/** 信号持久化由派送域维护，主流程经正式端口消费。 */
+@Repository
+public class DeliveryFactsChangedRepository {
+    private final DeliveryFactsChangedMapper mapper;
+    private final DeliveryOrderMapper deliveries;
+
+    /** 装配唯一的MyBatis数据入口。 */
+    public DeliveryFactsChangedRepository(DeliveryFactsChangedMapper mapper, DeliveryOrderMapper deliveries) {
+        this.mapper = mapper; this.deliveries = deliveries;
+    }
+
+    /** 公共信号端口只认整车和派送号对应的唯一真实单据。 */
+    public List<DeliveryOrder> deliveries(String dispatchNo, String deliveryNo) {
+        return deliveries.findForSignal(dispatchNo, deliveryNo);
+    }
+
+    /** 确认前复核信号原身份，普通读不反向申请父锁。 */
+    public DeliveryFactsChanged find(long id) { return mapper.findById(id); }
+
+    /** 保存一次事实并返回当前唯一版本供业务校验。 */
+    public DeliveryFactsChanged insertOnce(DeliveryFactsChanged fact) {
+        mapper.insertOnce(fact);
+        return mapper.find(fact.getCustomerId(), fact.getDeliveryId(), fact.getDeliveryVersion());
+    }
+
+    /** 有界普通扫描，不在此处持有父锁前的子行锁。 */
+    public List<DeliveryFactsChanged> pending(LocalDateTime now, int limit) {
+        return mapper.pending(now, limit);
+    }
+
+    /** 只确认调用方已经核对的指定信号与排车身份。 */
+    public int acknowledge(long id, long dispatchId, LocalDateTime now) {
+        return mapper.acknowledge(id, dispatchId, now);
+    }
+
+    /** 记录可重试失败且保留PENDING，不能覆盖已成功确认的信号。 */
+    public void failed(long id, String code, LocalDateTime nextAttemptAt) {
+        mapper.failed(id, code, nextAttemptAt);
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/repository/DispatchDeliveryRepository.java

@@ -0,0 +1,71 @@
+package com.baiyue.lastleg.delivery.repository;
+
+import com.baiyue.lastleg.delivery.entity.*;
+import com.baiyue.lastleg.delivery.mapper.*;
+import com.baiyue.lastleg.entity.LastlegOrder;
+import com.baiyue.lastleg.entity.LastlegOrderStatusHistory;
+import com.baiyue.lastleg.mapper.LastlegOrderMapper;
+import com.baiyue.lastleg.mapper.LastlegOrderStatusHistoryMapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+
+/** 整车派送数据访问；锁顺序明确区分子单和来源，不直写主流程表。 */
+@Repository
+public class DispatchDeliveryRepository {
+    private final DispatchDeliveryArrangementMapper arrangements;
+    private final OutboundOrderMapper outbounds;
+    private final OutboundPalletItemMapper items;
+    private final DeliveryOrderMapper deliveries;
+    private final DeliveryOperationMapper operations;
+    private final LastlegOrderMapper sources;
+    private final LastlegOrderStatusHistoryMapper histories;
+
+    /** 装配派送域唯一持久化入口。 */
+    public DispatchDeliveryRepository(DispatchDeliveryArrangementMapper arrangements,OutboundOrderMapper outbounds,
+        OutboundPalletItemMapper items,DeliveryOrderMapper deliveries,DeliveryOperationMapper operations,
+        LastlegOrderMapper sources,LastlegOrderStatusHistoryMapper histories) {
+        this.arrangements=arrangements;this.outbounds=outbounds;this.items=items;
+        this.deliveries=deliveries;this.operations=operations;
+        this.sources=sources;this.histories=histories;
+    }
+    /** 父锁外预览仅普通读安排事实。 */
+    public DispatchDeliveryArrangement arrangement(long id,boolean lock) { return lock?arrangements.lock(id):arrangements.find(id); }
+    /** 固定顺序取得或读取全部客户出库。 */
+    public List<OutboundOrder> outbounds(long id,boolean lock) { return lock?outbounds.lockAllByDispatch(id):outbounds.findAllByDispatch(id); }
+    /** 仅在取得全体出库锁之后取得全体派送锁。 */
+    public List<DeliveryOrder> deliveries(long id,boolean lock) { return lock?deliveries.lockAllByDispatch(id):deliveries.findAllByDispatch(id); }
+    /** 一次安排仅插入一个客户自己的出库头。 */
+    public void create(OutboundOrder value) { outbounds.insert(value); }
+    /** 不可变出库来源明细在同一安排事务保存。 */
+    public void create(OutboundPalletItem value) { items.insert(value); }
+    /** 每客户目的地分别保存派送单。 */
+    public void create(DeliveryOrder value) { deliveries.insert(value); }
+    /** 仅更新已锁定并复验的客户出库执行事实。 */
+    public void save(OutboundOrder value) { outbounds.updateById(value); }
+    /** 仅更新已锁定并复验的客户派送执行事实。 */
+    public void save(DeliveryOrder value) { deliveries.updateById(value); }
+    /** 最后保存单车唯一安排，失败整体回滚不留半车。 */
+    public void create(DispatchDeliveryArrangement value) { arrangements.insert(value); }
+    /** 保存真实业务操作事实，不将零约定冒充费用。 */
+    public void operation(DeliveryOperation value) { operations.insert(value); }
+    /** 正常完成只普通读当前异常数量，不反向锁历史来源。 */
+    public long activeReturns(DeliveryOrder value) { return operations.activeReturns(value.getCustomerId(),value.getId()); }
+    /** 只读取本派送真实退回流水。 */
+    public List<com.baiyue.lastleg.delivery.model.DeliveryReturnReceiptFact> returns(DeliveryOrder value) {
+        return operations.returnReceipts(value.getCustomerId(),value.getId());
+    }
+    /** 全部子单锁已收齐后，才按来源数字ID固定顺序申请来源锁。 */
+    public LastlegOrder lockSource(String customerId,long id) { return sources.lockById(customerId,id); }
+    /** 多目的地来源不借一张派送单冒充全部关联，完整归属保留在安排来源快照。 */
+    public void bindSource(LastlegOrder source,String outboundNo,String deliveryNo,java.time.LocalDateTime now) {
+        if (sources.update(null,new LambdaUpdateWrapper<LastlegOrder>().eq(LastlegOrder::getId,source.getId())
+            .eq(LastlegOrder::getCustomerId,source.getCustomerId()).set(LastlegOrder::getOutboundOrderNo,outboundNo)
+            .set(LastlegOrder::getDeliveryOrderNo,deliveryNo)
+            .set(LastlegOrder::getSubOrderStatus,"OUTBOUND:WAIT_OUTBOUND;DELIVERY:WAIT_DELIVERY")
+            .set(LastlegOrder::getVersion,java.util.Objects.requireNonNullElse(source.getVersion(),0)+1)
+            .set(LastlegOrder::getUpdatedAt,now))!=1) throw new IllegalStateException("派送来源绑定已变化");
+    }
+    /** 保存原状态事实供正式未执行取消核对，不把主流程状态改成派送子状态。 */
+    public void sourceHistory(LastlegOrderStatusHistory value) { histories.insert(value); }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/service/DeliveryDocumentService.java

@@ -5,12 +5,10 @@ import com.baiyue.lastleg.delivery.dto.DeliveryDocumentDtos;
 import com.baiyue.lastleg.delivery.dto.DeliveryDocumentDtos.*;
 import com.baiyue.lastleg.delivery.entity.*;
 import com.baiyue.lastleg.delivery.gateway.DeliveryDocumentFileGateway;
-import com.baiyue.lastleg.delivery.mapper.*;
+import com.baiyue.lastleg.delivery.repository.DeliveryDocumentRepository;
 import com.baiyue.lastleg.delivery.model.*;
 import com.baiyue.lastleg.customervisit.service.CustomerVisitService;
 import com.baiyue.lastleg.entity.LastlegOrder;
-import com.baiyue.lastleg.mapper.LastlegOrderMapper;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import jakarta.annotation.Resource;
@@ -28,20 +26,18 @@ import java.util.*;
 @Service
 public class DeliveryDocumentService {
     @Resource private com.baiyue.lastleg.fleet.business.FleetPoolOrderBridge fleetPool;
-    @Resource private DeliveryOrderMapper orders;
-    @Resource private OutboundOrderMapper outboundOrders;
-    @Resource private DeliveryDocumentRevisionMapper revisions;
-    @Resource private DeliveryOperationMapper operations;
+    @Resource private DeliveryDocumentRepository repository;
+    @Resource private com.baiyue.lastleg.dispatch.port.DispatchSignalPort signals;
     @Resource private DeliveryDocumentFileGateway files;
     @Resource private ObjectMapper objectMapper;
-    @Resource private LastlegOrderMapper lastlegOrders;
     @Resource private DeliveryCompletedOutboxService deliveryCompletedOutbox;
     @Resource private CustomerVisitService customerVisits;
     @Resource private SourceDeliveryCompletionQuery sourceCompletion;
-    @Resource private DeliverySourceEvidenceMapper sourceEvidence;
 
+    /** 客户和派送号共同定位当前资料。 */
     public Detail detail(String customerId, String deliveryNo) { return detail(require(customerId, deliveryNo), false); }
 
+    /** 客户只查看本客户派送的签收类附件，不返回其他资料。 */
     public MerchantReceipts merchantReceipts(String customerId, String deliveryNo) {
         Detail snapshot = detail(customerId, deliveryNo);
         return new MerchantReceipts(snapshot.deliveryNo(), snapshot.categories().stream()
@@ -49,23 +45,25 @@ public class DeliveryDocumentService {
             .flatMap(category -> category.files().stream()).toList());
     }
 
+    /** 下载仍复核业务与类别归属，不放开文件公共访问。 */
     public Download merchantReceiptDownload(String customerId, String deliveryNo, long fileId) {
         return download(customerId, deliveryNo, DeliveryDocumentCategory.RECEIPT, fileId, null);
     }
 
+    /** 上传准备不等于资料保存或真实签收完成。 */
     public DeliveryDocumentDtos.File upload(String customerId, String deliveryNo, DeliveryDocumentCategory category,
                                             String operatorId, MultipartFile file) {
         DeliveryOrder order = require(customerId, deliveryNo);
         return files.upload(customerId, order.getId(), category, operatorId, file);
     }
 
-    /** Lock the same aggregate as status commands, validate the whole set, then commit one snapshot. */
+    /** 先锁本派送并校验全部资料，签收及本地待汇总事实在同一事务提交。 */
     @Transactional(isolation = org.springframework.transaction.annotation.Isolation.READ_COMMITTED)
     public Detail save(String customerId, String deliveryNo, String operatorId, Save request) {
-        DeliveryOrder order = orders.lockByNo(customerId, deliveryNo);
+        DeliveryOrder order = repository.lock(customerId, deliveryNo);
         if (order == null) throw missing();
         String hash = hash(request);
-        DeliveryDocumentRevision replay = revisions.findCommand(customerId, order.getId(), request.idempotencyKey());
+        DeliveryDocumentRevision replay = repository.command(customerId, order.getId(), request.idempotencyKey());
         if (replay != null) {
             if (!hash.equals(replay.getRequestHash())) throw conflict("相同幂等键的派送资料内容不同");
             Detail saved = read(replay.getSnapshotJson());
@@ -96,11 +94,11 @@ public class DeliveryDocumentService {
         if (autoCompleted) {
             if (!DeliveryStatusPolicy.canTransition(order.getStatus(), "DELIVERED") && !"RETURN_PENDING".equals(order.getStatus()))
                 throw conflict("当前派送状态不允许通过签收文件完成");
-            // A read avoids reversing outbound -> delivery lock order. An uncommitted departure remains ineligible.
-            var outbound = outboundOrders.findByNo(customerId, order.getOutboundNo());
+            // 派送锁内只普通读出库，未提交的发车不构成真实出库资格，也不反向申请父锁。
+            var outbound = repository.outbound(customerId, order.getOutboundNo());
             if (outbound == null || !"OUTBOUNDED".equals(outbound.getStatus())) throw conflict("请先完成实际出库，再保存签收资料完成派送");
-            if (operations.activeReturns(customerId, order.getId()) != 0) throw conflict("请先完成或取消正在处理的退回异常，再确认剩余货物签收");
-            try { signedPackages = DeliveryCargoQuantities.from(order, operations.returnReceipts(customerId, order.getId())).remaining(); }
+            if (repository.activeReturns(customerId, order.getId()) != 0) throw conflict("请先完成或取消正在处理的退回异常，再确认剩余货物签收");
+            try { signedPackages = DeliveryCargoQuantities.from(order, repository.returns(customerId, order.getId())).remaining(); }
             catch (IllegalArgumentException error) { throw conflict(error.getMessage()); }
             if (signedPackages <= 0) throw conflict("本次派送已无待签收货物");
         }
@@ -113,7 +111,7 @@ public class DeliveryDocumentService {
             order.setSignedAt(now);
             order.setSignedPackages(signedPackages);
         }
-        orders.updateById(order);
+        repository.save(order);
         if (autoCompleted) {
             var completion = completeRelatedOrders(order, operatorId, now);
             fleetPool.signed(new SignedDelivery(
@@ -121,29 +119,34 @@ public class DeliveryDocumentService {
                 completion.sourcePackages(),operatorId,now);
             deliveryCompletedOutbox.publish(order, completion.orders(), completion.proofs(), now.atZone(executionZone).toInstant());
             customerVisits.ensureForCompletedDelivery(order, now);
+            // 只写持久信号；主流程提交后另事务汇总，不能在此持子锁回调父流程。
+            if (order.getDispatchOrderId() != null) signals.enqueue(order.getDispatchNo(), order.getDeliveryNo(),
+                order.getVersion(), now.atZone(executionZone).toInstant());
         }
         Detail result = detail(order, false);
         DeliveryDocumentRevision revision = new DeliveryDocumentRevision();
         revision.setCustomerId(customerId); revision.setDeliveryOrderId(order.getId()); revision.setVersion(order.getVersion());
         revision.setIdempotencyKey(request.idempotencyKey()); revision.setRequestHash(hash); revision.setSnapshotJson(write(result));
-        revision.setOperatorId(operatorId); revision.setCreatedAt(now); revisions.insert(revision);
+        revision.setOperatorId(operatorId); revision.setCreatedAt(now); repository.revision(revision);
         DeliveryOperation operation = new DeliveryOperation();
         operation.setCustomerId(customerId); operation.setDeliveryOrderId(order.getId()); operation.setOperatorId(operatorId);
         operation.setOperationNode("SAVE_DOCUMENTS"); operation.setResult("保存派送资料：" + result.uploadedCategoryCount() + "/3类");
-        operation.setCreatedAt(now); operations.insert(operation);
+        operation.setCreatedAt(now); repository.operation(operation);
         if (autoCompleted) recordAutomaticCompletion(order, operatorId, now);
         return result;
     }
+    /** 资料历史保持不可变版本并受原客户范围约束。 */
     public List<History> history(String customerId, String deliveryNo) {
         DeliveryOrder order = require(customerId, deliveryNo);
-        return revisions.history(customerId, order.getId()).stream().map(revision -> new History(revision.getVersion(),
+        return repository.history(customerId, order.getId()).stream().map(revision -> new History(revision.getVersion(),
             revision.getOperatorId(), revision.getCreatedAt(), read(revision.getSnapshotJson()))).toList();
     }
+    /** 当前或历史附件必须确实绑定在本派送对应资料版本。 */
     public Download download(String customerId, String deliveryNo, DeliveryDocumentCategory category, long fileId, Long revisionVersion) {
         DeliveryOrder order = require(customerId, deliveryNo);
         Detail snapshot = detail(order, false);
         if (revisionVersion != null) {
-            snapshot = revisions.history(customerId, order.getId()).stream().filter(r -> revisionVersion.equals(r.getVersion()))
+            snapshot = repository.history(customerId, order.getId()).stream().filter(r -> revisionVersion.equals(r.getVersion()))
                 .findFirst().map(r -> read(r.getSnapshotJson())).orElseThrow(DeliveryDocumentService::missing);
         }
         DeliveryDocumentDtos.File file = snapshot.categories().stream().filter(c -> c.category() == category)
@@ -152,36 +155,39 @@ public class DeliveryDocumentService {
         return new Download(file, files.download(customerId, order.getId(), category, fileId));
     }
     public record Download(DeliveryDocumentDtos.File file, byte[] content) { }
+    /** 业务编号不属于当前客户时按不存在处理。 */
     private DeliveryOrder require(String customerId, String deliveryNo) {
-        DeliveryOrder order = orders.findByNo(customerId, deliveryNo);
+        DeliveryOrder order = repository.find(customerId, deliveryNo);
         if (order == null) throw missing();
         return order;
     }
+    /** 三类资料只读投影不根据附件数量推断库存或整车阶段。 */
     private Detail detail(DeliveryOrder order, boolean replayed) {
         List<Category> categories = DeliveryDocumentSnapshot.categories(order.getDocumentsJson());
         return new Detail(order.getDeliveryNo(), order.getCustomerId(), version(order), order.getBolNo(),
             (int) categories.stream().filter(c -> !c.files().isEmpty()).count(), 3, categories, List.of("MANAGE_DOCUMENTS"), replayed);
     }
+    /** 原始单据版本0有效，后续保存按版本增加。 */
     private static long version(DeliveryOrder order) { return Objects.requireNonNullElse(order.getVersion(), 0L); }
     private record Completion(List<LastlegOrder> orders, Map<String, SourceDeliveryCompletionPolicy.Result> proofs,
                               Map<Long,Long> sourcePackages) { }
+    /** 先根据真实拣货收齐来源，再按跨趟来源锁协议证明正常签收。 */
     private Completion completeRelatedOrders(DeliveryOrder delivery, String operatorId, LocalDateTime now) {
         var related = new TreeMap<Long, LastlegOrder>();
         Map<Long,Long> sourcePackages = new TreeMap<>();
         if (delivery.getDispatchOrderId() != null) {
-            var actualPicks = sourceEvidence.picks(delivery.getCustomerId(), delivery.getDispatchOrderId()).stream()
+            var actualPicks = repository.picks(delivery.getCustomerId(), delivery.getDispatchOrderId()).stream()
                 .filter(p -> Objects.equals(p.groupKey(), delivery.getDeliveryGroupKey())).toList();
             for (var pick : actualPicks) sourcePackages.merge(pick.orderId(), pick.packages(), Math::addExact);
             var ids = actualPicks.stream()
                 .map(SourceDeliveryCompletionPolicy.Pick::orderId).distinct().toList();
-            if (!ids.isEmpty()) for (var tail : lastlegOrders.selectBatchIds(ids)) {
+            if (!ids.isEmpty()) for (var tail : repository.sourceOrders(ids)) {
                 if (!delivery.getCustomerId().equals(tail.getCustomerId())) throw conflict("派送来源客户归属不一致");
                 related.put(tail.getId(), tail);
             }
         }
-        // Non-dispatch local workflows retain their established relation; never use this to prove a domestic source.
-        for (var tail : lastlegOrders.selectList(new LambdaQueryWrapper<LastlegOrder>()
-            .eq(LastlegOrder::getCustomerId, delivery.getCustomerId()).eq(LastlegOrder::getDeliveryOrderNo, delivery.getDeliveryNo()))) {
+        // 本地非排车单保留既有关系，不能把当前指针当作头程全来源签收证明。
+        for (var tail : repository.locallyLinked(delivery.getCustomerId(), delivery.getDeliveryNo())) {
             if (!DeliveryCompletedOutboxService.domestic(tail)) related.putIfAbsent(tail.getId(),tail);
             else if (!related.containsKey(tail.getId())) pendingCompletion(delivery, operatorId, now,
                 inboundLabel(tail) + "：缺少历史实际拣货来源，未发布整来源签收事件");
@@ -190,10 +196,10 @@ public class DeliveryDocumentService {
             .map(LastlegOrder::getSourceInboundId).distinct().toList();
         var proofs = sourceIds.isEmpty() ? Map.<String,SourceDeliveryCompletionPolicy.Result>of()
             : sourceCompletion.proveAll(delivery.getCustomerId(),sourceIds);
-        // All source locks are now held. Re-read current rows instead of overwriting with pre-lock snapshots.
+        // 来源锁已按证明协议持有，重新读取当前行，不能用加锁前快照覆盖并发签收。
         var current = new ArrayList<LastlegOrder>();
         for (long id : related.keySet()) {
-            var tail = lastlegOrders.selectById(id);
+            var tail = repository.source(id);
             if (tail == null || !delivery.getCustomerId().equals(tail.getCustomerId())) throw conflict("派送来源已变化");
             if (DeliveryCompletedOutboxService.domestic(tail)) {
                 var proof = proofs.get(tail.getSourceInboundId());
@@ -205,38 +211,47 @@ public class DeliveryDocumentService {
                 }
             } else tail.setSubOrderStatus(Objects.equals(delivery.getSignedPackages(),delivery.getPackageCount())
                 ? "OUTBOUND:OUTBOUNDED;DELIVERY:DELIVERED" : "OUTBOUND:OUTBOUNDED;DELIVERY:PARTIALLY_RETURNED");
-            tail.setUpdatedAt(now); lastlegOrders.updateById(tail); current.add(tail);
+            tail.setUpdatedAt(now); repository.saveSource(tail); current.add(tail);
         }
         return new Completion(List.copyOf(current),proofs,Map.copyOf(sourcePackages));
     }
+    /** 入仓业务号缺失明确显示空值标记，不显示内部ID。 */
     private static String inboundLabel(LastlegOrder order) { return order.getInboundCode()==null || order.getInboundCode().isBlank() ? "—" : order.getInboundCode(); }
+    /** 未核齐的来源只保留诊断事实，不伪造全来源完成。 */
     private void pendingCompletion(DeliveryOrder delivery, String operatorId, LocalDateTime now, String reason) {
         var operation = new DeliveryOperation(); operation.setCustomerId(delivery.getCustomerId());
         operation.setDeliveryOrderId(delivery.getId()); operation.setOperatorId(operatorId);
         operation.setOperationNode("FIRSTLEG_COMPLETION_PENDING"); operation.setResult(reason);
-        operation.setCreatedAt(now); operations.insert(operation);
+        operation.setCreatedAt(now); repository.operation(operation);
     }
+    /** 保存本次实际签收箱数，真实退回不得混入签收数量。 */
     private void recordAutomaticCompletion(DeliveryOrder order, String operatorId, LocalDateTime now) {
         DeliveryOperation operation = new DeliveryOperation();
         operation.setCustomerId(order.getCustomerId()); operation.setDeliveryOrderId(order.getId());
         operation.setOperatorId(operatorId); operation.setOperatorName(operatorId);
         operation.setOperationNode("RECEIPT_AUTO_COMPLETE");
         operation.setResult("签收文件保存成功，本次实际签收" + order.getSignedPackages() + "箱；原实发" + order.getPackageCount() + "箱");
-        operation.setCreatedAt(now); operations.insert(operation);
+        operation.setCreatedAt(now); repository.operation(operation);
     }
+    /** 资料原请求以严格载荷摘要重放，版本和文件集合不得改写。 */
     private String hash(Object value) {
         try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(write(value).getBytes(StandardCharsets.UTF_8))); }
         catch (NoSuchAlgorithmException e) { throw new IllegalStateException(e); }
     }
+    /** 资料与操作结果必须可持久化，否则同事务回滚。 */
     private String write(Object value) {
         try { return objectMapper.writeValueAsString(value); }
         catch (JsonProcessingException e) { throw new IllegalStateException("无法保存派送资料", e); }
     }
+    /** 损坏历史直接阻断，不回退为当前资料成功。 */
     private Detail read(String value) {
         try { return objectMapper.readValue(value, Detail.class); }
         catch (JsonProcessingException e) { throw new IllegalStateException("派送资料历史损坏", e); }
     }
+    /** 隐藏不存在或不属于本客户的业务资料。 */
     private static ResponseStatusException missing() { return new ResponseStatusException(HttpStatus.NOT_FOUND, "派送单或已绑定资料不存在"); }
+    /** 同版本竞争或业务资格变化要求刷新核对。 */
     private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT, message); }
+    /** 参数范围不合法时不产生任何资料变更。 */
     private static ResponseStatusException bad(String message) { return new ResponseStatusException(HttpStatus.BAD_REQUEST, message); }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/service/DeliveryFactsChangedService.java

@@ -0,0 +1,118 @@
+package com.baiyue.lastleg.delivery.service;
+
+import com.baomidou.mybatisplus.core.toolkit.IdWorker;
+import com.baiyue.lastleg.delivery.entity.DeliveryFactsChanged;
+import com.baiyue.lastleg.delivery.entity.DeliveryOrder;
+import com.baiyue.lastleg.delivery.repository.DeliveryFactsChangedRepository;
+import com.baiyue.lastleg.dispatch.port.DispatchSignalPort;
+import com.baiyue.lastleg.dispatch.port.DispatchDeliveryModels.Signal;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.time.LocalDateTime;
+import java.time.Instant;
+import java.time.ZoneId;
+import java.util.HexFormat;
+import java.util.List;
+import java.util.Objects;
+
+/** 签收只写持久信号，绝不持派送子锁回调整车完成服务。 */
+@Service
+public class DeliveryFactsChangedService implements DispatchSignalPort {
+    private final DeliveryFactsChangedRepository repository;
+    private final ObjectMapper json;
+
+    /** 装配事实持久化和确定性序列化。 */
+    public DeliveryFactsChangedService(DeliveryFactsChangedRepository repository, ObjectMapper json) {
+        this.repository = repository;
+        this.json = json;
+    }
+
+    /** 直接消费主流程实际骨架，信号仅在原签收事务内持久化。 */
+    @Override
+    @Transactional(propagation = Propagation.MANDATORY)
+    public void enqueue(String dispatchNo, String deliveryNo, long deliveryVersion, Instant occurredAt) {
+        if (blank(dispatchNo) || blank(deliveryNo) || occurredAt == null) throw new IllegalArgumentException("签收信号身份不完整");
+        var rows = repository.deliveries(dispatchNo, deliveryNo);
+        if (rows.size() != 1 || !Objects.equals(rows.get(0).getVersion(), deliveryVersion))
+            throw new IllegalStateException("签收信号与当前真实派送版本不一致");
+        signed(rows.get(0), LocalDateTime.ofInstant(occurredAt, ZoneId.systemDefault()));
+    }
+
+    /** 有界普通读取候选，不在父汇总事务前领取或锁定信号。 */
+    @Override
+    @Transactional(readOnly = true)
+    public List<Signal> due(Instant now, int limit) {
+        if (now == null || limit < 1 || limit > 200) throw new IllegalArgumentException("信号扫描范围不合法");
+        return repository.pending(LocalDateTime.ofInstant(now, ZoneId.systemDefault()), limit).stream()
+            .map(f -> new Signal(f.getId(),f.getDispatchNo(),f.getDeliveryNo(),f.getDeliveryVersion(),
+                f.getAttemptCount(),f.getNextAttemptAt().atZone(ZoneId.systemDefault()).toInstant())).toList();
+    }
+
+    /** 与主阶段CAS共同提交指定信号确认，不能提前确认后来产生的版本。 */
+    @Override
+    @Transactional(propagation = Propagation.MANDATORY)
+    public void acknowledge(Signal signal, Instant acknowledgedAt) {
+        var stored = requireSignal(signal);
+        if (acknowledgedAt == null) throw new IllegalArgumentException("信号确认时间不能为空");
+        repository.acknowledge(stored.getId(),stored.getDispatchId(),LocalDateTime.ofInstant(acknowledgedAt,ZoneId.systemDefault()));
+    }
+
+    /** 调用方汇总回滚后独立记录退避，已确认的信号不会退回PENDING。 */
+    @Override
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    public void failed(Signal signal, Instant nextRetryAt, String errorCode) {
+        var stored = requireSignal(signal);
+        if (nextRetryAt == null || errorCode == null || !errorCode.matches("[A-Z0-9_]{1,64}"))
+            throw new IllegalArgumentException("信号重试信息不合法");
+        repository.failed(stored.getId(),errorCode,LocalDateTime.ofInstant(nextRetryAt,ZoneId.systemDefault()));
+    }
+
+    /** 只允许操作扫描时的真实业务身份，不凭一个内部ID修改别的信号。 */
+    private DeliveryFactsChanged requireSignal(Signal signal) {
+        if (signal == null || signal.signalId() == null) throw new IllegalArgumentException("信号不能为空");
+        var stored = repository.find(signal.signalId());
+        if (stored == null || !Objects.equals(stored.getDispatchNo(),signal.dispatchNo())
+            || !Objects.equals(stored.getDeliveryNo(),signal.deliveryNo())
+            || !Objects.equals(stored.getDeliveryVersion(),signal.deliveryVersion()))
+            throw new IllegalStateException("信号原业务身份不一致");
+        return stored;
+    }
+
+    /** 与签收共同提交唯一版本，缺失真实排车身份不得补造信号。 */
+    @Transactional(propagation = Propagation.MANDATORY)
+    public void signed(DeliveryOrder delivery, LocalDateTime now) {
+        if (delivery.getDispatchOrderId() == null) return;
+        if (delivery.getId() == null || delivery.getDispatchOrderId() <= 0 || blank(delivery.getCustomerId())
+            || blank(delivery.getDispatchNo()) || blank(delivery.getDeliveryNo()) || delivery.getVersion() == null
+            || delivery.getVersion() < 1 || delivery.getSignedAt() == null || delivery.getSignedPackages() == null
+            || delivery.getSignedPackages() <= 0 || now == null) throw new IllegalStateException("签收汇总信号缺少真实派送事实");
+        var fact = new DeliveryFactsChanged();
+        fact.setId(IdWorker.getId()); fact.setCustomerId(delivery.getCustomerId());
+        fact.setDispatchId(delivery.getDispatchOrderId()); fact.setDispatchNo(delivery.getDispatchNo());
+        fact.setDeliveryId(delivery.getId()); fact.setDeliveryNo(delivery.getDeliveryNo());
+        fact.setDeliveryVersion(delivery.getVersion()); fact.setOccurredAt(now);
+        fact.setFactsHash(hash(List.of(delivery.getCustomerId(), delivery.getDispatchOrderId(), delivery.getDispatchNo(),
+            delivery.getId(), delivery.getDeliveryNo(), delivery.getVersion(), delivery.getSignedPackages(), delivery.getSignedAt())));
+        var saved = repository.insertOnce(fact);
+        if (saved == null || !Objects.equals(saved.getDispatchId(), fact.getDispatchId())
+            || !Objects.equals(saved.getDispatchNo(), fact.getDispatchNo())
+            || !Objects.equals(saved.getDeliveryNo(), fact.getDeliveryNo())
+            || !Objects.equals(saved.getFactsHash(), fact.getFactsHash()))
+            throw new IllegalStateException("同一签收版本对应的持久事实不一致");
+    }
+
+    /** 以规范化真实字段生成摘要，不保存整车完成的推断结论。 */
+    private String hash(Object value) {
+        try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256")
+            .digest(json.writeValueAsBytes(value))); }
+        catch (NoSuchAlgorithmException | JsonProcessingException error) { throw new IllegalStateException("签收信号摘要生成失败", error); }
+    }
+
+    /** 业务身份缺失直接拒绝，不使用内部ID代替业务编号。 */
+    private static boolean blank(String value) { return value == null || value.isBlank(); }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/service/DeliveryFeeCoverageService.java

@@ -1,122 +0,0 @@
-package com.baiyue.lastleg.delivery.service;
-
-import com.baiyue.lastleg.client.FinanceFeeCoverageClient;
-import com.baiyue.lastleg.delivery.dto.DeliveryFeeCoverageModels;
-import com.baiyue.lastleg.delivery.dto.DeliveryRequests;
-import java.time.Instant;
-import com.baiyue.lastleg.delivery.mapper.DispatchFeeCargoMapper;
-import com.baiyue.lastleg.dispatch.entity.DispatchItem;
-import com.baiyue.lastleg.dispatch.mapper.DispatchItemMapper;
-import com.baiyue.lastleg.dispatch.mapper.DispatchOrderMapper;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.http.HttpStatus;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-import org.springframework.web.server.ResponseStatusException;
-import java.nio.charset.StandardCharsets;
-import java.security.MessageDigest;
-import java.util.*;
-import java.util.stream.Collectors;
-
-@Service
-public class DeliveryFeeCoverageService {
-    private final DispatchOrderMapper dispatches;
-    private final DispatchItemMapper items;
-    private final DispatchFeeCargoMapper sources;
-    private final FinanceFeeCoverageClient finance;
-    private final ObjectMapper json;
-    private final String token;
-    public DeliveryFeeCoverageService(DispatchOrderMapper dispatches, DispatchItemMapper items, DispatchFeeCargoMapper sources,
-        FinanceFeeCoverageClient finance, ObjectMapper json, @Value("${baiyue.security.internal-service-token}") String token) {
-        this.dispatches=dispatches; this.items=items; this.sources=sources; this.finance=finance; this.json=json; this.token=token;
-    }
-
-    @Transactional(readOnly = true, isolation = org.springframework.transaction.annotation.Isolation.REPEATABLE_READ)
-    public DeliveryFeeCoverageModels.Preview preview(String dispatchNo) {
-        var dispatch = dispatches.findGlobalByDispatchNo(dispatchNo.trim());
-        if (dispatch == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "排车单不存在");
-        var selected = items.findByDispatchOrder(dispatch.getCustomerId(), dispatch.getId());
-        var cargo = sources.list(dispatch.getCustomerId(), dispatch.getId());
-        String reason = incomplete(selected, cargo);
-        var inboundIds = new TreeSet<Long>();
-        if (reason == null) for (var row : cargo) if ("FIRSTLEG".equals(row.sourceRegion())) {
-            try { long id = Long.parseLong(row.sourceInboundId()); if (id < 1) throw new NumberFormatException(); inboundIds.add(id); }
-            catch (RuntimeException invalid) { reason = "货物缺少原头程入仓单关联，请先核对来源"; break; }
-        }
-        List<FinanceFeeCoverageClient.Fee> fees = List.of();
-        if (reason == null && !inboundIds.isEmpty()) fees = load(dispatch.getCustomerId(), List.copyOf(inboundIds));
-        try {
-            String hash = HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(
-                json.writeValueAsString(List.of(dispatch.getDispatchNo(), dispatch.getCustomerId(), cargo,
-                    selected.stream().map(item -> Arrays.asList(item.getId(), item.getPackageCount(), item.getOverseasWarehouseId(),
-                        item.getDestinationType(), item.getDestinationWarehouseCode(), item.getFbaWarehouseCode(),
-                        item.getDeliveryAddress(), item.getPostalCode())).toList())).getBytes(StandardCharsets.UTF_8)));
-            return new DeliveryFeeCoverageModels.Preview(dispatch.getDispatchNo(), reason == null, reason, hash, cargo, fees);
-        } catch (java.security.NoSuchAlgorithmException | com.fasterxml.jackson.core.JsonProcessingException error) { throw new IllegalStateException(error); }
-    }
-    private List<FinanceFeeCoverageClient.Fee> load(String customerId, List<Long> inboundIds) {
-        try {
-            var result = finance.sources(token, new FinanceFeeCoverageClient.Query(Long.valueOf(customerId), inboundIds));
-            if (result == null || !result.successful() || result.data() == null) throw unavailable();
-            if (result.data().stream().anyMatch(fee -> fee.financeFeeId() == null || fee.financeFeeId() < 1 || fee.sourceFeeId() == null
-                || !Objects.equals(fee.customerId(), Long.valueOf(customerId)) || fee.sourceVersion() < 1
-                || !inboundIds.contains(fee.sourceInboundId()) || fee.sourceHash() == null || fee.sourceHash().isBlank()
-                || fee.amount() == null || fee.amount().signum() < 0 || !"CNY".equals(fee.currency())
-                || !Set.of("INBOUND_FEE", "CONTAINER_FEE").contains(fee.sourceType())
-                || !Set.of("AVAILABLE", "SETTLED").contains(fee.status()))) throw unavailable();
-            return result.data();
-        } catch (RuntimeException error) { throw unavailable(); }
-    }
-    private static String incomplete(List<DispatchItem> selected, List<DeliveryFeeCoverageModels.Cargo> cargo) {
-        if (selected.isEmpty()) return "排车单没有待发运货物";
-        var totals = cargo.stream().collect(Collectors.groupingBy(DeliveryFeeCoverageModels.Cargo::dispatchItemId,
-            Collectors.summingLong(DeliveryFeeCoverageModels.Cargo::packages)));
-        var ids = selected.stream().map(DispatchItem::getId).collect(Collectors.toSet());
-        if (!ids.equals(totals.keySet())) return "实际货物来源尚未齐全，请先完成收货并核对实物托盘";
-        for (var item : selected) if (item.getPackageCount() == null || totals.get(item.getId()).longValue() != item.getPackageCount())
-            return "实物库存及本次已拣数量与排车箱数不一致，请先核对货物范围";
-        return null;
-    }
-    public record Decision(Set<String> includedServices, DeliveryFeeCoverageModels.Evidence evidence, Set<String> externalInboundCodes) {
-        public static Decision none() { return new Decision(Set.of(), null, Set.of()); }
-        public List<DeliveryFeeCoverageModels.Cargo> uncovered(String service) {
-            if (evidence == null) return List.of();
-            return evidence.cargo().stream().filter(row -> !covers(row, service, evidence.references(), externalInboundCodes)).toList();
-        }
-    }
-    /** 外接覆盖按实际入仓来源判定，不能免除同托普通货的派送费。 */
-    public Decision confirm(String dispatchNo, DeliveryRequests.Transfer request, String operator, Set<String> externalInboundCodes) {
-        if (request.feeCoverage() == null || request.feeCoverage().isEmpty()) return Decision.none();
-        var preview = preview(dispatchNo);
-        if (!preview.sourceComplete()) throw conflict(preview.blockReason());
-        if (!Objects.equals(preview.cargoHash(), request.feeCoverageCargoHash())) throw conflict("原费用对应货物已变化，请重新核对覆盖范围");
-        var references = new ArrayList<DeliveryFeeCoverageModels.Reference>();
-        var scopes = new HashSet<String>();
-        for (var selection : request.feeCoverage()) {
-            var fee = preview.feeSources().stream().filter(row -> Objects.equals(row.financeFeeId(), selection.financeFeeId())).findFirst()
-                .orElseThrow(() -> conflict("原费用不属于本次实际货物，或已审核状态/有效性发生变化"));
-            if (fee.sourceVersion() != selection.sourceVersion() || !Objects.equals(fee.sourceHash(), selection.sourceHash()))
-                throw conflict("原费用版本已变化，请重新确认服务覆盖范围");
-            var services = new TreeSet<>(selection.services());
-            if (services.isEmpty() || !Set.of("DELIVERY_FEE", "LOADING_FEE", "APPOINTMENT_FEE").containsAll(services))
-                throw conflict("请选择本票原费用明确包含的服务");
-            for (var service : services) if (!scopes.add(fee.sourceInboundId() + ":" + service))
-                throw conflict("同一票同一服务只能引用一项原费用");
-            references.add(new DeliveryFeeCoverageModels.Reference(fee, List.copyOf(services)));
-        }
-        var included = new HashSet<String>();
-        for (String service : List.of("DELIVERY_FEE", "LOADING_FEE", "APPOINTMENT_FEE"))
-            if (preview.cargo().stream().allMatch(row -> covers(row, service, references, externalInboundCodes))) included.add(service);
-        return new Decision(Set.copyOf(included), new DeliveryFeeCoverageModels.Evidence(preview.cargoHash(), preview.cargo(),
-            List.copyOf(references), operator, Instant.now()), Set.copyOf(externalInboundCodes));
-    }
-    private static boolean covers(DeliveryFeeCoverageModels.Cargo cargo, String service,
-        List<DeliveryFeeCoverageModels.Reference> references, Set<String> externalInboundCodes) {
-        if ("DELIVERY_FEE".equals(service) && externalInboundCodes.contains(cargo.inboundCode())) return true;
-        return "FIRSTLEG".equals(cargo.sourceRegion()) && references.stream().anyMatch(reference ->
-            reference.source().sourceInboundId().toString().equals(cargo.sourceInboundId()) && reference.services().contains(service));
-    }
-    private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT, message); }
-    private static ResponseStatusException unavailable() { return new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE, "原费用来源暂不可用，请稍后重试"); }
-}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/service/DeliveryTransferService.java

@@ -2,7 +2,6 @@ package com.baiyue.lastleg.delivery.service;
 
 import com.baiyue.lastleg.fleet.trip.FleetDispatchBindingGuard;
 import com.baiyue.lastleg.fleet.trip.FleetDispatchGateway;
-import com.baiyue.lastleg.fleet.trip.FleetBookingFreight;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.IdWorker;
@@ -94,7 +93,6 @@ import java.util.stream.Collectors;
 
 @Service
 public class DeliveryTransferService {
-    @Resource private com.baiyue.lastleg.delivery.repository.OutboundQuantityRepository outboundQuantities;
     @Resource private DispatchOrderMapper dispatchOrders;
     @Resource private DispatchItemMapper dispatchItems;
     @Resource private OutboundOrderMapper outboundOrders;
@@ -131,282 +129,9 @@ public class DeliveryTransferService {
     @Resource private LastlegOrderNoGenerator orderNoGenerator;
     @Resource private ObjectMapper objectMapper;
     @Resource private FleetDispatchBindingGuard fleetBindings;
-    @Resource private FleetBookingFreight bookingFreight;
-    @Resource private DeliveryFeeCoverageService feeCoverage;
     @Resource private DeliveryExecutionGuard deliveryExecution;
-    @Resource private DispatchCargoSourceQuery cargoSources;
-
-    @Transactional(readOnly = true, isolation = org.springframework.transaction.annotation.Isolation.REPEATABLE_READ)
-    public FleetBookingFreight.Preview externalFreight(String dispatchNo) {
-        DispatchOrder dispatch = dispatchOrders.findGlobalByDispatchNo(trim(dispatchNo));
-        if (dispatch == null) throw notFound("Dispatch order not found");
-        return externalFreight(dispatch, dispatchItems.findByDispatchOrder(dispatch.getCustomerId(), dispatch.getId()));
-    }
-
-    /** 外接运费与车次绑定使用相同的实际来源和数量。 */
-    private FleetBookingFreight.Preview externalFreight(DispatchOrder dispatch, List<DispatchItem> items) {
-        return bookingFreight.preview(dispatch.getId(), dispatch.getDispatchNo(), dispatch.getCustomerId(),
-            cargoSources.sources(dispatch, items));
-    }
-
-    @Transactional
-    public DeliveryResponses.TransferResult platformTransfer(String dispatchNo, String operatorId,
-                                                              DeliveryRequests.Transfer request) {
-        DispatchOrder dispatch = dispatchOrders.lockGlobalByDispatchNo(trim(dispatchNo));
-        if (dispatch == null) throw notFound("Dispatch order not found");
-        return transferResolved(dispatch, operatorId, request);
-    }
-
-    @Transactional
-    public DeliveryResponses.TransferResult merchantTransfer(String customerId, String dispatchNo, String operatorId,
-                                                              DeliveryRequests.Transfer request) {
-        if (request.feeCoverage() != null && !request.feeCoverage().isEmpty())
-            throw new ResponseStatusException(HttpStatus.FORBIDDEN, "原运费服务覆盖由平台确认");
-        DispatchOrder found = dispatchOrders.findByDispatchNo(customerId, dispatchNo);
-        if (found == null) throw notFound("Dispatch order not found");
-        DispatchOrder dispatch = dispatchOrders.lockById(customerId, found.getId());
-        if (dispatch == null) throw notFound("Dispatch order not found");
-        return transferResolved(dispatch, operatorId, request);
-    }
-
-    /** 排车锁内创建完整目的地派送，历史重放不生成新单或重复发布费用。 */
-    private DeliveryResponses.TransferResult transferResolved(DispatchOrder dispatch, String operatorId,
-                                                                DeliveryRequests.Transfer request) {
-        String customerId = dispatch.getCustomerId();
-        String requestHash = transferRequestHash(request);
-        OutboundOrder replay = outboundOrders.findByIdempotency(customerId, request.idempotencyKey().trim());
-        if (replay != null) {
-            if (!dispatch.getId().equals(replay.getDispatchOrderId())) throw conflict("Idempotency key belongs to another dispatch");
-            return replayTransfer(replay, requestHash);
-        }
-        OutboundOrder existing = outboundOrders.lockByDispatch(customerId, dispatch.getId());
-        if (existing != null) return replayTransfer(existing, requestHash);
-        if (Set.of("CANCELLED", "DEPARTED", "PARTIAL_DEPARTED", "COMPLETED").contains(dispatch.getStatus())) {
-            throw conflict("Dispatch cannot be transferred to delivery in its current status");
-        }
-        fleetBindings.requireMatchingAssignment(dispatch.getId(),
-            new FleetDispatchGateway.Assignment(dispatch.getVehiclePlate(), dispatch.getDriverName(), dispatch.getDriverPhone()),
-            new FleetDispatchGateway.Assignment(request.vehiclePlate(), request.driverName(), request.driverPhone()));
-        dispatchItems.bindReceivedPallets(customerId, dispatch.getId());
-        List<DispatchItem> items = dispatchItems.findByDispatchOrder(customerId, dispatch.getId());
-        if (items.isEmpty()) throw conflict("Dispatch has no pallets");
-        if (items.stream().anyMatch(item -> item.getWarehousePalletId() == null)) {
-            throw conflict("All dispatch pallets must be received before transfer to delivery");
-        }
-        if (!StringUtils.hasText(dispatch.getOverseasWarehouseId())) throw conflict("Dispatch warehouse is required");
-        var freight = externalFreight(dispatch, items);
-        if ((!freight.quotes().isEmpty() || StringUtils.hasText(request.externalFreightHash()))
-            && !Objects.equals(freight.snapshotHash(), request.externalFreightHash()))
-            throw conflict("外接实收或约定运费已变化，请重新打开转派送核对");
-        var externalInboundCodes = freight.quotes().stream().map(FleetBookingFreight.Quote::inboundCode).collect(Collectors.toSet());
-        var coverage = request.feeCoverage() == null || request.feeCoverage().isEmpty() ? DeliveryFeeCoverageService.Decision.none()
-            : feeCoverage.confirm(dispatch.getDispatchNo(), request, operatorId, externalInboundCodes);
-        validateTransferFees(request, freight.requiresDeliveryFee(), coverage.includedServices());
-        if (!freight.priorInboundCodes().isEmpty()) feeSources.requireNoActiveDeliveryReceivables(customerId, freight.priorInboundCodes());
-
-        LocalDateTime now = LocalDateTime.now();
-        OutboundOrder outbound = new OutboundOrder();
-        outbound.setId(IdWorker.getId()); outbound.setCustomerId(customerId);
-        outbound.setOutboundNo(orderNoGenerator.next("OUTBOUND", dispatch.getOverseasWarehouseId(), outbound.getId()));
-        outbound.setDispatchOrderId(dispatch.getId()); outbound.setDispatchNo(dispatch.getDispatchNo());
-        outbound.setOverseasWarehouseId(dispatch.getOverseasWarehouseId()); outbound.setStatus("WAIT_OUTBOUND"); outbound.setOutboundType("DISPATCH_DELIVERY");
-        outbound.setLxCodes(resolveLxCodes(customerId, items));
-        outbound.setPackageCount(items.stream().map(DispatchItem::getPackageCount).filter(Objects::nonNull).mapToInt(Integer::intValue).sum());
-        outbound.setPalletCount(items.size());
-        outbound.setGrossWeightKg(sumKnownPhysicalWeight(items, DispatchItem::getGrossWeightKg));
-        outbound.setVolumeWeightKg(sum(items, DispatchItem::getVolumeWeightKg));
-        outbound.setVolumeCbm(sum(items, DispatchItem::getVolumeCbm));
-        outbound.setIdempotencyKey(request.idempotencyKey().trim());
-        outbound.setRequestHash(requestHash);
-        if (coverage.evidence() != null) {
-            try { outbound.setFeeCoverageJson(objectMapper.writeValueAsString(coverage.evidence())); }
-            catch (JsonProcessingException exception) { throw new IllegalStateException("费用覆盖确认无法保存", exception); }
-        }
-        outbound.setCreatedBy(operatorId); outbound.setCreatedAt(now); outbound.setUpdatedAt(now);
-        try {
-            outboundOrders.insert(outbound);
-        } catch (DuplicateKeyException e) {
-            // The unique keys are the final concurrent guard.  A client retry must observe
-            // the document created by the winning transaction rather than receive a false failure.
-            OutboundOrder concurrent = outboundOrders.findByIdempotency(customerId, request.idempotencyKey().trim());
-            if (concurrent != null && dispatch.getId().equals(concurrent.getDispatchOrderId())) {
-                return replayTransfer(concurrent, requestHash);
-            }
-            concurrent = outboundOrders.lockByDispatch(customerId, dispatch.getId());
-            if (concurrent != null) {
-                return replayTransfer(concurrent, requestHash);
-            }
-            throw conflict("Dispatch was concurrently transferred to delivery");
-        }
-
-        for (DispatchItem source : items) {
-            OutboundPalletItem item = new OutboundPalletItem();
-            item.setId(IdWorker.getId()); item.setCustomerId(customerId); item.setOutboundOrderId(outbound.getId());
-            item.setWarehousePalletId(source.getWarehousePalletId()); item.setPalletNo(source.getPalletNo());
-            item.setDestinationWarehouseId(source.getDestinationWarehouseId());
-            item.setDestinationWarehouseCode(source.getDestinationWarehouseCode());
-            item.setDestinationWarehouseName(source.getDestinationWarehouseName());
-            item.setPackageCount(Objects.requireNonNullElse(source.getPackageCount(), 0));
-            item.setGrossWeightKg(source.getGrossWeightKg()); item.setVolumeWeightKg(source.getVolumeWeightKg());
-            item.setVolumeCbm(source.getVolumeCbm()); item.setPickedPackageCount(0); item.setStatus("WAIT_PICK");
-            if (StringUtils.hasText(source.getCartonMarks())) {
-                item.setCartonMarks(source.getCartonMarks());
-            } else if (source.getWarehousePalletId() != null) {
-                String marks = inboundCartons.listByPallet(customerId, source.getWarehousePalletId()).stream()
-                    .map(c -> c.getCartonMark()).filter(StringUtils::hasText).distinct().collect(java.util.stream.Collectors.joining(","));
-                item.setCartonMarks(StringUtils.hasText(marks) ? marks : null);
-            }
-            item.setOrderRefs(source.getOrderRefs()); item.setInboundCode(source.getInboundCode()); item.setCreatedAt(now);
-            outboundPallets.insert(item);
-        }
-
-        Map<String, List<DispatchItem>> destinationGroups = items.stream().collect(java.util.stream.Collectors.groupingBy(
-            this::deliveryGroupKey, LinkedHashMap::new, java.util.stream.Collectors.toList()));
-        List<DeliveryOrder> deliveries = new ArrayList<>();
-        int groupIndex = 0;
-        for (Map.Entry<String, List<DispatchItem>> entry : destinationGroups.entrySet()) {
-            List<DispatchItem> groupItems = entry.getValue();
-            DispatchItem destination = groupItems.get(0);
-            DeliveryOrder delivery = new DeliveryOrder();
-            delivery.setId(IdWorker.getId()); delivery.setCustomerId(customerId);
-            delivery.setDeliveryNo(orderNoGenerator.next("DELIVERY", dispatch.getOverseasWarehouseId(), delivery.getId()));
-            delivery.setOutboundOrderId(outbound.getId()); delivery.setOutboundNo(outbound.getOutboundNo());
-            delivery.setDispatchOrderId(dispatch.getId()); delivery.setDispatchNo(dispatch.getDispatchNo());
-            delivery.setOverseasWarehouseId(dispatch.getOverseasWarehouseId()); delivery.setOverseasWarehouseName(dispatch.getOverseasWarehouseName());
-            delivery.setDestinationWarehouseId(trim(destination.getDestinationWarehouseId()));
-            delivery.setDestinationWarehouseCode(firstText(
-                firstText(destination.getDestinationWarehouseCode(), destination.getFbaWarehouseCode()),
-                destination.getDestinationWarehouseId()));
-            delivery.setDestinationWarehouseName(trim(destination.getDestinationWarehouseName()));
-            delivery.setDestinationType(destination.getDestinationType());
-            delivery.setDeliveryAddress(destination.getDeliveryAddress());
-            delivery.setPostalCode(destination.getPostalCode());
-            delivery.setContactName(destination.getContactName());
-            delivery.setContactPhone(destination.getContactPhone());
-            delivery.setDeliveryGroupKey(entry.getKey());
-            LastlegOrder firstOrder = firstTailOrder(customerId, groupItems);
-            delivery.setCustomerName(firstOrder == null ? null : firstOrder.getCustomerName()); delivery.setStatus("WAIT_DELIVERY"); delivery.setVersion(0L);
-            delivery.setWaybillNo(trim(request.waybillNo())); delivery.setDeliveryMethod(request.deliveryMethod().trim());
-            delivery.setCarrierName(firstText(request.carrierName(), dispatch.getCarrierName())); delivery.setPickupMethod(trim(request.pickupMethod()));
-            delivery.setLoadingType(trim(request.loadingType())); delivery.setVehicleType(trim(request.vehicleType())); delivery.setVehicleSize(trim(request.vehicleSize()));
-            delivery.setVehiclePlate(firstText(request.vehiclePlate(), dispatch.getVehiclePlate())); delivery.setDriverName(firstText(request.driverName(), dispatch.getDriverName()));
-            delivery.setDriverPhone(firstText(request.driverPhone(), dispatch.getDriverPhone())); delivery.setAppointmentAccount(trim(request.appointmentAccount()));
-            delivery.setSellerName(trim(request.sellerName())); delivery.setPlannedDeliveryAt(request.plannedDeliveryAt());
-            delivery.setPackageCount(groupItems.stream().map(DispatchItem::getPackageCount).filter(Objects::nonNull).mapToInt(Integer::intValue).sum());
-            delivery.setPalletCount(groupItems.size());
-            delivery.setTotalVolumeCbm(sum(groupItems, DispatchItem::getVolumeCbm));
-            delivery.setTotalWeightKg(sumKnownPhysicalWeight(groupItems, DispatchItem::getGrossWeightKg)); delivery.setExpectedArrivalAt(dispatch.getEstimatedArrivalAt()); delivery.setRemark(trim(request.remark()));
-            delivery.setIdempotencyKey(childKey(request.idempotencyKey(), "DEST-" + groupIndex++)); delivery.setCreatedBy(operatorId);
-            delivery.setCreatedAt(now); delivery.setUpdatedAt(now); deliveryOrders.insert(delivery);
-            recordOperation(customerId, delivery.getId(), operatorId, "CREATE_DELIVERY", "按目的FBA仓生成派送单", now);
-            bindTailOrders(customerId, groupItems, outbound.getOutboundNo(), delivery.getDeliveryNo(), request.remark(), now);
-            deliveries.add(delivery);
-        }
-        for (var quote : freight.quotes()) {
-            var destination = deliveries.stream().filter(item -> Objects.equals(quote.destinationKey(), FleetDispatchGateway.destinationKey(
-                item.getDestinationType(), item.getDestinationWarehouseCode(), item.getDestinationWarehouseCode(),
-                item.getDeliveryAddress(), item.getPostalCode()))).findFirst()
-                .orElseThrow(() -> conflict("外接约定目的地未生成对应派送单"));
-            recordOperation(customerId, destination.getId(), operatorId, "CONFIRM_EXTERNAL_FREIGHT",
-                "外接预订 " + quote.bookingNo() + "；实收确认版本 " + quote.recordVersion() + "；约定运费 "
-                    + quote.currency() + " " + quote.amount().toPlainString(), now);
-            // An explicitly agreed free shipment remains a commercial fact, not a fabricated zero fee.
-            if (quote.amount().signum() == 0) continue;
-            feeSources.publishApproved(operatorId, "FLEET:" + quote.bookingNo() + ":" + dispatch.getDispatchNo() + ":FREIGHT",
-                new OverseasFeeSourceDtos.SaveRequest(customerId, quote.customerName(),
-                    "OVERSEAS_DELIVERY_FEE", "DELIVERY_ORDER", destination.getId(), destination.getDeliveryNo(),
-                    null, null, quote.inboundCode(), null, null, null, parseLong(destination.getOverseasWarehouseId()),
-                    "DELIVERY_FEE", "外接运费（" + quote.bookingNo() + "）", "RECEIVABLE", null, null, null,
-                    null, null, null, null, null, LocalDate.now(), quote.currency(), quote.amount(), quote.quantity(),
-                    quote.quantityUnit(), quote.unitPrice(), null, null));
-        }
-        DeliveryOrder feeDelivery = deliveries.get(0);
-        List<DeliveryRequests.FeeItem> feeInputs = request.fees() == null ? List.of() : request.fees();
-        var ordinaryCargo = freight.requiresDeliveryFee() ? cargoSources.sources(dispatch, items).stream()
-            .filter(source -> !externalInboundCodes.contains(source.inboundCode())).toList() : List.<FleetDispatchGateway.SourceCargo>of();
-        for (DeliveryRequests.FeeItem input : feeInputs) {
-            String feeCode = input.feeType().trim().toUpperCase(Locale.ROOT);
-            var uncovered = coverage.uncovered(feeCode);
-            var uncoveredItemIds = uncovered.stream().map(com.baiyue.lastleg.delivery.dto.DeliveryFeeCoverageModels.Cargo::dispatchItemId).collect(Collectors.toSet());
-            var chargeItems = coverage.evidence() != null && "RECEIVABLE".equals(input.direction())
-                ? items.stream().filter(item -> uncoveredItemIds.contains(item.getId())).toList()
-                : "RECEIVABLE".equals(input.direction()) && "DELIVERY_FEE".equals(feeCode) && freight.requiresDeliveryFee()
-                    ? items.stream().filter(item -> ordinaryCargo.stream().anyMatch(source -> Objects.equals(source.warehousePalletId(),
-                        item.getWarehousePalletId().toString()) && Objects.equals(source.destinationKey(), FleetDispatchGateway.destinationKey(
-                            item.getDestinationType(), item.getDestinationWarehouseCode(), item.getFbaWarehouseCode(), item.getDeliveryAddress(), item.getPostalCode())))).toList() : items;
-            var feeDestination = "DELIVERY_FEE".equalsIgnoreCase(input.feeType()) && !chargeItems.isEmpty()
-                ? deliveries.stream().filter(item -> deliveryGroupKey(chargeItems.get(0)).equals(item.getDeliveryGroupKey())).findFirst().orElseThrow()
-                : feeDelivery;
-            LastlegOrder firstOrder = firstTailOrder(customerId, chargeItems);
-            // 合托后按真实普通来源归属费用；多票时只绑定派送，不借展示入仓码挂到外接货。
-            if ("RECEIVABLE".equals(input.direction()) && "DELIVERY_FEE".equals(feeCode) && !externalInboundCodes.isEmpty()) {
-                var ordinaryOrders = cargoSources.ordinaryOrderIds(dispatch, externalInboundCodes);
-                firstOrder = ordinaryOrders.size() == 1 ? tailOrders.selectById(ordinaryOrders.iterator().next()) : null;
-                if (firstOrder != null && !customerId.equals(firstOrder.getCustomerId())) throw conflict("新增费用来源客户不一致");
-            }
-            if (coverage.evidence() != null && "RECEIVABLE".equals(input.direction())) {
-                var uncoveredOrderIds = uncovered.stream().map(com.baiyue.lastleg.delivery.dto.DeliveryFeeCoverageModels.Cargo::orderId).filter(Objects::nonNull).distinct().toList();
-                firstOrder = uncoveredOrderIds.size() == 1 ? tailOrders.selectById(uncoveredOrderIds.get(0)) : null;
-                if (firstOrder != null && !customerId.equals(firstOrder.getCustomerId())) throw conflict("新增费用来源客户不一致");
-            }
-            feeSources.publishApproved(operatorId, childKey(request.idempotencyKey(), input.direction() + ":" + feeCode),
-                new OverseasFeeSourceDtos.SaveRequest(customerId, feeDestination.getCustomerName(),
-                    "OVERSEAS_DELIVERY_FEE", "DELIVERY_ORDER", feeDestination.getId(), feeDestination.getDeliveryNo(),
-                    firstOrder == null ? null : firstOrder.getId(), null,
-                    firstOrder == null ? null : firstOrder.getInboundCode(), null,
-                    firstOrder == null ? null : parseLong(firstOrder.getSourceContainerBookingId()),
-                    firstOrder == null ? null : firstOrder.getContainerNo(), parseLong(feeDestination.getOverseasWarehouseId()),
-                    feeCode, input.feeName().trim(), input.direction(), input.supplierId(),
-                    input.supplierName(), input.supplierCategory(), input.settlementMode(), input.paidAt(),
-                    input.paymentMethod(), input.paymentReferenceNo(), input.paymentVoucherFileIds(), LocalDate.now(),
-                    input.currency(), input.amount(), input.chargeableQuantity(), input.quantityUnit(), input.unitPrice(),
-                    input.periodStart(), input.periodEnd()));
-        }
-        return result(outbound, deliveries, false);
-    }
-
-    /** 取消后的同载荷重放仍返回原取消单据，绝不作为新建成功。 */
-    private DeliveryResponses.TransferResult replayTransfer(OutboundOrder outbound, String requestHash) {
-        if (!requestHash.equals(outbound.getRequestHash()))
-            throw conflict("转派送请求与原已保存内容不一致，请查看原单据；费用调整须通过正式费用更正流程");
-        return result(outbound, requireDeliveries(outbound.getCustomerId(), outbound.getId()), true);
-    }
-
-    String transferRequestHash(DeliveryRequests.Transfer request) {
-        // A new command key cannot change an already transferred dispatch's business content.
-        com.fasterxml.jackson.databind.node.ObjectNode content = objectMapper.valueToTree(request);
-        content.remove("idempotencyKey");
-        if (request.feeCoverage() == null || request.feeCoverage().isEmpty()) {
-            content.remove("feeCoverage"); content.remove("feeCoverageCargoHash");
-        }
-        return hash(content);
-    }
-
-    private void validateTransferFees(DeliveryRequests.Transfer request, boolean requiresDeliveryFee, Set<String> covered) {
-        List<DeliveryRequests.FeeItem> inputs = request.fees() == null ? List.of() : request.fees();
-        Set<String> allowed = Set.of("DELIVERY_FEE", "LOADING_FEE", "APPOINTMENT_FEE");
-        Set<String> seen = new HashSet<>();
-        for (DeliveryRequests.FeeItem input : inputs) {
-            String feeType = input.feeType().trim().toUpperCase(Locale.ROOT);
-            if (!allowed.contains(feeType)) throw conflict("Unsupported delivery fee type: " + feeType);
-            if (!seen.add(input.direction() + ":" + feeType)) throw conflict("Duplicate delivery fee type: " + feeType);
-            if ("RECEIVABLE".equals(input.direction()) && covered.contains(feeType)) throw conflict("本次货物的该服务已由原费用覆盖，请勿重复登记应收");
-            if (!Set.of("CNY", "USD").contains(input.currency().trim().toUpperCase(Locale.ROOT)))
-                throw conflict("Delivery fees only support CNY or USD");
-            if (input.amount().signum() <= 0) throw conflict("Delivery fee amount must be greater than zero");
-        }
-        if (requiresDeliveryFee && !covered.contains("DELIVERY_FEE") && !seen.contains("RECEIVABLE:DELIVERY_FEE")) throw conflict("尚未有约定运费的货物须填写派送费");
-        if (!requiresDeliveryFee && inputs.stream().anyMatch(item -> "DELIVERY_FEE".equalsIgnoreCase(item.feeType().trim())
-            && "RECEIVABLE".equals(item.direction()))) throw conflict("本排车全部货物已带入外接约定运费，请勿重复填写派送应收");
-        if (Set.of("FLOOR", "MIXED").contains(request.loadingType().trim().toUpperCase(Locale.ROOT))
-            && !covered.contains("LOADING_FEE") && !seen.contains("RECEIVABLE:LOADING_FEE")) {
-            throw conflict("Loading fee is required for floor or mixed loading");
-        }
-        if ("BUY_APPOINTMENT".equalsIgnoreCase(trim(request.appointmentAccount()))) {
-            if (!StringUtils.hasText(request.sellerName())) throw conflict("Seller name is required when buying an appointment");
-            if (!covered.contains("APPOINTMENT_FEE") && !seen.contains("RECEIVABLE:APPOINTMENT_FEE")) throw conflict("Appointment fee is required when buying an appointment");
-        }
-    }
+    @Resource private com.baiyue.lastleg.dispatch.port.DispatchExecutionPort execution;
+    @Resource private com.baiyue.lastleg.delivery.repository.DeliveryCancellationRepository cancellations;
 
     @Transactional
     public DeliveryResponses.PdaTask createOneClick(String customerId, String operatorId, DeliveryRequests.OneClickOutbound request) {
@@ -1165,38 +890,44 @@ public class DeliveryTransferService {
         }
     }
 
-    @Transactional
+    /** 先取得真实整车父锁，再锁出库和派送；已扫码不得以取消出库伪造退库。 */
+    @Transactional(isolation = org.springframework.transaction.annotation.Isolation.READ_COMMITTED)
     public void cancelOutbound(String outboundNo, String operatorId, DeliveryRequests.Cancel request) {
         required(request == null ? null : request.reason(), "取消原因不能为空");
-        OutboundOrder observed = outboundOrders.findGlobalByNo(trim(outboundNo));
+        OutboundOrder observed = cancellations.find(trim(outboundNo));
         if (observed == null) throw notFound("Outbound order not found");
         if ("DISCARD_OUTBOUND".equals(observed.getOutboundType())) throw conflict("请通过废弃单取消，废弃出库单随申请同步取消");
-        // Match dispatch picking and relabel confirmation lock order before locking outbound.
-        DispatchOrder dispatch = observed.getDispatchOrderId() == null ? null
-            : dispatchOrders.lockById(observed.getCustomerId(), observed.getDispatchOrderId());
-        RelabelApplication application = "RELABEL_OUTBOUND".equals(observed.getOutboundType())
-            ? relabelApplications.lockByOutbound(observed.getCustomerId(), observed.getOutboundNo()) : null;
-        OutboundOrder outbound = outboundOrders.lockGlobalByNo(trim(outboundNo));
+        // 服务端身份与父锁仅使用正式共同端口，不按客户去锁整车头部。
+        var dispatch = observed.getDispatchOrderId() == null ? null
+            : execution.lockForArrangement(new com.baiyue.lastleg.dispatch.port.DispatchContracts.Actor(operatorId,
+                com.baiyue.lastleg.dispatch.port.DispatchTypes.ActorMode.PLATFORM,null),observed.getDispatchNo());
+        RelabelApplication application = observed.getDispatchOrderId()==null && "RELABEL_OUTBOUND".equals(observed.getOutboundType())
+            ? cancellations.lockRelabel(observed) : null;
+        OutboundOrder outbound = cancellations.lock(trim(outboundNo));
         if (outbound == null) throw notFound("Outbound order not found");
         if ("CANCELLED".equals(outbound.getStatus())) return;
         if (outbound.getDispatchOrderId() != null) {
-            if (dispatch == null || !Objects.equals(dispatch.getId(), outbound.getDispatchOrderId())
-                || !"PENDING_DEPARTURE".equals(dispatch.getStatus()) || value(dispatch.getPickedPackageCount()) > 0
-                || value(dispatch.getShippedPackageCount()) > 0) throw conflict("排车已开始执行，不能直接取消出库");
-            fleetBindings.requireUnbound(dispatch.getId());
+            if (dispatch == null || !Objects.equals(dispatch.dispatchId(), outbound.getDispatchOrderId())
+                || dispatch.status()!=com.baiyue.lastleg.dispatch.port.DispatchTypes.Status.ACTIVE
+                || dispatch.stage()!=com.baiyue.lastleg.dispatch.port.DispatchTypes.Stage.BEFORE_LOADING
+                || dispatch.counts()==null || dispatch.counts().pickedPackageCount()>0 || dispatch.counts().shippedPackageCount()>0)
+                throw conflict("排车已开始执行，不能直接取消出库");
+            fleetBindings.requireUnbound(dispatch.dispatchId());
         }
         if (!Set.of("WAIT_OUTBOUND", "WAIT_PICK").contains(outbound.getStatus())) {
             throw conflict("Only an unexecuted outbound order can be cancelled");
         }
         String customerId = outbound.getCustomerId();
-        List<OutboundPalletItem> outboundItems = outboundPallets.findByOutbound(customerId, outbound.getId());
+        List<OutboundPalletItem> outboundItems = cancellations.items(outbound);
         if (outboundItems.isEmpty() || outboundItems.stream().anyMatch(i -> value(i.getPickedPackageCount()) > 0
             || !Set.of("WAIT_PICK", "WAIT_OUTBOUND").contains(i.getStatus()))) {
             throw conflict("Outbound order cannot be cancelled after execution has started");
         }
-        List<DeliveryOrder> existingDeliveries = deliveryOrders.lockByOutbound(customerId, outbound.getId());
+        List<DeliveryOrder> existingDeliveries = cancellations.deliveries(outbound);
         if (existingDeliveries.stream().anyMatch(delivery -> !"WAIT_DELIVERY".equals(delivery.getStatus())))
             throw conflict("Outbound order cannot be cancelled while delivery is in progress");
+        if (outbound.getDispatchOrderId()!=null && "RELABEL_OUTBOUND".equals(outbound.getOutboundType()))
+            application=cancellations.lockRelabel(outbound);
         LocalDateTime now = LocalDateTime.now();
         if ("RELABEL_OUTBOUND".equals(outbound.getOutboundType())) {
             if (application == null || !customerId.equals(application.getCustomerId())
@@ -1206,13 +937,13 @@ public class DeliveryTransferService {
             for (OutboundPalletItem item : outboundItems) {
                 if (item.getWarehousePalletId() != null) continue;
                 for (String mark : Objects.toString(item.getCartonMarks(), "").split(",")) {
-                    ReturnInventoryCarton carton = returnCartons.lockMark(mark);
+                    ReturnInventoryCarton carton = cancellations.lockCarton(mark);
                     if (carton == null || !customerId.equals(carton.getCustomerId())
                         || !Objects.equals(application.getId(), carton.getRelabelApplicationId())
                         || !"OUTBOUND_PENDING".equals(carton.getStatus()))
                         throw conflict("退货换标箱预留状态异常，不能取消出库");
                     carton.setStatus("RELABEL_PENDING"); carton.setUpdatedAt(now);
-                    returnCartons.updateById(carton);
+                    cancellations.save(carton);
                 }
             }
             relabelService.changeStatus(customerId, application.getRelabelNo(), operatorId,
@@ -1220,12 +951,23 @@ public class DeliveryTransferService {
         }
         if ("RETURN_OUTBOUND".equals(outbound.getOutboundType())) {
             for (String mark : outboundItems.stream().map(OutboundPalletItem::getCartonMarks).sorted().toList()) {
-                ReturnInventoryCarton carton = returnCartons.lockMark(mark);
+                ReturnInventoryCarton carton = cancellations.lockCarton(mark);
                 if (carton == null || !customerId.equals(carton.getCustomerId()) || !"OUTBOUND_PENDING".equals(carton.getStatus()))
                     throw conflict("退货箱预留状态异常，不能取消出库");
-                carton.setStatus("AVAILABLE"); carton.setUpdatedAt(now); returnCartons.updateById(carton);
+                carton.setStatus("AVAILABLE"); carton.setUpdatedAt(now); cancellations.save(carton);
             }
         }
+        // 已收齐子单后，先锁齐全部相关来源；费用锁之后不得再发现新的来源锁。
+        var cancelTransfers=new LinkedHashMap<String,WarehouseTransferOrder>();
+        if("WAREHOUSE_TRANSFER_OUTBOUND".equals(outbound.getOutboundType()))
+            for(var no:outboundItems.stream().map(OutboundPalletItem::getOrderRefs).filter(StringUtils::hasText).distinct().sorted().toList()) {
+                var transfer=cancellations.lockTransfer(customerId,no);if(transfer!=null)cancelTransfers.put(no,transfer);
+            }
+        var cancelSources=new TreeMap<Long,LastlegOrder>();
+        for(var selected:cancellations.sources(customerId,outboundNo)) {
+            var current=cancellations.lockSource(customerId,selected.getId());
+            if(current!=null && outboundNo.equals(current.getOutboundOrderNo()))cancelSources.put(current.getId(),current);
+        }
         for (DeliveryOrder delivery : existingDeliveries) {
             int voidRequests = 0;
             for (var fee : feeSources.listForBusiness(customerId, "DELIVERY_ORDER", delivery.getId())) {
@@ -1237,61 +979,58 @@ public class DeliveryTransferService {
                     voidRequests++;
                 }
             }
-            recordOperation(customerId, delivery.getId(), operatorId, "CANCEL_OUTBOUND",
+            recordCancellationOperation(customerId, delivery.getId(), operatorId, "CANCEL_OUTBOUND",
                 "出库取消；" + voidRequests + "笔未履行派送应收已申请撤销，其他费用保留待核对", now);
             String reason = request.reason().trim();
             for (int offset = 0; offset < reason.length(); offset += 480)
-                recordOperation(customerId, delivery.getId(), operatorId, "CANCEL_OUTBOUND_REASON",
+                recordCancellationOperation(customerId, delivery.getId(), operatorId, "CANCEL_OUTBOUND_REASON",
                     "(" + (offset / 480 + 1) + ") " + reason.substring(offset, Math.min(offset + 480, reason.length())), now);
             delivery.setStatus("CANCELLED"); delivery.setVersion(value(delivery.getVersion()) + 1);
-            delivery.setUpdatedAt(now); deliveryOrders.updateById(delivery);
+            delivery.setUpdatedAt(now); cancellations.save(delivery);
         }
-        OutboundPdaTask task = pdaTasks.lockByOutbound(customerId, outbound.getId());
-        if (task != null) { task.setStatus("CANCELLED"); task.setUpdatedAt(now); pdaTasks.updateById(task); }
-        outbound.setStatus("CANCELLED"); outbound.setUpdatedAt(now); outboundOrders.updateById(outbound);
-        for (OutboundPalletItem item : outboundItems) { item.setStatus("CANCELLED"); outboundPallets.updateById(item); }
+        OutboundPdaTask task = cancellations.task(outbound);
+        if (task != null) { task.setStatus("CANCELLED"); task.setUpdatedAt(now); cancellations.save(task); }
+        outbound.setStatus("CANCELLED"); outbound.setUpdatedAt(now); cancellations.save(outbound);
+        for (OutboundPalletItem item : outboundItems) { item.setStatus("CANCELLED"); cancellations.save(item); }
         if ("WAREHOUSE_TRANSFER_OUTBOUND".equals(outbound.getOutboundType())) {
             for (String transferNo : outboundItems.stream().map(OutboundPalletItem::getOrderRefs)
                 .filter(StringUtils::hasText).distinct().toList()) {
-                WarehouseTransferOrder transfer = warehouseTransfers.lockNo(customerId, transferNo);
+                WarehouseTransferOrder transfer = cancelTransfers.get(transferNo);
                 if (transfer == null || !"WAIT_OUTBOUND".equals(transfer.getStatus())) continue;
                 String restored = "FBA".equals(transfer.getDestinationType()) || "PRIVATE".equals(transfer.getDestinationType())
                     ? "READY_FOR_DISPATCH" : "WAIT_FBA_DESTINATION";
-                transfer.setStatus(restored); transfer.setUpdatedAt(now); warehouseTransfers.updateById(transfer);
-                LastlegOrder order = tailOrders.selectById(transfer.getLastlegOrderId());
+                transfer.setStatus(restored); transfer.setUpdatedAt(now); cancellations.save(transfer);
+                LastlegOrder order = cancelSources.get(transfer.getLastlegOrderId());
                 if (order != null && customerId.equals(order.getCustomerId())) {
                     order.setCurrentStatus(restored); order.setSubOrderStatus("WAREHOUSE_TRANSFER:" + restored);
                     order.setOutboundOrderNo(null); order.setDeliveryOrderNo(null); order.setUpdatedAt(now);
-                    tailOrders.updateById(order);
+                    if(!cancellations.restore(order,outboundNo,restored,"WAREHOUSE_TRANSFER:"+restored,now))
+                        throw conflict("转仓来源关联已变化，请刷新核对");
                 }
             }
             return;
         }
         if (!existingDeliveries.isEmpty() && !"RELABEL_OUTBOUND".equals(outbound.getOutboundType())) {
             var transferEvents = existingDeliveries.stream().map(delivery -> "TRANSFER_DELIVERY:" + delivery.getDeliveryNo()).toList();
-            for (LastlegOrder selected : tailOrders.selectList(new LambdaQueryWrapper<LastlegOrder>().eq(LastlegOrder::getCustomerId, customerId)
-                .eq(LastlegOrder::getOutboundOrderNo, outboundNo).orderByAsc(LastlegOrder::getId))) {
-                var order = tailOrders.lockById(customerId, selected.getId());
+            for (LastlegOrder order : cancelSources.values()) {
                 if (order == null || !outboundNo.equals(order.getOutboundOrderNo())) continue;
-                var previous = histories.selectOne(new LambdaQueryWrapper<LastlegOrderStatusHistory>()
-                    .eq(LastlegOrderStatusHistory::getCustomerId, customerId).eq(LastlegOrderStatusHistory::getOrderId, order.getId())
-                    .in(LastlegOrderStatusHistory::getEventId, transferEvents)
-                    .orderByAsc(LastlegOrderStatusHistory::getCreatedAt, LastlegOrderStatusHistory::getId).last("LIMIT 1"));
+                var previous = cancellations.previous(customerId,order.getId(),transferEvents);
                 if (previous == null || !StringUtils.hasText(previous.getFromStatus())) throw conflict("缺少本次转派送前的订单状态记录，请先核对来源");
                 String from = order.getCurrentStatus();
-                if (tailOrders.update(null, new com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper<LastlegOrder>()
-                    .eq(LastlegOrder::getId, order.getId()).eq(LastlegOrder::getCustomerId, customerId)
-                    .eq(LastlegOrder::getOutboundOrderNo, outboundNo)
-                    .set(LastlegOrder::getCurrentStatus, previous.getFromStatus())
-                    .set(LastlegOrder::getSubOrderStatus, "OUTBOUND:CANCELLED;DELIVERY:CANCELLED")
-                    .set(LastlegOrder::getOutboundOrderNo, null).set(LastlegOrder::getDeliveryOrderNo, null)
-                    .set(LastlegOrder::getVersion, value(order.getVersion()) + 1).set(LastlegOrder::getUpdatedAt, now)) != 1)
+                if (!cancellations.restore(order,outboundNo,previous.getFromStatus(),"OUTBOUND:CANCELLED;DELIVERY:CANCELLED",now))
                     throw conflict("订单关联已变化，请刷新后重试");
-                LastlegOrderStatusHistory history = new LastlegOrderStatusHistory(); history.setCustomerId(customerId); history.setOrderId(order.getId()); history.setFromStatus(from); history.setToStatus(previous.getFromStatus()); history.setEventId("CANCEL_OUTBOUND:" + outboundNo); history.setRemark(request.reason().trim()); history.setCreatedAt(now); histories.insert(history);
+                LastlegOrderStatusHistory history = new LastlegOrderStatusHistory(); history.setCustomerId(customerId); history.setOrderId(order.getId()); history.setFromStatus(from); history.setToStatus(previous.getFromStatus()); history.setEventId("CANCEL_OUTBOUND:" + outboundNo); history.setRemark(request.reason().trim()); history.setCreatedAt(now); cancellations.history(history);
             }
         }
     }
 
+    /** 取消事实按完整原因分段写入，不借通用Service直调Mapper。 */
+    private void recordCancellationOperation(String customerId,Long deliveryId,String operator,String node,String result,LocalDateTime now) {
+        var operation=new DeliveryOperation();operation.setCustomerId(customerId);operation.setDeliveryOrderId(deliveryId);
+        operation.setOperatorId(operator);operation.setOperatorName(operator);operation.setOperationNode(node);operation.setResult(result);operation.setCreatedAt(now);
+        cancellations.operation(operation);
+    }
+
     public List<DeliveryResponses.PdaTask> pdaTasks(String warehouseId, String status) {
         String boundWarehouseId = required(warehouseId, "PDA warehouse binding is required");
         return pdaTasks.listByWarehouse(boundWarehouseId, StringUtils.hasText(status) ? status.trim() : null).stream()
@@ -1591,49 +1330,7 @@ public class DeliveryTransferService {
         } catch (JsonProcessingException exception) { throw new IllegalStateException("费用覆盖确认无法读取", exception); }
     }
 
-    private void bindTailOrders(String customerId, List<DispatchItem> items, String outboundNo, String deliveryNo,
-                                String remark, LocalDateTime now) {
-        Set<Long> orderIds = new LinkedHashSet<>();
-        items.stream().map(DispatchItem::getOrderId).filter(Objects::nonNull).forEach(orderIds::add);
-        List<Long> palletIds = items.stream().map(DispatchItem::getPlanPalletId).filter(Objects::nonNull).distinct().toList();
-        if (!palletIds.isEmpty()) {
-            List<InboundPlanPalletAllocation> allocations = planAllocations.selectList(
-                new LambdaQueryWrapper<InboundPlanPalletAllocation>().in(InboundPlanPalletAllocation::getPalletId, palletIds));
-            List<Long> lineIds = allocations.stream().map(InboundPlanPalletAllocation::getLineId)
-                .filter(Objects::nonNull).distinct().toList();
-            if (!lineIds.isEmpty()) {
-                planLines.selectBatchIds(lineIds).stream().map(InboundPlanLine::getOrderId)
-                    .filter(Objects::nonNull).forEach(orderIds::add);
-            }
-        }
-        if (orderIds.isEmpty()) return;
-        for (LastlegOrder order : tailOrders.selectList(new LambdaQueryWrapper<LastlegOrder>()
-            .eq(LastlegOrder::getCustomerId, customerId).in(LastlegOrder::getId, orderIds))) {
-            String from = order.getCurrentStatus(); order.setOutboundOrderNo(outboundNo);
-            order.setDeliveryOrderNo(deliveryNo); order.setCurrentStatus("WAIT_OUTBOUND"); order.setUpdatedAt(now);
-            order.setSubOrderStatus("OUTBOUND:WAIT_OUTBOUND;DELIVERY:WAIT_DELIVERY");
-            tailOrders.updateById(order);
-            LastlegOrderStatusHistory history = new LastlegOrderStatusHistory(); history.setCustomerId(customerId); history.setOrderId(order.getId());
-            history.setFromStatus(from); history.setToStatus("WAIT_OUTBOUND");
-            history.setEventId("TRANSFER_DELIVERY:" + deliveryNo);
-            history.setRemark(StringUtils.hasText(remark) ? remark.trim() : "Transferred to outbound and delivery documents");
-            history.setCreatedAt(now); histories.insert(history);
-        }
-    }
-
-    private List<DeliveryOrder> requireDeliveries(String customerId, Long outboundId) {
-        List<DeliveryOrder> values = deliveryOrders.lockByOutbound(customerId, outboundId);
-        if (values.isEmpty()) throw new IllegalStateException("Delivery documents are missing for outbound order");
-        return values;
-    }
-    private DeliveryResponses.TransferResult result(OutboundOrder o, List<DeliveryOrder> deliveries, boolean replayed) {
-        return new DeliveryResponses.TransferResult(o.getDispatchNo(), o.getOutboundNo(), o.getStatus(),
-            o.getPalletCount(), o.getPackageCount(), deliveries.stream().map(d -> new DeliveryResponses.TransferDelivery(
-                d.getDeliveryNo(), d.getStatus(), d.getDestinationWarehouseId(), d.getDestinationWarehouseCode(),
-                d.getDestinationWarehouseName(), value(d.getPalletCount()), value(d.getPackageCount()))).toList(), replayed);
-    }
-    /** 出库列表及详情头部按物理箱数汇总，退货件数不充当箱数。 */
-    private DeliveryResponses.OutboundRow outboundRow(OutboundOrder o) { return new DeliveryResponses.OutboundRow(o.getId(), o.getOutboundNo(), o.getDispatchNo(), o.getOverseasWarehouseId(), "DISCARD_OUTBOUND".equals(o.getOutboundType()) ? null : o.getLxCodes(), o.getStatus(), o.getPalletCount(), "DISCARD_OUTBOUND".equals(o.getOutboundType()) ? outboundQuantities.boxes(o) : o.getPackageCount(), o.getGrossWeightKg(), o.getVolumeWeightKg(), o.getVolumeCbm(), o.getCreatedAt(), o.getOutboundType()); }
+    private DeliveryResponses.OutboundRow outboundRow(OutboundOrder o) { return new DeliveryResponses.OutboundRow(o.getId(), o.getOutboundNo(), o.getDispatchNo(), o.getOverseasWarehouseId(), "DISCARD_OUTBOUND".equals(o.getOutboundType()) ? null : o.getLxCodes(), o.getStatus(), o.getPalletCount(), o.getPackageCount(), o.getGrossWeightKg(), o.getVolumeWeightKg(), o.getVolumeCbm(), o.getCreatedAt(), o.getOutboundType()); }
     private DeliveryResponses.OutboundPalletRow outboundPalletRow(OutboundPalletItem item) {
         return new DeliveryResponses.OutboundPalletRow(item.getId(), item.getPalletNo(), item.getCartonMarks(),
             item.getInboundCode(), item.getDestinationWarehouseCode(), item.getDestinationWarehouseName(),
@@ -1655,7 +1352,6 @@ public class DeliveryTransferService {
     private DeliveryResponses.DeliveryFeeRow feeRow(OverseasFeeSource f) { return new DeliveryResponses.DeliveryFeeRow(f.getId(), f.getDirection(), f.getFeeItemCode(), f.getOriginalCurrency(), f.getOriginalAmount(), f.getReviewReason(), f.getReviewStatus(), f.getSourceStatus(), f.getVoidStatus()); }
     private DeliveryResponses.DeliveryOperationRow operationRow(DeliveryOperation o) { return new DeliveryResponses.DeliveryOperationRow(o.getId(), o.getCreatedAt(), o.getOperationNode(), firstText(o.getOperatorName(), o.getOperatorId()), o.getResult()); }
     private void recordOperation(String customerId, Long deliveryId, String operatorId, String node, String result, LocalDateTime now) { DeliveryOperation operation = new DeliveryOperation(); operation.setCustomerId(customerId); operation.setDeliveryOrderId(deliveryId); operation.setOperationNode(node); operation.setOperatorId(operatorId); operation.setOperatorName(operatorId); operation.setResult(result); operation.setCreatedAt(now); deliveryOperations.insert(operation); }
-    private LastlegOrder firstTailOrder(String customerId, List<DispatchItem> items) { return items.stream().map(DispatchItem::getOrderId).filter(Objects::nonNull).map(tailOrders::selectById).filter(Objects::nonNull).filter(order -> customerId.equals(order.getCustomerId())).findFirst().orElse(null); }
     private String deliveryGroupKey(DispatchItem item) {
         if ("PRIVATE".equals(item.getDestinationType()) && StringUtils.hasText(item.getDeliveryAddress())) {
             return "PRIVATE:" + item.getDeliveryAddress().trim() + ":" + Objects.toString(item.getPostalCode(), "").trim();
@@ -1665,16 +1361,6 @@ public class DeliveryTransferService {
         if (StringUtils.hasText(item.getDestinationWarehouseId())) return "ID:" + item.getDestinationWarehouseId().trim();
         throw conflict("Dispatch pallet is missing its destination");
     }
-    private String resolveLxCodes(String customerId, List<DispatchItem> items) {
-        List<String> inboundCodes = items.stream().map(DispatchItem::getInboundCode)
-            .filter(StringUtils::hasText).map(String::trim).distinct().toList();
-        if (inboundCodes.isEmpty()) return "";
-        return tailOrders.selectList(new LambdaQueryWrapper<LastlegOrder>()
-                .eq(LastlegOrder::getCustomerId, customerId)
-                .in(LastlegOrder::getInboundCode, inboundCodes))
-            .stream().map(LastlegOrder::getLxCode).filter(StringUtils::hasText)
-            .map(String::trim).distinct().collect(java.util.stream.Collectors.joining(","));
-    }
     private void updateOutboundPickingStatus(String customerId, OutboundOrder outbound) {
         List<OutboundPalletItem> items = outboundPallets.findByOutbound(customerId, outbound.getId());
         String nextStatus = !items.isEmpty() && items.stream().allMatch(item -> "PICKED".equals(item.getStatus()))

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/service/DispatchDeliveryFees.java

@@ -0,0 +1,179 @@
+package com.baiyue.lastleg.delivery.service;
+
+import com.baiyue.lastleg.client.FinanceFeeCoverageClient;
+import com.baiyue.lastleg.delivery.dto.DeliveryFeeCoverageModels;
+import com.baiyue.lastleg.delivery.entity.DeliveryOrder;
+import com.baiyue.lastleg.delivery.entity.DeliveryOperation;
+import com.baiyue.lastleg.delivery.model.DeliveryCargoGroups;
+import com.baiyue.lastleg.delivery.model.DeliveryCargoGroups.Group;
+import com.baiyue.lastleg.delivery.repository.DispatchDeliveryRepository;
+import com.baiyue.lastleg.dispatch.port.DispatchContracts.*;
+import com.baiyue.lastleg.dispatch.port.DispatchDeliveryModels.*;
+import com.baiyue.lastleg.financefee.dto.OverseasFeeSourceDtos;
+import com.baiyue.lastleg.financefee.service.OverseasFeeSourceService;
+import com.baiyue.lastleg.fleet.trip.FleetBookingFreight;
+import com.baiyue.lastleg.fleet.trip.FleetDispatchGateway;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.web.server.ResponseStatusException;
+import java.math.BigDecimal;
+import java.time.*;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/** 逐客户逐目的地确认报价与覆盖，费用只归属于该组真实派送。 */
+@Service
+public class DispatchDeliveryFees {
+    private final FleetBookingFreight external;
+    private final FinanceFeeCoverageClient finance;
+    private final OverseasFeeSourceService fees;
+    private final DeliveryCargoGroups groups;
+    private final DispatchDeliveryRepository repository;
+    private final String internalToken;
+    private static final Set<String> SERVICES=Set.of("DELIVERY_FEE","LOADING_FEE","APPOINTMENT_FEE");
+
+    /** 复用现有报价、费用发布和Finance只读契约，不引入另一套账务。 */
+    public DispatchDeliveryFees(FleetBookingFreight external,FinanceFeeCoverageClient finance,
+        OverseasFeeSourceService fees,DeliveryCargoGroups groups,DispatchDeliveryRepository repository,
+        @Value("${baiyue.security.internal-service-token}") String internalToken) {
+        this.external=external;this.finance=finance;this.fees=fees;this.groups=groups;
+        this.repository=repository;this.internalToken=internalToken;
+    }
+
+    /** 一客户一次按全部真实来源校验外接实收，避免将一笔完整报价按目的地重复核价。 */
+    public Map<String,FleetBookingFreight.Preview> external(Context context) {
+        var byCustomer=context.cargo().stream().collect(Collectors.groupingBy(CargoLine::customerId,TreeMap::new,Collectors.toList()));
+        var result=new LinkedHashMap<String,FleetBookingFreight.Preview>();
+        for (var entry:byCustomer.entrySet()) {
+            var cargo=entry.getValue().stream().map(c->new FleetDispatchGateway.SourceCargo(c.inboundCode(),
+                c.warehousePalletId()==null?null:c.warehousePalletId().toString(),c.palletNo(),Math.toIntExact(c.packages()),c.destination().key())).toList();
+            result.put(entry.getKey(),external.preview(context.dispatchId(),context.dispatchNo(),entry.getKey(),cargo));
+        }
+        return result;
+    }
+
+    /** 原费候选按客户批量只读，响应越界或不可用直接失败，不能认作已覆盖。 */
+    public List<FinanceFeeCoverageClient.Fee> original(String customerId,List<CargoLine> cargo) {
+        var ids=new TreeSet<Long>();
+        for (var row:cargo) if ("FIRSTLEG".equals(row.sourceRegion())) {
+            try { long id=Long.parseLong(row.sourceInboundId());if(id<=0)throw new NumberFormatException();ids.add(id); }
+            catch (RuntimeException invalid) { throw conflict("原头程货物缺少真实来源关联"); }
+        }
+        if (ids.isEmpty()) return List.of();
+        try {
+            var response=finance.sources(internalToken,new FinanceFeeCoverageClient.Query(Long.valueOf(customerId),List.copyOf(ids)));
+            if (response==null || !response.successful() || response.data()==null) throw unavailable();
+            for (var fee:response.data()) if (fee==null || fee.financeFeeId()==null || fee.financeFeeId()<=0
+                || fee.sourceFeeId()==null || !Objects.equals(fee.customerId(),Long.valueOf(customerId))
+                || !ids.contains(fee.sourceInboundId()) || fee.sourceVersion()<1 || blank(fee.sourceHash())
+                || fee.amount()==null || fee.amount().signum()<0 || !"CNY".equals(fee.currency())
+                || !Set.of("INBOUND_FEE","CONTAINER_FEE").contains(fee.sourceType())
+                || !Set.of("AVAILABLE","SETTLED").contains(fee.status())) throw unavailable();
+            return response.data();
+        } catch (RuntimeException unavailable) { throw unavailable(); }
+    }
+
+    /** 平台按真实组服务范围确认原费，返回不可变证据供客户出库保存。 */
+    public DeliveryFeeCoverageModels.Evidence coverage(Group group,ArrangeGroup input,String operatorId,
+        FleetBookingFreight.Preview freight) {
+        var selected=input.feeCoverage()==null?List.<CoverageSelection>of():input.feeCoverage();
+        if (selected.isEmpty()) return null;
+        if (!Objects.equals(group.cargoHash(),input.feeCoverageCargoHash())) throw conflict("原费用对应货物已变化");
+        var candidates=original(group.customerId(),group.cargo());
+        var references=new ArrayList<DeliveryFeeCoverageModels.Reference>(); var scopes=new HashSet<String>();
+        for (var selection:selected) {
+            if (selection==null || selection.services()==null || selection.services().isEmpty()) throw conflict("请选择明确包含的服务");
+            var fee=candidates.stream().filter(f->Objects.equals(f.financeFeeId(),selection.financeFeeId())).findFirst()
+                .orElseThrow(()->conflict("原费用不属于本客户本次货物或已失效"));
+            if (fee.sourceVersion()!=selection.sourceVersion() || !Objects.equals(fee.sourceHash(),selection.sourceHash()))
+                throw conflict("原费用版本已变化，请重新核对");
+            var services=new TreeSet<>(selection.services());
+            if (services.size()!=selection.services().size() || !SERVICES.containsAll(services)) throw conflict("原费用服务范围重复或无效");
+            for (var service:services) if (!scopes.add(fee.sourceInboundId()+":"+service)) throw conflict("同一来源服务不得重复引用原费");
+            references.add(new DeliveryFeeCoverageModels.Reference(fee,List.copyOf(services)));
+        }
+        var cargo=group.cargo().stream().map(c->new DeliveryFeeCoverageModels.Cargo(c.dispatchItemId(),c.warehousePalletId(),
+            c.palletNo(),c.orderId(),c.sourceRegion(),c.sourceInboundId(),c.inboundCode(),c.packages(),c.inboundCode())).toList();
+        return new DeliveryFeeCoverageModels.Evidence(group.cargoHash(),cargo,List.copyOf(references),operatorId,Instant.now());
+    }
+
+    /** 按每条真实来源判断某服务是否已含，外接约定只覆盖派送服务。 */
+    private boolean covered(CargoLine cargo,String service,DeliveryFeeCoverageModels.Evidence evidence,FleetBookingFreight.Preview freight) {
+        if ("DELIVERY_FEE".equals(service) && freight.quotes().stream().anyMatch(q->Objects.equals(q.inboundCode(),cargo.inboundCode()))) return true;
+        return evidence!=null && "FIRSTLEG".equals(cargo.sourceRegion()) && evidence.references().stream().anyMatch(r->
+            Objects.equals(r.source().sourceInboundId().toString(),cargo.sourceInboundId()) && r.services().contains(service));
+    }
+
+    /** 所有收费资格在创建子单前核验，新增应收只能针对未覆盖来源。 */
+    public void validate(Group group,ArrangeGroup input,DeliveryFeeCoverageModels.Evidence evidence,FleetBookingFreight.Preview freight) {
+        if (input.plannedDeliveryAt()==null || blank(input.deliveryMethod()) || blank(input.pickupMethod()) || blank(input.loadingType()))
+            throw conflict("请补齐每个客户目的地的派送信息");
+        if (!Objects.equals(input.groupCargoHash(),group.cargoHash())) throw conflict("派送货物分组已变化");
+        if (!Objects.equals(input.externalFreightHash(),freight.snapshotHash())) throw conflict("外接实收或约定运费已变化");
+        var seen=new HashSet<String>();
+        for (var fee:input.fees()==null?List.<FeeItem>of():input.fees()) {
+            if (fee==null || blank(fee.feeType()) || !SERVICES.contains(fee.feeType()) || blank(fee.direction()) || !Set.of("RECEIVABLE","PAYABLE").contains(fee.direction())
+                || blank(fee.currency()) || !Set.of("CNY","USD").contains(fee.currency()) || blank(fee.feeName()) || fee.amount()==null || fee.amount().signum()<=0)
+                throw conflict("派送费用类型、方向、币种或金额不合法");
+            if (!seen.add(fee.direction()+":"+fee.feeType())) throw conflict("同组同方向同费用不得重复登记");
+            if ("RECEIVABLE".equals(fee.direction()) && group.cargo().stream().allMatch(c->covered(c,fee.feeType(),evidence,freight)))
+                throw conflict("本组该服务已全部覆盖，不得重复登记应收");
+        }
+        var required=new HashSet<String>(); required.add("DELIVERY_FEE");
+        if (Set.of("FLOOR","MIXED").contains(input.loadingType())) required.add("LOADING_FEE");
+        if ("BUY_APPOINTMENT".equals(input.appointmentAccount())) {
+            if (blank(input.sellerName())) throw conflict("买约须填写卖家名称");required.add("APPOINTMENT_FEE");
+        }
+        for (var code:required) if (group.cargo().stream().anyMatch(c->!covered(c,code,evidence,freight)) && !seen.contains("RECEIVABLE:"+code))
+            throw conflict("本组尚有未覆盖的服务费用，请核对" );
+    }
+
+    /** 子单及来源锁已经收齐后才核对原费用撤销状态，不能重复收费。 */
+    public void requireOriginalVoided(String customerId,FleetBookingFreight.Preview freight) {
+        fees.requireNoActiveDeliveryReceivables(customerId,freight.priorInboundCodes());
+    }
+
+    /** 费用与子单同事务保存，只向真实客户目的地发布一次正数来源。 */
+    public void publish(Context context,Group group,ArrangeGroup input,DeliveryOrder delivery,
+        DeliveryFeeCoverageModels.Evidence evidence,FleetBookingFreight.Preview freight,String operatorId,String arrangementKey) {
+        var now=LocalDateTime.now();
+        for (var quote:freight.quotes()) if (Objects.equals(quote.destinationKey(),group.destination().key())
+            && group.cargo().stream().anyMatch(c->Objects.equals(c.inboundCode(),quote.inboundCode()))) {
+            var operation=new DeliveryOperation();operation.setCustomerId(group.customerId());operation.setDeliveryOrderId(delivery.getId());
+            operation.setOperatorId(operatorId);operation.setOperationNode("CONFIRM_EXTERNAL_FREIGHT");
+            operation.setResult("外接预订 "+quote.bookingNo()+"；实收确认版本 "+quote.recordVersion()+"；约定运费 "+quote.currency()+" "+quote.amount().toPlainString());
+            operation.setCreatedAt(now);repository.operation(operation);
+            if (quote.amount().signum()==0) continue;
+            fees.publishApproved(operatorId,groups.hash(List.of(arrangementKey,group.key(),quote.bookingNo(),"FREIGHT")),
+                save(group,delivery,null,"DELIVERY_FEE","外接约定运费", "RECEIVABLE",quote.currency(),quote.amount(),
+                    quote.quantity(),quote.quantityUnit(),quote.unitPrice(),null,quote.inboundCode()));
+        }
+        for (var fee:input.fees()==null?List.<FeeItem>of():input.fees()) {
+            var charged=group.cargo().stream().filter(c->!"RECEIVABLE".equals(fee.direction())||!covered(c,fee.feeType(),evidence,freight)).toList();
+            var orders=charged.stream().map(CargoLine::orderId).filter(Objects::nonNull).distinct().toList();
+            var inbound=charged.stream().map(CargoLine::inboundCode).filter(Objects::nonNull).distinct().toList();
+            fees.publishApproved(operatorId,groups.hash(List.of(arrangementKey,group.key(),fee.direction(),fee.feeType())),
+                save(group,delivery,orders.size()==1?orders.get(0):null,fee.feeType(),fee.feeName(),fee.direction(),fee.currency(),
+                    fee.amount(),fee.chargeableQuantity(),fee.quantityUnit(),fee.unitPrice(),fee,inbound.size()==1?inbound.get(0):null));
+        }
+    }
+
+    /** 多来源不借第一票挂账，供应商应付与客户覆盖独立。 */
+    private OverseasFeeSourceDtos.SaveRequest save(Group group,DeliveryOrder delivery,Long orderId,String code,String name,
+        String direction,String currency,BigDecimal amount,BigDecimal quantity,String unit,BigDecimal unitPrice,FeeItem input,String inboundCode) {
+        return new OverseasFeeSourceDtos.SaveRequest(group.customerId(),group.customerName(),"OVERSEAS_DELIVERY_FEE","DELIVERY_ORDER",
+            delivery.getId(),delivery.getDeliveryNo(),orderId,null,inboundCode,null,null,null,Long.valueOf(delivery.getOverseasWarehouseId()),
+            code,name,direction,input==null?null:input.supplierId(),input==null?null:input.supplierName(),input==null?null:input.supplierCategory(),
+            input==null?null:input.settlementMode(),input==null||input.paidAt()==null?null:LocalDateTime.ofInstant(input.paidAt(),ZoneId.systemDefault()),
+            input==null?null:input.paymentMethod(),input==null?null:input.paymentReferenceNo(),input==null?null:input.paymentVoucherFileIds(),
+            LocalDate.now(),currency,amount,quantity,unit,unitPrice,input==null?null:input.periodStart(),input==null?null:input.periodEnd());
+    }
+
+    /** 只有真实业务标识可用于费用归属。 */
+    private static boolean blank(String value) { return value==null||value.isBlank(); }
+    /** 财务只读失败不降级为已覆盖或零费。 */
+    private static ResponseStatusException unavailable() { return new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,"原费用来源暂不可用，请稍后核对"); }
+    /** 校验失败由外层事务回滚所有客户单据。 */
+    private static ResponseStatusException conflict(String reason) { return new ResponseStatusException(HttpStatus.CONFLICT,reason); }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/service/DispatchDeliveryService.java

@@ -0,0 +1,354 @@
+package com.baiyue.lastleg.delivery.service;
+
+import com.baomidou.mybatisplus.core.toolkit.IdWorker;
+import com.baiyue.lastleg.delivery.entity.*;
+import com.baiyue.lastleg.delivery.dto.DeliveryFeeCoverageModels;
+import com.baiyue.lastleg.delivery.model.*;
+import com.baiyue.lastleg.delivery.model.DeliveryCargoGroups.Group;
+import com.baiyue.lastleg.delivery.repository.DispatchDeliveryRepository;
+import com.baiyue.lastleg.dispatch.port.*;
+import com.baiyue.lastleg.dispatch.port.DispatchContracts.*;
+import com.baiyue.lastleg.dispatch.port.DispatchDeliveryModels.*;
+import com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
+import com.baiyue.lastleg.entity.LastlegOrderStatusHistory;
+import com.baiyue.lastleg.service.LastlegOrderNoGenerator;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.*;
+import org.springframework.web.server.ResponseStatusException;
+import java.math.BigDecimal;
+import java.time.*;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/** 整车安排只有一个事务，真实客户单据、费用及主流程命令共同提交。 */
+@Service
+public class DispatchDeliveryService implements DispatchDeliveryPort {
+    private final DispatchExecutionPort execution;
+    private final DispatchDeliveryRepository repository;
+    private final DeliveryCargoGroups grouping;
+    private final DispatchDeliveryFees fees;
+    private final NormalDeliveryCompletionPolicy completion;
+    private final LastlegOrderNoGenerator numbers;
+    private final ObjectMapper json;
+
+    /** 消费主流程实际公共骨架，禁止注入对方Controller或具体Service。 */
+    public DispatchDeliveryService(@org.springframework.context.annotation.Lazy DispatchExecutionPort execution,DispatchDeliveryRepository repository,
+        DeliveryCargoGroups grouping,DispatchDeliveryFees fees,NormalDeliveryCompletionPolicy completion,
+        LastlegOrderNoGenerator numbers,ObjectMapper json) {
+        this.execution=execution;this.repository=repository;this.grouping=grouping;this.fees=fees;
+        this.completion=completion;this.numbers=numbers;this.json=json;
+    }
+
+    /** 组合GET的入口上下文和本地派送数据加入同一个只读快照。 */
+    @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
+    public ArrangementPreview preview(Actor actor,String dispatchNo) {
+        return preview(execution.preview(actor,dispatchNo));
+    }
+
+    /** 外部原费只读带版本证据，不能声称参与Lastleg数据库同刻快照。 */
+    @Override
+    @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
+    public ArrangementPreview preview(Context context) {
+        var saved=repository.arrangement(context.dispatchId(),false);
+        var result=saved==null?null:read(saved.getResultJson(),ArrangementResult.class);
+        var gate=arrangementGate(context);
+        if (context.cargo()==null || context.cargo().isEmpty() || !context.pickingReconciled())
+            return new ArrangementPreview(context.dispatchNo(),context.recordVersion(),context.status(),context.stage(),
+                context.cargoHash(),context.loadingCompletionHash(),gate,List.of(),result);
+        var groups=grouping.groups(context); var external=fees.external(context);
+        var original=new HashMap<String,List<com.baiyue.lastleg.client.FinanceFeeCoverageClient.Fee>>();
+        for (var customer:groups.stream().map(Group::customerId).distinct().toList())
+            original.put(customer,fees.original(customer,context.cargo().stream().filter(c->customer.equals(c.customerId())).toList()));
+        var previews=new ArrayList<PreviewGroup>();
+        for (var group:groups) {
+            var freight=external.get(group.customerId());
+            var quotes=freight.quotes().stream().filter(q->Objects.equals(q.destinationKey(),group.destination().key())
+                && group.cargo().stream().anyMatch(c->Objects.equals(c.inboundCode(),q.inboundCode())))
+                .map(q->new ExternalQuote(group.customerId(),group.key(),q.bookingNo(),q.inboundCode(),q.currency(),q.amount(),freight.snapshotHash())).toList();
+            var candidates=original.get(group.customerId()).stream().filter(f->group.cargo().stream().anyMatch(c->
+                Objects.equals(c.sourceInboundId(),f.sourceInboundId().toString())))
+                .map(f->new FeeCandidate(f.financeFeeId(),group.customerId(),f.currency(),f.amount(),f.sourceVersion(),f.sourceHash(),
+                    f.status(),List.of("DELIVERY_FEE","LOADING_FEE","APPOINTMENT_FEE"),group.cargo().stream()
+                        .filter(c->Objects.equals(c.sourceInboundId(),f.sourceInboundId().toString())).map(CargoLine::sourceKey).distinct().toList())).toList();
+            var required=group.cargo().stream().anyMatch(c->freight.quotes().stream().noneMatch(q->Objects.equals(q.inboundCode(),c.inboundCode())))
+                ?List.of("DELIVERY_FEE"):List.<String>of();
+            previews.add(new PreviewGroup(group.key(),group.customerId(),group.customerName(),group.destination(),group.cargoHash(),group.cargo(),
+                freight.snapshotHash(),quotes,group.cargoHash(),candidates,required,List.of()));
+        }
+        return new ArrangementPreview(context.dispatchNo(),context.recordVersion(),context.status(),context.stage(),context.cargoHash(),
+            context.loadingCompletionHash(),gate,List.copyOf(previews),result);
+    }
+
+    /** 先共同父锁和严格命令恢复，再按客户与目的地原子创建全车单据。 */
+    @Override
+    @Transactional(isolation=Isolation.READ_COMMITTED)
+    public CommandResult arrange(Actor actor,String dispatchNo,ArrangeDelivery request) {
+        if (actor==null || actor.mode()!=ActorMode.PLATFORM) throw new ResponseStatusException(HttpStatus.FORBIDDEN,"整车派送由平台安排");
+        if (request==null || request.recordVersion()<0 || blank(request.idempotencyKey()) || request.idempotencyKey().length()>255
+            || blank(request.cargoHash()) || blank(request.loadingCompletionHash()) || request.groups()==null || request.groups().isEmpty()
+            || request.groups().size()>200) throw conflict("安排派送请求不完整");
+        var canonical=canonical(request);
+        var context=execution.lockForArrangement(actor,dispatchNo);
+        var identity=new CommandIdentity(Action.ARRANGE_DELIVERY,request.idempotencyKey(),request.recordVersion(),
+            grouping.hash(List.of(actor,Action.ARRANGE_DELIVERY,context.dispatchNo(),canonical)));
+        var replay=execution.replay(context,actor,identity);
+        if (replay.isPresent()) return replay.get();
+        String businessHash=grouping.hash(Arrays.asList(context.dispatchNo(),canonical.cargoHash(),canonical.loadingCompletionHash(),canonical.groups()));
+        var saved=repository.arrangement(context.dispatchId(),true);
+        if (saved!=null) {
+            if (context.recordVersion()!=request.recordVersion() || !Objects.equals(saved.getBusinessHash(),businessHash))
+                throw conflict("本车已安排派送，当前版本或业务内容不同");
+            var current=departureFacts(context,true);
+            // 发车后的原安排也可作为既有业务事实读取，但取消/缺项绝不能补建为成功。
+            if (context.status()!=Status.ACTIVE || current.outbounds().isEmpty()
+                || current.outbounds().stream().anyMatch(o->"CANCELLED".equals(o.status()))
+                || current.deliveries().stream().anyMatch(d->"CANCELLED".equals(d.status()))
+                || !completeDocuments(context,saved,repository.outbounds(context.dispatchId(),false),repository.deliveries(context.dispatchId(),false)))
+                throw conflict("原安排单据不完整或已取消，请核对原单据");
+            return execution.recordArrangement(context,actor,identity,fact(saved),true);
+        }
+        execution.requireFreshArrangement(context,request.recordVersion());
+        if (!Objects.equals(context.cargoHash(),request.cargoHash()) || !Objects.equals(context.loadingCompletionHash(),request.loadingCompletionHash()))
+            throw conflict("装车或实际货物已经变化，请重新核对");
+        var groups=grouping.groups(context); var inputs=new HashMap<String,ArrangeGroup>();
+        for (var input:canonical.groups()) if (input==null || inputs.putIfAbsent(input.groupKey(),input)!=null) throw conflict("派送分组重复");
+        if (!inputs.keySet().equals(groups.stream().map(Group::key).collect(Collectors.toSet()))) throw conflict("必须一次安排本车全部客户目的地");
+        // 即使缺少唯一安排记录，也不把已有孤立客户单据当成可重建的半车。
+        var existingOutbounds=repository.outbounds(context.dispatchId(),true);
+        var existingDeliveries=repository.deliveries(context.dispatchId(),true);
+        if (!existingOutbounds.isEmpty() || !existingDeliveries.isEmpty()) throw conflict("已存在关联单据但缺少完整安排事实，请核对");
+        var external=fees.external(context);var coverages=new HashMap<String,DeliveryFeeCoverageModels.Evidence>();
+        for (var group:groups) {
+            var input=inputs.get(group.key());var coverage=fees.coverage(group,input,actor.operatorId(),external.get(group.customerId()));
+            fees.validate(group,input,coverage,external.get(group.customerId()));coverages.put(group.key(),coverage);
+        }
+        var now=Instant.now();String key="DLA"+IdWorker.getId();var outbounds=new LinkedHashMap<String,OutboundOrder>();
+        for (var customer:groups.stream().map(Group::customerId).distinct().sorted().toList()) {
+            var cargo=context.cargo().stream().filter(c->customer.equals(c.customerId())).toList();
+            var order=new OutboundOrder();order.setId(IdWorker.getId());order.setCustomerId(customer);
+            order.setOutboundNo(numbers.next("OUTBOUND",context.warehouseId(),order.getId()));
+            order.setDispatchOrderId(context.dispatchId());order.setDispatchNo(context.dispatchNo());order.setOverseasWarehouseId(context.warehouseId());
+            order.setOutboundType("DISPATCH_DELIVERY");order.setStatus("WAIT_OUTBOUND");order.setLxCodes("");
+            order.setPackageCount(Math.toIntExact(cargo.stream().mapToLong(CargoLine::packages).sum()));
+            order.setPalletCount((int)cargo.stream().map(CargoLine::warehousePalletId).filter(Objects::nonNull).distinct().count());
+            order.setGrossWeightKg(metric(cargo,CargoLine::grossWeightKg));order.setVolumeCbm(metric(cargo,CargoLine::volumeCbm));
+            order.setIdempotencyKey(grouping.hash(List.of(key,customer,"OUTBOUND")));order.setRequestHash(businessHash);
+            order.setCreatedBy(actor.operatorId());order.setCreatedAt(local(now));order.setUpdatedAt(local(now));
+            var covered=groups.stream().filter(g->g.customerId().equals(customer)).map(g->coverages.get(g.key())).filter(Objects::nonNull).toList();
+            if (!covered.isEmpty()) order.setFeeCoverageJson(write(mergeCoverage(covered,actor.operatorId())));
+            repository.create(order);outbounds.put(customer,order);
+        }
+        var deliveries=new LinkedHashMap<String,DeliveryOrder>();
+        for (var group:groups) {
+            var input=inputs.get(group.key());var outbound=outbounds.get(group.customerId());
+            var delivery=delivery(context,group,input,outbound,actor.operatorId(),key,now);
+            repository.create(delivery);deliveries.put(group.key(),delivery);
+            for (var row:group.cargo()) {
+                var item=new OutboundPalletItem();item.setId(IdWorker.getId());item.setCustomerId(row.customerId());item.setOutboundOrderId(outbound.getId());
+                item.setDispatchItemId(row.dispatchItemId());item.setSourceAttributionId(row.attributionId());item.setSourceOrderId(row.orderId());
+                item.setSourceInventoryPositionId(row.inventoryPositionId());item.setSourceReturnReceiptId(row.returnReceiptId());item.setSourceReturnCartonId(row.returnCartonId());
+                item.setWarehousePalletId(row.warehousePalletId());item.setPalletNo(row.palletNo());item.setInboundCode(row.inboundCode());
+                item.setDestinationWarehouseId(group.destination().warehouseId());item.setDestinationWarehouseCode(group.destination().warehouseCode());
+                item.setDestinationWarehouseName(group.destination().warehouseName());item.setPackageCount(Math.toIntExact(row.packages()));
+                item.setPickedPackageCount(Math.toIntExact(row.packages()));item.setStatus("PICKED");
+                item.setGrossWeightKg(row.grossWeightKg());item.setVolumeCbm(row.volumeCbm());item.setCartonMarks(row.cartonMark());
+                item.setOrderRefs(row.orderNo());item.setCreatedAt(local(now));repository.create(item);
+            }
+        }
+        // 所有出库/派送均已插入且持有写锁，此后才申请本次全部来源锁。
+        bindSources(context,groups,outbounds,deliveries,now);
+        for (var customer:external.keySet()) fees.requireOriginalVoided(customer,external.get(customer));
+        for (var group:groups) fees.publish(context,group,inputs.get(group.key()),deliveries.get(group.key()),coverages.get(group.key()),
+            external.get(group.customerId()),actor.operatorId(),key);
+        var result=new ArrangementResult(context.dispatchNo(),context.recordVersion()+1,key,context.cargoHash(),now,
+            outboundRefs(outbounds.values(),groups),deliveryRefs(deliveries.values(),groups));
+        var arrangement=new DispatchDeliveryArrangement();arrangement.setId(IdWorker.getId());arrangement.setDispatchOrderId(context.dispatchId());
+        arrangement.setDispatchNo(context.dispatchNo());arrangement.setArrangementKey(key);arrangement.setBusinessHash(businessHash);
+        arrangement.setCargoHash(context.cargoHash());arrangement.setLoadingCompletionHash(context.loadingCompletionHash());
+        arrangement.setOriginalCommandKey(request.idempotencyKey());arrangement.setOriginalOperatorId(actor.operatorId());
+        arrangement.setResultJson(write(result));arrangement.setCargoJson(write(context.cargo()));arrangement.setCreatedAt(local(now));repository.create(arrangement);
+        return execution.recordArrangement(context,actor,identity,fact(arrangement),false);
+    }
+
+    /** 发车先取得全部出库锁，再取得全部派送锁，当前读取不申请来源锁。 */
+    @Override
+    @Transactional(propagation=Propagation.MANDATORY)
+    public DepartureFacts departureFacts(Context context,boolean lock) {
+        var arrangement=repository.arrangement(context.dispatchId(),lock);
+        var outbounds=repository.outbounds(context.dispatchId(),lock);var deliveries=repository.deliveries(context.dispatchId(),lock);
+        var groups=context.cargo()==null||context.cargo().isEmpty()?List.<Group>of():grouping.groups(context);
+        String reason=arrangement==null?"请先安排本车全部客户派送":
+            !Objects.equals(arrangement.getCargoHash(),context.cargoHash()) || !Objects.equals(arrangement.getLoadingCompletionHash(),context.loadingCompletionHash())
+                ?"派送安排的装车或货物依据已经失效":!completeDocuments(context,arrangement,outbounds,deliveries)?"客户出库及派送未完整覆盖原安排":
+            outbounds.stream().anyMatch(o->!"WAIT_OUTBOUND".equals(o.getStatus())) || deliveries.stream().anyMatch(d->!"WAIT_DELIVERY".equals(d.getStatus())
+                || d.getSignedAt()!=null || d.getDispatchedAt()!=null)?"关联单据已执行或取消":null;
+        return new DepartureFacts(context.dispatchNo(),arrangement==null?null:arrangement.getArrangementKey(),context.cargoHash(),context.loadingCompletionHash(),
+            arrangement==null?null:arrangement.getBusinessHash(),outboundRefs(outbounds,groups),deliveryRefs(deliveries,groups),
+            context.cargo(),new Gate(reason==null,reason==null?null:"DELIVERY_NOT_READY",reason));
+    }
+
+    /** 只更新已锁单据，库存扣减及订单归属转换不在此重复执行。 */
+    @Override
+    @Transactional(propagation=Propagation.MANDATORY)
+    public DepartureResult markDeparted(Context context,Actor actor,Instant departedAt,String commandKey) {
+        if (departedAt==null) throw conflict("缺少实际发车时间");
+        var facts=departureFacts(context,true);if (!facts.depart().allowed()) throw conflict(facts.depart().blockReason());
+        var outbounds=repository.outbounds(context.dispatchId(),false);var deliveries=repository.deliveries(context.dispatchId(),false);
+        for (var outbound:outbounds) { outbound.setStatus("OUTBOUNDED");outbound.setUpdatedAt(local(departedAt));repository.save(outbound); }
+        for (var delivery:deliveries) { delivery.setStatus("DELIVERING");delivery.setDispatchedAt(local(departedAt));
+            delivery.setVersion(Objects.requireNonNullElse(delivery.getVersion(),0L)+1);delivery.setUpdatedAt(local(departedAt));repository.save(delivery); }
+        var groups=grouping.groups(context);
+        return new DepartureResult(outboundRefs(outbounds,groups),deliveryRefs(deliveries,groups),outbounds.stream().mapToLong(o->o.getPackageCount()).sum());
+    }
+
+    /** 签收汇总仅普通读取全部真实子单，不反向锁来源或再次发布费用。 */
+    @Override
+    @Transactional(readOnly=true,isolation=Isolation.READ_COMMITTED)
+    public NormalDeliveryFacts normalDeliveryFacts(Context context) {
+        var saved=repository.arrangement(context.dispatchId(),false);
+        var expected=saved==null?null:read(saved.getResultJson(),ArrangementResult.class);
+        var outbounds=repository.outbounds(context.dispatchId(),false);
+        var actual=new ArrayList<NormalDeliveryFact>();
+        for (var delivery:repository.deliveries(context.dispatchId(),false)) {
+            var outbound=outbounds.stream().filter(o->Objects.equals(o.getId(),delivery.getOutboundOrderId())
+                && Objects.equals(o.getCustomerId(),delivery.getCustomerId()) && Objects.equals(o.getOutboundNo(),delivery.getOutboundNo())).findFirst().orElse(null);
+            var destination=destination(delivery);String groupKey=grouping.groupKey(delivery.getCustomerId(),destination);
+            // 使用安排时原组身份，避免FBA领域键与单据CODE键的表示差异。
+            if (expected!=null) groupKey=expected.deliveries().stream().filter(d->d.deliveryNo().equals(delivery.getDeliveryNo()))
+                .map(DeliveryReference::groupKey).findFirst().orElse(groupKey);
+            long returned=repository.returns(delivery).stream().mapToLong(DeliveryReturnReceiptFact::packages).sum();
+            actual.add(new NormalDeliveryFact(delivery.getCustomerId(),groupKey,delivery.getOutboundNo(),delivery.getDeliveryNo(),
+                Objects.requireNonNullElse(delivery.getVersion(),0L),Objects.requireNonNullElse(delivery.getPackageCount(),0),
+                Objects.requireNonNullElse(delivery.getSignedPackages(),0),returned,repository.activeReturns(delivery),delivery.getStatus(),
+                DeliveryExecutionGuard.matches(delivery,outbound),delivery.getSignedAt()==null?null:instant(delivery.getSignedAt())));
+        }
+        var result=completion.evaluate(context,expected,actual,Instant.now());
+        if (saved!=null && !completeDocuments(context,saved,outbounds,repository.deliveries(context.dispatchId(),false))) {
+            var reasons=new ArrayList<>(result.blockReasons());reasons.add("本车出库及派送集合与原安排不一致");
+            return new NormalDeliveryFacts(result.dispatchNo(),result.factsHash(),false,null,result.expectedDeliveryNos(),result.deliveries(),List.copyOf(reasons));
+        }
+        return result;
+    }
+
+    /** 集合、客户、父引用和每组原始箱数全部相等，不仅比较全车总数。 */
+    private boolean completeDocuments(Context context,DispatchDeliveryArrangement arrangement,List<OutboundOrder> outbounds,List<DeliveryOrder> deliveries) {
+        var expected=read(arrangement.getResultJson(),ArrangementResult.class);
+        if (outbounds.size()!=expected.outbounds().size() || deliveries.size()!=expected.deliveries().size()) return false;
+        for (var ref:expected.outbounds()) if (outbounds.stream().filter(o->Objects.equals(o.getCustomerId(),ref.customerId())
+            && Objects.equals(o.getOutboundNo(),ref.outboundNo()) && Objects.equals(o.getDispatchOrderId(),context.dispatchId())
+            && Objects.equals(o.getOverseasWarehouseId(),context.warehouseId()) && Objects.equals((long)Objects.requireNonNullElse(o.getPackageCount(),0),ref.packageCount())).count()!=1) return false;
+        for (var ref:expected.deliveries()) if (deliveries.stream().filter(d->Objects.equals(d.getCustomerId(),ref.customerId())
+            && Objects.equals(d.getDeliveryNo(),ref.deliveryNo()) && Objects.equals(d.getOutboundNo(),ref.outboundNo())
+            && Objects.equals(d.getDispatchOrderId(),context.dispatchId()) && Objects.equals(d.getOverseasWarehouseId(),context.warehouseId())
+            && Objects.equals(d.getDeliveryGroupKey(),grouping.documentGroupKey(ref.destination()))
+            && Objects.equals((long)Objects.requireNonNullElse(d.getPackageCount(),0),ref.packageCount())
+            && outbounds.stream().anyMatch(o->Objects.equals(o.getId(),d.getOutboundOrderId()) && Objects.equals(o.getCustomerId(),d.getCustomerId()))).count()!=1) return false;
+        return expected.cargoHash().equals(context.cargoHash());
+    }
+
+    /** 按原实物来源数字ID一次锁齐全部来源，随后绑定状态和历史。 */
+    private void bindSources(Context context,List<Group> groups,Map<String,OutboundOrder> outbounds,Map<String,DeliveryOrder> deliveries,Instant now) {
+        var sources=new TreeMap<Long,List<CargoLine>>();
+        for (var row:context.cargo()) if(row.orderId()!=null)sources.computeIfAbsent(row.orderId(),ignored->new ArrayList<>()).add(row);
+        var locked=new TreeMap<Long,com.baiyue.lastleg.entity.LastlegOrder>();
+        for (var entry:sources.entrySet()) {
+            var customer=entry.getValue().get(0).customerId();
+            if(entry.getValue().stream().anyMatch(c->!customer.equals(c.customerId())))throw conflict("同一来源订单出现不同客户");
+            var source=repository.lockSource(customer,entry.getKey());
+            if(source==null||!Objects.equals(source.getCustomerId(),customer)||Boolean.TRUE.equals(source.getDetained()))throw conflict("派送来源订单不存在、暂扣或归属错误");
+            locked.put(entry.getKey(),source);
+        }
+        for (var entry:sources.entrySet()) {
+            var source=locked.get(entry.getKey());var outbound=outbounds.get(source.getCustomerId());
+            var refs=groups.stream().filter(g->g.cargo().stream().anyMatch(c->Objects.equals(c.orderId(),entry.getKey())))
+                .map(g->deliveries.get(g.key())).toList();
+            repository.bindSource(source,outbound.getOutboundNo(),refs.size()==1?refs.get(0).getDeliveryNo():null,local(now));
+            for(var delivery:refs) {var history=new LastlegOrderStatusHistory();history.setCustomerId(source.getCustomerId());history.setOrderId(source.getId());
+                history.setFromStatus(source.getCurrentStatus());history.setToStatus(source.getCurrentStatus());history.setEventId("TRANSFER_DELIVERY:"+delivery.getDeliveryNo());
+                history.setRemark("装车后按真实客户目的地安排派送");history.setCreatedAt(local(now));repository.sourceHistory(history);}
+        }
+    }
+
+    /** 客户、目的地和车辆司机仅来自权威事实，请求不能覆盖本趟资源。 */
+    private DeliveryOrder delivery(Context context,Group group,ArrangeGroup input,OutboundOrder outbound,String operator,String key,Instant now) {
+        var d=new DeliveryOrder();d.setId(IdWorker.getId());d.setCustomerId(group.customerId());d.setCustomerName(group.customerName());
+        d.setDeliveryNo(numbers.next("DELIVERY",context.warehouseId(),d.getId()));d.setOutboundOrderId(outbound.getId());d.setOutboundNo(outbound.getOutboundNo());
+        d.setDispatchOrderId(context.dispatchId());d.setDispatchNo(context.dispatchNo());d.setOverseasWarehouseId(context.warehouseId());d.setOverseasWarehouseName(context.warehouseName());
+        var destination=group.destination();d.setDeliveryGroupKey(grouping.documentGroupKey(destination));d.setDestinationType(destination.type());
+        d.setDestinationWarehouseId(destination.warehouseId());d.setDestinationWarehouseCode(destination.warehouseCode());d.setDestinationWarehouseName(destination.warehouseName());
+        d.setDeliveryAddress(destination.address());d.setPostalCode(destination.postalCode());d.setContactName(destination.contactName());d.setContactPhone(destination.contactPhone());
+        d.setStatus("WAIT_DELIVERY");d.setVersion(0L);d.setDeliveryMethod(input.deliveryMethod());d.setPlannedDeliveryAt(local(input.plannedDeliveryAt()));
+        d.setWaybillNo(input.waybillNo());d.setCarrierName(input.carrierName());d.setPickupMethod(input.pickupMethod());d.setLoadingType(input.loadingType());
+        d.setVehicleType(input.vehicleType());d.setVehicleSize(input.vehicleSize());d.setAppointmentAccount(input.appointmentAccount());d.setSellerName(input.sellerName());d.setRemark(input.remark());
+        if(context.resources()!=null){if(context.resources().vehicle()!=null)d.setVehiclePlate(context.resources().vehicle().plate());
+            if(context.resources().driver()!=null){d.setDriverName(context.resources().driver().name());d.setDriverPhone(context.resources().driver().phone());}}
+        d.setPackageCount(Math.toIntExact(group.packages()));d.setPalletCount(Math.toIntExact(group.palletCount()));
+        d.setTotalWeightKg(metric(group.cargo(),CargoLine::grossWeightKg));d.setTotalVolumeCbm(metric(group.cargo(),CargoLine::volumeCbm));
+        d.setIdempotencyKey(grouping.hash(List.of(key,group.key())));d.setCreatedBy(operator);d.setCreatedAt(local(now));d.setUpdatedAt(local(now));return d;
+    }
+
+    /** 输出全部真实客户出库，不能留单个outboundNo别名。 */
+    private List<OutboundReference> outboundRefs(Collection<OutboundOrder> rows,List<Group> groups) {
+        return rows.stream().map(o->new OutboundReference(o.getCustomerId(),groups.stream().filter(g->g.customerId().equals(o.getCustomerId()))
+            .map(Group::customerName).filter(Objects::nonNull).findFirst().orElse(null),o.getOutboundNo(),o.getStatus(),Objects.requireNonNullElse(o.getPackageCount(),0),Objects.requireNonNullElse(o.getPalletCount(),0))).toList();
+    }
+    /** 子单组身份由客户和目的地共同确定。 */
+    private List<DeliveryReference> deliveryRefs(Collection<DeliveryOrder> rows,List<Group> groups) {
+        return rows.stream().map(d->{var group=groups.stream().filter(g->g.customerId().equals(d.getCustomerId())
+            && grouping.documentGroupKey(g.destination()).equals(d.getDeliveryGroupKey())).findFirst().orElse(null);
+            var dest=group==null?destination(d):group.destination();return new DeliveryReference(group==null?grouping.groupKey(d.getCustomerId(),dest):group.key(),
+                d.getCustomerId(),d.getCustomerName(),d.getOutboundNo(),d.getDeliveryNo(),dest,d.getStatus(),Objects.requireNonNullElse(d.getPackageCount(),0),Objects.requireNonNullElse(d.getPalletCount(),0));}).toList();
+    }
+    /** 读取客户资料时只保留本客户来源与证据，原费用本身不复制为新来源。 */
+    private DeliveryFeeCoverageModels.Evidence mergeCoverage(List<DeliveryFeeCoverageModels.Evidence> rows,String operator) {
+        return new DeliveryFeeCoverageModels.Evidence(grouping.hash(rows.stream().map(DeliveryFeeCoverageModels.Evidence::cargoHash).toList()),
+            rows.stream().flatMap(e->e.cargo().stream()).toList(),rows.stream().flatMap(e->e.references().stream()).distinct().toList(),operator,Instant.now());
+    }
+    /** 仅依据主流程阶段和真实核平显示资格，写入还需共同端口复验。 */
+    private Gate arrangementGate(Context c) {
+        boolean allowed=c.status()==Status.ACTIVE&&c.stage()==Stage.AFTER_LOADING&&c.pickingReconciled()&&c.loadingCompletedAt()!=null;
+        return new Gate(allowed,allowed?null:"ARRANGEMENT_NOT_READY",allowed?null:"请先完成真实拣货核平及装车确认");
+    }
+    /** 严格命令和业务摘要共用规范化集合，但原命令不移除版本和主体。 */
+    private ArrangeDelivery canonical(ArrangeDelivery request) {
+        var inputs=new ArrayList<ArrangeGroup>();
+        for(var g:request.groups()) { if(g==null||blank(g.groupKey()))throw conflict("派送分组身份不能为空");
+            if(g.fees()!=null && (g.fees().size()>20||g.fees().stream().anyMatch(Objects::isNull))
+                || g.feeCoverage()!=null && (g.feeCoverage().size()>2000||g.feeCoverage().stream().anyMatch(s->s==null||s.services()==null||s.services().stream().anyMatch(Objects::isNull))))
+                throw conflict("派送费用或覆盖范围不合法");
+            var selections=g.feeCoverage()==null?List.<CoverageSelection>of():g.feeCoverage().stream()
+                .map(s->new CoverageSelection(s.financeFeeId(),s.sourceVersion(),s.sourceHash(),s.services().stream().sorted().toList()))
+                .sorted(Comparator.comparing(CoverageSelection::financeFeeId,Comparator.nullsFirst(Long::compareTo))).toList();
+            var feeInputs=g.fees()==null?List.<FeeItem>of():g.fees().stream().sorted(Comparator.comparing(FeeItem::direction,Comparator.nullsFirst(String::compareTo))
+                .thenComparing(FeeItem::feeType,Comparator.nullsFirst(String::compareTo))).toList();
+            inputs.add(new ArrangeGroup(g.groupKey(),g.groupCargoHash(),g.plannedDeliveryAt(),g.deliveryMethod(),g.waybillNo(),g.carrierName(),g.pickupMethod(),
+                g.loadingType(),g.vehicleType(),g.vehicleSize(),g.appointmentAccount(),g.sellerName(),g.remark(),g.externalFreightHash(),g.feeCoverageCargoHash(),selections,feeInputs));}
+        inputs.sort(Comparator.comparing(ArrangeGroup::groupKey));
+        return new ArrangeDelivery(request.recordVersion(),request.idempotencyKey(),request.cargoHash(),request.loadingCompletionHash(),List.copyOf(inputs));
+    }
+    /** 将持久安排还原为共同端口的完整不可变事实。 */
+    private ArrangementFact fact(DispatchDeliveryArrangement saved) { return new ArrangementFact(saved.getArrangementKey(),saved.getBusinessHash(),saved.getCargoHash(),
+        saved.getLoadingCompletionHash(),read(saved.getResultJson(),ArrangementResult.class)); }
+    /** 始终使用原目的地业务数据，不用内部ID回退。 */
+    private Destination destination(DeliveryOrder d) { return new Destination(d.getDeliveryGroupKey(),d.getDestinationType(),d.getDestinationWarehouseId(),
+        d.getDestinationWarehouseCode(),d.getDestinationWarehouseName(),d.getDeliveryAddress(),d.getPostalCode(),d.getContactName(),d.getContactPhone()); }
+    /** 未知物理量保持未知，不能补零或拿计费重量替代。 */
+    private BigDecimal metric(List<CargoLine> cargo,Function<CargoLine,BigDecimal> value) { return cargo.stream().anyMatch(c->value.apply(c)==null)?null:
+        cargo.stream().map(value).reduce(BigDecimal.ZERO,BigDecimal::add); }
+    /** 序列化不可变安排，不接受无法保存的半成品。 */
+    private String write(Object value) { try{return json.writeValueAsString(value);}catch(JsonProcessingException e){throw new IllegalStateException("派送事实无法保存",e);} }
+    /** 损坏的持久事实阻断，不能回退创建另一套单据。 */
+    private <T>T read(String value,Class<T> type) { try{return json.readValue(value,type);}catch(JsonProcessingException e){throw new IllegalStateException("派送事实无法读取",e);} }
+    /** 按既有服务端时区写本地单据时间。 */
+    private static LocalDateTime local(Instant value) { return LocalDateTime.ofInstant(value,ZoneId.systemDefault()); }
+    /** 按既有服务端时区读取实际事件时间。 */
+    private static Instant instant(LocalDateTime value) { return value.atZone(ZoneId.systemDefault()).toInstant(); }
+    /** 必要业务标识不允许空白。 */
+    private static boolean blank(String value) { return value==null||value.isBlank(); }
+    /** 任一客户失败由外层事务回滚全部单据和费用。 */
+    private static ResponseStatusException conflict(String reason) { return new ResponseStatusException(HttpStatus.CONFLICT,reason); }
+}