lastleg-service/docs/business-index.md

@@ -37,6 +37,7 @@
 | FBA 预约创建、详情与编辑 | `InboundPlanController.java` 的 `/fba-appointments/**`、`inboundplan/service/InboundFbaAppointmentService.java`、`BatchFbaAppointmentRequest.java`、`UpdateFbaAppointmentRequest.java` |
 | PDA 入仓、实收、上架与完成 | `inboundplan/pda/controller/ReceivingContainerController.java`、`inboundplan/pda/service/ReceivingContainerService.java`、内部编排 `InboundPdaWorkflowService.java`；公网入口固定为 `/api/pda/v1/last-leg/receiving-containers/**`，`/warehouse-profile` 只按 Token 绑定仓解析共享仓库中文名称与编码，旧 planNo/allocationId Controller 已移除。多计划同柜返回计划级 `assigned/mergeAllowed/urgent/mergeHint`；普通 FBA/OVERSEAS 分别使用 bulk/carton 收货，一件代发只允许 `/current/receipts/pallet` 按国内冻结来源托盘整托收货。普通 OVERSEAS 允许在本票已预留托盘间按现场实际分配箱数，逐托建议箱数不作为收货上限，仍校验本票总箱数、单托66箱、目的仓及客户归属；库存按已扫箱码的SKU和真实托盘归属入账。合托只作现场可选提示；全部计划完整绑定真实 pallet/location/lock 前不得查看、准备或签收该柜，托盘校验和提交均只确认本票已预留绑定。Admin 入库单详情可按行打印已预留真实托盘标签，复用海外托盘列表权限和标签PDF接口，不生成第二个托盘码 |
 | 普通散货收货短少确认 | `inboundplan/controller/InboundPlanController.java` 的 `/{planNo}/confirm-shortage` → `InboundPdaWorkflowService.confirmShortage`；仅平台入库编辑权限指定客户操作，要求待差异核对、原版本及应收/实收快照、原因和幂等键。FBA仅同柜次同目的仓收货组单票且冻结申报单SKU可按总数确认，多SKU及跨票自动分摊拒绝；普通OVERSEAS按已扫箱码精确核对SKU与逐托实收，可处理多SKU短少，一件代发整托货物拒绝此操作。逐SKU实收不得超原申报，确认后保留应收与现场结束时间，按实收生成库存和原计租批次，OVERSEAS已收箱转AVAILABLE、未收箱保留原状态，计划/PDA任务进入 `PARTIAL_INBOUND`，尾程订单完成入库；同事务交接原预排，明确零实收的托盘同步移除预排明细、释放本车占用及预约分配并重算整车货量；缺少零实收证据或已有拣货拒绝。不重复发布卸柜事件。无实收、超收或逐SKU事实不一致拒绝；空预留托盘不能再次作为计划货源排车。 |
+| 收货异常统一核对 | Admin 主入口为 `/{planNo}/receiving-reconciliation` GET/POST → `InboundReceivingReconciliationService`，契约 `inbound-reconciliation-v1.yaml`；按来源柜次、柜号和实际收货仓核对整柜，独立展示实盘与已归属数量。普通FBA支持明确逐托逐票SKU确认短少、超收、零实收和误录更正，每托守恒，原申报和现场时间保留；完成票据及普通地址逐箱身份只读，一件代发独立分组。旧生产 `confirm-shortage` 保留原语义。确认采用当前事实摘要、原因和幂等键，库存、实际体积、托盘、原预排和原始/确认后审计同事务提交，逐SKU短少不能被其他SKU超收抵消。 |
 | PDA 卸柜照片上传、归属校验与预览 | `ReceivingContainerController.java` 的 `/current/unload-photos/files`、`/current/unload-photos/files/{fileId}/download`，网关 `inboundplan/pda/gateway/UnloadPhotoFileGateway.java`、`HttpUnloadPhotoFileGateway.java`；File 类型固定 `OVERSEAS_UNLOAD_PHOTO`，下载只允许当前会话已签收的 fileId 并返回 `no-store` |
 | PDA 国内装柜照片对照 | `ReceivingContainerController.java` 的 `/current/domestic-loading-photos/{evidenceType}/content`、`ContainerLoadingEvidenceMapper.java`、`DomesticLoadingEvidenceGateway.java`；元数据按物理柜投影，不保存客户，下载必须经当前 PDA 会话鉴权并复用 `FILE_SERVICE_URL` 只读访问 File 服务，单图不可用不改变拆柜状态 |
 | 卸柜照片与海外卸柜完成 Outbox | `ReceivingContainerController.java`、`ReceivingContainerService.java`、`inboundplan/pda/service/InboundUnloadCompletedOutboxService.java`、`entity/LastlegEventOutbox.java`、`mapper/LastlegEventOutboxMapper.java`；多计划同柜只能在全柜完成后调用 `publishContainerCompleted`，按来源柜预订 ID 幂等发布一次，完成时刻与拍照时刻分离；事件模型见 `../common-event-contract/AGENTS.md` |

lastleg-service/src/main/java/com/baiyue/lastleg/inboundplan/controller/InboundPlanController.java

@@ -39,6 +39,39 @@ public class InboundPlanController {
     @Resource private ContainerInboundPlanConversionCoordinator containerConversion;
     @Resource private InboundFbaAppointmentService appointmentService;
     @Resource private com.baiyue.lastleg.inboundplan.pda.service.InboundPdaWorkflowService inboundWorkflow;
+    @Resource private com.baiyue.lastleg.inboundplan.pda.service.InboundReceivingReconciliationService receivingReconciliation;
+
+    /** 平台读取同一来源柜次的现场清点与逐票商品归属。 */
+    @GetMapping("/{planNo}/receiving-reconciliation")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.INBOUND_ORDER_LIST + "')")
+    @Operation(summary = "查询收货异常核对", description = "Required authority: " + OverseasPermissions.INBOUND_ORDER_LIST)
+    public ApiResponse<com.baiyue.lastleg.inboundplan.dto.InboundReceivingReconciliation.Snapshot> receivingReconciliation(
+            @AuthenticationPrincipal AuthenticatedUser user, @PathVariable String planNo,
+            @RequestParam String customerId) {
+        requireReconciliationPlatform(user);
+        return ApiResponse.success(receivingReconciliation.snapshot(convertScope(user, customerId), planNo));
+    }
+
+    /** 逐托逐商品确认短少、超收或误录，保留原申报和完整核对证据。 */
+    @PostMapping("/{planNo}/receiving-reconciliation")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.INBOUND_ORDER_EDIT + "')")
+    @Operation(summary = "确认收货异常", description = "Required authority: " + OverseasPermissions.INBOUND_ORDER_EDIT)
+    public ApiResponse<com.baiyue.lastleg.inboundplan.dto.InboundReceivingReconciliation.Result> confirmReceivingReconciliation(
+            @AuthenticationPrincipal AuthenticatedUser user, @PathVariable String planNo,
+            @RequestHeader("Idempotency-Key") String idempotencyKey,
+            @Valid @RequestBody com.baiyue.lastleg.inboundplan.dto.InboundReceivingReconciliation.Confirm request) {
+        requireReconciliationPlatform(user);
+        String customerId = convertScope(user, request.customerId());
+        String operatorId = user.userId() == null ? user.username() : String.valueOf(user.userId());
+        return ApiResponse.success(receivingReconciliation.confirm(customerId, planNo, operatorId, idempotencyKey, request));
+    }
+
+    /** 共托核对可能涉及多个客户，仅平台作业域允许读取和确认。 */
+    private void requireReconciliationPlatform(AuthenticatedUser user) {
+        if (user == null || user.tenantId() == null || user.tenantId() != 0L || !"PLATFORM".equals(user.appCode())) {
+            throw new ResponseStatusException(HttpStatus.FORBIDDEN, "仅平台账号可核对收货异常");
+        }
+    }
 
     /** 平台核对现场短少后按实收入库，不修改原应收数量。 */
     @PostMapping("/{planNo}/confirm-shortage")

lastleg-service/src/main/java/com/baiyue/lastleg/inboundplan/dto/InboundReceivingReconciliation.java

