test(appointments): require canonical dispatch calendar permission

# Conflicts:
#	lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/mapper/DispatchBolMapper.java

audit-service/AGENTS.md

@@ -2,8 +2,7 @@
 
 ## 数据库访问与中文注释约束
 
-- 强制遵守根 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则：正常业务访问统一为 `Controller → Service → Repository → Mapper`，不得省略 Repository 或跨层直调；生产 SQL 由 Mapper 执行，Repository 不得直接使用 JdbcTemplate 或原生 JDBC。非 HTTP 入口从 Service 进入；无数据库模块不引入数据库访问。
-- 每个手写方法及构造器须有简短中文说明；核心业务规则、复杂 SQL、事务、锁、幂等、并发及失败处理须补充适量中文注释，重点说明原因和边界。新增、修改方法立即执行，触及的存量代码同步整改。
+- 强制继承 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则；该节是分层、SQL 执行和方法/核心逻辑中文注释的唯一维护处，本模块不另设例外。
 
 ## 职责边界
 

auth/AGENTS.md

@@ -2,8 +2,7 @@
 
 ## 数据库访问与中文注释约束
 
-- 强制遵守根 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则：正常业务访问统一为 `Controller → Service → Repository → Mapper`，不得省略 Repository 或跨层直调；生产 SQL 由 Mapper 执行，Repository 不得直接使用 JdbcTemplate 或原生 JDBC。非 HTTP 入口从 Service 进入；无数据库模块不引入数据库访问。
-- 每个手写方法及构造器须有简短中文说明；核心业务规则、复杂 SQL、事务、锁、幂等、并发及失败处理须补充适量中文注释，重点说明原因和边界。新增、修改方法立即执行，触及的存量代码同步整改。
+- 强制继承 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则；该节是分层、SQL 执行和方法/核心逻辑中文注释的唯一维护处，本模块不另设例外。
 
 ## 职责与边界
 

common-audit/AGENTS.md

@@ -2,8 +2,7 @@
 
 ## 数据库访问与中文注释约束
 
-- 强制遵守根 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则：正常业务访问统一为 `Controller → Service → Repository → Mapper`，不得省略 Repository 或跨层直调；生产 SQL 由 Mapper 执行，Repository 不得直接使用 JdbcTemplate 或原生 JDBC。非 HTTP 入口从 Service 进入；无数据库模块不引入数据库访问。
-- 每个手写方法及构造器须有简短中文说明；核心业务规则、复杂 SQL、事务、锁、幂等、并发及失败处理须补充适量中文注释，重点说明原因和边界。新增、修改方法立即执行，触及的存量代码同步整改。
+- 强制继承 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则；该节是分层、SQL 执行和方法/核心逻辑中文注释的唯一维护处，本模块不另设例外。
 
 ## 职责边界
 

common-core/AGENTS.md

@@ -2,8 +2,7 @@
 
 ## 数据库访问与中文注释约束
 
-- 强制遵守根 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则：正常业务访问统一为 `Controller → Service → Repository → Mapper`，不得省略 Repository 或跨层直调；生产 SQL 由 Mapper 执行，Repository 不得直接使用 JdbcTemplate 或原生 JDBC。非 HTTP 入口从 Service 进入；无数据库模块不引入数据库访问。
-- 每个手写方法及构造器须有简短中文说明；核心业务规则、复杂 SQL、事务、锁、幂等、并发及失败处理须补充适量中文注释，重点说明原因和边界。新增、修改方法立即执行，触及的存量代码同步整改。
+- 强制继承 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则；该节是分层、SQL 执行和方法/核心逻辑中文注释的唯一维护处，本模块不另设例外。
 
 ## 职责边界
 

common-event-contract/AGENTS.md

@@ -2,8 +2,7 @@
 
 ## 数据库访问与中文注释约束
 
-- 强制遵守根 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则：正常业务访问统一为 `Controller → Service → Repository → Mapper`，不得省略 Repository 或跨层直调；生产 SQL 由 Mapper 执行，Repository 不得直接使用 JdbcTemplate 或原生 JDBC。非 HTTP 入口从 Service 进入；无数据库模块不引入数据库访问。
-- 每个手写方法及构造器须有简短中文说明；核心业务规则、复杂 SQL、事务、锁、幂等、并发及失败处理须补充适量中文注释，重点说明原因和边界。新增、修改方法立即执行，触及的存量代码同步整改。
+- 强制继承 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则；该节是分层、SQL 执行和方法/核心逻辑中文注释的唯一维护处，本模块不另设例外。
 
 ## 职责边界
 

common-openapi/AGENTS.md

@@ -2,8 +2,7 @@
 
 ## 数据库访问与中文注释约束
 
-- 强制遵守根 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则：正常业务访问统一为 `Controller → Service → Repository → Mapper`，不得省略 Repository 或跨层直调；生产 SQL 由 Mapper 执行，Repository 不得直接使用 JdbcTemplate 或原生 JDBC。非 HTTP 入口从 Service 进入；无数据库模块不引入数据库访问。
-- 每个手写方法及构造器须有简短中文说明；核心业务规则、复杂 SQL、事务、锁、幂等、并发及失败处理须补充适量中文注释，重点说明原因和边界。新增、修改方法立即执行，触及的存量代码同步整改。
+- 强制继承 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则；该节是分层、SQL 执行和方法/核心逻辑中文注释的唯一维护处，本模块不另设例外。
 
 ## 职责边界
 

common-security/AGENTS.md

@@ -2,8 +2,7 @@
 
 ## 数据库访问与中文注释约束
 
-- 强制遵守根 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则：正常业务访问统一为 `Controller → Service → Repository → Mapper`，不得省略 Repository 或跨层直调；生产 SQL 由 Mapper 执行，Repository 不得直接使用 JdbcTemplate 或原生 JDBC。非 HTTP 入口从 Service 进入；无数据库模块不引入数据库访问。
-- 每个手写方法及构造器须有简短中文说明；核心业务规则、复杂 SQL、事务、锁、幂等、并发及失败处理须补充适量中文注释，重点说明原因和边界。新增、修改方法立即执行，触及的存量代码同步整改。
+- 强制继承 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则；该节是分层、SQL 执行和方法/核心逻辑中文注释的唯一维护处，本模块不另设例外。
 
 ## 职责边界
 

common-web/AGENTS.md

@@ -2,8 +2,7 @@
 
 ## 数据库访问与中文注释约束
 
-- 强制遵守根 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则：正常业务访问统一为 `Controller → Service → Repository → Mapper`，不得省略 Repository 或跨层直调；生产 SQL 由 Mapper 执行，Repository 不得直接使用 JdbcTemplate 或原生 JDBC。非 HTTP 入口从 Service 进入；无数据库模块不引入数据库访问。
-- 每个手写方法及构造器须有简短中文说明；核心业务规则、复杂 SQL、事务、锁、幂等、并发及失败处理须补充适量中文注释，重点说明原因和边界。新增、修改方法立即执行，触及的存量代码同步整改。
+- 强制继承 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则；该节是分层、SQL 执行和方法/核心逻辑中文注释的唯一维护处，本模块不另设例外。
 
 ## 职责边界
 

deploy/sql/20261016-数据库变更汇总.md

@@ -10,7 +10,7 @@
 | warehouse-overseas-service | `baiyue_lastlag_warehouse` | 仅业务代码变化，无新增表或字段，无需 SQL；数据库名称保留正式的 lastlag 拼写 |
 | 其他服务 | 各服务原数据库 | 本次比较范围内无 SQL 结构新增，无需 SQL |
 
-已有尾程库使用：[V28 可重复执行 SQL](migrations/overseas/baiyue_lastleg/V28__merge_transfer_measurement_and_compact_numbers.sql)。文件显式指定 `USE baiyue_lastleg`，不访问其他服务数据库。
+已有尾程库使用：[V28 可重复执行 SQL](migrations/overseas/baiyue_lastleg/V28__merge_transfer_measurement_and_compact_numbers.sql)。由单 schema 执行器选定 `baiyue_lastleg`，文件内不切库，不访问其他服务数据库。2026-10-20 按尚未执行候选的边界移除内部切库语句，其余结构内容不变；本次未执行此候选。
 
 ## 新表与字段
 

deploy/sql/README.md

@@ -1,5 +1,7 @@
 # 单测试环境数据库空库初始化
 
+客户计费重独立确认新增 `fl_chargeable_weight_confirmation`，源表与国内空库基线同步；存量 TEST 使用 `migrations/cn/baiyue_firstleg/V8__chargeable_weight_confirmation.sql`，不回填费用确认。须随 Firstleg、Order、Lastleg、Admin 和 Client 匹配版本核对；本次未执行 SQL、未部署。
+
 费用项目默认价格结构：Firstleg 源基线 `phase2-fee-item-and-inbound-detail.sql` 与国内统一空库基线均增加可空的 `fl_fee_item.default_price DECIMAL(12,2)`。字段业务规则见工作区 `docs/入库测量与计费/README.md`；需与匹配的 Firstleg 和 Admin 一起发布。本次仅修改基线，不表示 SQL 已执行，也不能向已有测试库重放空库脚本。
 
 排车整车作业结构同步于 Lastleg 源基线及海外统一空库基线：整车主单移除客户头部，真实客户归属保留在货物、出库、派送和费用；新增公共命令账本、主单历史、派送安排及签收待汇总信号。空排车的计划时间可暂缺，提交审核前由业务校验补齐；`ll_dispatch_physical_pallet_lock` 独立保存无代表客户的实托排他占用，`ll_dispatch_pallet_lock.physical_lock_id` 关联逐客户逻辑来源，同车可共享、跨主单或草稿容器仍排他。`ll_dispatch_item` 按主单和完整来源键唯一，`ll_dispatch_item_source` 冻结换标明细的实际位置、绑定箱数、真实件数（未知为空）及原货源事实；拣货归属新增 `dispatch_item_source_id`，与实收、退回实收、原生退货箱三类凭据四者互斥，不伪造普通收货凭据。智能草稿按拥有者、起运仓和版本维护，一容器转换一整车；独立草稿命令保存原请求和结果。必须与匹配的 Lastleg、IAM、File、Admin 和 PDA 一起核对，空库脚本不能向已有 TEST 重放。本条仅说明代码基线，不表示 SQL 已执行、已部署或全流程已验收；唯一业务规则见工作区 `docs/海外仓业务/排车列表统一作业改造契约.md`。

deploy/sql/migrations/cn/baiyue_firstleg/V8__chargeable_weight_confirmation.sql

@@ -0,0 +1,15 @@
+-- 仅为已初始化的头程库新增独立确认历史；不回填费用确认，不修改订单事实。
+-- 由单 schema 执行器选择 baiyue_firstleg，不在迁移内部切库。
+-- 客户独立确认计费重，不回填既有费用确认。
+CREATE TABLE IF NOT EXISTS fl_chargeable_weight_confirmation (
+ id BIGINT NOT NULL COMMENT '确认记录ID',
+ tenant_id BIGINT NOT NULL COMMENT '客户隔离ID',
+ inbound_id BIGINT NOT NULL COMMENT '独立来源入仓单ID',
+ operator_id BIGINT NOT NULL COMMENT '确认客户成员ID',
+ command_key VARCHAR(128) NOT NULL COMMENT '成员确认幂等键',
+ fingerprint CHAR(64) NOT NULL COMMENT '计费重及测量轮次摘要',
+ chargeable_weight_kg DECIMAL(18,4) NOT NULL COMMENT '客户确认计费重千克',
+ confirmed_at DATETIME(3) NOT NULL COMMENT '客户确认时间',
+ PRIMARY KEY(id), UNIQUE KEY uk_weight_confirmation_command(tenant_id,operator_id,command_key),
+ KEY idx_weight_confirmation_inbound(tenant_id,inbound_id,id)
+) ENGINE=InnoDB COMMENT='客户计费重独立确认历史';

deploy/sql/migrations/overseas/baiyue_lastleg/V28__merge_transfer_measurement_and_compact_numbers.sql

@@ -2,7 +2,7 @@
 -- 目标：lastleg-service / baiyue_lastleg；前置：已有业务表及此前迁移。
 -- 只调整结构，不回填、删除或重算业务数据；执行失败应停止，修复后可重跑。
 SET NAMES utf8mb4;
-USE baiyue_lastleg;
+-- 由单 schema 执行器选择 baiyue_lastleg，不在迁移内部切库。
 
 CREATE TABLE IF NOT EXISTS ll_compact_number_clock (
   number_key VARCHAR(16) NOT NULL COMMENT '业务前缀和客户名称缩写',
@@ -11,7 +11,6 @@ CREATE TABLE IF NOT EXISTS ll_compact_number_clock (
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='海外业务短单号分配时钟';
 
 -- 仓储转运逐箱测量与清点；仅增加字段，不修改业务数据。
-USE baiyue_lastleg;
 SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_warehouse_transfer_carton' AND column_name='length_cm'), 'SELECT 1', 'ALTER TABLE ll_warehouse_transfer_carton ADD COLUMN length_cm DECIMAL(12,2) NULL COMMENT ''箱子实测长度厘米'''));
 PREPARE transfer_count_stmt FROM @ddl; EXECUTE transfer_count_stmt; DEALLOCATE PREPARE transfer_count_stmt;
 SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_warehouse_transfer_carton' AND column_name='width_cm'), 'SELECT 1', 'ALTER TABLE ll_warehouse_transfer_carton ADD COLUMN width_cm DECIMAL(12,2) NULL COMMENT ''箱子实测宽度厘米'''));
@@ -42,7 +41,6 @@ SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE tab
 PREPARE transfer_quantity_stmt FROM @ddl; EXECUTE transfer_quantity_stmt; DEALLOCATE PREPARE transfer_quantity_stmt;
 
 -- 仓储转运一箱多SKU清点；仅增加结构，不回填历史业务数据。
-USE baiyue_lastleg;
 SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_warehouse_transfer_carton' AND column_name='sku_items_json'), 'SELECT 1', 'ALTER TABLE ll_warehouse_transfer_carton ADD COLUMN sku_items_json JSON NULL COMMENT ''实收箱内SKU及逐项件数明细'''));
 PREPARE transfer_sku_stmt FROM @ddl; EXECUTE transfer_sku_stmt; DEALLOCATE PREPARE transfer_sku_stmt;
 

deploy/sql/migrations/overseas/baiyue_lastleg/V31__align_physical_pallet_guards.sql

@@ -0,0 +1,49 @@
+-- Region: OVERSEAS
+-- Schema: baiyue_lastleg
+-- Purpose: 排车物理托盘串行点、物理占用及逻辑占用关联结构补齐。
+-- Preconditions: MySQL 8；已选中目标schema；ll_dispatch_pallet_lock已有业务基线存在。
+-- Postconditions: 两张实托表和physical_lock_id列/idx_dispatch_logical_physical索引存在。
+-- 只增加缺失结构，不删除/回填/重算历史数据。重复执行已存在对象时跳过。
+-- 与当前lastleg.sql最终定义一致；已有异构对象须人工核对，不能以跳过证明一致。
+
+CREATE TABLE IF NOT EXISTS ll_physical_pallet_guard (
+  warehouse_pallet_id BIGINT NOT NULL COMMENT '真实全局物理托盘ID',
+  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '首次建立串行点时间',
+  PRIMARY KEY (warehouse_pallet_id)
+) ENGINE=InnoDB COMMENT='排车冻结与仓内实托组成修改的共同串行点';
+
+CREATE TABLE IF NOT EXISTS ll_dispatch_physical_pallet_lock (
+  id BIGINT NOT NULL COMMENT '物理实托占用主键',
+  warehouse_id VARCHAR(128) NOT NULL COMMENT '真实起运仓ID',
+  warehouse_pallet_id BIGINT NOT NULL COMMENT '全局真实物理托盘ID',
+  active_warehouse_pallet_id BIGINT NULL COMMENT '活动物理排他键，释放后为空',
+  dispatch_order_id BIGINT NULL COMMENT '正式排车主单ID，与草稿归属互斥',
+  draft_token VARCHAR(64) NULL COMMENT '草稿拥有者令牌，与正式排车归属互斥',
+  draft_container_id BIGINT NULL COMMENT '草稿内唯一占用该实托的容器ID',
+  operator_id VARCHAR(128) NULL COMMENT '占用操作人ID',
+  status VARCHAR(32) NOT NULL DEFAULT 'ACTIVE' COMMENT '物理占用状态',
+  expires_at DATETIME(3) NULL COMMENT '草稿失效时间，正式占用为空',
+  locked_at DATETIME(3) NOT NULL COMMENT '锁定时间',
+  released_at DATETIME(3) NULL COMMENT '释放时间',
+  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间',
+  updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT '更新时间',
+  PRIMARY KEY (id),
+  UNIQUE KEY uk_dispatch_physical_active_pallet (active_warehouse_pallet_id),
+  KEY idx_dispatch_physical_order (dispatch_order_id,status),
+  KEY idx_dispatch_physical_draft (draft_token,draft_container_id,status),
+  CONSTRAINT chk_dispatch_physical_active_key CHECK((status='ACTIVE' AND active_warehouse_pallet_id IS NOT NULL AND active_warehouse_pallet_id=warehouse_pallet_id) OR (status<>'ACTIVE' AND active_warehouse_pallet_id IS NULL)),
+  CONSTRAINT chk_dispatch_physical_owner CHECK((dispatch_order_id IS NOT NULL AND draft_token IS NULL AND draft_container_id IS NULL) OR (dispatch_order_id IS NULL AND draft_token IS NOT NULL AND draft_container_id IS NOT NULL))
+) ENGINE=InnoDB COMMENT='同车共享且跨车排他的物理实托占用';
+
+-- 已只读确认本地缺失：客户逻辑锁到物理锁的可空关联列及查询索引。
+-- 仅补结构，不根据历史单据推测或回填关联。
+SET @overseas_dimension_ddl = IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_dispatch_pallet_lock' AND column_name='physical_lock_id'), 'SELECT 1', 'ALTER TABLE ll_dispatch_pallet_lock ADD COLUMN physical_lock_id BIGINT NULL COMMENT ''实际物理实托占用ID，非物理来源为空''');
+PREPARE overseas_dimension_stmt FROM @overseas_dimension_ddl;
+EXECUTE overseas_dimension_stmt;
+DEALLOCATE PREPARE overseas_dimension_stmt;
+SET @overseas_dimension_ddl = IF(EXISTS (SELECT 1 FROM information_schema.statistics WHERE table_schema=DATABASE() AND table_name='ll_dispatch_pallet_lock' AND index_name='idx_dispatch_logical_physical'), 'SELECT 1', 'ALTER TABLE ll_dispatch_pallet_lock ADD KEY idx_dispatch_logical_physical (physical_lock_id,status)');
+PREPARE overseas_dimension_stmt FROM @overseas_dimension_ddl;
+EXECUTE overseas_dimension_stmt;
+DEALLOCATE PREPARE overseas_dimension_stmt;
+SET @overseas_dimension_ddl = NULL;
+

deploy/sql/头程数据库统一增量-MySQL8.sql

@@ -4437,6 +4437,20 @@ CREATE TABLE fl_inbound_split_item (
 
 SET SESSION foreign_key_checks = 1;
 
+-- 客户独立确认计费重，不回填既有费用确认。
+CREATE TABLE fl_chargeable_weight_confirmation (
+ id BIGINT NOT NULL COMMENT '确认记录ID',
+ tenant_id BIGINT NOT NULL COMMENT '客户隔离ID',
+ inbound_id BIGINT NOT NULL COMMENT '独立来源入仓单ID',
+ operator_id BIGINT NOT NULL COMMENT '确认客户成员ID',
+ command_key VARCHAR(128) NOT NULL COMMENT '成员确认幂等键',
+ fingerprint CHAR(64) NOT NULL COMMENT '计费重及测量轮次摘要',
+ chargeable_weight_kg DECIMAL(18,4) NOT NULL COMMENT '客户确认计费重千克',
+ confirmed_at DATETIME(3) NOT NULL COMMENT '客户确认时间',
+ PRIMARY KEY(id), UNIQUE KEY uk_weight_confirmation_command(tenant_id,operator_id,command_key),
+ KEY idx_weight_confirmation_inbound(tenant_id,inbound_id,id)
+) ENGINE=InnoDB COMMENT='客户计费重独立确认历史';
+
 -- 服务 schema：baiyue_file
 CREATE DATABASE IF NOT EXISTS baiyue_file DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
 USE baiyue_file;
@@ -8371,4 +8385,4 @@ INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at)
 INSERT INTO iam_permission (id, tenant_id, app_code, permission_type, parent_id, permission_code, permission_name, route_path, http_method, sort_no, status, built_in, created_at, updated_at, deleted) VALUES (5102213,0,'PLATFORM','BUTTON',5102200,'platform:firstleg:terminal-drayage:direct-unload:confirm','登记直送目的仓实际卸货',NULL,'POST',60,'ACTIVE',1,CURRENT_TIMESTAMP(3),CURRENT_TIMESTAMP(3),0);
 INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at) VALUES (4000001,5102213,0,CURRENT_TIMESTAMP(3));
 
-SELECT 'PASS' AS initialization_status, 'CN' AS region, 227 AS initialized_tables;
+SELECT 'PASS' AS initialization_status, 'CN' AS region, 228 AS initialized_tables;

file/AGENTS.md

@@ -2,8 +2,7 @@
 
 ## 数据库访问与中文注释约束
 
-- 强制遵守根 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则：正常业务访问统一为 `Controller → Service → Repository → Mapper`，不得省略 Repository 或跨层直调；生产 SQL 由 Mapper 执行，Repository 不得直接使用 JdbcTemplate 或原生 JDBC。非 HTTP 入口从 Service 进入；无数据库模块不引入数据库访问。
-- 每个手写方法及构造器须有简短中文说明；核心业务规则、复杂 SQL、事务、锁、幂等、并发及失败处理须补充适量中文注释，重点说明原因和边界。新增、修改方法立即执行，触及的存量代码同步整改。
+- 强制继承 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则；该节是分层、SQL 执行和方法/核心逻辑中文注释的唯一维护处，本模块不另设例外。
 
 ## 职责与边界
 

finance/AGENTS.md

@@ -2,8 +2,7 @@
 
 ## 数据库访问与中文注释约束
 
-- 强制遵守根 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则：正常业务访问统一为 `Controller → Service → Repository → Mapper`，不得省略 Repository 或跨层直调；生产 SQL 由 Mapper 执行，Repository 不得直接使用 JdbcTemplate 或原生 JDBC。非 HTTP 入口从 Service 进入；无数据库模块不引入数据库访问。
-- 每个手写方法及构造器须有简短中文说明；核心业务规则、复杂 SQL、事务、锁、幂等、并发及失败处理须补充适量中文注释，重点说明原因和边界。新增、修改方法立即执行，触及的存量代码同步整改。
+- 强制继承 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则；该节是分层、SQL 执行和方法/核心逻辑中文注释的唯一维护处，本模块不另设例外。
 
 ## 模块定位
 

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

@@ -157,6 +157,24 @@ public class InternalInboundOrderController {
         return ApiResponse.success(workbenchFilters.read(request));
     }
 
