优化

firstleg/src/main/java/com/baiyue/firstleg/controller/PlatformSmartLoadingController.java

@@ -38,4 +38,6 @@ public class PlatformSmartLoadingController {
  public ApiResponse<Plan> warehouseRemark(@AuthenticationPrincipal AuthenticatedUser u,@PathVariable @Positive long planId,@PathVariable @Positive long itemId,@Valid @RequestBody WarehouseRemarkRequest r){FirstlegScopeGuard.platform(u);return ApiResponse.success(service.updateWarehouseRemark(planId,itemId,r,u.userId(),u.username()));}
  @DeleteMapping("/plans/{planId}/items/{itemId}") @PreAuthorize("hasAuthority('platform:firstleg:smart-loading:delete')")
  public ApiResponse<Plan> delete(@AuthenticationPrincipal AuthenticatedUser u,@PathVariable @Positive long planId,@PathVariable @Positive long itemId,@Valid @RequestBody DeleteRequest r){FirstlegScopeGuard.platform(u);return ApiResponse.success(service.delete(planId,itemId,r,u.userId(),u.username()));}
+ @DeleteMapping("/plans/{planId}/unpicked-items") @PreAuthorize("hasAuthority('platform:firstleg:smart-loading:delete')")
+ public ApiResponse<Plan> removeUnpicked(@AuthenticationPrincipal AuthenticatedUser u,@PathVariable @Positive long planId,@Valid @RequestBody RemoveUnpickedRequest r){FirstlegScopeGuard.platform(u);return ApiResponse.success(service.removeUnpicked(planId,r,u.userId(),u.username()));}
 }

firstleg/src/main/java/com/baiyue/firstleg/dto/SmartLoadingDtos.java

@@ -73,6 +73,8 @@ public final class SmartLoadingDtos { private SmartLoadingDtos(){}
   @NotNull @Min(0) Integer expectedItemVersion,@NotBlank @Size(max=128) String operationId) {}
  public record DeleteRequest(@NotNull @Min(0) Integer expectedPlanVersion,
   @NotNull @Min(0) Integer expectedItemVersion,@NotBlank @Size(max=128) String operationId) {}
+ public record RemoveUnpickedRequest(@NotNull @Min(0) Integer expectedPlanVersion,
+  @NotBlank @Size(max=128) String operationId) {}
  public record WarehouseRemarkRequest(@Size(max=1000) String warehouseRemark,
   @NotNull @Min(0) Integer expectedPlanVersion, @NotNull @Min(0) Integer expectedItemVersion,
   @NotBlank @Size(max=128) String operationId) {}

firstleg/src/main/java/com/baiyue/firstleg/service/SmartLoadingService.java

@@ -420,7 +420,6 @@ public class SmartLoadingService {
             request.inboundDetailId());
         if (candidate == null) throw conflict("入库货物不存在或尚未完成入库");
         if (!wholeGroupAssignment) requireStandalone(candidate.accountId(), candidate.inboundId());