@@ -0,0 +1,41 @@
+package com.baiyue.lastleg.inboundplan.dto;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.*;
+import java.util.List;
+
+/** 平台按同柜收货事实核对异常，申报数量与确认实收分别保留。 */
+public final class InboundReceivingReconciliation {
+    /** 仅承载请求和响应类型。 */
+    private InboundReceivingReconciliation() { }
+
+    public record Snapshot(String planNo, String containerNo, String snapshotHash,
+            int expectedPackageCount, int countedPackageCount, int attributedPackageCount,
+            boolean canConfirm, String blockedReason, List<Plan> plans,
+            List<Pallet> pallets, List<Receipt> receipts) { }
+
+    public record Plan(String customerId, String planNo, String customerName, String status,
+            int expectedPackageCount, int attributedPackageCount) { }
+
+    public record Pallet(Long palletId, String palletNo, String groupKey,
+            int countedPackageCount, int attributedPackageCount, boolean editable) { }
+
+    public record Receipt(String customerId, String planNo, Long lineId, String inboundCode,
+            Long palletId, String palletNo, String skuCode, String productName,
+            int expectedPackageCount, int receivedPackageCount, boolean editable) { }
+
+    public record Confirm(@NotBlank String customerId, @NotBlank String snapshotHash,
+            @NotBlank @Size(max = 200) String reason,
+            @NotNull List<@NotNull @Valid Count> pallets,
+            @NotNull List<@NotNull @Valid Quantity> receipts) { }
+
+    public record Count(@NotNull Long palletId,
+            @NotNull @Min(0) Integer countedPackageCount) { }
+
+    public record Quantity(@NotBlank String customerId, @NotBlank String planNo,
+            @NotNull Long lineId, @NotNull Long palletId, @NotBlank String skuCode,
+            @NotNull @Min(0) Integer receivedPackageCount) { }
+
+    public record Result(String planNo, String status, int confirmedPackageCount,
+            List<String> reconciledPlanNos) { }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/inboundplan/pda/mapper/InboundReceivingReconciliationMapper.java

@@ -0,0 +1,47 @@
+package com.baiyue.lastleg.inboundplan.pda.mapper;
+
+import com.baiyue.lastleg.inboundplan.entity.InboundPlan;
+import com.baiyue.lastleg.inboundplan.pda.entity.ReceivingContainerSession;
+import com.baiyue.lastleg.inboundplan.pda.entity.ReceivingFbaPalletCount;
+import org.apache.ibatis.annotations.*;
+import java.util.List;
+
+/** 异常核对严格使用来源柜次、柜号与实际接柜仓共同确定作业范围。 */
+@Mapper
+public interface InboundReceivingReconciliationMapper {
+    /** 同柜共托需要一起核对，平台确认时按计划主键顺序锁定。 */
+    @Select("""
+        <script>
+        SELECT p.* FROM ll_inbound_plan selected
+        JOIN ll_order source ON source.id=selected.source_order_id AND source.customer_id=selected.customer_id
+        JOIN ll_inbound_plan p ON p.container_no=selected.container_no
+          AND p.overseas_warehouse_id=selected.overseas_warehouse_id
+        JOIN ll_order o ON o.id=p.source_order_id AND o.customer_id=p.customer_id
+          AND CAST(o.source_container_booking_id AS BINARY(512))=CAST(source.source_container_booking_id AS BINARY(512))
+        WHERE selected.customer_id=#{customerId} AND selected.plan_no=#{planNo}
+          AND NULLIF(TRIM(source.source_container_booking_id),'') IS NOT NULL
+        ORDER BY p.id <if test='lock'>FOR UPDATE</if>
+        </script>
+        """)
+    @Options(flushCache = Options.FlushCachePolicy.TRUE, useCache = false)
+    List<InboundPlan> scopePlans(@Param("customerId") String customerId,
+            @Param("planNo") String planNo, @Param("lock") boolean lock);
+
+    /** 完成会话已释放活动键，仍按完整来源身份定位并锁定原会话。 */
+    @Select("""
+        <script>
+        SELECT * FROM ll_receiving_container_session
+        WHERE CAST(source_container_booking_id AS BINARY(512))=CAST(#{bookingId} AS BINARY(512))
+          AND container_no=#{containerNo} AND overseas_warehouse_id=#{warehouseId}
+        ORDER BY created_at DESC,id DESC LIMIT 1 <if test='lock'>FOR UPDATE</if>
+        </script>
+        """)
+    @Options(flushCache = Options.FlushCachePolicy.TRUE, useCache = false)
+    ReceivingContainerSession session(@Param("bookingId") String bookingId,
+            @Param("containerNo") String containerNo, @Param("warehouseId") Long warehouseId,
+            @Param("lock") boolean lock);
+
+    /** 现场实盘与货件分配独立读取，不能将申报内分配数当作完整实盘。 */
+    @Select("SELECT * FROM ll_receiving_fba_pallet_count WHERE session_id=#{sessionId} ORDER BY group_key,pallet_code,id")
+    List<ReceivingFbaPalletCount> physicalCounts(Long sessionId);
+}

lastleg-service/src/main/java/com/baiyue/lastleg/inboundplan/pda/repository/InboundReceivingReconciliationRepository.java

@@ -0,0 +1,71 @@
+package com.baiyue.lastleg.inboundplan.pda.repository;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baiyue.lastleg.inboundplan.entity.InboundPlan;
+import com.baiyue.lastleg.entity.LastlegOrder;
+import com.baiyue.lastleg.mapper.LastlegOrderMapper;
+import com.baiyue.lastleg.inboundplan.pda.entity.*;
+import com.baiyue.lastleg.inboundplan.pda.mapper.*;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+import java.util.Collection;
+
+/** 将异常核对的持久化访问集中到 Mapper，业务确认规则由服务负责。 */
+@Repository
+public class InboundReceivingReconciliationRepository {
+    @Resource private InboundReceivingReconciliationMapper queries;
+    @Resource private ReceivingFbaPalletCountMapper physical;
+    @Resource private ReceivingSkuReceiptMapper skus;
+    @Resource private ReceivingContainerSessionMapper sessions;
+    @Resource private InboundStockReceiptMapper stockReceipts;
+    @Resource private LastlegOrderMapper orders;
+
+    /** 查询或顺序锁定同一来源柜次的全部计划。 */
+    public List<InboundPlan> plans(String customerId, String planNo, boolean lock) {
+        return queries.scopePlans(customerId, planNo, lock);
+    }
+
+    /** 精确读取已结束的原收货会话。 */
+    public ReceivingContainerSession session(String bookingId, String containerNo, Long warehouseId, boolean lock) {
+        return queries.session(bookingId, containerNo, warehouseId, lock);
+    }
+
+    /** 读取独立保存的现场实盘。 */
+    public List<ReceivingFbaPalletCount> physicalCounts(Long sessionId) {
+        return queries.physicalCounts(sessionId);
+    }
+
+    /** 已完成票据采用真实入库凭证还原 SKU，不以空收货行推断零实收。 */
+    public List<InboundStockReceipt> stockReceipts(String customerId, Long taskId) {
+        return stockReceipts.listTask(customerId, taskId);
+    }
+
+    /** 异常入库复用原订单快照，业务服务继续复核每条客户归属。 */
+    public List<LastlegOrder> orders(Collection<Long> orderIds) {
+        return orders.selectBatchIds(orderIds);
+    }
+
+    /** 查询本票已经明确保存的逐托 SKU 实收。 */
+    public List<ReceivingSkuReceipt> skuReceipts(String customerId, Long planId) {
+        return skus.listPlan(customerId, planId);
+    }
+
+    /** 仅替换本客户本计划待核对的 SKU 归属，原操作日记保留完整前后证据。 */
+    public void replaceSkuReceipts(String customerId, Long planId, List<ReceivingSkuReceipt> confirmed) {
+        skus.delete(new LambdaQueryWrapper<ReceivingSkuReceipt>()
+            .eq(ReceivingSkuReceipt::getCustomerId, customerId).eq(ReceivingSkuReceipt::getPlanId, planId));
+        confirmed.forEach(skus::insert);
+    }
+
+    /** 确认实盘时更新当前清点，历史原始输入保留在收货与核对操作日记。 */
+    public void savePhysical(ReceivingFbaPalletCount count, boolean existing) {
+        if (!existing) physical.insert(count);
+        else if (physical.updateById(count) != 1) throw new IllegalStateException("现场清点记录已变化");
+    }
+
+    /** 会话版本使并发核对和旧页面快照失效。 */
+    public void updateSession(ReceivingContainerSession session) {
+        if (sessions.updateById(session) != 1) throw new IllegalStateException("收货会话已变化");
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/inboundplan/pda/service/InboundReceivingReconciliationService.java

@@ -0,0 +1,472 @@
+package com.baiyue.lastleg.inboundplan.pda.service;
+
+import com.baomidou.mybatisplus.core.toolkit.IdWorker;
+import com.baiyue.lastleg.entity.LastlegOrder;
+import com.baiyue.lastleg.inboundplan.dto.InboundReceivingReconciliation;
+import com.baiyue.lastleg.inboundplan.dto.InboundReceivingReconciliation.*;
+import com.baiyue.lastleg.inboundplan.entity.*;
+import com.baiyue.lastleg.inboundplan.pda.entity.*;
+import com.baiyue.lastleg.inboundplan.pda.gateway.InboundDispatchReceiptGateway;
+import com.baiyue.lastleg.inboundplan.pda.mapper.ReceivingSkuReceiptMapper.FrozenSku;
+import com.baiyue.lastleg.inboundplan.pda.repository.InboundReceivingReconciliationRepository;
+import com.baiyue.lastleg.inboundplan.pda.repository.PdaWorkflowRepository;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.annotation.Resource;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.nio.charset.StandardCharsets;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/** 平台显式核对逐托、逐票和逐 SKU 实收，统一处理短少、超收及清点误录。 */
+@Service
+public class InboundReceivingReconciliationService {
+    @Resource private InboundReceivingReconciliationRepository reconciliation;
+    @Resource private PdaWorkflowRepository repository;
+    @Resource private InboundStockReceiptService stockReceipts;
+    @Resource private InboundDispatchReceiptGateway dispatchReceipts;
+    @Resource private ObjectMapper objectMapper;
+    private static final String ACTION = "CONFIRM_RECEIVING_DIFFERENCE";
+
+    /** 展示独立实盘和已归属数量，共托来源在同一快照中逐项核对。 */
+    @Transactional(readOnly = true)
+    public Snapshot snapshot(String customerId, String planNo) {
+        List<InboundPlan> plans = reconciliation.plans(customerId, planNo, false);
+        return present(planNo, load(customerId, planNo, plans, false));
+    }
+
+    /** 运输父锁先于会话和来源锁；库存、清点更正、状态和审计同事务提交。 */
+    @Transactional(isolation = Isolation.READ_COMMITTED)
+    public Result confirm(String customerId, String planNo, String operatorId, String idempotencyKey, Confirm request) {
+        if (!Objects.equals(customerId, request.customerId()) || operatorId == null || operatorId.isBlank()
+                || idempotencyKey == null || idempotencyKey.isBlank() || idempotencyKey.length() > 128
+                || request.reason() == null || request.reason().isBlank()) {
+            throw conflict("异常确认必须提供客户、操作人、确认原因及有效请求键");
+        }
+        List<InboundPlan> original = reconciliation.plans(customerId, planNo, false);
+        requireSelected(original, customerId, planNo);
+        List<Long> planIds = original.stream().map(InboundPlan::getId).toList();
+        dispatchReceipts.lock(planIds);
+        Scope scope = load(customerId, planNo, original, true);
+        Map<String, Object> command = Map.of("planNo", planNo, "operatorId", operatorId, "request", request);
+        InboundPdaOperation replay = repository.operation(customerId, idempotencyKey);
+        if (replay != null) {
+            if (!ACTION.equals(replay.getAction()) || !hash(command).equals(replay.getRequestHash())) {
+                throw conflict("请求键已用于其他异常确认，请刷新后重新操作");
+            }
+            return read(replay.getResultJson(), Result.class);
+        }
+        Snapshot before = present(planNo, scope);
+        if (!before.canConfirm()) throw conflict(before.blockedReason());
+        if (!before.snapshotHash().equals(request.snapshotHash())) throw conflict("收货记录已变化，请刷新后重新核对");
+        validate(before, request);
+        String sourceFacts = write(scope);
+        LocalDateTime now = LocalDateTime.now();
+        applyPhysical(scope, before, request, now);
+        for (PlanState state : scope.states()) {
+            if (pending(state.plan())) applyReceipts(scope, state, request, now);
+        }
+        for (Pallet row : before.pallets()) {
+            if (!row.editable()) continue;
+            InboundPlanPallet pallet = scope.pallets().get(row.palletId());
+            int count = request.pallets().stream().filter(value -> value.palletId().equals(row.palletId()))
+                .findFirst().orElseThrow().countedPackageCount();
+            pallet.setActualPackageCount(count);
+            if (count > 0 && row.groupKey().startsWith("FBA:")) pallet.setAssignmentStatus("ASSIGNED");
+            BigDecimal actualVolume = scope.states().stream().flatMap(state -> repository.allocations(state.plan().getId()).stream())
+                .filter(allocation -> row.palletId().equals(allocation.getPalletId()))
+                .map(allocation -> Objects.requireNonNullElse(allocation.getActualVolumeCbm(), BigDecimal.ZERO))
+                .reduce(BigDecimal.ZERO, BigDecimal::add).setScale(4, RoundingMode.HALF_UP);
+            pallet.setActualVolumeCbm(actualVolume);
+            repository.update(pallet);
+        }
+        List<String> completed = new ArrayList<>();
+        for (PlanState state : scope.states()) {
+            if (!pending(state.plan())) continue;
+            boolean shortage = hasShortage(state, request.receipts());
+            stockReceipts.stockInReconciled(state.plan().getCustomerId(), state.plan(), state.task(),
+                state.lines(), repository.allocations(state.plan().getId()),
+                new ArrayList<>(scope.pallets().values()), state.task().getCompletedAt());
+            state.task().setStatus(shortage ? "PARTIAL_INBOUND" : "COMPLETED");
+            state.task().setUpdatedAt(now);
+            state.task().setVersion(value(state.task().getVersion()) + 1);
+            repository.update(state.task());
+            state.plan().setStatus(state.task().getStatus());
+            state.plan().setUpdatedAt(now);
+            repository.update(state.plan());
+            completed.add(state.plan().getPlanNo());
+        }
+        dispatchReceipts.complete(scope.states().stream().filter(state -> completed.contains(state.plan().getPlanNo()))
+            .map(state -> state.plan().getId()).toList(), operatorId, now);
+        scope.session().setUpdatedAt(now);
+        reconciliation.updateSession(scope.session());
+        InboundPlan selected = requireSelected(scope.states().stream().map(PlanState::plan).toList(), customerId, planNo);
+        int confirmed = request.receipts().stream().filter(row -> planNo.equals(row.planNo()))
+            .mapToInt(Quantity::receivedPackageCount).sum();
+        Result result = new Result(planNo, selected.getStatus(), confirmed, List.copyOf(completed));
+        InboundPdaOperation audit = new InboundPdaOperation();
+        audit.setId(IdWorker.getId()); audit.setCustomerId(customerId);
+        audit.setTaskId(scope.states().stream().filter(state -> state.plan().getId().equals(selected.getId()))
+            .findFirst().orElseThrow().task().getId());
+        audit.setAction(ACTION); audit.setIdempotencyKey(idempotencyKey); audit.setRequestHash(hash(command));
+        audit.setRequestJson(write(Map.of("command", command, "before", before, "sourceFacts", sourceFacts)));
+        audit.setResultJson(write(result)); audit.setCreatedAt(now); repository.insert(audit);
+        return result;
+    }
+
+    /** 先锁原会话，再按主键锁齐计划、任务和托盘来源，阻断并发重新分配。 */
+    private Scope load(String customerId, String planNo, List<InboundPlan> original, boolean lock) {
+        InboundPlan selected = requireSelected(original, customerId, planNo);
+        LastlegOrder source = repository.order(selected.getSourceOrderId());
+        if (source == null || source.getSourceContainerBookingId() == null) throw conflict("来源柜次信息缺失");
+        ReceivingContainerSession session = reconciliation.session(source.getSourceContainerBookingId(),
+            selected.getContainerNo(), selected.getOverseasWarehouseId(), lock);
+        List<InboundPlan> plans = lock ? reconciliation.plans(customerId, planNo, true) : original;
+        if (!plans.stream().map(InboundPlan::getId).toList().equals(original.stream().map(InboundPlan::getId).toList())) {
+            throw conflict("本柜入库计划已变化，请刷新后重新核对");
+        }
+        List<PlanState> states = new ArrayList<>();
+        Map<Long, InboundPlanPallet> pallets = new LinkedHashMap<>();
+        for (InboundPlan plan : plans) {
+            InboundPdaTask task = lock ? repository.lockTask(plan.getCustomerId(), plan.getId())
+                : repository.task(plan.getCustomerId(), plan.getId());
+            List<InboundPlanLine> lines = repository.lines(plan.getId()).stream()
+                .sorted(Comparator.comparing(InboundPlanLine::getId)).toList();
+            List<InboundPlanPalletAllocation> allocations = repository.allocations(plan.getId()).stream()
+                .sorted(Comparator.comparing(InboundPlanPalletAllocation::getId)).toList();
+            if (lock) allocations = allocations.stream().map(row -> repository.lockAllocation(plan.getId(), row.getId())).toList();
+            for (InboundPlanPallet pallet : repository.pallets(plan.getId()).stream()
+                    .sorted(Comparator.comparing(InboundPlanPallet::getId)).toList()) {
+                pallets.put(pallet.getId(), lock ? repository.lockPallet(plan.getId(), pallet.getId()) : pallet);
+            }
+            Map<Long, List<FrozenSku>> frozen = new LinkedHashMap<>();
+            for (InboundPlanLine line : lines) frozen.put(line.getId(), repository
+                .frozenSkus(plan.getCustomerId(), plan.getId(), line.getId()).stream()
+                .sorted(Comparator.comparing(row -> normalize(row.skuCode()))).toList());
+            LastlegOrder order = repository.order(plan.getSourceOrderId());
+            List<ReceivingSkuReceipt> skus = readReceipts(plan, task, allocations);
+            if (!pending(plan) && order != null && "ONE_CLICK_DROPSHIP".equals(order.getOrderType())) {
+                for (InboundPlanLine line : lines) frozen.put(line.getId(), skus.stream()
+                    .filter(row -> line.getId().equals(row.getLineId())).collect(Collectors.groupingBy(
+                        row -> normalize(row.getSkuCode()), TreeMap::new, Collectors.summingLong(row -> value(row.getReceivedPackages()))))
+                    .entrySet().stream().map(entry -> new FrozenSku(entry.getKey(), entry.getValue())).toList());
+            }
+            states.add(new PlanState(plan, order, task, lines, allocations, skus, frozen));
+        }
+        List<ReceivingFbaPalletCount> physical = session == null ? List.of() : reconciliation.physicalCounts(session.getId());
+        return new Scope(session, states, pallets, physical);
+    }
+
+    /** 单票单 SKU 的归属唯一时展示完整实盘，其余组合保留分配值供人工逐项核实。 */
+    private Snapshot present(String planNo, Scope scope) {
+        List<Plan> plans = scope.states().stream().map(state -> new Plan(state.plan().getCustomerId(),
+            state.plan().getPlanNo(), state.order() == null ? null : state.order().getCustomerName(), state.plan().getStatus(),
+            state.lines().stream().mapToInt(line -> value(line.getRequiredPackageCount())).sum(),
+            state.allocations().stream().mapToInt(row -> value(row.getPickedPackageCount())).sum())).toList();
+        List<Pallet> pallets = new ArrayList<>();
+        List<Receipt> receipts = new ArrayList<>();
+        for (InboundPlanPallet pallet : scope.pallets().values()) {
+            String groupKey = groupKey(scope, pallet);
+            List<PlanState> members = scope.states().stream().filter(state -> state.lines().stream()
+                .anyMatch(line -> groupKey(scope, line, state.order()).equals(groupKey))).toList();
+            int attributed = scope.states().stream().flatMap(state -> state.allocations().stream())
+                .filter(row -> pallet.getId().equals(row.getPalletId()))
+                .mapToInt(row -> value(row.getPickedPackageCount())).sum();
+            ReceivingFbaPalletCount physical = scope.physical().stream()
+                .filter(row -> groupKey.equals(row.getGroupKey()) && Objects.equals(pallet.getPalletNo(), row.getPalletCode()))
+                .findFirst().orElse(null);
+            int counted = physical == null ? attributed : value(physical.getActualPackages());
+            boolean editable = groupKey.startsWith("FBA:") && members.stream().anyMatch(state -> pending(state.plan()));
+            pallets.add(new Pallet(pallet.getId(), pallet.getPalletNo(), groupKey, counted, attributed, editable));
+            int identities = members.stream().mapToInt(state -> state.lines().stream()
+                .filter(line -> groupKey.equals(groupKey(scope, line, state.order())))
+                .mapToInt(line -> state.frozen().get(line.getId()).size()).sum()).sum();
+            for (PlanState state : members) for (InboundPlanLine line : state.lines()) {
+                if (!groupKey.equals(groupKey(scope, line, state.order()))) continue;
+                for (FrozenSku sku : state.frozen().get(line.getId())) {
+                    String code = normalize(sku.skuCode());
+                    int allocated = state.skus().stream().filter(row -> line.getId().equals(row.getLineId())
+                        && pallet.getId().equals(row.getPalletId()) && code.equals(normalize(row.getSkuCode())))
+                        .mapToInt(row -> value(row.getReceivedPackages())).sum();
+                    boolean receiptEditable = pending(state.plan()) && groupKey.startsWith("FBA:");
+                    int received = identities == 1 && receiptEditable ? counted : allocated;
+                    String product = state.skus().stream().filter(row -> code.equals(normalize(row.getSkuCode())))
+                        .map(ReceivingSkuReceipt::getProductName).filter(Objects::nonNull).findFirst().orElse(null);
+                    receipts.add(new Receipt(state.plan().getCustomerId(), state.plan().getPlanNo(), line.getId(),
+                        line.getInboundCode(), pallet.getId(), pallet.getPalletNo(), code, product,
+                        Math.toIntExact(sku.packages()), received, receiptEditable));
+                }
+            }
+        }
+        String blocked = blocker(scope, pallets, receipts);
+        return new Snapshot(planNo, scope.states().get(0).plan().getContainerNo(), hash(scope),
+            plans.stream().mapToInt(Plan::expectedPackageCount).sum(),
+            pallets.stream().mapToInt(Pallet::countedPackageCount).sum(),
+            plans.stream().mapToInt(Plan::attributedPackageCount).sum(), blocked == null, blocked,
+            plans, pallets, receipts);
+    }
+
+    /** 证据缺失明确提示，避免把未知清点、未知 SKU 或其他作业来源默认为零。 */
+    private String blocker(Scope scope, List<Pallet> pallets, List<Receipt> receipts) {
+        if (scope.session() == null || scope.session().getCompletedAt() == null
+                || !List.of("COMPLETED", "COMPLETED_WITH_DIFFERENCE").contains(scope.session().getStatus())) {
+            return "本柜现场收货尚未结束，请先完成现场收货";
+        }
+        if (scope.states().stream().noneMatch(state -> pending(state.plan()))) return "本柜收货异常已经核对完成";
+        for (PlanState state : scope.states()) {
+            if (!List.of("PENDING_RECONCILIATION", "PARTIAL_INBOUND", "COMPLETED").contains(state.plan().getStatus())) {
+                return "本柜仍有未结束的入库作业，请先完成现场收货";
+            }
+            if (!pending(state.plan())) continue;
+            if (state.order() != null && "ONE_CLICK_DROPSHIP".equals(state.order().getOrderType())) {
+                return "一件代发须按冻结来源整托核对，请先核实原托盘及实物一致性";
+            }
+            if (state.task() == null || !"PENDING_RECONCILIATION".equals(state.task().getStatus())
+                    || state.task().getCompletedAt() == null || state.task().getUnloadPhotoUploadedAt() == null
+                    || state.task().getUnloadPhotoFileIds() == null || "[]".equals(state.task().getUnloadPhotoFileIds())) {
+                return "待核对入库单缺少现场结束或卸柜凭证";
+            }
+            if (state.lines().isEmpty() || state.frozen().values().stream().anyMatch(rows -> rows.isEmpty()
+                    || rows.stream().anyMatch(row -> normalize(row.skuCode()).isEmpty() || row.packages() < 0))) {
+                return "冻结商品资料缺失，请先核实每票货物的 SKU 归属";
+            }
+            if (state.lines().stream().anyMatch(line -> value(line.getRequiredPackageCount()) <= 0)) {
+                return "原应收箱数缺失，请先核实来源入库资料";
+            }
+            if (state.lines().stream().anyMatch(line -> state.frozen().get(line.getId()).stream()
+                    .mapToLong(FrozenSku::packages).sum() != value(line.getRequiredPackageCount()))) {
+                return "冻结 SKU 箱数与原应收不一致，请先核实来源商品资料";
+            }
+        }
+        for (ReceivingFbaPalletCount physical : scope.physical()) {
+            if (pallets.stream().noneMatch(pallet -> Objects.equals(pallet.palletNo(), physical.getPalletCode())
+                    && Objects.equals(pallet.groupKey(), physical.getGroupKey()))) {
+                return "存在未关联计划托盘的现场清点记录，请先核实托盘归属";
+            }
+        }
+        if (pallets.isEmpty() || receipts.isEmpty()) return "收货托盘或商品明细缺失，请先核实来源";
+        return null;
+    }
+
+    /** 请求必须覆盖当前全部明细，每托数量守恒，已完成票据保持原库存事实。 */
+    private void validate(Snapshot before, Confirm request) {
+        Map<Long, Count> counts = new LinkedHashMap<>();
+        for (Count row : request.pallets()) {
+            if (row.palletId() == null || row.countedPackageCount() == null || row.countedPackageCount() < 0
+                    || counts.put(row.palletId(), row) != null) {
+                throw conflict("逐托清点数量必须为 0 至 66 的整数且不能重复");
+            }
+        }
+        Map<String, Quantity> quantities = new LinkedHashMap<>();
+        for (Quantity row : request.receipts()) {
+            if (row.receivedPackageCount() == null || row.receivedPackageCount() < 0
+                    || quantities.put(key(row.customerId(), row.planNo(), row.lineId(), row.palletId(), row.skuCode()), row) != null) {
+                throw conflict("逐票 SKU 数量必须为 0 至 66 的整数且不能重复");
+            }
+        }
+        if (counts.size() != before.pallets().size() || quantities.size() != before.receipts().size()) {
+            throw conflict("核对明细不完整，请刷新后逐项核对");
+        }
+        for (Receipt row : before.receipts()) {
+            Quantity submitted = quantities.get(key(row.customerId(), row.planNo(), row.lineId(), row.palletId(), row.skuCode()));
+            if (submitted == null || (row.editable() && submitted.receivedPackageCount() > 66)
+                    || (!row.editable() && submitted.receivedPackageCount() != row.receivedPackageCount())) {
+                throw conflict("收货归属已变化或已入库票据被修改，请刷新后重新核对");
+            }
+        }
+        for (Pallet pallet : before.pallets()) {
+            Count count = counts.get(pallet.palletId());
+            if (count == null || (pallet.editable() && count.countedPackageCount() > 66)
+                    || (!pallet.editable() && count.countedPackageCount() != pallet.countedPackageCount())) {
+                throw conflict("已完成的托盘清点不能在本次异常确认中修改");
+            }
+            int total = request.receipts().stream().filter(row -> pallet.palletId().equals(row.palletId()))
+                .mapToInt(Quantity::receivedPackageCount).sum();
+            if (total != count.countedPackageCount()) throw conflict("托盘 " + pallet.palletNo() + " 的 SKU 归属合计必须等于核实清点箱数");
+        }
+    }
+
+    /** 现场原始输入已有收货日记，本次审计另保留更新前快照和明确更正原因。 */
+    private void applyPhysical(Scope scope, Snapshot before, Confirm request, LocalDateTime now) {
+        for (Pallet pallet : before.pallets()) {
+            if (!pallet.editable() || !pallet.groupKey().startsWith("FBA:")) continue;
+            int count = request.pallets().stream().filter(row -> row.palletId().equals(pallet.palletId()))
+                .findFirst().orElseThrow().countedPackageCount();
+            ReceivingFbaPalletCount physical = scope.physical().stream().filter(row -> row.getGroupKey().equals(pallet.groupKey())
+                && row.getPalletCode().equals(pallet.palletNo())).findFirst().orElse(null);
+            boolean existing = physical != null;
+            if (!existing) {
+                physical = new ReceivingFbaPalletCount(); physical.setId(IdWorker.getId());
+                physical.setSessionId(scope.session().getId()); physical.setGroupKey(pallet.groupKey());
+                physical.setPalletCode(pallet.palletNo()); physical.setCreatedAt(now);
+            }
+            physical.setActualPackages(count); physical.setUpdatedAt(now);
+            reconciliation.savePhysical(physical, existing);
+        }
+    }
+
+    /** 将已明确确认的逐 SKU 事实和逐托合计同时写入，原申报分配保持可追溯。 */
+    private void applyReceipts(Scope scope, PlanState state, Confirm request, LocalDateTime now) {
+        List<Quantity> rows = request.receipts().stream().filter(row -> row.planNo().equals(state.plan().getPlanNo())
+            && row.customerId().equals(state.plan().getCustomerId())).toList();
+        List<ReceivingSkuReceipt> confirmed = new ArrayList<>();
+        for (InboundPlanLine line : state.lines()) for (InboundPlanPallet pallet : scope.pallets().values()) {
+            List<Quantity> linePallet = rows.stream().filter(row -> row.lineId().equals(line.getId())
+                && row.palletId().equals(pallet.getId())).toList();
+            if (linePallet.isEmpty()) continue;
+            int packages = linePallet.stream().mapToInt(Quantity::receivedPackageCount).sum();
+            if (packages > 0 && (pallet.getWarehousePalletId() == null || pallet.getWarehouseLocationId() == null
+                    || pallet.getWarehouseResourceLockId() == null)) throw conflict("托盘 " + pallet.getPalletNo() + " 缺少实际仓储绑定");
+            InboundPlanPalletAllocation allocation = state.allocations().stream()
+                .filter(row -> line.getId().equals(row.getLineId()) && pallet.getId().equals(row.getPalletId())).findFirst().orElse(null);
+            if (allocation == null && packages == 0 && !state.plan().getId().equals(pallet.getPlanId())) continue;
+            if (allocation == null) {
+                allocation = new InboundPlanPalletAllocation(); allocation.setId(IdWorker.getId());
+                allocation.setCustomerId(state.plan().getCustomerId()); allocation.setPlanId(state.plan().getId());
+                allocation.setLineId(line.getId()); allocation.setPalletId(pallet.getId()); allocation.setPlannedPackageCount(0);
+                allocation.setAllocatedVolumeCbm(BigDecimal.ZERO); allocation.setActualVolumeCbm(BigDecimal.ZERO);
+                allocation.setCountedPackageCount(0); allocation.setPickedPackageCount(0); allocation.setStatus("PICKED");
+                allocation.setVersion(0); repository.insert(allocation);
+            }
+            allocation.setCountedPackageCount(packages); allocation.setPickedPackageCount(packages);
+            allocation.setActualVolumeCbm(Objects.requireNonNullElse(line.getVolumeCbm(), BigDecimal.ZERO)
+                .divide(BigDecimal.valueOf(line.getRequiredPackageCount()), 8, RoundingMode.HALF_UP)
+                .multiply(BigDecimal.valueOf(packages)).setScale(4, RoundingMode.HALF_UP));
+            allocation.setStatus("PICKED"); allocation.setVersion(value(allocation.getVersion()) + 1); repository.update(allocation);
+            for (Quantity row : linePallet) {
+                if (row.receivedPackageCount() == 0) continue;
+                ReceivingSkuReceipt sku = new ReceivingSkuReceipt(); sku.setId(IdWorker.getId());
+                sku.setCustomerId(state.plan().getCustomerId()); sku.setSessionId(scope.session().getId());
+                sku.setPlanId(state.plan().getId()); sku.setLineId(line.getId()); sku.setPalletId(pallet.getId());
+                sku.setOrderId(line.getOrderId()); sku.setInboundCode(line.getInboundCode()); sku.setSkuCode(normalize(row.skuCode()));
+                sku.setProductName(state.skus().stream().filter(old -> normalize(old.getSkuCode()).equals(sku.getSkuCode()))
+                    .map(ReceivingSkuReceipt::getProductName).filter(Objects::nonNull).findFirst().orElse(null));
+                sku.setReceivedPackages(row.receivedPackageCount()); sku.setCreatedAt(state.task().getCompletedAt());
+                sku.setUpdatedAt(now); sku.setVersion(0); confirmed.add(sku);
+            }
+        }
+        reconciliation.replaceSkuReceipts(state.plan().getCustomerId(), state.plan().getId(), confirmed);
+        for (InboundPlanCarton carton : repository.cartons(state.plan().getId())) {
+            if ("ON_PALLET".equals(carton.getStatus())) {
+                carton.setStatus("AVAILABLE"); carton.setReceivedAt(state.task().getCompletedAt());
+                carton.setUpdatedAt(now); carton.setVersion(value(carton.getVersion()) + 1); repository.update(carton);
+            }
+        }
+    }
+
+    /** 后台核对复用已入库凭证和逐箱扫描身份，不按申报顺序猜测普通地址货物。 */
+    private List<ReceivingSkuReceipt> readReceipts(InboundPlan plan, InboundPdaTask task,
+            List<InboundPlanPalletAllocation> allocations) {
+        List<ReceivingSkuReceipt> rows = repository.skuReceipts(plan.getCustomerId(), plan.getId());
+        if (!rows.isEmpty()) return rows;
+        List<ReceivingSkuReceipt> restored = new ArrayList<>();
+        if (!pending(plan) && task != null) {
+            for (InboundStockReceipt stock : reconciliation.stockReceipts(plan.getCustomerId(), task.getId())) {
+                InboundPlanPalletAllocation allocation = allocations.stream()
+                    .filter(row -> Objects.equals(row.getId(), stock.getAllocationId())).findFirst().orElse(null);
+                if (allocation == null) throw conflict("已入库凭证缺少原托盘来源，请核实库存事实");
+                ReceivingSkuReceipt row = new ReceivingSkuReceipt(); row.setLineId(stock.getLineId());
+                row.setPalletId(allocation.getPalletId()); row.setSkuCode(stock.getSkuCode());
+                row.setProductName(stock.getProductNameZh()); row.setReceivedPackages(Math.toIntExact(stock.getReceivedPackages()));
+                restored.add(row);
+            }
+        } else {
+            for (InboundPlanCarton carton : repository.cartons(plan.getId())) {
+                if (!"ON_PALLET".equals(carton.getStatus())) continue;
+                ReceivingSkuReceipt row = new ReceivingSkuReceipt(); row.setLineId(carton.getLineId());
+                row.setPalletId(carton.getPlanPalletId()); row.setSkuCode(carton.getSkuCode()); row.setReceivedPackages(1);
+                restored.add(row);
+            }
+        }
+        return restored;
+    }
+
+    /** SKU 短少单独判定，不能被另一商品超收抵消。 */
+    private boolean hasShortage(PlanState state, List<Quantity> rows) {
+        for (InboundPlanLine line : state.lines()) for (FrozenSku sku : state.frozen().get(line.getId())) {
+            long actual = rows.stream().filter(row -> row.planNo().equals(state.plan().getPlanNo())
+                && row.customerId().equals(state.plan().getCustomerId()) && row.lineId().equals(line.getId())
+                && normalize(row.skuCode()).equals(normalize(sku.skuCode())))
+                .mapToLong(Quantity::receivedPackageCount).sum();
+            if (actual < sku.packages()) return true;
+        }
+        return false;
+    }
+
+    /** 托盘所属目的组来自原计划，实物记录不能跨目的仓或来源柜次归属。 */
+    private String groupKey(Scope scope, InboundPlanPallet pallet) {
+        PlanState owner = scope.states().stream().filter(state -> state.plan().getId().equals(pallet.getPlanId())).findFirst().orElseThrow();
+        if (owner.order() != null && "ONE_CLICK_DROPSHIP".equals(owner.order().getOrderType())) {
+            return "DROPSHIP:" + owner.plan().getContainerNo() + ":" + owner.plan().getPlanNo();
+        }
+        InboundPlanLine line = owner.lines().stream().filter(row -> owner.allocations().stream()
+            .anyMatch(a -> a.getLineId().equals(row.getId()) && a.getPalletId().equals(pallet.getId()))).findFirst().orElse(null);
+        if (line != null) return groupKey(scope, line, owner.order());
+        String destination = normalize(pallet.getDestinationWarehouseCode());
+        return ("FBA".equals(normalize(pallet.getDestinationType())) ? "FBA:" : "OVERSEAS:")
+            + owner.plan().getContainerNo() + ":" + destination;
+    }
+
+    /** 普通 FBA 共用目的仓组，私人地址按原目的身份保留独立归属。 */
+    private String groupKey(Scope scope, InboundPlanLine line, LastlegOrder order) {
+        if (order != null && "ONE_CLICK_DROPSHIP".equals(order.getOrderType())) {
+            String planNo = scope.states().stream().filter(state -> state.lines().contains(line))
+                .findFirst().orElseThrow().plan().getPlanNo();
+            return "DROPSHIP:" + scope.states().get(0).plan().getContainerNo() + ":" + planNo;
+        }
+        String type = normalize(line.getDestinationType());
+        if (type.isEmpty() && order != null) type = normalize(order.getDestinationType());
+        if (type.isEmpty()) type = normalize(line.getFbaWarehouseCode()).isEmpty() ? "OVERSEAS" : "FBA";
+        String destination = "FBA".equals(type) ? normalize(line.getFbaWarehouseCode())
+            : normalize(Objects.toString(line.getDestinationWarehouseId(), line.getDestinationWarehouseCode()));
+        return type + ":" + scope.states().get(0).plan().getContainerNo() + ":" + destination;
+    }
+
+    /** 先校验请求客户与计划，再允许展开该计划所属的同柜范围。 */
+    private InboundPlan requireSelected(List<InboundPlan> plans, String customerId, String planNo) {
+        return plans.stream().filter(plan -> customerId.equals(plan.getCustomerId()) && planNo.equals(plan.getPlanNo()))
+            .findFirst().orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "入库单不存在或来源柜次信息缺失"));
+    }
+    /** 仅待核对票据可以更新收货归属。 */
+    private static boolean pending(InboundPlan plan) { return "PENDING_RECONCILIATION".equals(plan.getStatus()); }
+    /** 空计数用于读取汇总，提交数量必须另行显式校验。 */
+    private static int value(Integer value) { return value == null ? 0 : value; }
+    /** SKU 和目的仓采用与现场分组一致的标准化形式。 */
+    private static String normalize(String value) { return value == null ? "" : value.trim().toUpperCase(Locale.ROOT); }
+    /** 同时限定客户、票、明细、托盘和 SKU，防止跨来源替换。 */
+    private static String key(String customer, String plan, Long line, Long pallet, String sku) {
+        return customer + "/" + plan + "/" + line + "/" + pallet + "/" + normalize(sku);
+    }
+    /** 核对条件变化作为业务冲突返回，事务整体撤回。 */
+    private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT, message); }
+    /** 全部版本及现场数量参与摘要，过期页面不能覆盖新的事实。 */
+    private String hash(Object value) {
+        try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(write(value).getBytes(StandardCharsets.UTF_8))); }
+        catch (NoSuchAlgorithmException exception) { throw new IllegalStateException(exception); }
+    }
+    /** 持久化原始事实、操作原因和回执，保证可追溯。 */
+    private String write(Object value) {
+        try { return objectMapper.writeValueAsString(value); }
+        catch (JsonProcessingException exception) { throw new IllegalStateException("异常核对证据序列化失败", exception); }
+    }
+    /** 同键重放直接读取原回执，避免再次记库存。 */
+    private <T> T read(String json, Class<T> type) {
+        try { return objectMapper.readValue(json, type); }
+        catch (JsonProcessingException exception) { throw new IllegalStateException("异常核对回执读取失败", exception); }
+    }
+    private record PlanState(InboundPlan plan, LastlegOrder order, InboundPdaTask task,
+            List<InboundPlanLine> lines, List<InboundPlanPalletAllocation> allocations,
+            List<ReceivingSkuReceipt> skus, Map<Long, List<FrozenSku>> frozen) { }
+    private record Scope(ReceivingContainerSession session, List<PlanState> states,
+            Map<Long, InboundPlanPallet> pallets, List<ReceivingFbaPalletCount> physical) { }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/inboundplan/pda/service/InboundStockReceiptService.java