+    /** 当前页摘要继续应用原筛选，防止父子或分片入库投影错配。 */
+    @PostMapping("/unified-orders/status-summaries")
+    public ApiResponse<List<UnifiedInboundSummary>> unifiedStatusSummaries(
+        @RequestHeader(value = "X-Internal-Service-Token", required = false) String token,
+        @Valid @RequestBody UnifiedInboundQuery request) {
+        requireToken(token);
+        return ApiResponse.success(unifiedQueryService.statusSummaries(request));
+    }
+
+    /** 服务令牌保护的轻量状态投影，供 Order 统计和分页校正。 */
+    @PostMapping("/unified-orders/status-rows")
+    public ApiResponse<List<UnifiedInboundQueryService.StatusRow>> unifiedStatusRows(
+        @RequestHeader(value = "X-Internal-Service-Token", required = false) String token,
+        @Valid @RequestBody UnifiedInboundQuery request) {
+        requireToken(token);
+        return ApiResponse.success(unifiedQueryService.statusRows(request));
+    }
+
     @PostMapping("/unified-orders/query")
     public ApiResponse<PageResult<UnifiedInboundSummary>> unifiedPage(
         @RequestHeader(value = "X-Internal-Service-Token", required = false) String token,

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

@@ -140,7 +140,7 @@ public class PlatformContainerController {
     public ApiResponse<BusinessDocument> clearance(@AuthenticationPrincipal AuthenticatedUser user,
                                                     @PathVariable @Positive long id) {
         FirstlegScopeGuard.platform(user);
-        service.requireOverseas(id);
+        service.requireClearanceAccess(id);
         return ApiResponse.success(loadingLists.containerClearance(id));
     }
 
@@ -151,7 +151,7 @@ public class PlatformContainerController {
         @AuthenticationPrincipal AuthenticatedUser user, @PathVariable @Positive long id,
         @PathVariable @Positive long fileId) {
         FirstlegScopeGuard.platform(user);
-        service.requireOverseas(id);
+        service.requireClearanceAccess(id);
         var download = loadingLists.downloadContainerClearance(id, fileId);
         return ResponseEntity.ok().cacheControl(CacheControl.noStore())
             .header(HttpHeaders.CONTENT_DISPOSITION, org.springframework.http.ContentDisposition.attachment()
@@ -168,7 +168,7 @@ public class PlatformContainerController {
                                                           @RequestHeader("Idempotency-Key") String key,
                                                           @Valid @RequestBody DocumentAttachRequest request) {
         FirstlegScopeGuard.platform(user);
-        service.requireOverseas(id);
+        service.requireClearanceAccess(id);
         return ApiResponse.success(loadingLists.attachContainerClearance(
             id, user.userId(), user.username(), key, request));
     }
@@ -183,7 +183,7 @@ public class PlatformContainerController {
         @RequestParam("expectedVersion") @Min(0) int expectedVersion,
         @RequestParam(value = "operationReason", required = false) @Size(max = 500) String operationReason) {
         FirstlegScopeGuard.platform(user);
-        service.requireOverseas(id);
+        service.requireClearanceAccess(id);
         return ApiResponse.success(loadingLists.uploadContainerClearance(
             id, user.userId(), user.username(), key, expectedVersion, operationReason, file));
     }
@@ -196,7 +196,7 @@ public class PlatformContainerController {
                                                             @RequestHeader("Idempotency-Key") String key,
                                                             @Valid @RequestBody DocumentCompleteRequest request) {
         FirstlegScopeGuard.platform(user);
-        service.requireOverseas(id);
+        service.requireClearanceAccess(id);
         return ApiResponse.success(loadingLists.completeContainerClearance(
             id, user.userId(), user.username(), key, request));
     }

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

@@ -15,7 +15,7 @@ public record UnifiedInboundQuery(
     @Size(max = 64) String keyword,
     @Size(max = 64) String orderNo,
     @Schema(allowableValues = {"PENDING_REVIEW", "WAIT_MEASURE", "WAIT_PALLETIZE", "WAIT_SPLIT",
-        "LOADING", "LOADED", "DELIVERED"})
+        "LOADING", "LOADED", "DELIVERED", "WAIT_WEIGHT_CONFIRM", "WEIGHT_CONFIRMED", "WAIT_CUSTOMS_DOCS", "EXPORT_CUSTOMS", "SAILING_CLEARANCE", "WAIT_UNLOAD", "WAIT_DISPATCH", "OUTBOUND_DOCUMENT", "DELIVERING", "SIGNED", "MEASUREMENT_REVIEW"})
     @Size(max = 32) String mainStatus,
     Long customerId,
     Long receivingWarehouseId,

firstleg/src/main/java/com/baiyue/firstleg/mapper/ContainerBookingMapper.java

@@ -158,6 +158,14 @@ public interface ContainerBookingMapper extends BaseMapper<ContainerBookingEntit
         """)
     int hasActiveOutboundDeparture(@Param("id") long id);
 
+    /** 手动或拉取的实际开船节点均可作为清关资料入口依据。 */
+    @Select("""
+        SELECT COUNT(1) FROM fl_carrier_schedule_node_fact
+         WHERE container_booking_id=#{id} AND standard_node='DEPARTED_ORIGIN_PORT'
+           AND actual_at IS NOT NULL
+        """)
+    int hasActualVesselDeparture(@Param("id") long id);
+
     @Update("""
         UPDATE fl_container_booking SET pickup_code=#{pickupCode},pickup_code_updated_by=#{operatorId},
           pickup_code_updated_by_name=#{operatorName},pickup_code_updated_at=CURRENT_TIMESTAMP(3),

firstleg/src/main/java/com/baiyue/firstleg/repository/ContainerRepository.java

@@ -25,6 +25,8 @@ public class ContainerRepository {
     public ContainerBookingEntity findForUpdate(long id) { return mapper.selectBookingForUpdate(id); }
     public ContainerBookingEntity findActiveForUpdate(long id) { return mapper.selectActiveBookingForUpdate(id); }
     public boolean departed(long id) { return mapper.hasActiveOutboundDeparture(id) > 0; }
+    /** 读取本服务维护的实际开船事实，不依赖第三方查询任务是否建立。 */
+    public boolean sailed(long id) { return mapper.hasActualVesselDeparture(id) > 0; }
     public boolean containerNoExists(long oceanBookingId, String no, Long excludedId) {
         if (no == null) return false;
         return mapper.selectCount(new LambdaQueryWrapper<ContainerBookingEntity>()

firstleg/src/main/java/com/baiyue/firstleg/repository/InboundOrderRepository.java

@@ -114,9 +114,27 @@ public class InboundOrderRepository {
             .last("LIMIT 1"));
     }
 
-    /** Internal unified-query accessors. They always retain the tenant predicate when one is supplied. */
+    /** 统一订单列表按共享筛选分页。 */
     public Page<InboundOrderEntity> pageUnifiedEntities(UnifiedInboundQuery query, List<String> processStatuses) {
-        LambdaQueryWrapper<InboundOrderEntity> wrapper = new LambdaQueryWrapper<InboundOrderEntity>()
+        return orders.selectPage(new Page<>(query.page(), query.size()), unifiedFilter(query, processStatuses));
+    }
+
+    /** 只读取身份和流程状态，顺序与列表一致；空候选不能扩大查询范围。 */
+    public List<InboundOrderEntity> unifiedStatusEntities(UnifiedInboundQuery query) {
+        if (query.candidateOrderIds() != null && query.candidateOrderIds().isEmpty()) return List.of();
+        return orders.selectList(unifiedFilter(query, List.of()).select(InboundOrderEntity::getId,
+            InboundOrderEntity::getTenantId, InboundOrderEntity::getOrderId, InboundOrderEntity::getProcessStatus));
+    }
+
+    /** 当前页候选订单沿原筛选读取匹配的入库记录，避免读到另一条不匹配投影。 */
+    public List<InboundOrderEntity> unifiedMatchedEntities(UnifiedInboundQuery query, List<String> processStatuses) {
+        if (query.candidateOrderIds() == null || query.candidateOrderIds().isEmpty()) return List.of();
+        return orders.selectList(unifiedFilter(query, processStatuses));
+    }
+
+    /** 列表与统计共享客户隔离、费用、测量及船期等筛选语义。 */
+    private LambdaQueryWrapper<InboundOrderEntity> unifiedFilter(UnifiedInboundQuery query, List<String> processStatuses) {
+        return new LambdaQueryWrapper<InboundOrderEntity>()
             .eq(query.tenantId() != null, InboundOrderEntity::getTenantId, query.tenantId())
             .eq(query.taxMode() != null, InboundOrderEntity::getTaxMode, query.taxMode())
             .in(processStatuses != null && !processStatuses.isEmpty(), InboundOrderEntity::getProcessStatus, processStatuses)
@@ -187,7 +205,6 @@ public class InboundOrderRepository {
             .ge(query.createdFrom() != null, InboundOrderEntity::getCreatedAt, query.createdFrom())
             .le(query.createdTo() != null, InboundOrderEntity::getCreatedAt, query.createdTo())
             .orderByDesc(InboundOrderEntity::getCreatedAt).orderByDesc(InboundOrderEntity::getId);
-        return orders.selectPage(new Page<>(query.page(), query.size()), wrapper);
     }
 
     public List<InboundOrderEntity> findByOrderIds(Long tenantId, List<Long> orderIds) {

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

@@ -45,6 +45,13 @@ public class ContainerService {
         if (!repository.departed(id)) throw new BizException(ResultCode.NOT_FOUND, "国外工作台货柜不存在");
     }
 
+    /** 目的港清关资料允许已离仓或已实际开船货柜维护，不改写国内出仓事实。 */
+    public void requireClearanceAccess(long id) {
+        required(id);
+        if (!repository.departed(id) && !repository.sailed(id))
+            throw new BizException(ResultCode.NOT_FOUND, "货柜尚未离仓或实际开船，不能维护目的港清关资料");
+    }
+
     public void requireDomestic(long id) {
         required(id);
         if (repository.departed(id)) throw new BizException(ResultCode.NOT_FOUND, "国内工作台货柜不存在");

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

@@ -9,7 +9,9 @@ import org.springframework.stereotype.Service;
 public class MerchantWorkbenchFilterService {
     @Resource private MerchantWorkbenchFilterMapper mapper;
     @Resource private UnifiedInboundQueryService unified;
+    @Resource private com.baiyue.firstleg.workflow.ChargeableWeightService weights;
 
+    /** 精确详情只读进度；工作台待确认队列使用计费重事实，金额确认不能代替。 */
     @org.springframework.transaction.annotation.Transactional(readOnly=true)
     public MerchantWorkbenchFilters.Response read(MerchantWorkbenchFilters.Request request) {
         if (request.orderIds() != null) {
@@ -19,7 +21,7 @@ public class MerchantWorkbenchFilterService {
         return new MerchantWorkbenchFilters.Response(
             request.mainStatus() == null ? null : mapper.byProcessStatuses(request.tenantId(),
                 unified.internalStatuses(request.mainStatus())),
-            mapper.pendingFees(request.tenantId()), mapper.pendingCustoms(request.tenantId()),
+            weights.pendingOrders(request.tenantId()), mapper.pendingCustoms(request.tenantId()),
             progress(mapper.progressFragments(request.tenantId(), null)));
     }
 

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

@@ -36,6 +36,38 @@ public class UnifiedInboundQueryService {
     @Resource private FbaPricingRepository pricing;
     @Resource private UnifiedInboundReadRepository operations;
     @Resource private ObjectMapper json;
+    @Resource private com.baiyue.firstleg.workflow.WorkflowTabService workflowTabs;
+
+    /** 以稳定列表顺序返回去重履约状态，不触发逐票摘要及费用查询。 */
+    public List<StatusRow> statusRows(UnifiedInboundQuery query) {
+        validate(query);
+        Map<String, StatusRow> byOrder = new LinkedHashMap<>();
+        List<InboundOrderEntity> matched = inbounds.unifiedStatusEntities(query);
+        for (InboundOrderEntity inbound : matched) {
+            String status = mainStatus(inbound.getProcessStatus());
+            // 分片订单可同时命中不同履约页签；同一页签内每个订单只统计一次。
+            byOrder.putIfAbsent(inbound.getOrderId() + ":" + status, new StatusRow(inbound.getTenantId(),
+                inbound.getOrderId(), status));
+        }
+        workflowTabs.rows(matched).forEach(row -> byOrder.putIfAbsent(row.orderId() + ":" + row.mainStatus(), row));
+        return List.copyOf(byOrder.values());
+    }
+
+    /** 只对当前页最多200个订单读取匹配摘要，选取规则与状态投影一致。 */
+    public List<UnifiedInboundSummary> statusSummaries(UnifiedInboundQuery query) {
+        validate(query);
+        if (query.candidateOrderIds() == null || query.candidateOrderIds().size() > 200) {
+            throw new com.baiyue.common.core.exception.BizException(
+                com.baiyue.common.core.api.ResultCode.BAD_REQUEST, "状态摘要必须提供最多200个候选订单");
+        }
+        Map<Long, InboundOrderEntity> byOrder = new LinkedHashMap<>();
+        for (InboundOrderEntity inbound : inbounds.unifiedMatchedEntities(query, internalStatuses(query.mainStatus()))) {
+            byOrder.putIfAbsent(inbound.getOrderId(), inbound);
+        }
+        return summaries(List.copyOf(byOrder.values()));
+    }
+
+    public record StatusRow(Long tenantId, Long orderId, String mainStatus) {}
 
     public PageResult<UnifiedInboundSummary> page(UnifiedInboundQuery query) {
         validate(query);
@@ -43,11 +75,45 @@ public class UnifiedInboundQueryService {
             || query.candidateOrderIds() != null && query.candidateOrderIds().isEmpty()) {
             return new PageResult<>(List.of(), query.page(), query.size(), 0, 0);
         }
+        if (StringUtils.hasText(query.mainStatus())
+            && com.baiyue.firstleg.workflow.WorkflowTabService.KEYS.contains(query.mainStatus())) {
+            return workflowPage(query);
+        }
         Page<InboundOrderEntity> source = inbounds.pageUnifiedEntities(query, internalStatuses(query.mainStatus()));
         List<UnifiedInboundSummary> records = summaries(source.getRecords());
         return new PageResult<>(records, source.getCurrent(), source.getSize(), source.getTotal(), source.getPages());
     }
 
+    /** 独立事实页签先筛选完整来源再分页，内部查询也不能把业务页签解释成全部状态。 */
+    private PageResult<UnifiedInboundSummary> workflowPage(UnifiedInboundQuery query) {
+        List<InboundOrderEntity> matched = inbounds.unifiedStatusEntities(query);
+        Set<Long> matchingOrders = workflowTabs.rows(matched).stream()
+            .filter(row -> query.mainStatus().equals(row.mainStatus())).map(StatusRow::orderId)
+            .collect(Collectors.toSet());
+        Map<Long, InboundOrderEntity> unique = new LinkedHashMap<>();
+        // 轻量事实不能用于摘要，重新读取当前条件下的完整来源。
+        for (InboundOrderEntity inbound : inbounds.unifiedMatchedEntities(
+            withCandidates(query, matchingOrders.stream().toList()), List.of())) {
+            if (matchingOrders.contains(inbound.getOrderId())) unique.putIfAbsent(inbound.getOrderId(), inbound);
+        }
+        List<InboundOrderEntity> records = List.copyOf(unique.values());
+        long total = records.size();
+        long start = query.page() - 1 > Long.MAX_VALUE / query.size()
+            ? total : Math.min((query.page() - 1) * query.size(), total);
+        var current = records.subList((int) start, (int) Math.min(start + query.size(), total));
+        return new PageResult<>(summaries(current), query.page(), query.size(), total,
+            total / query.size() + (total % query.size() == 0 ? 0 : 1));
+    }
+
+    /** 保留全部过滤条件，只收窄为业务事实已命中的订单。 */
+    private UnifiedInboundQuery withCandidates(UnifiedInboundQuery q, List<Long> candidates) {
+        return new UnifiedInboundQuery(q.tenantId(), q.keyword(), q.orderNo(), q.mainStatus(), q.customerId(),
+            q.receivingWarehouseId(), q.destinationWarehouseId(), q.inboundCode(), q.internalOrderStatus(),
+            q.expectedArrivalDate(), q.feeReviewStatus(), q.channelName(), q.containerNo(), q.cabinetNo(),
+            q.sailingDate(), q.loaded(), q.fullContainer(), q.measurementReviewStatus(), candidates,
+            q.createdFrom(), q.createdTo(), q.page(), q.size(), q.taxMode());
+    }
+
     public List<UnifiedInboundSummary> summaries(Long tenantId, List<Long> orderIds) {
         Map<Long, UnifiedInboundSummary> byOrder = new LinkedHashMap<>();
         for (UnifiedInboundSummary item : summaries(inbounds.findByOrderIds(tenantId, orderIds)))
@@ -203,7 +269,7 @@ public class UnifiedInboundQueryService {
     }
 
     List<String> internalStatuses(String mainStatus) {
-        if (!StringUtils.hasText(mainStatus)) return List.of();
+        if (!StringUtils.hasText(mainStatus) || com.baiyue.firstleg.workflow.WorkflowTabService.KEYS.contains(mainStatus)) return List.of();
         return switch (mainStatus) {
             case "WAIT_MEASURE" -> List.of("WAIT_MEASURE", "MEASURING", "MEASURE_PENDING", "MEASURE_REJECTED",
                 "WAIT_PRICING", "FEE_CONFIRMING", "INBOUNDING");
@@ -231,6 +297,7 @@ public class UnifiedInboundQueryService {
         }
         if (StringUtils.hasText(query.mainStatus())
             && !MAIN_STATUSES.contains(query.mainStatus())
+            && !com.baiyue.firstleg.workflow.WorkflowTabService.KEYS.contains(query.mainStatus())
             ) {
             throw new com.baiyue.common.core.exception.BizException(
                 com.baiyue.common.core.api.ResultCode.BAD_REQUEST, "统一订单主状态不合法");

firstleg/src/main/java/com/baiyue/firstleg/workflow/ChargeableWeightService.java

@@ -0,0 +1,57 @@
+package com.baiyue.firstleg.workflow;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import com.baiyue.common.core.api.ResultCode;
+import com.baiyue.common.core.exception.BizException;
+import java.util.*;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.time.LocalDateTime;
+/** 客户独立确认计费重，金额确认和主流程不受影响。 */
+@Service
+public class ChargeableWeightService {
+ private final WorkflowFactRepository repository;
+ /** 注入当前事实和确认历史。 */
+ public ChargeableWeightService(WorkflowFactRepository repository) { this.repository=repository; }
+ /** 客户仅能读取本订单已审核的计费重。 */
+ public List<WorkflowFacts.Weight> read(long tenant,long orderId) {
+ return repository.facts(repository.orderInbounds(tenant,orderId)).stream().filter(f->f.tenantId()==tenant && eligible(f)).map(ChargeableWeightService::weight).toList();
+ }
+ /** 客户工作台按独立确认事实计算待办，不借用费用确认。 */
+ public List<Long> pendingOrders(long tenant) {
+ var ids=repository.weightCandidates(tenant);var orders=new LinkedHashSet<Long>();
+ for(int offset=0;offset<ids.size();offset+=500) for(var f:repository.facts(ids.subList(offset,Math.min(offset+500,ids.size()))))
+ if(f.tenantId()==tenant && eligible(f) && !weight(f).confirmed()) orders.add(f.orderId());
+ return List.copyOf(orders);
+ }
+ /** 值和测量轮次变化使旧确认失效，金额变化不影响计费重。 */
+ public static String fingerprint(WorkflowFacts.Fact f) {
+ try { String value=f.inboundId()+"|"+f.chargeableWeightKg().stripTrailingZeros().toPlainString()+"|"+f.measureCompletedAt();
+ return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(value.getBytes(StandardCharsets.UTF_8)));
+ } catch(java.security.NoSuchAlgorithmException e) { throw new IllegalStateException(e); }
+ }
+ /** 未审核或非正数不允许确认。 */
+ public static boolean eligible(WorkflowFacts.Fact f) { return "APPROVED".equals(f.reviewStatus()) && f.chargeableWeightKg()!=null && f.chargeableWeightKg().signum()>0; }
+ /** 只认可当前版本的确认。 */
+ public static WorkflowFacts.Weight weight(WorkflowFacts.Fact f) {
+ String hash=fingerprint(f);boolean confirmed=hash.equals(f.confirmationFingerprint());
+ return new WorkflowFacts.Weight(f.inboundId(),f.orderId(),f.chargeableWeightKg(),hash,confirmed,confirmed?f.confirmedAt():null);
+ }
+ /** 入仓锁、预期版本和幂等键防止确认旧值或异参重放。 */
+ @Transactional
+ public WorkflowFacts.Weight confirm(long tenant,long operator,long id,String key,WorkflowFacts.Confirm request) {
+ if(key==null || key.isBlank() || key.length()>128) throw new BizException(ResultCode.BAD_REQUEST,"确认幂等键不能为空且最多128字符");
+ var inbound=repository.lock(tenant,id);
+ if(inbound==null || "CANCELLED".equals(inbound.getProcessStatus())) throw new BizException(ResultCode.NOT_FOUND,"入仓单不存在");
+ var replay=repository.command(tenant,operator,key);
+ if(replay!=null && (replay.inboundId()!=id || !replay.fingerprint().equals(request.expectedFingerprint()))) throw new BizException(ResultCode.CONFLICT,"同一幂等键不能确认不同计费重");
+ var facts=repository.facts(List.of(id));
+ if(facts.isEmpty()) throw new BizException(ResultCode.CONFLICT,"请分别确认分柜后的独立订单计费重");
+ var f=facts.get(0);
+ if(!eligible(f)) throw new BizException(ResultCode.CONFLICT,"计费重尚未审核通过");
+ var current=weight(f);
+ if(!current.fingerprint().equals(request.expectedFingerprint())) throw new BizException(ResultCode.CONFLICT,"计费重已变化，请刷新后重新确认");
+ if(replay==null) repository.insert(new WorkflowFacts.Confirmation(com.baomidou.mybatisplus.core.toolkit.IdWorker.getId(),tenant,id,operator,key,current.fingerprint(),current.chargeableWeightKg(),LocalDateTime.now()));
+ return weight(repository.facts(List.of(id)).get(0));
+ }
+}

firstleg/src/main/java/com/baiyue/firstleg/workflow/LastlegWorkflowClient.java

@@ -0,0 +1,12 @@
+package com.baiyue.firstleg.workflow;
+import com.baiyue.common.core.api.ApiResponse;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.*;
+import java.util.List;
+/** 经内部接口读取尾程，禁止跨库查询。 */
+@FeignClient(name="lastleg-service",contextId="firstlegWorkflowFacts",url="${LASTLEG_SERVICE_URL:${baiyue.clients.lastleg.url:}}")
+public interface LastlegWorkflowClient {
+ /** 最多500个精确来源，不转发客户JWT。 */
+ @PostMapping("/internal/lastleg/v1/order-workflow-facts")
+ ApiResponse<List<WorkflowFacts.Overseas>> read(@RequestHeader("X-Internal-Service-Token") String token,@RequestBody WorkflowFacts.Request request);
+}

firstleg/src/main/java/com/baiyue/firstleg/workflow/MerchantChargeableWeightController.java

@@ -0,0 +1,26 @@
+package com.baiyue.firstleg.workflow;
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.common.security.AuthenticatedUser;
+import com.baiyue.firstleg.service.FirstlegScopeGuard;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import jakarta.validation.Valid;
+import java.util.List;
+/** 客户计费重确认入口，独立于费用确认。 */
+@RestController
+@RequestMapping("/api/merchant/v1/first-leg")
+public class MerchantChargeableWeightController {
+ private final ChargeableWeightService service;
+ /** 注入独立确认服务。 */
+ public MerchantChargeableWeightController(ChargeableWeightService service) { this.service=service; }
+ /** 客户范围取认证上下文。 */
+ @GetMapping("/orders/{orderId}/chargeable-weights")
+ @PreAuthorize("hasAuthority('merchant:order:view')")
+ public ApiResponse<List<WorkflowFacts.Weight>> read(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable long orderId) { return ApiResponse.success(service.read(FirstlegScopeGuard.merchant(user),orderId)); }
+ /** 不触发费用确认与金额锁定。 */
+ @com.baiyue.common.audit.BusinessAudit(event="CUSTOMER_CHARGEABLE_WEIGHT_CONFIRM",resourceType="INBOUND_ORDER",resourceId="#inboundId",description="客户独立确认计费重")
+ @PostMapping("/chargeable-weights/{inboundId}/confirm")
+ @PreAuthorize("hasAuthority('merchant:order:edit')")
+ public ApiResponse<WorkflowFacts.Weight> confirm(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable long inboundId,@RequestHeader("Idempotency-Key") String key,@Valid @RequestBody WorkflowFacts.Confirm request) { return ApiResponse.success(service.confirm(FirstlegScopeGuard.merchant(user),user.userId(),inboundId,key,request)); }
+}

firstleg/src/main/java/com/baiyue/firstleg/workflow/WorkflowFactMapper.java

@@ -0,0 +1,41 @@
+package com.baiyue.firstleg.workflow;
+import org.apache.ibatis.annotations.*;
+import java.util.List;
+/** 柜事实和独立确认SQL入口。 */
+@Mapper
+public interface WorkflowFactMapper {
+ String ACTUAL="""
+ FROM fl_loading_plan_item li JOIN fl_loading_plan p ON p.id=li.loading_plan_id AND p.plan_status='COMPLETED'
+ JOIN fl_loading_pick_task t ON t.loading_plan_id=p.id AND t.task_status='COMPLETED'
+ JOIN fl_loading_pick_item pk ON pk.pick_task_id=t.id AND pk.loading_plan_item_id=li.id
+ JOIN fl_container_booking b ON b.id=p.container_booking_id AND b.record_status='ACTIVE'
+ WHERE li.inbound_id=i.id AND li.account_id=i.tenant_id AND li.deleted=0
+ AND pk.item_status IN ('PICKED','PARTIAL') AND pk.picked_package_count>0
+ """;
+ /** 按独立实装票核验资料；来源单承接实装时，余量子单不能将来源票排除。 */
+ @Select("<script>SELECT i.tenant_id,i.id inbound_id,i.order_id,i.measure_review_status review_status,i.chargeable_weight_kg,i.measure_completed_at,"
+ +"EXISTS(SELECT 1 "+ACTUAL+" AND EXISTS(SELECT 1 FROM fl_carrier_schedule_node_fact n WHERE n.container_booking_id=b.id AND n.standard_node='DEPARTED_ORIGIN_PORT' AND n.actual_at IS NOT NULL)) departed,"
+ +"EXISTS(SELECT 1 "+ACTUAL+" AND EXISTS(SELECT 1 FROM fl_container_document d WHERE d.container_booking_id=b.id AND d.document_type='DESTINATION_CLEARANCE' AND d.file_id IS NOT NULL)) clearance_uploaded,"
+ +"EXISTS(SELECT 1 "+ACTUAL+" AND i.tax_mode='TAX_REFUND' AND NOT EXISTS(SELECT 1 FROM fl_customs_customer_document_inbound s JOIN fl_customs_customer_document d ON d.id=s.document_id AND d.tenant_id=i.tenant_id AND d.status='ACTIVE' JOIN fl_customs_container c ON c.id=d.customs_container_id AND c.loading_plan_id=p.id WHERE s.inbound_id=i.id AND s.tenant_id=i.tenant_id)) missing_customs,"
+ +"EXISTS(SELECT 1 "+ACTUAL+" AND (i.tax_mode='BUY_DECLARATION' OR EXISTS(SELECT 1 FROM fl_customs_customer_document_inbound s JOIN fl_customs_customer_document d ON d.id=s.document_id AND d.tenant_id=i.tenant_id AND d.status='ACTIVE' JOIN fl_customs_container c ON c.id=d.customs_container_id AND c.loading_plan_id=p.id WHERE s.inbound_id=i.id AND s.tenant_id=i.tenant_id))) export_customs_ready,"
+ +"(SELECT w.fingerprint FROM fl_chargeable_weight_confirmation w WHERE w.tenant_id=i.tenant_id AND w.inbound_id=i.id ORDER BY w.id DESC LIMIT 1) confirmation_fingerprint,"
+ +"(SELECT w.confirmed_at FROM fl_chargeable_weight_confirmation w WHERE w.tenant_id=i.tenant_id AND w.inbound_id=i.id ORDER BY w.id DESC LIMIT 1) confirmed_at "
+ +"FROM fl_inbound_order i WHERE i.deleted=0 AND NOT EXISTS(SELECT 1 FROM fl_inbound_order child WHERE child.tenant_id=i.tenant_id AND child.parent_inbound_id=i.id AND child.inbound_role='CHILD' AND (child.split_purpose IS NULL OR child.split_purpose != 'REMAINDER') AND child.deleted=0) AND i.process_status != 'CANCELLED' AND i.id IN "
+ +"<foreach collection='ids' item='id' open='(' separator=',' close=')'>#{id}</foreach></script>")
+ List<WorkflowFacts.Fact> facts(@Param("ids") List<Long> ids);
+ /** 锁定客户自己的入仓单，串行确认与测量写入。 */
+ @Select("SELECT * FROM fl_inbound_order WHERE tenant_id=#{tenantId} AND id=#{id} AND deleted=0 FOR UPDATE")
+ com.baiyue.firstleg.entity.InboundOrderEntity lock(@Param("tenantId") long tenantId,@Param("id") long id);
+ /** 客户订单下全部独立入仓单。 */
+ @Select("SELECT id FROM fl_inbound_order WHERE tenant_id=#{tenantId} AND order_id=#{orderId} AND deleted=0 AND process_status != 'CANCELLED' ORDER BY id")
+ List<Long> orderInbounds(@Param("tenantId") long tenantId,@Param("orderId") long orderId);
+ /** 客户工作台只读取审核通过且有正计费重的来源。 */
+ @Select("SELECT id FROM fl_inbound_order WHERE tenant_id=#{tenantId} AND deleted=0 AND process_status != 'CANCELLED' AND measure_review_status='APPROVED' AND chargeable_weight_kg>0 ORDER BY id")
+ List<Long> weightCandidates(@Param("tenantId") long tenantId);
+ /** 成员幂等键不允许跨确认对象复用。 */
+ @Select("SELECT * FROM fl_chargeable_weight_confirmation WHERE tenant_id=#{tenantId} AND operator_id=#{operatorId} AND command_key=#{key}")
+ WorkflowFacts.Confirmation command(@Param("tenantId") long tenantId,@Param("operatorId") long operatorId,@Param("key") String key);
+ /** 独立记录，不修改费用或物流主状态。 */
+ @Insert("INSERT INTO fl_chargeable_weight_confirmation(id,tenant_id,inbound_id,operator_id,command_key,fingerprint,chargeable_weight_kg,confirmed_at) VALUES(#{id},#{tenantId},#{inboundId},#{operatorId},#{commandKey},#{fingerprint},#{chargeableWeightKg},#{confirmedAt})")
+ int insert(WorkflowFacts.Confirmation value);
+}

firstleg/src/main/java/com/baiyue/firstleg/workflow/WorkflowFactRepository.java

@@ -0,0 +1,22 @@
+package com.baiyue.firstleg.workflow;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+/** 本地柜事实与确认记录的持久化入口。 */
+@Repository
+public class WorkflowFactRepository {
+ private final WorkflowFactMapper mapper;
+ /** 注入SQL提供者。 */
+ public WorkflowFactRepository(WorkflowFactMapper mapper) { this.mapper=mapper; }
+ /** 空候选不读取数据。 */
+ public List<WorkflowFacts.Fact> facts(List<Long> ids) { return ids.isEmpty()?List.of():mapper.facts(ids); }
+ /** 锁定所属客户来源。 */
+ public com.baiyue.firstleg.entity.InboundOrderEntity lock(long tenant,long id) { return mapper.lock(tenant,id); }
+ /** 查询订单下独立来源。 */
+ public List<Long> orderInbounds(long tenant,long order) { return mapper.orderInbounds(tenant,order); }
+ /** 客户计费重待确认候选。 */
+ public List<Long> weightCandidates(long tenant) { return mapper.weightCandidates(tenant); }
+ /** 读取成员确认命令。 */
+ public WorkflowFacts.Confirmation command(long tenant,long operator,String key) { return mapper.command(tenant,operator,key); }
+ /** 追加确认历史。 */
+ public void insert(WorkflowFacts.Confirmation value) { mapper.insert(value); }
+}

firstleg/src/main/java/com/baiyue/firstleg/workflow/WorkflowFacts.java

@@ -0,0 +1,17 @@
+package com.baiyue.firstleg.workflow;
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.List;
+/** 页签事实与独立计费重确认契约。 */
+public final class WorkflowFacts {
+ /** 仅承载查询及确认契约，不允许实例化。 */
+ private WorkflowFacts() {}
+ public record Fact(long tenantId,long inboundId,long orderId,String reviewStatus,BigDecimal chargeableWeightKg,LocalDateTime measureCompletedAt,
+ boolean departed,boolean clearanceUploaded,boolean missingCustoms,boolean exportCustomsReady,String confirmationFingerprint,LocalDateTime confirmedAt) {}
+ public record Source(long tenantId,long inboundId) {}
+ public record Request(List<Source> sources) {}
+ public record Overseas(long tenantId,long inboundId,boolean outboundExists,boolean pendingOutbound,boolean delivering,boolean unloaded) {}
+ public record Weight(long inboundId,long orderId,BigDecimal chargeableWeightKg,String fingerprint,boolean confirmed,LocalDateTime confirmedAt) {}
+ public record Confirm(@jakarta.validation.constraints.Pattern(regexp="[a-f0-9]{64}") @jakarta.validation.constraints.NotNull String expectedFingerprint) {}
+ public record Confirmation(long id,long tenantId,long inboundId,long operatorId,String commandKey,String fingerprint,BigDecimal chargeableWeightKg,LocalDateTime confirmedAt) {}
+}

firstleg/src/main/java/com/baiyue/firstleg/workflow/WorkflowTabService.java

@@ -0,0 +1,75 @@
+package com.baiyue.firstleg.workflow;
+import org.springframework.stereotype.Service;
+import org.springframework.beans.factory.annotation.Value;
+import com.baiyue.firstleg.entity.InboundOrderEntity;
+import com.baiyue.firstleg.service.UnifiedInboundQueryService.StatusRow;
+import com.baiyue.common.core.api.ResultCode;
+import com.baiyue.common.core.exception.BizException;
+import java.util.*;
+/** 将已确认的独立业务维度映射为页签，不改物流主状态。 */
+@Service
+public class WorkflowTabService {
+ public static final Set<String> KEYS=Set.of("WAIT_WEIGHT_CONFIRM","WEIGHT_CONFIRMED","WAIT_CUSTOMS_DOCS","EXPORT_CUSTOMS","SAILING_CLEARANCE","WAIT_UNLOAD","WAIT_DISPATCH","OUTBOUND_DOCUMENT","DELIVERING","SIGNED","MEASUREMENT_REVIEW");
+ private final WorkflowFactRepository repository;
+ private final LastlegWorkflowClient lastleg;
+ @Value("${baiyue.security.internal-service-token}") private String token;
+ /** 注入本地事实与尾程内部契约。 */
+ public WorkflowTabService(WorkflowFactRepository repository,LastlegWorkflowClient lastleg) { this.repository=repository;this.lastleg=lastleg; }
+ /** 分批取事实，失败整体关闭，不能把服务异常伪装成零。 */
+ public List<StatusRow> rows(List<InboundOrderEntity> inbounds) {
+ var result=new LinkedHashMap<String,StatusRow>();
+ for(int offset=0;offset<inbounds.size();offset+=500) {
+ var batch=inbounds.subList(offset,Math.min(offset+500,inbounds.size()));
+ var expected=new HashMap<Long,InboundOrderEntity>();batch.forEach(i->expected.put(i.getId(),i));
+ var facts=repository.facts(batch.stream().map(InboundOrderEntity::getId).toList());
+ var sources=facts.stream().filter(WorkflowFacts.Fact::departed).map(f->new WorkflowFacts.Source(f.tenantId(),f.inboundId())).distinct().toList();
+ Map<String,WorkflowFacts.Overseas> overseas=new HashMap<>();
+ if(!sources.isEmpty()) {
+ try {
+ var response=lastleg.read(token,new WorkflowFacts.Request(sources));
+ if(response==null || !response.successful() || response.data()==null) throw unavailable();
+ var allowed=new HashSet<>(sources);
+ for(var fact:response.data()) {
+ if(fact==null || !allowed.contains(new WorkflowFacts.Source(fact.tenantId(),fact.inboundId()))) throw unavailable();
+ overseas.merge(fact.tenantId()+":"+fact.inboundId(),fact,(a,b)->new WorkflowFacts.Overseas(a.tenantId(),a.inboundId(),a.outboundExists()||b.outboundExists(),a.pendingOutbound()||b.pendingOutbound(),a.delivering()||b.delivering(),a.unloaded()&&b.unloaded()));
+ }
+ if(overseas.size()!=sources.size()) throw unavailable();
+ } catch(BizException e) { throw e; } catch(Exception e) { throw unavailable(); }
+ }
+ // SQL排除仅作汇总的父票；保留承接实际装柜数量的来源票及独立余量票。
+ for(var fact:facts) {
+ var inbound=expected.get(fact.inboundId());
+ if(inbound==null || !Objects.equals(inbound.getTenantId(),fact.tenantId()) || !Objects.equals(inbound.getOrderId(),fact.orderId())) throw unavailable();
+ var o=overseas.get(fact.tenantId()+":"+fact.inboundId());
+ for(String key:classify(fact,inbound.getProcessStatus(),o)) result.putIfAbsent(fact.orderId()+":"+key,new StatusRow(fact.tenantId(),fact.orderId(),key));
+ }
+ }
+ return List.copyOf(result.values());
+ }
+ /** 分类为可重叠的待办/证据集合，计费重确认独立于费用确认。 */
+ public static Set<String> classify(WorkflowFacts.Fact f,String process,WorkflowFacts.Overseas o) {
+ Set<String> keys=new LinkedHashSet<>();
+ if("MEASURE_PENDING".equals(process) && "PENDING".equals(f.reviewStatus())) keys.add("MEASUREMENT_REVIEW");
+ if(ChargeableWeightService.eligible(f)) keys.add(ChargeableWeightService.weight(f).confirmed()?"WEIGHT_CONFIRMED":"WAIT_WEIGHT_CONFIRM");
+ boolean signed="DELIVERED".equals(process);
+ // 报关页签按资料与实装事实汇总，不依赖点击开始报关；实际开船后转入清关链路。
+ if(!f.departed() && !signed) {
+ if(f.missingCustoms()) keys.add("WAIT_CUSTOMS_DOCS");
+ if(f.exportCustomsReady()) keys.add("EXPORT_CUSTOMS");
+ }
+ if(signed) keys.add("SIGNED");
+ if(f.departed() && !signed) {
+ if(!f.clearanceUploaded()) keys.add("SAILING_CLEARANCE");
+ if(o!=null) {
+ if(f.clearanceUploaded() && !o.unloaded()) keys.add("WAIT_UNLOAD");
+ // 取消的出库不构成有效覆盖，读取事实后自动回显，不能保存永久隐藏标志。
+ if(!o.outboundExists()) keys.add("WAIT_DISPATCH");
+ if(o.pendingOutbound()) keys.add("OUTBOUND_DOCUMENT");
+ if(o.delivering()) keys.add("DELIVERING");
+ }
+ }
+ return keys;
+ }
+ /** 下游缺失或归属异常不能生成部分数量。 */
+ private static BizException unavailable() { return new BizException(ResultCode.SERVICE_UNAVAILABLE,"订单业务页签事实暂不可用，请稍后重试"); }
+}

firstleg/src/main/resources/db/chargeable-weight-confirmation.sql

@@ -0,0 +1,13 @@
+-- 客户独立确认计费重，不回填既有费用确认。
+CREATE TABLE IF NOT EXISTS fl_chargeable_weight_confirmation (
+ id BIGINT NOT NULL COMMENT '确认记录ID',
+ tenant_id BIGINT NOT NULL COMMENT '客户隔离ID',
+ inbound_id BIGINT NOT NULL COMMENT '独立来源入仓单ID',
+ operator_id BIGINT NOT NULL COMMENT '确认客户成员ID',
+ command_key VARCHAR(128) NOT NULL COMMENT '成员确认幂等键',
+ fingerprint CHAR(64) NOT NULL COMMENT '计费重及测量轮次摘要',
+ chargeable_weight_kg DECIMAL(18,4) NOT NULL COMMENT '客户确认计费重千克',
+ confirmed_at DATETIME(3) NOT NULL COMMENT '客户确认时间',
+ PRIMARY KEY(id), UNIQUE KEY uk_weight_confirmation_command(tenant_id,operator_id,command_key),
+ KEY idx_weight_confirmation_inbound(tenant_id,inbound_id,id)
+) ENGINE=InnoDB COMMENT='客户计费重独立确认历史';

firstleg/src/main/resources/db/phase3-channel-container-migration.sql

@@ -134,8 +134,11 @@ BEGIN
      OR NOT (NEW.cabinet_no <=> OLD.cabinet_no) THEN
     SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'PDA拣货任务稳定归属不可修改';
   END IF;
-  IF NOT (OLD.task_status = 'LOADING' AND NEW.task_status IN ('LOADING', 'COMPLETED')) THEN
-    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'PDA拣货任务状态只允许完成';
+  -- 与装柜主基线一致，允许持久化完成命令的处理中、失败重试及最终完成。
+  IF NOT ((OLD.task_status = 'LOADING' AND NEW.task_status IN ('LOADING','COMPLETING'))
+       OR (OLD.task_status = 'COMPLETING' AND NEW.task_status IN ('COMPLETING','COMPLETION_FAILED','COMPLETED'))
+       OR (OLD.task_status = 'COMPLETION_FAILED' AND NEW.task_status = 'COMPLETING')) THEN
+    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'PDA拣货任务状态流转非法';
   END IF;
 END$$
 DELIMITER ;

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

@@ -355,7 +355,7 @@ paths:
   /internal/firstleg/v1/inbounds/unified-orders/workbench-filters:
     post:
       summary: 查询单一客户工作台履约筛选标识（Order内部）
-      description: 只读返回命中状态、最新待确认费用及待上传资料的订单标识。客户必须明确且为正数；不创建报关聚合，不跨Schema读取。传入orderIds为精确进度模式，仅计算progress，matchingStatusOrderIds为null，feeOrderIds和customsOrderIds为空；mainStatus在该模式不参与查询。
+      description: 只读返回命中状态、待独立确认计费重及待上传报关资料的订单标识。feeOrderIds沿用既有字段名，值为尚未确认当前计费重的订单，不代表金额确认。客户必须明确且为正数；不创建报关聚合，不跨Schema读取。传入orderIds为精确进度模式，仅计算progress，matchingStatusOrderIds为null，feeOrderIds和customsOrderIds为空；mainStatus在该模式不参与查询。
       security: [{internalServiceToken: []}]
       requestBody:
         required: true
@@ -366,7 +366,7 @@ paths:
               required: [tenantId]
               properties:
                 tenantId: {type: integer, format: int64, minimum: 1}
-                mainStatus: {type: string, nullable: true, enum: [WAIT_MEASURE, WAIT_PALLETIZE, WAIT_SPLIT, LOADING, LOADED, DELIVERED]}
+                mainStatus: {type: string, nullable: true, enum: [WAIT_MEASURE, WAIT_PALLETIZE, WAIT_SPLIT, LOADING, LOADED, DELIVERED, WAIT_WEIGHT_CONFIRM, WEIGHT_CONFIRMED, WAIT_CUSTOMS_DOCS, EXPORT_CUSTOMS, SAILING_CLEARANCE, WAIT_UNLOAD, WAIT_DISPATCH, OUTBOUND_DOCUMENT, DELIVERING, SIGNED, MEASUREMENT_REVIEW]}
                 orderIds:
                   type: array
                   nullable: true
@@ -388,7 +388,7 @@ paths:
                     required: [feeOrderIds, customsOrderIds, progress]
                     properties:
                       matchingStatusOrderIds: {type: array, nullable: true, items: {type: integer, format: int64}}
-                      feeOrderIds: {type: array, items: {type: integer, format: int64}}
+                      feeOrderIds: {type: array, description: 待客户独立确认当前计费重的订单ID, items: {type: integer, format: int64}}
                       customsOrderIds: {type: array, items: {type: integer, format: int64}}
                       progress:
                         type: array
@@ -401,6 +401,47 @@ paths:
                             stage: {type: string, enum: [loaded, declared, cleared]}
                             partial: {type: boolean}
 
+  /internal/firstleg/v1/inbounds/unified-orders/status-summaries:
+    post:
+      summary: 当前页订单按原筛选读取履约摘要（Order 内部）
+      description: candidateOrderIds 必须提供且最多200项；保留统一筛选，避免读到不匹配的其他入库分片。
+      security: [{internalServiceToken: []}]
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema: {$ref: '#/components/schemas/UnifiedInboundQuery'}
+      responses:
+        '200':
+          description: 标准 ApiResponse，data 为 UnifiedInboundSummary 数组
+  /internal/firstleg/v1/inbounds/unified-orders/status-rows:
+    post:
+      summary: 统一订单筛选后的轻量状态投影（Order 内部）
+      description: 非分页查询，共享统一履约筛选；按创建时间和ID降序排列，同一订单同一主状态去重，保留不同分片主状态，不查询逐票详情。调用方不传mainStatus。
+      security: [{internalServiceToken: []}]
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema: {$ref: '#/components/schemas/UnifiedInboundQuery'}
+      responses:
+        '200':
+          description: 标准 ApiResponse；依赖失败不能返回空成功
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code: {type: string}
+                  data:
+                    type: array
+                    items:
+                      type: object
+                      required: [tenantId, orderId]
+                      properties:
+                        tenantId: {type: string}
+                        orderId: {type: string}
+                        mainStatus: {type: string, nullable: true}
   /internal/firstleg/v1/inbounds/unified-orders/query:
     post:
       summary: 按统一订单条件分页查询履约摘要（Order 内部）
@@ -594,13 +635,13 @@ paths:
   /api/platform/v1/containers/{id}/clearance:
     get:
       summary: 查询货柜目的港清关资料
-      description: 需要 platform:firstleg:terminal-drayage:list 权限；仅国外工作台货柜
+      description: 需要 platform:firstleg:terminal-drayage:list 权限；有效货柜已确认国内离仓，或已记录 DEPARTED_ORIGIN_PORT 且 actual_at 非空时可读取；人工与拉取节点使用相同事实
       parameters: [{$ref: '#/components/parameters/ContainerBookingId'}]
       responses: {'200': {description: 成功或货柜不存在}}
   /api/platform/v1/containers/{id}/clearance/document:
     post:
       summary: 上传或替换货柜目的港清关资料
-      description: 需要 platform:firstleg:terminal-drayage:document:edit 权限，fileId 必须严格绑定当前货柜
+      description: 需要 platform:firstleg:terminal-drayage:document:edit 权限；有效货柜已离仓或已实际开船，fileId 必须严格绑定当前货柜
       parameters: [{$ref: '#/components/parameters/ContainerBookingId'}, {$ref: '#/components/parameters/IdempotencyKey'}]
       requestBody:
         required: true
@@ -609,7 +650,7 @@ paths:
   /api/platform/v1/containers/{id}/clearance/document/{fileId}/download:
     get:
       summary: 下载货柜目的港清关附件
-      description: 需要 platform:firstleg:terminal-drayage:list 权限；服务端校验当前 DESTINATION_CLEARANCE fileId 及 File 业务归属，完成态仍可下载，响应禁止缓存
+      description: 需要 platform:firstleg:terminal-drayage:list 权限；有效货柜已离仓或已实际开船；服务端校验当前 DESTINATION_CLEARANCE fileId 及 File 业务归属，完成态仍可下载，响应禁止缓存
       parameters:
         - {$ref: '#/components/parameters/ContainerBookingId'}
         - {name: fileId, in: path, required: true, schema: {type: string, pattern: '^[1-9][0-9]*$'}}
@@ -619,7 +660,7 @@ paths:
   /api/platform/v1/containers/{id}/clearance/document/upload:
     post:
       summary: 直接选择文件上传或替换货柜目的港清关资料
-      description: 需要 platform:firstleg:terminal-drayage:document:edit；Firstleg 使用内部服务令牌上传 File，浏览器不得传递 fileId 或内部令牌。
+      description: 需要 platform:firstleg:terminal-drayage:document:edit；有效货柜已离仓或已实际开船；Firstleg 使用内部服务令牌上传 File，浏览器不得传递 fileId 或内部令牌。上传成功即作为待拆柜的资料事实，不要求另行确认清关完成。
       parameters: [{$ref: '#/components/parameters/ContainerBookingId'}, {$ref: '#/components/parameters/IdempotencyKey'}]
       requestBody:
         required: true
@@ -630,7 +671,7 @@ paths:
   /api/platform/v1/containers/{id}/clearance/complete:
     post:
       summary: 点击完成目的港清关
-      description: 需要 platform:firstleg:terminal-drayage:document:edit 权限
+      description: 需要 platform:firstleg:terminal-drayage:document:edit 权限；有效货柜已离仓或已实际开船；此完成动作不作为上传后进入待拆柜的附加条件
       parameters: [{$ref: '#/components/parameters/ContainerBookingId'}, {$ref: '#/components/parameters/IdempotencyKey'}]
       requestBody:
         required: true
@@ -1631,9 +1672,9 @@ components:
         orderNo: {type: string, maxLength: 64, nullable: true}
         mainStatus:
           type: string
-          enum: [PENDING_REVIEW, WAIT_MEASURE, WAIT_PALLETIZE, WAIT_SPLIT, LOADING, LOADED, DELIVERED]
+          enum: [PENDING_REVIEW, WAIT_MEASURE, WAIT_PALLETIZE, WAIT_SPLIT, LOADING, LOADED, DELIVERED, WAIT_WEIGHT_CONFIRM, WEIGHT_CONFIRMED, WAIT_CUSTOMS_DOCS, EXPORT_CUSTOMS, SAILING_CLEARANCE, WAIT_UNLOAD, WAIT_DISPATCH, OUTBOUND_DOCUMENT, DELIVERING, SIGNED, MEASUREMENT_REVIEW]
           nullable: true
-          description: WAIT_SPLIT 为唯一待分柜筛选值
+          description: WAIT_SPLIT 为唯一待分柜筛选值；WAIT_CUSTOMS_DOCS 为实际装柜后缺少本票客户报关资料；EXPORT_CUSTOMS 按本票资料已上传且实际装柜完成汇总，买单无需客户退税资料，不依赖点击开始报关，实际开船后移出；SAILING_CLEARANCE 按手动或拉取的实际离港节点进入，清关资料上传后进入 WAIT_UNLOAD，实际卸柜完成后移出。
         customerId: {type: integer, format: int64, nullable: true}
         receivingWarehouseId: {type: integer, format: int64, nullable: true}
         destinationWarehouseId: {type: integer, format: int64, nullable: true}

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

@@ -0,0 +1,64 @@
+openapi: 3.0.3
+info: {title: 客户独立计费重确认, version: 1.0.0}
+security: [{bearerAuth: []}]
+paths:
+  /api/merchant/v1/first-leg/orders/{orderId}/chargeable-weights:
+    get:
+      summary: 客户读取本票全部独立入仓计费重
+      description: 认证客户隔离，要求merchant:order:view；仅返回测量审核通过且计费重为正的分片。
+      parameters:
+        - {name: orderId, in: path, required: true, schema: {type: integer, format: int64}}
+      responses:
+        '200':
+          description: 标准ApiResponse，认证客户无可确认来源时返回空数组
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code: {type: string, example: '200'}
+                  message: {type: string}
+                  data:
+                    type: array
+                    items: {$ref: '#/components/schemas/Weight'}
+  /api/merchant/v1/first-leg/chargeable-weights/{inboundId}/confirm:
+    post:
+      summary: 客户独立确认当前计费重
+      description: 要求merchant:order:edit。与费用金额确认独立；值或测量轮次变化后旧确认失效。客户范围取认证主体。
+      parameters:
+        - {name: inboundId, in: path, required: true, schema: {type: integer, format: int64}}
+        - {name: Idempotency-Key, in: header, required: true, schema: {type: string, maxLength: 128}}
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [expectedFingerprint]
+              properties:
+                expectedFingerprint: {type: string, pattern: '^[a-f0-9]{64}$'}
+      responses:
+        '200':
+          description: 标准ApiResponse；版本或异参冲突返回业务冲突码，不改变费用状态
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code: {type: string, example: '200'}
+                  message: {type: string}
+                  data: {$ref: '#/components/schemas/Weight'}
+components:
+  securitySchemes:
+    bearerAuth: {type: http, scheme: bearer, bearerFormat: JWT}
+  schemas:
+    Weight:
+      type: object
+      required: [inboundId, orderId, chargeableWeightKg, fingerprint, confirmed]
+      properties:
+        inboundId: {type: string, description: 独立来源入仓单ID}
+        orderId: {type: string, description: 独立订单ID}
+        chargeableWeightKg: {type: number}
+        fingerprint: {type: string}
+        confirmed: {type: boolean}
+        confirmedAt: {type: string, format: date-time, nullable: true}

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

@@ -44,6 +44,20 @@ class InternalInboundOrderReferenceControllerTest {
     @Resource
     private InternalInboundOrderController controller;
 
+    /** 新增状态查询和摘要入口都必须校验内部服务身份。 */
+    @Test
+    void statusEndpointsRequireInternalTokenBeforeDelegation() {
+        var request = new UnifiedInboundQuery(10001L, null, null, null, null, null, null, null,
+            null, null, null, null, null, null, null, null, null, null, List.of(77L), null, null, 1, 20, null);
+        assertThatThrownBy(() -> controller.unifiedStatusRows(null, request)).isInstanceOf(BizException.class);
+        assertThatThrownBy(() -> controller.unifiedStatusSummaries("wrong", request)).isInstanceOf(BizException.class);
+        org.mockito.Mockito.verifyNoInteractions(unifiedQueryService);
+        when(unifiedQueryService.statusRows(request)).thenReturn(List.of());
+        when(unifiedQueryService.statusSummaries(request)).thenReturn(List.of());
+        assertThat(controller.unifiedStatusRows("internal-token", request).data()).isEmpty();
+        assertThat(controller.unifiedStatusSummaries("internal-token", request).data()).isEmpty();
+    }
+
     @Test void workbenchFiltersRejectMissingAndWrongInternalIdentity() {
         var request = new com.baiyue.firstleg.dto.MerchantWorkbenchFilters.Request(11L, "LOADED", null);
         assertThatThrownBy(() -> controller.workbenchFilters(null, request)).isInstanceOf(BizException.class);

firstleg/src/test/java/com/baiyue/firstleg/repository/LoadingCompletionSqlContractTest.java

@@ -9,6 +9,16 @@ import java.nio.file.Path;
 import static org.assertj.core.api.Assertions.assertThat;
 
 class LoadingCompletionSqlContractTest {
+    /** 后执行的渠道柜次脚本不能恢复旧触发器并阻断持久化完成命令。 */
+    @Test
+    void channelMigrationKeepsTheDurableCompletionTransitions() throws Exception {
+        String sql = Files.readString(Path.of("src", "main", "resources", "db",
+            "phase3-channel-container-migration.sql"), StandardCharsets.UTF_8);
+        assertThat(sql).contains("OLD.task_status = 'LOADING' AND NEW.task_status IN ('LOADING','COMPLETING')")
+            .contains("OLD.task_status = 'COMPLETING' AND NEW.task_status IN ('COMPLETING','COMPLETION_FAILED','COMPLETED')")
+            .contains("OLD.task_status = 'COMPLETION_FAILED' AND NEW.task_status = 'COMPLETING'")
+            .doesNotContain("任务状态只允许完成");
+    }
     @Test
     void baselineAndUnifiedSqlDefineDurableCompletionStateMachine() throws Exception {
         assertContract(Files.readString(Path.of("src", "main", "resources", "db",

firstleg/src/test/java/com/baiyue/firstleg/repository/Phase3FinalUnifiedSqlContractTest.java

@@ -80,7 +80,7 @@ class Phase3FinalUnifiedSqlContractTest {
     @Test
     void initializationPassIsUniqueAndFinal() throws Exception {
         String sql = sql();
-        int expectedTables = 227;
+        int expectedTables = 228;
         long actualTables = java.util.regex.Pattern.compile("(?m)^CREATE TABLE\\s+")
             .matcher(sql).results().count();
         assertThat(actualTables).isEqualTo(expectedTables);

firstleg/src/test/java/com/baiyue/firstleg/repository/UnifiedInboundTaxModePaginationTest.java

@@ -69,6 +69,17 @@ class UnifiedInboundTaxModePaginationTest {
         assertPage(null, 1, 4, 6);
         assertPage(null, 2, 4, 4);
     }
+    /** 轻量统计读取全量状态，不能把第二页当作全量，也不能越过客户和软删除条件。 */
+    @Test
+    void statusProjectionUsesFullFilteredSetAndEmptyCandidatesStayEmpty() {
+        var query = new UnifiedInboundQuery(11L, null, null, null, null, null, null, null, null, null,
+            null, null, null, null, null, null, null, null, null, null, null, 2, 1, "TAX_REFUND");
+        assertThat(repository.unifiedStatusEntities(query)).extracting(InboundOrderEntity::getId).containsExactly(6L, 2L);
+        var empty = new UnifiedInboundQuery(11L, null, null, null, null, null, null, null, null, null,
+            null, null, null, null, null, null, null, null, List.of(), null, null, 2, 1, "TAX_REFUND");
+        assertThat(repository.unifiedStatusEntities(empty)).isEmpty();
+    }
+
     private void assertPage(String taxMode, long page, long total, long expectedId) {
         var query = new UnifiedInboundQuery(11L, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, page, 1, taxMode);
         var result = repository.pageUnifiedEntities(query, List.of("LOADED"));

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

@@ -50,6 +50,18 @@ class ContainerServiceTest {
     @MockBean private SmartLoadingService smartLoadingService;
     @Resource private ContainerService service;
 
+    /** 实际开船可独立打开清关资料，预估节点与缺失货柜不能绕过校验。 */
+    @Test void clearanceAcceptsActualSailingWithoutInventingOutboundConfirmation() {
+        when(repository.find(91L)).thenReturn(new ContainerBookingEntity());
+        assertThatThrownBy(() -> service.requireClearanceAccess(91L)).isInstanceOf(BizException.class);
+        when(repository.sailed(91L)).thenReturn(true);
+        service.requireClearanceAccess(91L);
+        assertThatThrownBy(() -> service.requireClearanceAccess(92L)).isInstanceOf(BizException.class);
+        when(repository.sailed(91L)).thenReturn(false);
+        when(repository.departed(91L)).thenReturn(true);
+        service.requireClearanceAccess(91L);
+    }
+
     @BeforeEach
     void setUpWarehouse() {
         when(documentNumbers.nextCabinetNo()).thenReturn("D0001");

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

@@ -9,6 +9,20 @@ import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
 class MerchantWorkbenchFilterServiceTest {
+    /** 金额待确认与计费重待确认不同，客户工作台只能使用后者。 */
+    @Test void customerQueueUsesIndependentWeightConfirmation() {
+        var mapper=mock(MerchantWorkbenchFilterMapper.class);
+        var weights=mock(com.baiyue.firstleg.workflow.ChargeableWeightService.class);
+        var service=new MerchantWorkbenchFilterService();
+        ReflectionTestUtils.setField(service,"mapper",mapper);
+        ReflectionTestUtils.setField(service,"weights",weights);
+        when(weights.pendingOrders(11)).thenReturn(List.of(101L));
+        var response=service.read(new MerchantWorkbenchFilters.Request(11L,null,null));
+        assertThat(response.feeOrderIds()).containsExactly(101L);
+        verify(weights).pendingOrders(11);
+        verify(mapper,never()).pendingFees(anyLong());
+    }
+
     @Test void exactDetailProgressSkipsUnrelatedCustomerQueues() {
         var mapper=mock(MerchantWorkbenchFilterMapper.class);
         var unified=mock(UnifiedInboundQueryService.class);

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

@@ -24,11 +24,77 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 class UnifiedInboundQueryServiceTest {
+    /** 直接内部查询同样先按业务事实筛选再分页，不能返回未命中的订单。 */
+    @Test
+    void workflowPageFiltersBeforePagination() {
+        var repository = mock(InboundOrderRepository.class);
+        var workflow = mock(com.baiyue.firstleg.workflow.WorkflowTabService.class);
+        var service = new UnifiedInboundQueryService();
+        ReflectionTestUtils.setField(service, "inbounds", repository);
+        ReflectionTestUtils.setField(service, "workflowTabs", workflow);
+        ReflectionTestUtils.setField(service, "operations", mock(UnifiedInboundReadRepository.class));
+        ReflectionTestUtils.setField(service, "pricing", mock(FbaPricingRepository.class));
+        var query = new UnifiedInboundQuery(10001L, null, null, "WAIT_WEIGHT_CONFIRM", null, null, null, null,
+            null, null, null, null, null, null, null, null, null, null, null, null, null, 2, 1, null);
+        var first = new InboundOrderEntity(); first.setId(1L); first.setTenantId(10001L); first.setOrderId(77L); first.setProcessStatus("WAIT_SPLIT");
+        var second = new InboundOrderEntity(); second.setId(2L); second.setTenantId(10001L); second.setOrderId(78L); second.setProcessStatus("WAIT_SPLIT");
+        var other = new InboundOrderEntity(); other.setId(3L); other.setTenantId(10001L); other.setOrderId(79L); other.setProcessStatus("WAIT_SPLIT");
+        var sources = List.of(first, second, other);
+        when(repository.unifiedStatusEntities(query)).thenReturn(sources);
+        when(workflow.rows(sources)).thenReturn(List.of(
+            new UnifiedInboundQueryService.StatusRow(10001L,77L,"WAIT_WEIGHT_CONFIRM"),
+            new UnifiedInboundQueryService.StatusRow(10001L,78L,"WAIT_WEIGHT_CONFIRM"),
+            new UnifiedInboundQueryService.StatusRow(10001L,79L,"WEIGHT_CONFIRMED")));
+        when(repository.unifiedMatchedEntities(org.mockito.ArgumentMatchers.any(), org.mockito.ArgumentMatchers.eq(List.of())))
+            .thenReturn(sources);
+        var result = service.page(query);
+        assertThat(result.total()).isEqualTo(2);
+        assertThat(result.records()).singleElement().satisfies(row -> assertThat(row.inbound().orderId()).isEqualTo(78));
+    }
+
+    /** 分片订单保留各状态命中，同一状态内去重；不触发逐票富化查询。 */
+    @Test
+    void statusRowsDeduplicateLatestMatchingInboundWithoutEnrichment() {
+        var repository = mock(InboundOrderRepository.class);
+        var operations = mock(UnifiedInboundReadRepository.class);
+        var pricing = mock(FbaPricingRepository.class);
+        var service = new UnifiedInboundQueryService();
+        ReflectionTestUtils.setField(service, "workflowTabs", mock(com.baiyue.firstleg.workflow.WorkflowTabService.class));
+        ReflectionTestUtils.setField(service, "inbounds", repository);
+        ReflectionTestUtils.setField(service, "operations", operations);
+        ReflectionTestUtils.setField(service, "pricing", pricing);
+        var query = new UnifiedInboundQuery(10001L, null, null, null, null, null, null, null,
+            null, null, null, null, null, null, null, null, null, null, null, null, null, 9, 1, null);
+        var newest = new InboundOrderEntity(); newest.setTenantId(10001L); newest.setOrderId(77L);
+        newest.setProcessStatus("MEASURE_PENDING");
+        var older = new InboundOrderEntity(); older.setTenantId(10001L); older.setOrderId(77L);
+        older.setProcessStatus("LOADED");
+        when(repository.unifiedStatusEntities(query)).thenReturn(List.of(newest, newest, older));
+        assertThat(service.statusRows(query)).containsExactly(
+            new UnifiedInboundQueryService.StatusRow(10001L, 77L, "WAIT_MEASURE"),
+            new UnifiedInboundQueryService.StatusRow(10001L, 77L, "LOADED"));
+        verifyNoInteractions(operations, pricing);
+    }
+
+    /** 摘要入口必须提供当前页候选，不能误触发全量明细读取。 */
+    @Test
+    void statusSummariesRejectUnboundedCandidateRequest() {
+        var repository = mock(InboundOrderRepository.class);
+        var service = new UnifiedInboundQueryService();
+        ReflectionTestUtils.setField(service, "workflowTabs", mock(com.baiyue.firstleg.workflow.WorkflowTabService.class));
+        ReflectionTestUtils.setField(service, "inbounds", repository);
+        var query = new UnifiedInboundQuery(10001L, null, null, null, null, null, null, null,
+            null, null, null, null, null, null, null, null, null, null, null, null, null, 1, 20, null);
+        assertThatThrownBy(() -> service.statusSummaries(query)).isInstanceOf(BizException.class);
+        verifyNoInteractions(repository);
+    }
+
     @ParameterizedTest
     @ValueSource(strings = {"", " ", "tax_refund", "TAX_REFUND ", "OTHER", "TAX_INCLUDED"})
     void illegalTaxModeFailsBeforeRepository(String taxMode) {
         var repository = mock(InboundOrderRepository.class);
         var service = new UnifiedInboundQueryService();
+        ReflectionTestUtils.setField(service, "workflowTabs", mock(com.baiyue.firstleg.workflow.WorkflowTabService.class));
         ReflectionTestUtils.setField(service, "inbounds", repository);
         var query = new UnifiedInboundQuery(10001L, null, null, null, null, null, null, null,
             null, null, null, null, null, null, null, null, null, null, null, null, null, 1, 20, taxMode);
@@ -144,6 +210,7 @@ class UnifiedInboundQueryServiceTest {
         var operations = mock(UnifiedInboundReadRepository.class);
         var pricing = mock(FbaPricingRepository.class);
         var service = new UnifiedInboundQueryService();
+        ReflectionTestUtils.setField(service, "workflowTabs", mock(com.baiyue.firstleg.workflow.WorkflowTabService.class));
         ReflectionTestUtils.setField(service,"inbounds",inbounds);
         ReflectionTestUtils.setField(service,"operations",operations);
         ReflectionTestUtils.setField(service,"pricing",pricing);

firstleg/src/test/java/com/baiyue/firstleg/workflow/WorkflowBoundaryTest.java

@@ -0,0 +1,63 @@
+package com.baiyue.firstleg.workflow;
+
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.common.core.exception.BizException;
+import com.baiyue.firstleg.entity.InboundOrderEntity;
+import org.junit.jupiter.api.Test;
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.List;
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+/** 跨服务缺项和客户归属异常不能生成看似成功的部分统计。 */
+class WorkflowBoundaryTest {
+    /** 真实开船来源的测试事实。 */
+    private WorkflowFacts.Fact fact() {
+        return new WorkflowFacts.Fact(11,1,101,"APPROVED",BigDecimal.TEN,
+            LocalDateTime.of(2026,10,19,10,0),true,false,false,false,null,null);
+    }
+
+    /** 下游漏来源或返回其他客户均整体失败。 */
+    @Test void rejectsMissingAndForeignDownstreamFacts() {
+        var repository=mock(WorkflowFactRepository.class);
+        var downstream=mock(LastlegWorkflowClient.class);
+        var service=new WorkflowTabService(repository,downstream);
+        var inbound=new InboundOrderEntity();inbound.setId(1L);inbound.setTenantId(11L);
+        inbound.setOrderId(101L);inbound.setProcessStatus("LOADED");
+        when(repository.facts(List.of(1L))).thenReturn(List.of(fact()));
+        when(downstream.read(any(),any())).thenReturn(ApiResponse.success(List.of()));
+        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class);
+        when(downstream.read(any(),any())).thenReturn(ApiResponse.success(List.of(
+            new WorkflowFacts.Overseas(22,1,true,true,false,true))));
+        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class);
+        when(downstream.read(any(),any())).thenThrow(new IllegalStateException("unavailable"));
+        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class);
+    }
+
+    /** 重测同值也要求重新确认，金额没有参与摘要。 */
+    @Test void repeatedMeasurementRequiresNewConfirmation() {
+        var original=fact();
+        var measuredAgain=new WorkflowFacts.Fact(11,1,101,"APPROVED",BigDecimal.TEN,
+            original.measureCompletedAt().plusSeconds(1),true,false,false,false,
+            ChargeableWeightService.fingerprint(original),LocalDateTime.now());
+        assertThat(ChargeableWeightService.weight(measuredAgain).confirmed()).isFalse();
+    }
+
+    /** 平台主体不得冒充客户，客户和操作者只取认证上下文。 */
+    @Test void confirmationUsesAuthenticatedCustomerAndOperator() {
+        var service=mock(ChargeableWeightService.class);
+        var controller=new MerchantChargeableWeightController(service);
+        var platform=new com.baiyue.common.security.AuthenticatedUser(7L,0L,0L,9L,"platform","PLATFORM","WEB",java.util.Set.of());
+        var request=new WorkflowFacts.Confirm("a".repeat(64));
+        assertThatThrownBy(()->controller.read(platform,101)).isInstanceOf(BizException.class);
+        assertThatThrownBy(()->controller.confirm(platform,1,"key",request)).isInstanceOf(BizException.class);
+        verifyNoInteractions(service);
+        var merchant=new com.baiyue.common.security.AuthenticatedUser(7L,11L,0L,9L,"member","MERCHANT","WEB",java.util.Set.of());
+        controller.read(merchant,101);
+        controller.confirm(merchant,1,"key",request);
+        verify(service).read(11,101);
+        verify(service).confirm(11,7,1,"key",request);
+    }
+}

firstleg/src/test/java/com/baiyue/firstleg/workflow/WorkflowBusinessTest.java

@@ -0,0 +1,63 @@
+package com.baiyue.firstleg.workflow;
+import org.junit.jupiter.api.Test;
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import static org.assertj.core.api.Assertions.*;
+/** 取消回显、分柜隔离和独立计费重版本回归。 */
+class WorkflowBusinessTest {
+    /** 报关资料齐备进入汇总，实际开船及清关资料分别驱动后续页签。 */
+    @Test void customsDocumentsDepartureAndClearanceDriveTabs() {
+        var time=LocalDateTime.of(2026,10,19,10,0);
+        var missing=new WorkflowFacts.Fact(11,1,101,"APPROVED",BigDecimal.TEN,time,false,false,true,false,null,null);
+        var uploaded=new WorkflowFacts.Fact(11,1,101,"APPROVED",BigDecimal.TEN,time,false,false,false,true,null,null);
+        var departed=new WorkflowFacts.Fact(11,1,101,"APPROVED",BigDecimal.TEN,time,true,false,false,true,null,null);
+        var cleared=new WorkflowFacts.Fact(11,1,101,"APPROVED",BigDecimal.TEN,time,true,true,false,true,null,null);
+        var uploadedBeforeDeparture=new WorkflowFacts.Fact(11,1,101,"APPROVED",BigDecimal.TEN,time,false,true,false,true,null,null);
+        var pendingUnload=new WorkflowFacts.Overseas(11,1,false,false,false,false);
+        var unloaded=new WorkflowFacts.Overseas(11,1,false,false,false,true);
+        assertThat(WorkflowTabService.classify(missing,"LOADED",null))
+            .contains("WAIT_CUSTOMS_DOCS").doesNotContain("EXPORT_CUSTOMS","SAILING_CLEARANCE","WAIT_UNLOAD");
+        assertThat(WorkflowTabService.classify(uploaded,"LOADED",null))
+            .contains("EXPORT_CUSTOMS").doesNotContain("WAIT_CUSTOMS_DOCS","SAILING_CLEARANCE","WAIT_UNLOAD");
+        assertThat(WorkflowTabService.classify(uploadedBeforeDeparture,"LOADED",pendingUnload))
+            .contains("EXPORT_CUSTOMS").doesNotContain("SAILING_CLEARANCE","WAIT_UNLOAD");
+        assertThat(WorkflowTabService.classify(departed,"LOADED",pendingUnload))
+            .contains("SAILING_CLEARANCE").doesNotContain("WAIT_CUSTOMS_DOCS","EXPORT_CUSTOMS","WAIT_UNLOAD");
+        assertThat(WorkflowTabService.classify(cleared,"LOADED",pendingUnload))
+            .contains("WAIT_UNLOAD").doesNotContain("WAIT_CUSTOMS_DOCS","EXPORT_CUSTOMS","SAILING_CLEARANCE");
+        assertThat(WorkflowTabService.classify(cleared,"LOADED",unloaded))
+            .doesNotContain("WAIT_UNLOAD","SAILING_CLEARANCE","EXPORT_CUSTOMS");
+        assertThat(WorkflowTabService.classify(uploaded,"DELIVERED",unloaded))
+            .contains("SIGNED").doesNotContain("EXPORT_CUSTOMS","WAIT_CUSTOMS_DOCS");
+    }
+    /** 构造独立分柜来源。 */
+    private WorkflowFacts.Fact fact(long id,String kg,String confirmed,boolean uploaded) {
+        return new WorkflowFacts.Fact(11,id,100+id,"APPROVED",new BigDecimal(kg),LocalDateTime.of(2026,10,19,10,0),true,uploaded,false,false,confirmed,null);
+    }
+    /** 有效建单移出待排车，取消后恢复；实际出库不计未出库单。 */
+    @Test void cancellationRestoresDispatchQueue() {
+        var f=fact(1,"100",null,true);
+        var waiting=new WorkflowFacts.Overseas(11,1,false,false,false,true);
+        var created=new WorkflowFacts.Overseas(11,1,true,true,false,true);
+        var shipped=new WorkflowFacts.Overseas(11,1,true,false,true,true);
+        assertThat(WorkflowTabService.classify(f,"LOADED",waiting)).contains("WAIT_DISPATCH").doesNotContain("OUTBOUND_DOCUMENT");
+        assertThat(WorkflowTabService.classify(f,"LOADED",created)).contains("OUTBOUND_DOCUMENT").doesNotContain("WAIT_DISPATCH");
+        assertThat(WorkflowTabService.classify(f,"LOADED",shipped)).contains("DELIVERING").doesNotContain("WAIT_DISPATCH","OUTBOUND_DOCUMENT");
+        assertThat(WorkflowTabService.classify(f,"LOADED",waiting)).contains("WAIT_DISPATCH");
+    }
+    /** 一柜资料上传不覆盖另一柜；签收不再进入待排。 */
+    @Test void independentSlicesAndUploadedClearance() {
+        assertThat(WorkflowTabService.classify(fact(1,"100",null,false),"LOADED",new WorkflowFacts.Overseas(11,1,false,false,false,false)))
+            .contains("SAILING_CLEARANCE","WAIT_DISPATCH").doesNotContain("WAIT_UNLOAD");
+        assertThat(WorkflowTabService.classify(fact(2,"200",null,true),"LOADED",new WorkflowFacts.Overseas(11,2,true,true,false,false)))
+            .contains("WAIT_UNLOAD","OUTBOUND_DOCUMENT").doesNotContain("SAILING_CLEARANCE","WAIT_DISPATCH");
+        assertThat(WorkflowTabService.classify(fact(1,"100",null,false),"DELIVERED",null)).contains("SIGNED").doesNotContain("WAIT_DISPATCH");
+    }
+    /** 数值格式不改变版本，值或来源变化必须重新确认。 */
+    @Test void independentWeightVersion() {
+        var hash=ChargeableWeightService.fingerprint(fact(1,"100.0000",null,false));
+        assertThat(ChargeableWeightService.weight(fact(1,"100",hash,false)).confirmed()).isTrue();
+        assertThat(ChargeableWeightService.weight(fact(1,"101",hash,false)).confirmed()).isFalse();
+        assertThat(ChargeableWeightService.weight(fact(2,"100",hash,false)).confirmed()).isFalse();
+    }
+}

firstleg/src/test/java/com/baiyue/firstleg/workflow/WorkflowFactPersistenceTest.java

@@ -0,0 +1,120 @@
+package com.baiyue.firstleg.workflow;
+import org.junit.jupiter.api.Test;
+import org.h2.jdbcx.JdbcDataSource;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.mybatis.spring.SqlSessionTemplate;
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
+import java.nio.file.*;
+import java.util.List;
+import static org.assertj.core.api.Assertions.*;
+/** 真实Mapper和隔离内存库验证资料归属、计费重确认和历史失效。 */
+class WorkflowFactPersistenceTest {
+    /** 测试建表不连接业务数据库。 */
+    @Test void clearanceAndWeightConfirmationPersistIndependently() throws Exception {
+        var ds=new JdbcDataSource();ds.setURL("jdbc:h2:mem:weight-"+java.util.UUID.randomUUID()+";MODE=MySQL;DB_CLOSE_DELAY=-1");
+        var db=new JdbcTemplate(ds);
+        db.execute("CREATE TABLE fl_inbound_order(id BIGINT PRIMARY KEY,tenant_id BIGINT,order_id BIGINT,measure_review_status VARCHAR(30),chargeable_weight_kg DECIMAL(18,4),measure_completed_at TIMESTAMP,deleted INT,process_status VARCHAR(30))");
+        db.execute("CREATE TABLE fl_loading_plan_item(id BIGINT,inbound_id BIGINT,account_id BIGINT,loading_plan_id BIGINT,deleted INT)");
+        db.execute("CREATE TABLE fl_loading_plan(id BIGINT,plan_status VARCHAR(30),container_booking_id BIGINT)");
+        db.execute("CREATE TABLE fl_loading_pick_task(id BIGINT,loading_plan_id BIGINT,task_status VARCHAR(30))");
+        db.execute("CREATE TABLE fl_loading_pick_item(pick_task_id BIGINT,loading_plan_item_id BIGINT,item_status VARCHAR(30),picked_package_count INT)");
+        db.execute("CREATE TABLE fl_container_booking(id BIGINT,record_status VARCHAR(30))");
+        db.execute("CREATE TABLE fl_carrier_schedule_node_fact(container_booking_id BIGINT,standard_node VARCHAR(40),actual_at TIMESTAMP)");
+        db.execute("CREATE TABLE fl_container_document(container_booking_id BIGINT,document_type VARCHAR(40),file_id BIGINT)");
+        db.execute("CREATE TABLE fl_customs_customer_document_inbound(inbound_id BIGINT,tenant_id BIGINT,document_id BIGINT)");
+        db.execute("CREATE TABLE fl_customs_customer_document(id BIGINT,tenant_id BIGINT,status VARCHAR(30),customs_container_id BIGINT)");
+        db.execute("CREATE TABLE fl_customs_container(id BIGINT,loading_plan_id BIGINT,status VARCHAR(40))");
+        db.execute("ALTER TABLE fl_inbound_order ADD tax_mode VARCHAR(30)");
+        db.execute("ALTER TABLE fl_inbound_order ADD parent_inbound_id BIGINT");
+        db.execute("ALTER TABLE fl_inbound_order ADD inbound_role VARCHAR(30)");
+        db.execute("ALTER TABLE fl_inbound_order ADD split_purpose VARCHAR(30)");
+        db.execute(Files.readString(Path.of("src/main/resources/db/chargeable-weight-confirmation.sql")));
+        db.update("INSERT INTO fl_inbound_order(id,tenant_id,order_id,measure_review_status,chargeable_weight_kg,measure_completed_at,deleted,process_status,tax_mode) VALUES(1,11,101,'APPROVED',100,CURRENT_TIMESTAMP,0,'LOADED','TAX_REFUND'),(2,22,102,'APPROVED',200,CURRENT_TIMESTAMP,0,'LOADED','BUY_DECLARATION')");
+        db.update("INSERT INTO fl_loading_plan_item VALUES(3,1,11,4,0)");
+        db.update("INSERT INTO fl_loading_plan VALUES(4,'COMPLETED',5)");
+        db.update("INSERT INTO fl_container_booking VALUES(5,'ACTIVE')");
+        db.update("INSERT INTO fl_loading_pick_task VALUES(6,4,'COMPLETED')");
+        db.update("INSERT INTO fl_loading_pick_item VALUES(6,3,'PICKED',2)");
+        db.update("INSERT INTO fl_carrier_schedule_node_fact VALUES(5,'DEPARTED_ORIGIN_PORT',CURRENT_TIMESTAMP)");
+        var config=new MybatisConfiguration();config.setMapUnderscoreToCamelCase(true);config.addMapper(WorkflowFactMapper.class);
+        config.addMapper(com.baiyue.firstleg.mapper.ContainerBookingMapper.class);
+        var factory=new MybatisSqlSessionFactoryBean();factory.setDataSource(ds);factory.setConfiguration(config);
+        var mapper=new SqlSessionTemplate(factory.getObject()).getMapper(WorkflowFactMapper.class);
+        var containers=new SqlSessionTemplate(factory.getObject()).getMapper(com.baiyue.firstleg.mapper.ContainerBookingMapper.class);
+        assertThat(containers.hasActualVesselDeparture(5)).isOne();
+        assertThat(containers.hasActualVesselDeparture(6)).isZero();
+        db.update("INSERT INTO fl_carrier_schedule_node_fact VALUES(6,'DEPARTED_ORIGIN_PORT',NULL),(6,'ARRIVED_DESTINATION_PORT',CURRENT_TIMESTAMP)");
+        assertThat(containers.hasActualVesselDeparture(6)).isZero();
+        var repository=new WorkflowFactRepository(mapper);var service=new ChargeableWeightService(repository);
+        assertThat(service.read(22,101)).isEmpty();
+        assertThat(mapper.facts(List.of(1L))).singleElement().satisfies(f->{assertThat(f.departed()).isTrue();assertThat(f.clearanceUploaded()).isFalse();assertThat(f.missingCustoms()).isTrue();});
+        db.update("INSERT INTO fl_container_document VALUES(5,'DESTINATION_CLEARANCE',99)");
+        assertThat(mapper.facts(List.of(1L)).get(0).clearanceUploaded()).isTrue();
+        db.update("INSERT INTO fl_customs_container VALUES(8,4,'WAITING_CUSTOMER_DOCUMENTS')");
+        db.update("INSERT INTO fl_customs_customer_document VALUES(9,22,'ACTIVE',8)");
+        db.update("INSERT INTO fl_customs_customer_document_inbound VALUES(1,22,9)");
+        assertThat(mapper.facts(List.of(1L))).singleElement().satisfies(f->{
+            assertThat(f.missingCustoms()).isTrue();assertThat(f.exportCustomsReady()).isFalse();
+        });
+        db.update("INSERT INTO fl_customs_customer_document VALUES(10,11,'ACTIVE',8)");
+        db.update("INSERT INTO fl_customs_customer_document_inbound VALUES(1,11,10)");
+        assertThat(mapper.facts(List.of(1L))).singleElement().satisfies(f->{assertThat(f.missingCustoms()).isFalse();assertThat(f.exportCustomsReady()).isTrue();});
+        // 本票上传后即可汇总，不必等同柜其他票或点击开始报关；完成报关后仍等待实际开船。
+        for (String status : List.of("READY_TO_START", "DECLARING", "COMPLETED")) {
+            db.update("UPDATE fl_customs_container SET status=? WHERE id=8", status);
+            assertThat(mapper.facts(List.of(1L)).get(0).exportCustomsReady()).isTrue();
+        }
+        db.update("UPDATE fl_customs_customer_document SET status='DELETED' WHERE id=10");
+        assertThat(mapper.facts(List.of(1L))).singleElement().satisfies(f->{
+            assertThat(f.missingCustoms()).isTrue();assertThat(f.exportCustomsReady()).isFalse();
+        });
+        db.update("UPDATE fl_customs_customer_document SET status='ACTIVE' WHERE id=10");
+        db.update("INSERT INTO fl_customs_container VALUES(18,14,'READY_TO_START')");
+        db.update("UPDATE fl_customs_customer_document SET customs_container_id=18 WHERE id=10");
+        assertThat(mapper.facts(List.of(1L)).get(0).exportCustomsReady()).isFalse();
+        db.update("UPDATE fl_customs_customer_document SET customs_container_id=8 WHERE id=10");
+        db.update("UPDATE fl_loading_plan SET plan_status='LOADING' WHERE id=4");
+        assertThat(mapper.facts(List.of(1L)).get(0).exportCustomsReady()).isFalse();
+        db.update("UPDATE fl_loading_plan SET plan_status='COMPLETED' WHERE id=4");
+        db.update("UPDATE fl_loading_pick_item SET picked_package_count=0");
+        assertThat(mapper.facts(List.of(1L)).get(0).exportCustomsReady()).isFalse();
+        db.update("UPDATE fl_loading_pick_item SET picked_package_count=2");
+        // 不把预计开船当成实际开船；手动或拉取写入的实际节点都读同一事实表。
+        db.update("UPDATE fl_carrier_schedule_node_fact SET actual_at=NULL");
+        assertThat(mapper.facts(List.of(1L)).get(0).departed()).isFalse();
+        db.update("UPDATE fl_carrier_schedule_node_fact SET actual_at=CURRENT_TIMESTAMP");
+        assertThat(mapper.facts(List.of(1L)).get(0).departed()).isTrue();
+        // 买单票无需客户上传退税资料，但同样必须有实际装柜证据。
+        assertThat(mapper.facts(List.of(2L)).get(0).exportCustomsReady()).isFalse();
+        db.update("INSERT INTO fl_loading_plan_item VALUES(13,2,22,4,0)");
+        db.update("INSERT INTO fl_loading_pick_item VALUES(6,13,'PICKED',1)");
+        assertThat(mapper.facts(List.of(2L))).singleElement().satisfies(f->{
+            assertThat(f.missingCustoms()).isFalse();assertThat(f.exportCustomsReady()).isTrue();
+        });
+        var current=service.read(11,101).get(0);
+        assertThat(service.confirm(11,7,1,"cmd",new WorkflowFacts.Confirm(current.fingerprint())).confirmed()).isTrue();
+        assertThat(service.confirm(11,7,1,"cmd",new WorkflowFacts.Confirm(current.fingerprint())).confirmed()).isTrue();
+        assertThat(db.queryForObject("SELECT COUNT(*) FROM fl_chargeable_weight_confirmation",Integer.class)).isEqualTo(1);
+        assertThatThrownBy(()->service.confirm(11,7,1,"cmd",new WorkflowFacts.Confirm("0".repeat(64)))).isInstanceOf(com.baiyue.common.core.exception.BizException.class);
+        db.update("UPDATE fl_inbound_order SET chargeable_weight_kg=101 WHERE id=1");
+        assertThat(service.read(11,101).get(0).confirmed()).isFalse();
+        assertThatThrownBy(()->service.confirm(11,7,1,"old",new WorkflowFacts.Confirm(current.fingerprint()))).isInstanceOf(com.baiyue.common.core.exception.BizException.class);
+        assertThatThrownBy(()->service.confirm(22,7,1,"foreign",new WorkflowFacts.Confirm(current.fingerprint()))).isInstanceOf(com.baiyue.common.core.exception.BizException.class);
+        // 现行部分装柜由来源单承接实装，余量子单独立继续分柜，两票均应保留。
+        db.update("INSERT INTO fl_inbound_order(id,tenant_id,order_id,measure_review_status,chargeable_weight_kg,measure_completed_at,deleted,process_status,tax_mode,parent_inbound_id,inbound_role,split_purpose) VALUES(3,11,103,'APPROVED',50,CURRENT_TIMESTAMP,0,'WAIT_SPLIT','BUY_DECLARATION',1,'CHILD','REMAINDER')");
+        assertThat(mapper.facts(List.of(1L,3L))).hasSize(2);
+        assertThat(mapper.facts(List.of(1L)).get(0).departed()).isTrue();
+        assertThat(mapper.facts(List.of(3L)).get(0).departed()).isFalse();
+        assertThat(service.read(11,101)).hasSize(1);
+        assertThat(service.read(11,103)).hasSize(1);
+        // 旧模型已将实装移至独立子票时，父汇总不能重复进入页签或确认。
+        db.update("UPDATE fl_inbound_order SET process_status='LOADED',split_purpose='LOADED' WHERE id=3");
+        assertThat(service.read(11,101)).isEmpty();
+        assertThatThrownBy(()->service.confirm(11,7,1,"parent",new WorkflowFacts.Confirm(current.fingerprint()))).isInstanceOf(com.baiyue.common.core.exception.BizException.class);
+        var child=service.read(11,103).get(0);
+        assertThat(child.confirmed()).isFalse();
+        assertThatThrownBy(()->service.confirm(11,7,3,"cmd",new WorkflowFacts.Confirm(child.fingerprint()))).isInstanceOf(com.baiyue.common.core.exception.BizException.class);
+        assertThat(service.confirm(11,7,3,"child",new WorkflowFacts.Confirm(child.fingerprint())).confirmed()).isTrue();
+    }
+}

gateway/AGENTS.md

@@ -2,8 +2,7 @@
 
 ## 数据库访问与中文注释约束
 
-- 强制遵守根 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则：正常业务访问统一为 `Controller → Service → Repository → Mapper`，不得省略 Repository 或跨层直调；生产 SQL 由 Mapper 执行，Repository 不得直接使用 JdbcTemplate 或原生 JDBC。非 HTTP 入口从 Service 进入；无数据库模块不引入数据库访问。
-- 每个手写方法及构造器须有简短中文说明；核心业务规则、复杂 SQL、事务、锁、幂等、并发及失败处理须补充适量中文注释，重点说明原因和边界。新增、修改方法立即执行，触及的存量代码同步整改。
+- 强制继承 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则；该节是分层、SQL 执行和方法/核心逻辑中文注释的唯一维护处，本模块不另设例外。
 
 ## 职责与边界
 

iam/AGENTS.md

@@ -2,8 +2,7 @@
 
 ## 数据库访问与中文注释约束
 
-- 强制遵守根 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则：正常业务访问统一为 `Controller → Service → Repository → Mapper`，不得省略 Repository 或跨层直调；生产 SQL 由 Mapper 执行，Repository 不得直接使用 JdbcTemplate 或原生 JDBC。非 HTTP 入口从 Service 进入；无数据库模块不引入数据库访问。
-- 每个手写方法及构造器须有简短中文说明；核心业务规则、复杂 SQL、事务、锁、幂等、并发及失败处理须补充适量中文注释，重点说明原因和边界。新增、修改方法立即执行，触及的存量代码同步整改。
+- 强制继承 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则；该节是分层、SQL 执行和方法/核心逻辑中文注释的唯一维护处，本模块不另设例外。
 
 ## 职责与边界
 

integration-service/AGENTS.md

@@ -2,8 +2,7 @@
 
 ## 数据库访问与中文注释约束
 
-- 强制遵守根 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则：正常业务访问统一为 `Controller → Service → Repository → Mapper`，不得省略 Repository 或跨层直调；生产 SQL 由 Mapper 执行，Repository 不得直接使用 JdbcTemplate 或原生 JDBC。非 HTTP 入口从 Service 进入；无数据库模块不引入数据库访问。
-- 每个手写方法及构造器须有简短中文说明；核心业务规则、复杂 SQL、事务、锁、幂等、并发及失败处理须补充适量中文注释，重点说明原因和边界。新增、修改方法立即执行，触及的存量代码同步整改。
+- 强制继承 `../AGENTS.md` 的“数据库访问与中文代码注释”全部规则；该节是分层、SQL 执行和方法/核心逻辑中文注释的唯一维护处，本模块不另设例外。
 
 ## 职责与边界
 

lastleg-service/src/main/java/com/baiyue/lastleg/controller/LastlegOrderController.java

@@ -91,6 +91,15 @@ public class LastlegOrderController {
         return ApiResponse.success(orderService.page(platformScope(user, customerId), query, relabelNo));
     }
 
+    /** 按主列表完整筛选读取仓储转运数量，保持同一平台客户边界和列表权限。 */
+    @GetMapping("/api/platform/v1/last-leg/orders/warehouse-transfer-quantities")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.LAST_MILE_ORDER_LIST + "')")
+    public ApiResponse<com.baiyue.lastleg.transfer.dto.TransferQuantityTotals> transferQuantities(
+        @AuthenticationPrincipal AuthenticatedUser user, @RequestParam(required=false) String customerId,
+        @RequestParam(required=false) String relabelNo, @Valid LastlegOrderRequests.Query query) {
+        return ApiResponse.success(orderService.transferQuantityTotals(platformScope(user,customerId),query,relabelNo));
+    }
+
     /** Compatibility overload used by non-Spring callers and existing contract tests. */
     public ApiResponse<PageResult<LastlegOrderSummary>> list(
         AuthenticatedUser user, String customerId, LastlegOrderRequests.Query query) {

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

@@ -11,20 +11,22 @@ import java.util.HashSet;
 public class OutboundQuantityRepository {
     @Resource private OutboundPalletItemMapper pallets;
 
-    /** 废弃退货来源依据已冻结箱唛计数，读取已有单据也不会把件数当箱数。 */
+    /** 废弃来源依据已冻结箱唛去重计数，无箱唛的库存明细保留箱数快照。 */
     public Integer boxes(OutboundOrder outbound) {
         if (!"DISCARD_OUTBOUND".equals(outbound.getOutboundType())) return outbound.getPackageCount();
         var lines = pallets.findByOutbound(outbound.getCustomerId(), outbound.getId());
         if (lines.isEmpty()) return outbound.getPackageCount();
-        var returnBoxes = new HashSet<String>();
+        var markedBoxes = new HashSet<String>();
         int count = 0;
         for (var line : lines) {
-            if (line.getReturnSkuQuantity() != null && line.getCartonMarks() != null && !line.getCartonMarks().isBlank()) {
-                returnBoxes.add(line.getInboundCode() + ":" + line.getCartonMarks());
+            if (line.getCartonMarks() != null && !line.getCartonMarks().isBlank()) {
+                // 同一箱的多个 SKU 共用箱唛，只计一个实物箱；一行也可能冻结多个箱唛。
+                java.util.Arrays.stream(line.getCartonMarks().split(",")).map(String::trim)
+                    .filter(mark -> !mark.isEmpty()).forEach(markedBoxes::add);
             } else {
                 count = Math.addExact(count, java.util.Objects.requireNonNullElse(line.getPackageCount(), 0));
             }
         }
-        return Math.addExact(count, returnBoxes.size());
+        return Math.addExact(count, markedBoxes.size());
     }
 }

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

@@ -130,6 +130,7 @@ public class DeliveryTransferService {
     @Resource private DeliveryExecutionGuard deliveryExecution;
     @Resource private com.baiyue.lastleg.dispatch.port.DispatchExecutionPort execution;
     @Resource private com.baiyue.lastleg.delivery.repository.DeliveryCancellationRepository cancellations;
+    @Resource private com.baiyue.lastleg.delivery.repository.OutboundQuantityRepository outboundQuantities;
 
     @Transactional
     public DeliveryResponses.PdaTask createOneClick(String customerId, String operatorId, DeliveryRequests.OneClickOutbound request) {
@@ -596,12 +597,19 @@ public class DeliveryTransferService {
             if (application == null || !RelabelApplicationService.READY_FOR_OUTBOUND.equals(application.getStatus())) {
                 throw conflict("换标单尚未完成客户确认或已不可出库");
             }
+            if (relabelSnapshotMarks(item, selectedPosition.getId(), application.getRelabelNo()).isEmpty())
+                throw conflict("换标出库指定位置或箱唛快照不完整，请核对原申请");
             List<RelabelItem> sourceItems = relabelItems.selectList(new LambdaQueryWrapper<RelabelItem>()
                 .eq(RelabelItem::getApplicationId, application.getId())
                 .eq(RelabelItem::getCustomerId, customerId)
                 .eq(RelabelItem::getSourceInventoryPositionId, request.inventoryPositionId()));
             long sourcePackages = sourceItems.stream().mapToLong(source -> value(source.getNotifiedPackageCount())).sum();
-            if (sourcePackages != request.packages()) throw conflict("换标出库来源库存快照与任务箱数不一致");
+            List<String> sourceMarks = sourceItems.stream().map(RelabelItem::getCartonMark)
+                .filter(StringUtils::hasText).distinct().sorted().toList();
+            Set<String> sourceIds = sourceItems.stream().map(source -> String.valueOf(source.getId())).collect(Collectors.toSet());
+            if (sourcePackages != request.packages() || !sourceMarks.equals(expectedMarks)
+                || !sourceIds.equals(relabelSnapshotItemIds(item)))
+                throw conflict("换标出库来源库存快照与任务箱数或箱唛不一致");
             int releaseIndex = 0;
             for (RelabelItem source : sourceItems) {
                 inventoryCommands.release(customerId, operatorId, new InventoryCommandRequests.Move(
@@ -719,6 +727,7 @@ public class DeliveryTransferService {
         return taskResult(outbound, task);
     }
 
+    /** 扫描整托前核平全部指定来源，任一不足时不执行部分拣货。 */
     @Transactional
     public DeliveryResponses.PdaTask pdaPickPallet(String warehouseId, String operatorId, String taskNo,
                                                     String palletNo, DeliveryRequests.PdaPalletPick request) {
@@ -768,7 +777,7 @@ public class DeliveryTransferService {
             long remaining = value(item.getPackageCount()) - value(item.getPickedPackageCount());
             if (remaining <= 0) continue;
             Map<Long, List<DeliveryResponses.PdaPickPosition>> positionsById = pdaPickPositions(
-                task.getCustomerId(), boundWarehouseId, item).stream().collect(Collectors.groupingBy(
+                task.getCustomerId(), boundWarehouseId, item, outbound.getOutboundType()).stream().collect(Collectors.groupingBy(
                     DeliveryResponses.PdaPickPosition::inventoryPositionId, LinkedHashMap::new, Collectors.toList()));
             for (Map.Entry<Long, List<DeliveryResponses.PdaPickPosition>> entry : positionsById.entrySet()) {
                 if (remaining <= 0) break;
@@ -1048,6 +1057,7 @@ public class DeliveryTransferService {
             .map(task -> taskResult(requireOutboundInWarehouse(task, boundWarehouseId), task)).toList();
     }
 
+    /** PDA明细展示与整托拣货使用相同的客户、仓库及来源投影。 */
     public DeliveryResponses.PdaTaskDetail pdaTaskDetail(String warehouseId, String taskNo) {
         String boundWarehouseId = required(warehouseId, "PDA warehouse binding is required");
         OutboundPdaTask task = pdaTasks.findByNoAndWarehouse(required(taskNo, "PDA task number is required"),
@@ -1060,7 +1070,7 @@ public class DeliveryTransferService {
                 value(item.getPickedPackageCount()), item.getStatus(),
                 ("RETURN_OUTBOUND".equals(outbound.getOutboundType())
                     || ("RELABEL_OUTBOUND".equals(outbound.getOutboundType()) && item.getWarehousePalletId() == null)) ? returnPickPositions(outbound, task, item)
-                    : pdaPickPositions(task.getCustomerId(), boundWarehouseId, item), item.getReturnSkuQuantity())).toList();
+                    : pdaPickPositions(task.getCustomerId(), boundWarehouseId, item, outbound.getOutboundType()), item.getReturnSkuQuantity())).toList();
         return new DeliveryResponses.PdaTaskDetail(taskResult(outbound, task), items);
     }
 
@@ -1118,13 +1128,28 @@ public class DeliveryTransferService {
                 && value(item.getPickedPackageCount()) == 0 && "OUTBOUND_PENDING".equals(carton.getStatus()) ? 1 : 0, value(item.getPickedPackageCount())));
     }
 
+    /** 换标使用指定实物箱及仍归本单的冻结库存；普通出库继续按可用库存和SKU匹配。 */
     private List<DeliveryResponses.PdaPickPosition> pdaPickPositions(String customerId, String warehouseId,
-                                                                      OutboundPalletItem item) {
+                                                                      OutboundPalletItem item, String outboundType) {
         if (item.getWarehousePalletId() == null) return List.of();
         List<DeliveryResponses.PdaPickPosition> result = new ArrayList<>();
         Set<String> frozenMarks = new HashSet<>(Arrays.asList(
             Optional.ofNullable(item.getCartonMarks()).orElse("").split(",")));
         for (InventoryPosition position : inventoryPositions.listPallet(customerId, item.getWarehousePalletId())) {
+            if ("RELABEL_OUTBOUND".equals(outboundType)) {
+                List<String> marks = relabelSnapshotMarks(item, position.getId(), null);
+                InventoryBalance balance = inventoryBalances.selectById(position.getBalanceId());
+                if (marks.isEmpty() || !customerId.equals(position.getCustomerId())
+                    || !warehouseId.equals(position.getOverseasWarehouseId())
+                    || !Objects.equals(item.getWarehousePalletId(), position.getPalletId())
+                    || balance == null || !customerId.equals(balance.getCustomerId())
+                    || !warehouseId.equals(balance.getOverseasWarehouseId())
+                    || !Objects.equals(item.getInboundCode(), balance.getInboundCode())
+                    || value(position.getHoldPackages()) < marks.size()) continue;
+                // 本单冻结箱先在写路径校验原申请和来源任务，再释放、分配、拣货、出库；不把其他可用箱混入。
+                for (String mark : marks) result.add(pdaPosition(position, item, balance, mark, 1, 0));
+                continue;
+            }
             long available = value(position.getAvailablePackages());
             if (available <= 0 || !warehouseId.equals(position.getOverseasWarehouseId())) continue;
             InventoryBalance balance = inventoryBalances.selectById(position.getBalanceId());
@@ -1146,6 +1171,37 @@ public class DeliveryTransferService {
         return result;
     }
 
+    /** 仅接受完整的换标出库快照；空SKU不是通配符，必须精确匹配返工后冻结的位置和全部箱唛。 */
+    private List<String> relabelSnapshotMarks(OutboundPalletItem item, Long positionId, String expectedRelabelNo) {
+        try {
+            var refs = objectMapper.readTree(item.getOrderRefs());
+            if (!"RELABEL_ORDER".equals(refs.path("sourceType").asText())
+                || !StringUtils.hasText(refs.path("relabelNo").asText())
+                || expectedRelabelNo != null && !expectedRelabelNo.equals(refs.path("relabelNo").asText())
+                || positionId == null || !String.valueOf(positionId).equals(refs.path("sourceInventoryPositionId").asText())
+                || !refs.path("items").isArray()) return List.of();
+            var marks = new TreeSet<String>(); var ids = new HashSet<String>(); long packages = 0;
+            for (var line : refs.path("items")) {
+                String mark = line.path("cartonMark").asText().trim(), id = line.path("itemId").asText();
+                long count = line.path("packages").asLong();
+                if (!StringUtils.hasText(mark) || !StringUtils.hasText(id) || !ids.add(id) || !marks.add(mark) || count != 1) return List.of();
+                packages += count;
+            }
+            var frozen = Arrays.stream(Objects.toString(item.getCartonMarks(), "").split(","))
+                .map(String::trim).filter(StringUtils::hasText).collect(Collectors.toCollection(TreeSet::new));
+            return packages == value(item.getPackageCount()) && marks.equals(frozen) ? List.copyOf(marks) : List.of();
+        } catch (Exception ignored) { return List.of(); }
+    }
+
+    /** 释放冻结前核对快照任务主键与本申请当前位置的真实任务集合完全相同。 */
+    private Set<String> relabelSnapshotItemIds(OutboundPalletItem item) {
+        try {
+            var ids = new HashSet<String>();
+            for (var line : objectMapper.readTree(item.getOrderRefs()).path("items")) ids.add(line.path("itemId").asText());
+            return ids;
+        } catch (Exception ignored) { return Set.of(); }
+    }
+
     private DeliveryResponses.PdaPickPosition pdaPosition(InventoryPosition position, OutboundPalletItem item,
                                                             InventoryBalance balance, String cartonMark,
                                                             long available, long picked) {
@@ -1341,7 +1397,11 @@ public class DeliveryTransferService {
         } catch (JsonProcessingException exception) { throw new IllegalStateException("费用覆盖确认无法读取", exception); }
     }
 
-    private DeliveryResponses.OutboundRow outboundRow(OutboundOrder o) { return new DeliveryResponses.OutboundRow(o.getId(), o.getOutboundNo(), o.getDispatchNo(), o.getOverseasWarehouseId(), "DISCARD_OUTBOUND".equals(o.getOutboundType()) ? null : o.getLxCodes(), o.getStatus(), o.getPalletCount(), o.getPackageCount(), o.getGrossWeightKg(), o.getVolumeWeightKg(), o.getVolumeCbm(), o.getCreatedAt(), o.getOutboundType()); }
+    /** 废弃出库按冻结实物箱汇总，避免历史件数快照被展示为箱数。 */
+    private DeliveryResponses.OutboundRow outboundRow(OutboundOrder o) {
+        Integer boxes = "DISCARD_OUTBOUND".equals(o.getOutboundType()) ? outboundQuantities.boxes(o) : o.getPackageCount();
+        return new DeliveryResponses.OutboundRow(o.getId(), o.getOutboundNo(), o.getDispatchNo(), o.getOverseasWarehouseId(), "DISCARD_OUTBOUND".equals(o.getOutboundType()) ? null : o.getLxCodes(), o.getStatus(), o.getPalletCount(), boxes, o.getGrossWeightKg(), o.getVolumeWeightKg(), o.getVolumeCbm(), o.getCreatedAt(), o.getOutboundType());
+    }
     private DeliveryResponses.OutboundPalletRow outboundPalletRow(OutboundPalletItem item) {
         return new DeliveryResponses.OutboundPalletRow(item.getId(), item.getPalletNo(), item.getCartonMarks(),
             item.getInboundCode(), item.getDestinationWarehouseCode(), item.getDestinationWarehouseName(),

lastleg-service/src/main/java/com/baiyue/lastleg/discard/controller/CargoDiscardController.java

@@ -46,6 +46,14 @@ public class CargoDiscardController {
         return ApiResponse.success(service.page(scope(user, customerId), query));
     }
 
+    /** 读取全部筛选结果的数量统计，与分页记录分开返回。 */
+    @GetMapping("/statistics")
+    public ApiResponse<com.baiyue.lastleg.discard.service.CargoDiscardStatisticsService.Statistics> statistics(
+        @AuthenticationPrincipal AuthenticatedUser user, @RequestParam(required = false) String customerId,
+        @Valid CargoDiscardRequests.Query query) {
+        return ApiResponse.success(service.statistics(scope(user, customerId), query));
+    }
+
     @GetMapping("/{discardNo}")
     public ApiResponse<CargoDiscardResponses.Detail> detail(@AuthenticationPrincipal AuthenticatedUser user,
         @RequestParam(required = false) String customerId, @PathVariable String discardNo) {

lastleg-service/src/main/java/com/baiyue/lastleg/discard/controller/MerchantCargoDiscardController.java

@@ -32,6 +32,14 @@ public class MerchantCargoDiscardController {
     @PreAuthorize("hasAuthority('" + OverseasPermissions.MERCHANT_DISCARD_LIST + "')")
     public ApiResponse<PageResult<CargoDiscardResponses.Summary>> page(@AuthenticationPrincipal AuthenticatedUser user,
         @Valid CargoDiscardRequests.Query query) { return ApiResponse.success(service.page(customer(user), query)); }
+    /** 客户统计只读取当前认证客户，不接受客户端客户归属。 */
+    @GetMapping("/statistics")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.MERCHANT_DISCARD_LIST + "')")
+    public ApiResponse<com.baiyue.lastleg.discard.service.CargoDiscardStatisticsService.Statistics> statistics(
+        @AuthenticationPrincipal AuthenticatedUser user, @Valid CargoDiscardRequests.Query query) {
+        return ApiResponse.success(service.statistics(customer(user), query));
+    }
+
     @GetMapping("/{discardNo}")
     @PreAuthorize("hasAuthority('" + OverseasPermissions.MERCHANT_DISCARD_LIST + "')")
     public ApiResponse<CargoDiscardResponses.Detail> detail(@AuthenticationPrincipal AuthenticatedUser user,

lastleg-service/src/main/java/com/baiyue/lastleg/discard/dto/CargoDiscardRequests.java

@@ -33,5 +33,6 @@ public final class CargoDiscardRequests {
 
     public record Query(@Min(1) long page, @Min(1) @Max(200) long size,
                         String discardNo, String inboundCode, String overseasWarehouseId,
-                        String status, LocalDateTime createdFrom, LocalDateTime createdTo) {}
+                        String status, LocalDateTime createdFrom, LocalDateTime createdTo,
+                        LocalDateTime completedFrom, LocalDateTime completedTo) {}
 }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/dto/CargoDiscardResponses.java

@@ -29,15 +29,24 @@ public final class CargoDiscardResponses {
         }
     }
     public record Box(Long cartonId, String cartonMark, String palletNo, List<CandidateSku> skus) {}
-    public record CandidateSku(String skuCode, String productName, long availablePackages) {}
+    public record CandidateSku(String skuCode, String productName, long availablePackages, Long availablePieces) {
+        /** 无件数事实时保留未知，不按箱规推算。 */
+        public CandidateSku(String skuCode, String productName, long availablePackages) { this(skuCode, productName, availablePackages, null); }
+    }
 
     public record Summary(Long id, String customerId, String discardNo, String inboundCodes,
                           String overseasWarehouseId, String overseasWarehouseName,
                           int totalPackages, BigDecimal totalFee, String currency, String status,
-                          String createdBy, LocalDateTime createdAt, LocalDateTime reviewedAt, String outboundNo, LocalDateTime customerConfirmedAt) {}
+                          String createdBy, LocalDateTime createdAt, LocalDateTime reviewedAt, String outboundNo, LocalDateTime customerConfirmedAt,
+                          List<String> skuCodes, int skuCount, int requestedPackages, Integer actualPackages) {}
 
     public record Item(Long id, Long orderId, String inboundCode, String skuCode,
-                       String productName, int availablePackagesSnapshot, int discardPackages, List<String> cartonMarks) {
+                       String productName, int availablePackagesSnapshot, int discardPackages, List<String> cartonMarks,
+                       String quantityUnit, Integer actualDiscardPackages, String pdaStatus) {
+        /** 无来源事实的调用不猜测数量单位或实际完成数。 */
+        public Item(Long id, Long orderId, String inboundCode, String skuCode, String productName, int availablePackagesSnapshot, int discardPackages, List<String> cartonMarks) {
+            this(id, orderId, inboundCode, skuCode, productName, availablePackagesSnapshot, discardPackages, cartonMarks, null, null, null);
+        }
         public Item(Long id, Long orderId, String inboundCode, String skuCode, String productName, int availablePackagesSnapshot, int discardPackages) {
             this(id, orderId, inboundCode, skuCode, productName, availablePackagesSnapshot, discardPackages, List.of());
         }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/mapper/CargoDiscardDimensionMapper.java

@@ -0,0 +1,33 @@
+package com.baiyue.lastleg.discard.mapper;
+
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+import java.util.List;
+
+/** 只读取废弃明细真实关联的本库托盘身份。 */
+@Mapper
+public interface CargoDiscardDimensionMapper {
+    /** 无托盘事实以空串保留，避免把不适用维度伪造为零。 */
+    @Select("""
+        SELECT COALESCE(CASE WHEN i.return_carton_id IS NOT NULL THEN r.pallet_code
+            WHEN i.inventory_position_id IS NOT NULL THEN p.pallet_no ELSE d.pallet_no END,'')
+          FROM ll_cargo_discard_item i
+          LEFT JOIN ll_return_inventory_carton r ON r.id=i.return_carton_id AND r.customer_id=i.customer_id
+          LEFT JOIN ll_inventory_position p ON p.id=i.inventory_position_id AND p.customer_id=i.customer_id
+          LEFT JOIN ll_dropship_order_profile d ON d.id=i.profile_id AND d.customer_id=i.customer_id
+         WHERE i.customer_id=#{customerId} AND i.application_id=#{applicationId}
+        """)
+    List<String> palletNos(@Param("customerId") String customerId, @Param("applicationId") Long applicationId);
+
+    /** 仅读取所选转运实收箱的真实件数，其他来源保留未知。 */
+    @Select("""
+        SELECT CASE WHEN l.source_type='TRANSFER' THEN c.sku_items_json ELSE NULL END
+          FROM ll_cargo_discard_item i
+          JOIN ll_cargo_discard_carton l ON l.customer_id=i.customer_id AND l.application_id=i.application_id
+           AND (l.item_id=i.id OR (i.source_type='INVENTORY' AND JSON_CONTAINS(i.carton_marks_json,JSON_QUOTE(l.carton_mark))))
+          LEFT JOIN ll_warehouse_transfer_carton c ON c.id=l.carton_id AND c.customer_id=l.customer_id
+         WHERE i.customer_id=#{customerId} AND i.id=#{itemId}
+        """)
+    List<String> selectedCartonPieces(@Param("customerId") String customerId, @Param("itemId") Long itemId);
+}

lastleg-service/src/main/java/com/baiyue/lastleg/discard/mapper/CargoDiscardInventoryMapper.java

@@ -25,26 +25,27 @@ public interface CargoDiscardInventoryMapper {
     @Select("SELECT p.* FROM ll_inventory_position p WHERE p.customer_id=#{customerId} AND p.id=#{positionId} FOR UPDATE")
     com.baiyue.lastleg.inventory.entity.InventoryPosition lockGenericPosition(@Param("customerId") String customerId, @Param("positionId") Long positionId);
 
+    /** 按实收托盘关联已清点箱；混装物理余额允许箱内不同 SKU，仍严格限定客户、批次、仓和托盘。 */
     @Select("""
-        SELECT c.id,c.carton_mark,c.sku_code,'INBOUND' source_type
+        SELECT c.id,c.carton_mark,c.sku_code,'INBOUND' source_type,NULL sku_items_json
           FROM ll_inbound_plan_carton c
           JOIN ll_inventory_balance b ON b.customer_id=c.customer_id AND b.inbound_order_id=c.order_id
           JOIN ll_inventory_position p ON p.customer_id=b.customer_id AND p.balance_id=b.id AND p.pallet_id=c.warehouse_pallet_id
          WHERE p.customer_id=#{customerId} AND p.id=#{positionId} AND c.status='AVAILABLE' AND c.received_at IS NOT NULL
            AND COALESCE(b.destination_warehouse_code,'')=COALESCE(c.destination_warehouse_code,'')
         UNION ALL
-        SELECT c.id,c.carton_mark,i.sku_code,'TRANSFER' source_type
+        SELECT c.id,c.carton_mark,i.sku_code,'TRANSFER' source_type,c.sku_items_json
           FROM ll_inventory_position p
           JOIN ll_inventory_balance b ON b.customer_id=p.customer_id AND b.id=p.balance_id
           JOIN ll_warehouse_transfer_order t ON t.customer_id=p.customer_id AND t.inbound_order_id=b.inbound_order_id
              AND t.transfer_no=p.batch_no AND t.operating_warehouse_id=p.overseas_warehouse_id
-          JOIN ll_warehouse_transfer_carton c ON c.customer_id=t.customer_id AND c.transfer_order_id=t.id AND c.status='EXPECTED'
+          JOIN ll_warehouse_transfer_pallet tp ON tp.customer_id=t.customer_id AND tp.transfer_order_id=t.id
+             AND tp.warehouse_pallet_id=p.pallet_id AND tp.status='COMPLETED'
+          JOIN ll_warehouse_transfer_carton c ON c.customer_id=t.customer_id AND c.transfer_order_id=t.id
+             AND c.transfer_pallet_id=tp.id AND c.status='COUNTED'
           JOIN ll_warehouse_transfer_item i ON i.customer_id=c.customer_id AND i.id=c.transfer_item_id
+             AND i.transfer_order_id=t.id AND (b.sku_code='MIXED' OR COALESCE(i.sku_code,'')=COALESCE(b.sku_code,''))
          WHERE p.customer_id=#{customerId} AND p.id=#{positionId}
-           AND (SELECT COUNT(*) FROM ll_inventory_position current_position
-                 WHERE current_position.customer_id=p.customer_id AND current_position.balance_id=p.balance_id
-                   AND current_position.batch_no=p.batch_no AND current_position.overseas_warehouse_id=p.overseas_warehouse_id
-                   AND current_position.available_packages+current_position.hold_packages+current_position.allocated_packages+current_position.picked_packages>0)=1
          ORDER BY id
         """)
     List<com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow> genericCartons(@Param("customerId") String customerId, @Param("positionId") Long positionId);

lastleg-service/src/main/java/com/baiyue/lastleg/discard/model/CargoDiscardQuantities.java

@@ -12,15 +12,22 @@ public final class CargoDiscardQuantities {
     /** 退货混装箱按箱 ID 去重，其余来源累加已选择的物理箱数。 */
     public static int boxes(List<CargoDiscardItem> lines, boolean actual) {
         var returnBoxes = new HashSet<Long>();
+        var inventoryBoxes = new HashSet<String>();
         int total = 0;
         for (var line : lines) {
             int quantity = actual ? java.util.Objects.requireNonNullElse(line.getActualDiscardPackages(), 0) : line.getDiscardPackages();
             if (line.getReturnCartonId() != null) {
                 if (quantity > 0) returnBoxes.add(line.getReturnCartonId());
+            } else if ("INVENTORY".equals(line.getSourceType()) && line.getCartonMarksJson() != null && quantity > 0) {
+                try {
+                    var marks = new com.fasterxml.jackson.databind.ObjectMapper().readTree(line.getCartonMarksJson());
+                    if (!marks.isArray() || marks.size() != quantity) throw new IllegalStateException("废弃箱唛快照与数量不一致");
+                    for (var mark : marks) inventoryBoxes.add(line.getInboundCode() + ":" + mark.asText());
+                } catch (com.fasterxml.jackson.core.JsonProcessingException e) { throw new IllegalStateException("废弃箱唛快照无法读取", e); }
             } else {
                 total = Math.addExact(total, quantity);
             }
         }
-        return Math.addExact(total, returnBoxes.size());
+        return Math.addExact(Math.addExact(total, returnBoxes.size()), inventoryBoxes.size());
     }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/model/CargoDiscardReturnMark.java

@@ -0,0 +1,17 @@
+package com.baiyue.lastleg.discard.model;
+
+import com.baiyue.lastleg.returnreceipt.entity.ReturnInventoryCarton;
+
+/** 废弃作业沿用签收时实物标签，兼容历史包裹内部 RP 编号。 */
+public final class CargoDiscardReturnMark {
+    /** 工具类不允许实例化。 */
+    private CargoDiscardReturnMark() { }
+
+    /** 包裹取签收单元编码；箱子及缺少来源编码的历史数据保留原箱唛。 */
+    public static String of(ReturnInventoryCarton carton) {
+        if (carton == null) return null;
+        if ("PARCEL".equals(carton.getSourceUnitType()) && carton.getSourceUnitCode() != null
+            && !carton.getSourceUnitCode().isBlank()) return carton.getSourceUnitCode().trim();
+        return carton.getCartonMark();
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/discard/model/CargoDiscardStockCartonRow.java

@@ -9,4 +9,5 @@ public class CargoDiscardStockCartonRow {
     private String cartonMark;
     private String skuCode;
     private String sourceType;
+    private String skuItemsJson;
 }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/pda/dto/PdaCargoDiscardDtos.java

@@ -21,7 +21,8 @@ public final class PdaCargoDiscardDtos {
     }
     /** 明细数量按来源标识单位：退货库存为件，其余箱级库存为箱。 */
     public record Sku(Long itemId, String skuCode, String productName, int plannedPackages,
-                      Integer actualPackages, String status, String quantityUnit) { }
+                      Integer actualPackages, String status, String quantityUnit,
+                      boolean actualQuantityEditable) { }
     public record PalletTask(String discardNo, String customerId, String overseasWarehouseId,
                              String palletNo, Long profileId, String status, List<Sku> skus, String outboundNo,
                              String scanMode, List<String> cartonMarks) { }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/pda/service/PdaCargoDiscardService.java

@@ -1,17 +1,11 @@
 package com.baiyue.lastleg.discard.pda.service;
 
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baiyue.lastleg.discard.dto.CargoDiscardResponses;
 import com.baiyue.lastleg.discard.entity.*;
-import com.baiyue.lastleg.discard.mapper.*;
 import com.baiyue.lastleg.discard.pda.dto.PdaCargoDiscardDtos;
 import com.baiyue.lastleg.discard.service.CargoDiscardInventoryAdjustmentService;
 import com.baiyue.lastleg.discard.service.CargoDiscardService;
-import com.baiyue.lastleg.dropship.entity.DropshipOrderProfile;
-import com.baiyue.lastleg.dropship.mapper.DropshipOrderProfileMapper;
 import com.baiyue.lastleg.pda.security.PdaWarehouseIdentity;
-import com.baiyue.lastleg.returnreceipt.entity.ReturnInventoryCarton;
-import com.baiyue.lastleg.returnreceipt.mapper.ReturnInventoryCartonMapper;
 import jakarta.annotation.Resource;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
@@ -24,28 +18,24 @@ import java.util.stream.Collectors;
 @Service
 public class PdaCargoDiscardService {
     @Resource private com.baiyue.lastleg.discard.service.CargoDiscardPhotoService photoService;
-    @Resource private CargoDiscardApplicationMapper applications;
+    @Resource private com.baiyue.lastleg.discard.repository.CargoDiscardPdaRepository repository;
     @Resource private com.baiyue.lastleg.discard.service.CargoDiscardOutboundService outboundService;
-    @Resource private CargoDiscardItemMapper items;
-    @Resource private CargoDiscardCartonMapper cartons;
-    @Resource private DropshipOrderProfileMapper profiles;
     @Resource private CargoDiscardInventoryAdjustmentService adjustments;
     @Resource private CargoDiscardService discardService;
-    @Resource private ReturnInventoryCartonMapper returnCartons;
     @Resource private com.baiyue.lastleg.discard.service.CargoDiscardStockService stockService;
 
+    /** 只读取绑定仓已审核申请的实际托盘任务。 */
     public List<PdaCargoDiscardDtos.PalletTask> tasks(PdaWarehouseIdentity identity) {
-        return applications.selectList(new LambdaQueryWrapper<CargoDiscardApplication>()
-                .eq(CargoDiscardApplication::getOverseasWarehouseId, String.valueOf(identity.overseasWarehouseId()))
-                .eq(CargoDiscardApplication::getStatus, CargoDiscardService.APPROVED)
-                .orderByAsc(CargoDiscardApplication::getCreatedAt))
+        return repository.approved(String.valueOf(identity.overseasWarehouseId()))
             .stream().flatMap(a -> palletTasks(a).stream()).toList();
     }
 
+    /** 扫码读取当前仓库唯一可操作任务。 */
     public PdaCargoDiscardDtos.PalletTask resolve(PdaWarehouseIdentity identity, String palletNo) {
         return resolve(identity, palletNo, null);
     }
 
+    /** 扫码时限定已选择申请，防止同托盘多任务误操作。 */
     public PdaCargoDiscardDtos.PalletTask resolve(PdaWarehouseIdentity identity, String palletNo, String discardNo) {
         var matches = tasks(identity).stream().filter(t -> t.palletNo().equals(palletNo.trim()) || t.cartonMarks().contains(palletNo.trim()))
             .filter(t -> discardNo == null || discardNo.isBlank() || t.discardNo().equals(discardNo.trim())).toList();
@@ -54,10 +44,11 @@ public class PdaCargoDiscardService {
             .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "该仓库没有此托盘的待废弃任务"));
     }
 
+    /** 仓库按无箱唛对应任务的实点数结算，其余任务继续核平所选箱。 */
     @Transactional
     public PdaCargoDiscardDtos.PalletTask confirm(PdaWarehouseIdentity identity, String discardNo,
                                                    String palletNo, PdaCargoDiscardDtos.Confirm request) {
-        CargoDiscardApplication application = applications.findNoByWarehouse(discardNo,
+        CargoDiscardApplication application = repository.lockApplication(discardNo,
             String.valueOf(identity.overseasWarehouseId()));
         if (application == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "废弃任务不存在或不属于当前仓库");
         boolean terminal = CargoDiscardService.PDA_COMPLETED.equals(application.getStatus())
@@ -71,8 +62,12 @@ public class PdaCargoDiscardService {
         if (!actuals.keySet().equals(task.skus().stream().map(PdaCargoDiscardDtos.Sku::itemId).collect(Collectors.toSet()))) {
             throw conflict("必须提交该托盘全部 SKU 的实际废弃数量");
         }
-        if (task.skus().stream().anyMatch(line -> !Objects.equals(actuals.get(line.itemId()), line.plannedPackages())))
-            throw conflict("必须完成本次废弃单所选全部箱子，不能漏出");
+        for (var line : task.skus()) {
+            int actual = actuals.get(line.itemId());
+            if (actual < 0 || actual > line.plannedPackages()) throw conflict("实际废弃数量不能超过申请预留数量");
+            if (!line.actualQuantityEditable() && actual != line.plannedPackages())
+                throw conflict("必须完成本次废弃单所选全部箱子，不能漏出");
+        }
         if ("CARTON".equals(task.scanMode()) && !Boolean.TRUE.equals(request.confirmAllCartons())) {
             var scanned = request.scannedCartonMarks() == null ? List.<String>of() : request.scannedCartonMarks();
             if (scanned.size() != task.cartonMarks().size() || !new HashSet<>(scanned).equals(new HashSet<>(task.cartonMarks())))
@@ -80,7 +75,7 @@ public class PdaCargoDiscardService {
         }
         List<CargoDiscardItem> palletItems = new ArrayList<>();
         for (PdaCargoDiscardDtos.Sku line : task.skus()) {
-            CargoDiscardItem item = items.selectById(line.itemId());
+            CargoDiscardItem item = repository.item(line.itemId());
             if (item == null || !application.getCustomerId().equals(item.getCustomerId())
                 || !Objects.equals(application.getId(), item.getApplicationId())
                 || !physicalCode(application, item).equals(task.palletNo()))
@@ -90,14 +85,14 @@ public class PdaCargoDiscardService {
                 throw conflict("已完成托盘的实际数量不能修改");
             palletItems.add(item);
         }
-        if (terminal && items.listApplication(application.getCustomerId(), application.getId()).stream()
+        if (terminal && repository.items(application.getCustomerId(), application.getId()).stream()
             .anyMatch(item -> !"COMPLETED".equals(item.getPdaStatus())
                 || !application.getCustomerId().equals(item.getCustomerId())
                 || !Objects.equals(application.getId(), item.getApplicationId())))
             throw conflict("废弃申请终态存在未完成明细，不能恢复作业结果");
         photoService.confirm(application, task.palletNo(), request.photoFileIds(),
             palletItems.stream().allMatch(item -> "COMPLETED".equals(item.getPdaStatus())));
-        // A completed pallet is an immutable result, including the final pallet after application completion.
+        // 已完成托盘保持原始实点结果，终态重放不得再次扣减或释放库存。
         if (palletItems.stream().allMatch(item -> "COMPLETED".equals(item.getPdaStatus()))) return task;
         if (terminal) throw conflict("废弃终态不能执行未完成托盘");
         LocalDateTime now = LocalDateTime.now();
@@ -105,20 +100,25 @@ public class PdaCargoDiscardService {
             if ("COMPLETED".equals(item.getPdaStatus())) {
                 continue;
             }
-            List<CargoDiscardCarton> links = cartons.listApplication(application.getCustomerId(), application.getId()).stream()
+            List<CargoDiscardCarton> links = repository.cartons(application.getCustomerId(), application.getId()).stream()
                 .filter(c -> c.getItemId().equals(item.getId())).toList();
-            adjustments.discardPalletItem(application.getCustomerId(), application, item, links,
-                actuals.get(item.getId()), identity.operatorKey(), now);
+            // 未知箱唛对应关系时只按当前仓位冻结桶结算，不猜测被废弃的具体箱唛。
+            if ("INVENTORY".equals(item.getSourceType()) && stockService.actualQuantityEditable(item)) {
+                stockService.discard(application.getCustomerId(), identity.operatorKey(), application, item, actuals.get(item.getId()));
+            } else {
+                adjustments.discardPalletItem(application.getCustomerId(), application, item, links,
+                    actuals.get(item.getId()), identity.operatorKey(), now);
+            }
             item.setActualDiscardPackages(actuals.get(item.getId())); item.setPdaStatus("COMPLETED");
-            item.setPdaOperatorId(identity.operatorKey()); item.setPdaCompletedAt(now); items.updateById(item);
+            item.setPdaOperatorId(identity.operatorKey()); item.setPdaCompletedAt(now); repository.saveItem(item);
         }
-        task.skus().stream().map(PdaCargoDiscardDtos.Sku::itemId).map(items::selectById)
+        task.skus().stream().map(PdaCargoDiscardDtos.Sku::itemId).map(repository::item)
             .filter(this::isReturnItem).map(CargoDiscardItem::getReturnCartonId).filter(Objects::nonNull).distinct()
             .forEach(cartonId -> adjustments.finishReturnCarton(application.getCustomerId(), cartonId));
-        if (items.listApplication(application.getCustomerId(), application.getId()).stream()
+        if (repository.items(application.getCustomerId(), application.getId()).stream()
             .allMatch(i -> "COMPLETED".equals(i.getPdaStatus()))) {
             int actualTotal = com.baiyue.lastleg.discard.model.CargoDiscardQuantities.boxes(
-                items.listApplication(application.getCustomerId(), application.getId()), true);
+                repository.items(application.getCustomerId(), application.getId()), true);
             application.setTotalPackages(actualTotal);
             application.setTotalFee(application.getFeePerPackage().multiply(java.math.BigDecimal.valueOf(actualTotal)));
             discardService.updateLinkedStatus(application.getCustomerId(), application, CargoDiscardService.APPROVED,
@@ -130,6 +130,7 @@ public class PdaCargoDiscardService {
     }
 
     @Transactional
+    /** 当前申请行锁内保存现场照片，已完成托盘禁止补写。 */
     public CargoDiscardResponses.Photo uploadPhoto(PdaWarehouseIdentity identity, String discardNo, String palletNo,
                                                    long operatorUserId, org.springframework.web.multipart.MultipartFile file) {
         CargoDiscardApplication application = photoApplication(identity, discardNo, palletNo, true);
@@ -140,19 +141,22 @@ public class PdaCargoDiscardService {
     }
 
     @Transactional(readOnly = true)
+    /** 读取绑定仓当前托盘的照片。 */
     public List<CargoDiscardResponses.Photo> photos(PdaWarehouseIdentity identity, String discardNo, String palletNo) {
         return photoService.list(photoApplication(identity, discardNo, palletNo, false), palletNo.trim(), false);
     }
 
     @Transactional(readOnly = true)
+    /** 下载当前申请和托盘拥有的照片。 */
     public com.baiyue.lastleg.discard.gateway.CargoDiscardPhotoFileGateway.DownloadedFile downloadPhoto(
         PdaWarehouseIdentity identity, String discardNo, String palletNo, long fileId) {
         return photoService.download(photoApplication(identity, discardNo, palletNo, false), palletNo.trim(), fileId, false);
     }
 
+    /** 照片访问必须同时满足绑定仓和申请托盘范围。 */
     private CargoDiscardApplication photoApplication(PdaWarehouseIdentity identity, String discardNo, String palletNo, boolean lock) {
         var warehouseId = String.valueOf(identity.overseasWarehouseId());
-        var application = lock ? applications.findNoByWarehouse(discardNo, warehouseId) : applications.readNoByWarehouse(discardNo, warehouseId);
+        var application = lock ? repository.lockApplication(discardNo, warehouseId) : repository.readApplication(discardNo, warehouseId);
         if (application == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "废弃任务不存在或不属于当前仓库");
         if (palletTasks(application).stream().noneMatch(t -> t.palletNo().equals(palletNo.trim())))
             throw new ResponseStatusException(HttpStatus.NOT_FOUND, "托盘不属于该废弃单");
@@ -162,13 +166,13 @@ public class PdaCargoDiscardService {
     private static final String LOOSE = "散箱";
     /** 按实托汇总本单所选箱唛，退货件数与物理箱数分别呈现。 */
     private List<PdaCargoDiscardDtos.PalletTask> palletTasks(CargoDiscardApplication application) {
-        var allItems = items.listApplication(application.getCustomerId(), application.getId());
+        var allItems = repository.items(application.getCustomerId(), application.getId());
         var grouped = allItems.stream().collect(Collectors.groupingBy(i -> physicalCode(application, i), LinkedHashMap::new, Collectors.toList()));
         return grouped.entrySet().stream().map(entry -> {
             CargoDiscardItem first = entry.getValue().get(0);
             var skus = entry.getValue().stream().map(i -> new PdaCargoDiscardDtos.Sku(i.getId(), i.getSkuCode(), i.getProductName(),
                 i.getDiscardPackages(), i.getActualDiscardPackages(), i.getPdaStatus() == null ? "PENDING" : i.getPdaStatus(),
-                isReturnItem(i) ? "件" : "箱")).toList();
+                isReturnItem(i) ? "件" : "箱", "INVENTORY".equals(i.getSourceType()) && stockService.actualQuantityEditable(i))).toList();
             String status = skus.stream().allMatch(i -> "COMPLETED".equals(i.status())) ? "COMPLETED" : "PENDING";
             var marks = entry.getValue().stream().flatMap(i -> cartonMarks(application, i).stream()).distinct().sorted().toList();
             // 退货箱只代表本单选择的箱子，不能因为有托盘号就当成整托废弃。
@@ -180,6 +184,7 @@ public class PdaCargoDiscardService {
                 status, skus, outboundService.outboundNo(application), cartonScan ? "CARTON" : "PALLET", marks);
         }).toList();
     }
+    /** 相关托盘只从客户库存事实读取，不从请求推断。 */
     private String physicalCode(CargoDiscardApplication application, CargoDiscardItem item) {
         String code;
         if ("INVENTORY".equals(item.getSourceType())) {
@@ -187,30 +192,35 @@ public class PdaCargoDiscardService {
             if (!application.getOverseasWarehouseId().equals(position.getOverseasWarehouseId())) throw conflict("废弃库存不属于当前仓库");
             code = position.getPalletNo();
         } else if (isReturnItem(item)) {
-            var carton = returnCartons.selectById(item.getReturnCartonId());
+            var carton = repository.returnCarton(item.getReturnCartonId());
             if (carton == null || !application.getCustomerId().equals(carton.getCustomerId())) throw conflict("废弃明细关联退货箱不存在");
             code = carton.getPalletCode();
         } else {
-            var profile = profiles.selectById(item.getProfileId());
+            var profile = repository.profile(item.getProfileId());
             if (profile == null || !application.getCustomerId().equals(profile.getCustomerId())) throw conflict("废弃明细关联托盘不存在");
             code = profile.getPalletNo();
         }
         return code == null || code.isBlank() ? LOOSE : code.trim();
     }
+    /** 仅返回保存的真实箱唛，未知对应关系不补造箱码。 */
     private List<String> cartonMarks(CargoDiscardApplication application, CargoDiscardItem item) {
         if ("INVENTORY".equals(item.getSourceType())) return stockService.cartonMarks(item);
         if (isReturnItem(item)) {
-            var carton = returnCartons.selectById(item.getReturnCartonId());
-            return carton.getCartonMark() == null ? List.of() : List.of(carton.getCartonMark());
+            var carton = repository.returnCarton(item.getReturnCartonId());
+            String mark = com.baiyue.lastleg.discard.model.CargoDiscardReturnMark.of(carton);
+            return mark == null ? List.of() : List.of(mark);
         }
-        return cartons.listApplication(application.getCustomerId(), application.getId()).stream()
+        return repository.cartons(application.getCustomerId(), application.getId()).stream()
             .filter(c -> Objects.equals(c.getItemId(), item.getId())).map(CargoDiscardCarton::getCartonMark).filter(Objects::nonNull).toList();
     }
+    /** 退货库存沿用独立按件结算规则。 */
     private boolean isReturnItem(CargoDiscardItem item) {
         return "RETURN_CARTON".equals(item.getSourceType()) || item.getReturnCartonId() != null;
     }
+    /** 取首个有效业务展示值。 */
     private static String firstNonBlank(String first, String second) {
         return first != null && !first.isBlank() ? first : second;
     }
+    /** 返回可恢复业务冲突。 */
     private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT, message); }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/repository/CargoDiscardDimensionRepository.java

@@ -0,0 +1,40 @@
+package com.baiyue.lastleg.discard.repository;
+
+import com.baiyue.lastleg.discard.entity.CargoDiscardItem;
+import com.baiyue.lastleg.discard.mapper.CargoDiscardItemMapper;
+import com.baiyue.lastleg.discard.mapper.CargoDiscardDimensionMapper;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+
+/** 封装数量统计的明细与来源托盘读取。 */
+@Repository
+public class CargoDiscardDimensionRepository {
+    @Resource private CargoDiscardItemMapper items;
+    @Resource private CargoDiscardDimensionMapper dimensions;
+    @Resource private com.fasterxml.jackson.databind.ObjectMapper objectMapper;
+    /** 读取一票客户隔离明细。 */
+    public List<CargoDiscardItem> items(String customer, Long application) { return items.listApplication(customer, application); }
+    /** 读取一票托盘身份，保留无事实行。 */
+    public List<String> pallets(String customer, Long application) { return dimensions.palletNos(customer, application); }
+    /** 完整箱级事实才可提供件数，缺箱或未知件数不得固定换算。 */
+    public Long pieces(String customer, CargoDiscardItem item) {
+        var values = dimensions.selectedCartonPieces(customer, item.getId());
+        if (values.isEmpty() || values.size() != item.getDiscardPackages()) return null;
+        long total = 0;
+        for (var value : values) {
+            if (value == null || value.isBlank()) return null;
+            try {
+                var contents = objectMapper.readTree(value);
+                if (!contents.isArray()) return null;
+                long selected = 0;
+                for (var content : contents) {
+                    if (item.getSkuCode().equals(content.path("skuCode").asText())) selected += content.path("quantity").asLong();
+                }
+                if (selected <= 0) return null;
+                total += selected;
+            } catch (com.fasterxml.jackson.core.JsonProcessingException e) { return null; }
+        }
+        return total;
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/discard/repository/CargoDiscardPdaRepository.java

@@ -0,0 +1,46 @@
+package com.baiyue.lastleg.discard.repository;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baiyue.lastleg.discard.entity.*;
+import com.baiyue.lastleg.discard.mapper.*;
+import com.baiyue.lastleg.dropship.entity.DropshipOrderProfile;
+import com.baiyue.lastleg.dropship.mapper.DropshipOrderProfileMapper;
+import com.baiyue.lastleg.returnreceipt.entity.ReturnInventoryCarton;
+import com.baiyue.lastleg.returnreceipt.mapper.ReturnInventoryCartonMapper;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+
+/** 封装 PDA 废弃任务读取和作业快照持久化，保留绑定仓与申请行锁。 */
+@Repository
+public class CargoDiscardPdaRepository {
+    @Resource private CargoDiscardApplicationMapper applications;
+    @Resource private CargoDiscardItemMapper items;
+    @Resource private CargoDiscardCartonMapper cartons;
+    @Resource private DropshipOrderProfileMapper profiles;
+    @Resource private ReturnInventoryCartonMapper returnCartons;
+
+    /** 按已验证绑定仓读取已审核作业，客户归属由申请事实保留。 */
+    public List<CargoDiscardApplication> approved(String warehouseId) {
+        return applications.selectList(new LambdaQueryWrapper<CargoDiscardApplication>()
+            .eq(CargoDiscardApplication::getOverseasWarehouseId, warehouseId)
+            .eq(CargoDiscardApplication::getStatus, "APPROVED")
+            .orderByAsc(CargoDiscardApplication::getCreatedAt));
+    }
+    /** 写操作按申请串行，保证扣减、释放、实点结果及终态同事务。 */
+    public CargoDiscardApplication lockApplication(String no, String warehouse) { return applications.findNoByWarehouse(no, warehouse); }
+    /** 照片只读入口仍限制绑定仓。 */
+    public CargoDiscardApplication readApplication(String no, String warehouse) { return applications.readNoByWarehouse(no, warehouse); }
+    /** 按申请所属客户读取全部明细。 */
+    public List<CargoDiscardItem> items(String customer, Long application) { return items.listApplication(customer, application); }
+    /** 读取明细后由服务复验客户与申请。 */
+    public CargoDiscardItem item(Long id) { return items.selectById(id); }
+    /** 保存一次实际作业结果。 */
+    public void saveItem(CargoDiscardItem item) { items.updateById(item); }
+    /** 按客户和申请读取已选箱快照。 */
+    public List<CargoDiscardCarton> cartons(String customer, Long application) { return cartons.listApplication(customer, application); }
+    /** 读取原托盘档案供服务核验归属。 */
+    public DropshipOrderProfile profile(Long id) { return profiles.selectById(id); }
+    /** 读取退货箱档案供服务核验归属。 */
+    public ReturnInventoryCarton returnCarton(Long id) { return returnCartons.selectById(id); }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/discard/repository/CargoDiscardQuantityRepository.java

@@ -11,9 +11,10 @@ import org.springframework.stereotype.Repository;
 public class CargoDiscardQuantityRepository {
     @Resource private CargoDiscardItemMapper items;
 
-    /** 列表和详情均按所选实物箱展示；空明细保留申请自身快照。 */
+    /** 完工后列表和详情按实际箱数展示，作业前保留申请预留数量。 */
     public int boxes(CargoDiscardApplication application) {
         var lines = items.listApplication(application.getCustomerId(), application.getId());
-        return lines.isEmpty() ? application.getTotalPackages() : CargoDiscardQuantities.boxes(lines, false);
+        boolean completed = "PDA_COMPLETED".equals(application.getStatus()) || "COMPLETED".equals(application.getStatus());
+        return lines.isEmpty() ? application.getTotalPackages() : CargoDiscardQuantities.boxes(lines, completed);
     }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/repository/CargoDiscardQueryRepository.java

@@ -0,0 +1,36 @@
+package com.baiyue.lastleg.discard.repository;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baiyue.lastleg.discard.dto.CargoDiscardRequests;
+import com.baiyue.lastleg.discard.entity.CargoDiscardApplication;
+import com.baiyue.lastleg.discard.mapper.CargoDiscardApplicationMapper;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Repository;
+import org.springframework.util.StringUtils;
+import java.util.List;
+
+/** 列表和全筛选统计共用同一客户及时间过滤条件。 */
+@Repository
+public class CargoDiscardQueryRepository {
+    @Resource private CargoDiscardApplicationMapper applications;
+
+    /** 返回全部筛选单据，不受页面大小影响。 */
+    public List<CargoDiscardApplication> list(String customerId, CargoDiscardRequests.Query query) {
+        return applications.selectList(filter(customerId, query));
+    }
+
+    /** 完成时间使用客户确认时间，与客户端完成时间展示保持一致。 */
+    public static LambdaQueryWrapper<CargoDiscardApplication> filter(String customerId, CargoDiscardRequests.Query query) {
+        return new LambdaQueryWrapper<CargoDiscardApplication>()
+            .eq(StringUtils.hasText(customerId), CargoDiscardApplication::getCustomerId, customerId)
+            .like(StringUtils.hasText(query.discardNo()), CargoDiscardApplication::getDiscardNo, query.discardNo())
+            .like(StringUtils.hasText(query.inboundCode()), CargoDiscardApplication::getInboundCodes, query.inboundCode())
+            .eq(StringUtils.hasText(query.overseasWarehouseId()), CargoDiscardApplication::getOverseasWarehouseId, query.overseasWarehouseId())
+            .eq(StringUtils.hasText(query.status()), CargoDiscardApplication::getStatus, query.status())
+            .ge(query.createdFrom() != null, CargoDiscardApplication::getCreatedAt, query.createdFrom())
+            .le(query.createdTo() != null, CargoDiscardApplication::getCreatedAt, query.createdTo())
+            .ge(query.completedFrom() != null, CargoDiscardApplication::getCustomerConfirmedAt, query.completedFrom())
+            .le(query.completedTo() != null, CargoDiscardApplication::getCustomerConfirmedAt, query.completedTo())
+            .orderByDesc(CargoDiscardApplication::getCreatedAt).orderByDesc(CargoDiscardApplication::getId);
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/discard/repository/CargoDiscardStockRepository.java

@@ -0,0 +1,47 @@
+package com.baiyue.lastleg.discard.repository;
+
+import com.baiyue.lastleg.discard.entity.*;
+import com.baiyue.lastleg.discard.mapper.*;
+import com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow;
+import com.baiyue.lastleg.inventory.entity.*;
+import com.baiyue.lastleg.inventory.mapper.*;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+
+/** 封装普通库存废弃的客户隔离读取、锁箱和申请快照保存。 */
+@Repository
+public class CargoDiscardStockRepository {
+    @Resource private CargoDiscardInventoryMapper stock;
+    @Resource private InventoryPositionMapper positions;
+    @Resource private InventoryBalanceMapper balances;
+    @Resource private CargoDiscardItemMapper items;
+    @Resource private CargoDiscardCartonMapper links;
+
+    /** 读取客户当前可用且没有转运占用的库存仓位。 */
+    public List<InventoryPosition> candidates(String customer, String keyword) { return stock.genericPositions(customer, keyword); }
+    /** 读取余额，服务继续校验其客户与仓库归属。 */
+    public InventoryBalance balance(Long id) { return balances.selectById(id); }
+    /** 读取客户指定仓位。 */
+    public InventoryPosition position(String customer, Long id) { return positions.findTenantPosition(customer, id); }
+    /** 锁定源仓位以串行创建预留。 */
+    public InventoryPosition lockPosition(String customer, Long id) { return stock.lockGenericPosition(customer, id); }
+    /** 读取已有的真实箱唛与托盘对应事实。 */
+    public List<CargoDiscardStockCartonRow> cartons(String customer, Long position) { return stock.genericCartons(customer, position); }
+    /** 排除须走一件代发逐箱预留的仓位。 */
+    public boolean dropshipPosition(String customer, Long position) { return stock.isDropshipPosition(customer, position) > 0; }
+    /** 读取散箱实收流水中的箱码快照。 */
+    public List<String> looseMarks(String customer, Long position) { return stock.looseCartonMarks(customer, position); }
+    /** 保存废弃申请的库存来源明细。 */
+    public void saveItem(CargoDiscardItem item) { items.insert(item); }
+    /** 保存申请所选实物箱快照。 */
+    public void saveCarton(CargoDiscardCarton carton) { links.insert(carton); }
+    /** 读取申请全部所选箱，服务按当前明细筛选。 */
+    public List<CargoDiscardCarton> selectedCartons(String customer, Long application) { return links.listApplication(customer, application); }
+    /** 读取同申请各 SKU 的仓位和箱唛快照，用于按物理仓位消除重复库存命令。 */
+    public List<CargoDiscardItem> applicationItems(String customer, Long application) { return items.listApplication(customer, application); }
+    /** 普通实收箱用原状态条件更新，防止并发占用。 */
+    public int changeInboundCarton(String customer, Long id, String from, String to) { return stock.changeGenericCartonStatus(customer, id, from, to); }
+    /** 转运实收箱保留已清点状态语义。 */
+    public int changeTransferCarton(String customer, Long id, String from, String to) { return stock.changeTransferCartonStatus(customer, id, from, to); }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/discard/service/CargoDiscardOutboundService.java

@@ -58,6 +58,7 @@ public class CargoDiscardOutboundService {
         var snapshots = new java.util.ArrayList<OutboundPalletItem>();
         var palletCodes = new java.util.HashSet<String>();
         var returnBoxIds = new java.util.HashSet<Long>();
+        var inventoryBoxMarks = new java.util.HashSet<String>();
         for (var line : lines) {
             boolean returned = line.getReturnCartonId() != null || "RETURN_CARTON".equals(line.getSourceType());
             String palletNo;
@@ -73,7 +74,7 @@ public class CargoDiscardOutboundService {
                     || !application.getOverseasWarehouseId().equals(carton.getOverseasWarehouseId()))
                     throw conflict("废弃明细关联退货箱不存在或仓库不匹配");
                 palletNo = carton.getPalletCode() == null || carton.getPalletCode().isBlank() ? null : carton.getPalletCode();
-                cartonMarks = carton.getCartonMark();
+                cartonMarks = com.baiyue.lastleg.discard.model.CargoDiscardReturnMark.of(carton);
             } else {
                 var profile = profiles.selectById(line.getProfileId());
                 if (profile == null || !application.getCustomerId().equals(profile.getCustomerId()))
@@ -88,7 +89,7 @@ public class CargoDiscardOutboundService {
             snapshot.setId(line.getId()); snapshot.setCustomerId(application.getCustomerId()); snapshot.setOutboundOrderId(outbound.getId());
             snapshot.setPalletNo(palletNo); snapshot.setSkuCode(line.getSkuCode()); snapshot.setInboundCode(line.getInboundCode());
             snapshot.setOrderRefs(application.getDiscardNo()); snapshot.setCartonMarks(cartonMarks);
-            snapshot.setPackageCount(returned ? (returnBoxIds.add(line.getReturnCartonId()) ? 1 : 0) : line.getDiscardPackages());
+            snapshot.setPackageCount(returned ? (returnBoxIds.add(line.getReturnCartonId()) ? 1 : 0) : physicalBoxes(line, inventoryBoxMarks));
             snapshot.setPickedPackageCount(0); snapshot.setStatus("WAIT_PICK");
             if (returned) snapshot.setReturnSkuQuantity((long) line.getDiscardPackages());
             snapshot.setVolumeWeightKg(BigDecimal.ZERO); snapshot.setVolumeCbm(BigDecimal.ZERO); snapshot.setCreatedAt(at);
@@ -99,20 +100,28 @@ public class CargoDiscardOutboundService {
     }
 
     /** 同步实物箱的拣货进度，退货 SKU 件数不进入箱数汇总。 */
+    /** 同步废弃实物出库投影，混装 SKU 明细不能重复累计物理箱。 */
     public void sync(CargoDiscardApplication application) {
         OutboundOrder outbound = outbounds.lockByIdempotency(application.getCustomerId(), key(application));
         if (outbound == null) throw conflict("废弃出库单不存在，请联系平台核对审核结果");
         var lines = items.listApplication(application.getCustomerId(), application.getId());
         var returnBoxIds = new java.util.HashSet<Long>();
+        var inventoryBoxMarks = new java.util.HashSet<String>();
         for (var snapshot : pallets.findByOutbound(application.getCustomerId(), outbound.getId())) {
             var line = lines.stream().filter(i -> Objects.equals(i.getId(), snapshot.getId())).findFirst()
                 .orElseThrow(() -> conflict("废弃出库明细关联失效"));
             boolean returned = line.getReturnCartonId() != null;
-            int boxes = returned ? (returnBoxIds.add(line.getReturnCartonId()) ? 1 : 0) : line.getDiscardPackages();
+            if (returned) {
+                var carton = returnCartons.selectById(line.getReturnCartonId());
+                if (carton == null || !application.getCustomerId().equals(carton.getCustomerId()))
+                    throw conflict("废弃明细关联退货箱不存在");
+                snapshot.setCartonMarks(com.baiyue.lastleg.discard.model.CargoDiscardReturnMark.of(carton));
+            }
+            int boxes = returned ? (returnBoxIds.add(line.getReturnCartonId()) ? 1 : 0) : physicalBoxes(line, inventoryBoxMarks);
             snapshot.setPackageCount(boxes);
             if ("COMPLETED".equals(line.getPdaStatus())) {
                 snapshot.setPickedPackageCount(returned ? (Objects.requireNonNullElse(line.getActualDiscardPackages(), 0) > 0 ? boxes : 0)
-                    : Objects.requireNonNullElse(line.getActualDiscardPackages(), 0));
+                    : "INVENTORY".equals(line.getSourceType()) && !stockService.cartonMarks(line).isEmpty() ? boxes : Objects.requireNonNullElse(line.getActualDiscardPackages(), 0));
                 snapshot.setStatus("PICKED");
             }
             if (CargoDiscardService.CANCELLED.equals(application.getStatus())) snapshot.setStatus("CANCELLED");
@@ -128,5 +137,11 @@ public class CargoDiscardOutboundService {
         outbound.setPackageCount(com.baiyue.lastleg.discard.model.CargoDiscardQuantities.boxes(lines, "OUTBOUNDED".equals(status)));
         outbound.setUpdatedAt(LocalDateTime.now()); outbounds.updateById(outbound);
     }
+    /** 保留逐 SKU 来源行，已投影过的同一实箱在后续行记零箱。 */
+    private int physicalBoxes(com.baiyue.lastleg.discard.entity.CargoDiscardItem line, java.util.Set<String> seen) {
+        if (!"INVENTORY".equals(line.getSourceType())) return line.getDiscardPackages();
+        var marks = stockService.cartonMarks(line);
+        return marks.isEmpty() ? line.getDiscardPackages() : (int)marks.stream().filter(mark -> seen.add(line.getInboundCode() + ":" + mark)).count();
+    }
     private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT, message); }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/discard/service/CargoDiscardService.java

@@ -50,6 +50,7 @@ import java.util.Set;
 
 @Service
 public class CargoDiscardService {
+    @Resource private CargoDiscardStatisticsService statisticsService;
     @Resource private com.baiyue.lastleg.discard.repository.CargoDiscardQuantityRepository quantities;
     @Resource private com.baiyue.lastleg.service.LastlegOrderNoGenerator orderNoGenerator;
     public static final String APPROVAL_PERMISSION = "platform:overseas-warehouse:discard:approve";
@@ -97,14 +98,14 @@ public class CargoDiscardService {
         if (returnCartons == null || returnCartonItems == null) return result;
         for (ReturnInventoryCarton carton : returnCartons.findAvailable(customerId, null)) {
             if (StringUtils.hasText(keyword) && !containsIgnoreCase(carton.getSourceReturnNo(), keyword)
-                && !containsIgnoreCase(carton.getCartonMark(), keyword)) continue;
+                && !containsIgnoreCase(com.baiyue.lastleg.discard.model.CargoDiscardReturnMark.of(carton), keyword)) continue;
             List<CargoDiscardResponses.CandidateSku> skus = returnCartonItems.listCarton(carton.getId()).stream()
                 .filter(item -> value(item.getQuantity()) > 0)
                 .map(item -> new CargoDiscardResponses.CandidateSku(item.getSkuCode(), item.getProductNameZh(), value(item.getQuantity())))
                 .toList();
             long available = skus.stream().mapToLong(CargoDiscardResponses.CandidateSku::availablePackages).sum();
             if (available <= 0) continue;
-            result.add(new CargoDiscardResponses.Candidate(null, "RETURN_CARTON", carton.getId(), carton.getCartonMark(),
+            result.add(new CargoDiscardResponses.Candidate(null, "RETURN_CARTON", carton.getId(), com.baiyue.lastleg.discard.model.CargoDiscardReturnMark.of(carton),
                 carton.getSourceReturnNo(), carton.getSourceReturnNo(), carton.getOverseasWarehouseId(), null,
                 null, available, skus));
         }
@@ -164,7 +165,10 @@ public class CargoDiscardService {
             if (input.cartonIds() != null) {
                 if (input.cartonIds().isEmpty() || input.cartonIds().size() != input.discardPackages()) throw badRequest("请选择具体废弃箱子，箱数须与选择一致");
                 String source = input.inventoryPositionId() != null ? "INVENTORY" : "DROPSHIP";
-                for (Long cartonId : input.cartonIds()) if (!requestedBoxes.add(source + ":" + cartonId)) throw badRequest("同一个箱子不能重复废弃");
+                for (Long cartonId : input.cartonIds()) {
+                    boolean added = requestedBoxes.add(source + ":" + cartonId);
+                    if (!added && input.inventoryPositionId() == null) throw badRequest("同一个箱子不能重复废弃");
+                }
             }
             int sources = (returnSource ? 1 : 0) + (input.orderId() != null ? 1 : 0) + (input.inventoryPositionId() != null ? 1 : 0);
             if (sources != 1) {
@@ -201,7 +205,7 @@ public class CargoDiscardService {
                 throw conflict("One cargo discard application cannot span operating warehouses");
             }
             // 退货明细为件数，整箱只在全部 SKU 校验完成后按箱 ID 计一次。
-            if (!returnSource) total = Math.addExact(total, input.discardPackages());
+            if (!returnSource && input.cartonIds() == null) total = Math.addExact(total, input.discardPackages());
         }
 
         for (Long cartonId : returnCartonCache.keySet()) {
@@ -213,6 +217,7 @@ public class CargoDiscardService {
             if (!availableSkus.equals(requestedSkus)) throw conflict("目前不支持部分废弃，必须选择退货箱内全部 SKU 库存");
         }
         total = Math.addExact(total, returnCartonCache.size());
+        total = Math.addExact(total, requestedBoxes.size());
         LocalDateTime now = LocalDateTime.now();
         if (!StringUtils.hasText(warehouseName)) warehouseName = warehouseNames().get(warehouseId);
         CargoDiscardApplication application = new CargoDiscardApplication();
@@ -235,9 +240,10 @@ public class CargoDiscardService {
         // 废弃申请独立承载废弃流程，不创建尾程订单。
 
         Set<Long> reservedReturnCartons = new LinkedHashSet<>();
+        stockService.reserveAll(customerId, operatorId, application, request.items(), now);
         for (CargoDiscardRequests.Item input : request.items()) {
             if (input.inventoryPositionId() != null) {
-                stockService.reserve(customerId, operatorId, application, input, now);
+                // 普通库存已按完整混装箱批量预留。
             } else if (input.returnCartonId() != null) {
                 reserveReturn(customerId, application, returnCartonCache.get(input.returnCartonId()), input, now,
                     reservedReturnCartons);
@@ -253,7 +259,8 @@ public class CargoDiscardService {
         if ("INVENTORY".equals(line.getSourceType())) return stockService.cartonMarks(line);
         if (isReturnItem(line)) {
             var carton = returnCartons.selectById(line.getReturnCartonId());
-            return carton == null || carton.getCartonMark() == null ? List.of() : List.of(carton.getCartonMark());
+            String mark = com.baiyue.lastleg.discard.model.CargoDiscardReturnMark.of(carton);
+            return mark == null ? List.of() : List.of(mark);
         }
         return discardCartons.listApplication(customer, application.getId()).stream().filter(link -> link.getItemId().equals(line.getId()))
             .map(CargoDiscardCarton::getCartonMark).distinct().sorted().toList();
@@ -261,16 +268,7 @@ public class CargoDiscardService {
 
     public PageResult<CargoDiscardResponses.Summary> page(String customerId, CargoDiscardRequests.Query query) {
         validateQuery(query);
-        LambdaQueryWrapper<CargoDiscardApplication> wrapper = new LambdaQueryWrapper<CargoDiscardApplication>()
-            .eq(StringUtils.hasText(customerId), CargoDiscardApplication::getCustomerId, customerId)
-            .like(StringUtils.hasText(query.discardNo()), CargoDiscardApplication::getDiscardNo, query.discardNo())
-            .like(StringUtils.hasText(query.inboundCode()), CargoDiscardApplication::getInboundCodes, query.inboundCode())
-            .eq(StringUtils.hasText(query.overseasWarehouseId()), CargoDiscardApplication::getOverseasWarehouseId,
-                query.overseasWarehouseId())
-            .eq(StringUtils.hasText(query.status()), CargoDiscardApplication::getStatus, query.status())
-            .ge(query.createdFrom() != null, CargoDiscardApplication::getCreatedAt, query.createdFrom())
-            .le(query.createdTo() != null, CargoDiscardApplication::getCreatedAt, query.createdTo())
-            .orderByDesc(CargoDiscardApplication::getCreatedAt).orderByDesc(CargoDiscardApplication::getId);
+        var wrapper = com.baiyue.lastleg.discard.repository.CargoDiscardQueryRepository.filter(customerId, query);
         Page<CargoDiscardApplication> result = applications.selectPage(Page.of(query.page(), query.size()), wrapper);
         Map<String, String> names = result.getRecords().stream().anyMatch(a -> !StringUtils.hasText(a.getOverseasWarehouseName()))
             ? warehouseNames() : Map.of();
@@ -278,12 +276,19 @@ public class CargoDiscardService {
         return new PageResult<>(records, query.page(), query.size(), result.getTotal(), result.getPages());
     }
 
+    /** 全筛选汇总与列表使用同一输入校验，不受当前分页影响。 */
+    public CargoDiscardStatisticsService.Statistics statistics(String customerId, CargoDiscardRequests.Query query) {
+        validateQuery(query);
+        return statisticsService.statistics(customerId, query);
+    }
+
     public CargoDiscardResponses.Detail detail(String customerId, String discardNo) {
         CargoDiscardApplication application = applications.findNo(customerId, discardNo);
         if (application == null) throw notFound("Cargo discard application not found");
         List<CargoDiscardResponses.Item> itemViews = items.listApplication(customerId, application.getId()).stream()
             .map(value -> new CargoDiscardResponses.Item(value.getId(), value.getOrderId(), value.getInboundCode(),
-                value.getSkuCode(), value.getProductName(), value.getAvailablePackagesSnapshot(), value.getDiscardPackages(), selectedMarks(customerId, application, value)))
+                value.getSkuCode(), value.getProductName(), value.getAvailablePackagesSnapshot(), value.getDiscardPackages(), selectedMarks(customerId, application, value),
+                value.getReturnCartonId() != null ? "件" : "箱", value.getActualDiscardPackages(), value.getPdaStatus()))
             .toList();
         List<CargoDiscardResponses.History> historyViews = histories.listApplication(customerId, application.getId()).stream()
             .map(value -> new CargoDiscardResponses.History(value.getFromStatus(), value.getToStatus(),
@@ -513,10 +518,15 @@ public class CargoDiscardService {
     /** 废弃列表与详情按物理箱汇总，并按每箱单价计算应展示费用。 */
     private CargoDiscardResponses.Summary summary(CargoDiscardApplication value, Map<String, String> names) {
         int boxes = quantities.boxes(value);
+        var lines = items.listApplication(value.getCustomerId(), value.getId());
+        var skuCodes = lines.stream().map(CargoDiscardItem::getSkuCode).filter(s -> s != null && !s.isBlank()).distinct().sorted().toList();
+        int requested = lines.isEmpty() ? value.getTotalPackages() : com.baiyue.lastleg.discard.model.CargoDiscardQuantities.boxes(lines, false);
+        Integer actual = lines.stream().anyMatch(i -> i.getActualDiscardPackages() != null)
+            ? com.baiyue.lastleg.discard.model.CargoDiscardQuantities.boxes(lines, true) : null;
         return new CargoDiscardResponses.Summary(value.getId(), value.getCustomerId(), value.getDiscardNo(), value.getInboundCodes(),
             value.getOverseasWarehouseId(), StringUtils.hasText(value.getOverseasWarehouseName()) ? value.getOverseasWarehouseName() : names.get(value.getOverseasWarehouseId()), boxes,
             value.getFeePerPackage() == null ? value.getTotalFee() : value.getFeePerPackage().multiply(BigDecimal.valueOf(boxes)), value.getCurrency(), value.getStatus(), value.getCreatedBy(), value.getCreatedAt(),
-            value.getReviewedAt(), outboundService.outboundNo(value), value.getCustomerConfirmedAt());
+            value.getReviewedAt(), outboundService.outboundNo(value), value.getCustomerConfirmedAt(), skuCodes, skuCodes.size(), requested, actual);
     }
 
     private void history(String customerId, Long applicationId, String from, String to, String operatorId,
@@ -528,6 +538,9 @@ public class CargoDiscardService {
     }
 
     private void validateQuery(CargoDiscardRequests.Query query) {
+        if (query.completedFrom() != null && query.completedTo() != null && query.completedFrom().isAfter(query.completedTo())) {
+            throw badRequest("completedFrom must not be after completedTo");
+        }
         if (StringUtils.hasText(query.status()) && !STATUSES.contains(query.status())) throw badRequest("Unsupported discard status");
         if (query.createdFrom() != null && query.createdTo() != null && query.createdFrom().isAfter(query.createdTo())) {
             throw badRequest("createdFrom must not be after createdTo");

lastleg-service/src/main/java/com/baiyue/lastleg/discard/service/CargoDiscardStatisticsService.java

@@ -0,0 +1,60 @@
+package com.baiyue.lastleg.discard.service;
+
+import com.baiyue.lastleg.discard.dto.CargoDiscardRequests;
+import com.baiyue.lastleg.discard.model.CargoDiscardQuantities;
+import com.baiyue.lastleg.discard.repository.CargoDiscardQueryRepository;
+import com.baiyue.lastleg.discard.repository.CargoDiscardDimensionRepository;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+import java.util.HashSet;
+
+/** 按全部筛选单据统计票、SKU、件、箱和真实来源托盘。 */
+@Service
+public class CargoDiscardStatisticsService {
+    @Resource private CargoDiscardQueryRepository queries;
+    @Resource private CargoDiscardDimensionRepository dimensions;
+
+    public record Statistics(long orderCount, int skuCount, long requestedPackages, Long actualPackages,
+                             Long requestedPieces, Long actualPieces, Integer palletCount) {}
+
+    /** 已确认实际数独立汇总；缺失件数或托盘事实返回空值，不从箱数换算。 */
+    public Statistics statistics(String customer, CargoDiscardRequests.Query query) {
+        var applications = queries.list(customer, query);
+        var skus = new HashSet<String>(); var pallets = new HashSet<String>();
+        long boxes = 0, actualBoxes = 0, pieces = 0, actualPieces = 0;
+        boolean piecesKnown = true, actualPiecesKnown = true, actualKnown = false, palletsKnown = true;
+        for (var application : applications) {
+            var lines = dimensions.items(application.getCustomerId(), application.getId());
+            boxes += lines.isEmpty() ? application.getTotalPackages() : CargoDiscardQuantities.boxes(lines, false);
+            if (lines.isEmpty()) { piecesKnown = false; palletsKnown = false; }
+            var confirmed = lines.stream().filter(i -> i.getActualDiscardPackages() != null).toList();
+            if (!confirmed.isEmpty()) { actualKnown = true; actualBoxes += CargoDiscardQuantities.boxes(confirmed, true); }
+            for (var line : lines) {
+                if (line.getSkuCode() != null && !line.getSkuCode().isBlank()) skus.add(line.getSkuCode());
+                if (line.getReturnCartonId() == null) {
+                    var selectedPieces = dimensions.pieces(application.getCustomerId(), line);
+                    if (selectedPieces == null) piecesKnown = false;
+                    else pieces += selectedPieces;
+                    if (line.getActualDiscardPackages() != null) {
+                        if (line.getActualDiscardPackages() == 0) { /* 实际未废弃商品为零，不推测箱规。 */ }
+                        else if (selectedPieces != null && line.getActualDiscardPackages() == line.getDiscardPackages()) actualPieces += selectedPieces;
+                        else actualPiecesKnown = false;
+                    }
+                } else {
+                    pieces += line.getDiscardPackages();
+                    if (line.getActualDiscardPackages() != null) actualPieces += line.getActualDiscardPackages();
+                }
+            }
+            var sourcePallets = dimensions.pallets(application.getCustomerId(), application.getId());
+            if (sourcePallets.isEmpty()) palletsKnown = false;
+            for (var pallet : sourcePallets) {
+                if (pallet == null || pallet.isBlank() || "散箱".equals(pallet)) palletsKnown = false;
+                else pallets.add(application.getCustomerId() + ":" + application.getOverseasWarehouseId() + ":" + pallet);
+            }
+        }
+        return new Statistics(applications.size(), skus.size(), boxes, actualKnown ? actualBoxes : null,
+            !applications.isEmpty() && piecesKnown ? pieces : null,
+            actualKnown && actualPiecesKnown ? actualPieces : null,
+            !applications.isEmpty() && palletsKnown ? pallets.size() : null);
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/discard/service/CargoDiscardStockService.java

@@ -2,11 +2,9 @@ package com.baiyue.lastleg.discard.service;
 
 import com.baiyue.lastleg.discard.dto.*;
 import com.baiyue.lastleg.discard.entity.*;
-import com.baiyue.lastleg.discard.mapper.*;
 import com.baiyue.lastleg.inventory.command.dto.InventoryCommandRequests;
 import com.baiyue.lastleg.inventory.command.service.InventoryCommandService;
 import com.baiyue.lastleg.inventory.entity.*;
-import com.baiyue.lastleg.inventory.mapper.*;
 import com.baomidou.mybatisplus.core.toolkit.IdWorker;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import jakarta.annotation.Resource;
@@ -16,127 +14,233 @@ import org.springframework.web.server.ResponseStatusException;
 import java.util.*;
 import java.time.LocalDateTime;
 
-/** Stock eligibility is based on physical available positions, independent of the source document type. */
+/** 根据实际可用仓位校验废弃库存，精确选箱与无对应关系实点分别结算。 */
 @Service
 public class CargoDiscardStockService {
-    @Resource private CargoDiscardInventoryMapper stock;
-    @Resource private InventoryPositionMapper positions;
-    @Resource private InventoryBalanceMapper balances;
+    @Resource private com.baiyue.lastleg.discard.repository.CargoDiscardStockRepository repository;
     @Resource private InventoryCommandService commands;
-    @Resource private CargoDiscardItemMapper items;
-    @Resource private CargoDiscardCartonMapper links;
     @Resource private ObjectMapper objectMapper;
 
+    /** 展示可用库存及相关托盘，箱唛完整时才提供逐箱选择。 */
     public List<CargoDiscardResponses.Candidate> candidates(String customer, String keyword) {
-        return stock.genericPositions(customer, keyword).stream().map(position -> {
-            var balance = balances.selectById(position.getBalanceId());
+        return repository.candidates(customer, keyword).stream().map(position -> {
+            var balance = repository.balance(position.getBalanceId());
             if (balance == null || !customer.equals(balance.getCustomerId())) throw conflict("库存余额不存在");
             long available = Math.min(value(position.getAvailablePackages()), value(balance.getAvailablePackages()));
-            var cartons = stock.genericCartons(customer, position.getId());
-            boolean complete = cartons.size() == available && cartons.stream().allMatch(c -> c.getCartonMark() != null && !c.getCartonMark().isBlank())
-                && cartons.stream().map(c -> c.getCartonMark()).distinct().count() == cartons.size();
+            var cartons = repository.cartons(customer, position.getId());
+            boolean complete = completeCartons(cartons, available);
             var boxes = complete ? cartons.stream().map(c -> new CargoDiscardResponses.Box(c.getId(), c.getCartonMark(), position.getPalletNo(),
-                List.of(new CargoDiscardResponses.CandidateSku(c.getSkuCode(), balance.getProductNameZh(), 1)))).toList() : List.<CargoDiscardResponses.Box>of();
+                contents(c, balance.getProductNameZh()))).toList() : List.<CargoDiscardResponses.Box>of();
             return new CargoDiscardResponses.Candidate(null, "INVENTORY", null, null,
                 balance.getInboundCode(), balance.getInboundOrderNo(), balance.getOverseasWarehouseId(),
                 balance.getOverseasWarehouseName(), position.getCreatedAt(), available,
-                List.of(new CargoDiscardResponses.CandidateSku(sku(balance), balance.getProductNameZh(), available)),
+                complete ? summarizeSkus(cartons, balance) : List.of(new CargoDiscardResponses.CandidateSku(sku(balance), balance.getProductNameZh(), available)),
                 position.getId(), position.getPalletNo(), boxes, complete,
-                complete ? null : "当前库存缺少完整箱唛与托盘对应记录，可按全部库存废弃");
+                complete ? null : "缺少完整箱唛与托盘对应记录，将预留所选库存，由仓库核对相关托盘并填写实际废弃箱数，未废弃部分释放");
         }).filter(c -> c.availablePackages() > 0).toList();
     }
 
+    /** 校验客户、仓库、SKU、预留上限与具体箱子的归属。 */
     public InventoryBalance validate(String customer, CargoDiscardRequests.Item request) {
         var position = position(customer, request.inventoryPositionId());
-        var balance = balances.selectById(position.getBalanceId());
+        var balance = repository.balance(position.getBalanceId());
         if (balance == null || !customer.equals(balance.getCustomerId())
             || !Objects.equals(position.getOverseasWarehouseId(), balance.getOverseasWarehouseId()))
             throw conflict("库存不属于当前客户或仓库");
-        if (!sku(balance).equals(request.skuCode().trim())) throw conflict("SKU 不属于所选库存");
         long available = Math.min(value(position.getAvailablePackages()), value(balance.getAvailablePackages()));
         if (available <= 0 || request.discardPackages() <= 0 || request.discardPackages() > available) throw conflict("所选废弃库存数量不足");
         if (request.cartonIds() != null) {
             if (request.cartonIds().size() != request.discardPackages() || new HashSet<>(request.cartonIds()).size() != request.cartonIds().size())
                 throw conflict("废弃箱子数量与所选箱子不一致或重复");
-            var cartons = stock.genericCartons(customer, position.getId());
+            var cartons = repository.cartons(customer, position.getId());
             var ids = cartons.stream().map(c -> c.getId()).collect(java.util.stream.Collectors.toSet());
             if (cartons.size() != available || cartons.stream().anyMatch(c -> c.getCartonMark() == null || c.getCartonMark().isBlank()) || cartons.stream().map(c -> c.getCartonMark()).distinct().count() != cartons.size() || !ids.containsAll(request.cartonIds())) throw conflict("箱唛库存已变化或不属于所选托盘，请刷新后重选");
-        } else if (request.discardPackages() != available) throw conflict("部分废弃必须选择具体箱子，不能只填写数量");
-        if (stock.isDropshipPosition(customer, position.getId()) > 0) throw conflict("一件代发库存必须按真实箱唛选择，不能绕过箱级预留");
+            if (cartons.stream().filter(c -> request.cartonIds().contains(c.getId())).anyMatch(c -> contents(c, null).stream().noneMatch(s -> request.skuCode().trim().equals(s.skuCode())))) throw conflict("SKU 不属于所选箱子");
+        } else {
+            if (!sku(balance).equals(request.skuCode().trim())) throw conflict("SKU 不属于所选库存");
+            if (request.discardPackages() != available) throw conflict("部分废弃必须选择具体箱子，不能只填写数量");
+        }
+        if (repository.dropshipPosition(customer, position.getId())) throw conflict("一件代发库存必须按真实箱唛选择，不能绕过箱级预留");
         return balance;
     }
 
+    /** 预留所选实收箱并保存箱号快照，转运箱从已清点状态进入待废弃。 */
     public void reserve(String customer, String operator, CargoDiscardApplication application, CargoDiscardRequests.Item request, LocalDateTime at) {
-        if (stock.lockGenericPosition(customer, request.inventoryPositionId()) == null) throw conflict("库存仓位不存在");
+        if (repository.lockPosition(customer, request.inventoryPositionId()) == null) throw conflict("库存仓位不存在");
         var balance = validate(customer, request);
+        reserveValidated(customer, operator, application, request, at, balance, repository.cartons(customer, request.inventoryPositionId()), new HashSet<>(), new HashSet<>());
+    }
+
+    /** 整箱混装必须包含全部 SKU 仓位；先锁仓位并校验全部事实，再按实物箱仅锁定一次。 */
+    public void reserveAll(String customer, String operator, CargoDiscardApplication application, List<CargoDiscardRequests.Item> requests, LocalDateTime at) {
+        var stocks = requests.stream().filter(r -> r.inventoryPositionId() != null).toList();
+        stocks.stream().map(CargoDiscardRequests.Item::inventoryPositionId).distinct().sorted().forEach(id -> {
+            if (repository.lockPosition(customer, id) == null) throw conflict("库存仓位不存在");
+        });
+        var balances = new HashMap<Long, InventoryBalance>();
+        var cartons = new HashMap<Long, List<com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow>>();
+        var selectedSkus = new HashMap<String, Set<String>>();
+        for (var request : stocks) {
+            balances.put(request.inventoryPositionId(), validate(customer, request));
+            var facts = repository.cartons(customer, request.inventoryPositionId());
+            cartons.put(request.inventoryPositionId(), facts);
+            for (var carton : facts) if (request.cartonIds() == null || request.cartonIds().contains(carton.getId()))
+                selectedSkus.computeIfAbsent(carton.getSourceType() + ":" + carton.getId(), k -> new HashSet<>()).add(request.skuCode().trim());
+        }
+        for (var request : stocks) for (var carton : cartons.get(request.inventoryPositionId())) {
+            if (request.cartonIds() != null && !request.cartonIds().contains(carton.getId())) continue;
+            var required = contents(carton, null).stream().map(CargoDiscardResponses.CandidateSku::skuCode).collect(java.util.stream.Collectors.toSet());
+            if (required.size() > 1 && request.cartonIds() == null) throw conflict("混装箱必须选择具体箱子及箱内全部 SKU 库存");
+            if (!selectedSkus.get(carton.getSourceType() + ":" + carton.getId()).containsAll(required)) throw conflict("混装箱必须选择箱内全部 SKU 库存");
+        }
+        var lockedBoxes = new HashSet<String>();
+        var heldBoxes = new HashSet<String>();
+        for (var request : stocks) reserveValidated(customer, operator, application, request, at,
+            balances.get(request.inventoryPositionId()), cartons.get(request.inventoryPositionId()), lockedBoxes, heldBoxes);
+    }
+
+    /** 使用本事务变更箱状态前的完整事实，为每个 SKU 分别预留并保存相同箱唛快照。 */
+    private void reserveValidated(String customer, String operator, CargoDiscardApplication application, CargoDiscardRequests.Item request, LocalDateTime at,
+                                  InventoryBalance balance, List<com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow> availableCartons, Set<String> lockedBoxes, Set<String> heldBoxes) {
         var position = position(customer, request.inventoryPositionId());
         var line = new CargoDiscardItem(); line.setId(IdWorker.getId()); line.setApplicationId(application.getId());
         line.setCustomerId(customer); line.setSourceType("INVENTORY"); line.setInventoryPositionId(position.getId());
-        line.setInboundCode(balance.getInboundCode()); line.setSkuCode(sku(balance)); line.setProductName(balance.getProductNameZh());
-        line.setAvailablePackagesSnapshot(Math.toIntExact(Math.min(value(position.getAvailablePackages()), value(balance.getAvailablePackages())))); line.setDiscardPackages(request.discardPackages()); line.setCreatedAt(at);
-        var availableCartons = stock.genericCartons(customer, position.getId());
+        line.setInboundCode(balance.getInboundCode()); line.setSkuCode(request.skuCode().trim()); line.setProductName(sku(balance).equals(line.getSkuCode()) ? balance.getProductNameZh() : null);
+        line.setAvailablePackagesSnapshot(availableCartons.isEmpty() ? Math.toIntExact(Math.min(value(position.getAvailablePackages()), value(balance.getAvailablePackages()))) : availableCartons.size()); line.setDiscardPackages(request.discardPackages()); line.setCreatedAt(at);
         var selected = request.cartonIds() == null
-            ? (availableCartons.size() == request.discardPackages() ? availableCartons : List.<com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow>of())
+            ? (completeCartons(availableCartons, request.discardPackages()) ? availableCartons : List.<com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow>of())
             : availableCartons.stream().filter(c -> request.cartonIds().contains(c.getId())).toList();
         if (!selected.isEmpty()) {
             for (var carton : selected) {
-                if (changeBox(customer, carton.getId(), carton.getSourceType(), "TRANSFER".equals(carton.getSourceType()) ? "EXPECTED" : "AVAILABLE", "DISCARD_PENDING") != 1) throw conflict("箱子已被其他作业占用，请刷新后重选");
+                if (!lockedBoxes.add(carton.getSourceType() + ":" + carton.getId())) continue;
+                if (changeBox(customer, carton.getId(), carton.getSourceType(), "TRANSFER".equals(carton.getSourceType()) ? "COUNTED" : "AVAILABLE", "DISCARD_PENDING") != 1) throw conflict("箱子已被其他作业占用，请刷新后重选");
                 var link = new CargoDiscardCarton(); link.setId(IdWorker.getId()); link.setCustomerId(customer); link.setApplicationId(application.getId());
-                link.setItemId(line.getId()); link.setSourceType(carton.getSourceType()); link.setCartonId(carton.getId()); link.setCartonMark(carton.getCartonMark()); link.setCreatedAt(at); links.insert(link);
+                link.setItemId(line.getId()); link.setSourceType(carton.getSourceType()); link.setCartonId(carton.getId()); link.setCartonMark(carton.getCartonMark()); link.setCreatedAt(at); repository.saveCarton(link);
             }
             snapshotMarks(line, selected.stream().map(c -> c.getCartonMark()).toList());
             line.setCartonScanRequired(request.discardPackages() < value(position.getAvailablePackages()) + value(position.getHoldPackages()) + value(position.getAllocatedPackages()) + value(position.getPickedPackages()));
         } else if (position.getPalletNo() == null || position.getPalletNo().isBlank()) {
-            var marks = stock.looseCartonMarks(customer, position.getId());
+            var marks = repository.looseMarks(customer, position.getId());
             if (marks.size() != request.discardPackages() || marks.stream().distinct().count() != marks.size()) throw conflict("散箱库存缺少完整箱唛，请先核对实物箱级入库记录");
             snapshotMarks(line, marks);
         }
-        commands.hold(customer, operator, move(application, line, request.discardPackages(), "HOLD"));
-        items.insert(line);
+        int physical = selected.isEmpty() ? request.discardPackages() : (int)selected.stream().filter(c -> heldBoxes.add(position.getId() + ":" + c.getSourceType() + ":" + c.getId())).count();
+        if (physical > 0) commands.hold(customer, operator, move(application, line, physical, "HOLD"));
+        repository.saveItem(line);
     }
 
+    /** 同一仓位可能承载混装箱，完整 SKU 候选来自实箱而不是库存余额的首 SKU。 */
+    private List<CargoDiscardResponses.CandidateSku> summarizeSkus(List<com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow> cartons, InventoryBalance balance) {
+        var boxes = new LinkedHashMap<String, Long>(); var pieces = new HashMap<String, Long>(); var unknown = new HashSet<String>();
+        for (var carton : cartons) for (var content : contents(carton, null)) {
+            boxes.merge(content.skuCode(), 1L, Math::addExact);
+            if (content.availablePieces() == null) unknown.add(content.skuCode()); else pieces.merge(content.skuCode(), content.availablePieces(), Math::addExact);
+        }
+        return boxes.entrySet().stream().map(e -> new CargoDiscardResponses.CandidateSku(e.getKey(), sku(balance).equals(e.getKey()) ? balance.getProductNameZh() : null,
+            e.getValue(), unknown.contains(e.getKey()) ? null : pieces.get(e.getKey()))).toList();
+    }
+
+    /** 箱数、箱唛和唯一性均完整时，才允许将库存对应到具体箱子。 */
+    private boolean completeCartons(List<com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow> cartons, long count) {
+        return cartons.size() == count && cartons.stream().allMatch(c -> c.getCartonMark() != null && !c.getCartonMark().isBlank())
+            && cartons.stream().map(c -> c.getCartonMark()).distinct().count() == cartons.size();
+    }
+    /** 转运实收 JSON 提供完整 SKU 与件数；无 JSON 的单 SKU 来源保留箱数单位。 */
+    private List<CargoDiscardResponses.CandidateSku> contents(com.baiyue.lastleg.discard.model.CargoDiscardStockCartonRow carton, String productName) {
+        if (carton.getSkuItemsJson() == null || carton.getSkuItemsJson().isBlank())
+            return List.of(new CargoDiscardResponses.CandidateSku(carton.getSkuCode(), productName, 1));
+        try {
+            var values = objectMapper.readTree(carton.getSkuItemsJson());
+            if (!values.isArray()) throw conflict("箱内 SKU 事实不完整");
+            var quantities = new LinkedHashMap<String, Long>();
+            for (var value : values) {
+                String code = value.path("skuCode").asText().trim(); long pieces = value.path("quantity").asLong();
+                if (code.isEmpty() || pieces <= 0) throw conflict("箱内 SKU 事实不完整");
+                quantities.merge(code, pieces, Math::addExact);
+            }
+            if (quantities.isEmpty()) throw conflict("箱内 SKU 事实不完整");
+            return quantities.entrySet().stream().map(e -> new CargoDiscardResponses.CandidateSku(e.getKey(), Objects.equals(e.getKey(), carton.getSkuCode()) ? productName : null, 1, e.getValue())).toList();
+        } catch (com.fasterxml.jackson.core.JsonProcessingException e) { throw conflict("箱内 SKU 事实无法读取"); }
+    }
+
+    /** 驳回或取消时恢复所选箱状态并释放本次冻结数量。 */
     public void release(String customer, CargoDiscardApplication application, CargoDiscardItem line) {
         changeSelectedCartons(customer, application, line, "AVAILABLE");
-        commands.release(customer, application.getCreatedBy(), move(application, line, line.getDiscardPackages(), "RELEASE"));
+        int physical = physicalPackages(customer, application, line);
+        if (physical > 0) commands.release(customer, application.getCreatedBy(), move(application, line, physical, "RELEASE"));
     }
 
+    /** 无逐箱对应关系时按仓库实点扣冻结库存，未废弃余量在同一作业事务释放。 */
+    @org.springframework.transaction.annotation.Transactional(propagation = org.springframework.transaction.annotation.Propagation.MANDATORY)
     public void discard(String customer, String operator, CargoDiscardApplication application, CargoDiscardItem line, int actual) {
-        if (actual != line.getDiscardPackages()) throw conflict("必须完成本次申请所选全部箱子，不能漏出");
-        changeSelectedCartons(customer, application, line, "DISCARDED");
-        commands.discardHeld(customer, operator, move(application, line, actual, "DISCARD"));
+        if (actual < 0 || actual > line.getDiscardPackages()) throw conflict("实际废弃箱数不能超过申请预留箱数");
+        if (!actualQuantityEditable(line) && actual != line.getDiscardPackages())
+            throw conflict("必须完成本次申请所选全部箱子，不能漏出");
+        // 已选择具体箱子的作业仍按箱唛结算，不能按数量猜测哪些箱已被废弃。
+        if (!actualQuantityEditable(line)) changeSelectedCartons(customer, application, line, "DISCARDED");
+        int physical = actualQuantityEditable(line) ? actual : physicalPackages(customer, application, line);
+        if (physical > 0) commands.discardHeld(customer, operator, move(application, line, physical, "DISCARD"));
+        int remaining = line.getDiscardPackages() - actual;
+        if (remaining > 0) commands.release(customer, operator, move(application, line, remaining, "ACTUAL_RELEASE"));
     }
 
-    private int changeBox(String customer, Long cartonId, String source, String from, String to) {
-        if ("TRANSFER".equals(source)) return stock.changeTransferCartonStatus(customer, cartonId, from, to);
-        if (!"INBOUND".equals(source)) throw conflict("箱子库存来源不正确");
-        return stock.changeGenericCartonStatus(customer, cartonId, from, to);
+    /** 同仓位同箱只由首个 SKU 明细执行库存命令；其他 SKU 保存件数事实，不重复扣物理箱桶。 */
+    private int physicalPackages(String customer, CargoDiscardApplication application, CargoDiscardItem line) {
+        var marks = cartonMarks(line);
+        if (marks.isEmpty()) return line.getDiscardPackages();
+        var previous = new HashSet<String>();
+        for (var other : repository.applicationItems(customer, application.getId())) {
+            if (Objects.equals(other.getInventoryPositionId(), line.getInventoryPositionId()) && other.getId() != null && line.getId() != null && other.getId() < line.getId()) previous.addAll(cartonMarks(other));
+        }
+        return (int)marks.stream().filter(mark -> !previous.contains(mark)).count();
     }
+
+    /** 只有未保存具体箱唛的普通仓位库存允许仓库按实点箱数完成。 */
+    public boolean actualQuantityEditable(CargoDiscardItem line) {
+        return "INVENTORY".equals(line.getSourceType()) && line.getInventoryPositionId() != null
+            && cartonMarks(line).isEmpty() && !Boolean.TRUE.equals(line.getCartonScanRequired());
+    }
+
+    /** 按箱来源执行带原状态条件的变更。 */
+    private int changeBox(String customer, Long cartonId, String source, String from, String to) {
+        if ("TRANSFER".equals(source)) return repository.changeTransferCarton(customer, cartonId, from, to);
+        if (!"INBOUND".equals(source)) throw conflict("箱子库存来源不正确");
+        return repository.changeInboundCarton(customer, cartonId, from, to);
+    }
+    /** 保存本次选箱事实，后续作业不得按数量猜测箱唛。 */
     private void snapshotMarks(CargoDiscardItem line, List<String> marks) {
         try { line.setCartonMarksJson(objectMapper.writeValueAsString(marks)); }
         catch (Exception e) { throw new IllegalStateException("Cannot snapshot carton marks", e); }
     }
+    /** 仅变更当前申请明细保存的箱子，转运箱释放后恢复已清点状态。 */
     private void changeSelectedCartons(String customer, CargoDiscardApplication application, CargoDiscardItem line, String status) {
-        for (var link : links.listApplication(customer, application.getId())) {
-            if (Objects.equals(link.getItemId(), line.getId()) && changeBox(customer, link.getCartonId(), link.getSourceType(), "DISCARD_PENDING", "TRANSFER".equals(link.getSourceType()) && "AVAILABLE".equals(status) ? "EXPECTED" : status) != 1)
+        for (var link : repository.selectedCartons(customer, application.getId())) {
+            if (Objects.equals(link.getItemId(), line.getId()) && changeBox(customer, link.getCartonId(), link.getSourceType(), "DISCARD_PENDING", "TRANSFER".equals(link.getSourceType()) && "AVAILABLE".equals(status) ? "COUNTED" : status) != 1)
                 throw conflict("预留箱子的库存状态发生变化");
         }
     }
+    /** 库存命令使用申请和明细构成的稳定来源与幂等键。 */
     private InventoryCommandRequests.Move move(CargoDiscardApplication application, CargoDiscardItem line, int count, String action) {
         String cycle = "CARGO_DISCARD:" + application.getId() + ":" + line.getId();
         return new InventoryCommandRequests.Move(line.getInventoryPositionId(), count, application.getDiscardNo(),
             null, cycle, cycle + ":" + action, "货物废弃 " + action);
     }
+    /** 读取并核对客户指定库存仓位。 */
     public InventoryPosition position(String customer, Long id) {
-        var position = positions.findTenantPosition(customer, id);
+        var position = repository.position(customer, id);
         if (position == null) throw conflict("废弃库存仓位不存在或不属于当前客户");
         return position;
     }
+    /** 只解析申请保存的箱唛，缺失对应关系保留为空。 */
     public List<String> cartonMarks(CargoDiscardItem line) {
         if (line.getCartonMarksJson() == null) return List.of();
         try { return objectMapper.readValue(line.getCartonMarksJson(), new com.fasterxml.jackson.core.type.TypeReference<List<String>>() {}); }
         catch (Exception e) { throw new IllegalStateException("Cannot read carton marks", e); }
     }
+    /** 无 SKU 来源保留未指定标记，不猜测商品。 */
     private static String sku(InventoryBalance balance) { return balance.getSkuCode() == null || balance.getSkuCode().isBlank() ? "UNSPECIFIED" : balance.getSkuCode(); }
+    /** 空库存桶按零处理。 */
     private static long value(Long value) { return value == null ? 0 : value; }
+    /** 返回可恢复的业务冲突。 */
     private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT, message); }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/mapper/DispatchBolMapper.java

@@ -1,30 +1,65 @@
 package com.baiyue.lastleg.dispatch.mapper;
-import com.baiyue.lastleg.dispatch.model.DispatchBolData;
+
 import org.apache.ibatis.annotations.*;
 import java.util.List;
-/** BOL按真实明细客户逐行读取整车，不依赖已移除的主单客户头。 */
+
+/** BOL读取原调度逐来源数量及真实预约分配，扫码进度和订单商品JOIN均不放大或缩小箱数。 */
 @Mapper
 public interface DispatchBolMapper {
-    @Select("SELECT di.customer_id AS customerId,di.destination_type AS destinationType,di.delivery_address AS deliveryAddress,di.postal_code AS postalCode," +
-        "COALESCE(MAX(NULLIF(o.container_no,'')),MAX(NULLIF(ip.container_no,''))) AS containerNo," +
-        "MAX(NULLIF(di.pallet_no,'')) AS palletNo," +
-        "COALESCE(MAX(NULLIF(l.destination_warehouse_code,'')),MAX(NULLIF(di.fba_warehouse_code,''))," +
-        "MAX(NULLIF(di.destination_warehouse_code,''))) AS fbaWarehouseCode," +
-        "COALESCE(MAX(NULLIF(l.destination_warehouse_name,'')),MAX(NULLIF(di.destination_warehouse_name,''))) AS destinationWarehouseName," +
-        "COALESCE(MAX(NULLIF(l.inbound_code,'')),MAX(NULLIF(di.inbound_code,''))) AS warehouseNo," +
-        "GROUP_CONCAT(DISTINCT NULLIF(od.shipment_no,'') ORDER BY od.shipment_no SEPARATOR ', ') AS fbaShipmentId," +
-        "GROUP_CONCAT(DISTINCT NULLIF(od.fba_tracking_no,'') ORDER BY od.fba_tracking_no SEPARATOR ', ') AS poReferenceNo," +
-        "CASE WHEN MAX(l.id) IS NULL THEN COALESCE(MAX(di.package_count),0) " +
-        "WHEN COALESCE(MAX(a.picked_package_count),0)>0 THEN MAX(a.picked_package_count) " +
-        "ELSE COALESCE(MAX(a.planned_package_count),0) END AS packageCount " +
-        "FROM ll_dispatch_item di " +
-        "LEFT JOIN ll_inbound_plan_pallet p ON p.id=di.plan_pallet_id " +
-        "LEFT JOIN ll_inbound_plan ip ON ip.id=p.plan_id AND ip.customer_id=di.customer_id " +
-        "LEFT JOIN ll_inbound_plan_pallet_allocation a ON a.pallet_id=p.id AND di.return_receipt_id IS NULL AND COALESCE(di.source_business_type,'')<>'RELABEL_ORDER' " +
-        "LEFT JOIN ll_inbound_plan_line l ON l.id=a.line_id AND l.customer_id=di.customer_id " +
-        "LEFT JOIN ll_order o ON o.id=l.order_id AND o.customer_id=di.customer_id " +
-        "LEFT JOIN ll_order_detail od ON od.order_id=l.order_id AND od.customer_id=di.customer_id " +
-        "WHERE di.dispatch_order_id=#{dispatchOrderId} " +
-        "GROUP BY di.id,di.customer_id,di.destination_type,di.delivery_address,di.postal_code,l.id ORDER BY di.id,l.id")
-    List<DispatchBolData.Line> findWholeDispatch(@Param("dispatchOrderId") Long dispatchOrderId);
+    record Cargo(Long dispatchItemId,Long orderId,Long planPalletId,String customerId,String destinationType,
+        String deliveryAddress,String postalCode,String containerNo,String palletNo,String fbaWarehouseCode,
+        String destinationWarehouseName,String warehouseNo,String fbaShipmentId,String poReferenceNo,
+        Integer packageCount,Integer itemPackageCount,boolean originalPlan) { }
+    record Allocation(Long dispatchItemId,Long planPalletId,String batchKey,String customerId,String sourceKey,
+        String destinationKey,Integer packageCount,Long appointmentId,Long orderId,String confirmationNo) { }
+
+    /** 一行对应本车一个真实计划来源行；商品明细只聚合展示字段，原调度数量不取部分已拣数。 */
+    @Select("""
+        SELECT di.id AS dispatchItemId,
+          CASE WHEN di.plan_pallet_id IS NOT NULL AND di.return_receipt_id IS NULL
+            AND COALESCE(di.source_business_type,'')<>'RELABEL_ORDER' THEN l.order_id ELSE di.order_id END AS orderId,
+          di.plan_pallet_id AS planPalletId,di.customer_id AS customerId,di.destination_type AS destinationType,
+          di.delivery_address AS deliveryAddress,di.postal_code AS postalCode,
+          COALESCE(MAX(NULLIF(o.container_no,'')),MAX(NULLIF(ip.container_no,''))) AS containerNo,
+          MAX(NULLIF(di.pallet_no,'')) AS palletNo,
+          COALESCE(MAX(NULLIF(l.fba_warehouse_code,'')),MAX(NULLIF(l.destination_warehouse_code,'')),
+            MAX(NULLIF(di.fba_warehouse_code,'')),MAX(NULLIF(di.destination_warehouse_code,''))) AS fbaWarehouseCode,
+          COALESCE(MAX(NULLIF(l.destination_warehouse_name,'')),MAX(NULLIF(di.destination_warehouse_name,''))) AS destinationWarehouseName,
+          COALESCE(MAX(NULLIF(l.inbound_code,'')),MAX(NULLIF(di.inbound_code,''))) AS warehouseNo,
+          GROUP_CONCAT(DISTINCT NULLIF(od.shipment_no,'') ORDER BY od.shipment_no SEPARATOR ', ') AS fbaShipmentId,
+          GROUP_CONCAT(DISTINCT NULLIF(od.fba_tracking_no,'') ORDER BY od.fba_tracking_no SEPARATOR ', ') AS poReferenceNo,
+          CASE WHEN l.id IS NULL THEN MAX(di.package_count)
+            WHEN di.source_stage='RECEIVED' THEN MAX(a.counted_package_count)
+            ELSE MAX(a.planned_package_count) END AS packageCount,
+          MAX(di.package_count) AS itemPackageCount,
+          CASE WHEN di.plan_pallet_id IS NOT NULL AND di.return_receipt_id IS NULL
+            AND COALESCE(di.source_business_type,'')<>'RELABEL_ORDER' THEN TRUE ELSE FALSE END AS originalPlan
+        FROM ll_dispatch_item di
+        LEFT JOIN ll_inbound_plan_pallet p ON p.id=di.plan_pallet_id
+        LEFT JOIN ll_inbound_plan ip ON ip.id=p.plan_id AND ip.customer_id=di.customer_id
+        LEFT JOIN ll_inbound_plan_pallet_allocation a ON a.pallet_id=p.id AND a.customer_id=di.customer_id
+          AND di.return_receipt_id IS NULL AND COALESCE(di.source_business_type,'')<>'RELABEL_ORDER'
+        LEFT JOIN ll_inbound_plan_line l ON l.id=a.line_id AND l.customer_id=di.customer_id AND l.plan_id=p.plan_id
+        LEFT JOIN ll_order o ON o.id=l.order_id AND o.customer_id=di.customer_id
+        LEFT JOIN ll_order_detail od ON od.order_id=l.order_id AND od.customer_id=l.customer_id
+        WHERE di.dispatch_order_id=#{dispatchOrderId}
+        GROUP BY di.id,di.order_id,di.plan_pallet_id,di.customer_id,di.destination_type,di.delivery_address,
+          di.postal_code,di.source_stage,di.return_receipt_id,di.source_business_type,l.id,l.order_id,a.id
+        ORDER BY di.id,l.id,a.id
+        """)
+    List<Cargo> findWholeDispatch(@Param("dispatchOrderId") long dispatchOrderId);
+
+    /** 原batch+客户+稳定来源+目的地定位预约货物；BOOKING使用持久化order_id，绝不自行拼ORDER键。 */
+    @Select("""
+        SELECT a.dispatch_item_id AS dispatchItemId,a.plan_pallet_id AS planPalletId,a.batch_key AS batchKey,
+          a.customer_id AS customerId,a.source_key AS sourceKey,a.destination_key AS destinationKey,
+          a.package_count AS packageCount,p.id AS appointmentId,i.order_id AS orderId,p.confirmation_no AS confirmationNo
+        FROM ll_dispatch_appointment_allocation a
+        LEFT JOIN ll_inbound_fba_appointment p ON a.batch_key=CONCAT('FBA_APPOINTMENT:',p.id)
+        LEFT JOIN ll_inbound_fba_appointment_item i ON i.appointment_id=p.id AND i.customer_id=a.customer_id
+          AND i.source_key=a.source_key AND CONCAT('FBA:',i.fba_warehouse_code)=a.destination_key
+        WHERE a.dispatch_id=#{dispatchOrderId} AND a.batch_key LIKE 'FBA_APPOINTMENT:%'
+        ORDER BY a.dispatch_item_id,a.customer_id,a.source_key,a.destination_key,a.batch_key
+        """)
+    List<Allocation> findAppointmentAllocations(@Param("dispatchOrderId") long dispatchOrderId);
 }

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/model/DispatchBolData.java

@@ -3,13 +3,17 @@ import java.time.LocalDateTime;
 import java.util.*;
 /** 打印服务内部一致快照，不恢复旧排车JSON协议。 */
 public record DispatchBolData(String dispatchNo,String overseasWarehouseId,String overseasWarehouseName,String carrierName,
-    String vehiclePlate,LocalDateTime estimatedArrivalAt,List<Line> bolLines,Map<String,String> appointmentNumbers) {
-    public record Line(String customerId,String destinationType,String deliveryAddress,String postalCode,String containerNo,
+    String vehiclePlate,LocalDateTime estimatedArrivalAt,List<Line> bolLines) {
+    public record Line(Long dispatchItemId,Long orderId,String customerId,String destinationType,String deliveryAddress,String postalCode,String containerNo,
         String palletNo,String fbaWarehouseCode,String destinationWarehouseName,String warehouseNo,String fbaShipmentId,
-        String poReferenceNo,int packageCount) {
+        String poReferenceNo,int packageCount,String appointmentNo) {
+        /** 外部确认号只去首尾空白，未取得真实约号时保留空。 */
+        public Line { appointmentNo=appointmentNo==null || appointmentNo.isBlank()?null:appointmentNo.strip(); }
+        /** 目的地身份不使用客户作为分组条件。 */
         public String destinationKey(){return com.baiyue.lastleg.fleet.trip.FleetDispatchGateway.destinationKey(destinationType,fbaWarehouseCode,null,deliveryAddress,postalCode);}
+        /** 打印展示使用业务名称或真实地址。 */
         public String destinationLabel(){return "PRIVATE".equals(destinationType)?deliveryAddress:destinationWarehouseName;}
-        public String groupKey(){return customerId+"\u0000"+destinationKey();}
+        /** 同目的地同约号跨客户合并，无号也可组成同目的地文档。 */
+        public String groupKey(){return destinationKey()+"\u0000"+Objects.requireNonNullElse(appointmentNo,"");}
     }
-    public String appointmentFor(Line line){return appointmentNumbers.get(line.groupKey());}
 }

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/pda/service/DispatchPickOrderAttributionService.java

@@ -20,7 +20,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import com.baiyue.lastleg.dispatch.repository.DispatchItemSourceRepository;
-import com.baiyue.lastleg.dispatch.service.DispatchItemSourceService;
+import com.baiyue.lastleg.dispatch.port.DispatchSourceAllocation;
 
 @Service
 public class DispatchPickOrderAttributionService {
@@ -39,7 +39,7 @@ public class DispatchPickOrderAttributionService {
 
     /** 第四来源分支链接真实冻结贡献，全部归属、履约计数和库存跟随原扫码事务提交。 */
     @org.springframework.transaction.annotation.Transactional(propagation=org.springframework.transaction.annotation.Propagation.MANDATORY)
-    public void attributeRelabel(String customerId,DispatchPdaPick pick,Long orderId,List<DispatchItemSourceService.Allocation> allocations) {
+    public void attributeRelabel(String customerId,DispatchPdaPick pick,Long orderId,List<DispatchSourceAllocation> allocations) {
         long packages=0,quantity=0;var seen=new java.util.HashSet<Long>();
         for(var allocation:allocations) {
             var source=allocation.dispatchItemSourceId()==null?null:relabelSources.find(allocation.dispatchItemSourceId());

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/port/DispatchSourceAllocation.java

@@ -0,0 +1,4 @@
+package com.baiyue.lastleg.dispatch.port;
+
+/** 一次真实拣货消费的冻结来源额度；件数未知时保留空，不接受请求伪造来源身份。 */
+public record DispatchSourceAllocation(Long dispatchItemSourceId, long packages, Long productQuantity) { }

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/repository/DispatchBolRepository.java

@@ -0,0 +1,17 @@
+package com.baiyue.lastleg.dispatch.repository;
+
+import com.baiyue.lastleg.dispatch.mapper.DispatchBolMapper;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+
+/** BOL专用只读事实入口，应用服务不直接持有Mapper。 */
+@Repository
+public class DispatchBolRepository {
+    private final DispatchBolMapper mapper;
+    /** 装配同一次事务使用的来源及分配读取。 */
+    public DispatchBolRepository(DispatchBolMapper mapper){this.mapper=mapper;}
+    /** 返回完整明细身份、原调度箱数及逐来源打印资料。 */
+    public List<DispatchBolMapper.Cargo> cargo(long dispatchId){return mapper.findWholeDispatch(dispatchId);}
+    /** 仅正式FBA预约分配有外部预约号；客户仓内部DISPATCH批次不伪造约号。 */
+    public List<DispatchBolMapper.Allocation> allocations(long dispatchId){return mapper.findAppointmentAllocations(dispatchId);}
+}

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/service/DispatchAggregateService.java

@@ -369,7 +369,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         var row=lockPlatform(actor,number);var identity=identity(actor,number,Action.SUBMIT_REVIEW,request.recordVersion(),request.idempotencyKey(),request);
         var original=commands.replay(actor,number,identity);if(original.isPresent())return original.get();
         requireEditing(row,request.recordVersion());
-        if(!Set.of(ReviewState.DRAFT.name(),ReviewState.DISPATCH_REJECTED.name(),ReviewState.LOADING_REJECTED.name()).contains(row.getReviewState()))throw conflict("当前审核已提交，请刷新核对");
+        if(!canSubmitReview(row.getReviewState()))throw conflict("当前审核已提交，请刷新核对");
         verifyReviewResources(row);
         if(n(row.getPackageCount())<=0 || repository.cargo(row.getId()).isEmpty())throw bad("空排车不能提交审核");
         long round=row.getReviewRound()+1;String basis=basis(row);
@@ -739,6 +739,12 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         if(!Status.ACTIVE.name().equals(row.getStatus()) || !Stage.BEFORE_LOADING.name().equals(row.getStage()) || n(row.getPickedPackageCount())>0 || n(row.getShippedPackageCount())>0) throw conflict("仅装车前且未扫码的有效排车可以调整货物");
     }
 
+    /** 提交资格和写入共用可重提状态，已进入两级待审的整车不得再次显示提交入口。 */
+    private static boolean canSubmitReview(String reviewState) {
+        return ReviewState.DRAFT.name().equals(reviewState) || ReviewState.DISPATCH_REJECTED.name().equals(reviewState)
+            || ReviewState.LOADING_REJECTED.name().equals(reviewState);
+    }
+
     /** 动作快照只反映实际当前资格，写入仍须再次加锁校验。 */
     Map<Action,Gate> actions(Actor actor,DispatchAggregate row) {
         var gates=new EnumMap<Action,Gate>(Action.class); boolean active=Status.ACTIVE.name().equals(row.getStatus());
@@ -746,7 +752,8 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         for(var action:Action.values()) {
             boolean state=switch(action) {
                 case CREATE -> actor.mode()==ActorMode.PLATFORM;
-                case EDIT,ADD_CARGO,REMOVE_CARGO,CANCEL,SUBMIT_REVIEW -> active && stage==Stage.BEFORE_LOADING && n(row.getPickedPackageCount())==0;
+                case EDIT,ADD_CARGO,REMOVE_CARGO,CANCEL -> active && stage==Stage.BEFORE_LOADING && n(row.getPickedPackageCount())==0;
+                case SUBMIT_REVIEW -> active && stage==Stage.BEFORE_LOADING && n(row.getPickedPackageCount())==0 && canSubmitReview(row.getReviewState());
                 case DISPATCH_REVIEW -> active && review==ReviewState.DISPATCH_PENDING;
                 case LOADING_REVIEW -> active && review==ReviewState.LOADING_PENDING;
                 case RETURN_TO_REVIEW -> active && stage==Stage.LOADING && n(row.getPickedPackageCount())==0;

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/service/DispatchBolPrintService.java

@@ -32,6 +32,7 @@ public class DispatchBolPrintService {
     @Resource private DomesticWarehouseDirectoryClient warehouses;
     @Value("${baiyue.security.internal-service-token:}") private String internalToken;
 
+    /** 按本车一致快照组装全部BOL，一次调用打印服务并保持一个PDF下载。 */
     public GeneratedPdf generate(String dispatchNo, String requestId) {
         DispatchBolData detail = dispatches.read(dispatchNo);
         if (detail.bolLines() == null || detail.bolLines().isEmpty()) {
@@ -54,6 +55,7 @@ public class DispatchBolPrintService {
         }
     }
 
+    /** 将同目的地同预约号的跨客户货物组装为独立分页BOL，无预约号时ISA保持空白。 */
     private List<PrintPdfClient.Document> documents(DispatchBolData detail) {
         String shipFromAddress = warehouseAddress(detail.overseasWarehouseId());
         Map<String, List<DispatchBolData.Line>> groups = new LinkedHashMap<>();
@@ -72,7 +74,7 @@ public class DispatchBolPrintService {
                         .map(line -> new PrintPdfClient.CargoRow(text(line.containerNo()), text(line.palletNo()), text(line.fbaWarehouseCode()),
                                 text(line.warehouseNo()), text(line.fbaShipmentId()), text(line.poReferenceNo()), line.packageCount())).toList();
                 documents.add(new PrintPdfClient.Document(text(detail.overseasWarehouseName()), shipFromAddress, text(detail.carrierName()),
-                        text(detail.appointmentFor(lines.get(0))), dateTime(detail.estimatedArrivalAt()), text(detail.vehiclePlate()), "—",
+                        lines.get(0).appointmentNo() == null ? "" : lines.get(0).appointmentNo().strip(), dateTime(detail.estimatedArrivalAt()), text(detail.vehiclePlate()), "—",
                         text(lines.get(0).fbaWarehouseCode()), destination, "—", text(detail.dispatchNo()), unique(lines, true), unique(lines, false),
                         total, page + 1, pages, rows));
                 offset = end;

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/service/DispatchBolReadService.java

@@ -1,31 +1,92 @@
 package com.baiyue.lastleg.dispatch.service;
+
 import com.baiyue.common.core.api.ResultCode;
 import com.baiyue.common.core.exception.BizException;
 import com.baiyue.lastleg.dispatch.model.DispatchBolData;
 import com.baiyue.lastleg.dispatch.mapper.DispatchBolMapper;
 import com.baiyue.lastleg.dispatch.repository.DispatchAggregateRepository;
+import com.baiyue.lastleg.dispatch.repository.DispatchBolRepository;
 import com.baiyue.lastleg.dispatch.port.DispatchContracts.Resources;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.*;
 import java.time.*;
 import java.util.*;
-import java.util.stream.Collectors;
-/** 先在本地一致事务读全车打印事实，事务结束后才调用远程打印。 */
+
+/** 同一只读事务内核实本车逐来源数量，再按真实预约份额拆行；事务结束后才调用远程打印。 */
 @Service
 public class DispatchBolReadService {
-    private final DispatchAggregateRepository roots;private final DispatchBolMapper lines;private final ObjectMapper json;
-    public DispatchBolReadService(DispatchAggregateRepository roots,DispatchBolMapper lines,ObjectMapper json){this.roots=roots;this.lines=lines;this.json=json;}
+    private final DispatchAggregateRepository roots;private final DispatchBolRepository facts;private final ObjectMapper json;
+    private record Source(Long itemId,String customerId,Long orderId,String destinationKey) { }
+    private record AllocationKey(Long itemId,String batchKey,String customerId,String sourceKey,String destinationKey) { }
+    /** 打印读取只经Repository，不写预约、调度或库存事实。 */
+    public DispatchBolReadService(DispatchAggregateRepository roots,DispatchBolRepository facts,ObjectMapper json){this.roots=roots;this.facts=facts;this.json=json;}
+
+    /** 保留原调度总量，未约部分以空约号打印，不按部分拣货进度缩量。 */
     @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
     public DispatchBolData read(String number) {
         var row=roots.find(number);if(row==null)throw new BizException(ResultCode.NOT_FOUND,"排车单不存在");
         Resources resources;try{resources=json.readValue(row.getResourcesJson(),Resources.class);}catch(com.fasterxml.jackson.core.JsonProcessingException e){throw new IllegalStateException("本车资源快照损坏",e);}
-        var cargo=lines.findWholeDispatch(row.getId());
-        if(cargo.stream().anyMatch(l->l.customerId()==null || l.destinationKey()==null || l.packageCount()<=0))throw new BizException(ResultCode.VALIDATION_FAILED,"BOL货物客户、目的地或箱数尚未核实");
-        var confirmations=new LinkedHashMap<String,LinkedHashSet<String>>();
-        for(var batch:roots.batches(row.getId()))if(batch.confirmationNo()!=null && !batch.confirmationNo().isBlank())confirmations.computeIfAbsent(batch.customerId()+"\u0000"+batch.destinationKey(),k->new LinkedHashSet<>()).add(batch.confirmationNo());
-        var numbers=confirmations.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey,e->String.join(", ",e.getValue())));
+        var cargo=new LinkedHashMap<Source,DispatchBolData.Line>();var totals=new HashMap<Long,Integer>();var pallets=new HashMap<Long,Long>();
+        for(var raw:facts.cargo(row.getId())) {
+            int packages=nonnegative(raw.packageCount());var line=line(raw,null,packages);
+            if(raw.dispatchItemId()==null || blank(raw.customerId()) || line.destinationKey()==null
+                || raw.originalPlan() && raw.orderId()==null)throw invalid();
+            int total=positive(raw.itemPackageCount());var prior=totals.putIfAbsent(raw.dispatchItemId(),total);
+            if(prior!=null && prior!=total)throw invalid();
+            if(pallets.containsKey(raw.dispatchItemId()) && !Objects.equals(pallets.get(raw.dispatchItemId()),raw.planPalletId()))throw invalid();
+            pallets.put(raw.dispatchItemId(),raw.planPalletId());
+            if(packages==0)continue;
+            var key=new Source(raw.dispatchItemId(),raw.customerId(),raw.orderId(),line.destinationKey());
+            cargo.merge(key,line,DispatchBolReadService::merge);
+        }
+        var sourceTotals=new HashMap<Long,Integer>();
+        cargo.forEach((key,line)->sourceTotals.merge(key.itemId(),line.packageCount(),Math::addExact));
+        if(!sourceTotals.equals(totals))throw invalid();
+        var remaining=new LinkedHashMap<Source,Integer>();cargo.forEach((key,line)->remaining.put(key,line.packageCount()));
+        var seen=new HashSet<AllocationKey>();var result=new ArrayList<DispatchBolData.Line>();
+        for(var allocation:facts.allocations(row.getId())) {
+            if(allocation.appointmentId()==null || allocation.orderId()==null || blank(allocation.sourceKey())
+                || !Objects.equals(pallets.get(allocation.dispatchItemId()),allocation.planPalletId()))throw invalid();
+            var key=new Source(allocation.dispatchItemId(),allocation.customerId(),allocation.orderId(),allocation.destinationKey());
+            var source=cargo.get(key);int count=positive(allocation.packageCount());
+            if(source==null || !seen.add(new AllocationKey(allocation.dispatchItemId(),allocation.batchKey(),allocation.customerId(),allocation.sourceKey(),allocation.destinationKey()))
+                || count>remaining.get(key))throw invalid();
+            remaining.put(key,remaining.get(key)-count);result.add(copy(source,count,allocation.confirmationNo()));
+        }
+        // 每个来源只消费实际分配份额，余额有明确实物依据，保持空ISA而非重复整托。
+        remaining.forEach((key,count)->{if(count>0)result.add(copy(cargo.get(key),count,null));});
+        var printedTotals=new HashMap<Long,Integer>();result.forEach(line->printedTotals.merge(line.dispatchItemId(),line.packageCount(),Math::addExact));
+        if(!printedTotals.equals(totals))throw invalid();
         return new DispatchBolData(row.getDispatchNo(),row.getOverseasWarehouseId(),row.getOverseasWarehouseName(),resources.vehicle()==null?null:resources.vehicle().carrierName(),resources.vehicle()==null?null:resources.vehicle().plate(),
-            row.getEstimatedArrivalAt()==null?null:LocalDateTime.ofInstant(row.getEstimatedArrivalAt().toInstant(ZoneOffset.UTC),ZoneId.systemDefault()),List.copyOf(cargo),Map.copyOf(numbers));
+            row.getEstimatedArrivalAt()==null?null:LocalDateTime.ofInstant(row.getEstimatedArrivalAt().toInstant(ZoneOffset.UTC),ZoneId.systemDefault()),List.copyOf(result));
     }
+    /** 将数据库原始来源行转换为带真实身份的内部打印行。 */
+    private static DispatchBolData.Line line(DispatchBolMapper.Cargo c,String appointment,int packages) {
+        return new DispatchBolData.Line(c.dispatchItemId(),c.orderId(),c.customerId(),c.destinationType(),c.deliveryAddress(),c.postalCode(),c.containerNo(),c.palletNo(),
+            c.fbaWarehouseCode(),c.destinationWarehouseName(),c.warehouseNo(),c.fbaShipmentId(),c.poReferenceNo(),packages,appointment);
+    }
+    /** 拆份只改变份额和预约号，真实客户、源订单和排车明细身份不变。 */
+    private static DispatchBolData.Line copy(DispatchBolData.Line c,int packages,String appointment) {
+        return new DispatchBolData.Line(c.dispatchItemId(),c.orderId(),c.customerId(),c.destinationType(),c.deliveryAddress(),c.postalCode(),c.containerNo(),c.palletNo(),
+            c.fbaWarehouseCode(),c.destinationWarehouseName(),c.warehouseNo(),c.fbaShipmentId(),c.poReferenceNo(),packages,appointment);
+    }
+    /** 同订单多来源行先守恒合并，再让每条预约分配消费一次；展示字符串只去重合并。 */
+    private static DispatchBolData.Line merge(DispatchBolData.Line a,DispatchBolData.Line b) {
+        return new DispatchBolData.Line(a.dispatchItemId(),a.orderId(),a.customerId(),a.destinationType(),a.deliveryAddress(),a.postalCode(),join(a.containerNo(),b.containerNo()),a.palletNo(),
+            a.fbaWarehouseCode(),a.destinationWarehouseName(),join(a.warehouseNo(),b.warehouseNo()),join(a.fbaShipmentId(),b.fbaShipmentId()),join(a.poReferenceNo(),b.poReferenceNo()),Math.addExact(a.packageCount(),b.packageCount()),null);
+    }
+    /** 仅打印展示字段去重，不用逗号字符串表示预约身份。 */
+    private static String join(String a,String b) {
+        var values=new LinkedHashSet<String>();for(var text:Arrays.asList(a,b))if(text!=null)for(var part:text.split(","))if(!part.isBlank())values.add(part.strip());
+        return values.isEmpty()?null:String.join(", ",values);
+    }
+    /** 数量未知或非正不得伪造打印份额。 */
+    private static int positive(Integer value){if(value==null || value<=0)throw invalid();return value;}
+    /** 已核实为零的源行没有待打印货物，但不以零替代未知数量。 */
+    private static int nonnegative(Integer value){if(value==null || value<0)throw invalid();return value;}
+    /** 来源身份必须来自真实持久事实。 */
+    private static boolean blank(String value){return value==null || value.isBlank();}
+    /** 不完整、跨客户或超额分配不能生成看似守恒的BOL。 */
+    private static BizException invalid(){return new BizException(ResultCode.VALIDATION_FAILED,"BOL货物来源、预约归属或分配箱数尚未核实");}
 }

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/service/DispatchItemSourceService.java

@@ -6,6 +6,7 @@ import com.baiyue.common.core.exception.BizException;
 import com.baiyue.lastleg.dispatch.entity.*;
 import com.baiyue.lastleg.dispatch.mapper.DispatchSourceMapper;
 import com.baiyue.lastleg.dispatch.repository.DispatchItemSourceRepository;
+import com.baiyue.lastleg.dispatch.port.DispatchSourceAllocation;
 import com.baiyue.lastleg.relabel.port.RelabelDispatchSourcePort;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.stereotype.Service;
@@ -23,9 +24,6 @@ public class DispatchItemSourceService {
     /** 来源事实经提供者读取，冻结贡献及已消费数经本域仓储读取。 */
     public DispatchItemSourceService(DispatchItemSourceRepository repository,RelabelDispatchSourcePort relabel,ObjectMapper json){this.repository=repository;this.relabel=relabel;this.json=json;}
 
-    /** packages是本次实际消费量，件数未知保留空；不是请求可伪造的来源身份。 */
-    public record Allocation(Long dispatchItemSourceId,long packages,Long productQuantity) { }
-
     /** 主单原事务已锁齐全部来源与库存；所有当前成员一起核对，仅为新增明细追加不可变快照。 */
     @Transactional(propagation=Propagation.MANDATORY)
     public void capture(DispatchAggregate root,List<DispatchItem> all,List<DispatchItem> added,LocalDateTime at) {
@@ -108,7 +106,7 @@ public class DispatchItemSourceService {
 
     /** 本客户本实托的全部剩余贡献必须累计核对HOLD，逐item单独足够不能证明共享position总量足够。 */
     @Transactional(propagation=Propagation.MANDATORY)
-    public List<Allocation> allocate(long dispatch,DispatchItem item,long positionId,long packages,long productQuantity,String cartonMark,List<DispatchSourceMapper.Stock> actualStock) {
+    public List<DispatchSourceAllocation> allocate(long dispatch,DispatchItem item,long positionId,long packages,long productQuantity,String cartonMark,List<DispatchSourceMapper.Stock> actualStock) {
         var all=repository.all(dispatch);var consumed=repository.pickedAll(List.of(dispatch)).stream().collect(Collectors.toMap(p->p.sourceId(),p->p));
         var expected=new HashMap<Long,Long>();
         for(var source:all)if(Objects.equals(item.getCustomerId(),source.getCustomerId()) && Objects.equals(item.getWarehousePalletId(),source.getWarehousePalletId())) {
@@ -127,14 +125,14 @@ public class DispatchItemSourceService {
         for(var row:rows){long left=row.getPackageCount()-(consumed.containsKey(row.getId())?consumed.get(row.getId()).packages():0);remaining.put(row.getId(),left);total=Math.addExact(total,left);}
         if(packages<=0 || packages>total)throw conflict("实际扫码超过本换标来源本位置的剩余箱数");
         if(rows.size()>1 && packages!=total)throw conflict("本位置含多条换标贡献，请扫描具体箱唛后确认部分箱数");
-        var result=new ArrayList<Allocation>();long knownQuantity=0;
+        var result=new ArrayList<DispatchSourceAllocation>();long knownQuantity=0;
         for(var row:rows)if(row.getProductQuantity()!=null){long used=consumed.containsKey(row.getId())?consumed.get(row.getId()).productQuantity():0;long left=row.getProductQuantity()-used;if(left<0)throw conflict("换标实际件数超过来源贡献");knownQuantity=Math.addExact(knownQuantity,left);}
         if(rows.size()>1) {
             if(productQuantity!=knownQuantity)throw conflict("多来源件数不能推算，请扫描明确箱唛并确认实际件数");
-            for(var row:rows){Long quantity=row.getProductQuantity()==null?null:row.getProductQuantity()-(consumed.containsKey(row.getId())?consumed.get(row.getId()).productQuantity():0);result.add(new Allocation(row.getId(),remaining.get(row.getId()),quantity));}
+            for(var row:rows){Long quantity=row.getProductQuantity()==null?null:row.getProductQuantity()-(consumed.containsKey(row.getId())?consumed.get(row.getId()).productQuantity():0);result.add(new DispatchSourceAllocation(row.getId(),remaining.get(row.getId()),quantity));}
         } else {
             var row=rows.get(0);if(row.getProductQuantity()!=null && (productQuantity>knownQuantity || packages==total && productQuantity!=knownQuantity))throw conflict("实际扫码件数与本来源剩余件数不一致");
-            result.add(new Allocation(row.getId(),packages,row.getProductQuantity()==null && productQuantity==0?null:productQuantity));
+            result.add(new DispatchSourceAllocation(row.getId(),packages,row.getProductQuantity()==null && productQuantity==0?null:productQuantity));
         }
         return List.copyOf(result);
     }

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/service/DispatchPickingService.java

@@ -65,7 +65,7 @@ public class DispatchPickingService {
         boolean nativeReturn="RETURN_RELABEL".equals(item.getSourceStage());
         if(nativeReturn?request.positionId()!=null:request.positionId()==null)throw bad(nativeReturn?"退货换标请扫描来源箱唛":"普通入仓请选本托实际库存仓位");
         long pickId=IdWorker.getId();Long returnCartonId=null;boolean ordinaryRelabel=!nativeReturn && "RELABEL_ORDER".equals(item.getSourceBusinessType());
-        List<DispatchItemSourceService.Allocation> relabelAllocations=List.of();
+        List<DispatchSourceAllocation> relabelAllocations=List.of();
         if(nativeReturn) {
             attribution.prepareNativeReturn(item.getCustomerId(),item.getOrderId());
             returnCartonId=returns.pick(item,request.cartonMark(),request.packages(),request.productQuantity(),pickId,number).getId();

lastleg-service/src/main/java/com/baiyue/lastleg/dto/LastlegOrderSummary.java

@@ -75,7 +75,9 @@ public record LastlegOrderSummary(
     LocalDateTime updatedAt,
     @Schema(description = "同一主单关联的全部换标子单及各自状态，按创建时间排序")
     List<RelabelSubOrder> relabelApplications,
-    BusinessSource businessSource
+    BusinessSource businessSource,
+    @Schema(description = "仓储转运专属预报、历史实收及当前箱托数量；其他业务为空")
+    com.baiyue.lastleg.transfer.dto.TransferQuantityView warehouseTransferQuantity
 ) {
     @Schema(description = "从正式单据关联读取的商业来源；与履约类型 orderType 独立")
     public record BusinessSource(String businessType, String label, String businessOrderNo, String externalBookingNo) { }

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/pickup/FleetPickupMapper.java

@@ -1,13 +1,14 @@
 package com.baiyue.lastleg.fleet.pickup;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder;
 import org.apache.ibatis.annotations.*;
 import java.util.List;
 
 /** 取货持久化只访问 Lastleg 自有库，客户与原业务号始终成对使用。 */
 @Mapper
 public interface FleetPickupMapper extends BaseMapper<FleetPickupTask> {
+    String SOURCE_COLUMNS = "id,customer_id,transfer_no,inbound_code,lastleg_order_no,operating_warehouse_id,"
+        + "delivery_address,pickup_contact_name,pickup_contact_phone,package_count,status,delivery_method";
     String ELIGIBLE = " FROM ll_warehouse_transfer_order w LEFT JOIN ll_fleet_pickup_task p ON p.transfer_order_id=w.id "
         + "WHERE w.delivery_method='WAREHOUSE_PICKUP' AND w.transfer_no=w.inbound_code "
         + "AND w.status='WAIT_PDA_RECEIVING' AND (p.transfer_order_id IS NULL OR p.trip_no IS NULL) "
@@ -21,14 +22,11 @@ public interface FleetPickupMapper extends BaseMapper<FleetPickupTask> {
     @Select("SELECT COUNT(*)" + ELIGIBLE)
     long countCandidates(@Param("keyword") String keyword);
     /** 锁定源订单，串行化补箱、清点与取货任务关联。 */
-    @Select("SELECT * FROM ll_warehouse_transfer_order WHERE customer_id=#{customer} AND transfer_no=#{number} FOR UPDATE")
-    WarehouseTransferOrder lockSource(@Param("customer") String customer,@Param("number") String number);
+    @Select("SELECT " + SOURCE_COLUMNS + " FROM ll_warehouse_transfer_order WHERE customer_id=#{customer} AND transfer_no=#{number} FOR UPDATE")
+    FleetPickupSource lockSource(@Param("customer") String customer,@Param("number") String number);
     /** 读取明确客户下的源订单，不接收来自客户端的客户范围推断。 */
-    @Select("SELECT * FROM ll_warehouse_transfer_order WHERE customer_id=#{customer} AND transfer_no=#{number}")
-    WarehouseTransferOrder source(@Param("customer") String customer,@Param("number") String number);
-    /** PDA 作业仍按已绑定海外仓锁定原单。 */
-    @Select("SELECT * FROM ll_warehouse_transfer_order WHERE operating_warehouse_id=#{warehouse} AND transfer_no=#{number} FOR UPDATE")
-    WarehouseTransferOrder lockPdaSource(@Param("warehouse") String warehouse,@Param("number") String number);
+    @Select("SELECT " + SOURCE_COLUMNS + " FROM ll_warehouse_transfer_order WHERE customer_id=#{customer} AND transfer_no=#{number}")
+    FleetPickupSource source(@Param("customer") String customer,@Param("number") String number);
     /** 读取取货任务，原订单锁负责同票并发互斥。 */
     @Select("SELECT * FROM ll_fleet_pickup_task WHERE transfer_order_id=#{id}")
     FleetPickupTask task(@Param("id") long id);

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/pickup/FleetPickupRepository.java

@@ -2,7 +2,6 @@ package com.baiyue.lastleg.fleet.pickup;
 
 import com.baiyue.lastleg.fleet.trip.FleetTripEntity;
 import com.baiyue.lastleg.fleet.trip.FleetTripMapper;
-import com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder;
 import org.springframework.stereotype.Repository;
 import java.util.List;
 
@@ -18,9 +17,7 @@ public class FleetPickupRepository {
     /** 查询匹配需求总数。 */
     public long count(String keyword) { return mapper.countCandidates(keyword); }
     /** 读取或锁定客户原单。 */
-    public WarehouseTransferOrder source(String customer,String number,boolean lock) { return lock?mapper.lockSource(customer,number):mapper.source(customer,number); }
-    /** 按 PDA 仓库范围锁定原单。 */
-    public WarehouseTransferOrder pdaSource(String warehouse,String number) { return mapper.lockPdaSource(warehouse,number); }
+    public FleetPickupSource source(String customer,String number,boolean lock) { return lock?mapper.lockSource(customer,number):mapper.source(customer,number); }
     /** 读取原单唯一取货记录。 */
     public FleetPickupTask task(long id) { return mapper.task(id); }
     /** 读取车次全部取货成员。 */

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/pickup/FleetPickupService.java

@@ -6,7 +6,6 @@ import com.baiyue.lastleg.fleet.driver.FleetWarehouseDirectory;
 import com.baiyue.lastleg.fleet.reporting.TripOperationsEvidenceGateway;
 import com.baiyue.lastleg.fleet.trip.*;
 import com.baiyue.lastleg.masterdata.vehicle.application.port.out.VehicleRepository;
-import com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.http.HttpStatus;
@@ -59,7 +58,7 @@ public class FleetPickupService {
         var sources=request.sources().stream().sorted(Comparator.comparing(FleetPickupModels.Source::customerId)
             .thenComparing(FleetPickupModels.Source::transferNo)).toList();
         if(new HashSet<>(sources).size()!=sources.size())throw bad("同一取货单不能重复选择");
-        var orders=new ArrayList<WarehouseTransferOrder>();
+        var orders=new ArrayList<FleetPickupSource>();
         for(var source:sources) {
             var order=source(source.customerId(),source.transferNo(),true);eligible(order);
             // 相同请求并发等待原单锁后，允许返回第一次已经成功的车次。
@@ -107,18 +106,10 @@ public class FleetPickupService {
         if(!"WAREHOUSE_PICKUP".equals(source.getDeliveryMethod()) || !source.getTransferNo().equals(source.getInboundCode()))return null;
         return project(source,repository.task(source.getId()));
     }
-    /** PDA 开始作业前校验已送仓，防止把司机取货冒充仓库实收。 */
-    public WarehouseTransferOrder requireMeasuringSource(String warehouse,String number) {
-        var source=repository.pdaSource(warehouse,number);
-        if(source==null)throw missing("仓储转运单不存在");
-        if(!"WAIT_PDA_RECEIVING".equals(source.getStatus()))throw conflict("当前转运单不允许测量");
-        requireArrived(source);
-        return source;
-    }
     /** 已有原单行锁的清点、照片和完成入口复用相同到仓门禁。 */
-    public void requireArrived(WarehouseTransferOrder source) {
-        if("WAREHOUSE_PICKUP".equals(source.getDeliveryMethod()) && source.getTransferNo().equals(source.getInboundCode())) {
-            var task=repository.task(source.getId());
+    public void requireArrived(Long sourceId,String deliveryMethod,String transferNo,String inboundCode) {
+        if("WAREHOUSE_PICKUP".equals(deliveryMethod) && transferNo.equals(inboundCode)) {
+            var task=repository.task(sourceId);
             if(task==null || !"ARRIVED".equals(task.getStatus()))throw conflict("该单为仓库上门取货，请先完成车辆取货送仓");
         }
     }
@@ -198,7 +189,7 @@ public class FleetPickupService {
         var trip=pickupTrip(task.getTripNo(),false);return files.download(trip.getId(),fileId);
     }
     /** 组装运输进度，车次资源修改后自然回显最新分配。 */
-    private FleetPickupModels.Task project(WarehouseTransferOrder source,FleetPickupTask task) {
+    private FleetPickupModels.Task project(FleetPickupSource source,FleetPickupTask task) {
         var trip=task==null || task.getTripNo()==null?null:repository.trip(task.getTripNo(),false);
         String status=task==null || task.getTripNo()==null?("PENDING_REVIEW".equals(source.getStatus()) || "DRAFT".equals(source.getStatus())?"PENDING_REVIEW":"WAITING"):task.getStatus();
         return new FleetPickupModels.Task(source.getCustomerId(),source.getTransferNo(),source.getLastlegOrderNo(),source.getOperatingWarehouseId(),
@@ -215,11 +206,11 @@ public class FleetPickupService {
         if(task==null || !trip.getTripNo().equals(task.getTripNo()))throw missing("当前车次没有该取货订单");return task;
     }
     /** 按客户与单号读取原订单。 */
-    private WarehouseTransferOrder source(String customer,String number,boolean lock) {
+    private FleetPickupSource source(String customer,String number,boolean lock) {
         var source=repository.source(customer,number,lock);if(source==null)throw missing("仓储转运单不存在");return source;
     }
     /** 原业务资格每次执行复核，禁止未审、自送、库存转运和已完成测量单进入。 */
-    private static void eligible(WarehouseTransferOrder order) {
+    private static void eligible(FleetPickupSource order) {
         if(!"WAREHOUSE_PICKUP".equals(order.getDeliveryMethod()) || !order.getTransferNo().equals(order.getInboundCode())
             || !"WAIT_PDA_RECEIVING".equals(order.getStatus()))throw conflict("该单不是已审核待收货的仓库上门取货单");
         if(blank(order.getDeliveryAddress())==null || blank(order.getPickupContactName())==null || blank(order.getPickupContactPhone())==null)

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/pickup/FleetPickupSource.java

@@ -0,0 +1,20 @@
+package com.baiyue.lastleg.fleet.pickup;
+
+import lombok.Data;
+
+/** 车队只读取货资格和展示所需来源摘要，不共享转运领域实体或写入原订单。 */
+@Data
+public class FleetPickupSource {
+    private Long id;
+    private String customerId;
+    private String transferNo;
+    private String inboundCode;
+    private String lastlegOrderNo;
+    private String operatingWarehouseId;
+    private String deliveryAddress;
+    private String pickupContactName;
+    private String pickupContactPhone;
+    private Integer packageCount;
+    private String status;
+    private String deliveryMethod;
+}

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/FleetTripCalendarRow.java

@@ -0,0 +1,12 @@
+package com.baiyue.lastleg.fleet.trip;
+
+/** 日历专用只读查询投影，真实排车号不属于车次持久化字段。 */
+public class FleetTripCalendarRow extends FleetTripEntity {
+    private String dispatchNo;
+
+    /** 返回关联整车主单的业务号。 */
+    public String getDispatchNo() { return dispatchNo; }
+
+    /** 仅供日历SQL结果映射，不写入车次表。 */
+    public void setDispatchNo(String dispatchNo) { this.dispatchNo = dispatchNo; }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/FleetTripCalendarService.java

@@ -11,10 +11,10 @@ import org.springframework.web.server.ResponseStatusException;
 import java.time.*;
 import java.util.*;
 
-/** Read-only transport plans. A trip is never evidence of a receiving appointment confirmation. */
+/** 排车日历沿真实整车主单读取运输时间，不代表已取得目的仓收货确认。 */
 @Service
 public class FleetTripCalendarService {
-    public record Entry(String sourceType, String tripNo, String status, String originWarehouseId,
+    public record Entry(String sourceType, String dispatchNo, String status, String originWarehouseId,
         String originWarehouseCode, String originWarehouseName, String originCountryCode,
         String originTimezone, String originWarehouseStatus, Instant plannedDepartureAt,
         Instant expectedDriverEndAt, Instant departedAt, Instant completedAt,
@@ -31,12 +31,13 @@ public class FleetTripCalendarService {
         this.trips=trips; this.warehouses=warehouses; this.json=json; this.token=token;
     }
 
+    /** 一次读取真实排车及一次仓库资料查询，按业务地点判定日历归属。 */
     @Transactional(readOnly=true)
     public Result calendar(Instant from, Instant to) {
         if (from==null || to==null || !to.isAfter(from) || Duration.between(from,to).compareTo(Duration.ofDays(44))>0)
             throw new ResponseStatusException(HttpStatus.BAD_REQUEST,"查询须为不超过44天的UTC时间范围");
         var rows=trips.calendar(LocalDateTime.ofInstant(from,ZoneOffset.UTC),LocalDateTime.ofInstant(to,ZoneOffset.UTC));
-        if (rows.size()>2000) throw new ResponseStatusException(HttpStatus.BAD_REQUEST,"车次过多，请缩小查询日期范围");
+        if (rows.size()>2000) throw new ResponseStatusException(HttpStatus.BAD_REQUEST,"排车过多，请缩小查询日期范围");
         if (rows.isEmpty()) return new Result(List.of(),List.of());
         var ids=rows.stream().map(FleetTripEntity::getWarehouseId).filter(Objects::nonNull).filter(id->id>0).distinct().sorted().toList();
         var metadata=metadata(ids);
@@ -60,7 +61,7 @@ public class FleetTripCalendarService {
                     throw new IllegalArgumentException("incomplete route");
                 stops=List.copyOf(stops);
             } catch (Exception invalid) { stops=List.of(); reasons.add("ROUTE_INCOMPLETE"); }
-            var entry=new Entry("TRIP_PLAN",row.getTripNo(),row.getStatus(),row.getWarehouseId()==null?null:row.getWarehouseId().toString(),
+            var entry=new Entry("DISPATCH",row.getDispatchNo(),row.getStatus(),row.getWarehouseId()==null?null:row.getWarehouseId().toString(),
                 warehouse==null?row.getWarehouseCode():warehouse.warehouseCode(),warehouse==null?row.getWarehouseName():warehouse.warehouseName(),
                 country,zone,warehouse==null?null:warehouse.status(),instant(row.getPlannedDepartureAt()),instant(row.getExpectedDriverEndAt()),
                 instant(row.getDepartedAt()),instant(row.getCompletedAt()),stops,List.copyOf(reasons));

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/FleetTripMapper.java

@@ -7,17 +7,18 @@ import org.apache.ibatis.annotations.Select;
 
 @Mapper
 public interface FleetTripMapper extends BaseMapper<FleetTripEntity> {
-    /** 预约日历只读海外仓出库派送，取货入仓车次不属于排车类型。 */
+    /** 日历只读真实整车主单的出库派送，一单一条；独立车次及取消主单不进入排车日历。 */
     @Select("""
-        SELECT trip_no,status,warehouse_id,warehouse_code,warehouse_name,planned_departure_at,
-          expected_driver_end_at,departed_at,completed_at,stops_json
-        FROM ll_fleet_trip
-        WHERE trip_purpose='DELIVERY' AND (
-          (departed_at IS NOT NULL AND departed_at>=#{from} AND departed_at<#{to})
-           OR (departed_at IS NULL AND planned_departure_at>=#{from} AND planned_departure_at<#{to}))
-        ORDER BY COALESCE(departed_at,planned_departure_at),trip_no LIMIT 2001
+        SELECT d.dispatch_no,t.trip_no,t.status,t.warehouse_id,t.warehouse_code,t.warehouse_name,t.planned_departure_at,
+          t.expected_driver_end_at,t.departed_at,t.completed_at,t.stops_json
+        FROM ll_dispatch_order d JOIN ll_fleet_trip t ON t.id=d.trip_id
+        WHERE d.status='ACTIVE' AND d.dispatch_no IS NOT NULL AND TRIM(d.dispatch_no)<>''
+          AND t.trip_purpose='DELIVERY' AND (
+          (t.departed_at IS NOT NULL AND t.departed_at>=#{from} AND t.departed_at<#{to})
+           OR (t.departed_at IS NULL AND t.planned_departure_at>=#{from} AND t.planned_departure_at<#{to}))
+        ORDER BY COALESCE(t.departed_at,t.planned_departure_at),d.dispatch_no LIMIT 2001
         """)
-    java.util.List<FleetTripEntity> calendar(@Param("from") java.time.LocalDateTime from,@Param("to") java.time.LocalDateTime to);
+    java.util.List<FleetTripCalendarRow> calendar(@Param("from") java.time.LocalDateTime from,@Param("to") java.time.LocalDateTime to);
     @Select("SELECT * FROM ll_fleet_trip WHERE trip_no=#{tripNo} FOR UPDATE")
     FleetTripEntity lockByNo(@Param("tripNo") String tripNo);
     @Select("SELECT * FROM ll_fleet_trip WHERE trip_no=#{tripNo}")

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/trip/PlatformFleetTripController.java

@@ -18,13 +18,14 @@ import org.springframework.web.server.ResponseStatusException;
 @RequestMapping("/api/platform/v1/last-leg/fleet/trips")
 public class PlatformFleetTripController {
     @jakarta.annotation.Resource private FleetTripCalendarService calendar;
+    /** 预约排车日历沿用真实排车列表读取权限，不要求已退出菜单的车次管理权限。 */
     @GetMapping("/calendar")
-    @PreAuthorize("hasAuthority('platform:fleet:trip:list')")
+    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
     public ApiResponse<FleetTripCalendarService.Result> calendar(@AuthenticationPrincipal AuthenticatedUser user,
         @RequestParam java.time.Instant from,@RequestParam java.time.Instant to) {
         operator(user);
         if (!"PLATFORM".equals(user.appCode()) || !Long.valueOf(0).equals(user.tenantId()))
-            throw new ResponseStatusException(HttpStatus.FORBIDDEN,"仅平台主体可读取车次日历");
+            throw new ResponseStatusException(HttpStatus.FORBIDDEN,"仅平台主体可读取排车日历");
         return ApiResponse.success(calendar.calendar(from,to));
     }
 

lastleg-service/src/main/java/com/baiyue/lastleg/inventory/query/controller/InventoryQueryController.java

@@ -35,6 +35,16 @@ public class InventoryQueryController {
     private static final String BASE_PATH = "/api/platform/v1/last-leg/inventory";
 
     @Resource private InventoryQueryService service;
+    @Resource private com.baiyue.lastleg.inventory.query.service.InventoryPieceService pieces;
+
+    /** 完整筛选读取当前可用件数、箱内全部SKU及未知箱数，不改变原有箱数契约。 */
+    @GetMapping(BASE_PATH + "/piece-projection")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.INVENTORY_LIST + "')")
+    public ApiResponse<com.baiyue.lastleg.inventory.query.dto.InventoryPieceProjection> pieceProjection(
+        @AuthenticationPrincipal AuthenticatedUser user,@RequestParam(required=false) String customerId,
+        @Valid InventoryQueryRequests.BalanceQuery query) {
+        return ApiResponse.success(pieces.project(platformScope(user,customerId),query));
+    }
 
     @GetMapping(BASE_PATH + "/summary")
     @PreAuthorize("hasAuthority('" + OverseasPermissions.INVENTORY_LIST + "')")

lastleg-service/src/main/java/com/baiyue/lastleg/inventory/query/dto/InventoryPieceProjection.java

@@ -0,0 +1,14 @@
+package com.baiyue.lastleg.inventory.query.dto;
+import java.util.List;
+/** 当前严格可用件数与完整混箱SKU内容；不完整映射保持未知，不覆盖原有箱数API。 */
+public record InventoryPieceProjection(Long availablePieceCount,long knownAvailablePieceCount,long unknownCartonCount,
+    long availableCartonCount,long availablePalletCount,List<Group> groups) {
+    /** 与通用库存按客户、仓、目的仓、记账SKU分组对齐，箱内SKU不重复累计物理箱。 */
+    public record Group(String customerId,String warehouseId,String destinationCode,String anchorSkuCode,
+        Long availablePieceCount,long knownAvailablePieceCount,long unknownCartonCount,long availableCartonCount,
+        long availablePalletCount,List<Sku> skuContents,List<Carton> cartons) { }
+    /** 箱内实际SKU件数。 */
+    public record Sku(String skuCode,long quantity) { }
+    /** 保留箱唛及所在仓位，混箱SKU共享同一物理箱。 */
+    public record Carton(String cartonMark,Long inventoryPositionId,Long palletId,Long quantity,List<Sku> items) { }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/inventory/query/mapper/InventoryPieceMapper.java

@@ -0,0 +1,73 @@
+package com.baiyue.lastleg.inventory.query.mapper;
+
+import com.baiyue.lastleg.inventory.query.dto.InventoryQueryRequests;
+import org.apache.ibatis.annotations.*;
+import java.util.List;
+
+/** 从原箱清点事实及实际目的仓签收定位箱内SKU，不按首SKU或箱规换算件数。 */
+@Mapper
+public interface InventoryPieceMapper {
+    String POSITION_CTE = "WITH balances AS (SELECT * FROM ll_inventory_balance " + InventoryQueryMapper.BALANCE_FILTER + """
+        ), occupied AS (
+          SELECT DISTINCT t.customer_id,t.operating_warehouse_id warehouse_id,t.inbound_code,
+            COALESCE(NULLIF(c.customer_carton_mark,''),c.carton_mark) carton_mark
+          FROM ll_warehouse_transfer_order t JOIN ll_warehouse_transfer_carton c
+            ON c.transfer_order_id=t.id AND c.customer_id=t.customer_id
+          -- 出库已扣减来源箱，后续签收生成目的仓库存，不再把同一原箱当作待出库预留。
+          WHERE t.transfer_no<>t.inbound_code AND t.status NOT IN
+            ('DRAFT','REJECTED','CANCELLED','OUTBOUNDED','PARTIALLY_RECEIVED','RECEIVED')
+        ), raw_positions AS (SELECT p.* FROM ll_inventory_position p JOIN balances b
+          ON b.id=p.balance_id AND b.customer_id=p.customer_id WHERE p.available_packages>0),
+        located AS (
+          SELECT p.id position_id,c.id carton_id,c.carton_mark,c.counted_quantity,c.sku_items_json
+          FROM raw_positions p JOIN balances b ON b.id=p.balance_id AND b.customer_id=p.customer_id
+          JOIN ll_warehouse_transfer_order t ON t.customer_id=b.customer_id AND t.inbound_order_id=b.inbound_order_id
+            AND t.operating_warehouse_id=b.overseas_warehouse_id AND t.transfer_no=t.inbound_code
+          JOIN ll_warehouse_transfer_pallet tp ON tp.transfer_order_id=t.id AND tp.customer_id=t.customer_id AND tp.warehouse_pallet_id=p.pallet_id
+          JOIN ll_warehouse_transfer_carton c ON c.transfer_order_id=t.id AND c.customer_id=t.customer_id
+            AND c.transfer_pallet_id=tp.id AND c.status='COUNTED'
+          JOIN ll_warehouse_transfer_item i ON i.id=c.transfer_item_id AND i.customer_id=c.customer_id AND (b.sku_code='MIXED' OR i.sku_code=b.sku_code)
+          UNION
+          SELECT p.id,c.id,c.carton_mark,c.counted_quantity,c.sku_items_json
+          FROM raw_positions p JOIN balances b ON b.id=p.balance_id AND b.customer_id=p.customer_id
+          JOIN ll_warehouse_transfer_receipt r ON r.destination_inventory_position_id=p.id AND r.customer_id=p.customer_id
+          JOIN ll_warehouse_transfer_inventory_allocation a ON a.id=r.allocation_id AND a.customer_id=r.customer_id AND a.status='RECEIVED'
+          JOIN ll_inventory_position sp ON sp.id=a.inventory_position_id AND sp.customer_id=a.customer_id
+          JOIN ll_warehouse_transfer_order outgoing ON outgoing.id=a.transfer_order_id AND outgoing.customer_id=a.customer_id
+          JOIN ll_warehouse_transfer_carton chosen ON chosen.transfer_order_id=outgoing.id AND chosen.customer_id=outgoing.customer_id
+          JOIN ll_warehouse_transfer_order origin ON origin.customer_id=outgoing.customer_id AND origin.inbound_code=outgoing.inbound_code
+            AND origin.operating_warehouse_id=outgoing.operating_warehouse_id AND origin.transfer_no=origin.inbound_code
+          JOIN ll_warehouse_transfer_carton c ON c.transfer_order_id=origin.id AND c.customer_id=origin.customer_id
+            AND c.carton_mark=COALESCE(NULLIF(chosen.customer_carton_mark,''),chosen.carton_mark) AND c.status='SHIPPED'
+          JOIN ll_warehouse_transfer_pallet tp ON tp.id=c.transfer_pallet_id AND tp.customer_id=c.customer_id AND tp.warehouse_pallet_id=sp.pallet_id
+          JOIN ll_warehouse_transfer_item i ON i.id=c.transfer_item_id AND i.customer_id=c.customer_id AND (b.sku_code='MIXED' OR i.sku_code=b.sku_code)
+        ), reservations AS (
+          SELECT p.id position_id,COUNT(DISTINCT l.carton_id) reserved_count
+          FROM raw_positions p JOIN balances b ON b.id=p.balance_id AND b.customer_id=p.customer_id
+          JOIN located l ON l.position_id=p.id JOIN occupied o ON o.customer_id=b.customer_id
+            AND o.warehouse_id=b.overseas_warehouse_id AND o.inbound_code=b.inbound_code AND o.carton_mark=l.carton_mark
+          GROUP BY p.id
+        ), positions AS (
+          SELECT p.*,GREATEST(0,p.available_packages-COALESCE(r.reserved_count,0)) free_packages
+          FROM raw_positions p LEFT JOIN reservations r ON r.position_id=p.id
+        )
+        SELECT p.id positionId,p.balance_id balanceId,b.customer_id customerId,b.overseas_warehouse_id warehouseId,
+          b.destination_warehouse_code destinationCode,b.sku_code anchorSkuCode,p.pallet_id palletId,
+          p.free_packages availablePackages,l.carton_id cartonId,l.carton_mark cartonMark,
+          l.counted_quantity countedQuantity,l.sku_items_json skuItemsJson
+        FROM positions p JOIN balances b ON b.id=p.balance_id AND b.customer_id=p.customer_id
+        LEFT JOIN located l ON l.position_id=p.id AND NOT EXISTS (
+          SELECT 1 FROM occupied o WHERE o.customer_id=b.customer_id AND o.warehouse_id=b.overseas_warehouse_id
+            AND o.inbound_code=b.inbound_code AND o.carton_mark=l.carton_mark)
+        WHERE p.free_packages>0
+        ORDER BY p.id,l.carton_id
+        """;
+
+    /** 完整筛选取箱级投影；页码/每页大小不参与查询。 */
+    @Select("<script>" + POSITION_CTE + "</script>")
+    List<PieceRow> rows(@Param("customerId") String customerId,@Param("q") InventoryQueryRequests.BalanceQuery query);
+
+    /** 每个当前可用仓位及其匹配箱事实；未知箱以空cartonId表达。 */
+    record PieceRow(Long positionId,Long balanceId,String customerId,String warehouseId,String destinationCode,
+        String anchorSkuCode,Long palletId,long availablePackages,Long cartonId,String cartonMark,Long countedQuantity,String skuItemsJson) { }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/inventory/query/mapper/InventoryQueryMapper.java

@@ -24,7 +24,7 @@ public interface InventoryQueryMapper {
         "<if test='q.inboundOrderNo != null and q.inboundOrderNo != \"\"'> AND inbound_order_no LIKE CONCAT('%',#{q.inboundOrderNo},'%')</if>" +
         "<if test='q.inboundCode != null and q.inboundCode != \"\"'> AND inbound_code LIKE CONCAT('%',#{q.inboundCode},'%')</if>" +
         "<if test='q.businessOrderNo != null and q.businessOrderNo != \"\"'> AND EXISTS (SELECT 1 FROM ll_inventory_ledger l WHERE l.balance_id=ll_inventory_balance.id AND l.customer_id=ll_inventory_balance.customer_id AND l.business_order_no LIKE CONCAT('%',#{q.businessOrderNo},'%'))</if>" +
-        "<if test='q.skuCode != null and q.skuCode != \"\"'> AND sku_code LIKE CONCAT('%',#{q.skuCode},'%')</if>" +
+        "<if test='q.skuCode != null and q.skuCode != \"\"'> AND (sku_code LIKE CONCAT('%',#{q.skuCode},'%') OR EXISTS (SELECT 1 FROM ll_warehouse_transfer_order tq JOIN ll_warehouse_transfer_carton cq ON cq.transfer_order_id=tq.id AND cq.customer_id=tq.customer_id WHERE tq.customer_id=ll_inventory_balance.customer_id AND tq.inbound_order_id=ll_inventory_balance.inbound_order_id AND tq.operating_warehouse_id=ll_inventory_balance.overseas_warehouse_id AND tq.transfer_no=tq.inbound_code AND cq.status IN ('COUNTED','DISCARD_PENDING') AND EXISTS (SELECT 1 FROM ll_warehouse_transfer_item iq WHERE iq.id=cq.transfer_item_id AND iq.customer_id=cq.customer_id AND (ll_inventory_balance.sku_code='MIXED' OR iq.sku_code=ll_inventory_balance.sku_code)) AND JSON_SEARCH(cq.sku_items_json,'one',CONCAT('%',#{q.skuCode},'%'),NULL,'$[*].skuCode') IS NOT NULL) OR EXISTS (SELECT 1 FROM ll_inventory_position dp JOIN ll_warehouse_transfer_receipt rr ON rr.destination_inventory_position_id=dp.id AND rr.customer_id=dp.customer_id JOIN ll_warehouse_transfer_inventory_allocation aa ON aa.id=rr.allocation_id AND aa.customer_id=rr.customer_id AND aa.status='RECEIVED' JOIN ll_inventory_position sp ON sp.id=aa.inventory_position_id AND sp.customer_id=aa.customer_id JOIN ll_warehouse_transfer_order ot ON ot.id=aa.transfer_order_id AND ot.customer_id=aa.customer_id JOIN ll_warehouse_transfer_carton chosen ON chosen.transfer_order_id=ot.id AND chosen.customer_id=ot.customer_id JOIN ll_warehouse_transfer_order origin ON origin.customer_id=ot.customer_id AND origin.inbound_code=ot.inbound_code AND origin.operating_warehouse_id=ot.operating_warehouse_id AND origin.transfer_no=origin.inbound_code JOIN ll_warehouse_transfer_carton cc ON cc.transfer_order_id=origin.id AND cc.customer_id=origin.customer_id AND cc.carton_mark=COALESCE(NULLIF(chosen.customer_carton_mark,''),chosen.carton_mark) AND cc.status='SHIPPED' JOIN ll_warehouse_transfer_pallet pp ON pp.id=cc.transfer_pallet_id AND pp.customer_id=cc.customer_id AND pp.warehouse_pallet_id=sp.pallet_id JOIN ll_warehouse_transfer_item ii ON ii.id=cc.transfer_item_id AND ii.customer_id=cc.customer_id WHERE dp.balance_id=ll_inventory_balance.id AND dp.customer_id=ll_inventory_balance.customer_id AND dp.available_packages>0 AND (ll_inventory_balance.sku_code='MIXED' OR ii.sku_code=ll_inventory_balance.sku_code) AND JSON_SEARCH(cc.sku_items_json,'one',CONCAT('%',#{q.skuCode},'%'),NULL,'$[*].skuCode') IS NOT NULL))</if>" +
         "<if test='q.productName != null and q.productName != \"\"'> AND (product_name_zh LIKE CONCAT('%',#{q.productName},'%') OR product_name_en LIKE CONCAT('%',#{q.productName},'%'))</if>" +
         "<if test='q.batchNo != null and q.batchNo != \"\"'> AND EXISTS (SELECT 1 FROM ll_inventory_position p WHERE p.balance_id=ll_inventory_balance.id AND p.customer_id=ll_inventory_balance.customer_id AND p.batch_no LIKE CONCAT('%',#{q.batchNo},'%'))</if>" +
         "<if test='q.warehouseLocationCode != null and q.warehouseLocationCode != \"\"'> AND EXISTS (SELECT 1 FROM ll_inventory_position p WHERE p.balance_id=ll_inventory_balance.id AND p.customer_id=ll_inventory_balance.customer_id AND p.warehouse_location_code LIKE CONCAT('%',#{q.warehouseLocationCode},'%'))</if>" +
@@ -48,7 +48,7 @@ public interface InventoryQueryMapper {
         "<if test='q.inboundOrderNo != null and q.inboundOrderNo != \"\"'> AND b.inbound_order_no LIKE CONCAT('%',#{q.inboundOrderNo},'%')</if>" +
         "<if test='q.inboundCode != null and q.inboundCode != \"\"'> AND b.inbound_code LIKE CONCAT('%',#{q.inboundCode},'%')</if>" +
         "<if test='q.businessOrderNo != null and q.businessOrderNo != \"\"'> AND EXISTS (SELECT 1 FROM ll_inventory_ledger l WHERE l.balance_id=b.id AND l.customer_id=b.customer_id AND l.business_order_no LIKE CONCAT('%',#{q.businessOrderNo},'%'))</if>" +
-        "<if test='q.skuCode != null and q.skuCode != \"\"'> AND b.sku_code LIKE CONCAT('%',#{q.skuCode},'%')</if>" +
+        "<if test='q.skuCode != null and q.skuCode != \"\"'> AND (b.sku_code LIKE CONCAT('%',#{q.skuCode},'%') OR EXISTS (SELECT 1 FROM ll_warehouse_transfer_order tq JOIN ll_warehouse_transfer_carton cq ON cq.transfer_order_id=tq.id AND cq.customer_id=tq.customer_id WHERE tq.customer_id=b.customer_id AND tq.inbound_order_id=b.inbound_order_id AND tq.operating_warehouse_id=b.overseas_warehouse_id AND tq.transfer_no=tq.inbound_code AND cq.status IN ('COUNTED','DISCARD_PENDING') AND EXISTS (SELECT 1 FROM ll_warehouse_transfer_item iq WHERE iq.id=cq.transfer_item_id AND iq.customer_id=cq.customer_id AND (b.sku_code='MIXED' OR iq.sku_code=b.sku_code)) AND JSON_SEARCH(cq.sku_items_json,'one',CONCAT('%',#{q.skuCode},'%'),NULL,'$[*].skuCode') IS NOT NULL) OR EXISTS (SELECT 1 FROM ll_inventory_position dp JOIN ll_warehouse_transfer_receipt rr ON rr.destination_inventory_position_id=dp.id AND rr.customer_id=dp.customer_id JOIN ll_warehouse_transfer_inventory_allocation aa ON aa.id=rr.allocation_id AND aa.customer_id=rr.customer_id AND aa.status='RECEIVED' JOIN ll_inventory_position sp ON sp.id=aa.inventory_position_id AND sp.customer_id=aa.customer_id JOIN ll_warehouse_transfer_order ot ON ot.id=aa.transfer_order_id AND ot.customer_id=aa.customer_id JOIN ll_warehouse_transfer_carton chosen ON chosen.transfer_order_id=ot.id AND chosen.customer_id=ot.customer_id JOIN ll_warehouse_transfer_order origin ON origin.customer_id=ot.customer_id AND origin.inbound_code=ot.inbound_code AND origin.operating_warehouse_id=ot.operating_warehouse_id AND origin.transfer_no=origin.inbound_code JOIN ll_warehouse_transfer_carton cc ON cc.transfer_order_id=origin.id AND cc.customer_id=origin.customer_id AND cc.carton_mark=COALESCE(NULLIF(chosen.customer_carton_mark,''),chosen.carton_mark) AND cc.status='SHIPPED' JOIN ll_warehouse_transfer_pallet pp ON pp.id=cc.transfer_pallet_id AND pp.customer_id=cc.customer_id AND pp.warehouse_pallet_id=sp.pallet_id JOIN ll_warehouse_transfer_item ii ON ii.id=cc.transfer_item_id AND ii.customer_id=cc.customer_id WHERE dp.balance_id=b.id AND dp.customer_id=b.customer_id AND dp.available_packages>0 AND (b.sku_code='MIXED' OR ii.sku_code=b.sku_code) AND JSON_SEARCH(cc.sku_items_json,'one',CONCAT('%',#{q.skuCode},'%'),NULL,'$[*].skuCode') IS NOT NULL))</if>" +
         "<if test='q.productName != null and q.productName != \"\"'> AND (b.product_name_zh LIKE CONCAT('%',#{q.productName},'%') OR b.product_name_en LIKE CONCAT('%',#{q.productName},'%'))</if>" +
         "<if test='q.batchNo != null and q.batchNo != \"\"'> AND EXISTS (SELECT 1 FROM ll_inventory_position p2 WHERE p2.balance_id=b.id AND p2.customer_id=b.customer_id AND p2.batch_no LIKE CONCAT('%',#{q.batchNo},'%'))</if>" +
         "<if test='q.warehouseLocationCode != null and q.warehouseLocationCode != \"\"'> AND EXISTS (SELECT 1 FROM ll_inventory_position p2 WHERE p2.balance_id=b.id AND p2.customer_id=b.customer_id AND p2.warehouse_location_code LIKE CONCAT('%',#{q.warehouseLocationCode},'%'))</if>" +

lastleg-service/src/main/java/com/baiyue/lastleg/inventory/query/repository/InventoryPieceRepository.java

@@ -0,0 +1,15 @@
+package com.baiyue.lastleg.inventory.query.repository;
+import com.baiyue.lastleg.inventory.query.dto.InventoryQueryRequests;
+import com.baiyue.lastleg.inventory.query.mapper.InventoryPieceMapper;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+/** 统一库存混箱事实查询入口。 */
+@Repository
+public class InventoryPieceRepository {
+    @Resource private InventoryPieceMapper mapper;
+    /** 读取相同筛选范围的全部当前可用箱。 */
+    public List<InventoryPieceMapper.PieceRow> rows(String customerId,InventoryQueryRequests.BalanceQuery query) {
+        return mapper.rows(customerId,query);
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/inventory/query/service/InventoryPieceService.java

@@ -0,0 +1,71 @@
+package com.baiyue.lastleg.inventory.query.service;
+import com.baiyue.lastleg.inventory.query.dto.*;
+import com.baiyue.lastleg.inventory.query.mapper.InventoryPieceMapper.PieceRow;
+import com.baiyue.lastleg.inventory.query.repository.InventoryPieceRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/** 用完整箱内清点投影当前可用件数，对缺失或不完整映射显式返回未知。 */
+@Service
+public class InventoryPieceService {
+    @Resource private InventoryPieceRepository repository;
+    @Resource private ObjectMapper objectMapper;
+    /** 完整筛选的多分组汇总，同一物理托盘按客户及仓去重而非相减。 */
+    @Transactional(readOnly=true)
+    public InventoryPieceProjection project(String customerId,InventoryQueryRequests.BalanceQuery query) {
+        var rows=repository.rows(customerId,query);
+        var groups=rows.stream().collect(Collectors.groupingBy(r -> Arrays.asList(r.customerId(),r.warehouseId(),r.destinationCode(),r.anchorSkuCode()),LinkedHashMap::new,Collectors.toList()));
+        var result=new ArrayList<InventoryPieceProjection.Group>(); var pallets=new HashSet<String>();
+        for(var group:groups.values()) {
+            result.add(group(group));
+            for(var row:group) if(row.palletId()!=null) pallets.add(row.customerId()+":"+row.warehouseId()+":"+row.palletId());
+        }
+        long known=0,unknown=0,cartons=0;
+        for(var group:result) { known=Math.addExact(known,group.knownAvailablePieceCount()); unknown+=group.unknownCartonCount(); cartons+=group.availableCartonCount(); }
+        return new InventoryPieceProjection(unknown==0?known:null,known,unknown,cartons,pallets.size(),result);
+    }
+
+    /** 每个仓位只有精确箱映射完整时才计入已知件数，不能从多余箱中截取或按比例推算。 */
+    private InventoryPieceProjection.Group group(List<PieceRow> rows) {
+        var positions=rows.stream().collect(Collectors.groupingBy(PieceRow::positionId,LinkedHashMap::new,Collectors.toList()));
+        var contents=new TreeMap<String,Long>(); var cartons=new ArrayList<InventoryPieceProjection.Carton>();
+        var pallets=new HashSet<Long>(); long available=0,unknown=0,known=0;
+        for(var position:positions.values()) {
+            var first=position.get(0); available+=first.availablePackages(); if(first.palletId()!=null) pallets.add(first.palletId());
+            var boxes=position.stream().filter(r -> r.cartonId()!=null).collect(Collectors.toMap(PieceRow::cartonId,r -> r,(a,b)->a,LinkedHashMap::new));
+            var parsed=new ArrayList<InventoryPieceProjection.Carton>();
+            for(var row:boxes.values()) parsed.add(carton(row));
+            if(boxes.size()!=first.availablePackages() || parsed.stream().anyMatch(c -> c.quantity()==null)) { unknown+=first.availablePackages(); continue; }
+            for(var box:parsed) {
+                cartons.add(box); known=Math.addExact(known,box.quantity());
+                for(var sku:box.items()) contents.merge(sku.skuCode(),sku.quantity(),Math::addExact);
+            }
+        }
+        var first=rows.get(0);
+        return new InventoryPieceProjection.Group(first.customerId(),first.warehouseId(),first.destinationCode(),first.anchorSkuCode(),
+            unknown==0?known:null,known,unknown,available,pallets.size(),contents.entrySet().stream().map(e -> new InventoryPieceProjection.Sku(e.getKey(),e.getValue())).toList(),cartons);
+    }
+
+    /** 清点JSON与箱总件数必须一致；缺失信息保持未知，不拿首SKU替代混箱。 */
+    private InventoryPieceProjection.Carton carton(PieceRow row) {
+        var items=new ArrayList<InventoryPieceProjection.Sku>(); Long quantity=null;
+        try {
+            var lines=objectMapper.readTree(row.skuItemsJson()); long sum=0;
+            if(lines.isArray() && !lines.isEmpty()) {
+                for(var line:lines) {
+                    String sku=line.path("skuCode").asText(""); var count=line.path("quantity");
+                    if(sku.isBlank() || !count.asText().matches("[0-9]+")) throw new IllegalArgumentException("无效箱内SKU事实");
+                    long pieces=Long.parseLong(count.asText());
+                    if(pieces<=0) throw new IllegalArgumentException("箱内件数必须为正整数");
+                    items.add(new InventoryPieceProjection.Sku(sku,pieces)); sum=Math.addExact(sum,pieces);
+                }
+                if(row.countedQuantity()!=null && sum==row.countedQuantity()) quantity=sum;
+            }
+        } catch(Exception invalid) { items.clear(); }
+        return new InventoryPieceProjection.Carton(row.cartonMark(),row.positionId(),row.palletId(),quantity,items);
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/palletops/controller/PlatformPalletOperationRecoveryController.java

@@ -0,0 +1,24 @@
+package com.baiyue.lastleg.palletops.controller;
+
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.common.security.AuthenticatedUser;
+import com.baiyue.lastleg.palletops.service.PalletOperationRecoveryService;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import jakarta.validation.Valid;
+
+/** 受库存管理权限保护的人工恢复入口，不允许PDA自行批准技术状态关闭。 */
+@RestController
+@RequestMapping("/api/platform/v1/last-leg/pallet-operation-recoveries")
+@PreAuthorize("hasAuthority('lastleg:inventory:manage')")
+public class PlatformPalletOperationRecoveryController {
+    private final PalletOperationRecoveryService service;
+    /** 注入恢复业务服务。 */
+    public PlatformPalletOperationRecoveryController(PalletOperationRecoveryService service){this.service=service;}
+    /** 管理员读取原作业证据。 */
+    @GetMapping("/{id}") public ApiResponse<PalletOperationRecoveryService.State> inspect(@PathVariable long id){return ApiResponse.success(service.inspect(id));}
+    /** 以认证管理员身份审计关闭。 */
+    @PostMapping("/{id}/close-no-effect")
+    public ApiResponse<PalletOperationRecoveryService.Recovery> close(@PathVariable long id,@AuthenticationPrincipal AuthenticatedUser user,@Valid @RequestBody PalletOperationRecoveryService.Close request){return ApiResponse.success(service.close(id,String.valueOf(user.userId()),request));}
+}

lastleg-service/src/main/java/com/baiyue/lastleg/palletops/mapper/PalletOperationRecoveryMapper.java

@@ -0,0 +1,25 @@
+package com.baiyue.lastleg.palletops.mapper;
+
+import com.baiyue.lastleg.palletops.entity.PdaPalletOperation;
+import org.apache.ibatis.annotations.*;
+import java.time.LocalDateTime;
+
+/** 恢复与远端意图使用同一行CAS，恢复关闭后旧执行线程不能继续发起远端写入。 */
+@Mapper
+public interface PalletOperationRecoveryMapper {
+    /** 读取原作业技术状态。 */
+    @Select("SELECT * FROM ll_pda_pallet_operation WHERE id=#{id}")
+    PdaPalletOperation find(@Param("id") long id);
+    /** 恢复审批与远端意图按原行串行。 */
+    @Select("SELECT * FROM ll_pda_pallet_operation WHERE id=#{id} FOR UPDATE")
+    PdaPalletOperation lock(@Param("id") long id);
+    /** 恢复关闭后拒绝继续持久化远端意图。 */
+    @Update("UPDATE ll_pda_pallet_operation SET remote_transitions_json=#{json},updated_at=#{at} WHERE id=#{id} AND status='PROCESSING'")
+    int journal(@Param("id") long id,@Param("json") String json,@Param("at") LocalDateTime at);
+    /** 条件关闭原作业并保存恢复审计。 */
+    @Update("UPDATE ll_pda_pallet_operation SET status='RECOVERED_NO_EFFECT',result_json=#{audit},updated_at=#{at} WHERE id=#{id} AND status IN ('PROCESSING','FAILED_COMPENSATED')")
+    int close(@Param("id") long id,@Param("audit") String audit,@Param("at") LocalDateTime at);
+    /** 旧执行线程不能用失败结果覆盖已恢复或已完成终态。 */
+    @Update("UPDATE ll_pda_pallet_operation SET status=#{status},last_error=#{error},updated_at=#{at} WHERE id=#{id} AND status NOT IN ('RECOVERED_NO_EFFECT','COMPLETED')")
+    int fail(@Param("id") long id,@Param("status") String status,@Param("error") String error,@Param("at") LocalDateTime at);
+}

lastleg-service/src/main/java/com/baiyue/lastleg/palletops/mapper/PdaPalletOperationMapper.java

@@ -53,11 +53,15 @@ public interface PdaPalletOperationMapper extends BaseMapper<PdaPalletOperation>
     @Options(useCache=false, flushCache=Options.FlushCachePolicy.TRUE)
     List<MutationPallet> mutationPallets(@Param("warehouseId") String warehouseId, @Param("applicationNos") List<String> applicationNos);
 
-    /** 收齐原入仓、退回实收、计划及原生退货业务订单，不使用MIN或其他客户代表行。 */
+    /** 收齐真实尾程订单；入仓快照ID经同客户来源分片解析，缺失关联保留空值以拒绝改绑。 */
     @Select("<script>SELECT a.customer_id AS customerId,a.lastleg_order_id AS orderId FROM ll_relabel_application a WHERE a.relabel_no IN " + MUTATION_APPS
-        + " UNION SELECT i.customer_id,i.source_inbound_order_id FROM ll_relabel_item i JOIN ll_relabel_application a ON a.id=i.application_id AND a.customer_id=i.customer_id "
+        + " UNION SELECT i.customer_id,original.id FROM ll_relabel_item i JOIN ll_relabel_application a ON a.id=i.application_id AND a.customer_id=i.customer_id "
+        + "LEFT JOIN ll_inbound_order inbound ON inbound.id=i.source_inbound_order_id AND inbound.customer_id=i.customer_id "
+        + "LEFT JOIN ll_order original ON original.customer_id=inbound.customer_id AND original.source_inbound_id=inbound.source_inbound_id "
         + "WHERE a.relabel_no IN " + MUTATION_APPS + " AND i.return_carton_id IS NULL"
-        + " UNION SELECT p.customer_id,b.inbound_order_id FROM ll_inventory_position p JOIN ll_inventory_balance b ON b.id=p.balance_id AND b.customer_id=p.customer_id "
+        + " UNION SELECT p.customer_id,original.id FROM ll_inventory_position p JOIN ll_inventory_balance b ON b.id=p.balance_id AND b.customer_id=p.customer_id "
+        + "LEFT JOIN ll_inbound_order inbound ON inbound.id=b.inbound_order_id AND inbound.customer_id=b.customer_id "
+        + "LEFT JOIN ll_order original ON original.customer_id=inbound.customer_id AND original.source_inbound_id=inbound.source_inbound_id "
         + "WHERE p.overseas_warehouse_id=#{warehouseId} AND p.pallet_id IN " + MUTATION_IDS
         + " UNION SELECT r.customer_id,r.order_id FROM ll_inbound_stock_receipt r JOIN ll_inventory_position p ON p.id=r.inventory_position_id AND p.customer_id=r.customer_id "
         + "WHERE p.overseas_warehouse_id=#{warehouseId} AND r.warehouse_pallet_id IN " + MUTATION_IDS