-        requireSameChannel(booking, candidate);
         requireSameCustomerScope(booking, candidate);
         var task = loadingPickService.mutationSnapshot(planId);
         if (task.taskId() != null && "LOADING".equals(task.taskStatus())) {
@@ -525,7 +524,6 @@ public class SmartLoadingService {
         for (InboundAllocation allocation : allocations) {
             if (allocation.packageCount() == 0) continue;
             Candidate candidate = allocation.candidate();
-            requireSameChannel(booking, candidate);
             requireSameCustomerScope(booking, candidate);
             checkRouteAndCapacity(booking, current, candidate, allocation.packageCount(), true);
             OrderCargoClient.CargoBinding cargo = declared.stream()
@@ -581,7 +579,7 @@ public class SmartLoadingService {
         LoadingPlanEntity plan = editing(planId, request.expectedVersion(), operatorId, operatorName);
         ContainerBookingEntity booking = requireBooking(plan.getContainerBookingId());
         List<Candidate> details = frozenDetails == null
-            ? candidates(plan.getContainerBookingId(), booking.getWarehouseId()).stream()
+            ? manualCandidates(booking).stream()
                 .filter(candidate -> Objects.equals(candidate.inboundId(), request.inboundId())).toList()
             : List.copyOf(frozenDetails);
         if (details.isEmpty()) throw conflict("入仓码不存在、已分配完或尚未完成入库");
@@ -641,7 +639,6 @@ public class SmartLoadingService {
         for (InboundAllocation allocation : allocations) {
             if (allocation.packageCount() == 0) continue;
             Candidate candidate = allocation.candidate();
-            requireSameChannel(booking, candidate);
             requireSameCustomerScope(booking, candidate);
             checkRouteAndCapacity(booking, current, candidate, allocation.packageCount(), true);
             OrderCargoClient.CargoBinding cargo = declared.stream().map(DeclaredCargo::cargo)
@@ -853,7 +850,6 @@ public class SmartLoadingService {
         Candidate candidate = repository.candidate(planId, booking.getWarehouseId(), item.getInboundId(),
             item.getInboundDetailId());
         if (candidate == null || request.packageCount() > candidate.availablePackageCount() + item.getPackageCount()) throw validation("调整箱数超过可用箱数");
-        requireSameChannel(booking, candidate);
         requireSameCustomerScope(booking, candidate);
         OrderCargoClient.CargoBinding cargo = loadCargo(candidate);
         List<LoadingPlanItemEntity> others = new ArrayList<>(repository.items(planId));
@@ -945,6 +941,84 @@ public class SmartLoadingService {
         return view(repository.plan(planId), requireBooking(plan.getContainerBookingId()));
     }
 
+    @Transactional
+    @BusinessAudit(event = "SMART_LOADING_UNPICKED_REMOVE", resourceType = "LOADING_PLAN",
+        resourceId = "#planId", description = "批量移除智能装柜未拣明细")
+    public Plan removeUnpicked(long planId, RemoveUnpickedRequest request,
+                               long operatorId, String operatorName) {
+        String operation = operation(request.operationId());
+        String requestHash = sha256("REMOVE_UNPICKED|" + planId + '|' + request.expectedPlanVersion());
+        Plan replay = replay(operation, planId, "REMOVE_UNPICKED", null, requestHash);
+        if (replay != null) return replay;
+        LoadingPlanEntity plan = editing(planId, request.expectedPlanVersion(), operatorId, operatorName);
+        ContainerBookingEntity booking = requireBooking(plan.getContainerBookingId());
+        List<LoadingPlanItemEntity> items = repository.items(planId);
+        LoadingPickService.MutationSnapshot pickSnapshot = loadingPickService.mutationSnapshot(planId);
+        Map<Long, Integer> picked = pickSnapshot == null ? Map.of() : pickSnapshot.pickedByPlanItem();
+
+        Map<String, GroupSnapshot> groupByMember = new HashMap<>();
+        Map<Long, GroupSnapshot> groups = new LinkedHashMap<>();
+        for (LoadingPlanItemEntity item : items) {
+            String memberKey = item.getAccountId() + "|" + item.getInboundId();
+            if (!groupByMember.containsKey(memberKey)) {
+                groupByMember.put(memberKey, group(item.getAccountId(), item.getInboundId()));
+            }
+            GroupSnapshot group = groupByMember.get(memberKey);
+            if (group != null) groups.putIfAbsent(group.groupId(), group);
+        }
+        Set<Long> groupsWithPickedItems = new HashSet<>();
+        for (LoadingPlanItemEntity item : items) {
+            if (picked.getOrDefault(item.getId(), 0) <= 0) continue;
+            GroupSnapshot group = groupByMember.get(item.getAccountId() + "|" + item.getInboundId());
+            if (group != null) groupsWithPickedItems.add(group.groupId());
+        }
+
+        List<LoadingPlanItemEntity> removable = items.stream().filter(item -> {
+            if (picked.getOrDefault(item.getId(), 0) > 0) return false;
+            GroupSnapshot group = groupByMember.get(item.getAccountId() + "|" + item.getInboundId());
+            return group == null || !groupsWithPickedItems.contains(group.groupId());
+        }).toList();
+        Set<Long> removableIds = removable.stream().map(LoadingPlanItemEntity::getId)
+            .collect(java.util.stream.Collectors.toSet());
+        Set<Long> removableGroupIds = groups.values().stream()
+            .filter(group -> !groupsWithPickedItems.contains(group.groupId()))
+            .filter(group -> items.stream().anyMatch(item -> removableIds.contains(item.getId())
+                && group.members().stream().anyMatch(member -> member.tenantId() == item.getAccountId()
+                    && member.inboundId() == item.getInboundId())))
+            .map(GroupSnapshot::groupId).collect(java.util.stream.Collectors.toCollection(LinkedHashSet::new));
+        for (Long groupId : removableGroupIds) {
+            requireCompleteGroupAllocation(planId, groups.get(groupId), items);
+        }
+
+        if (!removable.isEmpty()) {
+            touch(plan, operatorId, operatorName);
+            for (LoadingPlanItemEntity item : removable) {
+                loadingPickService.remove(item.getId());
+                if (repository.remove(planId, item.getId(), item.getVersion(), operatorId, operatorName) != 1) {
+                    throw conflict("装柜未拣明细已被并发修改");
+                }
+            }
+            Set<String> releasedInbounds = new HashSet<>();
+            for (LoadingPlanItemEntity item : removable) {
+                String key = item.getAccountId() + "|" + item.getInboundId();
+                if (releasedInbounds.add(key)) {
+                    loadingModelBridge.removeIfUnallocated(planId, item.getAccountId(), item.getInboundId());
+                }
+            }
+            for (Long groupId : removableGroupIds) {
+                GroupSnapshot group = groups.get(groupId);
+                coloadGroups.unlockWholeGroupAfterRemoval(groupId, planId,
+                    "UNLOCK-" + sha256(operation + '|' + groupId).substring(0, 48),
+                    operatorId, operatorName);
+            }
+        }
+        history(planId, null, "REMOVE_UNPICKED", plan.getPlanStatus(), plan.getPlanStatus(), operation,
+            json(values("version", request.expectedPlanVersion(), "itemCount", items.size())),
+            json(values("requestHash", requestHash, "removedItemCount", removable.size(),
+                "removedGroupCount", removableGroupIds.size())), operatorId, operatorName);
+        return view(repository.plan(planId), booking);
+    }
+
     private List<Candidate> enrichColoadCandidates(ContainerBookingEntity booking, LoadingPlanEntity plan,
                                                     List<Candidate> values) {
         Map<String, GroupSnapshot> snapshots = new HashMap<>();
@@ -1013,7 +1087,7 @@ public class SmartLoadingService {
         if (!"ACTIVE".equals(group.status()) || group.lockedPlanId() != null) {
             throw conflict("同柜不可拆组已锁定或已消费");
         }
-        List<Candidate> available = availableCandidates(booking);
+        List<Candidate> available = manualCandidates(booking);
         Map<Long, List<Candidate>> result = new LinkedHashMap<>();
         for (Member member : group.members()) {
             if (!repository.activeItemsByInbound(member.tenantId(), member.inboundId()).isEmpty()) {
@@ -1040,6 +1114,11 @@ public class SmartLoadingService {
             .filter(candidate -> sameChannel(booking, candidate) && sameCustomerScope(booking, candidate)).toList();
     }
 
+    private List<Candidate> manualCandidates(ContainerBookingEntity booking) {
+        return repository.candidates(booking.getWarehouseId()).stream()
+            .filter(candidate -> sameCustomerScope(booking, candidate)).toList();
+    }
+
     private boolean groupFits(ContainerBookingEntity booking, List<LoadingPlanItemEntity> planItems,
                               GroupSnapshot group, List<Candidate> available) {
         if (booking.getCapacityCbm() == null || booking.getMaxWeightKg() == null) return false;
@@ -1272,7 +1351,6 @@ public class SmartLoadingService {
     private record DeclaredCargo(OrderCargoClient.CargoBinding cargo) {}
     private void checkRouteAndCapacity(ContainerBookingEntity b,List<LoadingPlanItemEntity> lines,Candidate c,
                                        int count, boolean requireSameDestination){
-        requireSameChannel(b, c);
         if (!Objects.equals(b.getWarehouseId(), c.warehouseId())) throw validation("装柜仓库不一致");
         if (requireSameDestination && StringUtils.hasText(b.getDestinationWarehouseCode())
             && !Objects.equals(b.getDestinationWarehouseCode(), c.destinationWarehouseCode())) {
@@ -1376,12 +1454,6 @@ public class SmartLoadingService {
     private static boolean sameCustomerScope(ContainerBookingEntity booking, Candidate candidate) {
         return booking.getCustomerId() == null || Objects.equals(booking.getCustomerId(), candidate.accountId());
     }
-    private static void requireSameChannel(ContainerBookingEntity booking, Candidate candidate) {
-        if (!StringUtils.hasText(booking.getChannelCode()) || !StringUtils.hasText(candidate.channelCode())) {
-            throw validation("柜次或入库货物缺少渠道快照，请先完成存量数据回填");
-        }
-        if (!sameChannel(booking, candidate)) throw validation("禁止跨渠道混装");
-    }
     private static void requireSameCustomerScope(ContainerBookingEntity booking, Candidate candidate) {
         if (!sameCustomerScope(booking, candidate)) throw forbidden();
     }

firstleg/src/main/resources/openapi/firstleg-v1.yaml

@@ -466,7 +466,8 @@ paths:
       description: >-
         需要 platform:firstleg:smart-loading:list 权限。渠道目录只来自平台当前唯一 ACTIVE 价格版本中
         对该国内仓存在 ACTIVE 价格行的渠道；候选入仓码数、可用箱数及可编排柜次数由 Firstleg 当前事实聚合。
-        零候选或零可用柜次的有效渠道仍返回，Admin 可展示空态；实际分配仍由服务端重新校验仓库、渠道和资格。
+        零候选或零可用柜次的有效渠道仍返回，Admin 可展示空态。渠道只约束智能推荐；人工加入允许跨渠道，
+        仍由服务端重新校验国内仓、客户范围、占用、同柜组、箱数和容量资格。
       parameters:
         - {name: warehouseId, in: query, required: true, schema: {type: string, pattern: '^[1-9][0-9]*$'}}
       responses:
@@ -493,7 +494,7 @@ paths:
         LOADING 全部未完成状态，已完成装柜永不返回。状态映射为：Order SUBMITTED=PENDING_REVIEW；
         Firstleg WAIT_MEASURE/MEASURING/MEASURE_PENDING/MEASURE_REJECTED/WAIT_PRICING/FEE_CONFIRMING/INBOUNDING
         =WAIT_MEASURE；WAIT_SPLIT=WAIT_SPLIT；LOADING=LOADING。状态只用于搜索和展示，canAssign 由有效柜次占用、
-        剩余箱数、同柜组、仓库、渠道和容量等事实决定；容积和重量均允许达到柜型额定值的150%，超过即拒绝。
+        剩余箱数、同柜组、仓库和容量等事实决定；容积和重量均允许达到柜型额定值的150%，超过即拒绝。
         待审核及待测量可以先加入清单；确认预装/PDA 前
         仍必须完成审核与测量并进入 WAIT_SPLIT。同柜不可拆组仅在全部成员命中当前状态集合时作为一个分页单位返回。
       parameters:
@@ -597,7 +598,8 @@ paths:
       summary: 向预装计划新增入库单明细
       description: >-
         EDITING 或 LOADING 且 PDA task 尚未完成时可用。服务端按 planId 锁定同一 PDA task，
-        校验仓库、渠道、客户范围、可用箱数、容积和限重后原子新增/累加明细；LOADING 时同步到原 taskId，
+        校验仓库、客户范围、可用箱数、容积和限重后原子新增/累加明细；人工加入允许订单渠道与柜次渠道不同，
+        智能推荐仍只选择柜次渠道。LOADING 时同步到原 taskId，
         递增 planVersion、taskVersion，原 inventorySnapshotToken 随即失效。与 PDA batch/final complete 并发时，
         锁顺序为 PDA task 行锁 -> plan 乐观锁；仅先取得任务锁且持有匹配版本的一方成功，另一方返回 A0409。
         PDA 应重新 GET task detail 与 inventory snapshot，Admin 应重新 GET SmartLoadingPlan。新增项沿用原 taskId、
@@ -616,6 +618,7 @@ paths:
       description: >-
         需要 platform:firstleg:smart-loading:assign 权限。操作员只选择某个入仓码的本次计划箱数；
         服务端在单一事务内按剩余规格箱数比例生成内部规格快照，用于体积估算及兼容 PDA/拆单；
+        人工分配不限制订单渠道与柜次渠道一致，渠道只约束智能推荐；国内仓、占用、同柜组和容量门禁不变。
         柜内总容积和总重量分别允许达到柜型额定值的150%，超过即拒绝。
         只记录数量计划，具体实装箱号归属为 UNVERIFIED，不得将内部比例分摊宣称为现场箱号事实。
       parameters:
@@ -631,7 +634,8 @@ paths:
       description: >-
         需要 platform:firstleg:smart-loading:assign 权限。订单审核状态不作为清单占位门禁；服务端以
         customerId + orderId + inboundCode 重新核验 Order 权威待审核事实，幂等创建或复用 PREPARING
-        入仓投影，并按订单申报箱数、重量和体积建立柜次占位。已被其他有效柜次占用、仓库/渠道不一致、
+        入仓投影，并按订单申报箱数、重量和体积建立柜次占位。人工分配允许订单渠道与柜次渠道不同；
+        已被其他有效柜次占用、国内仓不一致、
         超容量或订单事实变化返回业务冲突且事务零漂移。清单中存在 PREPARING/WAIT_MEASURE 订单时不得
         确认预装或启动 PDA，审核测量完成并进入 WAIT_SPLIT 后才可继续物理装柜。
       parameters:
@@ -670,6 +674,20 @@ paths:
         content: {application/json: {schema: {$ref: '#/components/schemas/SmartLoadingDeleteRequest'}}}
       responses:
         '200': {description: 成功或业务失败，data 为最新 SmartLoadingPlan}
+  /api/platform/v1/first-leg/smart-loading/plans/{planId}/unpicked-items:
+    delete:
+      summary: 一次性移除当前计划全部未拣明细
+      description: >-
+        需要 platform:firstleg:smart-loading:delete 权限。单次请求、单事务锁定计划与 PDA task，移除全部
+        pickedPackageCount=0 的普通入仓码；同柜不可拆组只在组内所有明细均未拣时整组移除，任一成员已拣则整组保留。
+        planVersion 只递增一次；并发版本变化或任一步失败均整体回滚。同 operationId 重放返回既有结果。
+      parameters:
+        - {name: planId, in: path, required: true, schema: {type: string, pattern: '^[1-9][0-9]*$'}}
+      requestBody:
+        required: true
+        content: {application/json: {schema: {$ref: '#/components/schemas/SmartLoadingRemoveUnpickedRequest'}}}
+      responses:
+        '200': {description: 成功或业务失败，data 为最新 SmartLoadingPlan}
   /api/platform/v1/first-leg/smart-loading/plans/{planId}/items/{itemId}/warehouse-remark:
     patch:
       summary: 修改装柜明细仓库备注
@@ -1956,6 +1974,12 @@ components:
         expectedPlanVersion: {type: integer, minimum: 0}
         expectedItemVersion: {type: integer, minimum: 0}
         operationId: {type: string, minLength: 1, maxLength: 128}
+    SmartLoadingRemoveUnpickedRequest:
+      type: object
+      required: [expectedPlanVersion, operationId]
+      properties:
+        expectedPlanVersion: {type: integer, minimum: 0}
+        operationId: {type: string, minLength: 1, maxLength: 128}
     SmartLoadingWarehouseRemarkRequest:
       type: object
       required: [expectedPlanVersion, expectedItemVersion, operationId]

firstleg/src/test/java/com/baiyue/firstleg/controller/PlatformSmartLoadingControllerContractTest.java

@@ -56,6 +56,7 @@ class PlatformSmartLoadingControllerContractTest {
   authority("adjust","platform:firstleg:smart-loading:assign",AuthenticatedUser.class,long.class,long.class,AdjustRequest.class);
   authority("warehouseRemark","platform:firstleg:preload:edit",AuthenticatedUser.class,long.class,long.class,WarehouseRemarkRequest.class);
   authority("delete","platform:firstleg:smart-loading:delete",AuthenticatedUser.class,long.class,long.class,DeleteRequest.class);
+  authority("removeUnpicked","platform:firstleg:smart-loading:delete",AuthenticatedUser.class,long.class,RemoveUnpickedRequest.class);
  }
  @Test void openApiHasNoManualCreateOrPushStep() throws Exception {
   String yaml=java.nio.file.Files.readString(java.nio.file.Path.of("src/main/resources/openapi/firstleg-v1.yaml"));
@@ -75,6 +76,7 @@ class PlatformSmartLoadingControllerContractTest {
    .contains("SmartLoadingAssignRequest:")
    .contains("SmartLoadingAdjustRequest:")
    .contains("SmartLoadingDeleteRequest:")
+   .contains("SmartLoadingRemoveUnpickedRequest:")
    .contains("SmartLoadingWarehouseRemarkRequest:")
    .contains("/items/{itemId}/warehouse-remark:")
    .contains("需要 platform:firstleg:preload:edit 权限")
@@ -83,6 +85,8 @@ class PlatformSmartLoadingControllerContractTest {
    .contains("items[].version 是递增后的 itemVersion")
    .contains("数量调整或动态增量不会覆盖已有 warehouseRemark")
    .contains("柜内总容积和总重量分别允许达到柜型额定值的150%")
+   .contains("人工分配不限制订单渠道与柜次渠道一致")
+   .contains("渠道只约束智能推荐")
    .contains("canAssign: {type: boolean}")
    .contains("canEdit: {type: boolean}")
    .contains("pickedPackageCount: {type: integer, minimum: 0}")

firstleg/src/test/java/com/baiyue/firstleg/service/SmartLoadingServiceTest.java

@@ -332,16 +332,16 @@ class SmartLoadingServiceTest {
     }
 
     @Test
-    void assignsPendingReviewOrderAsAProvisionalContainerAllocation() {
+    void manuallyAssignsCrossChannelPendingReviewOrderAsAProvisionalContainerAllocation() {
         long customerId = 2092797167699816450L;
         long orderId = 2095052002489335810L;
         String inboundCode = "EXXHK2609020361";
         var pending = new PendingReviewOrderClient.Row(orderId, "FL-361", inboundCode,
-            customerId, "客户", 100L, "FBA", "FBA渠道", 5,
+            customerId, "客户", 100L, "SLOW", "慢船", 5,
             LocalDateTime.parse("2026-09-02T15:31:36"), "PENDING_REVIEW");
         var snapshot = new com.baiyue.firstleg.dto.OrderApprovedInboundCommand(
             customerId, orderId, "FL-361", inboundCode, customerId, "客户", 100L, "义乌仓",
-            null, null, null, "FIRST_LEG", "FBA", "FBA渠道", null, null, null,
+            null, null, null, "FIRST_LEG", "SLOW", "慢船", null, null, null,
             null, null, false, "FBA", 200L, "FBA1", "FBA仓", null, null, null, 5);
         var label = new OrderCargoClient.CargoLabelBinding(20L, orderId, 1, "货物", 5,
             null, null, null);
@@ -381,7 +381,7 @@ class SmartLoadingServiceTest {
     }
 
     @Test
-    void assignsWaitMeasureInboundUsingDeclaredFactsWithoutTreatingStatusAsAGate() {
+    void manuallyAssignsCrossChannelWaitMeasureInboundUsingDeclaredFacts() {
         long customerId = 9L;
         long inboundId = 10L;
         long orderId = 30L;
@@ -391,11 +391,11 @@ class SmartLoadingServiceTest {
         projection.setOrderId(orderId);
         projection.setInboundCode("I10");
         projection.setWarehouseId(100L);
-        projection.setChannelCode("FBA");
+        projection.setChannelCode("SLOW");
         projection.setProcessStatus("WAIT_MEASURE");
         var snapshot = new com.baiyue.firstleg.dto.OrderApprovedInboundCommand(
             customerId, orderId, "O30", "I10", customerId, "客户", 100L, "义乌仓",
-            null, null, null, "FIRST_LEG", "FBA", "FBA渠道", null, null, null,
+            null, null, null, "FIRST_LEG", "SLOW", "慢船", null, null, null,
             null, null, false, "FBA", 200L, "FBA1", "FBA仓", null, null, null, 5);
         var label = new OrderCargoClient.CargoLabelBinding(20L, orderId, 1, "货物", 5,
             null, null, null);
@@ -575,8 +575,8 @@ class SmartLoadingServiceTest {
 
     @Test
     void atomicallyAssignsEveryInboundFragmentOfSameOrderAcrossDifferentDestinations() {
-        Candidate first = candidate(9L, 10L, 20L, 30L, 4);
-        Candidate second = candidate(9L, 11L, 21L, 30L, 6, "FBA2");
+        Candidate first = withChannel(candidate(9L, 10L, 20L, 30L, 4), "SLOW", "慢船");
+        Candidate second = withChannel(candidate(9L, 11L, 21L, 30L, 6, "FBA2"), "SLOW", "慢船");
         GroupSnapshot active = group("ACTIVE", null,
             new Member(9L, 30L, 10L, "IN-10", 4), new Member(9L, 30L, 11L, "IN-11", 6));
         GroupSnapshot locked = group("LOCKED", 1L,
@@ -796,6 +796,94 @@ class SmartLoadingServiceTest {
             org.mockito.ArgumentMatchers.startsWith("UNLOCK-"), eq(7L), eq("u"));
     }
 
+    @Test
+    void removesAllUnpickedItemsWithOnePlanVersionChange() {
+        LoadingPlanEntity initial = plan("EDITING", 2);
+        LoadingPlanEntity after = plan("EDITING", 3);
+        LoadingPlanItemEntity first = item(8L, 9L, 20L, 4);
+        LoadingPlanItemEntity second = item(9L, 19L, 21L, 6);
+        second.setInboundId(11L);
+        when(repository.plan(1L)).thenReturn(initial, after);
+        when(repository.booking(99L)).thenReturn(booking());
+        when(repository.items(1L)).thenReturn(List.of(first, second), List.of());
+        when(repository.touch(1L, 2, 7L, "u")).thenReturn(1);
+        when(repository.remove(eq(1L), anyLong(), eq(0), eq(7L), eq("u"))).thenReturn(1);
+
+        Plan result = service.removeUnpicked(1L,
+            new com.baiyue.firstleg.dto.SmartLoadingDtos.RemoveUnpickedRequest(2, "remove-unpicked"),
+            7L, "u");
+
+        assertThat(result.items()).isEmpty();
+        verify(repository).touch(1L, 2, 7L, "u");
+        verify(repository, times(2)).remove(eq(1L), anyLong(), eq(0), eq(7L), eq("u"));
+        verify(loadingPickService, times(2)).remove(anyLong());
+    }
+
+    @Test
+    void bulkRemovalKeepsWholeGroupWhenAnyMemberWasPicked() {
+        LoadingPlanEntity initial = plan("LOADING", 2);
+        LoadingPlanEntity after = plan("LOADING", 3);
+        LoadingPlanItemEntity first = item(8L, 9L, 20L, 4);
+        LoadingPlanItemEntity second = item(9L, 19L, 21L, 6);
+        second.setInboundId(11L);
+        LoadingPlanItemEntity standalone = item(10L, 29L, 22L, 3);
+        standalone.setInboundId(12L);
+        GroupSnapshot group = group("LOCKED", 1L,
+            new Member(9L, 30L, 10L, "IN-10", 4), new Member(19L, 31L, 11L, "IN-11", 6));
+        when(repository.plan(1L)).thenReturn(initial, after);
+        when(repository.booking(99L)).thenReturn(booking());
+        when(repository.items(1L)).thenReturn(List.of(first, second, standalone), List.of(first, second));
+        when(repository.touch(1L, 2, 7L, "u")).thenReturn(1);
+        when(repository.remove(1L, 10L, 0, 7L, "u")).thenReturn(1);
+        when(coloadGroups.findByInbound(9L, 10L)).thenReturn(group);
+        when(coloadGroups.findByInbound(19L, 11L)).thenReturn(group);
+        when(loadingPickService.mutationSnapshot(1L)).thenReturn(
+            new LoadingPickService.MutationSnapshot(77L, "LOADING", 5, Map.of(8L, 1)));
+
+        Plan result = service.removeUnpicked(1L,
+            new com.baiyue.firstleg.dto.SmartLoadingDtos.RemoveUnpickedRequest(2, "keep-picked-group"),
+            7L, "u");
+
+        assertThat(result.items()).extracting(LoadingPlanItemEntity::getId).containsExactly(8L, 9L);
+        verify(repository).remove(1L, 10L, 0, 7L, "u");
+        verify(repository, never()).remove(eq(1L), eq(8L), anyInt(), anyLong(), anyString());
+        verify(repository, never()).remove(eq(1L), eq(9L), anyInt(), anyLong(), anyString());
+        verify(coloadGroups, never()).unlockWholeGroupAfterRemoval(anyLong(), anyLong(), anyString(), anyLong(), anyString());
+    }
+
+    @Test
+    void bulkRemovalRemovesAndUnlocksACompletelyUnpickedGroupOnce() {
+        LoadingPlanEntity initial = plan("EDITING", 2);
+        LoadingPlanEntity after = plan("EDITING", 3);
+        LoadingPlanItemEntity first = item(8L, 9L, 20L, 4);
+        LoadingPlanItemEntity second = item(9L, 19L, 21L, 6);
+        second.setInboundId(11L);
+        GroupSnapshot group = group("LOCKED", 1L,
+            new Member(9L, 30L, 10L, "IN-10", 4), new Member(19L, 31L, 11L, "IN-11", 6));
+        when(repository.plan(1L)).thenReturn(initial, after);
+        when(repository.booking(99L)).thenReturn(booking());
+        when(repository.items(1L)).thenReturn(List.of(first, second), List.of());
+        when(repository.activeItemsByInbound(9L, 10L)).thenReturn(List.of(first));
+        when(repository.activeItemsByInbound(19L, 11L)).thenReturn(List.of(second));
+        when(repository.touch(1L, 2, 7L, "u")).thenReturn(1);
+        when(repository.remove(eq(1L), anyLong(), eq(0), eq(7L), eq("u"))).thenReturn(1);
+        when(coloadGroups.findByInbound(9L, 10L)).thenReturn(group);
+        when(coloadGroups.findByInbound(19L, 11L)).thenReturn(group);
+        GroupSnapshot unlocked = group("ACTIVE", null,
+            new Member(9L, 30L, 10L, "IN-10", 4), new Member(19L, 31L, 11L, "IN-11", 6));
+        when(coloadGroups.unlockWholeGroupAfterRemoval(eq(700L), eq(1L), anyString(), eq(7L), eq("u")))
+            .thenReturn(unlocked);
+
+        Plan result = service.removeUnpicked(1L,
+            new com.baiyue.firstleg.dto.SmartLoadingDtos.RemoveUnpickedRequest(2, "remove-unpicked-group"),
+            7L, "u");
+
+        assertThat(result.items()).isEmpty();
+        verify(repository, times(2)).remove(eq(1L), anyLong(), eq(0), eq(7L), eq("u"));
+        verify(coloadGroups).unlockWholeGroupAfterRemoval(eq(700L), eq(1L),
+            org.mockito.ArgumentMatchers.startsWith("UNLOCK-"), eq(7L), eq("u"));
+    }
+
     @Test
     void proportionallyDistributesInboundQuantityWithoutLosingCartons() {
         Candidate first = new Candidate(9L, 10L, 20L, 30L, "O", "I", 100L,