@@ -48,6 +48,7 @@ public class InboundStockReceiptService {
     @Resource private InboundStockReceiptMapper receipts;
     @Resource private ReceivingSkuReceiptMapper receivingSkuReceipts;
     @Resource private PdaWorkflowRepository workflowRepository;
+    @Resource private com.baiyue.lastleg.inboundplan.pda.repository.InboundReceivingReconciliationRepository reconciliationRepository;
     @Resource private InventoryCommandService inventory;
     @Resource private WarehouseResourceGateway warehouseGateway;
     @Resource private DropshipOrderService dropshipOrders;
@@ -61,6 +62,99 @@ public class InboundStockReceiptService {
         stockIn(customerId, plan, task, lines, allocations, pallets, receivedAt, false);
     }
 
+    /** 平台核对异常后按明确的逐托、逐 SKU 实收入库，保留原申报和现场收货时间。 */
+    @Transactional
+    public void stockInReconciled(String customerId, InboundPlan plan, InboundPdaTask task,
+                                 List<InboundPlanLine> lines, List<InboundPlanPalletAllocation> allocations,
+                                 List<InboundPlanPallet> pallets, LocalDateTime receivedAt) {
+        if (lines.isEmpty() || receivedAt == null) throw conflict("异常收货必须保留入库明细和现场收货时间");
+        Map<Long, LastlegOrder> orderById = reconciliationRepository.orders(lines.stream()
+            .map(InboundPlanLine::getOrderId).collect(Collectors.toSet())).stream()
+            .filter(order -> customerId.equals(order.getCustomerId()))
+            .collect(Collectors.toMap(LastlegOrder::getId, order -> order));
+        Map<Long, InboundPlanPallet> palletById = pallets.stream()
+            .collect(Collectors.toMap(InboundPlanPallet::getId, pallet -> pallet));
+        Map<Long, InboundPlanPalletAllocation> allocationById = allocations.stream()
+            .collect(Collectors.toMap(InboundPlanPalletAllocation::getId, allocation -> allocation));
+        Map<Long, List<ReceivingSkuReceipt>> exactByLine = reconciliationRepository.skuReceipts(customerId, plan.getId())
+            .stream().collect(Collectors.groupingBy(ReceivingSkuReceipt::getLineId));
+        Set<Long> lineIds = lines.stream().map(InboundPlanLine::getId).collect(Collectors.toSet());
+        if (!lineIds.containsAll(exactByLine.keySet()) || allocations.stream()
+            .anyMatch(allocation -> !lineIds.contains(allocation.getLineId())
+                || allocation.getPickedPackageCount() == null || allocation.getCountedPackageCount() == null
+                || value(allocation.getPickedPackageCount()) < 0
+                || !Objects.equals(allocation.getPickedPackageCount(), allocation.getCountedPackageCount()))) {
+            throw conflict("异常收货的逐票、清点和收货数量不一致");
+        }
+        List<ReconciledReceipt> confirmed = new java.util.ArrayList<>();
+        Map<ReceiptKey, Long> expectedReceipts = new java.util.HashMap<>();
+        Map<Long, Boolean> shortages = new java.util.HashMap<>();
+        for (InboundPlanLine line : lines) {
+            LastlegOrder order = orderById.get(line.getOrderId());
+            if (order == null || "ONE_CLICK_DROPSHIP".equals(order.getOrderType())) {
+                throw conflict("异常收货只支持归属明确的普通入库订单");
+            }
+            Map<String, SkuRemainder> frozenSkus = skuRemainders(order.getId(), value(line.getRequiredPackageCount()))
+                .stream().collect(Collectors.toMap(sku -> sku.skuCode.toUpperCase(java.util.Locale.ROOT),
+                    sku -> sku, (first, next) -> {
+                        first.remaining = Math.addExact(first.remaining, next.remaining);
+                        return first;
+                    }));
+            Map<Long, InboundPlanPalletAllocation> lineAllocations = allocations.stream()
+                .filter(allocation -> Objects.equals(allocation.getLineId(), line.getId()))
+                .collect(Collectors.toMap(InboundPlanPalletAllocation::getPalletId, allocation -> allocation));
+            Map<Long, Long> packagesByPallet = new java.util.HashMap<>();
+            Map<String, Long> packagesBySku = new java.util.HashMap<>();
+            for (ReceivingSkuReceipt exact : exactByLine.getOrDefault(line.getId(), List.of())) {
+                String skuCode = required(exact.getSkuCode(), "异常收货必须明确实收 SKU").toUpperCase(java.util.Locale.ROOT);
+                SkuRemainder frozen = frozenSkus.get(skuCode);
+                InboundPlanPalletAllocation allocation = lineAllocations.get(exact.getPalletId());
+                long packages = value(exact.getReceivedPackages());
+                if (frozen == null || allocation == null || packages <= 0) {
+                    throw conflict("异常收货必须使用原申报 SKU、真实托盘和正数箱数");
+                }
+                ReceiptKey key = new ReceiptKey(allocation.getId(), skuCode);
+                if (expectedReceipts.putIfAbsent(key, packages) != null) throw conflict("同托同 SKU 的实收记录重复");
+                packagesByPallet.merge(exact.getPalletId(), packages, Math::addExact);
+                packagesBySku.merge(skuCode, packages, Math::addExact);
+                confirmed.add(new ReconciledReceipt(line, allocation, requirePallet(palletById, allocation), order,
+                    new SkuSnapshot(frozen.skuCode, frozen.productNameZh, frozen.productNameEn, packages)));
+            }
+            if (lineAllocations.values().stream().anyMatch(allocation ->
+                value(allocation.getPickedPackageCount()) != packagesByPallet.getOrDefault(allocation.getPalletId(), 0L))) {
+                throw conflict("异常收货的逐托 SKU 箱数必须等于该托确认实收箱数");
+            }
+            boolean shortage = frozenSkus.entrySet().stream()
+                .anyMatch(entry -> packagesBySku.getOrDefault(entry.getKey(), 0L) < entry.getValue().remaining);
+            shortages.merge(order.getId(), shortage, (previous, current) -> previous || current);
+        }
+        // 重试只能重放同一份逐托 SKU 凭证，已入账数量发生变化时禁止二次入账或静默跳过。
+        List<InboundStockReceipt> existing = reconciliationRepository.stockReceipts(customerId, task.getId());
+        Map<ReceiptKey, Long> existingReceipts = new java.util.HashMap<>();
+        for (InboundStockReceipt receipt : existing) {
+            InboundPlanPalletAllocation allocation = allocationById.get(receipt.getAllocationId());
+            ReceiptKey key = new ReceiptKey(receipt.getAllocationId(),
+                required(receipt.getSkuCode(), "原库存凭证缺少 SKU").toUpperCase(java.util.Locale.ROOT));
+            if (allocation == null || !Objects.equals(receipt.getLineId(), allocation.getLineId())
+                || existingReceipts.putIfAbsent(key, receipt.getReceivedPackages()) != null) {
+                throw conflict("原库存凭证与确认实收归属不一致");
+            }
+        }
+        if (!existing.isEmpty() && !existingReceipts.equals(expectedReceipts)) {
+            throw conflict("原库存凭证与确认实收数量不一致，不能重复入账");
+        }
+        if (existing.isEmpty()) {
+            for (ReconciledReceipt receipt : confirmed) {
+                persist(customerId, plan, task, receipt.line(), receipt.allocation(), receipt.pallet(), receipt.order(),
+                    receipt.sku(), receivedAt);
+            }
+        }
+        // 零实收不产生零数量库存或计租凭证；逐 SKU 短少独立决定每票完成状态。
+        for (LastlegOrder order : orderById.values()) {
+            completeOrders(customerId, plan, Map.of(order.getId(), order), receivedAt, shortages.get(order.getId()));
+        }
+    }
+
     /** 按逐 SKU 实收生成凭证；普通海外仓货物以已扫描箱码和实托归属为准。 */
     @Transactional
     public void stockIn(String customerId, InboundPlan plan, InboundPdaTask task,
@@ -435,5 +529,8 @@ public class InboundStockReceiptService {
         }
     }
 
+    private record ReceiptKey(Long allocationId, String skuCode) { }
+    private record ReconciledReceipt(InboundPlanLine line, InboundPlanPalletAllocation allocation,
+                                     InboundPlanPallet pallet, LastlegOrder order, SkuSnapshot sku) { }
     private record SkuSnapshot(String skuCode, String productNameZh, String productNameEn, long packages) {}
 }

lastleg-service/src/main/resources/openapi/inbound-reconciliation-v1.yaml

@@ -0,0 +1,125 @@
+openapi: 3.0.3
+info:
+  title: 平台收货异常核对
+  version: 1.0.0
+paths:
+  /api/platform/v1/last-leg/inbound-plans/{planNo}/receiving-reconciliation:
+    parameters:
+      - { name: planNo, in: path, required: true, schema: { type: string } }
+    get:
+      operationId: getInboundReceivingReconciliation
+      summary: 查询收货异常核对
+      description: 仅平台入库列表权限。按所选客户计划的来源柜次、柜号和实际接柜仓查询同柜计划。独立返回现场实盘与已分配数量，完成票据只读。普通FBA单票单SKU组可唯一确定归属时预填完整实盘，其余逐票逐SKU由平台显式核对。
+      parameters:
+        - { name: customerId, in: query, required: true, schema: { type: string } }
+      responses:
+        '200':
+          description: 当前事实快照和确认资格
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code: { type: string }
+                  data: { $ref: '#/components/schemas/Snapshot' }
+    post:
+      operationId: confirmInboundReceivingReconciliation
+      summary: 确认收货异常
+      description: 仅平台入库编辑权限。必须提交当前snapshotHash、明确原因以及快照内全部逐托和逐票SKU明细。普通FBA可确认短少、超收、零实收或更正误录，每托归属合计须等于核实清点数，单托可编辑数量0至66。普通地址逐箱来源和已入库票据保持只读。原申报不变，按原现场时间生成实际库存及计租批次，逐SKU短少进入PARTIAL_INBOUND，其余进入COMPLETED。库存、托盘、原预排交接和审计同事务提交，保留原清点及归属事实，不重复发布卸柜事件。已完成一件代发来源独立分组，待核对一件代发仍须核实冻结整托身份。
+      parameters:
+        - { name: Idempotency-Key, in: header, required: true, schema: { type: string, maxLength: 128 } }
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema: { $ref: '#/components/schemas/Confirm' }
+      responses:
+        '200':
+          description: 确认结果，同键同操作人同载荷重放返回原结果
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code: { type: string }
+                  data:
+                    type: object
+                    properties:
+                      planNo: { type: string }
+                      status: { type: string }
+                      confirmedPackageCount: { type: integer }
+                      reconciledPlanNos: { type: array, items: { type: string } }
+        '409': { description: 旧快照、归属不完整、逐托不平、已完成来源变化或证据缺失 }
+components:
+  schemas:
+    Snapshot:
+      type: object
+      required: [planNo, containerNo, snapshotHash, expectedPackageCount, countedPackageCount, attributedPackageCount, canConfirm, plans, pallets, receipts]
+      properties:
+        planNo: { type: string }
+        containerNo: { type: string }
+        snapshotHash: { type: string }
+        expectedPackageCount: { type: integer, description: 本柜原申报箱数 }
+        countedPackageCount: { type: integer, description: 独立现场实盘箱数 }
+        attributedPackageCount: { type: integer, description: 当前已归属货件的箱数 }
+        canConfirm: { type: boolean }
+        blockedReason: { type: string, nullable: true }
+        plans:
+          type: array
+          items:
+            type: object
+            properties:
+              customerId: { type: string }
+              planNo: { type: string }
+              customerName: { type: string, nullable: true }
+              status: { type: string }
+              expectedPackageCount: { type: integer }
+              attributedPackageCount: { type: integer }
+        pallets:
+          type: array
+          items:
+            allOf:
+              - { $ref: '#/components/schemas/Count' }
+              - type: object
+                properties:
+                  palletNo: { type: string }
+                  groupKey: { type: string }
+                  attributedPackageCount: { type: integer }
+                  editable: { type: boolean }
+        receipts:
+          type: array
+          items:
+            allOf:
+              - { $ref: '#/components/schemas/Quantity' }
+              - type: object
+                properties:
+                  inboundCode: { type: string, nullable: true }
+                  palletNo: { type: string }
+                  productName: { type: string, nullable: true }
+                  expectedPackageCount: { type: integer, description: 该票SKU原申报合计，同SKU跨托显示重复值 }
+                  editable: { type: boolean }
+    Confirm:
+      type: object
+      required: [customerId, snapshotHash, reason, pallets, receipts]
+      properties:
+        customerId: { type: string }
+        snapshotHash: { type: string }
+        reason: { type: string, minLength: 1, maxLength: 200 }
+        pallets: { type: array, items: { $ref: '#/components/schemas/Count' } }
+        receipts: { type: array, items: { $ref: '#/components/schemas/Quantity' } }
+    Count:
+      type: object
+      required: [palletId, countedPackageCount]
+      properties:
+        palletId: { type: string }
+        countedPackageCount: { type: integer, minimum: 0 }
+    Quantity:
+      type: object
+      required: [customerId, planNo, lineId, palletId, skuCode, receivedPackageCount]
+      properties:
+        customerId: { type: string }
+        planNo: { type: string }
+        lineId: { type: string }
+        palletId: { type: string }
+        skuCode: { type: string }
+        receivedPackageCount: { type: integer, minimum: 0 }

lastleg-service/src/test/java/com/baiyue/lastleg/inboundplan/controller/InboundPlanControllerTest.java

@@ -32,6 +32,7 @@ class InboundPlanControllerTest {
     @Mock InboundFbaAppointmentService appointmentService;
     @Mock ContainerInboundPlanConversionCoordinator containerConversion;
     @Mock com.baiyue.lastleg.inboundplan.pda.service.InboundPdaWorkflowService inboundWorkflow;
+    @Mock com.baiyue.lastleg.inboundplan.pda.service.InboundReceivingReconciliationService receivingReconciliation;
     private InboundPlanController controller;
 
     @BeforeEach
@@ -41,6 +42,24 @@ class InboundPlanControllerTest {
         ReflectionTestUtils.setField(controller, "appointmentService", appointmentService);
         ReflectionTestUtils.setField(controller, "containerConversion", containerConversion);
         ReflectionTestUtils.setField(controller, "inboundWorkflow", inboundWorkflow);
+        ReflectionTestUtils.setField(controller, "receivingReconciliation", receivingReconciliation);
+    }
+
+    /** 平台统一核对短少或超收，客户范围、操作人与请求键原样交给事务服务。 */
+    @Test void platformConfirmsReceivingDifferenceWithExplicitScopeAndActor() {
+        var request = new com.baiyue.lastleg.inboundplan.dto.InboundReceivingReconciliation.Confirm(
+            "100", "snapshot", "现场核对", List.of(), List.of());
+        controller.receivingReconciliation(platform(), "IP-1", "100");
+        verify(receivingReconciliation).snapshot("100", "IP-1");
+        controller.confirmReceivingReconciliation(platform(), "IP-1", "key", request);
+        verify(receivingReconciliation).confirm("100", "IP-1", "7", "key", request);
+        var merchant = new AuthenticatedUser(8L, 100L, 100L, 9L, "customer", "MERCHANT", "WEB", Set.of());
+        assertThatThrownBy(() -> controller.receivingReconciliation(merchant, "IP-1", "100"))
+            .isInstanceOf(ResponseStatusException.class);
+        assertThatThrownBy(() -> controller.confirmReceivingReconciliation(merchant, "IP-1", "key", request))
+            .isInstanceOf(ResponseStatusException.class);
+        assertThatThrownBy(() -> controller.receivingReconciliation(platform(), "IP-1", "0"))
+            .isInstanceOf(ResponseStatusException.class);
     }
 
     /** 短少确认只允许平台指定具体客户，并保留真实操作人。 */

lastleg-service/src/test/java/com/baiyue/lastleg/inboundplan/pda/service/InboundReceivingReconciliationPersistenceTest.java

@@ -0,0 +1,152 @@
+package com.baiyue.lastleg.inboundplan.pda.service;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
+import com.baiyue.lastleg.inboundplan.entity.InboundPlan;
+import com.baiyue.lastleg.inboundplan.pda.entity.ReceivingContainerSession;
+import com.baiyue.lastleg.inboundplan.pda.entity.ReceivingFbaPalletCount;
+import com.baiyue.lastleg.inboundplan.pda.mapper.InboundReceivingReconciliationMapper;
+import org.junit.jupiter.api.Test;
+import org.mybatis.spring.SqlSessionTemplate;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.datasource.DataSourceTransactionManager;
+import org.springframework.jdbc.datasource.DriverManagerDataSource;
+import org.springframework.transaction.TransactionDefinition;
+import org.springframework.transaction.support.TransactionTemplate;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/** 使用真实 Mapper 校验整柜范围、历史完成会话和独立实盘取数。 */
+class InboundReceivingReconciliationPersistenceTest {
+    /** 同来源柜次同仓跨客户共同核对，复用柜号、其他仓及不匹配来源均排除。 */
+    @Test
+    void scopeIncludesOtherCustomersOnlyWithinTheSameBookingContainerAndWarehouse() throws Exception {
+        var fixture = new Fixture();
+
+        assertThat(fixture.mapper.scopePlans("101", "IP-10", false))
+            .extracting(InboundPlan::getId).containsExactly(10L, 20L);
+        assertThat(fixture.mapper.scopePlans("202", "IP-20", false))
+            .extracting(InboundPlan::getId).containsExactly(10L, 20L);
+        var lockedPlans = fixture.transaction.execute(status -> fixture.mapper.scopePlans("101", "IP-10", true));
+        assertThat(lockedPlans).extracting(InboundPlan::getId).containsExactly(10L, 20L);
+    }
+
+    /** 必须先定位指定客户的真实计划，空客户、其他客户和缺失柜次均不能扩大范围。 */
+    @Test
+    void scopeRequiresTheSelectedCustomerAndANonblankBooking() throws Exception {
+        var fixture = new Fixture();
+
+        assertThat(fixture.mapper.scopePlans(null, "IP-10", false)).isEmpty();
+        assertThat(fixture.mapper.scopePlans("", "IP-10", false)).isEmpty();
+        assertThat(fixture.mapper.scopePlans("202", "IP-10", false)).isEmpty();
+        assertThat(fixture.mapper.scopePlans("101", "MISSING", false)).isEmpty();
+        assertThat(fixture.mapper.scopePlans("101", "IP-70", false)).isEmpty();
+        assertThat(fixture.mapper.scopePlans("101", "IP-80", false)).isEmpty();
+        assertThat(fixture.mapper.scopePlans("101", "IP-90", false)).isEmpty();
+    }
+
+    /** 已完成会话释放活动键后，仍按柜次、柜号和仓定位，并能在事务中锁定。 */
+    @Test
+    void completedSessionCanBeLocatedAndLockedAfterItsActiveKeysAreCleared() throws Exception {
+        var fixture = new Fixture();
+        var originalTime = LocalDateTime.of(2026, 11, 6, 10, 0);
+        var latestTime = originalTime.plusHours(1);
+        fixture.session(100L, "BOOK-1", "CONT-1", 9L, "COMPLETED", originalTime);
+        fixture.session(110L, "BOOK-1", "CONT-1", 9L, "COMPLETED", latestTime);
+        fixture.session(111L, "BOOK-1", "CONT-1", 9L, "COMPLETED_WITH_DIFFERENCE", latestTime);
+        fixture.session(120L, "BOOK-2", "CONT-1", 9L, "COMPLETED", latestTime.plusHours(1));
+        fixture.session(130L, "BOOK-1", "CONT-1", 10L, "COMPLETED", latestTime.plusHours(1));
+        fixture.session(140L, "BOOK-1", "CONT-2", 9L, "COMPLETED", latestTime.plusHours(1));
+        fixture.session(150L, "book-1", "CONT-1", 9L, "COMPLETED", latestTime.plusHours(1));
+
+        ReceivingContainerSession session = fixture.transaction.execute(status ->
+            fixture.mapper.session("BOOK-1", "CONT-1", 9L, true));
+
+        assertThat(session).isNotNull();
+        assertThat(session.getId()).isEqualTo(111L);
+        assertThat(session.getStatus()).isEqualTo("COMPLETED_WITH_DIFFERENCE");
+        assertThat(session.getActiveOperatorKey()).isNull();
+        assertThat(session.getActiveContainerKey()).isNull();
+        assertThat(session.getCompletedAt()).isEqualTo(latestTime);
+        assertThat(fixture.mapper.session("BOOK-1", "CONT-1", 9L, false).getId()).isEqualTo(111L);
+        assertThat(fixture.mapper.session("MISSING", "CONT-1", 9L, false)).isNull();
+        assertThat(fixture.mapper.session(null, "CONT-1", 9L, false)).isNull();
+    }
+
+    /** 独立实盘保留超申报的完整数量及明确零记录，其他会话同码托盘不能混入。 */
+    @Test
+    void physicalCountsRetainActualAndExplicitZeroWithinTheirOriginalSession() throws Exception {
+        var fixture = new Fixture();
+        fixture.db.update("INSERT INTO ll_receiving_fba_pallet_count VALUES (2,111,'FBA:CONT-1:ONT8','PAL-2',0)");
+        fixture.db.update("INSERT INTO ll_receiving_fba_pallet_count VALUES (1,111,'FBA:CONT-1:ONT8','PAL-1',22)");
+        fixture.db.update("INSERT INTO ll_receiving_fba_pallet_count VALUES (3,222,'FBA:CONT-1:ONT8','PAL-1',66)");
+
+        var physical = fixture.mapper.physicalCounts(111L);
+
+        assertThat(physical).extracting(ReceivingFbaPalletCount::getId).containsExactly(1L, 2L);
+        assertThat(physical).extracting(ReceivingFbaPalletCount::getActualPackages).containsExactly(22, 0);
+        assertThat(physical).extracting(ReceivingFbaPalletCount::getSessionId).containsOnly(111L);
+        assertThat(fixture.mapper.physicalCounts(999L)).isEmpty();
+    }
+
+    private static final class Fixture {
+        final JdbcTemplate db;
+        final TransactionTemplate transaction;
+        final InboundReceivingReconciliationMapper mapper;
+
+        /** 仅建立本次生产 SQL 所需列，使用真实 MyBatis 和独立 READ_COMMITTED 事务。 */
+        Fixture() throws Exception {
+            var dataSource = new DriverManagerDataSource("jdbc:h2:mem:receiving-reconciliation-"
+                + UUID.randomUUID() + ";MODE=MySQL;DB_CLOSE_DELAY=-1;LOCK_TIMEOUT=5000", "sa", "");
+            db = new JdbcTemplate(dataSource);
+            transaction = new TransactionTemplate(new DataSourceTransactionManager(dataSource));
+            transaction.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
+            db.execute("CREATE TABLE ll_inbound_plan(id BIGINT PRIMARY KEY,plan_no VARCHAR(128),"
+                + "customer_id VARCHAR(128),source_order_id BIGINT,container_no VARCHAR(64),"
+                + "overseas_warehouse_id BIGINT,status VARCHAR(32))");
+            db.execute("CREATE TABLE ll_order(id BIGINT PRIMARY KEY,customer_id VARCHAR(128),"
+                + "source_container_booking_id VARCHAR(128))");
+            db.execute("CREATE TABLE ll_receiving_container_session(id BIGINT PRIMARY KEY,"
+                + "source_container_booking_id VARCHAR(128),container_no VARCHAR(64),"
+                + "overseas_warehouse_id BIGINT,status VARCHAR(32),active_operator_key VARCHAR(255),"
+                + "active_container_key VARCHAR(255),created_at TIMESTAMP,completed_at TIMESTAMP)");
+            db.execute("CREATE TABLE ll_receiving_fba_pallet_count(id BIGINT PRIMARY KEY,session_id BIGINT,"
+                + "group_key VARCHAR(255),pallet_code VARCHAR(128),actual_packages INT)");
+            plan(20L, "202", "BOOK-1", "CONT-1", 9L);
+            plan(10L, "101", "BOOK-1", "CONT-1", 9L);
+            plan(30L, "101", "BOOK-2", "CONT-1", 9L);
+            plan(40L, "101", "BOOK-1", "CONT-1", 10L);
+            plan(50L, "101", "BOOK-1", "CONT-2", 9L);
+            plan(60L, "101", "book-1", "CONT-1", 9L);
+            plan(70L, "101", "BOOK-1", "CONT-1", 9L);
+            db.update("UPDATE ll_order SET customer_id='202' WHERE id=1070");
+            plan(80L, "101", null, "CONT-1", 9L);
+            plan(90L, "101", "   ", "CONT-1", 9L);
+            var configuration = new MybatisConfiguration();
+            configuration.setMapUnderscoreToCamelCase(true);
+            configuration.addMapper(InboundReceivingReconciliationMapper.class);
+            var factory = new MybatisSqlSessionFactoryBean();
+            factory.setDataSource(dataSource);
+            factory.setConfiguration(configuration);
+            factory.afterPropertiesSet();
+            mapper = new SqlSessionTemplate(factory.getObject()).getMapper(InboundReceivingReconciliationMapper.class);
+        }
+
+        /** 插入真实客户与来源订单的计划关系，测试只通过正式 Mapper 查询范围。 */
+        private void plan(long id, String customerId, String bookingId, String containerNo, long warehouseId) {
+            db.update("INSERT INTO ll_order VALUES (?,?,?)", id + 1000, customerId, bookingId);
+            db.update("INSERT INTO ll_inbound_plan VALUES (?,?,?,?,?,?,?)", id, "IP-" + id,
+                customerId, id + 1000, containerNo, warehouseId, "PENDING_RECONCILIATION");
+        }
+
+        /** 历史完成会话的活动唯一键为空，原始完成时间仍可作为核对证据。 */
+        private void session(long id, String bookingId, String containerNo, long warehouseId,
+                             String status, LocalDateTime createdAt) {
+            db.update("INSERT INTO ll_receiving_container_session VALUES (?,?,?,?,?,?,?,?,?)",
+                id, bookingId, containerNo, warehouseId, status, null, null, createdAt, createdAt);
+        }
+    }
+}

lastleg-service/src/test/java/com/baiyue/lastleg/inboundplan/pda/service/InboundReceivingReconciliationRequestTest.java

@@ -0,0 +1,51 @@
+package com.baiyue.lastleg.inboundplan.pda.service;
+
+import com.baiyue.lastleg.inboundplan.dto.InboundReceivingReconciliation.*;
+import jakarta.validation.Validation;
+import org.junit.jupiter.api.Test;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.IntStream;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/** 请求层接受当前完整核对范围，数量守恒与只读事实继续由服务校验。 */
+class InboundReceivingReconciliationRequestTest {
+    /** 多票多商品的完整矩阵不能被任意一万行上限阻塞。 */
+    @Test void acceptsCompleteLargeReconciliationSnapshot() {
+        List<Quantity> rows = IntStream.range(0, 10400).mapToObj(index ->
+            new Quantity("100", "IP-1", 3L, 10L + index / 400, "SKU-" + index % 400, 0)).toList();
+        List<Count> pallets = IntStream.range(0, 26).mapToObj(index -> new Count(10L + index, 0)).toList();
+        try (var factory = Validation.buildDefaultValidatorFactory()) {
+            assertThat(factory.getValidator().validate(new Confirm("100", "snapshot", "逐托复核", pallets, rows))).isEmpty();
+        }
+    }
+
+    /** 空行必须在进入业务事务前拒绝，不能触发空引用错误。 */
+    @Test void rejectsNullListElements() {
+        try (var factory = Validation.buildDefaultValidatorFactory()) {
+            var validator = factory.getValidator();
+            assertThat(validator.validate(new Confirm("100", "snapshot", "现场复核", Arrays.asList((Count) null), List.of())))
+                .isNotEmpty();
+            assertThat(validator.validate(new Confirm("100", "snapshot", "现场复核", List.of(), Arrays.asList((Quantity) null))))
+                .isNotEmpty();
+        }
+    }
+
+    /** 已完成只读整托可以超过普通FBA单托上限，服务仍禁止改写这些数量。 */
+    @Test void acceptsReadonlySourceQuantityAboveBulkLimit() {
+        try (var factory = Validation.buildDefaultValidatorFactory()) {
+            assertThat(factory.getValidator().validate(new Confirm("100", "snapshot", "现场复核",
+                List.of(new Count(10L, 80)), List.of(new Quantity("100", "IP-1", 3L, 10L, "SKU-1", 80)))))
+                .isEmpty();
+        }
+    }
+
+    /** 原因必填，负数清点或SKU数量均在请求层拒绝。 */
+    @Test void rejectsNegativeCountsAndMissingReason() {
+        try (var factory = Validation.buildDefaultValidatorFactory()) {
+            assertThat(factory.getValidator().validate(new Confirm("100", "snapshot", " ",
+                List.of(new Count(10L, -1)), List.of(new Quantity("100", "IP-1", 3L, 10L, "SKU-1", -1)))))
+                .hasSize(3);
+        }
+    }
+}

lastleg-service/src/test/java/com/baiyue/lastleg/inboundplan/pda/service/InboundReceivingReconciliationServiceTest.java

@@ -0,0 +1,266 @@
+package com.baiyue.lastleg.inboundplan.pda.service;
+
+import com.baiyue.lastleg.entity.LastlegOrder;
+import com.baiyue.lastleg.inboundplan.dto.InboundReceivingReconciliation.*;
+import com.baiyue.lastleg.inboundplan.entity.*;
+import com.baiyue.lastleg.inboundplan.pda.entity.*;
+import com.baiyue.lastleg.inboundplan.pda.gateway.InboundDispatchReceiptGateway;
+import com.baiyue.lastleg.inboundplan.pda.mapper.ReceivingSkuReceiptMapper.FrozenSku;
+import com.baiyue.lastleg.inboundplan.pda.repository.*;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.*;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.test.util.ReflectionTestUtils;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.time.LocalDateTime;
+import java.util.*;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class InboundReceivingReconciliationServiceTest {
+    @Mock InboundReceivingReconciliationRepository reconciliation;
+    @Mock PdaWorkflowRepository repository;
+    @Mock InboundStockReceiptService stock;
+    @Mock InboundDispatchReceiptGateway dispatch;
+    InboundReceivingReconciliationService service;
+    InboundPlan plan;
+    InboundPdaTask task;
+    InboundPlanLine line;
+    ReceivingContainerSession session;
+    List<InboundPlanPallet> pallets;
+    List<InboundPlanPalletAllocation> allocations;
+    final LocalDateTime receivedAt = LocalDateTime.of(2026, 11, 6, 11, 28);
+
+    /** 现场5加20箱，申报内仅分配5加16箱，另有一个明确待核对的预留托盘。 */
+    @BeforeEach void setup() {
+        service = new InboundReceivingReconciliationService();
+        ReflectionTestUtils.setField(service, "reconciliation", reconciliation);
+        ReflectionTestUtils.setField(service, "repository", repository);
+        ReflectionTestUtils.setField(service, "stockReceipts", stock);
+        ReflectionTestUtils.setField(service, "dispatchReceipts", dispatch);
+        ReflectionTestUtils.setField(service, "objectMapper", new ObjectMapper().findAndRegisterModules());
+        plan = new InboundPlan(); plan.setId(1L); plan.setPlanNo("IP-1"); plan.setCustomerId("100");
+        plan.setSourceOrderId(9L); plan.setContainerNo("BOX-1"); plan.setOverseasWarehouseId(99L);
+        plan.setStatus("PENDING_RECONCILIATION"); plan.setVersion(5);
+        LastlegOrder order = new LastlegOrder(); order.setId(9L); order.setCustomerId("100");
+        order.setCustomerName("核对客户"); order.setSourceContainerBookingId("BOOKING-1");
+        order.setOrderType("FIRST_LEG"); order.setDestinationType("FBA");
+        task = new InboundPdaTask(); task.setId(2L); task.setPlanId(1L); task.setCustomerId("100");
+        task.setStatus("PENDING_RECONCILIATION"); task.setCompletedAt(receivedAt); task.setVersion(4);
+        task.setUnloadPhotoFileIds("[10]"); task.setUnloadPhotoUploadedAt(receivedAt);
+        line = new InboundPlanLine(); line.setId(3L); line.setPlanId(1L); line.setCustomerId("100");
+        line.setOrderId(9L); line.setInboundCode("IN-1"); line.setFbaWarehouseCode("ACY2"); line.setRequiredPackageCount(21);
+        session = new ReceivingContainerSession(); session.setId(50L); session.setVersion(4);
+        session.setSourceContainerBookingId("BOOKING-1"); session.setContainerNo("BOX-1");
+        session.setOverseasWarehouseId(99L); session.setStatus("COMPLETED_WITH_DIFFERENCE"); session.setCompletedAt(receivedAt);
+        pallets = new ArrayList<>(); allocations = new ArrayList<>();
+        for (int i = 0; i < 3; i++) {
+            InboundPlanPallet pallet = new InboundPlanPallet(); pallet.setId(10L+i); pallet.setPlanId(1L);
+            pallet.setCustomerId("100"); pallet.setPalletNo("PALLET-"+i); pallet.setActualPackageCount(i == 0 ? 5 : i == 1 ? 16 : 0);
+            pallet.setWarehousePalletId(100L+i); pallet.setWarehouseLocationId(200L+i); pallet.setWarehouseResourceLockId(300L+i);
+            pallet.setDestinationType("FBA"); pallet.setDestinationWarehouseCode("ACY2"); pallet.setVersion(1); pallets.add(pallet);
+            InboundPlanPalletAllocation allocation = new InboundPlanPalletAllocation(); allocation.setId(20L+i);
+            allocation.setCustomerId("100"); allocation.setPlanId(1L); allocation.setLineId(3L); allocation.setPalletId(pallet.getId());
+            allocation.setPlannedPackageCount(7); allocation.setCountedPackageCount(pallet.getActualPackageCount());
+            allocation.setPickedPackageCount(pallet.getActualPackageCount()); allocation.setVersion(1); allocations.add(allocation);
+        }
+        lenient().when(reconciliation.plans(eq("100"), eq("IP-1"), anyBoolean())).thenReturn(List.of(plan));
+        when(repository.order(9L)).thenReturn(order);
+        lenient().when(reconciliation.session(eq("BOOKING-1"), eq("BOX-1"), eq(99L), anyBoolean())).thenReturn(session);
+        lenient().when(repository.task("100",1L)).thenReturn(task);
+        lenient().when(repository.lockTask("100",1L)).thenReturn(task);
+        when(repository.lines(1L)).thenReturn(List.of(line)); when(repository.pallets(1L)).thenReturn(pallets);
+        when(repository.allocations(1L)).thenReturn(allocations);
+        for (int i=0; i<3; i++) {
+            lenient().when(repository.lockAllocation(1L,20L+i)).thenReturn(allocations.get(i));
+            lenient().when(repository.lockPallet(1L,10L+i)).thenReturn(pallets.get(i));
+        }
+        when(repository.frozenSkus("100",1L,3L)).thenReturn(List.of(new FrozenSku("SKU-1",21)));
+        when(repository.skuReceipts("100",1L)).thenReturn(List.of(sku(10L,"SKU-1",5),sku(11L,"SKU-1",16)));
+        lenient().when(reconciliation.physicalCounts(50L)).thenReturn(List.of(physical("PALLET-0",5), physical("PALLET-1",20)));
+    }
+
+    /** 页面保留21箱归属，独立展示25箱实盘，唯一SKU预填完整实盘。 */
+    @Test void exposesPhysicalTwentyFiveSeparatelyFromAttributedTwentyOne() {
+        Snapshot snapshot = service.snapshot("100","IP-1");
+        assertTrue(snapshot.canConfirm()); assertEquals(21,snapshot.expectedPackageCount());
+        assertEquals(21,snapshot.attributedPackageCount()); assertEquals(25,snapshot.countedPackageCount());
+        assertEquals(List.of(5,20,0), snapshot.receipts().stream().map(Receipt::receivedPackageCount).toList());
+        verifyNoInteractions(stock,dispatch);
+    }
+
+    /** 超收按25箱入库，原申报21与原现场时间保留，同时交接运输并记录完整前后证据。 */
+    @Test void confirmsOverReceiptAndReplaysWithoutDuplicatingStock() {
+        Confirm request = request(service.snapshot("100","IP-1"), 5,20,0);
+        Result result = service.confirm("100","IP-1","admin","key",request);
+        assertEquals("COMPLETED",result.status()); assertEquals(25,result.confirmedPackageCount());
+        assertEquals(21,line.getRequiredPackageCount()); assertEquals(receivedAt,task.getCompletedAt());
+        assertEquals(20,allocations.get(1).getPickedPackageCount()); assertEquals(20,pallets.get(1).getActualPackageCount());
+        var sequence = inOrder(dispatch,reconciliation,stock);
+        sequence.verify(dispatch).lock(List.of(1L));
+        sequence.verify(reconciliation).session("BOOKING-1","BOX-1",99L,true);
+        sequence.verify(stock).stockInReconciled(eq("100"),eq(plan),eq(task),eq(List.of(line)),anyList(),anyList(),eq(receivedAt));
+        sequence.verify(dispatch).complete(eq(List.of(1L)),eq("admin"),any());
+        var audit = ArgumentCaptor.forClass(InboundPdaOperation.class); verify(repository).insert(audit.capture());
+        assertTrue(audit.getValue().getRequestJson().contains("sourceFacts"));
+        assertTrue(audit.getValue().getRequestJson().contains("现场核实数量"));
+        when(repository.operation("100","key")).thenReturn(audit.getValue());
+        assertEquals(result,service.confirm("100","IP-1","admin","key",request));
+        verify(stock,times(1)).stockInReconciled(anyString(),any(),any(),anyList(),anyList(),anyList(),any());
+        assertThrows(ResponseStatusException.class,()->service.confirm("100","IP-1","other-admin","key",request));
+    }
+
+    /** 清点误录可在明确原因下更正为21箱，旧实盘完整留在审计中。 */
+    @Test void correctsPhysicalEntryAndCompletesAtTwentyOne() {
+        Result result=service.confirm("100","IP-1","admin","key",request(service.snapshot("100","IP-1"),5,16,0));
+        assertEquals(21,result.confirmedPackageCount()); assertEquals("COMPLETED",result.status());
+        var saved=ArgumentCaptor.forClass(ReceivingFbaPalletCount.class);
+        verify(reconciliation,times(3)).savePhysical(saved.capture(),anyBoolean());
+        assertEquals(List.of(5,16,0),saved.getAllValues().stream().map(ReceivingFbaPalletCount::getActualPackages).toList());
+    }
+
+    /** 短少与全无实收都可确认，预留托盘明确写零，不伪造库存箱数。 */
+    @Test void confirmsShortageIncludingExplicitZero() {
+        Result result=service.confirm("100","IP-1","admin","key",request(service.snapshot("100","IP-1"),0,0,0));
+        assertEquals("PARTIAL_INBOUND",result.status()); assertEquals(0,result.confirmedPackageCount());
+        assertTrue(allocations.stream().allMatch(row->row.getCountedPackageCount()==0&&row.getPickedPackageCount()==0));
+        verify(reconciliation).replaceSkuReceipts("100",1L,List.of());
+        verify(dispatch).complete(eq(List.of(1L)),eq("admin"),any());
+    }
+
+    /** 每托归属必须与确认清点守恒，拒绝用21箱分配掩盖25箱实盘。 */
+    @Test void rejectsUnattributedOverReceiptBeforeAnyWrite() {
+        Snapshot snapshot=service.snapshot("100","IP-1"); Confirm good=request(snapshot,5,20,0);
+        Confirm bad=new Confirm("100",snapshot.snapshotHash(),"现场核实数量",good.pallets(),request(snapshot,5,16,0).receipts());
+        assertThrows(ResponseStatusException.class,()->service.confirm("100","IP-1","admin","key",bad));
+        verifyNoInteractions(stock); verify(reconciliation,never()).savePhysical(any(),anyBoolean());
+    }
+
+    /** 旧快照不能覆盖另一操作的最新清点。 */
+    @Test void rejectsStaleSnapshot() {
+        Snapshot snapshot=service.snapshot("100","IP-1"); Confirm good=request(snapshot,5,20,0);
+        session.setVersion(5);
+        assertThrows(ResponseStatusException.class,()->service.confirm("100","IP-1","admin","key",good));
+        verifyNoInteractions(stock); verify(reconciliation,never()).replaceSkuReceipts(anyString(),anyLong(),anyList());
+    }
+
+    /** 多SKU必须显式核对，不将总箱数自动猜分给商品。 */
+    @Test void explicitSkuShortageCannotBeOffsetByAnotherSkuOverReceipt() {
+        when(repository.frozenSkus("100",1L,3L)).thenReturn(List.of(new FrozenSku("SKU-1",10),new FrozenSku("SKU-2",11)));
+        when(repository.skuReceipts("100",1L)).thenReturn(List.of(sku(10L,"SKU-1",5),sku(11L,"SKU-2",16)));
+        Snapshot snapshot=service.snapshot("100","IP-1");
+        assertEquals(21,snapshot.receipts().stream().mapToInt(Receipt::receivedPackageCount).sum());
+        List<Quantity> quantities=snapshot.receipts().stream().map(row -> new Quantity(row.customerId(),row.planNo(),row.lineId(),row.palletId(),row.skuCode(),
+            row.palletId()==10L&&row.skuCode().equals("SKU-1")?5:
+            row.palletId()==11L&&row.skuCode().equals("SKU-1")?4:
+            row.palletId()==11L&&row.skuCode().equals("SKU-2")?16:0)).toList();
+        Confirm request=new Confirm("100",snapshot.snapshotHash(),"逐商品核实",request(snapshot,5,20,0).pallets(),quantities);
+        Result result=service.confirm("100","IP-1","admin","key",request);
+        assertEquals("PARTIAL_INBOUND",result.status()); assertEquals(25,result.confirmedPackageCount());
+    }
+
+    /** 非本人范围和缺失原会话不能进入确认。 */
+    @Test void rejectsForeignScopeAndMissingSession() {
+        assertThrows(ResponseStatusException.class,()->service.snapshot("200","IP-1"));
+        when(reconciliation.session(eq("BOOKING-1"),eq("BOX-1"),eq(99L),anyBoolean())).thenReturn(null);
+        Snapshot snapshot=service.snapshot("100","IP-1"); assertFalse(snapshot.canConfirm());
+        assertThrows(ResponseStatusException.class,()->service.confirm("100","IP-1","admin","key",request(snapshot,5,20,0)));
+        verifyNoInteractions(stock);
+    }
+
+    /** 原现场仍在收货时禁止后台抢先入库。 */
+    @Test void blocksActiveOnsiteSession() {
+        session.setStatus("RECEIVING"); assertFalse(service.snapshot("100","IP-1").canConfirm());
+    }
+
+    /** 已完成的普通地址票据从真实库存凭证恢复，不能因缺少批量收货行阻塞本柜核对。 */
+    @Test void completedOverseasOrderKeepsItsRealStockImmutable() {
+        addCompletedPlan(false);
+        Snapshot snapshot = service.snapshot("100", "IP-1");
+        Receipt fixed = snapshot.receipts().stream().filter(row -> row.planNo().equals("IP-2")).findFirst().orElseThrow();
+        assertEquals(8, fixed.receivedPackageCount());
+        assertFalse(fixed.editable());
+        Result result = service.confirm("100", "IP-1", "admin", "key", request(snapshot, 5, 20, 0));
+        assertEquals("COMPLETED", result.status());
+        assertEquals(List.of("IP-1"), result.reconciledPlanNos());
+        verify(stock, never()).stockInReconciled(eq("200"), any(), any(), anyList(), anyList(), anyList(), any());
+    }
+
+    /** 同目的仓一件代发的原整托独立冻结，普通票不能把额外实收写入该托。 */
+    @Test void completedDropshipPalletCannotReceiveOrdinaryFbaCargo() {
+        addCompletedPlan(true);
+        Snapshot snapshot = service.snapshot("100", "IP-1");
+        Pallet dropship = snapshot.pallets().stream().filter(row -> row.palletId().equals(64L)).findFirst().orElseThrow();
+        assertTrue(dropship.groupKey().startsWith("DROPSHIP:"));
+        assertFalse(dropship.editable());
+        assertTrue(snapshot.receipts().stream().filter(row -> row.palletId().equals(64L))
+            .allMatch(row -> row.planNo().equals("IP-2") && !row.editable()));
+        assertEquals("COMPLETED", service.confirm("100", "IP-1", "admin", "key", request(snapshot, 5, 20, 0)).status());
+    }
+
+    /** 清点量变化时逐来源及整托体积同步采用现有单箱体积口径。 */
+    @Test void recalculatesActualVolumesFromConfirmedCounts() {
+        line.setVolumeCbm(new java.math.BigDecimal("2.1000"));
+        service.confirm("100", "IP-1", "admin", "key", request(service.snapshot("100", "IP-1"), 5, 20, 0));
+        assertEquals(new java.math.BigDecimal("2.0000"), allocations.get(1).getActualVolumeCbm());
+        assertEquals(new java.math.BigDecimal("2.0000"), pallets.get(1).getActualVolumeCbm());
+        assertEquals(new java.math.BigDecimal("0.0000"), pallets.get(2).getActualVolumeCbm());
+    }
+
+    /** 按三托单 SKU 样本生成完整确认请求，其他只读票据采用原事实。 */
+    private Confirm request(Snapshot snapshot,int first,int second,int third) {
+        Map<Long,Integer> counts=Map.of(10L,first,11L,second,12L,third);
+        return new Confirm("100",snapshot.snapshotHash(),"现场核实数量",
+            snapshot.pallets().stream().map(row->new Count(row.palletId(),counts.getOrDefault(row.palletId(), row.countedPackageCount()))).toList(),
+            snapshot.receipts().stream().map(row->new Quantity(row.customerId(),row.planNo(),row.lineId(),row.palletId(),row.skuCode(),counts.getOrDefault(row.palletId(), row.receivedPackageCount()))).toList());
+    }
+
+    /** 准备同柜已结束的另一客户票据，其库存来源不可被本次普通实收改写。 */
+    private void addCompletedPlan(boolean dropship) {
+        InboundPlan other = new InboundPlan(); other.setId(60L); other.setPlanNo("IP-2"); other.setCustomerId("200");
+        other.setSourceOrderId(69L); other.setContainerNo("BOX-1"); other.setOverseasWarehouseId(99L);
+        other.setStatus("COMPLETED"); other.setVersion(2);
+        LastlegOrder order = new LastlegOrder(); order.setId(69L); order.setCustomerId("200");
+        order.setOrderType(dropship ? "ONE_CLICK_DROPSHIP" : "FIRST_LEG");
+        order.setDestinationType(dropship ? "FBA" : "OVERSEAS");
+        InboundPdaTask completed = new InboundPdaTask(); completed.setId(62L); completed.setPlanId(60L);
+        completed.setCustomerId("200"); completed.setStatus("COMPLETED"); completed.setCompletedAt(receivedAt);
+        InboundPlanLine otherLine = new InboundPlanLine(); otherLine.setId(63L); otherLine.setPlanId(60L);
+        otherLine.setOrderId(69L); otherLine.setRequiredPackageCount(8); otherLine.setDestinationType(order.getDestinationType());
+        otherLine.setDestinationWarehouseId("DEST-2"); otherLine.setFbaWarehouseCode(dropship ? "ACY2" : null);
+        InboundPlanPallet pallet = new InboundPlanPallet(); pallet.setId(64L); pallet.setPlanId(60L);
+        pallet.setCustomerId("200"); pallet.setPalletNo("OTHER-PALLET"); pallet.setActualPackageCount(8);
+        InboundPlanPalletAllocation allocation = new InboundPlanPalletAllocation(); allocation.setId(65L);
+        allocation.setPlanId(60L); allocation.setLineId(63L); allocation.setPalletId(64L);
+        allocation.setCountedPackageCount(8); allocation.setPickedPackageCount(8);
+        InboundStockReceipt stock = new InboundStockReceipt(); stock.setAllocationId(65L); stock.setLineId(63L);
+        stock.setSkuCode(dropship ? "MIXED" : "SKU-2"); stock.setReceivedPackages(8L);
+        when(reconciliation.plans(eq("100"), eq("IP-1"), anyBoolean())).thenReturn(List.of(plan, other));
+        when(repository.order(69L)).thenReturn(order);
+        when(repository.task("200", 60L)).thenReturn(completed);
+        when(repository.lockTask("200", 60L)).thenReturn(completed);
+        when(repository.lines(60L)).thenReturn(List.of(otherLine));
+        when(repository.pallets(60L)).thenReturn(List.of(pallet));
+        when(repository.allocations(60L)).thenReturn(List.of(allocation));
+        when(repository.lockAllocation(60L, 65L)).thenReturn(allocation);
+        when(repository.lockPallet(60L, 64L)).thenReturn(pallet);
+        when(repository.frozenSkus("200", 60L, 63L)).thenReturn(List.of(new FrozenSku("SKU-2", 8)));
+        when(reconciliation.stockReceipts("200", 62L)).thenReturn(List.of(stock));
+    }
+    /** 构造已分配到货件的 SKU 数量。 */
+    private ReceivingSkuReceipt sku(long palletId,String skuCode,int packages) {
+        ReceivingSkuReceipt row=new ReceivingSkuReceipt(); row.setLineId(3L); row.setPalletId(palletId);
+        row.setSkuCode(skuCode); row.setReceivedPackages(packages); return row;
+    }
+    /** 构造独立于申报内分配的完整现场清点。 */
+    private ReceivingFbaPalletCount physical(String pallet,int packages) {
+        ReceivingFbaPalletCount row=new ReceivingFbaPalletCount(); row.setId(1000L+pallet.hashCode()); row.setSessionId(50L);
+        row.setGroupKey("FBA:BOX-1:ACY2"); row.setPalletCode(pallet); row.setActualPackages(packages);
+        row.setCreatedAt(receivedAt); row.setUpdatedAt(receivedAt); return row;
+    }
+}

lastleg-service/src/test/java/com/baiyue/lastleg/inboundplan/pda/service/InboundStockReceiptServiceTest.java

@@ -23,6 +23,7 @@ import com.baiyue.lastleg.mapper.LastlegOrderStatusHistoryMapper;
 import com.baiyue.lastleg.entity.LastlegOrderStatusHistory;
 import com.baiyue.lastleg.dropship.service.DropshipOrderService;
 import com.baiyue.lastleg.dropship.model.DropshipPalletSnapshot;
+import com.baiyue.lastleg.storagerent.service.StorageRentService;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -61,18 +62,24 @@ class InboundStockReceiptServiceTest {
     @Mock WarehouseResourceGateway warehouseGateway;
     @Mock DropshipOrderService dropshipOrders;
     @Mock LastlegOrderStatusHistoryMapper orderHistories;
+    @Mock StorageRentService storageRent;
     private InboundStockReceiptService service;
 
     @BeforeEach
     /** 组装库存、资源与逐箱事实的隔离依赖。 */
     void setUp() {
         service = new InboundStockReceiptService();
-        org.springframework.test.util.ReflectionTestUtils.setField(service, "storageRent", org.mockito.Mockito.mock(com.baiyue.lastleg.storagerent.service.StorageRentService.class));
+        ReflectionTestUtils.setField(service, "storageRent", storageRent);
         ReflectionTestUtils.setField(service, "orders", orders);
         ReflectionTestUtils.setField(service, "orderDetails", orderDetails);
         ReflectionTestUtils.setField(service, "receipts", receipts);
         ReflectionTestUtils.setField(service, "receivingSkuReceipts", receivingSkuReceipts);
         ReflectionTestUtils.setField(service, "workflowRepository", workflowRepository);
+        var reconciliationRepository = new com.baiyue.lastleg.inboundplan.pda.repository.InboundReceivingReconciliationRepository();
+        ReflectionTestUtils.setField(reconciliationRepository, "orders", orders);
+        ReflectionTestUtils.setField(reconciliationRepository, "stockReceipts", receipts);
+        ReflectionTestUtils.setField(reconciliationRepository, "skus", receivingSkuReceipts);
+        ReflectionTestUtils.setField(service, "reconciliationRepository", reconciliationRepository);
         ReflectionTestUtils.setField(service, "inventory", inventory);
         ReflectionTestUtils.setField(service, "warehouseGateway", warehouseGateway);
         org.mockito.Mockito.lenient().when(warehouseGateway.resolveLocation(eq(900L), anyLong())).thenAnswer(invocation -> {
@@ -82,7 +89,6 @@ class InboundStockReceiptServiceTest {
         });
         ReflectionTestUtils.setField(service, "dropshipOrders", dropshipOrders);
         ReflectionTestUtils.setField(service, "orderHistories", orderHistories);
-        when(receipts.listTask("100", 2L)).thenReturn(List.of());
         when(receivingSkuReceipts.listPlan("100", 1L)).thenReturn(List.of());
     }
 
@@ -476,6 +482,195 @@ class InboundStockReceiptServiceTest {
         verify(inventory, never()).stockIn(any(), any(), any());
     }
 
+    /** 明确核对的超收按5加20分别入库，保留21箱申报和原现场计租时间。 */
+    @Test void reconciledOverReceiptStocksAllConfirmedPallets() {
+        Fixture f = fixture(21, 21, 5, 210);
+        f.allocation.setCountedPackageCount(5);
+        var secondAllocation = allocation(32L, 12L, 22L, 20);
+        secondAllocation.setCountedPackageCount(20);
+        var secondPallet = pallet(22L, 2002L);
+        LocalDateTime receivedAt = LocalDateTime.of(2026, 11, 6, 12, 0);
+        when(orders.selectBatchIds(any())).thenReturn(List.of(f.order));
+        when(receivingSkuReceipts.listPlan("100", 1L)).thenReturn(List.of(
+            skuReceipt(12, 21, "SKU-1", 5), skuReceipt(12, 22, "SKU-1", 20)));
+        when(inventory.stockIn(eq("100"), eq("operator"), any()))
+            .thenReturn(new InventoryCommandResponse(8L, "STOCK_IN", 9L, 10L, 25, 0, 0, 0, false, false));
+
+        service.stockInReconciled("100", f.plan, f.task, List.of(f.line),
+            List.of(f.allocation, secondAllocation), List.of(f.pallet, secondPallet), receivedAt);
+
+        var commands = ArgumentCaptor.forClass(InventoryCommandRequests.StockIn.class);
+        verify(inventory, times(2)).stockIn(eq("100"), eq("operator"), commands.capture());
+        assertEquals(List.of(5L, 20L), commands.getAllValues().stream().map(InventoryCommandRequests.StockIn::packages).toList());
+        var saved = ArgumentCaptor.forClass(InboundStockReceipt.class);
+        verify(receipts, times(2)).insert(saved.capture());
+        assertEquals(List.of(receivedAt, receivedAt), saved.getAllValues().stream().map(InboundStockReceipt::getReceivedAt).toList());
+        verify(storageRent, times(2)).registerInbound(any(InboundStockReceipt.class), eq(f.order));
+        assertEquals(21, f.line.getRequiredPackageCount());
+        assertEquals(21, f.detail.getPackageCount());
+        assertEquals("INBOUND_PLAN:COMPLETED", f.order.getSubOrderStatus());
+        verify(dropshipOrders, never()).activateAfterStockIn(any(), any(), any(), any());
+    }
+
+    /** 零实收可以完成异常核对，不创建库存或计租凭证。 */
+    @Test void reconciledZeroReceiptCompletesAsPartialWithoutStock() {
+        Fixture f = fixture(21, 21, 0, 210);
+        f.allocation.setCountedPackageCount(0);
+        when(orders.selectBatchIds(any())).thenReturn(List.of(f.order));
+
+        service.stockInReconciled("100", f.plan, f.task, List.of(f.line), List.of(f.allocation),
+            List.of(f.pallet), LocalDateTime.now());
+
+        verify(inventory, never()).stockIn(any(), any(), any());
+        verify(receipts, never()).insert(any(InboundStockReceipt.class));
+        verify(storageRent, never()).registerInbound(any(), any());
+        assertEquals("INBOUND_COMPLETED", f.order.getCurrentStatus());
+        assertEquals("INBOUND_PLAN:PARTIAL_INBOUND", f.order.getSubOrderStatus());
+    }
+
+    /** 一个 SKU 超收不能掩盖另一个 SKU 短少，即使全票总数多于申报。 */
+    @Test void reconciledKnownSkuOverReceiptStillPreservesOtherSkuShortage() {
+        Fixture f = fixture(21, 21, 25, 210);
+        f.allocation.setCountedPackageCount(25);
+        f.detail.setPackageCount(10);
+        when(orderDetails.selectList(any())).thenReturn(List.of(f.detail, detail(202, "SKU-2", 11, 110)));
+        when(orders.selectBatchIds(any())).thenReturn(List.of(f.order));
+        when(receivingSkuReceipts.listPlan("100", 1L)).thenReturn(List.of(
+            skuReceipt(12, 21, "SKU-1", 16), skuReceipt(12, 21, "SKU-2", 9)));
+        when(inventory.stockIn(eq("100"), eq("operator"), any()))
+            .thenReturn(new InventoryCommandResponse(8L, "STOCK_IN", 9L, 10L, 25, 0, 0, 0, false, false));
+
+        service.stockInReconciled("100", f.plan, f.task, List.of(f.line), List.of(f.allocation),
+            List.of(f.pallet), LocalDateTime.now());
+
+        verify(inventory, times(2)).stockIn(eq("100"), eq("operator"), any());
+        assertEquals("INBOUND_PLAN:PARTIAL_INBOUND", f.order.getSubOrderStatus());
+    }
+
+    /** 多票分别判断短少，不能把另一票零实收的状态套给已核平的超收订单。 */
+    @Test void reconciledReceiptCompletesEachOrderFromItsOwnSkuFacts() {
+        Fixture f = fixture(21, 21, 25, 210);
+        f.allocation.setCountedPackageCount(25);
+        var emptyLine = new InboundPlanLine();
+        emptyLine.setId(13L); emptyLine.setOrderId(102L); emptyLine.setRequiredPackageCount(10);
+        var emptyOrder = new LastlegOrder();
+        emptyOrder.setId(102L); emptyOrder.setCustomerId("100"); emptyOrder.setCurrentStatus("INBOUND_PLANNED");
+        var emptyAllocation = allocation(32L, 13L, 22L, 0);
+        emptyAllocation.setCountedPackageCount(0);
+        when(orders.selectBatchIds(any())).thenReturn(List.of(f.order, emptyOrder));
+        when(orders.lockById("100", 102L)).thenReturn(emptyOrder);
+        when(orderDetails.selectList(any())).thenReturn(List.of(f.detail), List.of(detail(202L, "SKU-2", 10, 100)));
+        when(receivingSkuReceipts.listPlan("100", 1L)).thenReturn(List.of(skuReceipt(12, 21, "SKU-1", 25)));
+        when(inventory.stockIn(eq("100"), eq("operator"), any()))
+            .thenReturn(new InventoryCommandResponse(8L, "STOCK_IN", 9L, 10L, 25, 0, 0, 0, false, false));
+
+        service.stockInReconciled("100", f.plan, f.task, List.of(f.line, emptyLine),
+            List.of(f.allocation, emptyAllocation), List.of(f.pallet, pallet(22L, 2002L)), LocalDateTime.now());
+
+        assertEquals("INBOUND_PLAN:COMPLETED", f.order.getSubOrderStatus());
+        assertEquals("INBOUND_PLAN:PARTIAL_INBOUND", emptyOrder.getSubOrderStatus());
+        verify(inventory).stockIn(eq("100"), eq("operator"), any());
+    }
+
+    /** 缺少明确清点事实不能按零实收入库。 */
+    @Test void reconciledReceiptRejectsUnknownZeroCount() {
+        Fixture f = fixture(21, 21, 0, 210);
+        when(orders.selectBatchIds(any())).thenReturn(List.of(f.order));
+
+        assertThrows(ResponseStatusException.class, () -> service.stockInReconciled("100", f.plan, f.task,
+            List.of(f.line), List.of(f.allocation), List.of(f.pallet), LocalDateTime.now()));
+
+        verify(inventory, never()).stockIn(any(), any(), any());
+    }
+
+    /** 异常确认入口不能绕过一件代发必须整托收货的冻结来源。 */
+    @Test void reconciledReceiptRejectsDropshipOrder() {
+        Fixture f = fixture(21, 21, 0, 210);
+        f.allocation.setCountedPackageCount(0);
+        f.order.setOrderType("ONE_CLICK_DROPSHIP");
+        when(orders.selectBatchIds(any())).thenReturn(List.of(f.order));
+
+        assertThrows(ResponseStatusException.class, () -> service.stockInReconciled("100", f.plan, f.task,
+            List.of(f.line), List.of(f.allocation), List.of(f.pallet), LocalDateTime.now()));
+
+        verify(inventory, never()).stockIn(any(), any(), any());
+    }
+
+    /** 未明确逐 SKU 实收时不按原申报顺序自动分摊超收。 */
+    @Test void reconciledReceiptRequiresExactSkuFacts() {
+        Fixture f = fixture(21, 21, 25, 210);
+        f.allocation.setCountedPackageCount(25);
+        when(orders.selectBatchIds(any())).thenReturn(List.of(f.order));
+
+        assertThrows(ResponseStatusException.class, () -> service.stockInReconciled("100", f.plan, f.task,
+            List.of(f.line), List.of(f.allocation), List.of(f.pallet), LocalDateTime.now()));
+
+        verify(inventory, never()).stockIn(any(), any(), any());
+    }
+
+    /** 异常核对仍不能引入冻结申报以外的 SKU。 */
+    @Test void reconciledReceiptRejectsUnknownSku() {
+        Fixture f = fixture(21, 21, 25, 210);
+        f.allocation.setCountedPackageCount(25);
+        when(orders.selectBatchIds(any())).thenReturn(List.of(f.order));
+        when(receivingSkuReceipts.listPlan("100", 1L)).thenReturn(List.of(skuReceipt(12, 21, "UNKNOWN", 25)));
+
+        assertThrows(ResponseStatusException.class, () -> service.stockInReconciled("100", f.plan, f.task,
+            List.of(f.line), List.of(f.allocation), List.of(f.pallet), LocalDateTime.now()));
+
+        verify(inventory, never()).stockIn(any(), any(), any());
+    }
+
+    /** 全票总数相等也须拒绝逐托实收与 SKU 实收错配。 */
+    @Test void reconciledReceiptRejectsMismatchedPalletQuantities() {
+        Fixture f = fixture(21, 21, 5, 210);
+        f.allocation.setCountedPackageCount(5);
+        var secondAllocation = allocation(32L, 12L, 22L, 20);
+        secondAllocation.setCountedPackageCount(20);
+        when(orders.selectBatchIds(any())).thenReturn(List.of(f.order));
+        when(receivingSkuReceipts.listPlan("100", 1L)).thenReturn(List.of(
+            skuReceipt(12, 21, "SKU-1", 6), skuReceipt(12, 22, "SKU-1", 19)));
+
+        assertThrows(ResponseStatusException.class, () -> service.stockInReconciled("100", f.plan, f.task,
+            List.of(f.line), List.of(f.allocation, secondAllocation), List.of(f.pallet, pallet(22L, 2002L)), LocalDateTime.now()));
+
+        verify(inventory, never()).stockIn(any(), any(), any());
+    }
+
+    /** 同一份已入账实收可重放，不重复生成库存和计租。 */
+    @Test void reconciledReceiptReplaysOnlyMatchingStockReceipts() {
+        Fixture f = fixture(21, 21, 25, 210);
+        f.allocation.setCountedPackageCount(25);
+        when(orders.selectBatchIds(any())).thenReturn(List.of(f.order));
+        when(receivingSkuReceipts.listPlan("100", 1L)).thenReturn(List.of(skuReceipt(12, 21, "SKU-1", 25)));
+        var existing = new InboundStockReceipt();
+        existing.setAllocationId(31L); existing.setLineId(12L); existing.setSkuCode("SKU-1"); existing.setReceivedPackages(25L);
+        when(receipts.listTask("100", 2L)).thenReturn(List.of(existing));
+
+        service.stockInReconciled("100", f.plan, f.task, List.of(f.line), List.of(f.allocation), List.of(f.pallet), LocalDateTime.now());
+
+        verify(inventory, never()).stockIn(any(), any(), any());
+        verify(receipts, never()).insert(any(InboundStockReceipt.class));
+        verify(storageRent, never()).registerInbound(any(), any());
+        assertEquals("INBOUND_PLAN:COMPLETED", f.order.getSubOrderStatus());
+    }
+
+    /** 已入账凭证数量变化必须拒绝，不能沿用仅比较 allocation ID 的普通重试分支。 */
+    @Test void reconciledReceiptRejectsChangedStockReceiptQuantity() {
+        Fixture f = fixture(21, 21, 25, 210);
+        f.allocation.setCountedPackageCount(25);
+        when(orders.selectBatchIds(any())).thenReturn(List.of(f.order));
+        when(receivingSkuReceipts.listPlan("100", 1L)).thenReturn(List.of(skuReceipt(12, 21, "SKU-1", 25)));
+        var existing = new InboundStockReceipt();
+        existing.setAllocationId(31L); existing.setLineId(12L); existing.setSkuCode("SKU-1"); existing.setReceivedPackages(21L);
+        when(receipts.listTask("100", 2L)).thenReturn(List.of(existing));
+
+        assertThrows(ResponseStatusException.class, () -> service.stockInReconciled("100", f.plan, f.task,
+            List.of(f.line), List.of(f.allocation), List.of(f.pallet), LocalDateTime.now()));
+
+        verify(inventory, never()).stockIn(any(), any(), any());
+    }
+
     private Fixture fixture(int required, int planned, int picked, int quantity) {
         InboundPlan plan = new InboundPlan(); plan.setId(1L); plan.setPlanNo("IP-1"); plan.setOverseasWarehouseId(900L);
         InboundPdaTask task = new InboundPdaTask(); task.setId(2L); task.setOperatorId("operator");