fix(firstleg): align warehouse arrival sources on latest observed port fact

AGENTS.md

@@ -108,14 +108,14 @@
 
 ## 数据库访问与中文代码注释（所有服务及公共模块强制）
 
-- 本节适用于全部后端服务和公共模块；新增、修改的方法必须执行，触及的存量代码同步整改。登记本约束不代表存量代码已全部完成迁移和注释补齐。
+- 本节适用于全部后端服务和公共模块；新增代码遵守下列规范，存量分层仅在影响本次正确性或用户明确要求时整改，不因局部修改迁移整条链路；以上为目标规范，不代表存量均已达标。
 - 生产代码的关系型数据库读写统一经 MyBatis/MyBatis-Plus Mapper 执行；Controller、Service、定时任务、消费者、编号生成器和公共基础组件不得直接使用 `JdbcTemplate`、`NamedParameterJdbcTemplate`、原生 JDBC/Connection/Statement 或其他通道执行 SQL。仅改成 Repository 包装 JDBC 不算整改，SQL 必须进入 Mapper；无数据库职责的模块不得为满足本条新增数据库访问。
 - 正常业务数据库访问路径统一为 `Controller → Service → Repository → Mapper`，四层职责明确，不得省略 Repository，也不得由 Controller 直接调用 Repository/Mapper，或由 Service 直接调用 Mapper。定时任务、消费者等非 HTTP 入口从 Service 进入，同样经 Repository → Mapper 完成持久化访问。
 - Controller 负责请求接收、参数校验、入口权限和响应转换；Service 负责业务规则、编排及业务事务；Repository 负责领域数据访问封装、查询组合与持久化模型转换，对 Service 提供有业务含义的数据操作；Mapper 负责 SQL 执行及数据库记录映射。Repository 不承载业务状态流转，不直接用 JDBC 执行 SQL；Service 不继承 MyBatis-Plus `ServiceImpl` 等方式绕过 Repository。
 - 复杂查询、批量处理、原子计数、锁定读取、Outbox 和数据库监控查询同样经 Repository → Mapper，不以 SQL 特殊或实现方便为由跳层。公共模块需要数据库能力时，按现有模块边界定义 Repository/持久化接口，由所属服务的 Repository → Mapper 实现，禁止借此跨服务读库。
 - 迁移数据库操作须保留客户隔离条件、事务传播、行锁、幂等和并发语义；`LAST_INSERT_ID()` 等连接级操作必须在同一事务连接完成，并明确关闭相关读取缓存，不能仅机械搬移 SQL。Mapper 注册及扫描仍遵守下文统一规范。
 - 测试代码可用 `JdbcTemplate` 创建隔离测试表、准备数据及核对结果；被测生产路径仍必须调用实际 Mapper，不得把测试造数做法带入生产。数据库基线和迁移脚本按现有部署契约管理。
-- 每个手写方法及构造器均须添加简短中文注释，通常 1—3 行说明业务用途；接口方法和 Mapper 方法优先使用中文 Javadoc。覆盖方法同样须有简短中文说明，实现中的关键规则仍须就地注释；自动生成的方法不手工逐个补注释。
+- 本次新增或修改的手写方法及构造器须有简短中文业务注释，通常 1—3 行；接口与 Mapper 方法优先用中文 Javadoc，覆盖方法同样适用，关键规则就地说明。不补齐未修改或自动生成方法的注释。
 - 核心业务、复杂 SQL、状态流转、资金与库存变更、权限隔离、事务、锁、幂等、并发、重试和补偿逻辑，须在关键代码前增加适量中文注释，解释业务规则、处理原因、约束边界及失败影响；不逐行翻译代码，不添加无信息量或与实现不符的注释。
 - 新增和修改的代码说明注释统一使用中文；必要的技术标识、协议名、类名可保留原文，第三方许可证和生成标记保持原样。修改方法时同步更新相关存量英文或过期说明；审查时同时核对 Controller → Service → Repository → Mapper 分层及中文方法、核心逻辑注释。
 
@@ -132,7 +132,11 @@
 - 数据库只访问所属服务库。模块表结构位于 `<module>/src/main/resources/db/`；开发环境按最新模块基线和 `deploy/sql/头程数据库统一增量-MySQL8.sql` 收敛，不为历史开发数据新增兼容迁移。已有名称含 `migration` 的脚本仅作结构来源和追溯，部署说明见 `deploy/sql/README.md`；生产升级另按明确发布规则处理。
 - 后端同样遵守根指引中的“开发数据和上传文件可丢弃”边界：不得为现有开发库孤儿文件、旧文件归属或历史部分失败新增删除补偿接口、兼容复用、回填或清理链路；只修复当前正式上传与持久化路径，既有开发文件由人工重新上传。
 - 通用配置在 `config/nacos/test/`；服务日志、上传文件、`target/`、`reports/` 不属于源码。
-- Java 签名变更的最低编译门禁是 `mvn -pl <module> -am test-compile`，它必须在部署前完成并覆盖测试源码；有行为变化时继续运行 `mvn -pl <module> -am test`。`-DskipTests` 可跳过测试执行但仍须保留测试编译，`-Dmaven.test.skip=true` 会跳过测试编译，不得作为签名变更的交付验证。全量验证仍使用 `mvn -DskipTests validate`、`mvn test`；不要在本地启动 Java/Nacos/数据库，除非用户明确要求。
+- 后端本地验证默认使用 `scripts/backend-check.ps1`，必须显式指定 `-Modules`，不传模块直接拒绝；命令及参数见 `scripts/README.md` 的“后端分层检查”。入口自动经 `local-check.ps1` 限流，`-DryRun` 只检查选择范围，不代表测试通过。
+- 局部逻辑使用 `-Mode Focused -Tests <精确测试类名>`，覆盖修改行为及必要边界即可交付，不因收尾再跑 `Module`。Java 签名变化须覆盖生产与测试源码编译；定向测试已编译时不重复跑 `-Mode Compile`。只有影响扩及服务内多个行为且定向覆盖不足才选 `Module`，先说明原因。跨服务 DTO、接口或事件变化显式列入生产者和实际消费者；`-am` 仅补上游构建依赖，不自动包含下游或 HTTP/事件消费者。
+- 仅注释/文档调整不触发 Java 回归；脚本调整执行受影响脚本测试和登记合同。API、Mapper、AGENTS 等静态合同仍按各自触发条件执行。纯重构也应覆盖受影响行为，不能只用编译宣称回归通过。`-Dmaven.test.skip=true` 跳过测试编译，不得作为签名变更交付验证。
+- 全仓回归仅用于已确认影响广泛且定向覆盖不足的公共依赖/聚合拓扑/认证/序列化/基础模型变化，或用户要求的全量/跨域集成验收；先说明具体影响，不能因未查清范围而全跑。根 POM、依赖或测试配置改动先按实际影响选编译或测试，不一律全仓。入口为 `scripts/backend-full-regression.ps1`，CI 全量保留。普通提交、单服务任务或对话收尾不触发；有效结果复用，输入变化只补跑受影响范围。
+- 不以缩短耗时为由删除金额、库存、权限隔离、状态流转、幂等和并发测试；冗余测试须根据重复场景及维护成本单独评估。不要在本地启动 Java/Nacos/数据库，除非用户明确要求。
 - 同一批 `AGENTS.md` 索引修改完成后从后端根统一运行一次 `./scripts/agents-index-contract.ps1`；脚本只读源码目录和指定指引，不访问 HTTP、数据库或部署环境。
 - Mapper 注册静态合同为 `scripts/mapper-scan-contract.mjs`、`mapper-scan-contract.test.mjs`：自动发现聚合模块、生产 `*Mapper` 接口、服务启动类和分散扫描配置，不启动 Spring、不连接数据库；遗漏注解、扫描根漂移或重新引入子域扫描时直接失败并输出类与文件路径。
 - 单服务镜像构建/部署从 `Jenkinsfile.service`、`deploy/docker/Dockerfile`、`deploy/scripts/deploy-built-service.sh` 进入；新镜像启动失败或健康检查失败时只允许回滚到同服务先前镜像，并保持任务失败，离线合同见 `scripts/deploy-built-service-rollback.test.mjs`。实际部署仍须当前对话明确授权。

Jenkinsfile

@@ -161,7 +161,8 @@ pipeline {
         choice(name: 'ENVIRONMENT', choices: environmentChoicesForJob(env.JOB_BASE_NAME), description: '部署环境')
         booleanParam(name: 'DEPLOY', defaultValue: false, description: '各服务构建成功后是否独立部署')
         booleanParam(name: 'SKIP_TESTS', defaultValue: false, description: '是否跳过测试执行（仍编译测试源码）')
-        string(name: 'IMAGE_REPOSITORY', defaultValue: '', description: '必须填写已核实的共享镜像仓库地址 host[:port]/owner/image')
+        // 地址由当前 Job 配置提供；参数声明刷新时保留已配置值，不将环境地址写入源码。
+        string(name: 'IMAGE_REPOSITORY', defaultValue: params.IMAGE_REPOSITORY ?: '', description: '沿用当前 Job 已配置的镜像仓库地址；首次配置或更换仓库时填写 host[:port]/owner/image')
         string(name: 'DOCKER_BASE_IMAGE', defaultValue: 'eclipse-temurin:17-jre-alpine', description: 'Java 17 基础镜像')
         choice(name: 'DOWNSTREAM_JOB_PREFIX', choices: downstreamJobPrefixChoicesForJob(env.JOB_BASE_NAME), description: '由当前总控 Job 固定的单服务 Job 前缀')
     }

Jenkinsfile.service

@@ -49,7 +49,8 @@ pipeline {
         booleanParam(name: 'ALLOW_SAME_CONTRACT_ROLLBACK', defaultValue: false, description: '仅确认相同协议与Schema时允许回滚；架构切换保持关闭')
         booleanParam(name: 'DEPLOY', defaultValue: false, description: '构建成功后是否部署本服务')
         booleanParam(name: 'SKIP_TESTS', defaultValue: false, description: '是否跳过测试')
-        string(name: 'IMAGE_REPOSITORY', defaultValue: '', description: '必须填写已核实的共享镜像仓库基础路径，不包含服务名和标签')
+        // 独立构建沿用本 Job 配置，总控调度时保留其明确传入的地址。
+        string(name: 'IMAGE_REPOSITORY', defaultValue: params.IMAGE_REPOSITORY ?: '', description: '沿用当前 Job 已配置的镜像仓库基础路径，不包含服务名和标签；首次配置或更换仓库时填写')
         string(name: 'DOCKER_BASE_IMAGE', defaultValue: 'eclipse-temurin:17-jre-alpine', description: 'Java 17 基础镜像')
     }
 

README.md

@@ -23,11 +23,16 @@
 ## 本地构建
 
 ```powershell
-mvn -DskipTests validate
-node --test scripts/java-topology-contract.test.mjs
-mvn test
+# 日常按受影响模块检查；跨服务变更显式列入消费者。
+.\scripts\backend-check.ps1 -Modules order -Mode Compile
+.\scripts\backend-check.ps1 -Modules order
+# 根构建/拓扑变化等全量触发条件见 AGENTS.md。
+.\scripts\local-check.ps1 -Command @('node', '--test', 'scripts/java-topology-contract.test.mjs')
+.\scripts\backend-full-regression.ps1
 ```
 
+开发中可通过 `backend-check.ps1 -Mode Focused -Modules <模块> -Tests <精确测试类名>` 快速反馈；参数、DryRun 和结果边界见 [后端分层检查](scripts/README.md#后端分层检查)。单服务修改收尾执行模块回归，不默认执行上面的全仓命令。
+
 GitLab 在独立 Node 镜像中自动执行拓扑合同，随后才允许服务制品打包。Maven `verify` 会为执行过测试且产生覆盖率数据的模块生成 `target/site/jacoco/index.html` 与 `jacoco.xml`；当前只生成报告，不设置覆盖率阈值，也不改变测试选择。Jenkins 的 `java-builder` 尚未在仓库中声明 Node 运行时，因此暂不重复执行该 Node 合同，以 GitLab 门禁和上述本地命令为准。
 
 2026-07-30 订单与客户前端联调缺口已完成真实回归：19 个 Reactor 项目构建成功，75 项单元及组件测试、68 项认证与 IAM 真实 API、37 项订单与仓库真实 API 全部通过。详细证据见 `docs/phase1-business-maturity-regression-report.md`。

config/nacos/test/finance-service.yml

@@ -5,7 +5,8 @@ spring:
     password: ${FINANCE_DB_PASSWORD}
     driver-class-name: com.mysql.cj.jdbc.Driver
 baiyue.clients.warehouse.url: ${WAREHOUSE_SERVICE_URL:}
-baiyue.finance.recharge.qr-code-url: ${FINANCE_RECHARGE_QR_CODE_URL:}
+# TEST 流程验收复用 Client 的示例图片，图片标注不可付款且不含真实收款信息。
+baiyue.finance.recharge.qr-code-url: ${FINANCE_RECHARGE_QR_CODE_URL:/customer-recharge-qr.svg}
 baiyue.finance.wallet.default-credit-limit: ${FINANCE_WALLET_DEFAULT_CREDIT_LIMIT:0.00}
 baiyue.event-delivery.operations-token: ${EVENT_OPERATIONS_TOKEN:}
 baiyue.event-delivery.connect-timeout-ms: ${EVENT_CONNECT_TIMEOUT_MS:3000}

deploy/sql/海外区域统一增量-MySQL8.sql

@@ -429,6 +429,7 @@ CREATE TABLE ll_dispatch_order (
   review_state VARCHAR(32) NOT NULL DEFAULT 'DRAFT' COMMENT '审核子流程当前状态',
   review_round BIGINT NOT NULL DEFAULT 0 COMMENT '当前审核轮次',
   review_basis_hash CHAR(64) NULL COMMENT '本审核轮次核对的货物和资源依据摘要',
+  exceptions_json JSON NULL COMMENT '派送异常登记记录及图片引用，不改变派送及库存状态',
   dispatch_review_json JSON NULL COMMENT '当前调度审核事实快照',
   loading_review_json JSON NULL COMMENT '当前理货审核事实快照',
   resources_json JSON NULL COMMENT '本趟主档或临时车辆司机的真实资源快照',
@@ -4874,7 +4875,7 @@ CREATE TABLE ll_fleet_pickup_history (
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='取货不可变操作历史';
 
 -- 自有业务仅保存原排车的归属证据和附加运营信息，不复制履约主单。
-CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_ownership (
+CREATE TABLE ll_fleet_owned_business_ownership (
   dispatch_id BIGINT NOT NULL COMMENT '原排车内部主键',
   resource_mode VARCHAR(16) NOT NULL COMMENT '原排车资源模式MASTER或EXTERNAL',
   vehicle_id BIGINT NULL COMMENT '真实车辆档案主键，临时外配为空',
@@ -4892,7 +4893,7 @@ CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_ownership (
     OR (resource_mode='EXTERNAL' AND vehicle_id IS NULL AND vehicle_record_version IS NULL AND vehicle_ownership='DISPATCHED'))
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='原排车装车完成时的车辆归属证据';
 
-CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_record (
+CREATE TABLE ll_fleet_owned_business_record (
   id BIGINT NOT NULL COMMENT '附加运营记录内部主键',
   dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
   record_version BIGINT NOT NULL COMMENT '附加运营记录并发版本，独立于原排车版本',
@@ -4917,7 +4918,7 @@ CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_record (
   CONSTRAINT ck_owned_business_fuel CHECK (fuel_consumption_litres_per_100km IS NULL OR fuel_consumption_litres_per_100km>=0)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='原排车自有业务附加运营信息';
 
-CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_command (
+CREATE TABLE ll_fleet_owned_business_command (
   id BIGINT NOT NULL COMMENT '附加运营命令内部主键',
   dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
   operator_id VARCHAR(64) NOT NULL COMMENT '原命令操作人标识',
@@ -4938,7 +4939,7 @@ CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_command (
   CONSTRAINT ck_owned_business_command_status CHECK (status IN ('PENDING','SUCCEEDED','REJECTED','UNKNOWN_RESULT'))
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='原排车附加运营写命令及可恢复结果';
 
-CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_history (
+CREATE TABLE ll_fleet_owned_business_history (
   id BIGINT NOT NULL COMMENT '附加运营历史内部主键',
   dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
   record_version BIGINT NOT NULL COMMENT '成功写入后的附加记录版本',

file/src/main/java/com/baiyue/file/service/BusinessFileCategory.java

@@ -11,6 +11,8 @@ enum BusinessFileCategory {
     FLEET_TRIP_OPERATION_EVIDENCE(false, FormatPolicy.PDF_IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
     OVERSEAS_DISPATCH_VEHICLE_EVIDENCE(false, FormatPolicy.PDF_IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
     OVERSEAS_DISPATCH_DRIVER_EVIDENCE(false, FormatPolicy.PDF_IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
+    OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
+    OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
     OVERSEAS_DISPATCH_LOADING_PHOTO(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
     OVERSEAS_DISPATCH_FUEL_PHOTO(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
     FLEET_VEHICLE_RECORD_PHOTO(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
@@ -78,9 +80,9 @@ enum BusinessFileCategory {
                 && tenantId != 0) {
             throw new BizException(ResultCode.BAD_REQUEST, "排车运营照片必须归属平台");
         }
-        if ((this == OVERSEAS_DISPATCH_VEHICLE_EVIDENCE || this == OVERSEAS_DISPATCH_DRIVER_EVIDENCE)
+        if ((this == OVERSEAS_DISPATCH_VEHICLE_EVIDENCE || this == OVERSEAS_DISPATCH_DRIVER_EVIDENCE || this == OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE || this == OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE)
                 && tenantId != 0) {
-            throw new BizException(ResultCode.BAD_REQUEST, "排车车辆及司机证据必须归属平台");
+            throw new BizException(ResultCode.BAD_REQUEST, "排车证据必须归属平台");
         }
         if (this == FLEET_TRIP_OPERATION_EVIDENCE && tenantId != 0) {
             throw new BizException(ResultCode.BAD_REQUEST, "出车实测凭证必须归属平台");

file/src/main/resources/openapi/dispatch-evidence-v1.yaml

@@ -4,9 +4,9 @@ info:
   version: 1.0.0
   description: >-
     复用 InternalBusinessFileController 的现有通用内部入口，不新增公开文件路由。
-    两类证据均固定平台 tenantId=0，businessId 为排车内部正数 Long ID 的十进制表示，
+    三类证据均固定平台 tenantId=0，businessId 为排车内部正数 Long ID 的十进制表示，
     不使用车辆 ID、司机 ID、车牌或客户 ID。车辆与司机证据分别使用
-    OVERSEAS_DISPATCH_VEHICLE_EVIDENCE、OVERSEAS_DISPATCH_DRIVER_EVIDENCE，不可互换。
+    OVERSEAS_DISPATCH_VEHICLE_EVIDENCE、OVERSEAS_DISPATCH_DRIVER_EVIDENCE、OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE，不可互换。司机本人照片DRIVER_PHOTO和排车异常图片EXCEPTION仅支持JPG/PNG；其他两类沿PDF/JPG/PNG。
     File 校验内部服务令牌、平台归属、正数业务 ID、文件非空、最大 10MiB（10485760 字节，包含边界）、
     PDF/JPG/PNG MIME 及对应内容签名。元数据和下载按 tenantId、businessType、businessId、fileId
     联合查询 ACTIVE 且未删除文件，错车或错类别均视为归属不匹配，下载前完成归属校验。
@@ -126,7 +126,7 @@ components:
       description: 正数Long的十进制字符串，值不得超过9223372036854775807
     DispatchEvidenceType:
       type: string
-      enum: [OVERSEAS_DISPATCH_VEHICLE_EVIDENCE, OVERSEAS_DISPATCH_DRIVER_EVIDENCE]
+      enum: [OVERSEAS_DISPATCH_VEHICLE_EVIDENCE, OVERSEAS_DISPATCH_DRIVER_EVIDENCE, OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE, OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE]
     MetadataEnvelope:
       type: object
       required: [code, data]

file/src/test/java/com/baiyue/file/service/DispatchEvidenceFileTest.java

@@ -30,6 +30,8 @@ import static org.mockito.Mockito.*;
 
 class DispatchEvidenceFileTest {
     private static final String VEHICLE = "OVERSEAS_DISPATCH_VEHICLE_EVIDENCE";
+    private static final String EXCEPTION = "OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE";
+    private static final String PHOTO = "OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE";
     private static final String DRIVER = "OVERSEAS_DISPATCH_DRIVER_EVIDENCE";
     private static final int MAX_BYTES = 10 * 1024 * 1024;
     @TempDir Path root;
@@ -40,9 +42,9 @@ class DispatchEvidenceFileTest {
             FileObjectEntity.class);
     }
 
-    /** 两类证据只接受平台与有效排车内部 ID，非法输入不得访问数据库或磁盘。 */
+    /** 三类证据只接受平台与有效排车内部 ID，非法输入不得访问数据库或磁盘。 */
     @ParameterizedTest
-    @ValueSource(strings = {VEHICLE, DRIVER})
+    @ValueSource(strings = {VEHICLE, DRIVER, PHOTO, EXCEPTION})
     void requiresPlatformAndPositiveDispatchIdBeforeAccess(String type) {
         var files = mock(FileObjectMapper.class);
         var storage = mock(BusinessFileStorage.class);
@@ -64,6 +66,19 @@ class DispatchEvidenceFileTest {
         verifyNoInteractions(files, storage);
     }
 
+    /** 司机照片与异常图片使用独立平台类别，拒绝PDF和伪造图片。 */
+    @ParameterizedTest @ValueSource(strings = {PHOTO, EXCEPTION})
+    void photoAcceptsOnlyRealImages(String type) throws Exception {
+        var storage=storage();var category=BusinessFileCategory.require(type);
+        for(var format:new String[]{"jpeg","png"}) {
+            var upload=new MockMultipartFile("file","driver."+format,"image/"+format,image(format));
+            var saved=storage.store(0,"71",upload,category);
+            assertThat(storage.read(saved.objectKey())).isEqualTo(upload.getBytes());
+        }
+        assertThatThrownBy(()->storage.store(0,"71",pdf(),category)).isInstanceOf(BizException.class);
+        assertThatThrownBy(()->storage.store(0,"71",new MockMultipartFile("file","driver.png","image/png",pdf().getBytes()),category)).isInstanceOf(BizException.class);
+    }
+
     /** 真实 PDF、JPG、PNG 均可写入并保持内容；上传不以扩展名代替 MIME 和签名。 */
     @ParameterizedTest
     @ValueSource(strings = {VEHICLE, DRIVER})
@@ -149,7 +164,7 @@ class DispatchEvidenceFileTest {
 
     /** 元数据和下载均逐列带全复合键；错车、错类别、错文件不得读取存储内容。 */
     @ParameterizedTest
-    @ValueSource(strings = {VEHICLE, DRIVER})
+    @ValueSource(strings = {VEHICLE, DRIVER, PHOTO, EXCEPTION})
     void metadataAndDownloadEnforceEveryScopeKeyBeforeReading(String type) throws Exception {
         var files = mock(FileObjectMapper.class);
         var storage = mock(BusinessFileStorage.class);

firstleg/src/main/java/com/baiyue/firstleg/portschedule/mapper/CarrierScheduleQueryMapper.java

@@ -63,6 +63,7 @@ public interface CarrierScheduleQueryMapper extends BaseMapper<CarrierScheduleQu
         """)
     CarrierScheduleQueryEntity findByContainerBookingId(@Param("containerBookingId") long containerBookingId);
 
+    /** 到港与日历统一取最新观测的实际记录，后续修正为更早时间时不能被历史最大值覆盖。 */
     @Select("""
         <script>
         SELECT b.id AS containerBookingId,q.id AS queryId,q.version AS queryVersion,
@@ -70,7 +71,7 @@ public interface CarrierScheduleQueryMapper extends BaseMapper<CarrierScheduleQu
                current.actual_at AS latestActualAt,
                MAX(CASE WHEN f.standard_node='DEPARTED_WAREHOUSE' THEN f.actual_at END) AS departedWarehouseAt,
                MAX(CASE WHEN f.standard_node='DEPARTED_ORIGIN_PORT' THEN f.actual_at END) AS departedOriginPortAt,
-               MAX(CASE WHEN f.standard_node='ARRIVED_DESTINATION_PORT' THEN f.actual_at END) AS arrivedDestinationPortAt,
+               MAX(arrival.actual_at) AS arrivedDestinationPortAt,
                MAX(CASE WHEN f.standard_node='PICKUP_READY' THEN f.actual_at END) AS pickupReadyAt,
                MAX(CASE WHEN f.standard_node='PICKED_UP' THEN f.actual_at END) AS pickedUpAt,
                MAX(CASE WHEN f.standard_node='EMPTY_RETURNED' THEN f.actual_at END) AS emptyReturnedAt
@@ -81,6 +82,10 @@ public interface CarrierScheduleQueryMapper extends BaseMapper<CarrierScheduleQu
                  ORDER BY f2.observed_at DESC,f2.id DESC LIMIT 1)
           LEFT JOIN fl_carrier_schedule_query q ON q.id=current.query_id
           LEFT JOIN fl_carrier_schedule_node_fact f ON f.container_booking_id=b.id AND f.actual_at IS NOT NULL
+          LEFT JOIN fl_carrier_schedule_node_fact arrival ON arrival.id=(
+                SELECT a.id FROM fl_carrier_schedule_node_fact a
+                 WHERE a.container_booking_id=b.id AND a.standard_node='ARRIVED_DESTINATION_PORT' AND a.actual_at IS NOT NULL
+                 ORDER BY a.observed_at DESC,a.id DESC LIMIT 1)
          WHERE b.id IN
          <foreach collection="containerBookingIds" item="id" open="(" separator="," close=")">#{id}</foreach>
          GROUP BY b.id,q.id,q.version,q.status,current.standard_node,current.actual_at

firstleg/src/test/java/com/baiyue/firstleg/portschedule/repository/CarrierScheduleQuerySqlContractTest.java

@@ -44,8 +44,9 @@ class CarrierScheduleQuerySqlContractTest {
         }
     }
 
+    /** 保留批量读取，实际到港与日历采用相同的最新观测顺序。 */
     @Test
-    void batchesActualContainerFactsWithoutEstimatedOrPerNodeQueries() throws Exception {
+    void batchesActualContainerFactsWithLatestObservedArrivalAndWithoutEstimatedTimes() throws Exception {
         String sql = String.join("\n", CarrierScheduleQueryMapper.class
             .getMethod("selectContainerActualFacts", List.class)
             .getAnnotation(Select.class).value());
@@ -55,13 +56,16 @@ class CarrierScheduleQuerySqlContractTest {
             .contains("f.actual_at IS NOT NULL")
             .contains("MAX(CASE WHEN f.standard_node='DEPARTED_WAREHOUSE'")
             .contains("MAX(CASE WHEN f.standard_node='DEPARTED_ORIGIN_PORT'")
-            .contains("MAX(CASE WHEN f.standard_node='ARRIVED_DESTINATION_PORT'")
+            .contains("MAX(arrival.actual_at) AS arrivedDestinationPortAt")
+            .contains("a.standard_node='ARRIVED_DESTINATION_PORT' AND a.actual_at IS NOT NULL")
+            .contains("ORDER BY a.observed_at DESC,a.id DESC LIMIT 1")
+            .doesNotContain("MAX(CASE WHEN f.standard_node='ARRIVED_DESTINATION_PORT'")
             .contains("MAX(CASE WHEN f.standard_node='PICKUP_READY'")
             .contains("MAX(CASE WHEN f.standard_node='PICKED_UP'")
             .contains("MAX(CASE WHEN f.standard_node='EMPTY_RETURNED'")
             .contains("ORDER BY b.id")
             .doesNotContain("estimated_at");
-        assertThat(count(sql, "fl_carrier_schedule_node_fact")).isEqualTo(3);
+        assertThat(count(sql, "fl_carrier_schedule_node_fact")).isEqualTo(5);
         assertThat(count(sql, "SELECT f2.id FROM fl_carrier_schedule_node_fact f2")).isEqualTo(1);
     }
 

firstleg/src/test/java/com/baiyue/firstleg/terminaldrayage/mapper/ContainerCalendarSourceMapperTest.java

@@ -2,6 +2,7 @@ package com.baiyue.firstleg.terminaldrayage.mapper;
 
 import com.baomidou.mybatisplus.core.MybatisConfiguration;
 import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
+import com.baiyue.firstleg.portschedule.mapper.CarrierScheduleQueryMapper;
 import org.apache.ibatis.mapping.Environment;
 import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
 import org.h2.jdbcx.JdbcDataSource;
@@ -10,6 +11,51 @@ import java.time.LocalDateTime;
 import static org.junit.jupiter.api.Assertions.*;
 
 class ContainerCalendarSourceMapperTest {
+    /** 后续观测可将实际到港修正为更早日期，两入口须取同一条最新实际记录。 */
+    @Test
+    void usesLatestObservedArrivalIncludingSameObservationIdTieBreakAcrossBothEntrypoints() throws Exception {
+        var ds = new JdbcDataSource();
+        ds.setURL("jdbc:h2:mem:arrival-source-correction;MODE=MySQL;DB_CLOSE_DELAY=-1");
+        try (var connection = ds.getConnection(); var sql = connection.createStatement()) {
+            sql.execute("CREATE TABLE fl_container_booking(id BIGINT PRIMARY KEY,cabinet_no VARCHAR,container_no VARCHAR," +
+                "vessel_name VARCHAR,voyage_no VARCHAR,destination_port_name VARCHAR,destination_warehouse_code VARCHAR," +
+                "actual_port_arrival_at TIMESTAMP,estimated_port_arrival_at TIMESTAMP,unloading_completed_at TIMESTAMP,record_status VARCHAR)");
+            sql.execute("CREATE TABLE fl_terminal_drayage(container_booking_id BIGINT,actual_empty_return_at TIMESTAMP)");
+            sql.execute("CREATE TABLE fl_carrier_schedule_query(id BIGINT,version INT,status VARCHAR)");
+            sql.execute("CREATE TABLE fl_carrier_schedule_node_fact(id BIGINT,query_id BIGINT,container_booking_id BIGINT," +
+                "standard_node VARCHAR,actual_at TIMESTAMP,observed_at TIMESTAMP)");
+            sql.execute("CREATE TABLE fl_direct_delivery_unloading(container_booking_id BIGINT,actual_at TIMESTAMP)");
+            sql.execute("CREATE TABLE fl_outbound_dispatch(container_booking_id BIGINT,confirmed_at TIMESTAMP,reversed_at TIMESTAMP,status VARCHAR)");
+            sql.execute("INSERT INTO fl_container_booking(id,cabinet_no,estimated_port_arrival_at,record_status) VALUES " +
+                "(1,'D1','2026-10-29 08:00:00','ACTIVE'),(2,'D2','2026-10-29 08:00:00','ACTIVE')");
+            sql.execute("INSERT INTO fl_carrier_schedule_query VALUES(1,0,'READY'),(2,0,'READY')");
+            sql.execute("INSERT INTO fl_outbound_dispatch SELECT id,'2026-10-01 00:00:00',NULL,'WAITING_FOR_LOADING' FROM fl_container_booking");
+            sql.execute("INSERT INTO fl_carrier_schedule_node_fact VALUES " +
+                "(1,1,1,'ARRIVED_DESTINATION_PORT','2026-10-23 14:00:00','2026-10-24 14:00:00')," +
+                "(2,1,1,'ARRIVED_DESTINATION_PORT','2026-10-21 14:00:00','2026-10-25 14:00:00')," +
+                "(3,1,1,'ARRIVED_DESTINATION_PORT',NULL,'2026-10-26 14:00:00')," +
+                "(4,2,2,'ARRIVED_DESTINATION_PORT','2026-10-24 14:00:00','2026-10-25 14:00:00')," +
+                "(5,2,2,'ARRIVED_DESTINATION_PORT','2026-10-22 14:00:00','2026-10-25 14:00:00')");
+        }
+        var config = new MybatisConfiguration();
+        config.setEnvironment(new Environment("test", new JdbcTransactionFactory(), ds));
+        config.addMapper(ContainerCalendarSourceMapper.class);
+        config.addMapper(CarrierScheduleQueryMapper.class);
+        try (var session = new MybatisSqlSessionFactoryBuilder().build(config).openSession()) {
+            var from = LocalDateTime.parse("2026-10-01T00:00:00");
+            var calendar = session.getMapper(ContainerCalendarSourceMapper.class).sources(from, from.minusDays(2), from.minusDays(4), from.plusMonths(1));
+            var workbench = session.getMapper(CarrierScheduleQueryMapper.class).selectContainerActualFacts(java.util.List.of(1L, 2L));
+            assertEquals(2, calendar.size());
+            assertEquals(2, workbench.size());
+            for (int index = 0; index < calendar.size(); index++) {
+                var expected = LocalDateTime.parse(index == 0 ? "2026-10-21T14:00:00" : "2026-10-22T14:00:00");
+                assertEquals(expected, calendar.get(index).arrivalAt());
+                assertEquals("ACTUAL", calendar.get(index).arrivalType());
+                assertEquals(expected, workbench.get(index).arrivedDestinationPortAt());
+                assertEquals(calendar.get(index).arrivalAt().plusDays(2).toLocalDate(), workbench.get(index).arrivedDestinationPortAt().plusDays(2).toLocalDate());
+            }
+        }
+    }
     /** 使用实际 Mapper 核对跨月默认日期候选、缺日期与真实出仓边界。 */
     @Test
     void selectsShiftedArrivalUndatedAndOlderReturnCandidatesWithoutInactiveOrUndepartedContainers() throws Exception {

lastleg-service/AGENTS.md

@@ -17,7 +17,7 @@
 
 拼车余位发布查 `fleet/trip/FleetCapacityOfferService.java`；整车建单与准备查 `dispatch/controller/DispatchAggregateController.java` 和 `dispatch/service/DispatchAggregateService.java`，本土业务接线查 `fleet/business/`；既有外接登记衔接合同为 `fleet-preparation-v1.yaml`，排车流程按 `../../docs/海外仓业务/排车列表统一作业改造契约.md`。
 
-原排车装车后运营视图分别查 `fleet/ownedbusiness/`、`fleet/outsourcedbusiness/` 与各自 `fleet-*-business-v1.yaml`；自有/外配按同事务捕获的车辆归属，不按货源区分。两入口可信作用域及权限独立，外配仅整车承运金额、逐目的仓到达和五装车照片；复用四张附加表，不修改原履约/库存/财务状态。共同业务规则见 `../../docs/海外仓业务/自有业务首版开发契约.md`、`../../docs/海外仓业务/外配业务首版开发契约.md`，实际发布及HTTP只查部署主契约。
+原排车装车后运营视图分别查 `fleet/ownedbusiness/`、`fleet/outsourcedbusiness/` 与各自 `fleet-*-business-v1.yaml`；自有业务按无实际拼车货物、外配任务按已实际接入需求池货物分类；车辆归属仍读取装车快照，完整判定唯一见外配业务契约。两入口可信作用域及权限独立，外配仅整车承运金额、逐目的仓到达和五装车照片；复用四张附加表，不修改原履约/库存/财务状态。共同业务规则见 `../../docs/海外仓业务/自有业务首版开发契约.md`、`../../docs/海外仓业务/外配业务首版开发契约.md`，实际发布及HTTP只查部署主契约。
 
 事件重试：`controller/EventOperationsController.java`，内部 `/internal/lastleg/event-operations/{entryId}` 查询、`/retry` 写入；仅卸柜、派送、暂扣、资金及费用事件，以 `EVENT_OPERATIONS_TOKEN` 保护。原事件不可改，DEAD→PENDING 与 `event_delivery_retry_audit` 同事务；脚本 `scripts/event-outbox-operations.mjs`。
 
@@ -57,7 +57,7 @@
 | PDA 仓内通用扫码与操作历史 | `pda/warehouse/controller/PdaWarehouseController.java` |
 | 船节点接收与海外 PDA 可收货门禁 | `shipping/service/ContainerShippingNodeConsumer.java` |
 | 平台排车查询、整车四块详情、审核与实载 | `dispatch/controller/DispatchQueryController.java`、`DispatchAggregateController.java`；公开契约`dispatch/port/`，业务规则见`../../docs/海外仓业务/排车列表统一作业改造契约.md` |
-| 草稿、双端装发与派送安排 | `dispatch/controller/SmartDispatchController.java`、`dispatch/pda/controller/DispatchPdaController.java`；平台维护`DispatchController.java`，派送组合`delivery/controller/DeliveryTransferController.java` |
+| 草稿、双端装车发运 | `dispatch/controller/SmartDispatchController.java`、`dispatch/pda/controller/DispatchPdaController.java`；平台维护`DispatchController.java`；自动发运编排`dispatch/service/DispatchLoadingDepartureService.java` |
 | 仓储资源调用 | `inboundplan/pda/gateway/WarehouseResourceGateway.java` |
 | 仓储转运、历史订单/入仓绑定、可选换标联动 | `transfer/controller/WarehouseTransferController.java` |
 | 一件代发接收、SKU/箱唛库存 | `dropship/controller/DropshipOrderController.java` |
@@ -77,7 +77,7 @@
 | 整车调度与理货审核 | `dispatch/controller/DispatchAggregateController.java` → `dispatch/service/DispatchAggregateService.java` 的提交及两级审核；同一排车先调度审核、再理货审核，通过后才允许真实扫码。资源、货物或路线关键变更使原依据失效；零扫码显式退回后重新审核，不复用旧客户子单审核状态 |
 | 外接询价、确认占位及取消 | `fleet/trip/PlatformFleetBookingController.java`、`FleetBookingService.java`、`FleetBookingReservations.java`；客户从`fleet/customer/`读取IAM有效主档与资格，询价不占位，确认后与自有货计划共同校验逐段容量。约定金额不代表应收/实收，`FleetBookingIncomingGateway`由`transfer/fleet/FleetIncomingAdapter`实现来货登记/实收确认，排车关联通过`FleetDispatchGateway.sourceCargo`核对实收来源 |
 | 拣货前计划容量与逐段余位 | `FleetTripExecutionService.capacityPlan/confirmCapacityPlan`、`/fleet/trips/{tripNo}/capacity-plan`；保存自有货的计划值，不检查拣货完成、不推进审核或扣库存；`planValid`校验当前货物hash，不把计划值当实测值，资源/计划/关联变更后须重新核对 |
-| 实物装载、逐段容量与双端整车发车 | `dispatch/pda/controller/DispatchPdaController.java` → `dispatch/service/DispatchAggregateService.java`（装车）、`DispatchDepartureService.java`（发车）；平台与PDA均使用本端`dispatches/{dispatchNo}/loading-complete`及`/depart`，公共DTO在`dispatch/port/`，已有单写入唯一`recordVersion`。装车前须真实PDA拣货核平，发车前须全车派送安排完整；装车及发车不重复执行扫码已完成的库存SHIP，Fleet容量和资源资格继续由真实提供者复核 |
+| 实物装载、逐段容量与双端整车发车 | 两端`dispatches/{dispatchNo}/loading-complete`统一调用`dispatch/service/DispatchLoadingDepartureService.java`，同一事务复用实载确认、派送单准备及发车，成功直接`DELIVERING`；请求携带唯一`recordVersion`，原键恢复最终结果。公开手工安排派送、`/depart`入口已移除；内部`AFTER_LOADING`和步骤命令只用于事务编排。真实PDA拣货须核平，不重复库存SHIP，Fleet容量和资源资格仍复核；未知费用不补零、不阻塞发运，真实已明确外接报价沿原费用来源防重 |
 | 车次货物结案、车辆和司机分别释放 | `fleet/trip/FleetTripCompletionService.java`、`FleetCompletionModels.java`；平台 `/fleet/trips/{tripNo}/completion`、`/complete`、`/resources/release`，独立complete/release权限。结案核对所有派送终态与实发数量；实际任务结束时间/地点及车辆结束状态单独记录，不以结案或收款自动释放资源 |
 | 跨服务 HTTP 客户端装配 | `config/LastlegRestClientFactory.java` |
 | 数据库基线、表索引与中文注释契约 | `src/main/resources/db/lastleg.sql` |

lastleg-service/docs/business-index.md

@@ -85,8 +85,8 @@
 
 - 车次成本：`fleet/trip/FleetTripCostService.java`、`fleet-trip-costs-v1.yaml`；按DEPART实测及外接实收分摊，不产生客户账单/付款。
 - 报价/统计：`fleet/quote/`、`fleet/reporting/`，合同`fleet-quotes-v1.yaml`、`fleet-operations-v1.yaml`；实测凭证按车次归属，仅当前/历史版本引用可下载。
-- 自有业务运营：`fleet/ownedbusiness/`、`fleet-owned-business-v1.yaml`，共同规则见`../../../docs/海外仓业务/自有业务首版开发契约.md`；原排车装车后三阶段按装车时自有车辆归属展示，仅补金额、逐目的地到达、里程、油耗与照片。原详情只经`dispatch.port.DispatchDetailReader`读取，原装车事务经`OwnedBusinessOwnershipCapture`捕获归属，不另建履约流程。
-- 外配业务运营：`fleet/outsourcedbusiness/`、`fleet-outsourced-business-v1.yaml`，共同规则见`../../../docs/海外仓业务/外配业务首版开发契约.md`；原排车装车后三阶段按冻结DISPATCHED归属展示，包括正式MASTER/EXTERNAL两种资源模式。只登记整车承运金额、逐目的仓到达和五装车照片，无里程/油耗或成本拆分。内部可信作用域复用四表，入口权限与自有严格分开，不引入第二履约模型。
+- 自有业务运营：`fleet/ownedbusiness/`、`fleet-owned-business-v1.yaml`，共同规则见`../../../docs/海外仓业务/自有业务首版开发契约.md`；原排车装车后三阶段按无实际拼车货物展示，车辆归属独立，仅补金额、逐目的地到达、里程、油耗与照片。原详情只经`dispatch.port.DispatchDetailReader`读取，原装车事务经`OwnedBusinessOwnershipCapture`捕获归属，不另建履约流程。
+- 外配业务运营：`fleet/outsourcedbusiness/`、`fleet-outsourced-business-v1.yaml`，共同规则见`../../../docs/海外仓业务/外配业务首版开发契约.md`；原排车装车后三阶段按实际接入需求池拼车货物展示，车辆归属独立，包含MASTER/EXTERNAL两种资源模式。只登记整车承运金额、逐目的仓到达和五装车照片，无里程/油耗或成本拆分。内部可信作用域复用四表，入口权限与自有严格分开，不引入第二履约模型。
 - 外接选价合同：`fleet-quote-candidates-v1.yaml`、`fleet-trips-v1.yaml`；来源快照与成交价分开，确认承运复验。
 - 在途交接：`fleet/exception/`、`fleet-handovers-v1.yaml`；后台确认交接，旧资源分别结束任务，DEPART不重写。
 
@@ -95,9 +95,9 @@
 - 海外仓全流程连续覆盖尾程订单、入仓计划/PDA 入仓、换标、产品与箱唛快照、库存、转运、废弃、采购、本土卡车、本土散板、排车查询/智能预排、排车编辑/取消/发车、PDA 拣货与出库、一件代发、转派送、客户派送单、异常退回和客户回访。
 - 服务端正式入口包括 `dispatch/controller/DispatchController.java`、`dispatch/pda/controller/DispatchPdaController.java`、`delivery/controller/DeliveryTransferController.java`、`delivery/controller/OutboundPdaController.java`、`delivery/controller/MerchantDeliveryController.java`、`exceptionorder/` 与 `customervisit/`；设备页面是否可用以海外 PDA 正式路由和能力开关为准，未由 PDA 承载的操作由 Admin/Client 完成。
 - 平台一件代发出库候选由 `/outbound-orders/one-click-dropship/candidates` 统一返回已完成入库且仍有可用箱唛、SKU 汇总和库存仓位绑定的托盘明细；查询不强制先传 `customerId`，未传时跨客户展示供页面分页筛选，创建时必须从所选候选解析为唯一客户和唯一海外仓，禁止一张出库单跨客户或跨仓。创建后出库单按 `WAIT_PICK → PICKING → PICKED → OUTBOUNDED` 推进；海外 PDA 扫描托盘码时通过整托命令原子拣取该托盘在当前任务内全部剩余箱件和 SKU，任一库存明细失败须整托回滚，逐箱拣货入口继续保留。
-- 排车主流程以工作区 `docs/海外仓业务/排车列表统一作业改造契约.md` 为正式入口：一张排车单代表一趟车，装车完成后、实际发车前由后台安排派送，按客户与目的仓拆分派送单。`DispatchPdaWorkflowService` 按公开 `status`、`stage`、`recordVersion` 和 `actions` 返回作业事实与资格，Admin/PDA 共用服务端规则；BOL 与签收资料归拆分后的派送单，费用按其来源去重，不以旧转派送阶段或前端推算代替资格校验。
+- 排车主流程以工作区 `docs/海外仓业务/排车列表统一作业改造契约.md` 为正式入口：一张排车单代表一趟车；Admin/PDA确认`loading-complete`时，同一事务自动按客户与目的仓生成派送单并发车，成功直接进入`DELIVERING`。公开手工安排派送及`/depart`入口已删除；内部`AFTER_LOADING`仅是同事务中间态。`DispatchPdaWorkflowService` 按公开 `status`、`stage`、`recordVersion` 和 `actions` 返回作业事实与资格，Admin/PDA 共用服务端规则；BOL 与签收资料归拆分后的派送单，费用按其来源去重，不以旧转派送阶段或前端推算代替资格校验。
 - 排车主单允许同一起运仓的跨客户货物同车，每条来源保留客户、库存与费用归属；不再要求用户先建独立车次再关联多张客户排车。Fleet 的资源、司机证照、容量、历史与附加能力继续沿 `fleet/trip/` 定位；计划或资源变化对审核、实载确认的影响按正式契约及服务端结果核对，已拣货事实不能因改派或取消被直接抹除，实际发车后不得伪造资源释放。
-- 实物装载按仓库托盘去重计量，客户货量与物理占位分别保存；重量/体积必须来自实际确认，不用计费材积重回填。装车前真实拣货须核平，后台不能补录拣货数量绕过；装车、安排派送和发车不重复执行已完成的库存扣减。来源、审核、实载与资源版本变化按正式契约重新校验，保留操作历史；双端使用同一版本与原请求键核对结果，任何失败均不得伪造完成事实。
+- 实物装载按仓库托盘去重计量，客户货量与物理占位分别保存；重量/体积必须来自实际确认，不用计费材积重回填。装车前真实拣货须核平，后台不能补录拣货数量绕过；装车发运编排不重复执行已完成的库存扣减；费用未明确时保持未计费，不要求理货员补费用，也不填零，真实已明确外接报价仍按原来源防重发布。来源、审核、实载与资源版本变化按正式契约重新校验，保留操作历史；双端使用同一版本与原请求键核对结果，任何失败均不得伪造完成事实。
 - 车次结案只消费派送事实：实签须signedAt/signedPackages，实退须原来源入账流水/RETURN_COMPLETED；实签加本趟实退等于原实发且余量为零。拒收、待退回、取消不算完成，时间取最后实际终态。结案不改客户状态/费用、不释放占用；车/司机分别记录实际结束时间地点，车辆状态与释放同事务。过期证照不阻止旧任务结束、不恢复新任务资格；原键重放不影响后续车次。
 - 已签收后另发起退货保留原运输的签收事实，后续退货不重开原车次、不被车次结案改写；未签收货物仍按实际退回完成核对。`DeliveryDocumentService.save` 首次保存签收资料触发完成时要求关联出库已OUTBOUNDED，未出库可以准备BOL/装车资料但不能提前完成派送。
 - 排车执行与 `delivery/` Controller 一同注册；平台排车查询和智能预排入口分别沿 `lastleg.dispatch-query-api.enabled`、`lastleg.smart-dispatch-api.enabled` 配置定位，启用现状以配置和实际路由核对。平台查询按全局排车号及来源归属加载跨客户同车明细，客户接口保持本客户隔离；预排创建逐项校验同一起运仓及各来源客户，不能强制整张排车只含一个客户。草稿托盘锁仍按操作人与草稿标识持有，释放、失效及转正式锁由服务端原子处理。

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

@@ -37,25 +37,6 @@ public class DeliveryTransferController {
         return ApiResponse.success(dispatchDelivery.preview(actor(user),dispatchNo).groups());
     }
 
-    /** 一次快照提供全部客户目的地、费用证据及既有安排的完整数组。 */
-    @GetMapping("/dispatches/{dispatchNo}/delivery-arrangement")
-    @PreAuthorize("hasAuthority('" + OverseasPermissions.DISPATCH_LIST + "')")
-    public ApiResponse<ArrangementPreview> arrangement(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo) {
-        requirePlatform(user);
-        return ApiResponse.success(dispatchDelivery.preview(actor(user),dispatchNo));
-    }
-
-    /** 平台一次安排本车全部客户，身份只从认证上下文获取。 */
-    @PostMapping("/dispatches/{dispatchNo}/transfer-delivery")
-    @PreAuthorize("hasAuthority('" + OverseasPermissions.DISPATCH_TRANSFER_DELIVERY + "')")
-    @Operation(summary = "按真实客户生成出库单并按客户目的地生成派送单")
-    public ApiResponse<CommandResult> transfer(
-        @AuthenticationPrincipal AuthenticatedUser user, @PathVariable String dispatchNo,
-        @Valid @RequestBody ArrangeDelivery request) {
-        requirePlatform(user);
-        return ApiResponse.success(dispatchDelivery.arrange(actor(user),dispatchNo,request));
-    }
-
     @PostMapping("/outbound-orders/one-click-dropship")
     @PreAuthorize("hasAuthority('" + OverseasPermissions.OUTBOUND_CREATE + "')")
     @Operation(summary = "Create one-click dropship outbound and push a PDA picking task")

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

@@ -126,6 +126,51 @@ public class DispatchDeliveryService implements DispatchDeliveryPort {
             var input=inputs.get(group.key());var coverage=fees.coverage(group,input,actor.operatorId(),external.get(group.customerId()));
             fees.validate(group,input,coverage,external.get(group.customerId()));coverages.put(group.key(),coverage);
         }
+        var fact=createDocuments(context,actor,request.idempotencyKey(),businessHash,groups,inputs,external,coverages);
+        return execution.recordArrangement(context,actor,identity,fact,false);
+    }
+
+    /** 装车父事务内自动生成全车单据；未知派送资料和未确认费用保持未登记。 */
+    @Override
+    @Transactional(propagation=Propagation.MANDATORY)
+    public ArrangementFact prepareForDeparture(Context context,Actor actor,String commandKey) {
+        if(actor==null || blank(actor.operatorId()) || blank(commandKey) || commandKey.length()>255)
+            throw conflict("缺少装车操作身份或原请求标识");
+        if(context==null || context.status()!=Status.ACTIVE || context.stage()!=Stage.AFTER_LOADING
+            || !context.pickingReconciled() || context.loadingCompletedAt()==null || blank(context.loadingCompletionHash())
+            || blank(context.cargoHash()) || context.cargo()==null || context.cargo().isEmpty())
+            throw conflict("请先完成真实拣货核平及装车确认");
+        if(actor.mode()==ActorMode.PDA && !Objects.equals(actor.boundWarehouseId(),context.warehouseId()))
+            throw conflict("排车不属于当前绑定仓");
+        var saved=repository.arrangement(context.dispatchId(),true);
+        if(saved!=null) {
+            if(!Objects.equals(saved.getOriginalCommandKey(),commandKey)
+                || !Objects.equals(saved.getCargoHash(),context.cargoHash())
+                || !Objects.equals(saved.getLoadingCompletionHash(),context.loadingCompletionHash()))
+                throw conflict("本车已有不同装车命令生成的派送事实");
+            var facts=departureFacts(context,true);
+            if(!facts.depart().allowed())throw conflict(facts.depart().blockReason());
+            return fact(saved);
+        }
+        // 不能把缺少安排事实的孤立单据补建成另一套；全部客户在同一事务中创建。
+        if(!repository.outbounds(context.dispatchId(),true).isEmpty() || !repository.deliveries(context.dispatchId(),true).isEmpty())
+            throw conflict("已存在关联单据但缺少完整安排事实，请核对");
+        var groups=grouping.groups(context);var external=fees.external(context);
+        var inputs=new HashMap<String,ArrangeGroup>();
+        for(var group:groups) {
+            String carrier=context.resources()==null || context.resources().vehicle()==null?null:context.resources().vehicle().carrierName();
+            inputs.put(group.key(),new ArrangeGroup(group.key(),group.cargoHash(),null,null,null,carrier,null,null,
+                null,null,null,null,null,external.get(group.customerId()).snapshotHash(),null,List.of(),List.of()));
+        }
+        String businessHash=grouping.hash(Arrays.asList(context.dispatchNo(),context.cargoHash(),context.loadingCompletionHash(),
+            groups.stream().map(g->inputs.get(g.key())).toList()));
+        return createDocuments(context,actor,commandKey,businessHash,groups,inputs,external,Map.of());
+    }
+
+    /** 自动装车与内部安排复用同一建单、来源锁及真实外接报价发布路径，不推定原费覆盖。 */
+    private ArrangementFact createDocuments(Context context,Actor actor,String commandKey,String businessHash,List<Group> groups,
+        Map<String,ArrangeGroup> inputs,Map<String,com.baiyue.lastleg.fleet.trip.FleetBookingFreight.Preview> external,
+        Map<String,DeliveryFeeCoverageModels.Evidence> coverages) {
         var now=Instant.now();String key="DLA"+IdWorker.getId();var outbounds=new LinkedHashMap<String,OutboundOrder>();
         for (var customer:groups.stream().map(Group::customerId).distinct().sorted().toList()) {
             var cargo=context.cargo().stream().filter(c->customer.equals(c.customerId())).toList();
@@ -169,9 +214,9 @@ public class DispatchDeliveryService implements DispatchDeliveryPort {
         var arrangement=new DispatchDeliveryArrangement();arrangement.setId(IdWorker.getId());arrangement.setDispatchOrderId(context.dispatchId());
         arrangement.setDispatchNo(context.dispatchNo());arrangement.setArrangementKey(key);arrangement.setBusinessHash(businessHash);
         arrangement.setCargoHash(context.cargoHash());arrangement.setLoadingCompletionHash(context.loadingCompletionHash());
-        arrangement.setOriginalCommandKey(request.idempotencyKey());arrangement.setOriginalOperatorId(actor.operatorId());
+        arrangement.setOriginalCommandKey(commandKey);arrangement.setOriginalOperatorId(actor.operatorId());
         arrangement.setResultJson(write(result));arrangement.setCargoJson(write(context.cargo()));arrangement.setCreatedAt(local(now));repository.create(arrangement);
-        return execution.recordArrangement(context,actor,identity,fact(arrangement),false);
+        return fact(arrangement);
     }
 
     /** 发车先取得全部出库锁，再取得全部派送锁，当前读取不申请来源锁。 */
@@ -281,7 +326,7 @@ public class DispatchDeliveryService implements DispatchDeliveryPort {
         var destination=group.destination();d.setDeliveryGroupKey(grouping.documentGroupKey(destination));d.setDestinationType(destination.type());
         d.setDestinationWarehouseId(destination.warehouseId());d.setDestinationWarehouseCode(destination.warehouseCode());d.setDestinationWarehouseName(destination.warehouseName());
         d.setDeliveryAddress(destination.address());d.setPostalCode(destination.postalCode());d.setContactName(destination.contactName());d.setContactPhone(destination.contactPhone());
-        d.setStatus("WAIT_DELIVERY");d.setVersion(0L);d.setDeliveryMethod(input.deliveryMethod());d.setPlannedDeliveryAt(local(input.plannedDeliveryAt()));
+        d.setStatus("WAIT_DELIVERY");d.setVersion(0L);d.setDeliveryMethod(input.deliveryMethod());d.setPlannedDeliveryAt(input.plannedDeliveryAt()==null?null:local(input.plannedDeliveryAt()));
         d.setWaybillNo(input.waybillNo());d.setCarrierName(input.carrierName());d.setPickupMethod(input.pickupMethod());d.setLoadingType(input.loadingType());
         d.setVehicleType(input.vehicleType());d.setVehicleSize(input.vehicleSize());d.setAppointmentAccount(input.appointmentAccount());d.setSellerName(input.sellerName());d.setRemark(input.remark());
         if(context.resources()!=null){if(context.resources().vehicle()!=null)d.setVehiclePlate(context.resources().vehicle().plate());

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/controller/DispatchAggregateController.java

@@ -14,7 +14,7 @@ import org.springframework.web.bind.annotation.*;
 @RequestMapping("/api/platform/v1/last-leg/dispatches")
 public class DispatchAggregateController {
     private final DispatchAggregateService service;
-    @jakarta.annotation.Resource private com.baiyue.lastleg.dispatch.service.DispatchDepartureService departure;
+    @jakarta.annotation.Resource private com.baiyue.lastleg.dispatch.service.DispatchLoadingDepartureService loadingDeparture;
 
     /** 注入本域应用服务。 */
     public DispatchAggregateController(DispatchAggregateService service) { this.service=service; }
@@ -71,21 +71,21 @@ public class DispatchAggregateController {
     public ApiResponse<com.baiyue.lastleg.dispatch.port.DispatchPlanningModels.LoadingPreview> loading(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo) {
         return ApiResponse.success(service.loading(DispatchActorFactory.platform(user),dispatchNo));
     }
-    /** 显式确认装车，不复用最后扫码或实际发车操作。 */
+    /** 显式确认装车后自动准备派送并发车，原请求恢复最终派送中结果。 */
     @PostMapping("/{dispatchNo}/loading-complete")
     @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:loading-complete')")
     public ApiResponse<CommandResult> loadingComplete(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@RequestBody DispatchCommands.LoadingComplete request) {
-        return ApiResponse.success(service.loadingComplete(DispatchActorFactory.platform(user),dispatchNo,request));
+        return ApiResponse.success(loadingDeparture.complete(DispatchActorFactory.platform(user),dispatchNo,request));
     }
-    /** 与PDA共用实际发车服务和公共版本，未完整安排派送不能发车。 */
-    @PostMapping("/{dispatchNo}/depart")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:depart')")
-    public ApiResponse<CommandResult> depart(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@RequestBody DispatchCommands.Depart request) {
-        return ApiResponse.success(departure.depart(DispatchActorFactory.platform(user),dispatchNo,request));
-    }
-    /** 本车证据先上传，主单引用随后走版本化编辑。 */
-    @PostMapping(value="/{dispatchNo}/evidence/{kind}",consumes=org.springframework.http.MediaType.MULTIPART_FORM_DATA_VALUE)
+    /** 派送异常登记不触发签收或退货入库。 */
+    @PostMapping("/{dispatchNo}/exceptions")
     @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
+    public ApiResponse<CommandResult> markException(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@RequestBody DispatchCommands.MarkException request) {
+        return ApiResponse.success(service.markException(DispatchActorFactory.platform(user),dispatchNo,request));
+    }
+    /** 本车证据先上传；维护和当前待审权限分别由服务端核验，引用随对应命令保存。 */
+    @PostMapping(value="/{dispatchNo}/evidence/{kind}",consumes=org.springframework.http.MediaType.MULTIPART_FORM_DATA_VALUE)
+    @PreAuthorize("hasAnyAuthority('platform:overseas-warehouse:dispatch:edit','platform:fleet:trip:dispatch-review','platform:fleet:trip:loading-review')")
     public ApiResponse<com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.File> uploadEvidence(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,
         @PathVariable com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind kind,@RequestPart("file")org.springframework.web.multipart.MultipartFile file) {
         return ApiResponse.success(service.uploadEvidence(DispatchActorFactory.platform(user),dispatchNo,kind,file));

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/controller/SmartDispatchController.java

@@ -26,7 +26,7 @@ public class SmartDispatchController {
     /** 读取实际候选，不在草稿域复制来源筛选逻辑。 */
     @GetMapping("/candidates")
     @PreAuthorize("hasAuthority('"+OverseasPermissions.DISPATCH_LIST+"')")
-    public ApiResponse<CandidateList> candidates(@AuthenticationPrincipal AuthenticatedUser user,@RequestParam String warehouseId,
+    public ApiResponse<CandidateList> candidates(@AuthenticationPrincipal AuthenticatedUser user,@RequestParam(required=false) String warehouseId,
         @RequestParam(required=false)List<Long> planIds,@RequestParam(required=false)String orderNo,
         @RequestParam(required=false)String destinationWarehouseCode,@RequestParam(required=false)String sourceStage,@RequestParam(required=false)String draftToken,
         @RequestParam(defaultValue="1")int page,@RequestParam(defaultValue="20")int size,@RequestParam(defaultValue="ALL")String warehouseTab) {

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/entity/DispatchAggregate.java

@@ -24,6 +24,7 @@ public class DispatchAggregate {
     private String dispatchReviewJson;
     private String loadingReviewJson;
     private String resourcesJson;
+    private String exceptionsJson;
     private String vehiclePlate;
     private String route;
     private LocalDateTime plannedDepartureAt;

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/gateway/DispatchEvidenceGateway.java

@@ -2,9 +2,9 @@ package com.baiyue.lastleg.dispatch.gateway;
 
 import org.springframework.web.multipart.MultipartFile;
 
-/** 临时车辆和司机证据属于本张整车，不能借司机主档或客户文件授权。 */
+/** 车辆、司机及审核补充证据属于本张整车，不能借司机主档或客户文件授权。 */
 public interface DispatchEvidenceGateway {
-    enum Kind { VEHICLE, DRIVER }
+    enum Kind { VEHICLE, DRIVER, DRIVER_PHOTO, EXCEPTION }
     record File(Long fileId,String fileName,String contentType,long sizeBytes) { }
     /** 上传只写本车、本类证据。 */
     File upload(long dispatchId,Kind kind,String operator,MultipartFile file);

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/gateway/HttpDispatchEvidenceGateway.java

@@ -29,7 +29,7 @@ public class HttpDispatchEvidenceGateway implements DispatchEvidenceGateway {
     private static String type(Kind kind) { return "OVERSEAS_DISPATCH_"+Objects.requireNonNull(kind).name()+"_EVIDENCE"; }
     /** 本车证据上传完成后仍以File返回元数据核对复合归属。 */
     @Override public File upload(long dispatch,Kind kind,String operator,MultipartFile file) {
-        if(file==null || file.isEmpty() || file.getSize()>MAX || !TYPES.contains(Objects.toString(file.getContentType(),"")))throw invalid();
+        if(file==null || file.isEmpty() || file.getSize()>MAX || !supportedType(kind,file.getContentType()))throw invalid();
         var body=new MultipartBodyBuilder();
         try { body.part("file",new ByteArrayResource(file.getBytes()) {
             /** 保留用户文件名供审阅，不把路径当业务事实。 */
@@ -80,9 +80,13 @@ public class HttpDispatchEvidenceGateway implements DispatchEvidenceGateway {
         var value=envelope.data();
         if(!Objects.equals(value.tenantId(),0L) || !type(kind).equals(value.businessType()) || !Long.toString(dispatch).equals(value.businessId())
             || value.fileId()==null || value.fileId()<=0 || id!=null&&!id.equals(value.fileId()) || value.fileName()==null || value.fileName().isBlank()
-            || !TYPES.contains(Objects.toString(value.contentType(),"")) || value.sizeBytes()==null || value.sizeBytes()<=0 || value.sizeBytes()>MAX)throw invalid();
+            || !supportedType(kind,value.contentType()) || value.sizeBytes()==null || value.sizeBytes()<=0 || value.sizeBytes()>MAX)throw invalid();
         return new File(value.fileId(),value.fileName(),value.contentType(),value.sizeBytes());
     }
+    /** 司机本人照片与异常证据只接受图片；车辆和驾驶证沿现有PDF/图片证据规则。 */
+    private static boolean supportedType(Kind kind,String contentType) {
+        return TYPES.contains(Objects.toString(contentType,"")) && ((kind!=Kind.DRIVER_PHOTO && kind!=Kind.EXCEPTION) || !"application/pdf".equals(contentType));
+    }
     /** 无效证据不能作为已核实资料。 */
     private static ResponseStatusException invalid(){return new ResponseStatusException(HttpStatus.BAD_REQUEST,"证据须为本车有效PDF、JPG或PNG，最大10MiB");}
     /** File明确拒绝归属或文件格式属于业务错误，不能伪装成服务不可用。 */

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

@@ -26,6 +26,9 @@ public interface DispatchAggregateMapper {
     String CURRENT_FILTER = """
         <if test='q.status != "ALL"'> AND d.status=#{q.status}</if>
         <if test='q.stage != null'> AND d.stage=#{q.stage}</if>
+        <if test='q.section == "VEHICLE_INFO"'> AND d.stage='BEFORE_LOADING' AND d.review_state IN ('DRAFT','DISPATCH_REJECTED','LOADING_REJECTED')</if>
+        <if test='q.section == "DISPATCH_REVIEW"'> AND d.stage='BEFORE_LOADING' AND d.review_state='DISPATCH_PENDING'</if>
+        <if test='q.section == "LOADING_REVIEW"'> AND d.stage='BEFORE_LOADING' AND d.review_state='LOADING_PENDING'</if>
         <if test='q.reviewStatus != null and q.section == "DISPATCH_REVIEW"'> AND (
         """ + REVIEW_DISPATCH + ")=#{q.reviewStatus}</if>"
         + "<if test='q.reviewStatus != null and q.section == \"LOADING_REVIEW\"'> AND (" + REVIEW_LOADING + ")=#{q.reviewStatus}</if>";
@@ -76,21 +79,22 @@ public interface DispatchAggregateMapper {
     @Update("""
         UPDATE ll_dispatch_order SET cargo_revision=cargo_revision+1,cargo_hash=#{hash},item_count=#{items},
           pallet_count=#{pallets},package_count=#{packages},route=#{route},review_state='DRAFT',
-          review_basis_hash=NULL,dispatch_review_json=#{pending},loading_review_json=#{pending},
+          review_basis_hash=NULL,dispatch_review_json=#{dispatchReview},loading_review_json=#{loadingReview},
           record_version=record_version+1,updated_at=#{at}
         WHERE id=#{id} AND record_version=#{version} AND status='ACTIVE' AND stage='BEFORE_LOADING'
           AND picked_package_count=0 AND shipped_package_count=0
         """)
     int changeCargo(@Param("id") long id, @Param("version") long version, @Param("hash") String hash,
                     @Param("items") int items, @Param("pallets") int pallets, @Param("packages") int packages,
-                    @Param("route") String route, @Param("pending") String pending, @Param("at") java.time.LocalDateTime at);
+                    @Param("route") String route, @Param("dispatchReview") String dispatchReview, @Param("loadingReview") String loadingReview,
+                    @Param("at") java.time.LocalDateTime at);
 
     /** 父锁内按公共版本保存状态及审核依据，显式清空旧依据而不依赖实体非空更新策略。 */
     @Update("""
         UPDATE ll_dispatch_order SET status=#{r.status},stage=#{r.stage},record_version=#{r.recordVersion},
           review_state=#{r.reviewState},review_round=#{r.reviewRound},review_basis_hash=#{r.reviewBasisHash},
           dispatch_review_json=#{r.dispatchReviewJson},loading_review_json=#{r.loadingReviewJson},
-          cargo_hash=#{r.cargoHash},cargo_revision=#{r.cargoRevision},resources_json=#{r.resourcesJson},vehicle_plate=#{r.vehiclePlate},planned_departure_at=#{r.plannedDepartureAt},
+          exceptions_json=#{r.exceptionsJson},cargo_hash=#{r.cargoHash},cargo_revision=#{r.cargoRevision},resources_json=#{r.resourcesJson},vehicle_plate=#{r.vehiclePlate},planned_departure_at=#{r.plannedDepartureAt},
           estimated_arrival_at=#{r.estimatedArrivalAt},remark=#{r.remark},loading_completed_at=#{r.loadingCompletedAt},
           loading_completion_hash=#{r.loadingCompletionHash},loading_confirmation_json=#{r.loadingConfirmationJson},arrangement_key=#{r.arrangementKey},
           arrangement_business_hash=#{r.arrangementBusinessHash},departed_at=#{r.departedAt},

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

@@ -50,7 +50,8 @@ public interface DispatchCandidatePageMapper {
         }
         /** 仓库页签也是服务端筛选，分页后不能再用本地筛选伪装完整结果。 */
         private static String filtered(boolean count) {
-            return " FROM ("+rows(count)+") candidates WHERE overseasWarehouseId=#{query.warehouseId}"
+            return " FROM ("+rows(count)+") candidates WHERE 1=1"
+                +"<if test='query.warehouseId != null'> AND overseasWarehouseId=#{query.warehouseId}</if>"
                 +"<if test='query.destinationWarehouseCode != null'> AND fbaWarehouseCode=#{query.destinationWarehouseCode}</if>"
                 +"<if test=\"query.warehouseTab == 'LAX'\"> AND LOWER(CONCAT(COALESCE(overseasWarehouseCode,''),' ',COALESCE(overseasWarehouseName,''))) REGEXP 'lax|洛杉矶|los angeles'</if>"
                 +"<if test=\"query.warehouseTab == 'NYC'\"> AND LOWER(CONCAT(COALESCE(overseasWarehouseCode,''),' ',COALESCE(overseasWarehouseName,''))) REGEXP 'nyc|jfk|(^|[^a-z])ny([^a-z]|$)|纽约|new[ -]?york'</if>";

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

@@ -20,7 +20,7 @@ public class DispatchPdaController {
     @Resource private DispatchPdaQueryService queries;
     @Resource private DispatchPickingService picking;
     @Resource private DispatchAggregateService workflow;
-    @Resource private DispatchDepartureService departure;
+    @Resource private DispatchLoadingDepartureService loadingDeparture;
 
     /** 批量读取当前绑定仓的整车作业。 */
     @GetMapping
@@ -36,6 +36,13 @@ public class DispatchPdaController {
         return ApiResponse.success(queries.task(DispatchActorFactory.pda(user),dispatchNo));
     }
 
+    /** 理货审核与后台共用同一轮次、版本和幂等账本，驳回须填写原因。 */
+    @PostMapping("/{dispatchNo}/loading-review")
+    public ApiResponse<DispatchContracts.CommandResult> loadingReview(@AuthenticationPrincipal AuthenticatedUser user,
+        @PathVariable String dispatchNo,@Valid @RequestBody DispatchCommands.ReviewCommand request) {
+        return ApiResponse.success(workflow.review(DispatchActorFactory.pda(user),dispatchNo,true,request));
+    }
+
     /** 共用公共版本和全局请求键执行一次真实库存扫码。 */
     @PostMapping("/{dispatchNo}/items/{itemId}/pick")
     public ApiResponse<DispatchContracts.CommandResult> pick(@AuthenticationPrincipal AuthenticatedUser user,
@@ -50,18 +57,10 @@ public class DispatchPdaController {
         return ApiResponse.success(workflow.loading(DispatchActorFactory.pda(user),dispatchNo));
     }
 
-    /** 最后一次扫码不代替显式装车确认，双方使用同一正式命令。 */
+    /** 真实扫码核平后确认装车即发车，两端使用同一事务命令。 */
     @PostMapping("/{dispatchNo}/loading-complete")
     public ApiResponse<DispatchContracts.CommandResult> loadingComplete(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@RequestBody DispatchCommands.LoadingComplete request) {
-        return ApiResponse.success(workflow.loadingComplete(DispatchActorFactory.pda(user),dispatchNo,request));
-    }
-
-    /** 与平台共用实际发车服务，不执行第二次库存扣减。 */
-    @PostMapping("/{dispatchNo}/depart")
-    public ApiResponse<DispatchContracts.CommandResult> depart(@AuthenticationPrincipal AuthenticatedUser user,
-                                                              @PathVariable String dispatchNo,
-                                                              @Valid @RequestBody DispatchCommands.Depart request) {
-        return ApiResponse.success(departure.depart(DispatchActorFactory.pda(user),dispatchNo,request));
+        return ApiResponse.success(loadingDeparture.complete(DispatchActorFactory.pda(user),dispatchNo,request));
     }
 
     /** 原动作权限与绑定仓同时核对未知结果，不按单客户任务恢复。 */

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

@@ -14,7 +14,7 @@ public interface DispatchWholePdaReadMapper {
     /** 精确单号或有界阶段列表均先在SQL限制绑定仓。 */
     @Select("<script>SELECT * FROM ll_dispatch_order WHERE overseas_warehouse_id=#{warehouse} AND status='ACTIVE' "
         +"<choose><when test='number != null'>AND dispatch_no=#{number} </when><when test='stage != null'>AND stage=#{stage} </when>"
-        +"<otherwise>AND stage IN('LOADING','AFTER_LOADING','DELIVERING') </otherwise></choose>ORDER BY updated_at DESC,id DESC LIMIT 201</script>")
+        +"<otherwise>AND (stage IN('LOADING','AFTER_LOADING','DELIVERING') OR (stage='BEFORE_LOADING' AND review_state='LOADING_PENDING')) </otherwise></choose>ORDER BY updated_at DESC,id DESC LIMIT 201</script>")
     List<DispatchAggregate> headers(@Param("warehouse")String warehouse,@Param("number")String number,@Param("stage")String stage);
     String ROOTS="<foreach collection='ids' item='id' open='(' separator=',' close=')'>#{id}</foreach>";
     /** 一次读取选中整车所有真实客户货物。 */

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

@@ -24,9 +24,6 @@ public final class DispatchApi {
     public static final String LOADING_REVIEW = "/{dispatchNo}/loading-review";
     public static final String RETURN_TO_REVIEW = "/{dispatchNo}/return-to-review";
     public static final String LOADING_COMPLETE = "/{dispatchNo}/loading-complete";
-    public static final String DEPART = "/{dispatchNo}/depart";
-    public static final String DELIVERY_ARRANGEMENT = "/{dispatchNo}/delivery-arrangement";
-    public static final String TRANSFER_DELIVERY = "/{dispatchNo}/transfer-delivery";
 
     /** 端点容器不允许实例化。 */
     private DispatchApi() { }

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

@@ -49,9 +49,9 @@ public final class DispatchCommands {
     }
 
     public record ReviewCommand(Long recordVersion, String idempotencyKey, Decision decision,
-                                 String reason) {
-        /** 两级审核都执行相同的必填版本约束。 */
-        public ReviewCommand { recordVersion = requireVersion(recordVersion); }
+                                 String reason, ReviewAttachments attachments) {
+        /** 两级审核都执行相同的必填版本约束，未传附件表示没有本次补充。 */
+        public ReviewCommand { recordVersion = requireVersion(recordVersion); attachments = attachments == null ? ReviewAttachments.empty() : attachments; }
     }
 
     /** 只有零真实扫码时可退回，保留原单号与审核轮次历史。 */
@@ -73,6 +73,13 @@ public final class DispatchCommands {
         public LoadingComplete { recordVersion = requireVersion(recordVersion); }
     }
 
+    /** 派送异常仅登记事实，不改变派送、签收或库存。 */
+    public record MarkException(Long recordVersion, String idempotencyKey, ExceptionType exceptionType,
+                                ReturnDirection returnDirection, String description, List<Long> imageFileIds) {
+        /** 必填版本用于阻止过期页面覆盖当前排车。 */
+        public MarkException { recordVersion = requireVersion(recordVersion); }
+    }
+
     public record Depart(Long recordVersion, String idempotencyKey, String remark) {
         /** 实际发车不得接受缺省版本。 */
         public Depart { recordVersion = requireVersion(recordVersion); }

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

@@ -41,7 +41,27 @@ public final class DispatchContracts {
                                String contactName, String contactPhone) { }
 
     public record Review(ReviewStatus status, String reason, String reviewerId, Instant reviewedAt,
-                          long reviewRound, String basisHash, String invalidatedReason) { }
+                          long reviewRound, String basisHash, String invalidatedReason, ReviewAttachments attachments) {
+        /** 无补充附件时返回明确空集合，旧决定不得从资源快照自动继承。 */
+        public Review { attachments = attachments == null ? ReviewAttachments.empty() : attachments; }
+    }
+
+    /** 本次审核补充证据按分类归属本车，不修改车辆或司机业务资料。 */
+    public record ReviewAttachments(List<Long> vehicleFileIds, List<Long> driverPhotoFileIds, List<Long> licenseFileIds) {
+        /** 每类附件有界、不可变且不允许空身份或重复引用。 */
+        public ReviewAttachments {
+            vehicleFileIds = checked(vehicleFileIds); driverPhotoFileIds = checked(driverPhotoFileIds); licenseFileIds = checked(licenseFileIds);
+        }
+        /** 未传附件表示本次没有补充证据。 */
+        public static ReviewAttachments empty() { return new ReviewAttachments(List.of(), List.of(), List.of()); }
+        /** 只规范引用形状；本车和类别归属由审核服务逐个验证。 */
+        private static List<Long> checked(List<Long> ids) {
+            if (ids == null) return List.of();
+            if (ids.size() > 20 || ids.stream().anyMatch(id -> id == null || id <= 0) || ids.stream().distinct().count() != ids.size())
+                throw new IllegalArgumentException("每类审核附件最多20个，文件引用须有效且不重复");
+            return List.copyOf(ids);
+        }
+    }
 
     public record Reviews(Review dispatchReview, Review loadingReview) { }
 

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

@@ -7,6 +7,9 @@ import static com.baiyue.lastleg.dispatch.port.DispatchDeliveryModels.*;
 
 /** 派送域实现的整车安排和单据事实边界，禁止回写排车持久化实体。 */
 public interface DispatchDeliveryPort {
+    /** 装车完成父事务自动准备全车真实客户单据，不要求人工安排或补造费用。 */
+    ArrangementFact prepareForDeparture(Context context, Actor actor, String commandKey);
+
     /** 一次预览返回同快照下全部客户目的地及费用证据。 */
     ArrangementPreview preview(Context context);
 

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

@@ -9,6 +9,8 @@ public final class DispatchTypes {
     public enum Stage { BEFORE_LOADING, LOADING, AFTER_LOADING, DELIVERING, DELIVERED }
     public enum ReviewState { DRAFT, DISPATCH_PENDING, DISPATCH_REJECTED, LOADING_PENDING, LOADING_REJECTED, APPROVED }
     public enum ReviewStatus { NOT_SUBMITTED, PENDING, APPROVED, REJECTED }
+    public enum ExceptionType { REFUSED, PARTIAL_RECEIPT, VEHICLE_EXCEPTION }
+    public enum ReturnDirection { OVERSEAS_WAREHOUSE, OTHER }
     public enum Decision { APPROVED, REJECTED }
     public enum ResourceMode { MASTER, EXTERNAL }
     public enum ActorMode { PLATFORM, PDA }
@@ -18,6 +20,6 @@ public final class DispatchTypes {
     public enum Effect { APPLIED, EXISTING }
     public enum Action {
         CREATE, EDIT, ADD_CARGO, REMOVE_CARGO, CANCEL, SUBMIT_REVIEW, DISPATCH_REVIEW,
-        LOADING_REVIEW, RETURN_TO_REVIEW, PICK, LOADING_COMPLETE, ARRANGE_DELIVERY, DEPART
+        LOADING_REVIEW, RETURN_TO_REVIEW, PICK, LOADING_COMPLETE, ARRANGE_DELIVERY, DEPART, MARK_EXCEPTION
     }
 }

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

@@ -44,7 +44,11 @@ public final class DispatchViews {
 
     public record DispatchInfo(String route, Instant plannedDepartureAt, Instant departedAt,
                                  Instant estimatedArrivalAt, List<FbaAppointment> fbaAppointments,
-                                 List<BatchReference> appointmentBatches) { }
+                                 List<BatchReference> appointmentBatches, List<ExceptionRecord> exceptions) { }
+
+    /** 排车级异常记录；退货去向只描述安排，不产生退货入库事实。 */
+    public record ExceptionRecord(ExceptionType exceptionType, ReturnDirection returnDirection,
+                                  String description, List<Long> imageFileIds, Instant occurredAt) { }
 
     public record Documents(String dispatchNo, List<DispatchDeliveryModels.OutboundReference> outbounds,
                               List<DispatchDeliveryModels.DeliveryReference> deliveries,
@@ -63,7 +67,7 @@ public final class DispatchViews {
                            List<OrderDetail> orderDetails) { }
 
     public record PdaTask(String taskNo, String dispatchNo, String warehouseId, Status status,
-                           Stage stage, long recordVersion, Reviews reviews, Counts counts,
+                           Stage stage, long recordVersion, Reviews reviews, Resources resources, Counts counts,
                            boolean pickingReconciled, List<PdaItem> items, Map<Action, Gate> actions) { }
 
     public record PdaItem(Long dispatchItemId, String customerId, String customerName, String palletNo,

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

@@ -46,8 +46,8 @@ public class DispatchAggregateRepository {
     public int removeItem(long itemId) {return items.deleteById(itemId);}
     /** 原子更新货量并作废旧审核依据。 */
     public int changeCargo(long id, long version, String hash, int itemCount, int pallets, int packages,
-                           String route, String pending, LocalDateTime at) {
-        return mapper.changeCargo(id, version, hash, itemCount, pallets, packages, route, pending, at);
+                           String route, String dispatchReview, String loadingReview, LocalDateTime at) {
+        return mapper.changeCargo(id, version, hash, itemCount, pallets, packages, route, dispatchReview, loadingReview, at);
     }
     /** 追加不可变业务快照。 */
     public int history(long id, DispatchAggregate row, String action, String operator, String reason, String snapshot, LocalDateTime at) {

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

@@ -146,7 +146,8 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
     @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
     public DispatchPlanningModels.CandidateList candidates(Actor actor,DispatchPlanningModels.CandidateQuery query) {
         requirePlatform(actor);
-        if(query==null || query.warehouseId()==null || !query.warehouseId().matches("[1-9][0-9]*")) throw bad("请选择真实海外起运仓");
+        // 未指定起运仓时按区域浏览；写入草稿仍由来源确定唯一真实起运仓。
+        if(query==null || query.warehouseId()!=null && !query.warehouseId().matches("[1-9][0-9]*")) throw bad("起运仓筛选无效");
         if(query.planIds()!=null && (query.planIds().size()>500 || query.planIds().stream().anyMatch(id->id==null || id<=0))) throw bad("计划筛选不合法");
         if(query.page()<1 || query.size()<1 || query.size()>50 || !Set.of("ALL","LAX","NYC").contains(Objects.toString(query.warehouseTab(),"")))throw bad("候选分页或仓库页签不合法");
         var normalized=new DispatchPlanningModels.CandidateQuery(query.warehouseId(),query.planIds(),trim(query.orderNo()),
@@ -235,10 +236,18 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         return saveCommand(row,actor,identity,request.reason());
     }
 
-    /** 上传不修改主单引用；返回本车文件ID后由公共版本编辑命令保存选择。 */
+    /** 上传只返回本车证据；待审按当前审核权限授权，客服阶段按维护权限授权。 */
     public com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.File uploadEvidence(Actor actor,String number,
         com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind kind,org.springframework.web.multipart.MultipartFile file) {
-        requirePlatform(actor);var row=required(actor,number,false);requireEditing(row,row.getRecordVersion());
+        requirePlatform(actor);var row=required(actor,number,false);
+        if(kind==com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.EXCEPTION) {
+            requireExceptionAllowed(actor,row,row.getRecordVersion());
+            return evidence.upload(row.getId(),kind,actor.operatorId(),file);
+        }
+        requireEditing(row,row.getRecordVersion());
+        Action permission = ReviewState.DISPATCH_PENDING.name().equals(row.getReviewState()) ? Action.DISPATCH_REVIEW
+            : ReviewState.LOADING_PENDING.name().equals(row.getReviewState()) ? Action.LOADING_REVIEW : Action.EDIT;
+        if(!hasPermission(actor,permission))throw new BizException(ResultCode.FORBIDDEN,"无当前阶段附件上传权限");
         return evidence.upload(row.getId(),kind,actor.operatorId(),file);
     }
     /** 列表权限含详情只读；仅冻结MASTER证照走司机归属，其余保持本车附件复合归属。 */
@@ -392,7 +401,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         if(n(row.getPackageCount())<=0 || repository.cargo(row.getId()).isEmpty())throw bad("空排车不能提交审核");
         long round=row.getReviewRound()+1;String basis=basis(row);
         row.setReviewRound(round);row.setReviewBasisHash(basis);row.setReviewState(ReviewState.DISPATCH_PENDING.name());
-        row.setDispatchReviewJson(write(new Review(ReviewStatus.PENDING,null,null,null,round,basis,null)));
+        row.setDispatchReviewJson(write(new Review(ReviewStatus.PENDING,null,null,null,round,basis,null,null)));
         row.setLoadingReviewJson(write(pending(round)));
         return saveCommand(row,actor,identity,request.remark());
     }
@@ -400,7 +409,14 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
     /** 调度与理货审核按同一轮次、同一事实摘要串行执行；理货通过才进入装车。 */
     @Transactional(isolation=Isolation.READ_COMMITTED)
     public CommandResult review(Actor actor,String number,boolean loading,DispatchCommands.ReviewCommand request) {
-        var row=lockPlatform(actor,number);Action action=loading?Action.LOADING_REVIEW:Action.DISPATCH_REVIEW;
+        Action action=loading?Action.LOADING_REVIEW:Action.DISPATCH_REVIEW;
+        // PDA仅可处理本绑定仓理货审核，原键重试也先重新核验权限和范围。
+        DispatchAggregate row;
+        if(actor!=null && actor.mode()==ActorMode.PDA) {
+            if(!loading || actor.boundWarehouseId()==null || !hasPermission(actor,action))
+                throw new BizException(ResultCode.FORBIDDEN,"仅当前绑定仓理货员可执行理货审核");
+            required(actor,number,false);fleet.lockDispatchShell(number);row=required(actor,number,true);
+        } else row=lockPlatform(actor,number);
         var identity=identity(actor,number,action,request.recordVersion(),request.idempotencyKey(),request);
         var original=commands.replay(actor,number,identity);if(original.isPresent())return original.get();
         requireEditing(row,request.recordVersion());
@@ -413,14 +429,21 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
             var dispatch=reviews(row).dispatchReview();
             if(dispatch.status()!=ReviewStatus.APPROVED || dispatch.reviewRound()!=row.getReviewRound() || !Objects.equals(dispatch.basisHash(),row.getReviewBasisHash()))throw conflict("调度审核尚未通过或依据已失效");
         }
+        verifyReviewAttachments(row.getId(),request.attachments());
         if(request.decision()==Decision.APPROVED)verifyReviewResources(row);
-        var reviewed=new Review(request.decision()==Decision.APPROVED?ReviewStatus.APPROVED:ReviewStatus.REJECTED,trim(request.reason()),actor.operatorId(),Instant.now().truncatedTo(ChronoUnit.MILLIS),row.getReviewRound(),row.getReviewBasisHash(),null);
+        var reviewed=new Review(request.decision()==Decision.APPROVED?ReviewStatus.APPROVED:ReviewStatus.REJECTED,trim(request.reason()),actor.operatorId(),Instant.now().truncatedTo(ChronoUnit.MILLIS),row.getReviewRound(),row.getReviewBasisHash(),null,request.attachments());
         if(loading) {
             row.setLoadingReviewJson(write(reviewed));row.setReviewState(request.decision()==Decision.APPROVED?ReviewState.APPROVED.name():ReviewState.LOADING_REJECTED.name());
             if(request.decision()==Decision.APPROVED)row.setStage(Stage.LOADING.name());
         } else {
             row.setDispatchReviewJson(write(reviewed));row.setReviewState(request.decision()==Decision.APPROVED?ReviewState.LOADING_PENDING.name():ReviewState.DISPATCH_REJECTED.name());
-            row.setLoadingReviewJson(write(request.decision()==Decision.APPROVED?new Review(ReviewStatus.PENDING,null,null,null,row.getReviewRound(),row.getReviewBasisHash(),null):pending(row.getReviewRound())));
+            row.setLoadingReviewJson(write(request.decision()==Decision.APPROVED?new Review(ReviewStatus.PENDING,null,null,null,row.getReviewRound(),row.getReviewBasisHash(),null,null):pending(row.getReviewRound())));
+        }
+        if(request.decision()==Decision.REJECTED) {
+            // 任一级驳回均回客服处理，旧调度批准不再作为可继续理货的有效依据。
+            row.setStage(Stage.BEFORE_LOADING.name());row.setReviewBasisHash(null);
+            if(loading)row.setDispatchReviewJson(write(new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,
+                row.getReviewRound(),null,"理货审核驳回，请客服修改后重新提交调度审核",reviews(row).dispatchReview().attachments())));
         }
         return saveCommand(row,actor,identity,request.reason());
     }
@@ -517,7 +540,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
             List.copyOf(pallets),row.getLoadingConfirmationJson()==null?null:read(row.getLoadingConfirmationJson(),ConfirmedLoad.class),gate,List.copyOf(missing));
     }
 
-    /** 最后一次扫码只核平，显式装车完成才保存实载并进入装车后。 */
+    /** 内部实载步骤：扫码核平后保存装载证据，中间装车后状态由外层同事务继续推进发车。 */
     @Transactional(isolation=Isolation.READ_COMMITTED)
     public CommandResult loadingComplete(Actor actor,String number,DispatchCommands.LoadingComplete request) {
         required(actor,number,false);fleet.lockDispatchShell(number);var row=required(actor,number,true);
@@ -609,9 +632,24 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
     /** 作废原因进入两级显式记录，旧审核证据仍保留在不可变历史中。 */
     private void invalidate(DispatchAggregate row,String reason) {
         row.setReviewState(ReviewState.DRAFT.name());row.setReviewBasisHash(null);
-        var invalid=new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,row.getReviewRound(),null,reason);
-        row.setDispatchReviewJson(write(invalid));row.setLoadingReviewJson(write(invalid));
+        var invalid=new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,row.getReviewRound(),null,reason,null);
+        var previous=reviews(row);
+        row.setDispatchReviewJson(write(retainRejection(previous.dispatchReview(),invalid)));
+        row.setLoadingReviewJson(write(retainRejection(previous.loadingReview(),invalid)));
     }
+    /** 客服改资料期间保留本轮驳回原因；下一轮提交统一重置，不复用批准。 */
+    private static Review retainRejection(Review previous,Review invalid) {
+        return previous.status()==ReviewStatus.REJECTED
+            ?new Review(previous.status(),previous.reason(),previous.reviewerId(),previous.reviewedAt(),previous.reviewRound(),null,invalid.invalidatedReason(),previous.attachments())
+            :new Review(invalid.status(),null,null,null,invalid.reviewRound(),null,invalid.invalidatedReason(),previous.attachments());
+    }
+    /** 审核附件逐个验证本车与种类；MASTER档案证照不能冒充本次上传证据。 */
+    private void verifyReviewAttachments(long dispatch,ReviewAttachments attachments) {
+        for(var id:attachments.vehicleFileIds())evidence.metadata(dispatch,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.VEHICLE,id);
+        for(var id:attachments.driverPhotoFileIds())evidence.metadata(dispatch,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER_PHOTO,id);
+        for(var id:attachments.licenseFileIds())evidence.metadata(dispatch,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER,id);
+    }
+
     /** 临时取证、有效期和实际主档资格必须在提交及通过时再次核验。 */
     void verifyReviewResources(DispatchAggregate row) {
         var r=read(row.getResourcesJson(),Resources.class);var v=r.vehicle();var d=r.driver();
@@ -631,6 +669,40 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         for(var id:ids)evidence.metadata(dispatch,kind,id);
     }
 
+    /** 仅派送中登记异常；原键重试先恢复，避免追加重复记录。 */
+    @Transactional(isolation=Isolation.READ_COMMITTED)
+    public CommandResult markException(Actor actor,String number,DispatchCommands.MarkException request) {
+        var row=lockPlatform(actor,number);
+        if(!hasPermission(actor,Action.MARK_EXCEPTION))throw new BizException(ResultCode.FORBIDDEN,"无标记异常权限");
+        var identity=identity(actor,number,Action.MARK_EXCEPTION,request.recordVersion(),request.idempotencyKey(),request);
+        var replay=commands.replay(actor,number,identity);if(replay.isPresent())return replay.get();
+        requireExceptionAllowed(actor,row,request.recordVersion());
+        if(request.exceptionType()==null)throw bad("请选择异常类型");
+        var description=trim(request.description());
+        if(description!=null && description.length()>1000)throw bad("异常说明不能超过1000字");
+        var ids=request.imageFileIds()==null?List.<Long>of():request.imageFileIds();
+        if(ids.size()>20 || ids.stream().anyMatch(id->id==null || id<=0) || ids.stream().distinct().count()!=ids.size())throw bad("异常图片引用无效或超过20张");
+        // 文件须属于本车异常类别，不能借用其他车辆或审核附件。
+        for(var id:ids)evidence.metadata(row.getId(),com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.EXCEPTION,id);
+        var records=new ArrayList<>(exceptionRecords(row));
+        records.add(new DispatchViews.ExceptionRecord(request.exceptionType(),request.returnDirection(),description,List.copyOf(ids),Instant.now()));
+        row.setExceptionsJson(write(records));
+        return saveCommand(row,actor,identity,description);
+    }
+
+    /** 异常登记复用排车维护权限；版本、任务类型与阶段由服务端再次核验。 */
+    private void requireExceptionAllowed(Actor actor,DispatchAggregate row,long version) {
+        if(!hasPermission(actor,Action.MARK_EXCEPTION))throw new BizException(ResultCode.FORBIDDEN,"无标记异常权限");
+        if(row.getRecordVersion()!=version)throw conflict("排车版本已变化，请刷新后再标记异常");
+        if(!actions(actor,row).get(Action.MARK_EXCEPTION).allowed())throw conflict("仅派送中的仓库派送排车可以标记异常");
+    }
+
+    /** 尚未登记时为空集合，已登记记录按保存顺序完整回看。 */
+    private List<DispatchViews.ExceptionRecord> exceptionRecords(DispatchAggregate row) {
+        if(row.getExceptionsJson()==null)return List.of();
+        return Arrays.asList(read(row.getExceptionsJson(),DispatchViews.ExceptionRecord[].class));
+    }
+
     /** 同一只读快照返回分页、总数和基集分布，不能在前端过滤当前页。 */
     @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
     public DispatchViews.Page page(Actor actor, DispatchViews.Query query) {
@@ -667,7 +739,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         var documents=new DispatchViews.Documents(number,repository.outbounds(row.getId()),deliveries,instant(row.getCreatedAt()),instant(row.getUpdatedAt()),row.getRemark());
         return new DispatchViews.Detail(number,row.getTaskType()==null?"DELIVERY":row.getTaskType(),Status.valueOf(row.getStatus()),Stage.valueOf(row.getStage()),row.getRecordVersion(),ReviewState.valueOf(row.getReviewState()),
             reviews(row),counts(row),reconciled(row),actions(actor,row),new DispatchViews.VehicleInfo(resources.vehicle(),resources.driver()),
-            new DispatchViews.DispatchInfo(row.getRoute(),instant(row.getPlannedDepartureAt()),instant(row.getDepartedAt()),instant(row.getEstimatedArrivalAt()),appointments,batchRefs),
+            new DispatchViews.DispatchInfo(row.getRoute(),instant(row.getPlannedDepartureAt()),instant(row.getDepartedAt()),instant(row.getEstimatedArrivalAt()),appointments,batchRefs,exceptionRecords(row)),
             documents,orderDetails(cargo));
     }
 
@@ -726,7 +798,8 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         int pallets=(int)all.stream().map(i -> i.getWarehousePalletId()==null ? "PLAN:"+i.getPlanPalletId() : "PALLET:"+i.getWarehousePalletId()).distinct().count();
         String route=all.stream().map(this::destinationLabel).filter(Objects::nonNull).distinct().sorted().collect(Collectors.joining(","));
         var digest=all.stream().sorted(Comparator.comparing(DispatchItem::getSourceKey)).map(i -> List.of(i.getSourceKey(),i.getSourceVersion(),i.getCustomerId(),i.getPackageCount())).toList();
-        if(repository.changeCargo(row.getId(),row.getRecordVersion(),hashes.source(digest),all.size(),pallets,packages,route,write(pending(row.getReviewRound())),now())!=1) throw conflict("排车版本已变化，未保存本次货物");
+        invalidate(row,"排车货物已修改，请客服重新提交审核");
+        if(repository.changeCargo(row.getId(),row.getRecordVersion(),hashes.source(digest),all.size(),pallets,packages,route,row.getDispatchReviewJson(),row.getLoadingReviewJson(),now())!=1) throw conflict("排车版本已变化，未保存本次货物");
         var stops=all.stream().map(i -> new FleetExecutionModels.DispatchStop(destinationLabel(i),i.getDeliveryAddress(),destination(i).key()))
             .collect(Collectors.toMap(FleetExecutionModels.DispatchStop::destinationKey,s->s,(a,b)->a,TreeMap::new)).values().stream().toList();
         fleet.updateDispatchCargo(row.getDispatchNo(),packages,stops);
@@ -775,13 +848,16 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         // 到仓取货和本土卡车沿运输任务执行，不能进入仓内拣货、扣库存和转派送链。
         if (row.getTaskType()!=null && !"DELIVERY".equals(row.getTaskType())) {
             var blocked=new EnumMap<Action,Gate>(Action.class);
-            for(var action:Action.values())blocked.put(action,new Gate(false,"TRANSPORT_TASK","请在排车运输任务中操作"));
+            for(var action:Action.values())if(action!=Action.ARRANGE_DELIVERY && action!=Action.DEPART)
+                blocked.put(action,new Gate(false,"TRANSPORT_TASK","请在排车运输任务中操作"));
             return Collections.unmodifiableMap(blocked);
         }
         var gates=new EnumMap<Action,Gate>(Action.class); boolean active=Status.ACTIVE.name().equals(row.getStatus());
         Stage stage=Stage.valueOf(row.getStage()); ReviewState review=ReviewState.valueOf(row.getReviewState());
         for(var action:Action.values()) {
+            if(action==Action.ARRANGE_DELIVERY || action==Action.DEPART)continue;
             boolean state=switch(action) {
+                case MARK_EXCEPTION -> active && stage==Stage.DELIVERING;
                 case CREATE -> actor.mode()==ActorMode.PLATFORM;
                 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());
@@ -799,11 +875,20 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         return Collections.unmodifiableMap(gates);
     }
 
+    /** 装车发运及原结果恢复都按当前装车权限与PDA绑定身份校验。 */
+    void requireLoadingPermission(Actor actor) {
+        if(actor==null || actor.operatorId()==null || !hasPermission(actor,Action.LOADING_COMPLETE))
+            throw new BizException(ResultCode.FORBIDDEN,"当前无装车完成权限");
+    }
+
     /** 主体类型和正式动作权限逐项判断，不把list权限等同写权限。 */
     private static boolean hasPermission(Actor actor,Action action) {
+        if(action==Action.ARRANGE_DELIVERY || action==Action.DEPART)return false;
         var auth=SecurityContextHolder.getContext().getAuthentication(); if(auth==null || actor==null) return false;
-        if(actor.mode()==ActorMode.PDA) return Set.of(Action.PICK,Action.LOADING_COMPLETE,Action.DEPART).contains(action)
-            && auth.getAuthorities().stream().anyMatch(a->"lastleg:pda:operate".equals(a.getAuthority()));
+        if(actor.mode()==ActorMode.PDA) return Set.of(Action.LOADING_REVIEW,Action.PICK,Action.LOADING_COMPLETE,Action.DEPART).contains(action)
+            && actor.boundWarehouseId()!=null
+            && auth.getAuthorities().stream().anyMatch(a->"lastleg:pda:operate".equals(a.getAuthority()))
+            && auth.getAuthorities().stream().anyMatch(a->"ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR".equals(a.getAuthority()));
         if(action==Action.PICK) return false;
         String permission=switch(action) {
             case CREATE -> PREFIX+"create"; case CANCEL -> PREFIX+"cancel";
@@ -814,6 +899,9 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         return auth.getAuthorities().stream().anyMatch(a->permission.equals(a.getAuthority()));
     }
 
+    /** PDA审核读取整车冻结资源，与后台共用相同快照，查询不更改主档。 */
+    Resources resources(DispatchAggregate row) { return read(row.getResourcesJson(),Resources.class); }
+
     /** 统计按真整车去重并补齐全部零项。 */
     private static DispatchViews.Statistics statistics(List<DispatchAggregateMapper.Summary> groups) {
         var stages=new EnumMap<Stage,Long>(Stage.class); for(var stage:Stage.values()) stages.put(stage,0L);
@@ -821,9 +909,13 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
         for(var group:groups) {
             if(Status.CANCELLED.name().equals(group.status())) { cancelled+=group.quantity(); continue; }
             active+=group.quantity(); var stage=Stage.valueOf(group.stage()); stages.merge(stage,group.quantity(),Long::sum);
-            if(stage==Stage.BEFORE_LOADING) { before+=group.quantity(); var review=ReviewState.valueOf(group.reviewState());
-                dispatch[review==ReviewState.DRAFT?0:review==ReviewState.DISPATCH_PENDING?1:review==ReviewState.DISPATCH_REJECTED?3:2]+=group.quantity();
-                loading[review==ReviewState.LOADING_PENDING?1:review==ReviewState.LOADING_REJECTED?3:review==ReviewState.APPROVED?2:0]+=group.quantity(); }
+            if(stage==Stage.BEFORE_LOADING) {
+                // 三分区表示当前待办，驳回只能计入客服处理，不能留在审核队列。
+                var review=ReviewState.valueOf(group.reviewState());
+                if(canSubmitReview(review.name()))before+=group.quantity();
+                else if(review==ReviewState.DISPATCH_PENDING)dispatch[1]+=group.quantity();
+                else if(review==ReviewState.LOADING_PENDING)loading[1]+=group.quantity();
+            }
         }
         return new DispatchViews.Statistics(active+cancelled,active,cancelled,Collections.unmodifiableMap(stages),new DispatchViews.BeforeLoadingCounts(before,
             new DispatchViews.ReviewCounts(dispatch[0],dispatch[1],dispatch[2],dispatch[3]),new DispatchViews.ReviewCounts(loading[0],loading[1],loading[2],loading[3])));
@@ -883,7 +975,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
     /** 当前审核记录，不以版本相等代替轮次有效性。 */
     Reviews reviews(DispatchAggregate row) { return new Reviews(read(row.getDispatchReviewJson(),Review.class),read(row.getLoadingReviewJson(),Review.class)); }
     /** 未提交的审核不伪造待审核。 */
-    private static Review pending(long round) { return new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,round,null,null); }
+    private static Review pending(long round) { return new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,round,null,null,null); }
     /** 整车真实统计。 */
     private static Counts counts(DispatchAggregate row) { return new Counts(n(row.getItemCount()),n(row.getPalletCount()),n(row.getPackageCount()),n(row.getPickedPackageCount()),n(row.getShippedPackageCount())); }
     /** 空单永远不能核平为装车完成。 */

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

@@ -73,7 +73,7 @@ public final class DispatchCommandCodec {
             case DEPART -> DispatchResults.Departed.class;
             case ARRANGE_DELIVERY -> DispatchDeliveryModels.ArrangementResult.class;
             case CREATE, EDIT, ADD_CARGO, REMOVE_CARGO, CANCEL, SUBMIT_REVIEW,
-                 DISPATCH_REVIEW, LOADING_REVIEW, RETURN_TO_REVIEW -> DispatchResults.Saved.class;
+                 DISPATCH_REVIEW, LOADING_REVIEW, RETURN_TO_REVIEW, MARK_EXCEPTION -> DispatchResults.Saved.class;
         };
     }
 

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

@@ -0,0 +1,58 @@
+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.port.*;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.*;
+import java.util.List;
+import static com.baiyue.lastleg.dispatch.port.DispatchContracts.*;
+import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
+
+/** 两端装车完成即发车：所有中间状态只存在于同一事务，原请求只恢复最终结果。 */
+@Service
+public class DispatchLoadingDepartureService {
+    private final DispatchAggregateService workflow;
+    private final DispatchDeliveryPort delivery;
+    private final DispatchDepartureService departure;
+    private final DispatchCommandLedger commands;
+    private final DispatchCommandHasher hashes;
+
+    /** 复用装车、派送和发车的真实规则，不另建库存或运输状态实现。 */
+    public DispatchLoadingDepartureService(DispatchAggregateService workflow,DispatchDeliveryPort delivery,
+        DispatchDepartureService departure,DispatchCommandLedger commands,DispatchCommandHasher hashes) {
+        this.workflow=workflow;this.delivery=delivery;this.departure=departure;this.commands=commands;this.hashes=hashes;
+    }
+
+    /** 原键恢复先于阶段校验；任一步失败均回滚装载、子单、费用、发车与全部账本。 */
+    @Transactional(isolation=Isolation.READ_COMMITTED)
+    public CommandResult complete(Actor actor,String number,DispatchCommands.LoadingComplete request) {
+        workflow.requireLoadingPermission(actor);
+        var context=workflow.lockForArrangement(actor,number);
+        var identity=new CommandIdentity(Action.LOADING_COMPLETE,request.idempotencyKey(),request.recordVersion(),
+            hashes.command(actor,Action.LOADING_COMPLETE,number,request.recordVersion(),request));
+        var replay=commands.replay(actor,number,identity);if(replay.isPresent())return replay.get();
+        // 先取得本车单据锁再申请真实来源锁，后续所有步骤保持同一个整车父锁。
+        delivery.departureFacts(context,true);
+        var loaded=workflow.loadingComplete(actor,number,new DispatchCommands.LoadingComplete(request.recordVersion(),
+            stepKey(number,request.idempotencyKey(),"LOAD"),request.manifestHash(),request.measurements(),request.remark()));
+        context=workflow.preview(actor,number);
+        String arrangementKey=stepKey(number,request.idempotencyKey(),"ARRANGE");
+        var fact=delivery.prepareForDeparture(context,actor,arrangementKey);
+        var arrangementIdentity=new CommandIdentity(Action.ARRANGE_DELIVERY,arrangementKey,context.recordVersion(),
+            hashes.source(List.of(number,actor.operatorId(),context.recordVersion(),fact.arrangementBusinessHash())));
+        var arranged=workflow.recordArrangement(context,actor,arrangementIdentity,fact,false);
+        var departed=departure.depart(actor,number,new DispatchCommands.Depart(arranged.recordVersion(),
+            stepKey(number,request.idempotencyKey(),"DEPART"),request.remark()));
+        if(departed.stage()!=Stage.DELIVERING || !(loaded.result() instanceof DispatchResults.Loaded))
+            throw new BizException(ResultCode.CONFLICT,"装车发运结果未核平");
+        var result=new CommandResult(number,Action.LOADING_COMPLETE,request.idempotencyKey(),departed.recordVersion(),
+            departed.status(),departed.stage(),departed.occurredAt(),Effect.APPLIED,departed.counts(),loaded.result(),false,false);
+        commands.append(context.dispatchId(),actor,identity,result);return result;
+    }
+
+    /** 固定长度内部键绑定原请求和步骤，不向客户端暴露中间命令作为恢复入口。 */
+    private String stepKey(String number,String original,String step) {
+        return "AUTO_"+step+"_"+hashes.source(List.of(number,original,step));
+    }
+}

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

@@ -89,7 +89,7 @@ public class DispatchPdaQueryService {
             else actions.put(Action.PICK,new Gate(false,"PICKING_RECONCILED","本车全部来源已核平，请显式确认装车"));
             var counts=new Counts(n(root.getItemCount()),n(root.getPalletCount()),n(root.getPackageCount()),n(root.getPickedPackageCount()),n(root.getShippedPackageCount()));
             // 整车作业直接以排车业务号识别；真实客户子taskId只在服务端审计保存。
-            result.add(new DispatchViews.PdaTask(root.getDispatchNo(),root.getDispatchNo(),root.getOverseasWarehouseId(),Status.valueOf(root.getStatus()),Stage.valueOf(root.getStage()),root.getRecordVersion(),workflow.reviews(root),counts,complete,List.copyOf(detail),Collections.unmodifiableMap(actions)));
+            result.add(new DispatchViews.PdaTask(root.getDispatchNo(),root.getDispatchNo(),root.getOverseasWarehouseId(),Status.valueOf(root.getStatus()),Stage.valueOf(root.getStage()),root.getRecordVersion(),workflow.reviews(root),workflow.resources(root),counts,complete,List.copyOf(detail),Collections.unmodifiableMap(actions)));
         }
         return List.copyOf(result);
     }

lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/transport/TransportTaskProjection.java

@@ -36,7 +36,7 @@ public class TransportTaskProjection {
         row.setOverseasWarehouseCode(trip.getWarehouseCode());row.setOverseasWarehouseName(trip.getWarehouseName());
         row.setStatus("ACTIVE");row.setStage("BEFORE_LOADING");row.setRecordVersion(trip.getRecordVersion());row.setCargoRevision(0L);
         row.setCargoHash(trip.getRequestHash());row.setReviewState("DRAFT");row.setReviewRound(0L);
-        var review=new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,0,null,null);
+        var review=new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,0,null,null,null);
         row.setDispatchReviewJson(write(review));row.setLoadingReviewJson(write(review));
         resources(row,trip);row.setPlannedDepartureAt(trip.getPlannedDepartureAt());row.setEstimatedArrivalAt(trip.getExpectedDriverEndAt());
         row.setRoute(("PICKUP".equals(trip.getTripPurpose())?"到仓取货":"本土卡车")+" · "+items+"单 · "+trip.getWarehouseCode());row.setItemCount(items);row.setPalletCount(pallets);row.setPackageCount(packages);

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

@@ -7,5 +7,6 @@ public record ContainerArrivalTimeView(
     String sourceContainerBookingId,
     LocalDateTime estimatedWarehouseArrivalAt,
     LocalDateTime actualWarehouseArrivalAt,
-    int version
+    int version,
+    long planCount
 ) { }

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/outsourcedbusiness/service/OutsourcedBusinessService.java

@@ -37,7 +37,7 @@ public class OutsourcedBusinessService {
     public HistoryPage history(OwnedBusinessModels.Actor actor,String number,Integer page,Integer size) {
         var result=queries.history(actor,number,page,size,SCOPE);
         return new HistoryPage(result.records().stream().map(h->new History(h.eventSource(),h.recordVersion(),h.dispatchRecordVersion(),h.action(),h.operatorName(),
-            h.occurredAt(),h.reason(),h.operations()==null?null:operations(h.operations()),h.photos().stream().map(this::photo).toList())).toList(),result.page(),result.size(),result.total());
+            h.occurredAt(),h.reason(),h.operations()==null?null:operations(h.operations()),h.photos().stream().filter(p->"LOADING".equals(p.category())).map(this::photo).toList())).toList(),result.page(),result.size(),result.total());
     }
     /** 外配只生成金额和到达的规范内部请求，不接收归属或隐藏油耗写入。 */
     public Detail save(OwnedBusinessModels.Actor actor,String number,SaveOperations request) {
@@ -71,11 +71,11 @@ public class OutsourcedBusinessService {
     }
     /** 回执公开形状不带内部里程、油耗或油耗照片摘要。 */
     private Detail detail(OwnedBusinessModels.Detail detail) {
-        return new Detail(row(detail.row(),projection.carrierName(detail)),detail.dispatch(),detail.cargo(),detail.photos().stream().map(this::photo).toList());
+        return new Detail(row(detail.row(),projection.carrierName(detail)),detail.dispatch(),detail.cargo(),detail.photos().stream().filter(p->"LOADING".equals(p.category())).map(this::photo).toList());
     }
     /** 临时车辆合法保留空vehicleId；承运商缺失保留null供页面显示破折号。 */
     private Row row(OwnedBusinessModels.Row r,String carrierName) {
-        if(!"DISPATCHED".equals(r.vehicle().ownership()) || r.photoSummary().fuelCount()!=0)throw conflict("外配运营快照与冻结归属不一致");
+        if(!java.util.Set.of("OWNED","DISPATCHED").contains(r.vehicle().ownership()))throw conflict("外配运营快照的车辆归属或照片不合法");
         return new Row(r.dispatchNo(),r.stage(),r.plannedDepartureAt(),r.loadingCompletedAt(),r.departedAt(),r.deliveryCompletedAt(),r.origin(),
             new Vehicle(r.vehicle().vehicleId(),r.vehicle().plate(),r.vehicle().ownership(),carrierName==null || carrierName.isBlank()?null:carrierName),r.driver(),r.destinations(),
             r.actualPalletCount(),operations(r.operations()),r.unitPrice(),r.recordVersion(),r.dispatchRecordVersion(),new PhotoSummary(r.photoSummary().loadingCount()),r.actions(),r.sourceIssues());
@@ -85,7 +85,7 @@ public class OutsourcedBusinessService {
         if(ops.actualDistanceMiles()!=null || ops.fuelConsumptionLitresPer100Km()!=null)throw conflict("外配业务不能包含里程或油耗登记");
         return new Operations(ops.money(),ops.arrivals());
     }
-    /** 外配照片枚举只有五框，异常油耗历史不能借复用向外输出。 */
+    /** 外配照片枚举只有五框，排车油耗图片保留在共用记录中但不在外配入口输出。 */
     private Photo photo(OwnedBusinessModels.Photo p) {
         SCOPE.requireSlot(p.slot());return new Photo(PhotoSlot.valueOf(p.slot().name()),p.category(),p.fileId(),p.fileName(),p.contentType(),p.sizeBytes(),p.uploadedAt(),p.savedAt());
     }

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/ownedbusiness/controller/DispatchVehicleDocumentController.java

@@ -0,0 +1,76 @@
+package com.baiyue.lastleg.fleet.ownedbusiness.controller;
+
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.common.security.AuthenticatedUser;
+import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessModels.*;
+import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessScope;
+import com.baiyue.lastleg.fleet.ownedbusiness.service.*;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.*;
+import org.springframework.http.*;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+import java.util.List;
+
+/** 排车资料入口复用车队原照片记录；签收及BOL仍由派送单管理。 */
+@RestController
+@Validated
+@RequestMapping("/api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents")
+public class DispatchVehicleDocumentController {
+    private static final OwnedBusinessScope SCOPE=OwnedBusinessScope.DISPATCH;
+    private final OwnedBusinessQueryService queries;
+    private final OwnedBusinessPhotoService photos;
+    private final OwnedBusinessSupport access;
+    /** 沿已有服务复用来源校验、文件归属、版本和命令账本。 */
+    public DispatchVehicleDocumentController(OwnedBusinessQueryService queries,OwnedBusinessPhotoService photos,OwnedBusinessSupport access) {
+        this.queries=queries;this.photos=photos;this.access=access;
+    }
+    public record Documents(String dispatchNo,String recordVersion,boolean editable,List<Photo> photos) {}
+    /** 只输出油耗资料，避免把车队签收照片当作派送签收文件。 */
+    private Documents documents(Detail value) {
+        return new Documents(value.row().dispatchNo(),value.row().recordVersion(),value.row().actions().upload().allowed(),
+            value.photos().stream().filter(p->"FUEL".equals(p.category())).toList());
+    }
+    /** 排车列表权限包含车辆资料只读，不扩大派送单客户访问权限。 */
+    @GetMapping
+    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
+    public ApiResponse<Documents> get(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo) {
+        return ApiResponse.success(documents(queries.detail(access.actor(user,SCOPE),dispatchNo,SCOPE)));
+    }
+    /** 上传和引用保存分开，沿原请求键防止重传。 */
+    @PostMapping(value="/{slot}/uploads",consumes=MediaType.MULTIPART_FORM_DATA_VALUE)
+    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
+    public ApiResponse<Photo> upload(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable PhotoSlot slot,
+        @RequestParam @Size(min=8,max=128) String idempotencyKey,@RequestPart("file") MultipartFile file) {
+        return ApiResponse.success(photos.upload(access.actor(user,SCOPE),dispatchNo,slot,idempotencyKey,file,SCOPE));
+    }
+    /** 只更新既有附加资料版本，不修改排车阶段或签收状态。 */
+    @PutMapping("/{slot}")
+    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
+    public ApiResponse<Documents> bind(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable PhotoSlot slot,@Valid @RequestBody BindPhoto request) {
+        return ApiResponse.success(documents(photos.bind(access.actor(user,SCOPE),dispatchNo,slot,request,SCOPE)));
+    }
+    /** 预览只读取本车当前已经绑定的照片。 */
+    @GetMapping("/{slot}/files/{fileId}/content")
+    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
+    public ResponseEntity<byte[]> content(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable PhotoSlot slot,@PathVariable @Positive long fileId) {
+        var value=photos.content(access.actor(user,SCOPE),dispatchNo,slot,fileId,null,SCOPE);
+        return ResponseEntity.ok().cacheControl(CacheControl.noStore()).contentType(MediaType.parseMediaType(value.photo().contentType()))
+            .header("X-Content-Type-Options","nosniff").body(value.content());
+    }
+    /** 恢复仅返回油耗上传结果，不通过排车入口暴露其他运营命令。 */
+    @GetMapping("/uploads/{idempotencyKey}")
+    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
+    public ApiResponse<Photo> recover(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable String idempotencyKey) {
+        var actor=access.actor(user,SCOPE);
+        access.require(actor,SCOPE.uploadPermission());
+        var command=photos.command(actor,dispatchNo,idempotencyKey,SCOPE);
+        if(!"UPLOAD_PHOTO".equals(command.action()) || !"SUCCEEDED".equals(command.state()) || command.result()==null)
+            throw OwnedBusinessSupport.conflict("原上传结果尚未确认，请保留原请求稍后核对");
+        var value=access.read(access.write(command.result()),Photo.class);SCOPE.requireSlot(value.slot());
+        return ApiResponse.success(value);
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/ownedbusiness/mapper/OwnedBusinessQueryMapper.java

@@ -7,8 +7,26 @@ import java.util.List;
 /** 在原排车事实之上做自有运营分页，不复制或推进履约模型。 */
 @Mapper
 public interface OwnedBusinessQueryMapper {
+    /** 拼车须实收且来源仍在本车；标识按完整字节精确比较，512字节覆盖128字符utf8mb4，避免列排序规则冲突或截断。 */
+    String POOLED_CARGO="""
+        EXISTS (SELECT 1 FROM ll_fleet_external_booking b
+          JOIN ll_warehouse_transfer_order incoming ON CAST(incoming.customer_id AS BINARY(512))=CAST(b.customer_id AS BINARY(512))
+            AND CAST(incoming.transfer_no AS BINARY(512))=CAST(b.incoming_no AS BINARY(512))
+          WHERE b.trip_id=d.trip_id AND CAST(b.dispatch_no AS BINARY(512))=CAST(d.dispatch_no AS BINARY(512)) AND b.offer_id IS NOT NULL
+            AND b.status='BOUND' AND b.receipt_json IS NOT NULL
+            AND EXISTS (SELECT 1 FROM ll_dispatch_item cargo
+              JOIN ll_inbound_plan_pallet_allocation allocation ON allocation.pallet_id=cargo.plan_pallet_id
+                AND allocation.plan_id=cargo.plan_id AND CAST(allocation.customer_id AS BINARY(512))=CAST(cargo.customer_id AS BINARY(512))
+              JOIN ll_inbound_plan_line line ON line.id=allocation.line_id AND line.plan_id=cargo.plan_id
+              WHERE cargo.dispatch_order_id=d.id AND CAST(cargo.customer_id AS BINARY(512))=CAST(b.customer_id AS BINARY(512))
+                AND CAST(line.customer_id AS BINARY(512))=CAST(b.customer_id AS BINARY(512))
+                AND CAST(line.inbound_code AS BINARY(512))=CAST(incoming.inbound_code AS BINARY(512))
+                AND cargo.warehouse_pallet_id IS NOT NULL AND cargo.package_count>0))
+        """;
     String SOURCE="""
-        SELECT d.id,d.dispatch_no,d.status,d.stage,d.record_version,d.overseas_warehouse_id,
+        SELECT
+        """+POOLED_CARGO+" AS pooled_cargo,"+"""
+        d.id,d.dispatch_no,d.status,d.stage,d.record_version,d.overseas_warehouse_id,
         d.overseas_warehouse_code,d.overseas_warehouse_name,d.planned_departure_at,d.loading_completed_at,
         d.departed_at,d.delivery_completed_at,d.loading_completion_hash,d.loading_confirmation_json,d.resources_json,
         o.vehicle_id AS owned_vehicle_id,o.resource_mode AS owned_resource_mode,
@@ -20,10 +38,12 @@ public interface OwnedBusinessQueryMapper {
     String FILTER="""
         d.status='ACTIVE' AND d.stage IN ('AFTER_LOADING','DELIVERING','DELIVERED')
         AND d.loading_completed_at IS NOT NULL AND d.loading_confirmation_json IS NOT NULL
-        AND o.vehicle_ownership=#{q.scope.ownership}
+        AND o.vehicle_ownership IN ('OWNED','DISPATCHED')
         AND CAST(o.loading_completion_hash AS BINARY(128))=CAST(d.loading_completion_hash AS BINARY(128))
         AND o.loading_completed_at=d.loading_completed_at
-        AND (o.resource_mode='MASTER' OR (#{q.scope.ownership}='DISPATCHED' AND o.resource_mode='EXTERNAL'))
+        AND (o.resource_mode='MASTER' OR (o.vehicle_ownership='DISPATCHED' AND o.resource_mode='EXTERNAL'))
+        AND <if test='!q.scope.pooledCargo'>NOT</if>
+        """+POOLED_CARGO+"""
         <if test='q.from != null'> AND d.planned_departure_at &gt;= #{q.from}</if>
         <if test='q.to != null'> AND d.planned_departure_at &lt; #{q.to}</if>
         <if test='q.stage != null'> AND d.stage=#{q.stage}</if>

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/ownedbusiness/model/OwnedBusinessRows.java

@@ -14,6 +14,7 @@ public final class OwnedBusinessRows {
         private LocalDateTime ownershipCapturedAt,loadingCompletedAt;
     }
     @Data public static class Source {
+        private Boolean pooledCargo;
         private Long id,recordVersion;
         private String dispatchNo,status,stage,overseasWarehouseId,overseasWarehouseCode,overseasWarehouseName;
         private String loadingCompletionHash,loadingConfirmationJson,resourcesJson;

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/ownedbusiness/model/OwnedBusinessScope.java

@@ -6,21 +6,23 @@ import com.baiyue.common.core.api.ResultCode;
 
 /** 仅服务端固定入口选择的作用域；不得成为浏览器请求字段或权限别名。 */
 public enum OwnedBusinessScope {
-    OWNED("OWNED","platform:fleet:owned-business:"),
-    OUTSOURCED("DISPATCHED","platform:fleet:outsourced-business:");
-    private final String ownership,prefix;
-    /** 车辆归属与入口权限一一固定，不能由请求指定。 */
-    OwnedBusinessScope(String ownership,String prefix){this.ownership=ownership;this.prefix=prefix;}
-    /** SQL仅绑定此可信枚举的归属值，不拼接客户端片段。 */
-    public String getOwnership(){return ownership;}
+    OWNED(false,"platform:fleet:owned-business:"),
+    OUTSOURCED(true,"platform:fleet:outsourced-business:"),
+    DISPATCH(false,"platform:overseas-warehouse:dispatch:");
+    private final boolean pooledCargo;
+    private final String prefix;
+    /** 业务入口按是否实际接入拼车货物分类，与车辆归属独立。 */
+    OwnedBusinessScope(boolean pooledCargo,String prefix){this.pooledCargo=pooledCargo;this.prefix=prefix;}
+    /** SQL绑定服务端固定分类，不接受浏览器指定作用域。 */
+    public boolean isPooledCargo(){return pooledCargo;}
     /** 查看权限包含本作用域详情、历史和照片读取。 */
     public String listPermission(){return prefix+"list";}
     /** 运营写权限独立，外配权限不映射成自有权限。 */
     public String editPermission(){return prefix+"edit";}
     /** 照片写权限独立，不扩大到原排车。 */
-    public String uploadPermission(){return prefix+"upload";}
+    public String uploadPermission(){return prefix+(this==DISPATCH?"edit":"upload");}
     /** 外配只支持装车五框，服务调用同样不能绕过。 */
-    public void requireSlot(PhotoSlot slot){if(slot==null || this==OUTSOURCED && !"LOADING".equals(slot.category()))throw new BizException(ResultCode.BAD_REQUEST,"当前业务不支持该照片框");}
+    public void requireSlot(PhotoSlot slot){if(slot==null || this==OUTSOURCED && !"LOADING".equals(slot.category()) || this==DISPATCH && !"FUEL".equals(slot.category()))throw new BizException(ResultCode.BAD_REQUEST,"当前业务不支持该照片框");}
     /** 不存在只显示当前业务归属，不泄露内部身份。 */
-    public BizException missing(){return new BizException(ResultCode.NOT_FOUND,"排车单不存在或不属于当前"+(this==OWNED?"自有":"外配")+"业务");}
+    public BizException missing(){return new BizException(ResultCode.NOT_FOUND,this==DISPATCH?"排车单不存在":"排车单不存在或不属于当前"+(this==OWNED?"自有业务":"外配任务"));}
 }

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/ownedbusiness/service/OwnedBusinessProjection.java

@@ -53,8 +53,7 @@ public class OwnedBusinessProjection {
         var resources=codec.read(source.getResourcesJson(),Resources.class);
         if(resources.vehicle()==null)throw OwnedBusinessSupport.conflict("原车辆快照缺失");
         var ops=operations(record);var photos=photos(record);int pallets=palletCount(source);
-        if(scope==OwnedBusinessScope.OUTSOURCED && (ops.actualDistanceMiles()!=null || ops.fuelConsumptionLitresPer100Km()!=null
-            || photos.stream().anyMatch(p->!"LOADING".equals(p.category()))))throw OwnedBusinessSupport.conflict("外配运营记录含不支持的里程、油耗或照片");
+        if(scope==OwnedBusinessScope.OUTSOURCED && (ops.actualDistanceMiles()!=null || ops.fuelConsumptionLitresPer100Km()!=null))throw OwnedBusinessSupport.conflict("外配运营记录含不支持的里程、油耗或照片");
         var arrivals=new HashMap<String,String>();for(var a:ops.arrivals())arrivals.put(a.destinationKey(),a.actualArrivedAt());
         var destinations=new LinkedHashMap<String,Destination>();
         for(var item:cargo) {
@@ -68,7 +67,7 @@ public class OwnedBusinessProjection {
         return new Row(source.getDispatchNo(),Stage.valueOf(source.getStage()),codec.iso(source.getPlannedDepartureAt()),
             codec.iso(source.getLoadingCompletedAt()),codec.iso(source.getDepartedAt()),codec.iso(source.getDeliveryCompletedAt()),
             new Origin(source.getOverseasWarehouseId(),source.getOverseasWarehouseCode(),source.getOverseasWarehouseName()),
-            new Vehicle(resources.vehicle().vehicleId()==null?null:String.valueOf(resources.vehicle().vehicleId()),resources.vehicle().plate(),scope.getOwnership()),
+            new Vehicle(resources.vehicle().vehicleId()==null?null:String.valueOf(resources.vehicle().vehicleId()),resources.vehicle().plate(),source.getOwnedVehicleOwnership()),
             new Driver(driver==null?null:driver.name(),driver==null?null:driver.phone()),List.copyOf(destinations.values()),pallets,ops,price,
             record==null?"0":String.valueOf(record.getRecordVersion()),String.valueOf(source.getRecordVersion()),
             new PhotoSummary((int)photos.stream().filter(p->"LOADING".equals(p.category())).count(),(int)photos.stream().filter(p->"FUEL".equals(p.category())).count()),

lastleg-service/src/main/java/com/baiyue/lastleg/fleet/ownedbusiness/service/OwnedBusinessQueryService.java

@@ -17,7 +17,7 @@ import java.util.stream.Collectors;
 import static com.baiyue.lastleg.fleet.ownedbusiness.service.OwnedBusinessSupport.*;
 import static com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessModels.*;
 
-/** 自有车辆装车后视图；无归属快照的旧单不在GET时回填。 */
+/** 装车后按实际拼车货物分组；车辆归属仅保留原装车证据。 */
 @Service
 public class OwnedBusinessQueryService {
     private final OwnedBusinessRepository repository;
@@ -61,7 +61,7 @@ public class OwnedBusinessQueryService {
     /** 对原排车详情做组合，不创建第二份主单或履约状态。 */
     @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
     public Detail detail(Actor actor,String number){codec.require(actor,LIST);return detailForWrite(actor,requireOwned(number));}
-    /** 外配入口只能读取其冻结归属，不能借自有权限取得原详情。 */
+    /** 外配入口只读实际拼车任务，不能借自有权限取得原详情。 */
     @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
     public Detail detail(Actor actor,String number,OwnedBusinessScope scope){codec.require(actor,scope.listPermission());return detailForWrite(actor,requireScoped(number,scope),scope);}
     /** 写入已经有独立权限；回执仍由相同真实来源组成。 */
@@ -82,7 +82,7 @@ public class OwnedBusinessQueryService {
         if(number==null || number.isBlank() || number.length()>128)throw bad("请指定排车单号");
         var source=repository.source(number);if(source==null)throw missing();eligible(source,OwnedBusinessScope.OWNED);return source;
     }
-    /** 共享附加表仍按原装车归属隔离，不接受浏览器业务域参数。 */
+    /** 共享附加表按实际拼车分类隔离，不接受浏览器业务域参数。 */
     public Source requireScoped(String number,OwnedBusinessScope scope) {
         if(scope==OwnedBusinessScope.OWNED)return requireOwned(number);
         if(number==null || number.isBlank() || number.length()>128)throw bad("请指定排车单号");
@@ -91,13 +91,16 @@ public class OwnedBusinessQueryService {
     /** 阶段、真实装车hash及车辆快照须与捕获证据一致。 */
     private void eligible(Source source,OwnedBusinessScope scope) {
         if(source.getOwnedVehicleOwnership()==null)throw conflict("本单缺少装车时车辆归属证据，不能归入"+(scope==OwnedBusinessScope.OWNED?"自有":"外配")+"业务");
-        if(!scope.getOwnership().equals(source.getOwnedVehicleOwnership()))throw scope.missing();
+        if(!Set.of("OWNED","DISPATCHED").contains(source.getOwnedVehicleOwnership()))throw conflict("装车车辆归属不合法");
+        if(source.getPooledCargo()==null)throw conflict("本单缺少实际拼车分类依据");
+        if(scope!=OwnedBusinessScope.DISPATCH && scope.isPooledCargo()!=source.getPooledCargo())throw scope.missing();
         if(!"ACTIVE".equals(source.getStatus()) || source.getStage()==null || !Set.of("AFTER_LOADING","DELIVERING","DELIVERED").contains(source.getStage())
             || source.getLoadingCompletedAt()==null || source.getLoadingConfirmationJson()==null)throw conflict("本单尚无合法装车完成事实");
+        if(scope==OwnedBusinessScope.DISPATCH && !Set.of("DELIVERING","DELIVERED").contains(source.getStage()))throw conflict("仅派送中和配送完成可管理车辆资料");
         var resource=codec.read(source.getResourcesJson(),DispatchContracts.Resources.class).vehicle();
         boolean master=resource!=null && resource.mode()!=null && "MASTER".equals(resource.mode().name()) && "MASTER".equals(source.getOwnedResourceMode())
             && resource.vehicleId()!=null && Objects.equals(source.getOwnedVehicleId(),resource.vehicleId());
-        boolean external=scope==OwnedBusinessScope.OUTSOURCED && resource!=null && resource.mode()!=null && "EXTERNAL".equals(resource.mode().name())
+        boolean external="DISPATCHED".equals(source.getOwnedVehicleOwnership()) && resource!=null && resource.mode()!=null && "EXTERNAL".equals(resource.mode().name())
             && "EXTERNAL".equals(source.getOwnedResourceMode()) && resource.vehicleId()==null && source.getOwnedVehicleId()==null;
         if((!master && !external) || !Objects.equals(source.getOwnedLoadingCompletionHash(),source.getLoadingCompletionHash())
             || !Objects.equals(source.getOwnedLoadingCompletedAt(),source.getLoadingCompletedAt()))throw conflict("车辆归属与原装车事实不一致");

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

@@ -303,7 +303,8 @@ public class FleetBookingService {
     private static void requireTrip(FleetTripEntity trip,long version){if("PICKUP".equals(trip.getTripPurpose()))throw conflict("取货车次不能承接出库拼车预订");if(!"PLANNED".equals(trip.getStatus()))throw conflict("仅计划中的车次允许管理外接预订");if(trip.getRecordVersion()!=version)throw conflict("车次已被修改，请刷新");}
     private static void requireVersion(FleetBookingEntity row,long version){if(row.getRecordVersion()!=version)throw conflict("外接预订已被修改，请刷新");}
     private String write(Object value){try{return json.writeValueAsString(value);}catch(Exception error){throw new IllegalStateException(error);}}
-    private String hash(Object value){try{ObjectNode node=json.valueToTree(value);node.remove("idempotencyKey");node.remove("tripRecordVersion");return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(write(node).getBytes(StandardCharsets.UTF_8)));}catch(Exception error){throw new IllegalStateException(error);}}
+    /** 请求对象排除重放元数据；排车来源键的数组必须保留全部元素及顺序。 */
+    private String hash(Object value){try{com.fasterxml.jackson.databind.JsonNode node=json.valueToTree(value);if(node instanceof ObjectNode object){object.remove("idempotencyKey");object.remove("tripRecordVersion");}return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(write(node).getBytes(StandardCharsets.UTF_8)));}catch(Exception error){throw new IllegalStateException(error);}}
     private static LocalDateTime now(){return LocalDateTime.now(ZoneOffset.UTC);}
     private static String trim(String value){return value==null||value.isBlank()?null:value.trim();}
     private static String reason(String value,String fallback){return trim(value)==null?fallback:trim(value);}

lastleg-service/src/main/java/com/baiyue/lastleg/mapper/LastlegOrderMapper.java

@@ -210,12 +210,19 @@ public interface LastlegOrderMapper extends BaseMapper<LastlegOrder> {
     @Select("SELECT * FROM ll_order WHERE source_container_booking_id=#{sourceContainerBookingId} ORDER BY customer_id,id FOR UPDATE")
     List<LastlegOrder> lockContainerOrders(@Param("sourceContainerBookingId") String sourceContainerBookingId);
 
+    /** 人工时间及计划冻结时间优先；返回计划数量供各页面统一判断默认日期。 */
     @Select("<script>SELECT o.source_container_booking_id AS sourceContainerBookingId," +
         "CASE WHEN COUNT(o.estimated_warehouse_at)=COUNT(*) AND COUNT(DISTINCT o.estimated_warehouse_at)=1 " +
+        "AND (MAX(o.arrival_time_version)&gt;0 OR EXISTS(SELECT 1 FROM ll_inbound_plan p " +
+        "JOIN ll_order po ON po.id=p.source_order_id AND po.customer_id=p.customer_id " +
+        "WHERE po.source_container_booking_id=o.source_container_booking_id)) " +
         "THEN MAX(o.estimated_warehouse_at) ELSE NULL END AS estimatedWarehouseArrivalAt," +
         "(SELECT MIN(s.receiving_at) FROM ll_receiving_container_session s " +
         "WHERE s.source_container_booking_id=o.source_container_booking_id AND s.receiving_at IS NOT NULL) AS actualWarehouseArrivalAt," +
-        "CASE WHEN COUNT(DISTINCT o.arrival_time_version)=1 THEN MAX(o.arrival_time_version) ELSE -1 END AS version " +
+        "CASE WHEN COUNT(DISTINCT o.arrival_time_version)=1 THEN MAX(o.arrival_time_version) ELSE -1 END AS version," +
+        "(SELECT COUNT(*) FROM ll_inbound_plan p JOIN ll_order po " +
+        "ON po.id=p.source_order_id AND po.customer_id=p.customer_id " +
+        "WHERE po.source_container_booking_id=o.source_container_booking_id) AS planCount " +
         "FROM ll_order o WHERE o.source_container_booking_id IN " +
         "<foreach collection='bookingIds' item='id' open='(' separator=',' close=')'>#{id}</foreach> " +
         "GROUP BY o.source_container_booking_id</script>")

lastleg-service/src/main/resources/db/lastleg.sql

@@ -1907,6 +1907,7 @@ CREATE TABLE IF NOT EXISTS ll_dispatch_order (
   review_state VARCHAR(32) NOT NULL DEFAULT 'DRAFT' COMMENT '审核子流程当前状态',
   review_round BIGINT NOT NULL DEFAULT 0 COMMENT '当前审核轮次',
   review_basis_hash CHAR(64) NULL COMMENT '本审核轮次核对的货物和资源依据摘要',
+  exceptions_json JSON NULL COMMENT '派送异常登记记录及图片引用，不改变派送及库存状态',
   dispatch_review_json JSON NULL COMMENT '当前调度审核事实快照',
   loading_review_json JSON NULL COMMENT '当前理货审核事实快照',
   resources_json JSON NULL COMMENT '本趟主档或临时车辆司机的真实资源快照',

lastleg-service/src/main/resources/openapi/dispatch-vehicle-documents-v1.yaml

@@ -0,0 +1,379 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "排车车辆资料",
+    "version": "1.0.0",
+    "description": "仅平台有效排车DELIVERING/DELIVERED可用；兼容有无拼车货物，沿装车归属证据校验。共享原车队照片、版本、命令与历史，不新建附件存储。派送文件仍使用delivery-orders documents；不把车队RECEIPT照片当签收。列表权限只读，排车edit独立写；恢复还需list。"
+  },
+  "security": [
+    {
+      "bearerAuth": []
+    }
+  ],
+  "paths": {
+    "/api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents": {
+      "get": {
+        "operationId": "getDispatchVehicleDocuments",
+        "summary": "读取本车油耗图片；复用车队附加记录",
+        "x-permission-code": "platform:overseas-warehouse:dispatch:list",
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/dispatchNo"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "code": {
+                      "type": "string"
+                    },
+                    "message": {
+                      "type": "string"
+                    },
+                    "data": {
+                      "$ref": "#/components/schemas/Documents"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents/{slot}/uploads": {
+      "post": {
+        "operationId": "uploadDispatchVehiclePhoto",
+        "summary": "准备本车油耗图片；尚未绑定保存",
+        "x-permission-code": "platform:overseas-warehouse:dispatch:edit",
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/dispatchNo"
+          },
+          {
+            "$ref": "#/components/parameters/slot"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "code": {
+                      "type": "string"
+                    },
+                    "message": {
+                      "type": "string"
+                    },
+                    "data": {
+                      "$ref": "#/components/schemas/Photo"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "requestBody": {
+          "required": true,
+          "content": {
+            "multipart/form-data": {
+              "schema": {
+                "type": "object",
+                "required": [
+                  "file",
+                  "idempotencyKey"
+                ],
+                "properties": {
+                  "file": {
+                    "type": "string",
+                    "format": "binary",
+                    "description": "非空JPG/PNG，最大10MiB"
+                  },
+                  "idempotencyKey": {
+                    "type": "string",
+                    "minLength": 8,
+                    "maxLength": 128
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents/{slot}": {
+      "put": {
+        "operationId": "bindDispatchVehiclePhoto",
+        "summary": "按附加版本绑定原上传文件，不改变排车或签收状态",
+        "x-permission-code": "platform:overseas-warehouse:dispatch:edit",
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/dispatchNo"
+          },
+          {
+            "$ref": "#/components/parameters/slot"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "code": {
+                      "type": "string"
+                    },
+                    "message": {
+                      "type": "string"
+                    },
+                    "data": {
+                      "$ref": "#/components/schemas/Documents"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/BindPhoto"
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents/{slot}/files/{fileId}/content": {
+      "get": {
+        "operationId": "readDispatchVehiclePhoto",
+        "summary": "只读取本车当前绑定图片",
+        "x-permission-code": "platform:overseas-warehouse:dispatch:list",
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/dispatchNo"
+          },
+          {
+            "$ref": "#/components/parameters/slot"
+          },
+          {
+            "$ref": "#/components/parameters/fileId"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "no-store图片内容",
+            "content": {
+              "image/jpeg": {
+                "schema": {
+                  "type": "string",
+                  "format": "binary"
+                }
+              },
+              "image/png": {
+                "schema": {
+                  "type": "string",
+                  "format": "binary"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents/uploads/{idempotencyKey}": {
+      "get": {
+        "operationId": "recoverDispatchVehiclePhoto",
+        "summary": "只恢复当前操作者原油耗上传成功结果，未知结果拒绝重传",
+        "x-permission-code": "platform:overseas-warehouse:dispatch:edit",
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/dispatchNo"
+          },
+          {
+            "$ref": "#/components/parameters/idempotencyKey"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "code": {
+                      "type": "string"
+                    },
+                    "message": {
+                      "type": "string"
+                    },
+                    "data": {
+                      "$ref": "#/components/schemas/Photo"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "securitySchemes": {
+      "bearerAuth": {
+        "type": "http",
+        "scheme": "bearer",
+        "bearerFormat": "JWT"
+      }
+    },
+    "parameters": {
+      "dispatchNo": {
+        "name": "dispatchNo",
+        "in": "path",
+        "required": true,
+        "schema": {
+          "type": "string"
+        }
+      },
+      "slot": {
+        "name": "slot",
+        "in": "path",
+        "required": true,
+        "schema": {
+          "type": "string",
+          "enum": [
+            "FUEL_START",
+            "FUEL_END"
+          ]
+        }
+      },
+      "fileId": {
+        "name": "fileId",
+        "in": "path",
+        "required": true,
+        "schema": {
+          "type": "string"
+        }
+      },
+      "idempotencyKey": {
+        "name": "idempotencyKey",
+        "in": "path",
+        "required": true,
+        "schema": {
+          "type": "string"
+        }
+      }
+    },
+    "schemas": {
+      "Photo": {
+        "type": "object",
+        "required": [
+          "slot",
+          "fileId",
+          "fileName",
+          "contentType",
+          "sizeBytes",
+          "uploadedAt"
+        ],
+        "properties": {
+          "slot": {
+            "type": "string",
+            "enum": [
+              "FUEL_START",
+              "FUEL_END"
+            ]
+          },
+          "category": {
+            "type": "string",
+            "enum": [
+              "FUEL"
+            ]
+          },
+          "fileId": {
+            "type": "string"
+          },
+          "fileName": {
+            "type": "string"
+          },
+          "contentType": {
+            "type": "string"
+          },
+          "sizeBytes": {
+            "type": "string"
+          },
+          "uploadedAt": {
+            "type": "string"
+          },
+          "savedAt": {
+            "type": "string",
+            "nullable": true
+          }
+        }
+      },
+      "Documents": {
+        "type": "object",
+        "required": [
+          "dispatchNo",
+          "recordVersion",
+          "editable",
+          "photos"
+        ],
+        "properties": {
+          "dispatchNo": {
+            "type": "string"
+          },
+          "recordVersion": {
+            "type": "string"
+          },
+          "editable": {
+            "type": "boolean"
+          },
+          "photos": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/Photo"
+            }
+          }
+        }
+      },
+      "BindPhoto": {
+        "type": "object",
+        "required": [
+          "recordVersion",
+          "idempotencyKey",
+          "fileId"
+        ],
+        "properties": {
+          "recordVersion": {
+            "type": "string",
+            "pattern": "^(0|[1-9][0-9]*)$"
+          },
+          "idempotencyKey": {
+            "type": "string",
+            "minLength": 8,
+            "maxLength": 128
+          },
+          "fileId": {
+            "type": "string"
+          }
+        }
+      }
+    }
+  }
+}

lastleg-service/src/main/resources/openapi/fleet-outsourced-business-v1.yaml

@@ -1,8 +1,8 @@
 openapi: "3.0.3"
 info:
-  title: "原排车外配车辆运营视图"
+  title: "原排车拼车任务运营视图"
   version: "1.0.0"
-  description: "仅ACTIVE且装车后/派送中/已完成。按原装车归属DISPATCHED及MASTER/EXTERNAL资源快照读取；无快照不回填。复用四张附加表，不推进排车、不触发库存/财务。承运金额CNY/USD显式登记；单价除以实际物理托数并HALF_UP两位。无里程、油耗及油耗照片。响应遵循NON_NULL：可空属性可省略，省略与null均表示空值，0仍是明确登记值；请求必填项仍以required及DTO校验为准。"
+  description: "仅ACTIVE且装车后/派送中/已完成。按需求池已实收绑定及本车真实货物组成判定实际拼车。车辆归属允许OWNED/DISPATCHED，MASTER/EXTERNAL只表示资源身份；无快照不回填。复用四张附加表，不推进排车、不触发库存/财务。承运金额CNY/USD显式登记；单价除以实际物理托数并HALF_UP两位。无里程、油耗及油耗照片。响应遵循NON_NULL：可空属性可省略，省略与null均表示空值，0仍是明确登记值；请求必填项仍以required及DTO校验为准。"
 security:
   - bearerAuth: []
 paths:
@@ -182,7 +182,7 @@ components:
       properties:
         vehicleId: { type: string, nullable: true, description: "原临时EXTERNAL车辆合法为空，档案MASTER核对原捕获ID" }
         plate: { type: string, nullable: true }
-        ownership: { type: string, enum: [DISPATCHED] }
+        ownership: { type: string, enum: [OWNED, DISPATCHED] }
         carrierName: { type: string, nullable: true, description: "只取原车辆快照，缺失显示—；不查当前档案补值" }
     PhotoSlot:
       type: string

lastleg-service/src/main/resources/openapi/fleet-owned-business-v1.yaml

@@ -1,8 +1,8 @@
 openapi: "3.0.3"
 info:
-  title: "原排车自有车辆运营视图"
+  title: "原排车未拼车业务运营视图"
   version: "1.0.0"
-  description: "装车完成时冻结车辆OWNED/DISPATCHED；所有主单事实来自原dispatch。新增数据仅附加运营记录、命令、历史及归属证据。油耗L/100km手工登记，金额CNY/USD不默认、不换汇；零与未登记不同。响应遵循NON_NULL：可空属性可省略，省略与null均表示空值，0仍是明确登记值；请求必填项仍以required及DTO校验为准。"
+  description: "未实际接入拼车货物的装车后排车；按需求池已实收绑定及本车真实货物组成判定。车辆OWNED/DISPATCHED只表示装车时归属，不决定业务分类；所有主单事实来自原dispatch。新增数据仅附加运营记录、命令、历史及归属证据。油耗L/100km手工登记，金额CNY/USD不默认、不换汇；零与未登记不同。响应遵循NON_NULL：可空属性可省略，省略与null均表示空值，0仍是明确登记值；请求必填项仍以required及DTO校验为准。"
 security:
   -
     bearerAuth: []
@@ -10,7 +10,7 @@ paths:
   "/api/platform/v1/last-leg/fleet/owned-business":
     get:
       operationId: "listOwnedBusiness"
-      summary: "自有车辆装车后视图及同筛选四项统计"
+      summary: "未接入拼车货物的装车后视图及同筛选四项统计"
       description: "权限：platform:fleet:owned-business:list。仅可信平台主体；只读原排车事实，不改变其状态/版本，不发布费用。"
       x-permission-code: "platform:fleet:owned-business:list"
       responses:
@@ -540,18 +540,19 @@ components:
       type: "object"
       x-java-record: "OwnedBusinessModels.Vehicle"
       required:
-        - "vehicleId"
-        - "plate"
         - "ownership"
       properties:
         vehicleId:
           type: "string"
+          nullable: true
         plate:
           type: "string"
+          nullable: true
         ownership:
           type: "string"
           enum:
             - "OWNED"
+            - "DISPATCHED"
     Driver:
       type: "object"
       x-java-record: "OwnedBusinessModels.Driver"

lastleg-service/src/main/resources/openapi/overseas-business-v1.yaml

@@ -920,7 +920,8 @@ paths:
       parameters:
       - name: warehouseId
         in: query
-        required: true
+        description: 可选真实起运仓；未指定时按 warehouseTab 跨仓分页浏览，草稿及建单仍要求同一起运仓。
+        required: false
         schema:
           type: string
       - name: planIds
@@ -1345,49 +1346,6 @@ paths:
       required: true
       schema:
         type: string
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/transfer-delivery:
-    post:
-      summary: 原子安排本车全部客户派送及费用
-      description: 权限 platform:overseas-warehouse:dispatch:transfer-delivery。
-      security:
-      - bearerAuth: []
-      responses:
-        '200':
-          description: 统一ApiResponse；业务失败通过code返回，不能仅凭HTTP200判断成功。
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  requestId:
-                    type: string
-                    nullable: true
-                  traceId:
-                    type: string
-                    nullable: true
-                  timestamp:
-                    type: string
-                    format: date-time
-                  data:
-                    allOf:
-                    - $ref: '#/components/schemas/DispatchCommandResult'
-                    nullable: true
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/DispatchArrangeDelivery'
-    parameters:
-    - name: dispatchNo
-      in: path
-      required: true
-      schema:
-        type: string
   /api/platform/v1/last-leg/dispatches/{dispatchNo}/items:
     post:
       summary: 按真实来源版本向整车加货
@@ -1725,10 +1683,53 @@ paths:
       required: true
       schema:
         type: string
+  /api/platform/v1/last-leg/dispatches/{dispatchNo}/exceptions:
+    post:
+      summary: 登记派送异常
+      description: 权限 platform:overseas-warehouse:dispatch:edit；仅有效仓库派送单DELIVERING可登记，保存后阶段不变，不产生退货、签收或库存变化。原键重试恢复原结果。
+      security:
+      - bearerAuth: []
+      responses:
+        '200':
+          description: 统一ApiResponse；业务失败通过code返回，不能仅凭HTTP200判断成功。
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code:
+                    type: string
+                  message:
+                    type: string
+                  requestId:
+                    type: string
+                    nullable: true
+                  traceId:
+                    type: string
+                    nullable: true
+                  timestamp:
+                    type: string
+                    format: date-time
+                  data:
+                    allOf:
+                    - $ref: '#/components/schemas/DispatchCommandResult'
+                    nullable: true
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/DispatchMarkException'
+    parameters:
+    - name: dispatchNo
+      in: path
+      required: true
+      schema:
+        type: string
   /api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-complete:
     post:
-      summary: PDA核平后确认装车完成
-      description: 权限 platform:overseas-warehouse:dispatch:loading-complete。
+      summary: 确认装车完成并自动进入派送中
+      description: 权限 platform:overseas-warehouse:dispatch:loading-complete。 原请求在同一事务完成实载确认、全车派送单生成及发车；成功action为LOADING_COMPLETE、stage为DELIVERING，result保留真实Loaded装车证据。任一步失败整体回滚，重试原键恢复最终结果，不另行安排派送或确认发车。
       security:
       - bearerAuth: []
       responses:
@@ -1878,43 +1879,6 @@ paths:
       required: true
       schema:
         type: string
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/delivery-arrangement:
-    get:
-      summary: 读取全车派送分组与费用依据
-      description: 权限 platform:overseas-warehouse:dispatch:list。
-      security:
-      - bearerAuth: []
-      responses:
-        '200':
-          description: 统一ApiResponse；业务失败通过code返回，不能仅凭HTTP200判断成功。
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  requestId:
-                    type: string
-                    nullable: true
-                  traceId:
-                    type: string
-                    nullable: true
-                  timestamp:
-                    type: string
-                    format: date-time
-                  data:
-                    allOf:
-                    - $ref: '#/components/schemas/DispatchArrangementPreview'
-                    nullable: true
-    parameters:
-    - name: dispatchNo
-      in: path
-      required: true
-      schema:
-        type: string
   /api/platform/v1/last-leg/dispatches/{dispatchNo}/commands/{idempotencyKey}:
     get:
       summary: 恢复本人原动作不可变结果
@@ -1960,7 +1924,7 @@ paths:
   /api/platform/v1/last-leg/dispatches/{dispatchNo}/evidence/{kind}:
     post:
       summary: 上传本趟车辆或司机证据
-      description: 权限 platform:overseas-warehouse:dispatch:edit。PDF/JPG/PNG，非空且不超过10MiB；平台、本车、类型复合归属。上传后通过版本化EDIT保存引用。
+      description: 客服阶段使用 platform:overseas-warehouse:dispatch:edit；调度待审/理货待审分别使用 platform:fleet:trip:dispatch-review / platform:fleet:trip:loading-review，无需维护车辆权限。VEHICLE和DRIVER支持PDF/JPG/PNG，DRIVER_PHOTO和EXCEPTION仅JPG/PNG；EXCEPTION仅派送中使用排车edit权限，引用随异常登记保存。非空且不超过10MiB；平台、本车、类型复合归属。审核补充附件随ReviewCommand保存，不修改资源，不重启审核。
       security:
       - bearerAuth: []
       responses:
@@ -2014,6 +1978,8 @@ paths:
         enum:
         - VEHICLE
         - DRIVER
+        - DRIVER_PHOTO
+        - EXCEPTION
   /api/platform/v1/last-leg/dispatches/{dispatchNo}/evidence/{kind}/{fileId}:
     get:
       summary: 读取本车证据元数据
@@ -2059,6 +2025,8 @@ paths:
         enum:
         - VEHICLE
         - DRIVER
+        - DRIVER_PHOTO
+        - EXCEPTION
     - name: fileId
       in: path
       required: true
@@ -2101,55 +2069,14 @@ paths:
         enum:
         - VEHICLE
         - DRIVER
+        - DRIVER_PHOTO
+        - EXCEPTION
     - name: fileId
       in: path
       required: true
       schema:
         type: string
         pattern: ^[1-9][0-9]*$
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/depart:
-    post:
-      summary: 确认实际整车发车
-      description: 权限 platform:overseas-warehouse:dispatch:depart。
-      security:
-      - bearerAuth: []
-      responses:
-        '200':
-          description: 统一ApiResponse；业务失败通过code返回，不能仅凭HTTP200判断成功。
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  requestId:
-                    type: string
-                    nullable: true
-                  traceId:
-                    type: string
-                    nullable: true
-                  timestamp:
-                    type: string
-                    format: date-time
-                  data:
-                    allOf:
-                    - $ref: '#/components/schemas/DispatchCommandResult'
-                    nullable: true
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/DispatchDepart'
-    parameters:
-    - name: dispatchNo
-      in: path
-      required: true
-      schema:
-        type: string
   /api/platform/v1/last-leg/outbound-orders:
     get:
       summary: 分页查询出库单
@@ -3623,12 +3550,13 @@ components:
         remark: { type: string, maxLength: 500, nullable: true }
     ContainerArrivalTimeView:
       type: object
-      required: [sourceContainerBookingId, version]
+      required: [sourceContainerBookingId, version, planCount]
       properties:
         sourceContainerBookingId: { type: string }
-        estimatedWarehouseArrivalAt: { type: string, format: date-time, nullable: true }
+        estimatedWarehouseArrivalAt: { type: string, format: date-time, nullable: true, description: 人工维护或入库计划冻结的整柜时间；未维护未建计划时为空，由页面按到港当地日期加两个自然日展示默认日期 }
         actualWarehouseArrivalAt: { type: string, format: date-time, nullable: true, description: 海外 PDA 首次开始收货时间 }
-        version: { type: integer, minimum: 0 }
+        version: { type: integer, minimum: -1, description: -1表示柜内时间版本不一致 }
+        planCount: { type: integer, format: int64, minimum: 0, description: 整柜已有入库计划数量；非零时禁止默认推算及改期 }
     ContainerPlanProgressDetail:
       type: object
       required: [summary, orders]
@@ -4274,7 +4202,10 @@ components:
         invalidatedReason:
           type: string
           nullable: true
+        attachments:
+          $ref: '#/components/schemas/DispatchReviewAttachments'
       required:
+      - attachments
       - status
       - reason
       - reviewerId
@@ -5259,6 +5190,7 @@ components:
       - LOADING_COMPLETE
       - ARRANGE_DELIVERY
       - DEPART
+      - MARK_EXCEPTION
     DispatchGate:
       type: object
       x-java-record: DispatchContracts.Gate
@@ -5943,6 +5875,47 @@ components:
       required:
       - recordVersion
       - idempotencyKey
+    DispatchReviewAttachments:
+      type: object
+      description: 本次审核补充证据；省略或null为三组空数组。每类最多20个且不得重复；逐个验证本车和类别归属，不接受MASTER档案证照冒充本车审核上传。
+      x-java-record: DispatchContracts.ReviewAttachments
+      properties:
+        vehicleFileIds:
+          type: array
+          maxItems: 20
+          uniqueItems: true
+          description: 本车VEHICLE证据文件ID。
+          items:
+            oneOf:
+            - type: string
+              pattern: ^[1-9][0-9]*$
+            - type: integer
+              format: int64
+              minimum: 1
+        driverPhotoFileIds:
+          type: array
+          maxItems: 20
+          uniqueItems: true
+          description: 本车DRIVER_PHOTO证据文件ID。
+          items:
+            oneOf:
+            - type: string
+              pattern: ^[1-9][0-9]*$
+            - type: integer
+              format: int64
+              minimum: 1
+        licenseFileIds:
+          type: array
+          maxItems: 20
+          uniqueItems: true
+          description: 本车DRIVER证据文件ID。
+          items:
+            oneOf:
+            - type: string
+              pattern: ^[1-9][0-9]*$
+            - type: integer
+              format: int64
+              minimum: 1
     DispatchReviewCommand:
       type: object
       x-java-record: DispatchCommands.ReviewCommand
@@ -5963,6 +5936,10 @@ components:
         reason:
           type: string
           nullable: true
+        attachments:
+          allOf:
+          - $ref: '#/components/schemas/DispatchReviewAttachments'
+          nullable: true
       required:
       - recordVersion
       - idempotencyKey
@@ -6386,6 +6363,10 @@ components:
           items:
             $ref: '#/components/schemas/DispatchBatchReference'
           nullable: true
+        exceptions:
+          type: array
+          items:
+            $ref: '#/components/schemas/DispatchExceptionRecord'
       required:
       - route
       - plannedDepartureAt
@@ -6393,6 +6374,7 @@ components:
       - estimatedArrivalAt
       - fbaAppointments
       - appointmentBatches
+      - exceptions
     DispatchDocuments:
       type: object
       x-java-record: DispatchViews.Documents
@@ -6586,6 +6568,10 @@ components:
           allOf:
           - $ref: '#/components/schemas/DispatchReviews'
           nullable: true
+        resources:
+          allOf:
+          - $ref: '#/components/schemas/DispatchResources'
+          nullable: true
         counts:
           allOf:
           - $ref: '#/components/schemas/DispatchCounts'
@@ -6610,6 +6596,7 @@ components:
       - stage
       - recordVersion
       - reviews
+      - resources
       - counts
       - pickingReconciled
       - items
@@ -8007,5 +7994,66 @@ components:
       - sourceInboundOrderNo
       - sourceInboundCode
       - productQuantity
+
+    DispatchExceptionType:
+      type: string
+      enum: [REFUSED, PARTIAL_RECEIPT, VEHICLE_EXCEPTION]
+      description: 拒收、部分签收、车辆异常。
+    DispatchReturnDirection:
+      type: string
+      enum: [OVERSEAS_WAREHOUSE, OTHER]
+      description: 退回海外仓、其他；仅登记去向，不自动退货入库。
+    DispatchMarkException:
+      type: object
+      x-java-record: DispatchCommands.MarkException
+      required: [recordVersion, idempotencyKey, exceptionType]
+      properties:
+        recordVersion:
+          oneOf:
+          - type: string
+            pattern: ^[0-9]+$
+          - type: integer
+            minimum: 0
+        idempotencyKey:
+          type: string
+        exceptionType:
+          $ref: '#/components/schemas/DispatchExceptionType'
+        returnDirection:
+          allOf:
+          - $ref: '#/components/schemas/DispatchReturnDirection'
+          nullable: true
+        description:
+          type: string
+          maxLength: 1000
+          nullable: true
+        imageFileIds:
+          type: array
+          maxItems: 20
+          uniqueItems: true
+          items:
+            type: string
+            pattern: ^[1-9][0-9]*$
+    DispatchExceptionRecord:
+      type: object
+      x-java-record: DispatchViews.ExceptionRecord
+      required: [exceptionType, returnDirection, description, imageFileIds, occurredAt]
+      properties:
+        exceptionType:
+          $ref: '#/components/schemas/DispatchExceptionType'
+        returnDirection:
+          allOf:
+          - $ref: '#/components/schemas/DispatchReturnDirection'
+          nullable: true
+        description:
+          type: string
+          nullable: true
+        imageFileIds:
+          type: array
+          items:
+            type: string
+        occurredAt:
+          type: string
+          format: date-time
+
   securitySchemes:
     bearerAuth: { type: http, scheme: bearer, bearerFormat: JWT }

lastleg-service/src/main/resources/openapi/overseas-pda-operations-v1.yaml

@@ -9,7 +9,7 @@ paths:
   /api/pda/v1/last-leg/dispatches:
     get:
       summary: 读取Token绑定仓五阶段整车任务
-      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。不接收客户或仓库范围参数；真实客户归属保留在items，整车公共版本及Gate由服务端返回。
+      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。不接收客户或仓库范围参数；真实客户归属保留在items，整车公共版本及Gate由服务端返回。未指定阶段时返回待理货审核及装车、装车后、派送中的任务；车辆与司机依据读取resources。
       security:
       - bearerAuth: []
       responses:
@@ -208,10 +208,53 @@ paths:
       required: true
       schema:
         type: string
+  /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-review:
+    post:
+      summary: 理货员审核整车，后台与PDA共用审核轮次
+      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。仅绑定仓且调度审核通过的本轮整车可审核；REJECTED 必填 reason 并退回客服处理，APPROVED 才进入 LOADING；公共版本拒绝双端重复审核，原键恢复仍核验本人、绑定仓和理货权限。
+      security:
+      - bearerAuth: []
+      responses:
+        '200':
+          description: 统一ApiResponse；业务失败通过code返回，不能仅凭HTTP200判断成功。
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code:
+                    type: string
+                  message:
+                    type: string
+                  requestId:
+                    type: string
+                    nullable: true
+                  traceId:
+                    type: string
+                    nullable: true
+                  timestamp:
+                    type: string
+                    format: date-time
+                  data:
+                    allOf:
+                    - $ref: overseas-business-v1.yaml#/components/schemas/DispatchCommandResult
+                    nullable: true
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: overseas-business-v1.yaml#/components/schemas/DispatchReviewCommand
+    parameters:
+    - name: dispatchNo
+      in: path
+      required: true
+      schema:
+        type: string
   /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-complete:
     post:
-      summary: 真实拣货核平后显式确认装车完成
-      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。只用整车recordVersion和全载荷幂等键；扫码执行真实库存SHIP，装车完成和发车不重复SHIP。错误或结果未知保留原请求核对。
+      summary: 确认装车完成并自动进入派送中
+      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。只用整车recordVersion和全载荷幂等键；扫码执行真实库存SHIP，装车完成和发车不重复SHIP。错误或结果未知保留原请求核对。 原请求在同一事务完成实载确认、全车派送单生成及发车；成功action为LOADING_COMPLETE、stage为DELIVERING，result保留真实Loaded装车证据。任一步失败整体回滚，重试原键恢复最终结果，不另行安排派送或确认发车。
       security:
       - bearerAuth: []
       responses:
@@ -251,49 +294,6 @@ paths:
       required: true
       schema:
         type: string
-  /api/pda/v1/last-leg/dispatches/{dispatchNo}/depart:
-    post:
-      summary: 完整安排派送后确认实际发车
-      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。只用整车recordVersion和全载荷幂等键；扫码执行真实库存SHIP，装车完成和发车不重复SHIP。错误或结果未知保留原请求核对。
-      security:
-      - bearerAuth: []
-      responses:
-        '200':
-          description: 统一ApiResponse；业务失败通过code返回，不能仅凭HTTP200判断成功。
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  requestId:
-                    type: string
-                    nullable: true
-                  traceId:
-                    type: string
-                    nullable: true
-                  timestamp:
-                    type: string
-                    format: date-time
-                  data:
-                    allOf:
-                    - $ref: overseas-business-v1.yaml#/components/schemas/DispatchCommandResult
-                    nullable: true
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: overseas-business-v1.yaml#/components/schemas/DispatchDepart
-    parameters:
-    - name: dispatchNo
-      in: path
-      required: true
-      schema:
-        type: string
   /api/pda/v1/last-leg/outbound-tasks:
     get:
       summary: 查询Token绑定仓的一件代发出库任务

lastleg-service/src/test/java/com/baiyue/lastleg/calendar/WarehouseCalendarMapperTest.java

@@ -2,6 +2,7 @@ package com.baiyue.lastleg.calendar;
 
 import com.baomidou.mybatisplus.core.MybatisConfiguration;
 import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
+import com.baiyue.lastleg.mapper.LastlegOrderMapper;
 import org.apache.ibatis.mapping.Environment;
 import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
 import org.h2.jdbcx.JdbcDataSource;
@@ -28,12 +29,23 @@ class WarehouseCalendarMapperTest {
         }
         var config=new MybatisConfiguration(); config.setEnvironment(new Environment("test",new JdbcTransactionFactory(),ds));
         config.addMapper(WarehouseCalendarMapper.class);
+        config.addMapper(LastlegOrderMapper.class);
         try(var session=new MybatisSqlSessionFactoryBuilder().build(config).openSession()) {
             var rows=session.getMapper(WarehouseCalendarMapper.class).calendar(LocalDateTime.parse("2026-11-01T00:00:00"),LocalDateTime.parse("2026-12-01T00:00:00"),List.of("1"));
             assertEquals(3,rows.size());
             assertEquals("1",rows.get(0).sourceContainerBookingId()); assertNull(rows.get(0).plannedAt());
             assertEquals(2,rows.get(1).version()); assertEquals("2026-11-10T09:00",rows.get(1).plannedAt().toString());
             assertEquals(1,rows.get(2).planCount()); assertNotNull(rows.get(2).plannedAt());
+            // 清关提柜与日历必须读取相同的人工/冻结事实，默认日期由前端统一推算。
+            var customs=session.getMapper(LastlegOrderMapper.class).findContainerArrivalTimes(List.of("1","2","3"));
+            assertEquals(3,customs.size());
+            for(var calendar:rows) {
+                var arrival=customs.stream().filter(row -> row.sourceContainerBookingId().equals(calendar.sourceContainerBookingId())).findFirst().orElseThrow();
+                assertEquals(calendar.plannedAt(),arrival.estimatedWarehouseArrivalAt());
+                assertEquals(calendar.actualAt(),arrival.actualWarehouseArrivalAt());
+                assertEquals(calendar.version(),arrival.version());
+                assertEquals(calendar.planCount(),arrival.planCount());
+            }
         }
     }
 }

lastleg-service/src/test/java/com/baiyue/lastleg/delivery/DispatchDeliveryArrangementPersistenceTest.java

@@ -37,6 +37,7 @@ import static org.mockito.Mockito.*;
 /** 真实生产Mapper及事务验证任何客户或主单CAS失败时全车原子回滚。 */
 class DispatchDeliveryArrangementPersistenceTest {
     private JdbcTemplate db;
+    private org.springframework.transaction.support.TransactionTemplate tx;
     private DispatchDeliveryService service;
     private final DispatchExecutionPort execution=mock(DispatchExecutionPort.class);
     private final DispatchDeliveryFees fees=mock(DispatchDeliveryFees.class);
@@ -49,6 +50,7 @@ class DispatchDeliveryArrangementPersistenceTest {
     @BeforeEach void prepare() throws Exception {
         var ds=new DriverManagerDataSource("jdbc:h2:mem:arrangement-"+UUID.randomUUID()+";MODE=MySQL;DB_CLOSE_DELAY=-1","sa","");
         db=new JdbcTemplate(ds);
+        tx=new org.springframework.transaction.support.TransactionTemplate(new DataSourceTransactionManager(ds));
         for (var type:List.of(OutboundOrder.class,OutboundPalletItem.class,DeliveryOrder.class,LastlegOrder.class,LastlegOrderStatusHistory.class)) {
             String columns=Arrays.stream(type.getDeclaredFields()).filter(f->!Modifier.isStatic(f.getModifiers())).map(f->{
                 String name=f.getName().replaceAll("([A-Z])","_$1").toLowerCase();
@@ -173,6 +175,32 @@ class DispatchDeliveryArrangementPersistenceTest {
         assertEquals(6L,frozen.stream().filter(c->c.attributionId()==4).findFirst().orElseThrow().sourceOrigin().productQuantity());
     }
 
+    /** 自动装车加入父事务，最终主单失败时全部客户单据与来源绑定均回滚。 */
+    @Test void automaticPreparationSharesLoadingParentTransactionAndRollback() {
+        assertThrows(IllegalStateException.class,()->tx.execute(status->{
+            service.prepareForDeparture(context,actor,"LOADING-FAIL");
+            throw new IllegalStateException("装车最终保存失败");
+        }));
+        for(var table:List.of("ll_outbound_order","ll_outbound_pallet_item","ll_delivery_order","ll_dispatch_delivery_arrangement","ll_loading_order_status_history"))
+            assertEquals(0,db.queryForObject("SELECT COUNT(*) FROM "+table,Integer.class));
+        assertEquals(2,db.queryForObject("SELECT COUNT(*) FROM ll_order WHERE outbound_order_no IS NULL AND version=0",Integer.class));
+        var fact=tx.execute(status->service.prepareForDeparture(context,actor,"LOADING-OK"));
+        assertEquals(2,fact.result().deliveries().size());
+        assertEquals(2,db.queryForObject("SELECT COUNT(*) FROM ll_delivery_order WHERE planned_delivery_at IS NULL AND delivery_method IS NULL AND pickup_method IS NULL AND loading_type IS NULL",Integer.class));
+        assertEquals(2,db.queryForObject("SELECT COUNT(*) FROM ll_outbound_order WHERE fee_coverage_json IS NULL",Integer.class));
+        clearInvocations(fees);
+        assertEquals(fact,tx.execute(status->service.prepareForDeparture(context,actor,"LOADING-OK")));
+        verifyNoInteractions(fees);
+    }
+
+    /** 外接费用发布失败同样回滚自动生成的全部客户单据，不能留下半车。 */
+    @Test void automaticExternalFreightFailureRollsBackEveryCustomer() {
+        doThrow(new IllegalStateException("外接费用发布失败")).when(fees).publish(any(),argThat(g->g.customerId().equals("102")),any(),any(),any(),any(),anyString(),anyString());
+        assertThrows(IllegalStateException.class,()->tx.execute(status->service.prepareForDeparture(context,actor,"LOADING-FAIL")));
+        assertEquals(0,db.queryForObject("SELECT COUNT(*) FROM ll_outbound_order",Integer.class));
+        assertEquals(0,db.queryForObject("SELECT COUNT(*) FROM ll_delivery_order",Integer.class));
+    }
+
     /** 按真实共享记录构造完整客户目的地请求。 */
     private ArrangeDelivery request() { return new ArrangeDelivery(3L,"ARRANGE-1","cargo-hash","loading-hash",grouping.groups(context).stream().map(g->
         new ArrangeGroup(g.key(),g.cargoHash(),DEPARTED,"TRUCK",null,null,"WAREHOUSE_PICKUP","PALLET",null,null,null,null,null,

lastleg-service/src/test/java/com/baiyue/lastleg/delivery/DispatchDeliveryServiceTest.java

@@ -72,6 +72,38 @@ class DispatchDeliveryServiceTest {
         verify(fees,times(3)).publish(any(),any(),any(),any(),isNull(),any(),eq("OP-A"),anyString());
     }
 
+    /** PDA装车自动生成完整客户目的地，不猜派送计划、不要求人工费用或原费覆盖。 */
+    @Test void loadingAutomaticallyCreatesDocumentsWithoutInventedInputsOrFees() {
+        var pda=new Actor("PDA-1",ActorMode.PDA,"1001");
+        var fact=service.prepareForDeparture(context,pda,"LOADING-1");
+        assertEquals(2,fact.result().outbounds().size());assertEquals(3,fact.result().deliveries().size());
+        assertEquals(4,fact.result().recordVersion());
+        assertTrue(deliveries.stream().allMatch(d->d.getPlannedDeliveryAt()==null && d.getDeliveryMethod()==null
+            && d.getPickupMethod()==null && d.getLoadingType()==null));
+        assertTrue(outbounds.stream().allMatch(o->o.getFeeCoverageJson()==null));
+        assertTrue(calls.indexOf("SOURCE")>calls.lastIndexOf("DELIVERY"));
+        verify(fees,never()).validate(any(),any(),any(),any());verify(fees,never()).coverage(any(),any(),any(),any());
+        var inputs=org.mockito.ArgumentCaptor.forClass(ArrangeGroup.class);
+        verify(fees,times(3)).publish(eq(context),any(),inputs.capture(),any(),isNull(),any(),eq("PDA-1"),anyString());
+        assertTrue(inputs.getAllValues().stream().allMatch(i->i.fees().isEmpty() && i.feeCoverage().isEmpty()));
+        clearInvocations(fees,repository);
+        assertEquals(fact,service.prepareForDeparture(context,pda,"LOADING-1"));
+        verifyNoInteractions(fees);verify(repository,never()).create(any(OutboundOrder.class));
+        assertThrows(org.springframework.web.server.ResponseStatusException.class,
+            ()->service.prepareForDeparture(context,pda,"DIFFERENT-KEY"));
+    }
+
+    /** 自动生成仍拒绝越仓与孤立子单，不为异常半车补造第二套事实。 */
+    @Test void automaticPreparationRejectsWrongWarehouseAndOrphanDocuments() {
+        assertThrows(org.springframework.web.server.ResponseStatusException.class,
+            ()->service.prepareForDeparture(context,new Actor("PDA-1",ActorMode.PDA,"OTHER"),"LOADING-1"));
+        verifyNoInteractions(repository,fees);
+        outbounds.add(new OutboundOrder());
+        assertThrows(org.springframework.web.server.ResponseStatusException.class,
+            ()->service.prepareForDeparture(context,actor,"LOADING-1"));
+        verifyNoInteractions(fees);
+    }
+
     /** 同实托的两申请分别冻结原货源，出库引用逐次归属且真实客户目的地与履约订单不被替换。 */
     @Test void relabelOriginsStayFrozenBehindOutboundAttributionReferences() throws Exception {
         var first=new SourceOrigin(10001L,201L,301L,401L,701L,"IN-701","CODE-701",null);

lastleg-service/src/test/java/com/baiyue/lastleg/delivery/PlatformDispatchOutboundContractTest.java

@@ -97,8 +97,6 @@ class PlatformDispatchOutboundContractTest {
             String.class, DispatchCommands.Update.class);
         Method cancel = DispatchAggregateController.class.getMethod("cancel", AuthenticatedUser.class,
             String.class, DispatchCommands.ReasonCommand.class);
-        Method transfer = DeliveryTransferController.class.getMethod("transfer", AuthenticatedUser.class,
-            String.class, com.baiyue.lastleg.dispatch.port.DispatchDeliveryModels.ArrangeDelivery.class);
         Method externalFreight = DeliveryTransferController.class.getMethod("externalFreight", AuthenticatedUser.class, String.class);
         assertPermission(externalFreight, OverseasPermissions.DISPATCH_LIST);
         Method outboundDetail = DeliveryTransferController.class.getMethod("outboundDetail",
@@ -113,11 +111,12 @@ class PlatformDispatchOutboundContractTest {
         assertEquals(Set.of("/{dispatchNo}/cancel"), Set.of(cancelRoute.value()));
         assertFalse(cancel.isAnnotationPresent(org.springframework.web.bind.annotation.DeleteMapping.class));
         assertTrue(cancel.getParameters()[2].isAnnotationPresent(org.springframework.web.bind.annotation.RequestBody.class));
-        assertPermission(transfer, OverseasPermissions.DISPATCH_TRANSFER_DELIVERY);
+        assertTrue(Arrays.stream(DeliveryTransferController.class.getDeclaredMethods())
+            .noneMatch(method -> Set.of("transfer", "arrangement").contains(method.getName())));
         assertPermission(outboundDetail, OverseasPermissions.OUTBOUND_LIST);
         assertEquals(2, outboundDetail.getParameterCount());
         assertPermission(outboundCancel, OverseasPermissions.OUTBOUND_CANCEL);
-        for (Method method : Set.of(update, cancel, transfer, externalFreight, outboundDetail, outboundCancel)) {
+        for (Method method : Set.of(update, cancel, externalFreight, outboundDetail, outboundCancel)) {
             assertTrue(Arrays.stream(method.getParameters())
                 .noneMatch(parameter -> parameter.isAnnotationPresent(RequestParam.class)));
         }
@@ -202,16 +201,13 @@ class PlatformDispatchOutboundContractTest {
         assertFalse(schema.contains("uk_ll_outbound_no (customer_id,outbound_no)"));
     }
 
-    /** 当前整车请求按公共版本一次提交全部组，响应保留多客户出库及多目的地派送数组。 */
+    /** 公开协议撤销人工安排入口，内部完整派送事实仍保留多客户和多目的地数组。 */
     @Test
     void openApiPublishesOnlyTheFrozenPlatformProtocol() throws Exception {
         String yaml = Files.readString(Path.of("src/main/resources/openapi/overseas-business-v1.yaml"),
             StandardCharsets.UTF_8);
         String dispatchAction = slice(yaml, "  /api/platform/v1/last-leg/dispatches/{dispatchNo}:",
             "  /api/platform/v1/last-leg/dispatches/candidates:");
-        String transfer = slice(yaml,
-            "  /api/platform/v1/last-leg/dispatches/{dispatchNo}/transfer-delivery:",
-            "  /api/platform/v1/last-leg/outbound-orders:");
         String outboundDetail = slice(yaml,
             "  /api/platform/v1/last-leg/outbound-orders/{outboundNo}:",
             "  /api/platform/v1/last-leg/outbound-orders/{outboundNo}/cancel:");
@@ -219,7 +215,7 @@ class PlatformDispatchOutboundContractTest {
             "  /api/platform/v1/last-leg/outbound-orders/{outboundNo}/cancel:",
             "  /api/platform/v1/last-leg/overseas-procurements:");
 
-        for (String action : Set.of(dispatchAction, transfer, outboundDetail, outboundCancel)) {
+        for (String action : Set.of(dispatchAction, outboundDetail, outboundCancel)) {
             assertFalse(action.contains("name: customerId"));
         }
         assertTrue(outboundDetail.contains("pallets[].palletNo"));
@@ -228,24 +224,13 @@ class PlatformDispatchOutboundContractTest {
         assertTrue(yaml.contains("单次 SQL 返回，不逐行补查"));
         assertTrue(yaml.contains("platform:overseas-warehouse:dispatch:edit"));
         assertTrue(yaml.contains("platform:overseas-warehouse:dispatch:cancel"));
-        assertTrue(yaml.contains("platform:overseas-warehouse:dispatch:transfer-delivery"));
+        assertFalse(yaml.contains("  /api/platform/v1/last-leg/dispatches/{dispatchNo}/transfer-delivery:"));
+        assertFalse(yaml.contains("  /api/platform/v1/last-leg/dispatches/{dispatchNo}/delivery-arrangement:"));
         assertTrue(yaml.contains("platform:overseas-warehouse:outbound:list"));
         assertTrue(yaml.contains("platform:overseas-warehouse:outbound:create"));
         assertTrue(yaml.contains("platform:overseas-warehouse:outbound:cancel"));
         java.util.Map<?,?> document = new org.yaml.snakeyaml.Yaml().load(yaml);
         java.util.Map<?,?> schemas = (java.util.Map<?,?>)((java.util.Map<?,?>)document.get("components")).get("schemas");
-        java.util.Map<?,?> arrange = (java.util.Map<?,?>)schemas.get("DispatchArrangeDelivery");
-        assertNotNull(arrange);
-        assertTrue(((java.util.List<?>)arrange.get("required")).containsAll(java.util.List.of("recordVersion", "idempotencyKey")));
-        java.util.Map<?,?> fields = (java.util.Map<?,?>)arrange.get("properties");
-        assertTrue(fields.keySet().containsAll(java.util.Set.of("recordVersion", "idempotencyKey", "cargoHash", "loadingCompletionHash", "groups")));
-        assertFalse(fields.containsKey("customerId"));
-        assertFalse(fields.containsKey("expectedVersion"));
-        java.util.Map<?,?> groups = (java.util.Map<?,?>)fields.get("groups");
-        assertEquals("array", groups.get("type"));
-        assertEquals("#/components/schemas/DispatchArrangeGroup", ((java.util.Map<?,?>)groups.get("items")).get("$ref"));
-        java.util.Map<?,?> groupFields = (java.util.Map<?,?>)((java.util.Map<?,?>)schemas.get("DispatchArrangeGroup")).get("properties");
-        assertTrue(groupFields.keySet().containsAll(java.util.Set.of("groupKey", "groupCargoHash", "fees", "feeCoverage")));
         java.util.Map<?,?> resultFields = (java.util.Map<?,?>)((java.util.Map<?,?>)schemas.get("DispatchArrangementResult")).get("properties");
         assertEquals("array", ((java.util.Map<?,?>)resultFields.get("outbounds")).get("type"));
         assertEquals("array", ((java.util.Map<?,?>)resultFields.get("deliveries")).get("type"));

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/SmartDispatchOpenApiContractTest.java

@@ -38,6 +38,9 @@ class SmartDispatchOpenApiContractTest {
         assertThat(map(paths.get(base+"/drafts"))).containsKey("get");
         var candidate=map(map(paths.get(base+"/candidates")).get("get"));
         var parameterNames=((List<?>)candidate.get("parameters")).stream().map(SmartDispatchOpenApiContractTest::map).map(p->p.get("name")).toList();
+        var warehouseParameter=((List<?>)candidate.get("parameters")).stream().map(SmartDispatchOpenApiContractTest::map)
+            .filter(p->"warehouseId".equals(p.get("name"))).findFirst().orElseThrow();
+        assertThat(warehouseParameter.get("required")).isEqualTo(false);
         assertThat(parameterNames).contains("warehouseId","destinationWarehouseCode","draftToken","page","size","warehouseTab").doesNotContain("customerId","fbaWarehouseCode");
         assertThat(map(map(schemas.get("DispatchCandidateList")).get("properties")).keySet())
             .containsExactlyInAnyOrder("candidates","snapshotAt","complete","total","page","size","pages");

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/controller/SmartDispatchControllerTest.java

@@ -45,6 +45,16 @@ class SmartDispatchControllerTest {
             .andExpect(status().isOk());
         verify(aggregate).candidates(actor,new CandidateQuery("92",null,null,"LAX9",null,null,1,20,"ALL"));verifyNoInteractions(planning);
     }
+    /** 区域入口无需隐藏默认仓，全部与城市均由服务端分页。 */
+    @Test void candidateHttpQueryAllowsRegionalBrowsingWithoutWarehouse()throws Exception {
+        var mvc=MockMvcBuilders.standaloneSetup(controller).setCustomArgumentResolvers(new AuthenticationPrincipalArgumentResolver()).build();
+        SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken(platform(),null,List.of()));
+        for(String tab:List.of("ALL","LAX","NYC")) {
+            mvc.perform(get("/api/platform/v1/last-leg/dispatches/candidates").param("warehouseTab",tab)).andExpect(status().isOk());
+            verify(aggregate).candidates(actor,new CandidateQuery(null,null,null,null,null,null,1,20,tab));
+        }
+        verifyNoInteractions(planning);
+    }
     /** 每个写入都将冻结DTO原样传递，拥有者只能来自认证主体。 */
     @Test void allDraftRoutesDelegateFrozenVersionedRequests(){
         var create=new CreateDraft("create","92");var container=new CreateContainer(0L,"container","d",15);

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/gateway/HttpDispatchEvidenceGatewayTest.java

@@ -37,6 +37,23 @@ class HttpDispatchEvidenceGatewayTest {
         assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",own),9,DispatchEvidenceGateway.Kind.VEHICLE,3L)).isInstanceOf(ResponseStatusException.class);
         assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",own),9,DispatchEvidenceGateway.Kind.DRIVER,4L)).isInstanceOf(ResponseStatusException.class);
     }
+    /** 司机照片使用独立本车类别且禁止PDF，不与驾驶证证据串用。 */
+    @Test void driverPhotoUsesDistinctKindAndImageOnly() {
+        var photo=new HttpDispatchEvidenceGateway.Metadata(3L,0L,"OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE","9","driver.png","image/png",128L);
+        assertThat(HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",photo),9,DispatchEvidenceGateway.Kind.DRIVER_PHOTO,3L).fileId()).isEqualTo(3L);
+        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",photo),9,DispatchEvidenceGateway.Kind.DRIVER,3L)).isInstanceOf(ResponseStatusException.class);
+        var pdf=new HttpDispatchEvidenceGateway.Metadata(3L,0L,"OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE","9","driver.pdf","application/pdf",128L);
+        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",pdf),9,DispatchEvidenceGateway.Kind.DRIVER_PHOTO,3L)).isInstanceOf(ResponseStatusException.class);
+    }
+    /** 异常图片独立归属本车，审核照片及PDF均不能用作异常图片。 */
+    @Test void exceptionImagesRejectOtherKindsCarsAndPdf() {
+        var photo=new HttpDispatchEvidenceGateway.Metadata(3L,0L,"OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE","9","exception.png","image/png",128L);
+        assertThat(HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",photo),9,DispatchEvidenceGateway.Kind.EXCEPTION,3L).fileId()).isEqualTo(3L);
+        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",photo),10,DispatchEvidenceGateway.Kind.EXCEPTION,3L)).isInstanceOf(ResponseStatusException.class);
+        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",photo),9,DispatchEvidenceGateway.Kind.DRIVER_PHOTO,3L)).isInstanceOf(ResponseStatusException.class);
+        var pdf=new HttpDispatchEvidenceGateway.Metadata(3L,0L,"OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE","9","exception.pdf","application/pdf",128L);
+        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",pdf),9,DispatchEvidenceGateway.Kind.EXCEPTION,3L)).isInstanceOf(ResponseStatusException.class);
+    }
     /** 客户、旧主档或缺失媒体类型均拒绝，不因为文件本身存在而放行。 */
     @Test void rejectsForeignTenantMasterScopeAndMalformedMetadata() {
         for(var value:java.util.List.of(

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/service/DispatchAggregatePersistenceTest.java

@@ -340,12 +340,12 @@ public class DispatchAggregatePersistenceTest {
             assertSubmissionGate(f,created.dispatchNo(),ReviewState.DRAFT,true);
             var submitted=f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(created.recordVersion(),"submission-states-1",null)));
             assertSubmissionGate(f,created.dispatchNo(),ReviewState.DISPATCH_PENDING,false);
-            var rejected=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submitted.recordVersion(),"submission-states-dispatch-rejected",Decision.REJECTED,"核对调度")));
+            var rejected=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submitted.recordVersion(),"submission-states-dispatch-rejected",Decision.REJECTED,"核对调度",null)));
             assertSubmissionGate(f,created.dispatchNo(),ReviewState.DISPATCH_REJECTED,true);
             var resubmitted=f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(rejected.recordVersion(),"submission-states-2",null)));
-            var approved=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(resubmitted.recordVersion(),"submission-states-dispatch-approved",Decision.APPROVED,null)));
+            var approved=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(resubmitted.recordVersion(),"submission-states-dispatch-approved",Decision.APPROVED,null,null)));
             assertSubmissionGate(f,created.dispatchNo(),ReviewState.LOADING_PENDING,false);
-            var loadingRejected=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(approved.recordVersion(),"submission-states-loading-rejected",Decision.REJECTED,"核对装载")));
+            var loadingRejected=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(approved.recordVersion(),"submission-states-loading-rejected",Decision.REJECTED,"核对装载",null)));
             assertSubmissionGate(f,created.dispatchNo(),ReviewState.LOADING_REJECTED,true);
             f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(loadingRejected.recordVersion(),"submission-states-3",null)));
             assertSubmissionGate(f,created.dispatchNo(),ReviewState.DISPATCH_PENDING,false);
@@ -363,13 +363,13 @@ public class DispatchAggregatePersistenceTest {
         var f=new Fixture();var source=f.source(1,"101",501,"ONT8",3);
         var created=f.tx.execute(s->f.service.create(f.actor,f.configured("review-create",List.of(source))));
         var submit=f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(created.recordVersion(),"submit-1",null)));
-        assertThatThrownBy(()->f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(submit.recordVersion(),"wrong-order",Decision.APPROVED,null)))).isInstanceOf(BizException.class);
-        var rejected=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submit.recordVersion(),"reject-1",Decision.REJECTED,"补核装载计划")));
+        assertThatThrownBy(()->f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(submit.recordVersion(),"wrong-order",Decision.APPROVED,null,null)))).isInstanceOf(BizException.class);
+        var rejected=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submit.recordVersion(),"reject-1",Decision.REJECTED,"补核装载计划",null)));
         var resubmitted=f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(rejected.recordVersion(),"submit-2",null)));
-        var approved=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(resubmitted.recordVersion(),"dispatch-approved",Decision.APPROVED,null)));
-        var loading=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(approved.recordVersion(),"loading-approved",Decision.APPROVED,null)));
+        var approved=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(resubmitted.recordVersion(),"dispatch-approved",Decision.APPROVED,null,null)));
+        var loading=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(approved.recordVersion(),"loading-approved",Decision.APPROVED,null,null)));
         assertThat(loading.stage()).isEqualTo(Stage.LOADING);
-        var replay=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submit.recordVersion(),"reject-1",Decision.REJECTED,"补核装载计划")));
+        var replay=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submit.recordVersion(),"reject-1",Decision.REJECTED,"补核装载计划",null)));
         assertThat(replay.replayed()).isTrue();assertThat(replay.stage()).isEqualTo(Stage.BEFORE_LOADING);assertThat(replay.recordVersion()).isEqualTo(rejected.recordVersion());
         var returned=f.tx.execute(s->f.service.returnToReview(f.actor,created.dispatchNo(),new DispatchCommands.ReturnToReview(loading.recordVersion(),"return-zero","重新核实资源")));
         assertThat(returned.stage()).isEqualTo(Stage.BEFORE_LOADING);
@@ -419,12 +419,13 @@ public class DispatchAggregatePersistenceTest {
         assertThat(f.db.queryForList("SELECT DISTINCT customer_id FROM ll_dispatch_item ORDER BY customer_id",String.class)).containsExactly("101","202");
         assertThat(f.db.queryForObject("SELECT COUNT(DISTINCT dispatch_order_id) FROM ll_dispatch_item",Long.class)).isOne();
         assertThat(f.db.queryForObject("SELECT package_count FROM ll_fleet_trip_dispatch",Integer.class)).isEqualTo(8);
-        var query=new DispatchViews.Query(1,20,null,null,null,"101",null,StatusFilter.ACTIVE,Stage.BEFORE_LOADING,BeforeLoadingSection.DISPATCH_REVIEW,ReviewStatus.NOT_SUBMITTED);
+        var query=new DispatchViews.Query(1,20,null,null,null,"101",null,StatusFilter.ACTIVE,Stage.BEFORE_LOADING,BeforeLoadingSection.VEHICLE_INFO,null);
         var page=f.tx.execute(s->f.service.page(f.actor,query));
         assertThat(page.total()).isOne(); assertThat(page.records()).hasSize(1);
         assertThat(page.records().get(0).counts().packageCount()).isEqualTo(8);
         assertThat(page.statistics().activeTotal()).isOne(); assertThat(page.statistics().stageCounts().get(Stage.BEFORE_LOADING)).isOne();
-        assertThat(page.statistics().beforeLoadingReviewCounts().dispatchReview().notSubmitted()).isOne();
+        assertThat(page.statistics().beforeLoadingReviewCounts().vehicleInfoTotal()).isOne();
+        assertThat(page.statistics().beforeLoadingReviewCounts().dispatchReview().notSubmitted()).isZero();
 
         long dispatch=f.db.queryForObject("SELECT id FROM ll_dispatch_order",Long.class);
         long item=f.db.queryForObject("SELECT id FROM ll_dispatch_item WHERE customer_id='101'",Long.class);
@@ -597,8 +598,8 @@ public class DispatchAggregatePersistenceTest {
         /** 通过实际两级流程进入装车，测试不直接伪造通过状态。 */
         public DispatchContracts.CommandResult approve(DispatchContracts.CommandResult created) {
             var submitted=tx.execute(s->service.submitReview(actor,created.dispatchNo(),new DispatchCommands.SubmitReview(created.recordVersion(),created.dispatchNo()+"-submit",null)));
-            var reviewed=tx.execute(s->service.review(actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submitted.recordVersion(),created.dispatchNo()+"-dispatch",Decision.APPROVED,null)));
-            return tx.execute(s->service.review(actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(reviewed.recordVersion(),created.dispatchNo()+"-loading",Decision.APPROVED,null)));
+            var reviewed=tx.execute(s->service.review(actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submitted.recordVersion(),created.dispatchNo()+"-dispatch",Decision.APPROVED,null,null)));
+            return tx.execute(s->service.review(actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(reviewed.recordVersion(),created.dispatchNo()+"-loading",Decision.APPROVED,null,null)));
         }
         /** 只为实载端口夹具准备真实扫码/归属记录，不声称运行库存命令。 */
         public void picked(long source,String customer,long pallet,int packages) {

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/service/DispatchExceptionPersistenceTest.java

@@ -0,0 +1,89 @@
+package com.baiyue.lastleg.dispatch.service;
+
+import com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway;
+import com.baiyue.lastleg.dispatch.port.DispatchCommands;
+import com.baiyue.lastleg.dispatch.port.DispatchContracts;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.security.authentication.TestingAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.test.util.ReflectionTestUtils;
+import java.util.List;
+import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+/** 通过真实Mapper和事务验证异常登记，不把登记事实解释成签收或退货。 */
+class DispatchExceptionPersistenceTest {
+    /** 登记使用排车独立维护权限。 */
+    @BeforeEach void authorize() { SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("operator-test","","platform:overseas-warehouse:dispatch:edit")); }
+    /** 清除线程身份，避免影响其他权限回归。 */
+    @AfterEach void clear() { SecurityContextHolder.clearContext(); }
+
+    /** 每种原型类型均可保存，原键重试不追加，最终完成后仍恢复原结果。 */
+    @Test void recordsAllTypesAndReplaysWithoutChangingDeliveryFacts() throws Exception {
+        var f=new DispatchAggregatePersistenceTest.Fixture();var no=create(f);long version=0;
+        var before=f.db.queryForMap("SELECT stage,shipped_package_count,departed_at,review_state FROM ll_dispatch_order");
+        for(var type:ExceptionType.values()) {
+            var body=new DispatchCommands.MarkException(version,"exception-"+type,type,ReturnDirection.OVERSEAS_WAREHOUSE,"真实异常",List.of());
+            var saved=f.tx.execute(t->f.service.markException(f.actor,no,body));
+            var replay=f.tx.execute(t->f.service.markException(f.actor,no,body));
+            assertThat(saved.stage()).isEqualTo(Stage.DELIVERING);assertThat(replay.replayed()).isTrue();
+            assertThat(replay.recordVersion()).isEqualTo(saved.recordVersion());version=saved.recordVersion();
+        }
+        var records=f.service.detail(f.actor,no).dispatchInfo().exceptions();assertThat(records).hasSize(3);
+        assertThat(records).allSatisfy(r->{assertThat(r.description()).isEqualTo("真实异常");assertThat(r.occurredAt()).isNotNull();});
+        assertThat(f.db.queryForMap("SELECT stage,shipped_package_count,departed_at,review_state FROM ll_dispatch_order")).isEqualTo(before);
+        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_inventory_ledger",Long.class)).isZero();
+        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_history WHERE action='MARK_EXCEPTION'",Long.class)).isEqualTo(3);
+        var first=new DispatchCommands.MarkException(0L,"exception-REFUSED",ExceptionType.REFUSED,ReturnDirection.OVERSEAS_WAREHOUSE,"真实异常",List.of());
+        f.db.update("UPDATE ll_dispatch_order SET stage='DELIVERED'");
+        assertThat(f.tx.execute(t->f.service.markException(f.actor,no,first)).replayed()).isTrue();
+        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,new DispatchCommands.MarkException(0L,"exception-REFUSED",ExceptionType.REFUSED,null,"改了内容",List.of())))).isInstanceOf(RuntimeException.class);
+        assertThat(f.service.detail(f.actor,no).dispatchInfo().exceptions()).hasSize(3);
+    }
+
+    /** 非派送阶段、过期版本、只读身份、PDA及运输任务不能登记。 */
+    @Test void rejectsWrongStageVersionPermissionAndTask() throws Exception {
+        var f=new DispatchAggregatePersistenceTest.Fixture();var no=create(f);var body=request(0,"blocked",List.of());
+        for(var stage:List.of("BEFORE_LOADING","LOADING","AFTER_LOADING","DELIVERED")) {
+            f.db.update("UPDATE ll_dispatch_order SET stage=?",stage);
+            assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,body))).hasMessageContaining("仅派送中");
+        }
+        f.db.update("UPDATE ll_dispatch_order SET stage='DELIVERING'");
+        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,request(9,"stale",List.of())))).hasMessageContaining("版本");
+        SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("operator-test","","platform:overseas-warehouse:dispatch:list"));
+        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,body))).hasMessageContaining("权限");
+        authorize();f.db.update("UPDATE ll_dispatch_order SET task_type='LOCAL_TRUCK'");
+        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,body))).hasMessageContaining("仅派送中");
+        f.db.update("UPDATE ll_dispatch_order SET task_type='DELIVERY',status='CANCELLED'");
+        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,body))).hasMessageContaining("仅派送中");
+        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(new DispatchContracts.Actor("pda",ActorMode.PDA,"9"),no,body))).hasMessageContaining("仅平台");
+        assertThat(f.db.queryForObject("SELECT record_version FROM ll_dispatch_order",Long.class)).isZero();
+    }
+
+    /** 图片严格核对当前车和类别；附件失败或缺类型不保存任何业务记录。 */
+    @Test void verifiesImageOwnershipAndKeepsFailedRequestUnchanged() throws Exception {
+        var f=new DispatchAggregatePersistenceTest.Fixture();var no=create(f);var id=f.repository.find(no).getId();
+        var files=mock(DispatchEvidenceGateway.class);ReflectionTestUtils.setField(f.service,"evidence",files);
+        when(files.metadata(id,DispatchEvidenceGateway.Kind.EXCEPTION,91L)).thenThrow(new IllegalArgumentException("文件不属于当前车"));
+        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,request(0,"files",List.of(91L))))).hasMessageContaining("不属于");
+        assertThat(f.service.detail(f.actor,no).dispatchInfo().exceptions()).isEmpty();
+        var missingType=new DispatchCommands.MarkException(0L,"no-type",null,null,null,List.of());
+        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,missingType))).hasMessageContaining("请选择异常类型");
+        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,request(0,"duplicates",List.of(91L,91L))))).hasMessageContaining("图片引用");
+        doReturn(new DispatchEvidenceGateway.File(91L,"现场.png","image/png",10L)).when(files).metadata(id,DispatchEvidenceGateway.Kind.EXCEPTION,91L);
+        f.tx.execute(t->f.service.markException(f.actor,no,request(0,"files",List.of(91L))));
+        assertThat(f.service.detail(f.actor,no).dispatchInfo().exceptions().get(0).imageFileIds()).containsExactly(91L);
+        verify(files,times(2)).metadata(id,DispatchEvidenceGateway.Kind.EXCEPTION,91L);
+    }
+
+    /** 创建真实排车后仅以SQL模拟已发车前置，不声称此用例执行装车流程。 */
+    private String create(DispatchAggregatePersistenceTest.Fixture f) {
+        var created=f.tx.execute(t->f.service.create(f.actor,f.configured("create",List.of())));
+        f.db.update("UPDATE ll_dispatch_order SET stage='DELIVERING',shipped_package_count=3,departed_at=CURRENT_TIMESTAMP");return created.dispatchNo();
+    }
+    /** 构造类型必填、其余选填的最小登记请求。 */
+    private DispatchCommands.MarkException request(long version,String key,List<Long> images) { return new DispatchCommands.MarkException(version,key,ExceptionType.VEHICLE_EXCEPTION,null,null,images); }
+}

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/service/DispatchLoadingDeparturePersistenceTest.java

@@ -0,0 +1,144 @@
+package com.baiyue.lastleg.dispatch.service;
+
+import com.baiyue.lastleg.dispatch.mapper.*;
+import com.baiyue.lastleg.dispatch.pda.service.DispatchPdaWorkflowService;
+import com.baiyue.lastleg.dispatch.port.*;
+import com.baiyue.lastleg.dispatch.repository.*;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.springframework.security.authentication.TestingAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.util.*;
+import java.util.concurrent.*;
+import static com.baiyue.lastleg.dispatch.port.DispatchContracts.*;
+import static com.baiyue.lastleg.dispatch.port.DispatchDeliveryModels.*;
+import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import static org.mockito.ArgumentMatchers.*;
+
+/** 装完即发车的共同事务、原键最终结果及跨端竞争使用真实根单据和版本。 */
+class DispatchLoadingDeparturePersistenceTest {
+    /** 每例恢复隔离身份，不影响其他服务权限测试。 */
+    @AfterEach void clearSecurity(){SecurityContextHolder.clearContext();}
+
+    /** 一次确认完成全部客户发运；原键重放返回派送中，不再生成子单或执行来源。 */
+    @Test void loadingCompletesAllCustomersAndReplaysOnlyFinalResult() throws Exception {
+        authorize();var f=new Fixture();
+        var result=f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("complete")));
+        assertThat(result.action()).isEqualTo(Action.LOADING_COMPLETE);assertThat(result.stage()).isEqualTo(Stage.DELIVERING);
+        assertThat(result.counts().shippedPackageCount()).isEqualTo(8);assertThat(result.result()).isInstanceOf(DispatchResults.Loaded.class);
+        assertThat(f.f.db.queryForList("SELECT status FROM ll_outbound_order",String.class)).containsExactly("OUTBOUNDED","OUTBOUNDED");
+        assertThat(f.f.db.queryForList("SELECT status FROM ll_delivery_order",String.class)).containsExactly("DELIVERING","DELIVERING");
+        assertThat(f.f.db.queryForObject("SELECT status FROM ll_fleet_trip",String.class)).isEqualTo("IN_TRANSIT");
+        assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_pda_pick",Long.class)).isEqualTo(2);
+        assertThat(f.f.db.queryForObject("SELECT result_json FROM ll_dispatch_command WHERE idempotency_key='complete'",String.class)).contains("DELIVERING");
+        var replay=f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("complete")));
+        assertThat(replay.replayed()).isTrue();assertThat(replay.recordVersion()).isEqualTo(result.recordVersion());assertThat(replay.result()).isEqualTo(result.result());
+        assertThat(f.f.tx.execute(s->f.f.service.command(f.f.actor,f.number,"complete")).stage()).isEqualTo(Stage.DELIVERING);
+        verify(f.delivery,times(1)).prepareForDeparture(any(),any(),anyString());verify(f.sourceWorkflow,times(1)).departWholeSources(any(),any(),any(),any());
+        assertThat(f.f.service.actions(f.f.actor,f.f.repository.find(f.number))).doesNotContainKeys(Action.ARRANGE_DELIVERY,Action.DEPART);
+        assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("stale-new")))).hasMessageContaining("版本或审核阶段");
+    }
+
+    /** 任一后续步骤失败都恢复装车中，已提交的真实拣货保持，不留下中间装车或子单。 */
+    @Test void preparationAndDepartureFailuresRollBackTheEntireLoadingCommand() throws Exception {
+        authorize();
+        for(boolean failPreparation:List.of(true,false)) {
+            var f=new Fixture();
+            if(failPreparation)doThrow(new IllegalStateException("模拟单据准备失败")).when(f.delivery).prepareForDeparture(any(),any(),anyString());
+            else doThrow(new IllegalStateException("模拟来源发运失败")).when(f.sourceWorkflow).departWholeSources(any(),any(),any(),any());
+            assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("failed")))).isInstanceOf(IllegalStateException.class);
+            var row=f.f.repository.find(f.number);assertThat(row.getStage()).isEqualTo("LOADING");assertThat(row.getRecordVersion()).isEqualTo(f.version);
+            assertThat(row.getLoadingCompletionHash()).isNull();assertThat(row.getArrangementKey()).isNull();assertThat(row.getDepartedAt()).isNull();
+            assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_outbound_order",Long.class)).isZero();
+            assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_delivery_order",Long.class)).isZero();
+            assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_command WHERE action IN ('LOADING_COMPLETE','ARRANGE_DELIVERY','DEPART')",Long.class)).isZero();
+            assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_pda_pick",Long.class)).isEqualTo(2);
+            assertThat(f.f.db.queryForObject("SELECT status FROM ll_fleet_trip",String.class)).isEqualTo("PLANNED");
+        }
+    }
+
+    /** PDA保持本仓权限、原键权限复验；不借自动流程绕开真实装载清单。 */
+    @Test void pdaUsesOnePermissionButRejectsOtherWarehouseAndInvalidEvidence() throws Exception {
+        authorize();var f=new Fixture();var pda=new Actor("picker",ActorMode.PDA,"9");
+        assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(new Actor("picker",ActorMode.PDA,"99"),f.number,f.request("foreign")))).hasMessageContaining("当前绑定仓");
+        var bad=new DispatchCommands.LoadingComplete(f.version,"bad-manifest","changed",f.measurements,null);
+        assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(pda,f.number,bad))).hasMessageContaining("真实装载清单已变化");
+        verify(f.delivery,never()).prepareForDeparture(any(),any(),anyString());
+        var result=f.f.tx.execute(s->f.service.complete(pda,f.number,f.request("pda")));assertThat(result.stage()).isEqualTo(Stage.DELIVERING);
+        SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("picker","","ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR"));
+        assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(pda,f.number,f.request("pda")))).hasMessageContaining("装车完成权限");
+    }
+
+    /** 同一版本后台/PDA同时确认只有一条完整链提交，不会产生半车或重复派送。 */
+    @Test void concurrentAdminAndPdaCompleteOnlyOneDeparture() throws Exception {
+        authorize();var f=new Fixture();var start=new CountDownLatch(1);var workers=Executors.newFixedThreadPool(2);
+        try {
+            var a=workers.submit(()->f.tryComplete(start,f.f.actor,"admin"));
+            var b=workers.submit(()->f.tryComplete(start,new Actor("picker",ActorMode.PDA,"9"),"pda"));
+            start.countDown();assertThat(List.of(a.get(25,TimeUnit.SECONDS),b.get(25,TimeUnit.SECONDS))).containsExactlyInAnyOrder(true,false);
+        } finally {workers.shutdownNow();}
+        assertThat(f.f.repository.find(f.number).getStage()).isEqualTo("DELIVERING");
+        verify(f.delivery,times(1)).prepareForDeparture(any(),any(),anyString());verify(f.sourceWorkflow,times(1)).departWholeSources(any(),any(),any(),any());
+    }
+
+    /** 仅配置装车完成及PDA既有角色权限，不授予人工派送、发车权限。 */
+    private static void authorize(){SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("operator","",
+        "platform:overseas-warehouse:dispatch:loading-complete","lastleg:pda:operate","ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR"));}
+
+    /** 主流程与发车使用真实SQL，派送提供者受控写入真实子单来验证共同回滚。 */
+    private static final class Fixture {
+        final DispatchAggregatePersistenceTest.Fixture f=new DispatchAggregatePersistenceTest.Fixture();
+        final DispatchDeliveryPort delivery=mock(DispatchDeliveryPort.class);
+        final DispatchPdaWorkflowService sourceWorkflow=mock(DispatchPdaWorkflowService.class);
+        final DispatchLoadingDepartureService service;final String number;final long version;final String manifest;
+        final List<LoadingMeasurement> measurements;
+        /** 创建两客户货物并走真实两级审核、真实拣货归属，不伪造已装车状态。 */
+        Fixture() throws Exception {
+            var created=f.tx.execute(s->f.service.create(f.actor,f.configured("create",List.of(f.source(1,"101",501,"ONT8",3),f.source(2,"202",502,"LAX9",5)))));
+            number=created.dispatchNo();version=f.approve(created).recordVersion();
+            f.picked(1,"101",501,3);f.picked(2,"202",502,5);f.db.update("UPDATE ll_dispatch_order SET picked_package_count=8");
+            f.db.execute("ALTER TABLE ll_order ADD detained INT DEFAULT 0");
+            var preview=f.tx.execute(s->f.service.loading(f.actor,number));manifest=preview.manifestHash();
+            measurements=preview.pallets().stream().map(p->new LoadingMeasurement(p.warehousePalletId(),1,BigDecimal.ONE,BigDecimal.ONE,p.deliveryIndex())).toList();
+            when(delivery.prepareForDeparture(any(),any(),anyString())).thenAnswer(call->{
+                Context c=call.getArgument(0);assertThat(c.stage()).isEqualTo(Stage.AFTER_LOADING);
+                var os=outbounds("WAIT_OUTBOUND");var ds=deliveries(c,"WAIT_DELIVERY");
+                for(int n=0;n<os.size();n++) {
+                    var o=os.get(n);var d=ds.get(n);
+                    f.db.update("INSERT INTO ll_outbound_order(id,customer_id,dispatch_order_id,outbound_no,status,package_count)VALUES(?,?,?,?,?,?)",6001+n,o.customerId(),c.dispatchId(),o.outboundNo(),o.status(),o.packageCount());
+                    f.db.update("INSERT INTO ll_delivery_order(id,customer_id,dispatch_order_id,outbound_order_id,outbound_no,delivery_no,status,package_count)VALUES(?,?,?,?,?,?,?,?)",7001+n,o.customerId(),c.dispatchId(),6001+n,o.outboundNo(),d.deliveryNo(),d.status(),d.packageCount());
+                }
+                return new ArrangementFact("AUTO-ARR","business-hash",c.cargoHash(),c.loadingCompletionHash(),new ArrangementResult(number,c.recordVersion()+1,"AUTO-ARR",c.cargoHash(),Instant.now(),os,ds));
+            });
+            when(delivery.departureFacts(any(),eq(true))).thenAnswer(call->{
+                Context c=call.getArgument(0);f.db.queryForList("SELECT id FROM ll_outbound_order ORDER BY id FOR UPDATE");f.db.queryForList("SELECT id FROM ll_delivery_order ORDER BY id FOR UPDATE");
+                return new DepartureFacts(number,"AUTO-ARR",c.cargoHash(),c.loadingCompletionHash(),"business-hash",outbounds("WAIT_OUTBOUND"),deliveries(c,"WAIT_DELIVERY"),c.cargo(),new Gate(true,null,null));
+            });
+            when(delivery.markDeparted(any(),any(),any(),anyString())).thenAnswer(call->{
+                Context c=call.getArgument(0);f.db.update("UPDATE ll_outbound_order SET status='OUTBOUNDED'");f.db.update("UPDATE ll_delivery_order SET status='DELIVERING'");
+                return new DepartureResult(outbounds("OUTBOUNDED"),deliveries(c,"DELIVERING"),8);
+            });
+            var ledger=new DispatchCommandLedger(new DispatchCommandRepository(f.session.getMapper(DispatchCommandMapper.class)),new DispatchCommandCodec(f.json));
+            var hashes=new DispatchCommandHasher(f.json);
+            var sources=new DispatchSourceRepository(mock(DispatchCandidateMapper.class),mock(ReturnDispatchCandidateMapper.class),f.session.getMapper(DispatchSourceMapper.class));
+            var departure=new DispatchDepartureService(f.service,f.repository,sources,delivery,sourceWorkflow,f.fleet,ledger,hashes,f.json);
+            service=new DispatchLoadingDepartureService(f.service,delivery,departure,ledger,hashes);
+        }
+        /** 每次请求沿用最初真实测量和版本，便于验证竞争及原键恢复。 */
+        DispatchCommands.LoadingComplete request(String key){return new DispatchCommands.LoadingComplete(version,key,manifest,measurements,"实装发车");}
+        /** 两客户子出库保持独立业务号和箱数。 */
+        List<OutboundReference> outbounds(String status){return List.of(new OutboundReference("101","客户101","OUT-A",status,3,1),new OutboundReference("202","客户202","OUT-B",status,5,1));}
+        /** 两目的地仍对应各自真实客户，不把整车合并为单客户。 */
+        List<DeliveryReference> deliveries(Context c,String status){return List.of(new DeliveryReference("GA","101","客户101","OUT-A","DL-A",c.cargo().get(0).destination(),status,3,1),new DeliveryReference("GB","202","客户202","OUT-B","DL-B",c.cargo().get(1).destination(),status,5,1));}
+        /** 各线程独立身份和数据库事务竞争同一整车父锁。 */
+        boolean tryComplete(CountDownLatch start,Actor actor,String key) throws Exception {
+            authorize();try {start.await(5,TimeUnit.SECONDS);f.tx.execute(s->service.complete(actor,number,request(key)));return true;}
+            catch(com.baiyue.common.core.exception.BizException expected){return false;}
+            finally {SecurityContextHolder.clearContext();}
+        }
+    }
+}

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/service/DispatchPdaReadPersistenceTest.java

@@ -13,6 +13,32 @@ import static org.assertj.core.api.Assertions.*;
 
 /** 统一PDA读取实际多客户主单和逐项扫码，仓限制在SQL完成。 */
 class DispatchPdaReadPersistenceTest {
+    /** 默认PDA待办包含已通过调度的待理货整车，资源取同一冻结快照。 */
+    @Test void pendingTallyReviewIsVisibleWithResourcesButDraftAndRejectedAreNot() throws Exception {
+        var security=org.springframework.security.core.context.SecurityContextHolder.getContext();var previous=security.getAuthentication();
+        security.setAuthentication(new org.springframework.security.authentication.TestingAuthenticationToken("picker","","lastleg:pda:operate","ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR"));
+        try {
+            var f=new DispatchAggregatePersistenceTest.Fixture();
+            var created=f.tx.execute(s->f.service.create(f.actor,f.configured("pending-read",List.of(f.source(1,"101",501,"ONT8",3)))));
+            f.db.execute("CREATE TABLE ll_inventory_position(id BIGINT,customer_id VARCHAR(64),balance_id BIGINT,pallet_id BIGINT,overseas_warehouse_id VARCHAR(64),available_packages BIGINT,hold_packages BIGINT,allocated_packages BIGINT,picked_packages BIGINT)");
+            var config=new MybatisConfiguration();config.setMapUnderscoreToCamelCase(true);config.addMapper(DispatchWholePdaReadMapper.class);
+            var factory=new MybatisSqlSessionFactoryBean();factory.setDataSource(f.db.getDataSource());factory.setConfiguration(config);factory.afterPropertiesSet();
+            var queries=new DispatchPdaQueryService(new DispatchPdaReadRepository(new SqlSessionTemplate(factory.getObject()).getMapper(DispatchWholePdaReadMapper.class)),f.service);
+            var actor=new DispatchContracts.Actor("picker",ActorMode.PDA,"9");
+            assertThat(f.tx.<List<DispatchViews.PdaTask>>execute(s->queries.list(actor,null))).isEmpty();
+            var submitted=f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(created.recordVersion(),"submit",null)));
+            assertThat(f.tx.<List<DispatchViews.PdaTask>>execute(s->queries.list(actor,null))).isEmpty();
+            var approved=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submitted.recordVersion(),"dispatch",Decision.APPROVED,null,null)));
+            var list=f.tx.execute(s->queries.list(actor,null));assertThat(list).hasSize(1);
+            var task=list.get(0);assertThat(task.stage()).isEqualTo(Stage.BEFORE_LOADING);
+            assertThat(task.actions().get(Action.LOADING_REVIEW).allowed()).isTrue();assertThat(task.actions().get(Action.PICK).allowed()).isFalse();
+            assertThat(task.resources().vehicle().plate()).isEqualTo("TEST-TRUCK");assertThat(task.resources().driver().name()).isEqualTo("测试司机");
+            f.tx.execute(s->f.service.review(actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(approved.recordVersion(),"tally-reject",Decision.REJECTED,"车辆不符",null)));
+            assertThat(f.tx.<List<DispatchViews.PdaTask>>execute(s->queries.list(actor,null))).isEmpty();
+            assertThat(f.tx.execute(s->queries.task(actor,created.dispatchNo())).reviews().loadingReview().reason()).isEqualTo("车辆不符");
+        } finally {security.setAuthentication(previous);}
+    }
+
     /** 同仓两个客户、两个目的地只返回一个整车作业，别仓不能借单号读取。 */
     @Test void readsOneTruckAcrossCustomersAndRejectsOtherWarehouseNumber() throws Exception {
         var f=new DispatchAggregatePersistenceTest.Fixture();var a=f.source(1,"101",501,"ONT8",3);var b=f.source(2,"202",502,"LAX9",5);

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/service/DispatchRegionalCandidatesTest.java

@@ -0,0 +1,47 @@
+package com.baiyue.lastleg.dispatch.service;
+
+import com.baiyue.lastleg.dispatch.mapper.DispatchCandidatePageMapper;
+import com.baiyue.lastleg.dispatch.port.DispatchContracts.Actor;
+import com.baiyue.lastleg.dispatch.port.DispatchPlanningModels.CandidateQuery;
+import com.baiyue.lastleg.dispatch.port.DispatchTypes.ActorMode;
+import org.apache.ibatis.session.Configuration;
+import org.junit.jupiter.api.Test;
+import org.springframework.test.util.ReflectionTestUtils;
+import java.util.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+/** 区域候选的读取范围与单仓写入职责分离，不依赖测试环境数据。 */
+class DispatchRegionalCandidatesTest {
+    /** 真实服务接受不指定仓的三种区域，保留服务端分页总数；非法仓和区域仍拒绝。 */
+    @Test void serviceAcceptsRegionalQueriesAndRejectsMalformedScopes() {
+        var sources=mock(DispatchService.class);var appointments=mock(DispatchAppointmentAllocations.class);
+        var service=new DispatchAggregateService(null,null,sources,null,null,null,new com.fasterxml.jackson.databind.ObjectMapper());
+        ReflectionTestUtils.setField(service,"appointments",appointments);
+        var actor=new Actor("7",ActorMode.PLATFORM,null);
+        when(sources.candidatePage(eq("7"),any())).thenReturn(new DispatchService.CandidatePage(List.of(),41));
+        when(sources.selectionGroups(List.of())).thenReturn(Map.of());when(appointments.candidates(List.of())).thenReturn(Map.of());
+        for(String tab:List.of("ALL","LAX","NYC")) {
+            var query=new CandidateQuery(null,null,null,null,null,null,2,20,tab);
+            var result=service.candidates(actor,query);
+            assertThat(result.total()).isEqualTo(41);assertThat(result.page()).isEqualTo(2);assertThat(result.pages()).isEqualTo(3);
+            verify(sources).candidatePage("7",query);
+        }
+        assertThatThrownBy(()->service.candidates(actor,new CandidateQuery("bad",null,null,null,null,null,1,20,"ALL"))).hasMessageContaining("起运仓筛选无效");
+        assertThatThrownBy(()->service.candidates(actor,new CandidateQuery(null,null,null,null,null,null,1,20,"bad"))).hasMessageContaining("仓库页签不合法");
+    }
+    /** 解析实际Mapper动态SQL，统计和分页采用相同区域条件，单仓消费者继续绑定真实仓。 */
+    @Test void countAndPageUseOptionalWarehouseAndTheSameRegionPredicate() {
+        var config=new Configuration();config.addMapper(DispatchCandidatePageMapper.class);
+        for(String method:List.of("count","page")) for(String tab:List.of("ALL","LAX","NYC")) for(String warehouse:List.of("ALL_WAREHOUSES","321")) {
+            var query=new CandidateQuery(warehouse.equals("321")?warehouse:null,null,null,null,null,null,1,20,tab);
+            var sql=config.getMappedStatement(DispatchCandidatePageMapper.class.getName()+"."+method).getBoundSql(Map.of("query",query,"offset",0)).getSql();
+            if(query.warehouseId()==null)assertThat(sql).doesNotContain("overseasWarehouseId=?");
+            else assertThat(sql).contains("overseasWarehouseId=?");
+            if(tab.equals("LAX"))assertThat(sql).contains("REGEXP 'lax|洛杉矶|los angeles'");
+            if(tab.equals("NYC"))assertThat(sql).contains("REGEXP 'nyc|jfk|");
+            if(tab.equals("ALL"))assertThat(sql).doesNotContain("REGEXP 'lax|", "REGEXP 'nyc|");
+            if(method.equals("page"))assertThat(sql).contains("LIMIT ? OFFSET ?");
+        }
+    }
+}

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/service/DispatchReviewAttachmentsPersistenceTest.java

@@ -0,0 +1,104 @@
+package com.baiyue.lastleg.dispatch.service;
+
+import com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway;
+import com.baiyue.lastleg.dispatch.port.*;
+import org.junit.jupiter.api.Test;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.security.authentication.TestingAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.test.util.ReflectionTestUtils;
+import java.util.List;
+import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+/** 审核附件以真实Mapper保存并随审核轮次流转，不能改写车辆和司机资源。 */
+class DispatchReviewAttachmentsPersistenceTest {
+    /** 两级附件随决定保存，理货驳回与客服改货保留证据，重提清当前但历史不丢。 */
+    @Test void attachmentsSurviveRejectionAndEditsUntilResubmission() throws Exception {
+        var f=new DispatchAggregatePersistenceTest.Fixture();
+        var created=f.tx.execute(s->f.service.create(f.actor,f.configured("review-evidence",List.of(f.source(1,"101",501,"ONT8",3)))));
+        var submitted=f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(created.recordVersion(),"submit",null)));
+        var before=f.repository.find(created.dispatchNo()).getResourcesJson();
+        var first=new DispatchContracts.ReviewAttachments(List.of(91L),List.of(92L),List.of(93L));
+        var request=new DispatchCommands.ReviewCommand(submitted.recordVersion(),"dispatch",Decision.APPROVED,null,first);
+        var approved=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,request));
+        assertThat(f.service.detail(f.actor,created.dispatchNo()).reviews().dispatchReview().attachments()).isEqualTo(first);
+        assertThat(f.repository.find(created.dispatchNo()).getResourcesJson()).isEqualTo(before);
+        var second=new DispatchContracts.ReviewAttachments(List.of(94L),List.of(95L),List.of(96L));
+        var rejected=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(approved.recordVersion(),"reject",Decision.REJECTED,"照片不清晰",second)));
+        var reviews=f.service.detail(f.actor,created.dispatchNo()).reviews();
+        assertThat(reviews.dispatchReview().status()).isEqualTo(ReviewStatus.NOT_SUBMITTED);
+        assertThat(reviews.dispatchReview().attachments()).isEqualTo(first);
+        assertThat(reviews.loadingReview().attachments()).isEqualTo(second);
+        var changed=f.tx.execute(s->f.service.addCargo(f.actor,created.dispatchNo(),new DispatchCommands.AddCargo(rejected.recordVersion(),"cargo",List.of(f.source(2,"101",502,"ONT8",2)),List.of())));
+        reviews=f.service.detail(f.actor,created.dispatchNo()).reviews();
+        assertThat(reviews.dispatchReview().attachments()).isEqualTo(first);
+        assertThat(reviews.loadingReview().attachments()).isEqualTo(second);
+        assertThat(reviews.loadingReview().reason()).isEqualTo("照片不清晰");
+        f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(changed.recordVersion(),"resubmit",null)));
+        reviews=f.service.detail(f.actor,created.dispatchNo()).reviews();
+        assertThat(reviews.dispatchReview().attachments()).isEqualTo(DispatchContracts.ReviewAttachments.empty());
+        assertThat(reviews.loadingReview().attachments()).isEqualTo(DispatchContracts.ReviewAttachments.empty());
+        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_history WHERE snapshot_json LIKE '%driverPhotoFileIds%92%'",Long.class)).isPositive();
+        assertThat(f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,request)).replayed()).isTrue();
+        assertThatThrownBy(()->f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submitted.recordVersion(),"dispatch",Decision.APPROVED,null,second)))).hasMessageContaining("原请求标识");
+    }
+
+    /** 拒绝也逐文件核验本车分类；错误归属不提交状态和版本。 */
+    @Test void rejectsForeignKindOrMasterLicenseAndKeepsOriginalVersion() throws Exception {
+        var f=new DispatchAggregatePersistenceTest.Fixture();
+        var created=f.tx.execute(s->f.service.create(f.actor,f.configured("verify-evidence",List.of(f.source(1,"101",501,"ONT8",3)))));
+        var submitted=f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(created.recordVersion(),"submit",null)));
+        var gateway=(DispatchEvidenceGateway)ReflectionTestUtils.getField(f.service,"evidence");
+        long id=f.repository.find(created.dispatchNo()).getId();
+        var attachments=new DispatchContracts.ReviewAttachments(List.of(91L),List.of(92L),List.of(93L));
+        doThrow(new IllegalArgumentException("本车分类归属不匹配")).when(gateway).metadata(id,DispatchEvidenceGateway.Kind.DRIVER,93L);
+        assertThatThrownBy(()->f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submitted.recordVersion(),"bad",Decision.REJECTED,"需补资料",attachments)))).hasMessageContaining("归属不匹配");
+        verify(gateway).metadata(id,DispatchEvidenceGateway.Kind.VEHICLE,91L);
+        verify(gateway).metadata(id,DispatchEvidenceGateway.Kind.DRIVER_PHOTO,92L);
+        verify(gateway).metadata(id,DispatchEvidenceGateway.Kind.DRIVER,93L);
+        assertThat(f.repository.find(created.dispatchNo()).getRecordVersion()).isEqualTo(submitted.recordVersion());
+        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_command WHERE idempotency_key='bad'",Long.class)).isZero();
+    }
+
+    /** 只有当前待审角色能上传；维护权限不能替代审核资格，上传不变更版本和依据。 */
+    @Test void uploadUsesCurrentReviewAuthorityWithoutEditAndDoesNotMutateAggregate() throws Exception {
+        var security=SecurityContextHolder.getContext();var prior=security.getAuthentication();
+        try {
+            var f=new DispatchAggregatePersistenceTest.Fixture();
+            var created=f.tx.execute(s->f.service.create(f.actor,f.configured("upload-evidence",List.of(f.source(1,"101",501,"ONT8",3)))));
+            var file=new MockMultipartFile("file","driver.png","image/png",new byte[]{1});
+            var kind=DispatchEvidenceGateway.Kind.DRIVER_PHOTO;
+            security.setAuthentication(new TestingAuthenticationToken("operator","","platform:fleet:trip:dispatch-review"));
+            assertThatThrownBy(()->f.service.uploadEvidence(f.actor,created.dispatchNo(),kind,file)).hasMessageContaining("无当前阶段");
+            var submitted=f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(created.recordVersion(),"submit",null)));
+            var before=f.repository.find(created.dispatchNo());
+            f.service.uploadEvidence(f.actor,created.dispatchNo(),kind,file);
+            security.setAuthentication(new TestingAuthenticationToken("operator","","platform:overseas-warehouse:dispatch:edit"));
+            assertThatThrownBy(()->f.service.uploadEvidence(f.actor,created.dispatchNo(),kind,file)).hasMessageContaining("无当前阶段");
+            var approved=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submitted.recordVersion(),"approve",Decision.APPROVED,null,null)));
+            security.setAuthentication(new TestingAuthenticationToken("operator","","platform:fleet:trip:dispatch-review"));
+            assertThatThrownBy(()->f.service.uploadEvidence(f.actor,created.dispatchNo(),kind,file)).hasMessageContaining("无当前阶段");
+            security.setAuthentication(new TestingAuthenticationToken("operator","","platform:fleet:trip:loading-review"));
+            f.service.uploadEvidence(f.actor,created.dispatchNo(),kind,file);
+            var after=f.repository.find(created.dispatchNo());
+            assertThat(after.getRecordVersion()).isEqualTo(approved.recordVersion());
+            assertThat(after.getReviewBasisHash()).isEqualTo(before.getReviewBasisHash());
+            assertThat(after.getResourcesJson()).isEqualTo(before.getResourcesJson());
+            var loaded=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(approved.recordVersion(),"load",Decision.APPROVED,null,null)));
+            assertThatThrownBy(()->f.service.uploadEvidence(f.actor,created.dispatchNo(),kind,file)).hasMessageContaining("装车前");
+        } finally {security.setAuthentication(prior);}
+    }
+
+    /** 省略附件保持PDA原输入语义，非法或过多引用在进入业务前拒绝。 */
+    @Test void optionalAttachmentShapeIsBoundedAndNormalized() throws Exception {
+        var json=new com.fasterxml.jackson.databind.ObjectMapper();
+        var request=json.readValue("{\"recordVersion\":1,\"idempotencyKey\":\"pda\",\"decision\":\"APPROVED\"}",DispatchCommands.ReviewCommand.class);
+        assertThat(request.attachments()).isEqualTo(DispatchContracts.ReviewAttachments.empty());
+        assertThatThrownBy(()->new DispatchContracts.ReviewAttachments(List.of(1L,1L),null,null)).isInstanceOf(IllegalArgumentException.class);
+        assertThatThrownBy(()->new DispatchContracts.ReviewAttachments(null,List.of(-1L),null)).isInstanceOf(IllegalArgumentException.class);
+        assertThatThrownBy(()->new DispatchContracts.ReviewAttachments(null,null,java.util.stream.LongStream.rangeClosed(1,21).boxed().toList())).isInstanceOf(IllegalArgumentException.class);
+    }
+}

lastleg-service/src/test/java/com/baiyue/lastleg/dispatch/service/DispatchReviewWorkflowPersistenceTest.java

@@ -0,0 +1,126 @@
+package com.baiyue.lastleg.dispatch.service;
+
+import com.baiyue.common.core.exception.BizException;
+import com.baiyue.lastleg.dispatch.port.*;
+import org.junit.jupiter.api.Test;
+import org.springframework.security.authentication.TestingAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import java.util.List;
+import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
+import static org.assertj.core.api.Assertions.*;
+
+/** 审核两端共用真实持久主单，驳回回客服且不能复用上一轮批准。 */
+class DispatchReviewWorkflowPersistenceTest {
+    /** 客服、调度、理货队列互斥，任一级驳回都只回客服队列。 */
+    @Test void eachReviewRejectionReturnsOnlyToCustomerServiceQueue() throws Exception {
+        var f=new DispatchAggregatePersistenceTest.Fixture();
+        var created=f.tx.execute(s->f.service.create(f.actor,f.configured("queues",List.of(f.source(1,"101",501,"ONT8",3)))));
+        assertQueue(f,created.dispatchNo(),BeforeLoadingSection.VEHICLE_INFO);
+        var submitted=submit(f,created,"submit-1");assertQueue(f,created.dispatchNo(),BeforeLoadingSection.DISPATCH_REVIEW);
+        var rejected=review(f,f.actor,submitted,false,"dispatch-reject",Decision.REJECTED,"  车辆图片不清楚  ");
+        assertQueue(f,created.dispatchNo(),BeforeLoadingSection.VEHICLE_INFO);
+        assertThat(f.service.detail(f.actor,created.dispatchNo()).reviews().dispatchReview().reason()).isEqualTo("车辆图片不清楚");
+        var resubmitted=submit(f,rejected,"submit-2");
+        var approved=review(f,f.actor,resubmitted,false,"dispatch-approve",Decision.APPROVED,null);
+        assertQueue(f,created.dispatchNo(),BeforeLoadingSection.LOADING_REVIEW);
+        var tallyRejected=review(f,f.actor,approved,true,"loading-reject",Decision.REJECTED,"司机不符");
+        assertQueue(f,created.dispatchNo(),BeforeLoadingSection.VEHICLE_INFO);
+        var detail=f.service.detail(f.actor,created.dispatchNo());
+        assertThat(detail.reviews().loadingReview().reason()).isEqualTo("司机不符");
+        assertThat(detail.reviews().dispatchReview().status()).isEqualTo(ReviewStatus.NOT_SUBMITTED);
+        assertThatThrownBy(()->review(f,f.actor,tallyRejected,true,"cannot-skip-dispatch",Decision.APPROVED,null)).hasMessageContaining("状态已变化");
+        var third=submit(f,tallyRejected,"submit-3");assertQueue(f,created.dispatchNo(),BeforeLoadingSection.DISPATCH_REVIEW);
+        detail=f.service.detail(f.actor,created.dispatchNo());
+        assertThat(detail.reviews().dispatchReview().reviewRound()).isEqualTo(3);
+        assertThat(detail.reviews().loadingReview().reason()).isNull();
+        assertThatThrownBy(()->review(f,f.actor,third,true,"cannot-skip-again",Decision.APPROVED,null)).hasMessageContaining("状态已变化");
+    }
+
+    /** 两级拒绝都须真实原因；失败不写版本、审核历史或命令结果。 */
+    @Test void blankRejectionReasonIsRejectedAtBothLevelsWithoutWrites() throws Exception {
+        var f=new DispatchAggregatePersistenceTest.Fixture();
+        var created=f.tx.execute(s->f.service.create(f.actor,f.configured("reason",List.of(f.source(1,"101",501,"ONT8",3)))));
+        var submitted=submit(f,created,"submit");
+        assertThatThrownBy(()->review(f,f.actor,submitted,false,"blank-dispatch",Decision.REJECTED," \n ")).hasMessageContaining("驳回原因不能为空");
+        assertThat(f.repository.find(created.dispatchNo()).getRecordVersion()).isEqualTo(submitted.recordVersion());
+        var approved=review(f,f.actor,submitted,false,"approve",Decision.APPROVED,null);
+        assertThatThrownBy(()->review(f,f.actor,approved,true,"blank-loading",Decision.REJECTED,null)).hasMessageContaining("驳回原因不能为空");
+        assertThat(f.repository.find(created.dispatchNo()).getRecordVersion()).isEqualTo(approved.recordVersion());
+        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_command WHERE idempotency_key LIKE 'blank-%'",Long.class)).isZero();
+    }
+
+    /** 客服多次改车货保留本轮驳回原因，重新提交才开始全新审核轮次。 */
+    @Test void cargoChangesKeepRejectionReasonUntilNextSubmission() throws Exception {
+        for(boolean loading:List.of(false,true)) {
+            var f=new DispatchAggregatePersistenceTest.Fixture();
+            var created=f.tx.execute(s->f.service.create(f.actor,f.configured("retain",List.of(f.source(1,"101",501,"ONT8",3)))));
+            var current=submit(f,created,"submit");
+            if(loading)current=review(f,f.actor,current,false,"approve",Decision.APPROVED,null);
+            var rejected=review(f,f.actor,current,loading,"reject",Decision.REJECTED,"请重新核对货物");
+            var added=f.tx.execute(s->f.service.addCargo(f.actor,created.dispatchNo(),new DispatchCommands.AddCargo(rejected.recordVersion(),"add",List.of(f.source(2,"101",502,"ONT8",2)),List.of())));
+            var addedAgain=f.tx.execute(s->f.service.addCargo(f.actor,created.dispatchNo(),new DispatchCommands.AddCargo(added.recordVersion(),"add-again",List.of(f.source(3,"101",503,"ONT8",1)),List.of())));
+            long item=f.db.queryForObject("SELECT id FROM ll_dispatch_item WHERE plan_pallet_id=3",Long.class);
+            var removed=f.tx.execute(s->f.service.removeCargo(f.actor,created.dispatchNo(),item,new DispatchCommands.ReasonCommand(addedAgain.recordVersion(),"remove","调整目的仓")));
+            var resources=f.configured("updated-resources",List.of());
+            var updated=f.tx.execute(s->f.service.update(f.actor,created.dispatchNo(),new DispatchCommands.Update(removed.recordVersion(),"update-vehicle",resources.vehicle(),resources.driver(),resources.plannedDepartureAt().plusSeconds(60),null,"客服更正")));
+            var detail=f.service.detail(f.actor,created.dispatchNo());
+            var retained=loading?detail.reviews().loadingReview():detail.reviews().dispatchReview();
+            assertThat(detail.reviewState()).isEqualTo(ReviewState.DRAFT);
+            assertThat(retained.status()).isEqualTo(ReviewStatus.REJECTED);assertThat(retained.reason()).isEqualTo("请重新核对货物");
+            assertThat(retained.basisHash()).isNull();assertQueue(f,created.dispatchNo(),BeforeLoadingSection.VEHICLE_INFO);
+            submit(f,updated,"resubmit");detail=f.service.detail(f.actor,created.dispatchNo());
+            assertThat(detail.reviews().dispatchReview().status()).isEqualTo(ReviewStatus.PENDING);
+            assertThat(detail.reviews().dispatchReview().reason()).isNull();assertThat(detail.reviews().loadingReview().reason()).isNull();
+        }
+    }
+
+    /** PDA理货共享后台版本；成功恢复不重复写，越仓、失权和替换身份均拒绝。 */
+    @Test void pdaReviewSharesVersionAndOriginalRecoveryWithAdmin() throws Exception {
+        var security=SecurityContextHolder.getContext();var previous=security.getAuthentication();
+        try {
+            security.setAuthentication(new TestingAuthenticationToken("picker","","lastleg:pda:operate","ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR"));
+            var f=new DispatchAggregatePersistenceTest.Fixture();
+            var pda=new DispatchContracts.Actor("picker",ActorMode.PDA,"9");
+            var created=f.tx.execute(s->f.service.create(f.actor,f.configured("pda-review",List.of(f.source(1,"101",501,"ONT8",3)))));
+            var submitted=submit(f,created,"submit");
+            assertThat(f.service.actions(pda,f.repository.find(created.dispatchNo())).get(Action.LOADING_REVIEW).allowed()).isFalse();
+            assertThatThrownBy(()->review(f,pda,submitted,false,"pda-dispatch",Decision.APPROVED,null)).hasMessageContaining("仅当前绑定仓");
+            var approved=review(f,f.actor,submitted,false,"dispatch",Decision.APPROVED,null);
+            assertThat(f.service.actions(pda,f.repository.find(created.dispatchNo())).get(Action.LOADING_REVIEW).allowed()).isTrue();
+            assertThatThrownBy(()->review(f,new DispatchContracts.Actor("picker",ActorMode.PDA,"99"),approved,true,"wrong-warehouse",Decision.APPROVED,null)).hasMessageContaining("当前绑定仓");
+            var loaded=review(f,pda,approved,true,"pda-approve",Decision.APPROVED,null);
+            assertThat(loaded.stage()).isEqualTo(Stage.LOADING);
+            assertThatThrownBy(()->review(f,f.actor,approved,true,"admin-stale",Decision.APPROVED,null)).hasMessageContaining("版本已变化");
+            assertThat(review(f,pda,approved,true,"pda-approve",Decision.APPROVED,null).replayed()).isTrue();
+            assertThat(f.tx.execute(s->f.service.command(pda,created.dispatchNo(),"pda-approve")).replayed()).isTrue();
+            assertThatThrownBy(()->f.tx.execute(s->f.service.command(new DispatchContracts.Actor("picker",ActorMode.PDA,"99"),created.dispatchNo(),"pda-approve"))).hasMessageContaining("当前绑定仓");
+            assertThatThrownBy(()->f.tx.execute(s->f.service.command(new DispatchContracts.Actor("other",ActorMode.PDA,"9"),created.dispatchNo(),"pda-approve"))).hasMessageContaining("无权");
+            security.setAuthentication(new TestingAuthenticationToken("picker","","lastleg:pda:operate"));
+            assertThatThrownBy(()->review(f,pda,approved,true,"pda-approve",Decision.APPROVED,null)).hasMessageContaining("仅当前绑定仓");
+            assertThatThrownBy(()->f.tx.execute(s->f.service.command(pda,created.dispatchNo(),"pda-approve"))).hasMessageContaining("原动作权限");
+            assertThat(f.repository.find(created.dispatchNo()).getRecordVersion()).isEqualTo(loaded.recordVersion());
+        } finally {security.setAuthentication(previous);}
+    }
+
+    /** 使用服务真实SQL分页和全量统计验证当前队列，不以返回动作猜测队列。 */
+    private static void assertQueue(DispatchAggregatePersistenceTest.Fixture f,String number,BeforeLoadingSection expected) {
+        for(var section:BeforeLoadingSection.values()) {
+            var page=f.tx.execute(s->f.service.page(f.actor,new DispatchViews.Query(1,20,number,null,null,null,null,StatusFilter.ACTIVE,Stage.BEFORE_LOADING,section,null)));
+            assertThat(page.total()).isEqualTo(section==expected?1:0);
+            var counts=page.statistics().beforeLoadingReviewCounts();
+            assertThat(counts.vehicleInfoTotal()).isEqualTo(expected==BeforeLoadingSection.VEHICLE_INFO?1:0);
+            assertThat(counts.dispatchReview().pending()).isEqualTo(expected==BeforeLoadingSection.DISPATCH_REVIEW?1:0);
+            assertThat(counts.loadingReview().pending()).isEqualTo(expected==BeforeLoadingSection.LOADING_REVIEW?1:0);
+        }
+    }
+
+    /** 每次提交以真实返回版本开始下一轮，不人工造审核状态。 */
+    private static DispatchContracts.CommandResult submit(DispatchAggregatePersistenceTest.Fixture f,DispatchContracts.CommandResult prior,String key) {
+        return f.tx.execute(s->f.service.submitReview(f.actor,prior.dispatchNo(),new DispatchCommands.SubmitReview(prior.recordVersion(),key,null)));
+    }
+
+    /** 通过同一审核服务分别调用两端，版本和幂等键始终由请求明确提供。 */
+    private static DispatchContracts.CommandResult review(DispatchAggregatePersistenceTest.Fixture f,DispatchContracts.Actor actor,DispatchContracts.CommandResult prior,boolean loading,String key,Decision decision,String reason) {
+        return f.tx.execute(s->f.service.review(actor,prior.dispatchNo(),loading,new DispatchCommands.ReviewCommand(prior.recordVersion(),key,decision,reason,null)));
+    }
+}

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/ownedbusiness/OwnedBusinessFixtures.java

@@ -20,6 +20,7 @@ final class OwnedBusinessFixtures {
     /** 装车完成但未发车，证明不依赖DEPART历史。 */
     static Source source() {
         var row=new Source();row.setId(1L);row.setDispatchNo("DS-OWN-ONE");row.setStatus("ACTIVE");row.setStage("AFTER_LOADING");
+        row.setPooledCargo(false);
         row.setRecordVersion(8L);row.setOverseasWarehouseId("9");row.setOverseasWarehouseCode("WH-9");row.setOverseasWarehouseName("测试仓");
         row.setPlannedDepartureAt(LocalDateTime.parse("2026-10-20T08:00:00"));row.setLoadingCompletedAt(LocalDateTime.parse("2026-10-20T07:30:00"));
         row.setLoadingCompletionHash("actual-load");row.setOwnedLoadingCompletionHash("actual-load");row.setOwnedLoadingCompletedAt(row.getLoadingCompletedAt());

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/ownedbusiness/OwnedBusinessPersistenceTest.java

@@ -50,8 +50,12 @@ class OwnedBusinessPersistenceTest {
             customer_name VARCHAR(128),source_key VARCHAR(128),order_no VARCHAR(128),inbound_code VARCHAR(128),
             pallet_no VARCHAR(128),warehouse_pallet_id BIGINT,destination_type VARCHAR(32),
             destination_warehouse_code VARCHAR(128),destination_warehouse_name VARCHAR(128),fba_warehouse_code VARCHAR(128),
-            delivery_address VARCHAR(256),postal_code VARCHAR(64),package_count INT)
+            delivery_address VARCHAR(256),postal_code VARCHAR(64),package_count INT,plan_id BIGINT,plan_pallet_id BIGINT)
             """);
+        jdbc.execute("CREATE TABLE ll_fleet_external_booking(id BIGINT PRIMARY KEY,trip_id BIGINT,dispatch_no VARCHAR(128),customer_id VARCHAR(128),offer_id BIGINT,status VARCHAR(32),incoming_no VARCHAR(128),receipt_json LONGTEXT)");
+        jdbc.execute("CREATE TABLE ll_warehouse_transfer_order(customer_id VARCHAR(128),transfer_no VARCHAR(128),inbound_code VARCHAR(128))");
+        jdbc.execute("CREATE TABLE ll_inbound_plan_line(id BIGINT PRIMARY KEY,plan_id BIGINT,customer_id VARCHAR(128),inbound_code VARCHAR(128))");
+        jdbc.execute("CREATE TABLE ll_inbound_plan_pallet_allocation(pallet_id BIGINT,line_id BIGINT,plan_id BIGINT,customer_id VARCHAR(128))");
         jdbc.execute("CREATE TABLE ll_dispatch_appointment_allocation(dispatch_id BIGINT,dispatch_item_id BIGINT,customer_id VARCHAR(64),batch_key VARCHAR(128),destination_key VARCHAR(128),package_count INT)");
         jdbc.execute("CREATE TABLE ll_inbound_fba_appointment(id BIGINT,appointment_no VARCHAR(64),confirmation_no VARCHAR(64),appointment_start_utc DATETIME(3))");
         jdbc.execute("""

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/ownedbusiness/OwnedBusinessQueryTest.java

@@ -41,14 +41,15 @@ class OwnedBusinessQueryTest {
         assertThrows(BizException.class,()->service.detail(OwnedBusinessFixtures.actor(),"DS-OWN-ONE"));
         verifyNoInteractions(dispatch);verify(repo,never()).capture(any());assertEquals(8L,source.getRecordVersion());
     }
-    /** 装车前、非自有归属、失配的原装车hash均不能作为本页可写来源。 */
+    /** 装车前、已实际拼车、失配的装车hash均不可写；未拼车的外配车辆仍属自有业务。 */
     @Test void stageAndFrozenOwnershipFactsAreBothRequired() {
         var repo=mock(OwnedBusinessRepository.class);var codec=OwnedBusinessFixtures.codec();
         var service=new OwnedBusinessQueryService(repo,new OwnedBusinessProjection(codec),codec,mock(DispatchDetailReader.class));
         var source=OwnedBusinessFixtures.source();when(repo.source("DS-OWN-ONE")).thenReturn(source);
         source.setStage("LOADING");assertThrows(BizException.class,()->service.requireOwned("DS-OWN-ONE"));
-        source.setStage("AFTER_LOADING");source.setOwnedVehicleOwnership("DISPATCHED");assertThrows(BizException.class,()->service.requireOwned("DS-OWN-ONE"));
-        source.setOwnedVehicleOwnership("OWNED");source.setOwnedLoadingCompletionHash("other");assertThrows(BizException.class,()->service.requireOwned("DS-OWN-ONE"));
+        source.setStage("AFTER_LOADING");source.setOwnedVehicleOwnership("DISPATCHED");assertSame(source,service.requireOwned("DS-OWN-ONE"));
+        source.setPooledCargo(true);assertThrows(BizException.class,()->service.requireOwned("DS-OWN-ONE"));
+        source.setPooledCargo(false);source.setOwnedLoadingCompletionHash("other");assertThrows(BizException.class,()->service.requireOwned("DS-OWN-ONE"));
     }
     /** 列表权限不自动授予编辑或上传，不暴露主流程写动作。 */
     @Test void readOnlyActorHasOnlyReadGates() {

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/ownedbusiness/OwnedBusinessScopePersistenceTest.java

@@ -75,7 +75,7 @@ class OwnedBusinessScopePersistenceTest {
             """,id,"DS-OUT-"+id,stage,load,snapshot,"TEST-OUT-"+id);
         baseline.jdbc.update("""
             INSERT INTO ll_dispatch_item SELECT id+?, ?,customer_id,customer_name,source_key,order_no,inbound_code,?, ?,destination_type,
-              destination_warehouse_code,destination_warehouse_name,fba_warehouse_code,delivery_address,postal_code,package_count FROM ll_dispatch_item WHERE dispatch_order_id=1
+              destination_warehouse_code,destination_warehouse_name,fba_warehouse_code,delivery_address,postal_code,package_count,NULL,NULL FROM ll_dispatch_item WHERE dispatch_order_id=1
             """,id*100,id,"PAL-"+(31+id),31+id);
         var ownership=new OwnedBusinessRows.Ownership();ownership.setDispatchId(id);ownership.setVehicleId(vehicle.vehicleId());
         ownership.setResourceMode(mode);ownership.setVehicleOwnership("DISPATCHED");ownership.setVehicleRecordVersion(vehicle.vehicleId()==null?null:3L);
@@ -83,6 +83,12 @@ class OwnedBusinessScopePersistenceTest {
         baseline.jdbc.update("INSERT INTO ll_dispatch_history VALUES(?,?,8,'LOADING_COMPLETE','TEST-picker',NULL,'{}',?)",100+id,id,original.getLoadingCompletedAt());
         if(!"AFTER_LOADING".equals(stage))baseline.jdbc.update("UPDATE ll_dispatch_order SET departed_at=? WHERE id=?",original.getLoadingCompletedAt().plusHours(1),id);
         if("DELIVERED".equals(stage))baseline.jdbc.update("UPDATE ll_dispatch_order SET delivery_completed_at=? WHERE id=?",original.getLoadingCompletedAt().plusHours(2),id);
+        // 每张外配测试任务真实关联一票拼车来源，车辆归属不再充当分类依据。
+        baseline.jdbc.update("UPDATE ll_dispatch_item SET plan_id=?,plan_pallet_id=? WHERE dispatch_order_id=? AND customer_id='101'",id*1000,id*1000+1,id);
+        baseline.jdbc.update("INSERT INTO ll_inbound_plan_line VALUES(?,?,'101','IN-A')",id*1000+2,id*1000);
+        baseline.jdbc.update("INSERT INTO ll_inbound_plan_pallet_allocation VALUES(?,?,?,'101')",id*1000+1,id*1000+2,id*1000);
+        baseline.jdbc.update("INSERT INTO ll_warehouse_transfer_order VALUES('101',?,'IN-A')","INCOMING-"+id);
+        baseline.jdbc.update("INSERT INTO ll_fleet_external_booking VALUES(?,2,?,'101',9,'BOUND',?,'{}')",id,"DS-OUT-"+id,"INCOMING-"+id);
     }
     /** 外配真实三权限，与自有集合完全不相交。 */
     private OwnedBusinessModels.Actor actor(){return new OwnedBusinessModels.Actor("outsourced-operator","TEST外配操作员",Set.of(OutsourcedBusinessModels.LIST,OutsourcedBusinessModels.EDIT,OutsourcedBusinessModels.UPLOAD));}
@@ -101,6 +107,75 @@ class OwnedBusinessScopePersistenceTest {
         assertEquals(0,outsourced.list(actor(),new OwnedBusinessModels.Query(1,20,null,"2026-10-20T08:00:00Z",null,null,"9")).total());
         for(var stage:OwnedBusinessModels.Stage.values())assertEquals(1,outsourced.list(actor(),new OwnedBusinessModels.Query(1,20,"2026-10-20T08:00:00Z","2026-10-21T08:00:00Z",null,stage,"9")).total());
     }
+    /** 四种车辆/拼车组合只按货物分类；临时外配未拼车也可从自有入口登记。 */
+    @Test void classificationIsIndependentOfVehicleOwnershipAndResourceMode() {
+        baseline.jdbc.update("UPDATE ll_fleet_owned_business_ownership SET vehicle_ownership='OWNED' WHERE dispatch_id=2");
+        baseline.jdbc.update("UPDATE ll_fleet_external_booking SET status='RECEIVED',dispatch_no=NULL WHERE id=3");
+        baseline.jdbc.update("UPDATE ll_fleet_owned_business_ownership SET vehicle_ownership='DISPATCHED' WHERE dispatch_id=1");
+        var query=new OwnedBusinessModels.Query(1,20,null,null,null,null,null);
+        assertEquals(2,outsourced.list(actor(),query).total());assertEquals(2,queries.list(OwnedBusinessFixtures.actor(),query).total());
+        assertEquals("OWNED",outsourced.detail(actor(),"DS-OUT-2").row().vehicle().ownership());
+        var external=queries.detail(OwnedBusinessFixtures.actor(),"DS-OUT-3");
+        assertNull(external.row().vehicle().vehicleId());assertEquals("DISPATCHED",external.row().vehicle().ownership());
+        var saved=records.save(OwnedBusinessFixtures.actor(),"DS-OUT-3",new OwnedBusinessModels.SaveOperations("0","non-pool-external-save",
+            new OwnedBusinessModels.Operations(new OwnedBusinessModels.Money("USD","0"),null,null,List.of()),null));
+        assertEquals("1",saved.row().recordVersion());
+        var pooled=outsourced.save(actor(),"DS-OUT-2",request("0","pool-owned-save",new OwnedBusinessModels.Money("USD","25"),List.of()));
+        assertEquals("OWNED",pooled.row().vehicle().ownership());assertEquals("25.00",pooled.row().unitPrice());
+        assertThrows(BizException.class,()->queries.detail(OwnedBusinessFixtures.actor(),"DS-OUT-2"));
+        assertThrows(BizException.class,()->outsourced.detail(actor(),"DS-OUT-3"));
+    }
+    /** 发布、询价、占位、实收未排入、取消和非池来源均不计拼车，详情与完整统计一致。 */
+    @Test void onlyReceivedPoolCargoBoundToThisDispatchCounts() {
+        var query=new OwnedBusinessModels.Query(1,1,null,null,null,null,null);
+        for(String status:List.of("DRAFT","CONFIRMED","RECEIVED","CANCELLED")) {
+            baseline.jdbc.update("UPDATE ll_fleet_external_booking SET status=? WHERE id=2",status);
+            assertEquals(2,outsourced.list(actor(),query).total());assertEquals(2,queries.list(OwnedBusinessFixtures.actor(),query).total());
+            assertNotNull(queries.detail(OwnedBusinessFixtures.actor(),"DS-OUT-2"));
+            assertThrows(BizException.class,()->outsourced.detail(actor(),"DS-OUT-2"));
+        }
+        baseline.jdbc.update("UPDATE ll_fleet_external_booking SET status='BOUND',offer_id=NULL WHERE id=2");
+        assertNotNull(queries.detail(OwnedBusinessFixtures.actor(),"DS-OUT-2"));
+        baseline.jdbc.update("UPDATE ll_fleet_external_booking SET offer_id=9,receipt_json=NULL WHERE id=2");
+        assertNotNull(queries.detail(OwnedBusinessFixtures.actor(),"DS-OUT-2"));
+        baseline.jdbc.update("UPDATE ll_fleet_external_booking SET receipt_json='{}',trip_id=999 WHERE id=2");
+        assertNotNull(queries.detail(OwnedBusinessFixtures.actor(),"DS-OUT-2"));
+        baseline.jdbc.update("UPDATE ll_fleet_external_booking SET trip_id=2,dispatch_no='OTHER' WHERE id=2");
+        assertNotNull(queries.detail(OwnedBusinessFixtures.actor(),"DS-OUT-2"));
+        baseline.jdbc.update("UPDATE ll_fleet_external_booking SET dispatch_no='DS-OUT-2',customer_id='102' WHERE id=2");
+        assertNotNull(queries.detail(OwnedBusinessFixtures.actor(),"DS-OUT-2"));
+    }
+    /** 用真实计划组成核对来源，展示入仓码不能代替组成；多条有效拼车登记不重复整车。 */
+    @Test void actualCargoSourceIsRequiredAndMultipleBookingsNeverMultiplyStatistics() {
+        baseline.jdbc.update("UPDATE ll_dispatch_item SET inbound_code='DISPLAY-ONLY' WHERE dispatch_order_id=2");
+        assertNotNull(outsourced.detail(actor(),"DS-OUT-2"));
+        baseline.jdbc.update("INSERT INTO ll_fleet_external_booking SELECT 22,trip_id,dispatch_no,customer_id,offer_id,status,incoming_no,receipt_json FROM ll_fleet_external_booking WHERE id=2");
+        var query=new OwnedBusinessModels.Query(1,1,null,null,null,null,null);
+        assertEquals(3,outsourced.list(actor(),query).total());assertEquals(1,outsourced.list(actor(),query).records().size());
+        baseline.jdbc.update("DELETE FROM ll_inbound_plan_pallet_allocation WHERE plan_id=2000");
+        assertNotNull(queries.detail(OwnedBusinessFixtures.actor(),"DS-OUT-2"));
+        assertEquals(2,outsourced.list(actor(),query).total());
+        assertThrows(BizException.class,()->outsourced.detail(actor(),"DS-OUT-2"));
+    }
+    /** 同前缀编号末位必须参与来源匹配，128字符的多字节入仓码不能被二进制宽度截断。 */
+    @Test void completeIdentifiersDeterminePoolScopeWithoutPrefixTruncation() {
+        String transfer="T".repeat(63)+"A",dispatch="D".repeat(63)+"A",inbound="仓".repeat(127)+"甲";
+        baseline.jdbc.update("UPDATE ll_warehouse_transfer_order SET transfer_no=?,inbound_code=? WHERE transfer_no='INCOMING-2'",transfer,inbound);
+        baseline.jdbc.update("UPDATE ll_inbound_plan_line SET inbound_code=? WHERE plan_id=2000",inbound);
+        baseline.jdbc.update("UPDATE ll_dispatch_order SET dispatch_no=? WHERE id=2",dispatch);
+        baseline.jdbc.update("UPDATE ll_fleet_external_booking SET dispatch_no=?,incoming_no=? WHERE id=2",dispatch,transfer);
+        assertNotNull(outsourced.detail(actor(),dispatch));
+        baseline.jdbc.update("UPDATE ll_fleet_external_booking SET incoming_no=? WHERE id=2","T".repeat(63)+"B");
+        assertNotNull(queries.detail(OwnedBusinessFixtures.actor(),dispatch));
+        baseline.jdbc.update("UPDATE ll_fleet_external_booking SET incoming_no=?,dispatch_no=? WHERE id=2",transfer,"D".repeat(63)+"B");
+        assertNotNull(queries.detail(OwnedBusinessFixtures.actor(),dispatch));
+        baseline.jdbc.update("UPDATE ll_fleet_external_booking SET dispatch_no=? WHERE id=2",dispatch);
+        baseline.jdbc.update("UPDATE ll_inbound_plan_line SET inbound_code=? WHERE plan_id=2000","仓".repeat(127)+"乙");
+        assertNotNull(queries.detail(OwnedBusinessFixtures.actor(),dispatch));
+        baseline.jdbc.update("UPDATE ll_inbound_plan_line SET inbound_code=? WHERE plan_id=2000",inbound);
+        assertNotNull(outsourced.detail(actor(),dispatch));
+        assertEquals(3,outsourced.list(actor(),new OwnedBusinessModels.Query(1,1,null,null,null,null,null)).summary().dispatchCount());
+    }
     /** 外配档案和临时车辆分别保持真实ID/空ID及原承运商，GET不建记录。 */
     @Test void masterAndExternalReadOriginalSnapshotWithoutBackfill() {
         var master=outsourced.detail(actor(),"DS-OUT-2");var external=outsourced.detail(actor(),"DS-OUT-3");
@@ -210,7 +285,7 @@ class OwnedBusinessScopePersistenceTest {
     @Test void roundingUsesActualDistinctPalletsAndZeroDenominatorStaysNull() {
         String load=baseline.repository.source("DS-OUT-2").getLoadingConfirmationJson().replace("\"pallets\":[", "\"pallets\":[{\"warehousePalletId\":99,\"palletSpaces\":5,\"weightKg\":10,\"volumeCbm\":1,\"deliveryIndex\":1},");
         baseline.jdbc.update("UPDATE ll_dispatch_order SET loading_confirmation_json=? WHERE id=2",load);
-        baseline.jdbc.update("INSERT INTO ll_dispatch_item SELECT id+1000,dispatch_order_id,customer_id,customer_name,CONCAT(source_key,'-2'),order_no,inbound_code,'PAL-99',99,destination_type,destination_warehouse_code,destination_warehouse_name,fba_warehouse_code,delivery_address,postal_code,package_count FROM ll_dispatch_item WHERE id=211");
+        baseline.jdbc.update("INSERT INTO ll_dispatch_item SELECT id+1000,dispatch_order_id,customer_id,customer_name,CONCAT(source_key,'-2'),order_no,inbound_code,'PAL-99',99,destination_type,destination_warehouse_code,destination_warehouse_name,fba_warehouse_code,delivery_address,postal_code,package_count,plan_id,plan_pallet_id FROM ll_dispatch_item WHERE id=211");
         var saved=outsourced.save(actor(),"DS-OUT-2",request("0","out-half-up-rounding",new OwnedBusinessModels.Money("USD","10.01"),List.of()));
         assertEquals(2,saved.row().actualPalletCount());assertEquals(3,saved.cargo().size());assertEquals("5.01",saved.row().unitPrice());
         var confirmation=baseline.codec.read(load,DispatchContracts.ConfirmedLoad.class);

lastleg-service/src/test/java/com/baiyue/lastleg/fleet/trip/FleetBookingRequestHashTest.java

@@ -0,0 +1,30 @@
+package com.baiyue.lastleg.fleet.trip;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.Test;
+import org.springframework.test.util.ReflectionTestUtils;
+import java.util.List;
+import static org.junit.jupiter.api.Assertions.*;
+
+class FleetBookingRequestHashTest {
+    final FleetBookingService service = new FleetBookingService(null, null, null, null, null, null,
+        new ObjectMapper().findAndRegisterModules(), null, null, null);
+
+    private String hash(Object value) { return ReflectionTestUtils.invokeMethod(service, "hash", value); }
+
+    @Test void incomingDispatchSourceKeyAcceptsArrayAndPreservesBookingAndCommandIdentity() {
+        var source = List.of("FB202610210004", "pool-arrange-command");
+        var digest = assertDoesNotThrow(() -> hash(source));
+        assertEquals(64, digest.length());
+        assertEquals(digest, hash(source));
+        assertNotEquals(digest, hash(List.of("FB202610210005", "pool-arrange-command")));
+        assertNotEquals(digest, hash(List.of("FB202610210004", "another-command")));
+        assertNotEquals(digest, hash(List.of("pool-arrange-command", "FB202610210004")));
+    }
+
+    @Test void bookingCommandsStillIgnoreReplayKeyAndTripVersionButRetainBookingVersion() {
+        var digest = hash(new FleetBookingModels.Command(8L, 4L, "command-original", "TEST"));
+        assertEquals(digest, hash(new FleetBookingModels.Command(9L, 4L, "command-replay", "TEST")));
+        assertNotEquals(digest, hash(new FleetBookingModels.Command(8L, 5L, "command-original", "TEST")));
+    }
+}

lastleg-service/src/test/java/com/baiyue/lastleg/pda/PdaOutboundDispatchContractTest.java

@@ -72,6 +72,18 @@ class PdaOutboundDispatchContractTest {
         verify(outboundService).pdaTasks("900", null);
     }
 
+    /** PDA只暴露理货审核且身份固定取绑定仓，不提供调度审核入口。 */
+    @Test
+    void loadingReviewUsesTheSharedServiceWithBoundPdaIdentity() {
+        var workflow=mock(com.baiyue.lastleg.dispatch.service.DispatchAggregateService.class);
+        var controller=new DispatchPdaController();ReflectionTestUtils.setField(controller,"workflow",workflow);
+        var user=pda(Set.of("lastleg:pda:operate","ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR"),900L);
+        var request=new DispatchCommands.ReviewCommand(2L,"pda-review",DispatchTypes.Decision.REJECTED,"司机资料待核对",null);
+        controller.loadingReview(user,"PC202610210001",request);
+        verify(workflow).review(new DispatchContracts.Actor("7",DispatchTypes.ActorMode.PDA,"900"),"PC202610210001",true,request);
+        assertFalse(Arrays.stream(DispatchPdaController.class.getDeclaredMethods()).anyMatch(method->method.getName().equals("dispatchReview")));
+    }
+
     @Test
     void missingRolePermissionOrWarehouseBindingIsRejected() {
         DispatchPdaController controller = new DispatchPdaController();
@@ -88,7 +100,10 @@ class PdaOutboundDispatchContractTest {
         String yaml = Files.readString(Path.of("src/main/resources/openapi/overseas-pda-operations-v1.yaml"),
             StandardCharsets.UTF_8);
         assertTrue(yaml.contains("/api/pda/v1/last-leg/dispatches:"));
-        assertTrue(yaml.contains("/api/pda/v1/last-leg/dispatches/{dispatchNo}/depart:"));
+        assertTrue(yaml.contains("/api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-review:"));
+        assertTrue(yaml.contains("overseas-business-v1.yaml#/components/schemas/DispatchReviewCommand"));
+        assertFalse(yaml.contains("/api/pda/v1/last-leg/dispatches/{dispatchNo}/depart:"));
+        assertTrue(yaml.contains("/api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-complete:"));
         assertTrue(yaml.contains("/api/pda/v1/last-leg/outbound-tasks/{taskNo}/complete:"));
         assertTrue(yaml.contains("/api/pda/v1/last-leg/outbound-tasks/{taskNo}/pallets/{palletNo}/pick:"));
         assertFalse(yaml.contains("name: customerId"));

lastleg-service/src/test/java/com/baiyue/lastleg/service/LastlegOrderServiceTest.java

@@ -148,7 +148,7 @@ class LastlegOrderServiceTest {
         when(orders.countContainerPlans("BOOKING-1")).thenReturn(0L);
         when(orders.updateContainerExpectedWarehouseArrival("BOOKING-1", estimatedAt, 0)).thenReturn(2);
         when(orders.findContainerArrivalTimes(List.of("BOOKING-1"))).thenReturn(List.of(
-            new ContainerArrivalTimeView("BOOKING-1", estimatedAt, null, 1)));
+            new ContainerArrivalTimeView("BOOKING-1", estimatedAt, null, 1, 0)));
 
         ContainerArrivalTimeView result = service.changeExpectedWarehouseArrival("BOOKING-1", "arrival-1",
             new LastlegOrderRequests.ChangeExpectedWarehouseArrival(estimatedAt, 0, null), "admin");

scripts/AGENTS.md

@@ -10,7 +10,8 @@
 
 | 类别 | 正式入口 | 管理边界 |
 |---|---|---|
-| 本机重型检查限流 | `local-check.ps1` | 所有工作目录、对话共用一个用户级执行名额；PowerShell 7，状态/超时/并发与 Job Object 回收规则见外层 `docs/AI工程执行与协作约束.md`；只读状态不申请重型名额 |
+| 本机重型检查限流 | `local-check.ps1` | 所有工作目录、对话共用两个用户级执行名额；PowerShell 7，状态/超时/并发与 Job Object 回收规则见外层 `docs/AI工程执行与协作约束.md`；只读状态不申请重型名额 |
+| 后端分层检查 | `backend-check.ps1` | 局部任务显式选 Focused；模式缺省为 Module，不是日常必跑；必填模块并接入限流，范围见后端根指引，参数见 README |
 | 测试/灰度单票验收 | `prod-release-acceptance.mjs`、`prod-release-delivery-stage.mjs`、内部 `prod-release-order-stage.mjs` | 显式 test/gray、统一 Gateway/accessToken；同一票义乌到洛杉矶、前置同时核对东莞；full-flow 串行覆盖买单FBA正常链至签收回传及车次资源释放，保留分阶段入口与独立检查点；不调用测试造数模块，不创建账号/主档或删除数据；配置和边界见 README |
 | Admin 全量 HTTP 验证 | `admin-test-env-acceptance.mjs` | 通过显式环境文件运行统一 TEST Gateway/会话，拒绝旧海外网关参数；默认模块覆盖平台全链路，定向验证使用 `--modules`，模块注册和依赖以总入口及 `admin-test-env-modules/README.md` 为准 |
 | Client 全量 HTTP 验证 | `client-test-env-acceptance.mjs` | 通过显式环境文件运行统一 TEST Gateway/会话，拒绝旧海外网关参数；覆盖客户工作台完整链路，`client-phase2-test-env-acceptance.mjs` 只是入库测量与计费专项，不替代全量入口 |

scripts/README.md

@@ -1,5 +1,29 @@
 # 后端脚本管理与全量 HTTP 验收索引
 
+## 先看范围，再看证据
+
+`acceptance-overview.mjs` 是离线只读总览入口，不需要凭据、不联网、不创建报告或测试数据。默认范围直接读取 Admin 实际注册表，不维护另一份模块枚举：
+
+```powershell
+node scripts/acceptance-overview.mjs
+node scripts/acceptance-overview.mjs --report reports/<明确的一次验收报告>.json
+```
+
+| 验收层 | 正式入口 | 结论边界 |
+| --- | --- | --- |
+| Admin 默认 HTTP | `admin-test-env-acceptance.mjs` | 总览的 defaultModules；optionalModules 需显式指定，不自动计入 |
+| Client 全量 HTTP | `client-test-env-acceptance.mjs` | 独立执行，跳过详情不得视为详情已验证 |
+| 测量计费专项 | `client-phase2-test-env-acceptance.mjs` | 不替代 Client 全量，使用本轮样本 |
+| 车辆等专项 | 本索引对应的专项入口 | 只覆盖各自声明范围，不能合并宣称默认全量一次通过 |
+| 离线检查 | `local-check.ps1` 包装受影响测试 | 证明源码检查，不证明部署或真实 HTTP |
+| 页面与真机 | 应用验收规则 | 单独提供操作和视觉证据，HTTP 不代替 |
+
+总览显式读取一份报告，不遍历历史目录挑选绿灯。`FAILED` 表示有失败、fatal 或阻断缺口；`INCOMPLETE` 表示有跳过、非阻断缺口、计划模块未出现或仅准备/局部模式；`RECORDED_CHECKS_PASSED` 只表示所记录检查通过，**不是当前版本全量通过**。旧报告没有执行计划时显示 `UNKNOWN_LEGACY_REPORT`，不反推范围。报告损坏或格式不支持时退出1，不自动重跑；正常分析退出0，即使报告失败也不作为 CI 放行命令。
+
+新 Admin 报告的 `executionScope` 保存申请模块、依赖展开后的计划、当轮默认范围及模式限制；这里只记录计划，不以注册即视为已执行。总览将有请求失败与无请求失败分开统计，后者包含模块退出/前置不足，不能把失败条数直接当作独立 Bug 数。缺少模块断言也仅表示缺少证据，不猜测未执行原因。
+
+最新部署与已验/未验状态仍只维护在外层 `docs/测试环境单机部署与配置契约.md`；本索引不复制每日进度。总览不校验实际部署版本、不读取环境文件，执行前仍须经正式入口校验凭据和环境。直接离线测试为 `acceptance-overview.test.mjs`。
+
 `local-dispatch-transport-acceptance.mjs`：仅本机 LOCAL 的现有排车运输任务 HTTP 验收。显式 `node --env-file=<本机凭据文件>` 注入 `ADMIN_TEST_GATEWAY`、`ADMIN_TEST_USERNAME/PASSWORD`、`LOCAL_TRANSFER_PDA_PASSWORD`；拒绝远端网关。创建3张 TEST 仓储转运单、1张本土卡车原单、5张排车（完成/取消/重新安排），以及本轮专用调度/PDA账号、角色、车辆司机；缺失的正式排车权限仅补资源并授予专用角色，不修改既有角色。经正式网关验证原单审核、跨客户取货、资源冲突、凭证隔离、取消重排、发车完成回写、独立仓库清点和车辆司机释放。合成 PNG 只验文件链路，不代表实际运输或有效证照。默认报告 `reports/local-dispatch-transport.json`，可用 `TRANSPORT_ACCEPTANCE_OUTPUT` 指定；每步保留请求键、脱敏意图、错误码和关联标识，失败停止且保留数据。确认已知失败结果后显式 `TRANSPORT_ACCEPTANCE_RESUME=true` 复用同一报告继续；网络结果未知必须先核对，不自动清理或删除，不使用业务 SQL。已成功批次禁止重复运行；不能替代远端部署或人工截图验收。
 
 `local-check.ps1`：Windows / PowerShell 7 本机重型检查统一入口，适用于前后端测试、类型检查、构建、安装依赖及 Maven。示例：`& ./scripts/local-check.ps1 -WorkingDirectory ../apps/admin-web -Label 'Admin typecheck' -Command @('pnpm', 'typecheck')`；`-Status` 查看占用。当前用户所有工作目录共用一个文件句柄锁，默认排队900秒、执行1200秒；超时分别退出75/124，其余透传命令退出码。Vitest workers=2，Node堆2048MB，Java堆1536MB/处理器2；直接 Maven 自动单线程/单fork，直接 Node 内置测试自动并发2。Windows Job Object 仅回收本次后代，不接管旧进程；嵌套调用拒绝，批次内部执行原始命令。无凭据、不主动联网或写业务数据；被包装命令的环境授权不变。状态和最近结果仅写 `%LOCALAPPDATA%/Chongchong/LocalChecks/`，不存命令参数或输出；不自动缓存成功结果。失败保留最近摘要，确认输入后重新排队；锁文件无需手工删除，状态不是验收报告。完整规则见 `../../docs/AI工程执行与协作约束.md` 的“本机重型检查与多对话限流”；离线行为测试为 `local-check.test.mjs`。
@@ -93,7 +117,7 @@ F33 分阶段助手的组合换标顺序为 `unit → unit-carton → bind`：
 
 F40 专项可用 `--signature-mode ROOT_FIRST|CHILD_FIRST|ROOT_SIGNED_REMAINDER_CANCELLED` 只运行显式指定的一种顺序，省略仍串行执行三种；报告和成功范围仅覆盖所列模式。`--verify-delivery-event-recovery` 必须同时显式指定一种顺序，且环境为TEST；仅在该模式第一张真实FBA派送签收前开启定向ACK丢失，不能使用普通海外转运的签收替代国内回写。故障窗口会重建同镜像Lastleg并临时调整事件目标和退避配置，禁止与其他部署或共享环境写入并行；原事件DEAD恢复后必须验证原镜像/配置/网络身份、健康及代理退出。入口事先留存精确故障scope，finally兜底恢复，缺恢复证据或恢复校验失败一律失败。完整库存取证接入既有只读器，报告保留于该批次 `evidence/`，不能把某一模式或事件通过解读为全部反向事件完成。
 
-`fleet-cross-customer-test-env.mjs` 是最小两客户同一排车主单的串行 TEST 专项入口，默认 `--plan` 零网络。显式运行参数为 `--execute --environment TEST --run-id <新批次> --warehouse-id <实际海外收货仓ID> --destination-warehouse-id <FBA目的仓ID>`，凭据仅从显式 `node --env-file="<TEST配置>" --env-file="<Jenkins配置>"` 与 `FBA_CORE_JENKINS_AGENT` 提供。通过普通转运来货、PDA实收和客户确认创建两个新客户各一托一箱，真实来源一次Create到同一主单，自动唯一Fleet记录、配置资源并完成两审；一客户未核平时验证整车装车/发车拒绝及完整库存快照不变，全量实拣后按真实测量显式装车、平台逐客户目的地安排，再统一发车、原键重放、逐客户签收，最后正式结案并分别释放车辆/司机，核对结案前后库存零变化。完整库存由只读取证器获取，缺实测不补计划值，不写业务SQL，不部署或改共享配置。报告位于 `reports/fleet-cross-<新批次>/`，每次请求发送前记录意图；失败保留原现场，不自动重跑或续跑，已存在批次拒绝覆盖。finally停用本轮PDA并退出独立会话；业务样本保留。前置拒绝不代表事务中途回滚，后者另验。对应入口保护合同为 `fleet-cross-customer-test-env.test.mjs`；内部生成与验收函数见模块README。
+`fleet-cross-customer-test-env.mjs` 是最小两客户同一排车主单的串行 TEST 专项入口，默认 `--plan` 零网络。显式运行参数为 `--execute --environment TEST --run-id <新批次> --warehouse-id <实际海外收货仓ID> --destination-warehouse-id <FBA目的仓ID>`，凭据仅从显式 `node --env-file="<TEST配置>" --env-file="<Jenkins配置>"` 与 `FBA_CORE_JENKINS_AGENT` 提供。通过普通转运来货、PDA实收和客户确认创建两个新客户各一托一箱，真实来源一次Create到同一主单，自动唯一Fleet记录、配置资源并完成两审；一客户未核平时验证整车装车/发车拒绝及完整库存快照不变，全量实拣后按真实测量确认装车，自动生成客户目的地单据并发车、原键重放、逐客户签收，最后正式结案并分别释放车辆/司机，核对结案前后库存零变化。完整库存由只读取证器获取，缺实测不补计划值，不写业务SQL，不部署或改共享配置。报告位于 `reports/fleet-cross-<新批次>/`，每次请求发送前记录意图；失败保留原现场，不自动重跑或续跑，已存在批次拒绝覆盖。finally停用本轮PDA并退出独立会话；业务样本保留。前置拒绝不代表事务中途回滚，后者另验。对应入口保护合同为 `fleet-cross-customer-test-env.test.mjs`；内部生成与验收函数见模块README。
 
 头程订单提交使用首次原始详情的 `expectedVersion` 与原 `Idempotency-Key`。单票验收的 `SUBMIT_INTENT` 必须先持久化 `submitCommand` 再发送，显式续跑不得使用当前版本替换原命令，缺少原命令的提交意图及后续检查点停止并等待人工核对。源 Excel 造数同样在提交前保存订单条目的 `submitCommand`；中断或失败条目保留原检查点且不自动重跑，不重建订单或换版本继续。
 
@@ -101,7 +125,7 @@ F40 专项可用 `--signature-mode ROOT_FIRST|CHILD_FIRST|ROOT_SIGNED_REMAINDER_
 
 `fleet-trip-rollback-test-env.mjs` 是跨客户同一原生主单发车中途回滚的串行TEST入口，默认`--plan`零网络；实际参数沿用`--execute --environment TEST --run-id <新批次> --warehouse-id <实际海外仓ID> --destination-warehouse-id <FBA目的仓ID>`，凭据只通过显式TEST/Jenkins环境文件及`FBA_CORE_JENKINS_AGENT`提供。复用正式两客户一托一箱普通转仓来货/实收、同主单两审/实拣/实测装车及平台安排链；按Java客户字符串顺序，通过原业务号只读解析当前主单、客户子单及真实转仓来源，第二客户转仓行建立65秒SELECT FOR UPDATE租约，等待事务自身的50秒会话锁超时使原整车发车失败。不修改业务行、Schema、共享参数或镜像；GLOBAL超时或HTTP超时不能代替会话与事务证据。等待图须精确对应原发车事务、目标转仓主键及实际UPDATE，同时独立READ UNCOMMITTED观察已写的第一客户子单、来源计数及历史；此时主单仍AFTER_LOADING、Fleet为PLANNED、尚无DEPART命令结果，不能沿用旧DEPARTED/重放表断言。最终新已提交读按实际Schema全字段比较相关主/子单、来源历史、占用、命令账本及已提交扫码/SHIP事实，脏读仅作中途证明。租约自动ROLLBACK，核对原事务和等待均已消失，再用同一原发车键/载荷完成正式发车、重放、逐客户签收和资源释放。报告沿`reports/fleet-cross-<新批次>/`，额外`rollback.json`、源码SHA与镜像身份保留；权限、字段、会话超时或任一证据缺失明确阻断，失败保留原现场，不自动重造或续跑，finally仅清理自有PDA/会话。执行需要对应TEST数据库取证、持锁及真实HTTP的明确授权，共享窗口禁止并行发布或操作相同库存。对应`fleet-trip-rollback-test-env.test.mjs`验证证据反例和范围；通用跨客户入口不默认故障注入。
 
-`fleet-test-env-acceptance.mjs` 是显式 TEST 车辆专项入口，默认 `--plan` 仅输出计划；使用显式外部 TEST 与 Jenkins 配置后，以 `--execute --environment TEST --run-id <新批次>` 串行创建本轮头程/海外来源并验证原费用全覆盖、取消重排后的部分覆盖、外接承运占位、PDA真实收货、外接排车计费、逐客户PDA拣货、整车发车、逐目的地签收及资源释放。报告在 `reports/fleet-<run-id>/`；目录和锁独占，失败保留原请求/资源，不自动续跑或重造。会通过正式HTTP写入测试资源和取消未执行单据；既有收货取证使用Jenkins只读查询，不执行业务SQL写入、部署或共享配置修改。Finance费用池消费事实与生产者ACK分开记录；UI及未实现车辆产品范围另验。对应离线入口合同为 `fleet-test-env-acceptance.test.mjs`，内部助手详见模块README。
+`fleet-test-env-acceptance.mjs` 是显式 TEST 车辆专项入口，默认 `--plan` 仅输出计划；使用显式外部 TEST 与 Jenkins 配置后，以 `--execute --environment TEST --run-id <新批次>` 串行创建本轮头程/海外来源并验证两组独立货物自动生成派送单据、外接承运占位、PDA真实收货、外接排车计费、逐客户PDA拣货、整车发车、逐目的地签收及资源释放。报告在 `reports/fleet-<run-id>/`；目录和锁独占，失败保留原请求/资源，不自动续跑或重造。会通过正式HTTP写入测试资源和取消未执行单据；既有收货取证使用Jenkins只读查询，不执行业务SQL写入、部署或共享配置修改。Finance费用池消费事实与生产者ACK分开记录；UI及未实现车辆产品范围另验。对应离线入口合同为 `fleet-test-env-acceptance.test.mjs`，内部助手详见模块README。
 
 整车回滚专项的完整快照覆盖当前23表，包括本批真实实托的`ll_physical_pallet_guard`永久串行行；按实际Schema全列及COUNT取证，中途和回滚后均核对原主键与首次创建时间不变，不把删除重建串行点视作成功回滚。此取证范围仅限该回滚专项，不扩展通用车辆入口的故障注入。
 
@@ -271,7 +295,7 @@ node --env-file="<仓库外灰度验收环境文件>" scripts/admin-test-env-acc
 
 排车扩展入口还支持独立新批次 `--scenario reviews`，真实覆盖两级驳回重提、零扫码退回改货改车及旧版本/幂等冲突，再接完整履约。`--scenario review-terminal --resume-report <本扩展原失败报告> --resume-report-sha256 <原SHA>` 只接收已完成双签收、请求全部明确RESPONSE、审核包VERIFIED但顺序只读快照跨过异步完成版本的精确停点；新报告先只读核齐原单DELIVERED及全量库存，再仅结案释放本批资源，不重拣、重发、重签或覆盖旧失败。其他未知写和原人工单不接受此模式。
 
-`dispatch-workflow-extensions-test-env.mjs` 是排车扩展 TEST HTTP 串行入口，默认 `--plan` 零网络。显式执行使用 `--execute --environment TEST --scenario dual-destination --run-id <新批次> --warehouse-id <实际海外仓> --destination-warehouse-id <首个FBA仓> --pda-env-file <现有海外PDA私有配置> --synthetic-pallet-spaces 1`；TEST及只读取证凭据由调用者在脚本前显式 `node --env-file=<TEST配置>` 加载。正式目录找到第二个同国有效FBA仓后才造新客户和货物，验证双目的仓、独立费用/单据/库存与完整履约。现有PDA只开新会话、不创建停用账号；托位、费用、附件标记TEST合成，重量体积必须来自正式测量证据，不代表现场或硬件。原人工单不参与新造数。报告 `reports/fleet-cross-<run-id>/` 与独占intent存在即拒绝重入；未知写保留原键载荷并停写。只复用受保护库存读者，不新增SQL、部署、改权限或清理数据；退出自有会话、保留业务样本。未就绪矩阵保持未执行；直接合同为 `admin-test-env-modules/dispatch-workflow-extension-contract.test.mjs`。
+`dispatch-workflow-extensions-test-env.mjs` 是排车扩展 TEST HTTP 串行入口，默认 `--plan` 零网络。显式执行使用 `--execute --environment TEST --scenario dual-destination --run-id <新批次> --warehouse-id <实际海外仓> --destination-warehouse-id <首个FBA仓> --pda-env-file <现有海外PDA私有配置> --synthetic-pallet-spaces 1`；TEST及只读取证凭据由调用者在脚本前显式 `node --env-file=<TEST配置>` 加载。正式目录找到第二个同国有效FBA仓后才造新客户和货物，验证双目的仓、自动单据、实际费用归属/库存与完整履约。现有PDA只开新会话、不创建停用账号；托位、附件标记TEST合成，重量体积必须来自正式测量证据，不代表现场或硬件。原人工单不参与新造数。报告 `reports/fleet-cross-<run-id>/` 与独占intent存在即拒绝重入；未知写保留原键载荷并停写。只复用受保护库存读者，不新增SQL、部署、改权限或清理数据；退出自有会话、保留业务样本。未就绪矩阵保持未执行；直接合同为 `admin-test-env-modules/dispatch-workflow-extension-contract.test.mjs`。
 
 `--scenario competition` 同样仅使用本轮新样本，验证占用中的车辆/司机拒绝第二张空排车、装车后尚未安排派送的发车拒绝，以及已成功装车原键的两个 Admin/PDA 请求并发重放；原操作员恢复唯一结果，另一操作员被拒绝，完整库存与主单事实不变。该场景不宣称首次有效命令竞争或完整权限矩阵通过。第二次签收确定成功后增加最多30秒只读完结等待，再进入既有跨接口一致性快照；不重放签收写入，也不修改既有失败报告或共享验证器。
 
@@ -309,7 +333,8 @@ BOL长托盘码按现行模板省略，自动核验使用完整入仓码与本
 | 订单与客户本地验收 | `phase1-acceptance.ps1` | 订单与客户本地服务/API 综合验收，会创建本地业务数据 |
 | 订单与客户本地验收 | `phase1-business-maturity-regression.ps1` | 订单与客户业务成熟度回归，调用本地服务并生成报告 |
 | 订单与客户本地验收 | `phase1-onboarding-order-e2e.ps1` | 注册、资质、审核到下单的本地 E2E，会创建客户、仓库、往来单位和订单 |
-| 本地质量 | `backend-full-regression.ps1` | Gateway 路由与 Mapper 门禁后执行根 POM 全部有效模块 Maven 测试；`-DryRun` 只打印与校验 |
+| 本地质量 | `backend-check.ps1` | 必填模块，默认模块回归；Compile 编译测试源码，Focused 运行精确测试类并检查本轮报告；`-DryRun` 只校验选择并打印 |
+| 本地质量 | `backend-full-regression.ps1` | Gateway 路由与 Mapper 门禁后执行根 POM 全部有效模块 Maven 测试；`-DryRun` 只打印与校验；全量触发条件见后端根 AGENTS |
 | 本地质量 | `frontend-full-regression.ps1` | 编排 Admin/Client 本地测试、类型检查及国内/海外 PDA Node 全量测试，不访问 Gateway |
 | 本地质量 | `database-comment-audit.ps1` | 离线扫描数据库中文注释，不连接数据库 |
 | Jenkins 只读数据库结构 | `database-schema-contract.mjs` | 只查询 `information_schema` 核对区域初始化 SQL 的表和字段；不执行 SQL、不造业务数据、不执行迁移 |
@@ -402,7 +427,7 @@ Gateway 路由防漏：`node --test scripts/gateway-route-contract.test.mjs`。
 
 | 检查 | 入口 |
 |---|---|
-| 后端 Maven 契约/单元测试 | `scripts/backend-full-regression.ps1` |
+| 后端 Maven 契约/单元测试 | 日常 `scripts/backend-check.ps1`；全仓 `scripts/backend-full-regression.ps1` |
 | Admin/Client/国内与海外 PDA 本地全量回归 | `scripts/frontend-full-regression.ps1` |
 | PDA 本地页面和状态定向测试 | `../apps/pda-uniapp/tests/*.test.mjs` |
 | 本地数据库 SQL 静态/受控验收 | `scripts/local-db-full-acceptance.ps1` |
@@ -420,6 +445,33 @@ Admin/Client HTTP 脚本的离线合同只验证脚本结构、参数和模块
 | Client 消息中心调用 | `scripts/client-notifications-contract.test.mjs` |
 | 验收入口与模块注册 | `scripts/full-regression-entry-contract.test.mjs`、`scripts/controller-pipeline-contract.test.mjs` |
 
+## 后端分层检查
+
+`backend-check.ps1` 是本地日常入口，PowerShell 7 执行，自动经 `local-check.ps1` 占用一个重型名额。全量触发条件唯一见 `../AGENTS.md`；不自动根据 Git diff 猜测跨服务消费者，不自动缓存或跳过测试。
+
+在后端根目录执行，`-Modules` 使用逗号分隔的当前根 POM 模块名：
+
+```powershell
+# 只查看范围，不运行 Maven。
+.\scripts\backend-check.ps1 -Modules order -DryRun
+# 签名变化：保留生产及测试源码编译。
+.\scripts\backend-check.ps1 -Modules order -Mode Compile
+# 开发迭代：精确类名，支持逗号分隔和全限定名。
+.\scripts\backend-check.ps1 -Modules common-core -Mode Focused -Tests ApiResponseTest
+# 服务级影响且定向覆盖不足：指定模块及上游依赖测试。
+.\scripts\backend-check.ps1 -Modules order
+# 跨服务模块回归：显式列出受影响生产者、消费者。
+.\scripts\backend-check.ps1 -Modules 'order,firstleg'
+```
+
+三种模式均使用根 reactor 的 `-pl <modules> -am`，不会安装制品到本地仓库，不默认 `clean`。`Compile` 运行 `test-compile`；`Focused`/`Module` 运行 `test`。`-am` 只补上游构建依赖，HTTP/事件下游消费者须显式列入。局部逻辑使用 `Focused` 覆盖修改行为及必要边界即可交付，不因收尾改跑 `Module`；模块回归只用于定向覆盖不足的服务级影响。公共模块按实际消费者验证。模式缺省值为 `Module`，局部任务须显式选 `Focused`；API、Mapper、索引合同按各自条件执行。
+
+Focused 不接受通配符或方法选择，每个类必须唯一命中所选模块的 `src/test/java`。为允许上游无同名测试，Maven 设置 `surefire.failIfNoSpecifiedTests=false`，随后逐类核对本轮更新的 Surefire XML；报告缺失、陈旧、全部跳过或含失败均不能通过，避免零测试假绿。
+
+无环境凭据，不调用真实 HTTP、部署或共享数据库，不启动常驻服务；Maven 可读取依赖缓存、下载缺失依赖，并写各模块 `target/`，测试中的隔离内存数据库行为不变。沿用现有 Maven 测试配置，不额外启用环境集成测试。报告仍在各模块 `target/surefire-reports/`，不创建额外报告目录、不删除旧报告。失败保留产物，修复后重新执行相同范围；报告新鲜度校验仅防止复用旧结果，不支持同一模块在多个对话并发执行测试。
+
+`-MavenCommand` 可指定 Maven 可执行文件，默认 `mvn`。退出码：0 为所选范围通过（DryRun 仅预检通过），2 为模块/测试选择无效；Maven 非零退出码透传，报告核验失败返回非零。排队/执行超时沿用 `local-check.ps1` 的 75/124。入口行为测试为 `backend-check.test.mjs`。
+
 ## 后端全量回归
 
 ## 入口

scripts/acceptance-overview.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { describeAcceptanceScope } from './admin-test-env-acceptance.mjs'
+
+/** 只输出白名单统计和模块名，不转抄报告中的账号、地址、凭据或业务载荷。 */
+export function summarizeReport(report) {
+  if (!report || !Array.isArray(report.steps) || report.steps.length === 0
+      || report.steps.some((step) => typeof step.passed !== 'boolean')) {
+    throw new Error('报告缺少有效 steps，不能认定验收结果')
+  }
+  const steps = report.steps
+  const failed = steps.filter((step) => !step.passed && !step.skipped)
+  const skipped = steps.filter((step) => step.skipped)
+  const skippedModules = Array.isArray(report.modules) ? report.modules.filter((module) => module.skipped).length : 0
+  const gaps = Array.isArray(report.coverageGaps) ? report.coverageGaps : []
+  const blockers = gaps.filter((gap) => gap.blocking || gap.deploymentBlocker)
+  const scope = report.executionScope
+  // 历史报告不包含计划信息，不能从断言数量或模块名字推定完整执行。
+  const scopeKnown = Array.isArray(scope?.plannedModules) && scope.plannedModules.length > 0
+    && Array.isArray(scope.defaultModules) && scope.defaultModules.length > 0
+  const observedModules = new Set(steps.map((step) => step.module))
+  const missingModules = scopeKnown ? scope.plannedModules.filter((name) => !observedModules.has(name)) : []
+  const limited = Boolean(scope?.preparationOnly || scope?.returnMainChainOnly || report.fullAcceptance === false)
+  const failedResult = Boolean(report.fatal) || report.success === false || failed.length > 0 || blockers.length > 0
+  return {
+    result: failedResult ? 'FAILED' : skipped.length || skippedModules || gaps.length || missingModules.length || limited ? 'INCOMPLETE' : 'RECORDED_CHECKS_PASSED',
+    passed: steps.filter((step) => step.passed && !step.skipped).length,
+    failed: failed.length,
+    skipped: skipped.length,
+    skippedModules,
+    blockingGaps: blockers.length,
+    nonBlockingGaps: gaps.length - blockers.length,
+    failedModules: [...new Set(failed.map((step) => step.module).filter(Boolean))],
+    // 无请求的失败包含前置不足和模块退出，不能计作独立接口缺陷。
+    failuresWithRequest: failed.filter((step) => step.request).length,
+    failuresWithoutRequest: failed.filter((step) => !step.request).length,
+    scope: !scopeKnown ? 'UNKNOWN_LEGACY_REPORT' : limited ? 'LIMITED_SCOPE'
+      : scope.defaultModules.every((name) => scope.plannedModules.includes(name)) ? 'DEFAULT_ADMIN_PLAN' : 'SELECTED_MODULES',
+    missingPlannedModules: missingModules,
+    currentVersionVerified: false,
+    pageAcceptance: 'NOT_VERIFIED_BY_HTTP',
+  }
+}
+
+/** 默认仅展示范围；显式报告只读分析，不发现历史目录、不联网、不执行验收。 */
+async function main(argv) {
+  if (argv.length && !(argv.length === 2 && argv[0] === '--report')) {
+    throw new Error('用法：node scripts/acceptance-overview.mjs [--report <明确JSON路径>]')
+  }
+  const scope = describeAcceptanceScope()
+  const result = {
+    purpose: '离线验收范围总览，不执行HTTP，不证明当前部署通过',
+    admin: { entry: 'scripts/admin-test-env-acceptance.mjs', ...scope },
+    otherEntries: [
+      { entry: 'scripts/client-test-env-acceptance.mjs', scope: 'Client全量HTTP，独立执行' },
+      { entry: 'scripts/client-phase2-test-env-acceptance.mjs', scope: '测量计费专项，不替代Client全量' },
+      { entry: 'scripts/fleet-test-env-acceptance.mjs', scope: '车辆专项，不计入Admin默认全量' },
+    ],
+    boundaries: ['可选模块不等于默认执行；其他专项入口详见scripts/README.md',
+      '本地合同、HTTP、页面与真机验收分别报告',
+      '报告通过只代表该次记录；需另核对源码、配置与实际部署版本',
+      '环境与凭据前置仍由实际入口校验；本工具不读取环境文件'],
+  }
+  if (argv.length) result.report = summarizeReport(JSON.parse(await readFile(resolve(argv[1]), 'utf8')))
+  console.log(JSON.stringify(result, null, 2))
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  main(process.argv.slice(2)).catch((error) => { console.error(error.message); process.exitCode = 1 })
+}

scripts/acceptance-overview.test.mjs

@@ -0,0 +1,46 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { summarizeReport } from './acceptance-overview.mjs'
+import { describeAcceptanceScope } from './admin-test-env-acceptance.mjs'
+
+test('注册表返回独立副本，默认与可选不重复', () => {
+  const scope = describeAcceptanceScope()
+  assert.ok(scope.defaultModules.includes('appointment-work'))
+  assert.ok(scope.optionalModules.includes('phase4-overseas-return-followups'))
+  assert.ok(scope.optionalModules.every((name) => !scope.defaultModules.includes(name)))
+  scope.defaultModules.length = 0
+  assert.ok(describeAcceptanceScope().defaultModules.length > 0)
+})
+
+test('旧报告全绿也不推断默认全量或当前版本通过', () => {
+  const result = summarizeReport({ success: true, steps: [{ module: 'orders', passed: true }] })
+  assert.equal(result.scope, 'UNKNOWN_LEGACY_REPORT')
+  assert.equal(result.currentVersionVerified, false)
+  assert.equal(result.result, 'RECORDED_CHECKS_PASSED')
+})
+
+test('跳过、覆盖缺口和未执行模块不能被success掩盖', () => {
+  const base = { success: true, steps: [{ module: 'orders', passed: true }],
+    executionScope: { plannedModules: ['orders', 'finance'], defaultModules: ['orders', 'finance'] } }
+  assert.equal(summarizeReport(base).result, 'INCOMPLETE')
+  assert.deepEqual(summarizeReport(base).missingPlannedModules, ['finance'])
+  assert.equal(summarizeReport({ ...base, coverageGaps: [{ blocking: true }] }).result, 'FAILED')
+  assert.equal(summarizeReport({ steps: [{ passed: true, skipped: true }] }).result, 'INCOMPLETE')
+  assert.equal(summarizeReport({ steps: [{ passed: true }], modules: [{ name: 'orders', skipped: true }] }).result, 'INCOMPLETE')
+})
+
+test('前置退出与接口失败分开统计，输出不携带敏感载荷', () => {
+  const result = summarizeReport({ success: false, gateway: 'SECRET', steps: [
+    { module: 'exports', passed: false, request: { path: 'SECRET' }, message: 'SECRET' },
+    { module: 'dependent', passed: false, evidence: 'SECRET' },
+  ] })
+  assert.equal(result.failed, 2)
+  assert.equal(result.failuresWithRequest, 1)
+  assert.equal(result.failuresWithoutRequest, 1)
+  assert.equal(JSON.stringify(result).includes('SECRET'), false)
+})
+
+test('准备数据和局部模式不冒充完整验收，空报告拒绝', () => {
+  assert.equal(summarizeReport({ fullAcceptance: false, steps: [{ passed: true }] }).result, 'INCOMPLETE')
+  assert.throws(() => summarizeReport({ success: true, steps: [] }), /steps/)
+})

scripts/admin-test-env-acceptance.mjs

@@ -57,6 +57,8 @@ export function planA0LocationIsolation(locations, requiredSlots = 1,
 }
 
 const MODULE_DEPENDENCIES = new Map([
+  ['inbound-weight-ocr', ['orders']],
+  ['orders', ['merchant-qualification-fixture']],
   ['phase5-root-fulfillment', ['merchant-qualification-fixture']],
   ['pda-loading-link-regression', ['merchant-qualification-fixture']],
   ['phase4-overseas-return-followups', ['phase4-overseas-return-receipt']],
@@ -281,6 +283,14 @@ export function normalizeModuleOrder(modules) {
 }
 
 const DEFAULT_MODULES = normalizeModuleOrder(CONFIGURED_MODULES)
+
+/** 从执行注册表返回范围，供离线总览使用，避免维护第二套模块清单。 */
+export function describeAcceptanceScope() {
+  return {
+    defaultModules: [...DEFAULT_MODULES],
+    optionalModules: OPTIONAL_MODULES.filter((name) => !DEFAULT_MODULES.includes(name)),
+  }
+}
 const WEIGHT_IMAGE_PATH = process.env.ADMIN_TEST_WEIGHT_IMAGE_PATH || ''
 const CUSTOMER_FIELDS = [
   'id', 'tenantCode', 'tenantName', 'status', 'legalName', 'legalRepresentative',
@@ -1940,6 +1950,16 @@ export class AcceptanceRun {
     return {
       reportName: this.options.prepareDomesticPdaH5 ? '国内 PDA H5 待拣任务准备（非全链路验收）' : this.options.environment === 'gray' ? '灰度环境 FBA 定向闭环 HTTP API 验收' : '后台管理测试环境 HTTP API 验收', marker: this.marker,
       environment: this.options.environment || 'test', gateway: this.options.gateway,
+      executionScope: {
+        requestedModules: [...(this.options.requestedModules || [])],
+        plannedModules: [...this.options.modules],
+        defaultModules: [...DEFAULT_MODULES],
+        defaultPlanSelected: DEFAULT_MODULES.every((name) => this.options.modules.includes(name)),
+        preparationOnly: this.options.prepareDomesticPdaH5 === true || this.options.prepareDropshipManualCount === true,
+        returnMainChainOnly: this.options.returnMainChainOnly === true,
+        evidenceType: 'HTTP',
+        pageAcceptance: 'NOT_VERIFIED',
+      },
       generatedAt: new Date().toISOString(), startedAt: this.startedAt,
       success: this.fatal === null && summary.failed === 0, fatal: this.fatal,
       ...(this.options.prepareDomesticPdaH5 ? { fullAcceptance: false, purpose: 'DOMESTIC_PDA_H5_FIXTURE' } : {}),

scripts/admin-test-env-modules/README.md

@@ -1,6 +1,16 @@
 # Admin 测试环境 HTTP 模块
 
-`dispatch-workflow-extension-acceptance.mjs` 由 `../dispatch-workflow-extensions-test-env.mjs` 显式调用，不是独立CLI。双客户双目的仓扩展先从正式目录核验两FBA仓，复用本轮独立来货和PDA实收；派送费用按真实group客户使用不同合成金额，完整正常链后核对逐客户目的仓、费用、单据和交叉读取拒绝。`fleet-cross-customer-fixture.mjs` 可接收两个明确 `destinationWarehouseIds`，在任何造数写前核验全部目的仓；原单目的仓调用不变。所有写经过既有逐请求持久化和未知结果停写边界，不修改共享runner；中途故障注入无工具时明确NOT_TESTED。直接合同 `dispatch-workflow-extension-contract.test.mjs` 不证明环境通过。
+`fleet-return-redispatch-acceptance.mjs` 的原出发证明读取本轮 `LOADING_COMPLETE` 回执与 `departureDeliveries`；重派在 PDA 装车完成后回查自动生成的出库/派送及两箱已发运事实，不再调用手工安排派送或确认发车。原键重放和跨操作员拒绝仍由共享装车验证覆盖，原签收不漂移、源订单完成事件审计及资源分别释放仍须独立核对。离线模拟不能代替匹配部署的真实 HTTP。
+
+固定托盘造数中，`inbound-measurement.mjs` 只复用 `TP-001`、`YW-TP-002` 指定池中的现有托盘；一只可复用，不要求两只同时存在，两只均缺失才阻断，不自动选择池外托盘。仅明确设置内部 `allowAnyExistingPallet` 的通用场景可读取当前仓库已有资源；两者均不创建托盘。
+
+OCR模块必须通过`ADMIN_TEST_OCR_IMAGE`显式指定本轮图片，不依赖个人桌面路径；定向运行自动展开客户资质及订单前置。识别失败的空字段允许省略，但识别成功必须有有效重量与单位；人工修正和确认分别增加版本。合成称重测试图只证明上传、识别响应及人工确认协议，不代表现场称重照片或设备验收。费用项目模块按受控编码验证112条正式基线，合法扩展项目保留并单独核对分页和筛选。散板普通状态接口仅验证取消及非法派车拒绝，原单须出现在待匹配需求池；需求池接车到签收另列覆盖缺口，不以手工跳状态冒充履约。
+
+预约工作查询在本轮业务写入后，仅对服务端明确返回的 A0409“预约批次或运输关联已变化，服务端正在协调完整工作清单”或“已开船工作范围变化，请先完成服务端同步”每 5 秒重读，最多等待 240 秒；超时保留失败，其他错误不重试。这是后台完整扫描的就绪等待，不是页面响应性能验收，也不触发同步写接口。
+
+先运行 `node scripts/acceptance-overview.mjs`（后端根目录，无网络）查看当前默认与可选模块。范围来自真实注册表；本文件描述各模块用途与依赖，不代表所有模块默认执行或已通过。报告解读及跨端/专项边界见 [总索引](../README.md#先看范围再看证据)，最新运行状态只查外层部署契约。
+
+`dispatch-workflow-extension-acceptance.mjs` 由 `../dispatch-workflow-extensions-test-env.mjs` 显式调用，不是独立CLI。双客户双目的仓扩展先从正式目录核验两FBA仓，复用本轮独立来货和PDA实收；装车完成自动生成派送并发车，完整正常链后核对逐客户目的仓、实际费用、单据和交叉读取拒绝。`fleet-cross-customer-fixture.mjs` 可接收两个明确 `destinationWarehouseIds`，在任何造数写前核验全部目的仓；原单目的仓调用不变。所有写经过既有逐请求持久化和未知结果停写边界，不修改共享runner；中途故障注入无工具时明确NOT_TESTED。直接合同 `dispatch-workflow-extension-contract.test.mjs` 不证明环境通过。
 
 其 `competition` 扩展只并发两个已经成功装车命令的跨端原键重放，并回查完整库存、主单、货物和车次；不是首次执行竞争。占用资源与未安排派送发车分别串行验证拒绝后快照不变。签收成功后的自动完结只做有界只读等待，保持真实写回执，等待失败阻断下一请求而不伪报已知写为未知结果。
 
@@ -18,7 +28,7 @@
 
 `dispatch-repair-acceptance.mjs` 是本批排车修复的内部增量验收助手，不是独立 CLI。`verifyDispatchRepair` 默认只返回计划，显式执行要求 TEST、Lastleg/Admin 健康及 Schema 就绪、请求前后持久化检查点。`context.producerEvidence` 指定本轮生产回执 JSON 的路径及 SHA-256；文件须含 `environment=TEST`、`marker`、已部署 Lastleg 的 `sourceCommit` 和 `requests`。请求条目保留实际 `method/path/body/actor`、`status=RESPONDED`、`http/code/requestId/traceId/result`，不得保存登录凭据或 Token。助手从正式创建响应及父来源回执提取业务号、客户和仓库，形成资源白名单；所有 fixture 关联身份在首个请求前核对，不能仅声明“本轮新建”。缺样本标记 NOT_RUN，不借旧业务样本。
 
-该助手核对取消出库/取消排车/释放重排、实际出库门禁、换标全托、混托两种展示来源、拆合托后重核、原箱回仓及只读权限。两种混托须使用独立排车/托盘/预订，普通与外接来源的箱数由生产实收回执确定，并回查实物仓位组成及报价数量/单价/金额。原箱限本轮单箱出库，按原始 SKU、客户、仓分页精确筛选库存及流水，以排车号匹配 OUTBOUND；先取完成前 S、首次完成后 R，再同键重放取 R′，核对本轮唯一 SKU 的完成前零库存基线及首次总量、可用展示数量、箱数恢复、receiptNo 的 EXCEPTION_RETURN_IN 精确集合、目标托盘库位及重放零增量。HTTP availableQuantity 是受实箱可用量限制的展示值，不冒称裸余额证明。只对已授权的新排车调用 DELETE 取消状态，不运行移托 DELETE 负向分支，不物理删除、SQL 造数或清理。未知结果保存原命令并停写；证据明确标为合成测试资料，不冒充真实外部预约/POD。保留 `sourceEventsVerified=false`，来源事件、人工页面及 PDA 真机仍单列。相邻 `dispatch-repair-acceptance-contract.test.mjs` 只做离线验证，未实际执行不得表述为环境通过。
+该助手将已撤销的装车后取消/人工重排场景标为 NOT_APPLICABLE，仍核对实际出库门禁、换标全托、混托两种展示来源、拆合托后重核、原箱回仓及只读权限。两种混托须使用独立排车/托盘/预订，普通与外接来源的箱数由生产实收回执确定，并回查实物仓位组成及报价数量/单价/金额。原箱限本轮单箱出库，按原始 SKU、客户、仓分页精确筛选库存及流水，以排车号匹配 OUTBOUND；先取完成前 S、首次完成后 R，再同键重放取 R′，核对本轮唯一 SKU 的完成前零库存基线及首次总量、可用展示数量、箱数恢复、receiptNo 的 EXCEPTION_RETURN_IN 精确集合、目标托盘库位及重放零增量。HTTP availableQuantity 是受实箱可用量限制的展示值，不冒称裸余额证明。不运行移托 DELETE 负向分支，不物理删除、SQL 造数或清理。未知结果保存原命令并停写；证据明确标为合成测试资料，不冒充真实外部预约/POD。保留 `sourceEventsVerified=false`，来源事件、人工页面及 PDA 真机仍单列。相邻 `dispatch-repair-acceptance-contract.test.mjs` 只做离线验证，未实际执行不得表述为环境通过。
 
 - 人工状态矩阵的 `FEE_CONFIRMING` 使用独立新订单，在测量提交成功后暂停审核，经正式 `fees/calculate` 生成费用；回查同一费用版本、入库客户身份、测量仍待审核及入仓码精确筛选结果。该状态是必验项，不再列入不可造数缺口；不发送费用、不推进该样本、不借历史数据。入口仍为 `--modules manual-state-matrix`，对应 `order-inbound-status-fixtures-contract.test.mjs` 和 `manual-state-matrix-contract.test.mjs`。
 - `WAIT_PRICING` 另建保留原始 `APPROVED` 的订单，先形成未发布的 `FEE_CONFIRMING`，再通过客户实时渠道目录与报价选择同仓、同目的仓、同税制的不同渠道，以正式申报更新触发费用失效；回查 `WAIT_PRICING/UNPRICED`、新渠道及精确筛选。缺少可计价替换渠道、客户漂移或状态未收敛均失败；不写业务SQL，退出专用目录查询会话。该状态同样为必验项，原先借历史 `WAIT_SPLIT` 样本的兜底已移除。
@@ -42,7 +52,7 @@
 
 `fleet-cross-customer-fixture.mjs` 导出 `createFleetCrossCustomerFixture`，由上述专用 TEST 入口显式调用。默认只返回准备契约；执行时重新核对指定实际收货仓和FBA目的仓，通过正式客户资质、普通转运来货、PDA一托一箱测量/绑定/实收及客户确认生成两套独立本轮货物，再以真实来源一次 Create 建立同一原生排车主单、自动唯一 Fleet 资源记录并完成两级审核，停在 LOADING、零扫码、未生成出库和派送单。每条明细保留其真实客户、来货码、物理托盘和库位，主单不挂客户。客户上下文独立且不覆盖外层客户环境，退出本函数创建的客户会话，PDA启停归外层入口；无外接预订循环依赖、业务SQL、部署或自动恢复。`fleet-cross-customer-fixture-contract.test.mjs` 只证明生成编排及拒绝边界，真实运行另行留证。
 
-`fleet-cross-customer-acceptance.mjs` 是跨客户同一原生排车主单的内部后半链验收函数，不是独立入口。默认只返回 fixture 契约、零网络；显式 `execute:true` 需要同批次两个独立客户、同仓各一托一箱已实收、同一主单已通过两级审核且未拣货，以及调用方提供的完整库存只读取证器。按各明细实际客户扫码，验证一个客户未核平时整车装车/发车拒绝及全部快照不变；全部实拣核平后按实际测量显式装车、平台逐客户目的地安排，再以当前主单版本统一发车、原键重放和分别签收。实托测量缺失明确阻断，不以计费/计划常量替代。前置门禁与事务中途回滚分别记录；默认后者为 `NOT_TESTED`，只有显式注入`verifyDepartureRollback`且返回精确本轮验证、完整一致性快照恢复相同后才记VERIFIED。专用`../fleet-trip-rollback-test-env.mjs`负责租约/脏读观察与持久化，普通入口不注入故障；钩子异常、未验证或快照漂移必须停止在正常发车前。失败保留当前样本与原请求，不自动续跑、补造或清理。对应合同 `fleet-cross-customer-acceptance-contract.test.mjs` 仅证明编排与反例断言，不能代替真实运行。临时账号生命周期、最小来货生成及报告保存由外层显式编排负责。
+`fleet-cross-customer-acceptance.mjs` 是跨客户同一原生排车主单的内部后半链验收函数，不是独立入口。默认只返回 fixture 契约、零网络；显式 `execute:true` 需要同批次两个独立客户、同仓各一托一箱已实收、同一主单已通过两级审核且未拣货，以及调用方提供的完整库存只读取证器。按各明细实际客户扫码，验证一个客户未核平时整车装车/发车拒绝及全部快照不变；全部实拣核平后按实际测量确认装车，在同一次命令自动生成客户目的地单据并发车；按详情 documents 核对真实单据，原键重放和分别签收。实托测量缺失明确阻断，不以计费/计划常量替代。前置门禁与事务中途回滚分别记录；默认后者为 `NOT_TESTED`，只有显式注入`verifyDepartureRollback`且返回精确本轮验证、完整一致性快照恢复相同后才记VERIFIED。专用`../fleet-trip-rollback-test-env.mjs`负责租约/脏读观察与持久化，普通入口不注入故障；钩子异常、未验证或快照漂移必须停止在正常发车前。失败保留当前样本与原请求，不自动续跑、补造或清理。对应合同 `fleet-cross-customer-acceptance-contract.test.mjs` 仅证明编排与反例断言，不能代替真实运行。临时账号生命周期、最小来货生成及报告保存由外层显式编排负责。
 
 `TERMINAL_READONLY` 用于全部业务写入和结案助手均完成、仅专项入口汇总状态断言错误的已复核报告。结案助手成功状态为 `CARGO_COMPLETED_AND_RESOURCES_RELEASED`。该检查点登录后仅 GET 原车次、每张排车/派送、资源占用测试计划与精确财务来源版本，不重放任何业务写入，不覆盖原失败报告；真实状态、数量、签收或费用不符仍失败。它不补充生产者 ACK 或页面验收证据。
 
@@ -58,7 +68,7 @@
 
 车辆专项入口为 `../fleet-test-env-acceptance.mjs`，先使用原 `phase4-overseas-dispatch` 依赖链创建本轮客户、头程费用和海外库存，再执行专用车辆编排；不改变已通过的 F40 默认调用顺序。默认 `--plan` 无网络，实际运行须显式 `--execute --environment TEST --run-id <新批次>`。仅串行运行，会创建当前批次资源及执行正式未执行单据取消重排，不执行部署、配置修改或业务 SQL 写入；原收货取证沿用现有只读读取器。失败保留原样本、请求与报告，不自动重造或续跑。
 
-四个内部助手及各自 `*-contract.test.mjs`：`fleet-booking-reservation-acceptance.mjs` 验证询价/确认/超卖/取消的逐段占位与重放；`fleet-fee-coverage-acceptance.mjs` 用独立排车验证全覆盖及多原入仓的部分覆盖，核对原费用版本、目的地、快照及重放不重复收费；`fleet-external-receipt-acceptance.mjs` 通过正式来货与 PDA 测量、生成托盘、扫码绑定、照片和完成接口入库，按客户/仓/来货码查询余额与流水，验证重放不再入库、运营核量改价和预留替换；`fleet-external-dispatch-acceptance.mjs` 将该实收货物预排并绑定原车次，重核容量并逐客户审核，验证约定运费来源与重放。后两者会产生新外接货，必须走专用编排，不能直接加入只拣一张排车的 F40 默认流程。专项入口继续逐单 PDA 拣货、整车发车、逐目的地签收及资源释放；报告将 Finance 消费入池与生产者 ACK 分别记录，消费行存在不能冒充生产者已收到 ACK。以上助手不能独立当作全链入口，离线合同通过不代表真实 HTTP 或页面验收通过。
+四个内部助手及各自 `*-contract.test.mjs`：`fleet-booking-reservation-acceptance.mjs` 验证询价/确认/超卖/取消的逐段占位与重放；`fleet-fee-coverage-acceptance.mjs` 复用两组独立排车样本，核对装车完成自动生成单据的客户、目的地、箱数和实际费用；已撤销的人工费用覆盖选择不计作通过；`fleet-external-receipt-acceptance.mjs` 通过正式来货与 PDA 测量、生成托盘、扫码绑定、照片和完成接口入库，按客户/仓/来货码查询余额与流水，验证重放不再入库、运营核量改价和预留替换；`fleet-external-dispatch-acceptance.mjs` 将该实收货物预排并绑定原车次，重核容量并逐客户审核，验证约定运费来源与重放。后两者会产生新外接货，必须走专用编排，不能直接加入只拣一张排车的 F40 默认流程。专项入口继续逐单 PDA 拣货、整车发车、逐目的地签收及资源释放；报告将 Finance 消费入池与生产者 ACK 分别记录，消费行存在不能冒充生产者已收到 ACK。以上助手不能独立当作全链入口，离线合同通过不代表真实 HTTP 或页面验收通过。
 
 头程提交、平台编辑与取消按首次原始详情版本冻结请求。原键原载荷重放成功；同键异载荷、旧版本及新键重复操作分别核验拒绝后事实不变。Platform 编辑使用平台权限与显式客户范围，客户 Token 不得调用。
 
@@ -488,6 +498,6 @@ Client 全量为单文件，新增的客户账单、海外仓自助、跨境采
 - 必须在 `baiyue-firstleg` 根运行批量合同：`auth-login-payload` 等合同按 `scripts/...` 相对路径读取，从工作区根运行会产生 `ENOENT` 假失败。
 - `appointment-work-test-env`、`agents-index-registry`、`ci-maven-resource`、`deploy-built-service-rollback` 会 `spawn` 子进程；受限沙箱下 `EPERM` 属于运行环境限制，不是合同失败。
 - `database-schema-diff`、`prod-release-*`、`fleet-*-test-env` 等需要数据库或测试环境的合同不进入本地批量扫描；按各自 README 单独授权执行。
-- 当前 134 个模块合同中有 4 个 `fleet-*` 合同失败（`fleet-cross-customer-fixture`、`fleet-external-dispatch-acceptance`、`fleet-fee-coverage-acceptance`、`fleet-return-redispatch-acceptance`），失败点在 fleet 业务模拟断言，与脚本新增模块和本次 `phase4-overseas-dispatch`/`finance-downloads` 修改无关，另行处理。
+- 合同数量与失败清单以同一源码快照的实际报告为准，不在模块索引维护固定失败数量；当前已验/未验范围统一查外层部署契约，历史报告不覆盖最新源码。
 
 采购费用不再使用通用费用草稿、审核和发布链。`phase4-overseas-finance-cross-region.mjs` 对采购改为验证通用创建被拒绝，其他四类费用继续验证既有投递链；采购成功来源由完整样品流程核对实扣与来源关联。

scripts/admin-test-env-modules/appointment-work-contract.test.mjs

@@ -1,7 +1,26 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
 import { readFileSync } from 'node:fs'
-import { run } from './appointment-work.mjs'
+import { run, readAfterSynchronization } from './appointment-work.mjs'
+
+test('同步就绪只重试明确协调状态，超限及其他错误原样保留', async () => {
+  const coordinating = {http:200,body:{code:'A0409',message:'预约批次或运输关联已变化，服务端正在协调完整工作清单'}}
+  const success = {http:200,body:{code:'200',data:{}}}
+  let calls = 0
+  assert.equal(await readAfterSynchronization({request:async()=>++calls === 1 ? coordinating : success}, '/summary', {attempts:3,delay:async()=>{}}),success)
+  assert.equal(calls,2)
+  const scopeChanged = {http:200,body:{code:'A0409',message:'已开船工作范围变化，请先完成服务端同步'}}
+  calls=0
+  assert.equal(await readAfterSynchronization({request:async()=>++calls===1?scopeChanged:success}, '/summary', {attempts:3,delay:async()=>{}}),success)
+  assert.equal(calls,2)
+  calls=0
+  assert.equal(await readAfterSynchronization({request:async()=>{calls++;return coordinating}}, '/summary', {attempts:3,delay:async()=>{}}),coordinating)
+  assert.equal(calls,3)
+  const other={http:500,body:{code:'S0500'}}
+  assert.equal(await readAfterSynchronization({request:async()=>other}, '/summary', {delay:async()=>assert.fail('must not retry')}),other)
+  const conflict={http:200,body:{code:'A0409',message:'预约版本冲突'}}
+  assert.equal(await readAfterSynchronization({request:async()=>conflict}, '/summary', {delay:async()=>assert.fail('must not retry unrelated conflict')}),conflict)
+})
 
 const entry = readFileSync(new URL('../admin-test-env-acceptance.mjs', import.meta.url), 'utf8')
 const moduleSource = readFileSync(new URL('./appointment-work.mjs', import.meta.url), 'utf8')

scripts/admin-test-env-modules/appointment-work.mjs

@@ -1,3 +1,18 @@
+import { setTimeout as sleep } from 'node:timers/promises'
+
+export async function readAfterSynchronization(context, path, { attempts = 49, delay = () => sleep(5000) } = {}) {
+  let response
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    response = await context.request('GET', path)
+    const coordinating = response.http === 200 && String(response.body?.code) === 'A0409'
+      && ['预约批次或运输关联已变化，服务端正在协调完整工作清单',
+        '已开船工作范围变化，请先完成服务端同步'].includes(response.body?.message)
+    if (!coordinating || attempt === attempts) return response
+    await delay()
+  }
+  return response
+}
+
 function count(value) {
   const number = Number(value)
   return Number.isFinite(number) ? number : NaN
@@ -15,7 +30,7 @@ export async function run(context) {
   const from = shanghaiDate(-7)
   const to = shanghaiDate(7)
 
-  const calendarResponse = await context.request('GET', `${base}/calendar?from=${from}&to=${to}`)
+  const calendarResponse = await readAfterSynchronization(context, `${base}/calendar?from=${from}&to=${to}`)
   const calendar = context.apiSuccess(module, '查询预约工作日历', calendarResponse)
   const days = Array.isArray(calendar?.days) ? calendar.days : []
   const dayTotal = days.reduce((sum, day) => sum + Number(day?.total || 0), 0)
@@ -29,14 +44,14 @@ export async function run(context) {
       `date=${day?.date || 'missing'},total=${day?.total ?? 'missing'},typeTotal=${typeTotal}`)
   }
 
-  const summaryResponse = await context.request('GET', `${base}/summary`)
+  const summaryResponse = await readAfterSynchronization(context, `${base}/summary`)
   const summary = context.apiSuccess(module, '查询预约工作汇总', summaryResponse)
   const summaryFields = ['all', 'followToday', 'overdue', 'undated', 'review']
   context.assert(module, '工作汇总五项计数完整', summaryResponse,
     summaryFields.every((field) => Number.isFinite(Number(summary?.[field]))),
     summaryFields.map((field) => `${field}=${summary?.[field] ?? 'missing'}`).join(','))
 
-  const pageResponse = await context.request('GET', `${base}/items?view=ALL&page=1&size=20`)
+  const pageResponse = await readAfterSynchronization(context, `${base}/items?view=ALL&page=1&size=20`)
   const page = context.apiSuccess(module, '查询预约工作事项首页', pageResponse)
   const records = Array.isArray(page?.records) ? page.records : []
   const total = count(page?.total)

scripts/admin-test-env-modules/dispatch-repair-acceptance-contract.test.mjs

@@ -63,7 +63,7 @@ function producerReport() {
   event('GET', '/api/platform/v1/last-leg/return-inventory/cartons/BOX', undefined, { cartonMark: 'BOX', sourceReturnNo: 'RT', customerId: 'C', overseasWarehouseId: 'W', status: 'AVAILABLE', items: [{ skuCode: 'SKU-A', quantity: 3 }, { skuCode: 'SKU-B', quantity: 2 }] })
   event('POST', '/api/merchant/v1/last-leg/relabel-applications', { operationWarehouseId: 'W' }, { application: { relabelNo: 'RL-N', overseasWarehouseId: 'W' } }, 'MERCHANT')
   dispatch('NDP', [candidate(null, '601', null, { sourceStage: 'RELABEL', orderRefs: 'RL-N', returnCartonSource: true })], 'RL-N', 1)
-  event('POST', '/api/platform/v1/last-leg/dispatches/NDP/transfer-delivery', {}, { outboundNo: 'O', deliveries: [{ deliveryNo: 'D' }] })
+  event('GET', '/api/platform/v1/last-leg/dispatches/NDP', undefined, { stage:'DELIVERING', documents:{outbounds:[{outboundNo:'O',customerId:'C'}],deliveries:[{deliveryNo:'D',outboundNo:'O',customerId:'C'}]} })
   event('GET', '/api/platform/v1/last-leg/delivery-orders/D/return-inbound-options?customerId=C', undefined, [{ customerId: 'C', lastMileOrderId: '91', deliveryNo: 'D', outboundNo: 'O', returnSources: [{ returnCartonId: '81', cartonMark: 'BOX', inventoryPositionId: null }] }])
   return { environment: 'TEST', marker: 'CURRENT', sourceCommit: commit, requests }
 }
@@ -98,7 +98,7 @@ test('import/plan is zero-network and missing current fixtures never become a pa
   const ctx = context(); assert.equal((await verifyDispatchRepair(ctx, {})).status, 'PLAN_ONLY'); assert.equal(ctx.calls.length, 0)
   const result = await execute(ctx, {})
   assert.equal(result.status, 'PARTIAL_NOT_ALL_VERIFIED')
-  assert.equal(Object.values(result.cases).every(row => row.status === 'NOT_RUN'), true)
+  assert.equal(Object.entries(result.cases).filter(([key])=>key!=='cancellation').every(([,row]) => row.status === 'NOT_RUN'), true)
   assert.equal(result.sourceEventsVerified, false)
 })
 for (const field of ['lastlegHealthy', 'adminHealthy', 'schemaReady']) test(`unready ${field} blocks before any HTTP`, async () => {
@@ -137,25 +137,7 @@ test('failed pre-send checkpoint leaves the command unsent', async () => {
   assert.equal(ctx.calls.length, 0)
 })
 
-test('new unpicked dispatch cancels outbound, retains cancelled history, re-arranges released pallets and replays old transfer', async () => {
-  let cancelled = false, dispatchCancelled = false, transfers = 0
-  const ctx = context((method, path, body) => {
-    if (path.endsWith('/transfer-delivery')) return ok({ outboundNo: 'O', deliveries: [{ deliveryNo: 'D' }], replayed: transfers++ > 0 })
-    if (path.includes('/delivery-orders/') && path.includes('/status')) { assert.ok(['DELIVERING', 'REJECTED', 'CANCELLED'].includes(body.status)); assert.equal(body.expectedVersion, 0); return reject() }
-    if (path.includes('/delivery-orders/')) return ok({ order: { deliveryNo: 'D', outboundNo: 'O', status: cancelled ? 'CANCELLED' : 'WAIT_DELIVERY', version: 0, packageCount: 1 } })
-    if (path.endsWith('/outbound-orders/O/cancel')) { cancelled = true; return ok(null) }
-    if (path.endsWith('/outbound-orders/O')) return ok({ outbound: { status: cancelled ? 'CANCELLED' : 'WAIT_OUTBOUND' } })
-    if (method === 'DELETE') { assert.equal(path, '/api/platform/v1/last-leg/dispatches/DP'); assert.equal(cancelled, true); dispatchCancelled = true; return ok(null) }
-    if (path.endsWith('/dispatches/DP')) return ok({ status: dispatchCancelled ? 'CANCELLED' : 'PENDING_DEPARTURE', createdAt: '2026-10-18T16:00:00', actions: { canTransfer: true } })
-    if (path.includes('/dispatches/candidates?')) return ok([{ planPalletId: '11' }])
-    if (path.endsWith('/pre-arrange')) { assert.deepEqual(body.planPalletIds, ['11']); assert.equal(dispatchCancelled, true); return ok({ dispatchNo: 'DP-NEW', status: 'PENDING_DEPARTURE', items: [{ planPalletId: '11' }] }) }
-    assert.fail(path)
-  })
-  const result = await execute(ctx, { cancellation: fresh({ allowDispatchCancellation: true, dispatchNo: 'DP', transferBody: { fees: [] }, rearrangeBody: { planPalletIds: ['11'] }, candidateQuery: { sourceStage: 'RECEIVED' } }) })
-  assert.equal(result.cases.cancellation.status, 'PASS')
-  assert.equal(ctx.calls.filter(row => row.method === 'DELETE').length, 1)
-  assert.equal(ctx.calls.some(row => row.method === 'DELETE' && row.path.includes('/items/')), false)
-})
+test('retired pre-departure cancellation is not reported as verified',async()=>{const ctx=context(),proof=await execute(ctx,{});assert.equal(proof.cases.cancellation.status,'NOT_APPLICABLE');assert.equal(ctx.calls.length,0);assert.notEqual(proof.status,'VERIFIED')})
 
 test('domain rejection cannot be faked by a missing permission; actual shipment cancellation leaves facts unchanged', async () => {
   for (const forbidden of [false, true]) {

scripts/admin-test-env-modules/dispatch-repair-acceptance.mjs

@@ -100,11 +100,11 @@ async function loadProducerResources(context) {
       must(id(data.overseasWarehouseId) === sources[0].warehouseId && same((data.items || []).map(row => id(row.warehousePalletId)).sort(), sources.map(row => id(row.candidate.warehousePalletId)).sort()), 'Dispatch birth response differs from producer selection')
       add('dispatch', data.dispatchNo, sources[0].customerId, sources[0].warehouseId, e, { dispatch: data, arrangeBody: e.body })
     }
-    match = path.match(/\/dispatches\/([^/]+)\/transfer-delivery$/)
+    match = path.match(/\/dispatches\/([^/]+)$/)
     const dispatched = match && own.dispatch.get(decodeURIComponent(match[1]))
-    if (e.method === 'POST' && dispatched && data.outboundNo && !data.replayed) {
-      add('outbound', data.outboundNo, dispatched.customerId, dispatched.warehouseId, e, { dispatchNo: dispatched.key })
-      for (const row of data.deliveries || []) add('delivery', row.deliveryNo, dispatched.customerId, dispatched.warehouseId, e, { outboundNo: data.outboundNo, dispatchNo: dispatched.key })
+    if (e.method === 'GET' && dispatched && data.stage === 'DELIVERING') {
+      for (const row of data.documents?.outbounds || []) if (id(row.customerId) === dispatched.customerId) add('outbound', row.outboundNo, dispatched.customerId, dispatched.warehouseId, e, { dispatchNo: dispatched.key })
+      for (const row of data.documents?.deliveries || []) if (id(row.customerId) === dispatched.customerId && own.outbound.has(row.outboundNo)) add('delivery', row.deliveryNo, dispatched.customerId, dispatched.warehouseId, e, { outboundNo: row.outboundNo, dispatchNo: dispatched.key })
     }
     match = path.match(/\/delivery-orders\/([^/]+)\/return-inbound-options$/)
     if (e.method === 'GET' && match && own.delivery.has(decodeURIComponent(match[1])) && Array.isArray(data)) {
@@ -242,39 +242,7 @@ export async function verifyDispatchRepair(context, fixtures, { execute = false
     finally { await context.checkpoint() }
   }
   try {
-    await run('cancellation', async f => {
-      must(f.allowDispatchCancellation === true && f.dispatchNo && f.transferBody && f.rearrangeBody, 'Owned cancellation fixture and explicit business cancel scope required')
-      const path = `${BASE}/dispatches/${encodeURIComponent(f.dispatchNo)}`
-      const original = await call('GET', path)
-      must(original.status === 'PENDING_DEPARTURE' && original.createdAt && original.actions?.canTransfer, 'New unpicked execution required')
-      const transferBody = { ...f.transferBody, idempotencyKey: key() }
-      const transfer = await call('POST', `${path}/transfer-delivery`, transferBody)
-      must(transfer.outboundNo && transfer.deliveries?.length, 'New outbound and delivery required')
-      const dpath = scope(`${BASE}/delivery-orders/${encodeURIComponent(transfer.deliveries[0].deliveryNo)}`, f.customerId)
-      const before = await call('GET', dpath)
-      must(before.order?.status === 'WAIT_DELIVERY' && before.order.outboundNo === transfer.outboundNo, 'Delivery must belong to new unexecuted outbound')
-      for (const status of ['DELIVERING', 'REJECTED', 'CANCELLED']) {
-        await call('PUT', scope(`${BASE}/delivery-orders/${encodeURIComponent(before.order.deliveryNo)}/status`, f.customerId),
-          { status, expectedVersion: before.order.version, remark: context.marker }, { failure: true })
-      }
-      must(same(shipment((await call('GET', dpath)).order), shipment(before.order)), 'Rejected status commands changed delivery')
-      const opath = `${BASE}/outbound-orders/${encodeURIComponent(transfer.outboundNo)}`
-      await call('POST', `${opath}/cancel`, { reason: context.marker })
-      must((await call('GET', opath)).outbound?.status === 'CANCELLED', 'Outbound cancellation did not persist')
-      must((await call('GET', dpath)).order?.status === 'CANCELLED', 'Linked delivery cancellation did not persist')
-      await call('DELETE', path, undefined, { cancel: true })
-      must((await call('GET', path)).status === 'CANCELLED', 'Original dispatch was not retained as cancelled')
-      const candidateQuery = new URLSearchParams(f.candidateQuery)
-      const candidates = await call('GET', `${BASE}/dispatches/candidates?${candidateQuery}`)
-      const expected = f.rearrangeBody.planPalletIds.map(id)
-      must(expected.length && expected.every(value => candidates.some(row => id(row.planPalletId) === value)), 'Cancelled source pallets were not released')
-      const replacement = await call('POST', `${BASE}/dispatches/pre-arrange`, f.rearrangeBody)
-      must(replacement.dispatchNo && replacement.dispatchNo !== f.dispatchNo && replacement.status === 'PENDING_DEPARTURE'
-        && same(replacement.items.map(row => id(row.planPalletId)).sort(), [...expected].sort()), 'Released source was not re-arranged exactly once')
-      const replay = await call('POST', `${path}/transfer-delivery`, transferBody)
-      must(replay.outboundNo === transfer.outboundNo && replay.replayed, 'Old transfer replay generated another outbound')
-      return { originalDispatchNo: f.dispatchNo, cancelledOutboundNo: transfer.outboundNo, replacementDispatchNo: replacement.dispatchNo }
-    })
+    proof.cases.cancellation = { status: 'NOT_APPLICABLE', reason: '装车完成即派送，已撤销未发车出库取消及人工安排派送场景' }
     await run('departedGate', async f => {
       const opath = `${BASE}/outbound-orders/${encodeURIComponent(f.outboundNo)}`
       const dpath = scope(`${BASE}/delivery-orders/${encodeURIComponent(f.deliveryNo)}`, f.customerId)

scripts/admin-test-env-modules/dispatch-workflow-extension-acceptance.mjs

@@ -9,10 +9,10 @@ const OPTIONS = { scenario: MODULE, deploymentBlocker: true }
 const clone = value => structuredClone(value)
 const id = value => String(value ?? '')
 export const extensionMatrix = Object.freeze([
-  { scenario: 'dual-destination', scope: 'Two fresh customers, two distinct real FBA destinations, one main/trip; distinct fee inputs and isolated execution documents', readiness: 'READY' },
+  { scenario: 'dual-destination', scope: 'Two fresh customers, two distinct real FBA destinations, one main/trip; automatic isolated execution documents and actual fee facts', readiness: 'READY' },
   { scenario: 'reviews', scope: 'Both rejection/resubmission rounds, zero-pick return and cargo/resource changes, stale/version/idempotency conflicts', readiness: 'READY' },
   { scenario: 'relabel', scope: 'Fresh three-box customer receipt, confirmed zero-scan cancellation, two applications sharing one pallet and native rearrangement', readiness: 'READY_FORMAL_THREE_BOX_RECEIPT' },
-  { scenario: 'competition', scope: 'Two-request Admin/PDA replay race, occupied resources and unarranged departure gates; first-execution race remains untested', readiness: 'READY_BOUNDED_REPLAY' },
+  { scenario: 'competition', scope: 'Two-request Admin/PDA replay race, occupied resources gates; first-execution race remains untested', readiness: 'READY_BOUNDED_REPLAY' },
   { scenario: 'bol', scope: 'Fresh same-destination cargo, empty/same/different formal appointment allocations and actual PDF conservation', readiness: 'READY_FORMAL_APPOINTMENTS' },
 ])
 export function assertDualDestinationFixture(fixture) {
@@ -30,24 +30,6 @@ export function feeCents(value) {
   const cents = Number(whole) * 100 + Number(fraction.padEnd(2, '0'))
   assert(Number.isSafeInteger(cents)); return cents
 }
-export function applyIndependentFees(body, groups, members, marker) {
-  assert.equal(groups?.length, 2); assert.equal(body.groups?.length, 2)
-  assert.equal(new Set(groups.map(row => row.groupKey)).size, 2)
-  assert.equal(new Set(groups.map(row => id(row.customerId))).size, 2)
-  const centsByCustomer = new Map(members.map((member, index) => [member.customerId, index === 0 ? 3125 : 4775]))
-  const expected = {}
-  for (const group of body.groups) {
-    const matches = groups.filter(row => row.groupKey === group.groupKey)
-    assert.equal(matches.length, 1)
-    const customerId = id(matches[0].customerId), cents = centsByCustomer.get(customerId)
-    assert(cents && group.fees?.length > 0, 'Explicit current-customer fee services required')
-    assert(!expected[customerId], 'Duplicated customer fee group')
-    for (const fee of group.fees) { fee.amount = cents / 100; fee.feeName = `${marker} TEST合成客户独立费用` }
-    expected[customerId] = group.fees.map(fee => ({ feeType: fee.feeType, currency: fee.currency, cents: feeCents(fee.amount) }))
-  }
-  return expected
-}
-
 /** Public master-data reads only; no fixture writes until both independent US FBA masters are verified. */
 export async function discoverSecondDestination(context, primaryId) {
   const get = async path => {
@@ -88,17 +70,13 @@ export async function verifyDualDestination(context, fixture, options) {
   }
   const proof = context.createdResources.dispatchWorkflowExtensions = { scenario: options.bol || 'dual-destination', marker: context.marker,
     dispatchNo: fixture.dispatchNo, status: 'CHECKING', syntheticTestMaterials: true, physicalMeasurementVerified: false,
-    hardwareVerified: false, midTransactionRollback: 'NOT_TESTED_NO_CONTROLLED_INJECTION', expectedFees: {}, isolation: [] }
+    hardwareVerified: false, midTransactionRollback: 'NOT_TESTED_NO_CONTROLLED_INJECTION', isolation: [] }
   const original = context.request
-  let arrangement, deferredFailure, raceDone = false, firstRaceDone = false, unarrangedDone = false
+  let deferredFailure, raceDone = false, firstRaceDone = false
   const mainPath = `${ROOT}/dispatches/${encodeURIComponent(fixture.dispatchNo)}`
   const pdaPath = `/api/pda/v1/last-leg/dispatches/${encodeURIComponent(fixture.dispatchNo)}`
   context.request = async function (method, path, body, ...rest) {
     if (deferredFailure) throw deferredFailure
-    if (method === 'POST' && path === `${ROOT}/dispatches/${encodeURIComponent(fixture.dispatchNo)}/transfer-delivery`) {
-      proof.expectedFees = applyIndependentFees(body, arrangement?.groups, fixture.members, context.marker)
-      proof.arrangeRequest = clone(body); await context.checkpoint()
-    }
     let response
     if (options.firstCompetition && !firstRaceDone && method === 'POST' && path === `${pdaPath}/loading-complete`
       && fixture.tripProof.loadingCommand?.body?.idempotencyKey === body?.idempotencyKey) {
@@ -107,21 +85,14 @@ export async function verifyDualDestination(context, fixture, options) {
       response = outcome.pdaResponse
       if (outcome.error) deferredFailure = outcome.error
     } else response = await original.call(this, method, path, body, ...rest)
-    if (method === 'GET' && path === `${ROOT}/dispatches/${encodeURIComponent(fixture.dispatchNo)}/delivery-arrangement`
-      && response.http === 200 && String(response.body?.code) === '200') arrangement = clone(response.body.data)
     // 写请求已收到确定回执后，只做独立扩展；后续核验失败延至下一读请求抛出，不能把已知成功伪报成未知写。
     if (!deferredFailure && response.http === 200 && String(response.body?.code) === '200') {
       try {
         if (options.competition && method === 'POST' && path === `${pdaPath}/loading-complete` && !raceDone
-          && response.body.data?.replayed !== true && response.body.data?.stage === 'AFTER_LOADING') {
+          && response.body.data?.replayed !== true && response.body.data?.stage === 'DELIVERING') {
           raceDone = true
           await verifyLoadingReplayRace(context, fixture, options, original.bind(this), body, response.body.data)
         }
-        if (options.competition && method === 'GET' && path === `${mainPath}/delivery-arrangement` && !unarrangedDone
-          && response.body.data?.stage === 'AFTER_LOADING' && response.body.data?.arrangement == null) {
-          unarrangedDone = true
-          await verifyUnarrangedDeparture(context, fixture, options, original.bind(this), response.body.data)
-        }
         if (method === 'PUT' && body?.idempotencyKey === `${context.marker}-CROSS-SIGN-1`) {
           const fence = proof.completionReadFence = { status: 'READING', attempts: [], writeReceiptPreserved: true }
           for (let attempt = 1; attempt <= 60; attempt++) {
@@ -154,11 +125,9 @@ export async function verifyDualDestination(context, fixture, options) {
     assert.equal(id(delivery.order.customerId), member.customerId)
     assert.equal(delivery.order.destinationWarehouseCode, member.destination.warehouseCode)
     assert.equal(Number(delivery.order.packageCount), 1); assert.equal(Number(delivery.order.palletCount), 1)
-    const expected = proof.expectedFees[member.customerId]
-    assert(expected?.length > 0); assert.equal(delivery.fees?.length, expected.length)
+    assert(Array.isArray(delivery.fees))
     for (const fee of delivery.fees) {
       assert(fee.id && !feeIds.has(id(fee.id))); feeIds.add(id(fee.id))
-      assert(expected.some(row => row.feeType === fee.feeType && row.currency === fee.currency && row.cents === feeCents(fee.amount)))
       assert.equal(fee.feeDirection, 'RECEIVABLE'); assert.equal(fee.sourceStatus, 'ACTIVE')
     }
     const other = fixture.members[1 - index]
@@ -170,7 +139,6 @@ export async function verifyDualDestination(context, fixture, options) {
     proof.isolation.push({ customerId: member.customerId, wrongCustomerId: other.customerId, deliveryNo: delivery.order.deliveryNo,
       http: response.http, code: response.body.code, requestId: response.requestId, traceId: response.traceId })
   }
-  assert.notDeepEqual(proof.expectedFees[fixture.members[0].customerId], proof.expectedFees[fixture.members[1].customerId])
   proof.status = 'VERIFIED'; await context.checkpoint(); return verified
 }
 
@@ -238,11 +206,11 @@ export async function executeFirstLoadingRace(context, fixture, options, send, b
     assert.equal(winnerIndexes.length, 1)
     const winnerIndex = winnerIndexes[0], winner = responses[winnerIndex], loser = responses[1 - winnerIndex]
     assert.equal(String(loser.body?.code), 'A0409')
-    assert.equal(winner.body.data.stage, 'AFTER_LOADING')
+    assert.equal(winner.body.data.stage, 'DELIVERING')
     assert.equal(winner.body.data.result?.confirmedLoad?.manifestHash, body.manifestHash)
-    assert.equal(BigInt(winner.body.data.recordVersion), BigInt(body.recordVersion) + 1n)
+    assert(BigInt(winner.body.data.recordVersion) > BigInt(body.recordVersion))
     race.after = await competitionSnapshot(context, fixture, options, send)
-    assert.equal(race.after.main.stage, 'AFTER_LOADING')
+    assert.equal(race.after.main.stage, 'DELIVERING')
     assert.equal(id(race.after.main.recordVersion), id(winner.body.data.recordVersion))
     assert.deepEqual(race.after.stock, race.before.stock)
     assert.equal(Number(race.after.main.counts.packageCount), 2)
@@ -259,20 +227,6 @@ export async function executeFirstLoadingRace(context, fixture, options, send, b
   }
 }
 
-async function verifyUnarrangedDeparture(context, fixture, options, send, arrangement) {
-  const proof = context.createdResources.dispatchWorkflowCompetition
-  const state = proof.unarrangedDeparture = { status: 'INTENT', before: await competitionSnapshot(context, fixture, options, send),
-    body: { recordVersion: arrangement.recordVersion, idempotencyKey: `${context.marker}-EXT-NO-ARRANGEMENT-DEPART`, remark: 'TEST装车后未安排派送必须拒绝' } }
-  assert.equal(state.before.main.stage, 'AFTER_LOADING'); assert.equal(state.before.main.documents?.deliveries?.length, 0)
-  await context.checkpoint()
-  const response = await send('POST', `/api/pda/v1/last-leg/dispatches/${encodeURIComponent(fixture.dispatchNo)}/depart`, state.body, fixture.pdaToken)
-  state.response = receipt(response); await context.checkpoint()
-  assert.equal(String(response.body?.code), 'A0409'); assert.match(response.body?.message || '', /派送|安排/)
-  state.after = await competitionSnapshot(context, fixture, options, send); assert.deepEqual(state.after, state.before)
-  context.assert(MODULE, 'Loaded but unarranged departure is rejected without inventory or execution mutation', response, true, '', OPTIONS)
-  state.status = 'VERIFIED'; await context.checkpoint()
-}
-
 export async function verifyCompetitionExtension(context, fixture, options) {
   const proof = context.createdResources.dispatchWorkflowCompetition = { marker: context.marker, dispatchNo: fixture.dispatchNo,
     status: 'CHECKING', firstExecutionRace: 'NOT_TESTED', arbitraryPrivilegeMatrix: 'NOT_TESTED_NO_PERMISSION_MUTATION' }
@@ -291,7 +245,7 @@ export async function verifyCompetitionExtension(context, fixture, options) {
   context.assert(MODULE, 'Occupied vehicle/driver reject a second native main without changing the existing trip or inventory', response, true, '', OPTIONS)
   proof.resourceConflict.status = 'VERIFIED'
   const verified = await verifyDualDestination(context, fixture, { ...options, competition: true })
-  assert.equal(proof.loadingReplayRace?.status, 'VERIFIED'); assert.equal(proof.unarrangedDeparture?.status, 'VERIFIED')
+  assert.equal(proof.loadingReplayRace?.status, 'VERIFIED')
   if (options.firstCompetition) assert.equal(proof.firstLoadingRace?.status, 'VERIFIED')
   proof.status = options.firstCompetition ? 'VERIFIED_FIRST_EXECUTION_AND_REPLAY' : 'VERIFIED_BOUNDED_SCOPE'
   await context.checkpoint(); return verified
@@ -784,10 +738,11 @@ export async function reconcileReviewTerminal(context, fixture, { readInventory
     assert.equal(outbound.outbound.dispatchNo, fixture.dispatchNo); assert.equal(outbound.outbound.status, 'OUTBOUNDED')
     assert.equal(delivery.order.dispatchNo, fixture.dispatchNo); assert.equal(delivery.order.status, 'DELIVERED')
     assert.equal(id(delivery.order.customerId), member.customerId); assert.equal(delivery.order.destinationWarehouseCode, member.destination.warehouseCode)
-    const expected = extension.expectedFees[member.customerId]; assert.equal(delivery.fees.length, expected.length)
+    assert(Array.isArray(delivery.fees))
+    const originalFees=old.snapshots.BEFORE_SIGN_1.members[index].delivery.fees
+    assert(Array.isArray(originalFees)); assert.deepEqual(delivery.fees,originalFees)
     for (const fee of delivery.fees) {
-      assert(!allFeeIds.has(id(fee.id))); allFeeIds.add(id(fee.id))
-      assert(expected.some(row => row.feeType === fee.feeType && row.currency === fee.currency && row.cents === feeCents(fee.amount)))
+      assert(fee.id && !allFeeIds.has(id(fee.id))); allFeeIds.add(id(fee.id))
     }
     const stock = await readInventory({ marker: context.marker, customerId: member.customerId, warehouseId: fixture.warehouseId })
     assert.deepEqual(stock, old.snapshots.BEFORE_SIGN_1.members[index].stock, 'Terminal completion must not change already shipped inventory')

scripts/admin-test-env-modules/dispatch-workflow-extension-contract.test.mjs

@@ -1,6 +1,6 @@
 import test from 'node:test'
 import assert from 'node:assert/strict'
-import { applyIndependentFees, feeCents, assertDualDestinationFixture, extensionMatrix, verifyLoadingReplayRace, executeFirstLoadingRace, assertBolPages, assertConfirmedRelabelCancellation } from './dispatch-workflow-extension-acceptance.mjs'
+import { feeCents, assertDualDestinationFixture, extensionMatrix, verifyLoadingReplayRace, executeFirstLoadingRace, assertBolPages, assertConfirmedRelabelCancellation } from './dispatch-workflow-extension-acceptance.mjs'
 import { parseExtensionArguments, runDispatchExtensions } from '../dispatch-workflow-extensions-test-env.mjs'
 
 test('default plan imports without credentials/network and keeps all unexecuted gaps explicit', async () => {
@@ -24,26 +24,6 @@ test('terminal continuation requires an explicit original report hash and is nev
     '--resume-report', 'reports/current/report.json', '--resume-report-sha256', 'a'.repeat(64)])
   assert.equal(config.scenario, 'review-terminal'); assert.equal(config.resumeReportSha256, 'a'.repeat(64))
 })
-test('actual group owner controls distinct cents even when server group ordering differs', () => {
-  const groups = [{ groupKey: 'B-GROUP', customerId: 'B' }, { groupKey: 'A-GROUP', customerId: 'A' }]
-  const body = { recordVersion: '9007199254740993', idempotencyKey: 'ORIGINAL', groups: groups.map(row => ({ groupKey: row.groupKey,
-    fees: [{ feeType: 'DELIVERY_FEE', currency: 'CNY', amount: 30 }] })) }
-  const expected = applyIndependentFees(body, groups, [{ customerId: 'A' }, { customerId: 'B' }], 'CURRENT')
-  assert.deepEqual(body.groups.map(row => row.fees[0].amount), [47.75, 31.25])
-  assert.equal(expected.A[0].cents, 3125); assert.equal(expected.B[0].cents, 4775)
-  assert.equal(body.recordVersion, '9007199254740993'); assert.equal(body.idempotencyKey, 'ORIGINAL')
-  assert(body.groups.every(row => row.fees[0].feeName.includes('TEST合成')))
-})
-test('unknown customers, repeated groups and missing real required fees fail before transport', () => {
-  const members = [{ customerId: 'A' }, { customerId: 'B' }]
-  for (const groups of [[{ groupKey: 'G', customerId: 'A' }, { groupKey: 'G', customerId: 'B' }],
-    [{ groupKey: 'A', customerId: 'A' }, { groupKey: 'X', customerId: 'FOREIGN' }]]) {
-    const body = { groups: groups.map(row => ({ groupKey: row.groupKey, fees: [{ feeType: 'DELIVERY_FEE', currency: 'CNY' }] })) }
-    assert.throws(() => applyIndependentFees(body, groups, members, 'CURRENT'))
-  }
-  assert.throws(() => applyIndependentFees({ groups: [{ groupKey: 'A', fees: [] }, { groupKey: 'B', fees: [] }] },
-    [{ groupKey: 'A', customerId: 'A' }, { groupKey: 'B', customerId: 'B' }], members, 'CURRENT'))
-})
 test('dual destination proof rejects reused customer, collapsed destination and missing route stop', () => {
   const fixture = { members: [{ customerId: 'A', destination: { key: 'FBA:ONE' }, receiptVerified: true },
     { customerId: 'B', destination: { key: 'FBA:TWO' }, receiptVerified: true }],
@@ -120,10 +100,10 @@ for (const winner of ['PDA', 'ADMIN']) test(`first valid loading CAS race record
   const context = { marker: 'CURRENT', createdResources: { dispatchWorkflowCompetition: { status: 'CHECKING' } }, checkpoint: async () => {}, assert: () => {} }
   const fixture = { dispatchNo: 'OWN', tripNo: 'TRIP', warehouseId: 'W', pdaToken: 'OWN_PDA', members: [{ customerId: 'A' }, { customerId: 'B' }] }
   const body = { recordVersion: '7', idempotencyKey: 'ORIGINAL_PDA', manifestHash: 'ACTUAL_HASH' }
-  const success = { http: 200, body: { code: '200', data: { stage: 'AFTER_LOADING', recordVersion: '8', result: { confirmedLoad: { manifestHash: 'ACTUAL_HASH' } } } } }
+  const success = { http: 200, body: { code: '200', data: { stage: 'DELIVERING', recordVersion: '8', result: { confirmedLoad: { manifestHash: 'ACTUAL_HASH' } } } } }
   const rejected = { http: 200, body: { code: 'A0409' } }, pending = []; let completed = false
   const send = async (method, path, payload, token) => {
-    if (method === 'GET') return { http: 200, body: { code: '200', data: { stage: completed ? 'AFTER_LOADING' : 'LOADING',
+    if (method === 'GET') return { http: 200, body: { code: '200', data: { stage: completed ? 'DELIVERING' : 'LOADING',
       recordVersion: completed ? '8' : '7', counts: { packageCount: 2, pickedPackageCount: 2 } } } }
     return new Promise(resolve => {
       pending.push({ resolve, token, payload })

scripts/admin-test-env-modules/fee-items-contract.test.mjs

@@ -3,7 +3,7 @@ import { readFileSync } from 'node:fs'
 import test from 'node:test'
 
 import { normalizeModuleOrder, parseArguments } from '../admin-test-env-acceptance.mjs'
-import { cleanupSucceeded, isAcceptanceFeeItem } from './fee-items.mjs'
+import { cleanupSucceeded, isAcceptanceFeeItem, formalFeeItems } from './fee-items.mjs'
 
 const source = readFileSync(new URL('./fee-items.mjs', import.meta.url), 'utf8')
 
@@ -31,7 +31,15 @@ test('stale cleanup only recognizes the acceptance-owned code and name pair', ()
 
 test('baseline checks run only after stale acceptance cleanup', () => {
   assert.ok(source.indexOf('cleanupStaleAcceptanceItems(context)')
-    < source.indexOf("'正式目录112条且默认20条对应6页'"))
+    < source.indexOf("'全部目录默认20条分页与完整列表一致'"))
+})
+
+test('正式费用按编码识别，扩展停用项目保留且不掩盖缺失正式编码', () => {
+  const rows = [{ feeCode: 'FBA_HEAD_FREIGHT' }, { feeCode: 'FEE_TYPE_001' },
+    { feeCode: 'PRIVATE_LAST_MILE_DELIVERY' }, { feeCode: 'FEE_EXT_OTHER', status: 'DISABLED' }]
+  assert.deepEqual(formalFeeItems(rows), rows.slice(0, 3))
+  assert.equal(rows.length, 4)
+  assert.equal(formalFeeItems([{ feeCode: 'FEE_TYPE_111' }]).length, 0)
 })
 
 test('formal baseline includes both system fee items in addition to the 110 controlled items', () => {

scripts/admin-test-env-modules/fee-items.mjs

@@ -51,6 +51,11 @@ function expectedCodes() {
     ...Array.from({ length: 110 }, (_, index) => `FEE_TYPE_${String(index + 1).padStart(3, '0')}`),
   ].sort()
 }
+/** 正式基线按受控编码识别；其他业务合法扩展不计入112条基线。 */
+export function formalFeeItems(rows) {
+  const codes = new Set(expectedCodes())
+  return rows.filter(row => codes.has(row.feeCode))
+}
 export function isAcceptanceFeeItem(row) {
   return /^ACPT_\d+$/.test(String(row?.feeCode || ''))
     && String(row?.feeTypeName || '').startsWith('全量验收费用-')
@@ -91,16 +96,16 @@ export async function run(context) {
   const initialPageResponse = await context.request('GET', query({ page: 1, size: 20 }))
   const initialPage = context.apiSuccess(MODULE, '费用项目查看权限与分页查询', initialPageResponse,
     'page=1,size=20', OPTIONS)
-  context.assert(MODULE, '正式目录112条且默认20条对应6页', initialPageResponse,
-    records(initialPage).length === 20 && Number(initialPage?.total) === BASELINE_COUNT
-      && Number(initialPage?.pages) === 6 && Number(initialPage?.page) === 1,
+  const initial = await listAll(context)
+  context.assert(MODULE, '全部目录默认20条分页与完整列表一致', initialPageResponse,
+    records(initialPage).length === Math.min(20, initial.rows.length) && Number(initialPage?.total) === initial.rows.length
+      && Number(initialPage?.pages) === Math.ceil(initial.rows.length / 20) && Number(initialPage?.page) === 1,
     `records=${records(initialPage).length}, total=${initialPage?.total ?? 'n/a'}, pages=${initialPage?.pages ?? 'n/a'}`, OPTIONS)
   context.assert(MODULE, '费用项目查询不传 accountId 仍成功', initialPageResponse,
     success(initialPageResponse) && !String(initialPageResponse.path || initialPageResponse.request?.path || '').includes('accountId'),
     `path=${initialPageResponse.path || 'missing'}`, OPTIONS)
 
-  const initial = await listAll(context)
-  const initialRows = initial.rows
+  const initialRows = formalFeeItems(initial.rows)
   const domestic = initialRows.filter((row) => row.tradeScope === 'DOMESTIC')
   const international = initialRows.filter((row) => row.tradeScope === 'INTERNATIONAL')
   const actualCodes = initialRows.map((row) => row.feeCode).sort()
@@ -126,7 +131,8 @@ export async function run(context) {
     const response = await context.request('GET', query({ tradeScope: scope, page: 1, size: 200 }))
     const page = context.apiSuccess(MODULE, `按 ${scope} 贸易范围筛选`, response, '', OPTIONS)
     context.assert(MODULE, `${scope} 筛选数量和范围正确`, response,
-      Number(page?.total) === expected && records(page).every((row) => row.tradeScope === scope),
+      Number(page?.total) === initial.rows.filter(row => row.tradeScope === scope).length
+        && formalFeeItems(records(page)).length === expected && records(page).every((row) => row.tradeScope === scope),
       `total=${page?.total ?? 'n/a'}, records=${records(page).length}`, OPTIONS)
   }
 
@@ -142,8 +148,9 @@ export async function run(context) {
 
   const activeResponse = await context.request('GET', query({ status: 'ACTIVE', page: 1, size: 200 }))
   const activePage = context.apiSuccess(MODULE, '按 ACTIVE 状态筛选费用项目', activeResponse, '', OPTIONS)
-  context.assert(MODULE, 'ACTIVE 筛选返回112条且无停用记录', activeResponse,
-    Number(activePage?.total) === BASELINE_COUNT && records(activePage).every((row) => row.status === 'ACTIVE'),
+  context.assert(MODULE, 'ACTIVE 筛选覆盖112条正式项目且无停用记录', activeResponse,
+    Number(activePage?.total) === initial.rows.filter(row => row.status === 'ACTIVE').length
+      && formalFeeItems(records(activePage)).length === BASELINE_COUNT && records(activePage).every((row) => row.status === 'ACTIVE'),
     `total=${activePage?.total ?? 'n/a'}`, OPTIONS)
 
   const merchantLoginResponse = await context.request('POST', '/api/auth/login', {
@@ -273,8 +280,10 @@ export async function run(context) {
         `feeItemId=${feeItemId}`, OPTIONS)
     }
     const final = await listAll(context)
-    context.assert(MODULE, '清理后恢复112条正式基线且无临时编码或名称', final.response,
-      final.rows.length === BASELINE_COUNT && !final.rows.some((row) => row.feeCode === createPayload.feeCode
+    context.assert(MODULE, '清理后保留原目录与112条正式基线且无本轮临时项目', final.response,
+      formalFeeItems(final.rows).length === BASELINE_COUNT
+        && final.rows.map(row => row.feeCode).sort().join(',') === initial.rows.map(row => row.feeCode).sort().join(',')
+        && !final.rows.some((row) => row.feeCode === createPayload.feeCode
         || String(row.feeTypeName).includes(suffix)),
       `rows=${final.rows.length}, temporary=${final.rows.filter((row) => row.feeCode === createPayload.feeCode).length}`, OPTIONS)
     context.createdResources.feeItems = {

scripts/admin-test-env-modules/fleet-capacity-pool-schema-contract.test.mjs

@@ -35,9 +35,10 @@ test('one booking maps to exactly one commercial order and one actual incoming s
 })
 
 test('module and unified fresh baselines contain the exact same new table definitions', () => {
-  const module = read('lastleg-service/src/main/resources/db/lastleg.sql')
+  // 比较定义而不是文件换行；仍要求列、约束及表选项完全相同。
+  const module = read('lastleg-service/src/main/resources/db/lastleg.sql').replace(/\r\n/g, '\n')
   for (const name of ['ll_fleet_capacity_offer', 'll_fleet_capacity_offer_command', 'll_fleet_pool_order_link']) {
-    const definition = table(overseas, 'baiyue_lastleg', name)
+    const definition = table(overseas, 'baiyue_lastleg', name).replace(/\r\n/g, '\n')
     assert.ok(module.includes(definition), `${name}: module and unified contract drift`)
   }
   const sql = read('deploy/sql/migrations/overseas/baiyue_lastleg/V10__fleet_capacity_pool.sql')

scripts/admin-test-env-modules/fleet-cross-customer-acceptance-contract.test.mjs

@@ -43,8 +43,8 @@ function model(fault = '') {
       if (method === 'POST' && keys.has(body?.idempotencyKey)) {
         const prior = keys.get(body.idempotencyKey); assert.deepEqual(body,prior.body)
         if(token!==prior.actor) {
-          if(fault==='foreign departure actor accepted'&&path.endsWith('/depart'))return response({...prior.result,replayed:true})
-          if(fault==='foreign departure actor mutates'&&path.endsWith('/depart'))state[0].stock.ledger.push({...state[0].stock.ledger[0],id:'FOREIGN-ACTOR-MUTATION'})
+          if(fault==='foreign departure actor accepted'&&path.endsWith('/loading-complete'))return response({...prior.result,replayed:true})
+          if(fault==='foreign departure actor mutates'&&path.endsWith('/loading-complete'))state[0].stock.ledger.push({...state[0].stock.ledger[0],id:'FOREIGN-ACTOR-MUTATION'})
           return forbidden()
         }
         return response({...prior.result,replayed:true})
@@ -56,6 +56,7 @@ function model(fault = '') {
         if(fault==='aggregation delayed'&&state.every(s=>s.delivery?.order.status==='DELIVERED')) {
           if(aggregationReads===0)stage='DELIVERED';else aggregationReads--
         }
+        if(stopAtArrangement&&stage==='DELIVERING'&&fixture.tripProof.loadingCommand?.afterReplay)throw Error('Explicit test checkpoint after confirmed loading')
         return response(detail())
       }
       if (path.endsWith('/loading') && method === 'GET') return response({dispatchNo:'DS-ONE',status:'ACTIVE',stage,recordVersion:nativeVersion,manifestHash:'REAL-MANIFEST',
@@ -64,11 +65,15 @@ function model(fault = '') {
           evidence:[actualEvidence('weightKg',100,i),actualEvidence('volumeCbm',1,i)]}))})
       if (path.endsWith('/loading-complete')) {
         if (!state.every(s=>s.picked===1)) {
+          if(fault==='gate reorders route')[trip.trip.stops[1],trip.trip.stops[2]]=[trip.trip.stops[2],trip.trip.stops[1]]
+          if(fault==='gate mutates second customer')state[1].stock.balances[0].holdPackages='1'
           if(fault==='outage disguised as rejection')return {http:503,body:{code:'S0503'},requestId:'r',traceId:'t'}
           return reject(fault==='unrelated gate rejection'?'车次版本已变化':'逐项真实拣货尚未核平')
         }
         assert.equal(body.recordVersion,nativeVersion); assert.equal(body.measurements.length,2)
-        stage='AFTER_LOADING';nativeVersion++
+        stage='DELIVERING';nativeVersion++;trip.trip.status='IN_TRANSIT'
+        for(const [i,s] of state.entries()) { const m=members[i];s.outbound={outboundNo:`OUT${i}`,dispatchNo:'DS-ONE',overseasWarehouseId:'WH',customerId:m.customerId,status:'OUTBOUNDED',packageCount:1};s.delivery={order:{deliveryNo:`DL${i}`,customerId:fault==='foreign delivery'?'OTHER':m.customerId,dispatchNo:'DS-ONE',outboundNo:`OUT${i}`,status:fault==='partial departure'&&i===1?'WAIT_DELIVERY':'DELIVERING',version:0}} }
+        if(fault==='depart deducts again'){state[0].stock.balances[0].availablePackages='-1';state[0].stock.positions[0].availablePackages='-1'}
         confirmedLoad={manifestHash:body.manifestHash,pallets:copy(body.measurements),operatorId:'PDA-ACTOR',confirmedAt:'2026-10-19T01:00:00Z'}
         return remember(body,{confirmedLoad,loadingCompletionHash:'LOADED'},token,'LOADING_COMPLETE')
       }
@@ -82,29 +87,6 @@ function model(fault = '') {
       }
       if (path === '/api/pda/v1/last-leg/dispatches/DS-ONE') return response({dispatchNo:'DS-ONE',warehouseId:'WH',status:'ACTIVE',stage,recordVersion:nativeVersion,counts:counts(),pickingReconciled:state.every(s=>s.picked===1),
         items:items().map((item,i)=>({...item,positions:fault==='missing PDA position'?[]:[{positionId:members[i].positionId,balanceId:members[i].balanceId,availablePackages:state[i].stock.positions[0].availablePackages}]}))})
-      if (path.endsWith('/delivery-arrangement')) {
-        if(stopAtArrangement)throw Error('Explicit test checkpoint after confirmed loading')
-        return response({dispatchNo:'DS-ONE',recordVersion:nativeVersion,status:'ACTIVE',stage,cargoHash:'CARGO',loadingCompletionHash:'LOADED',arrange:{allowed:true},arrangement:arranged?{status:'ARRANGED'}:null,
-        groups:members.map((m,i)=>({groupKey:`GROUP${i}`,customerId:m.customerId,groupCargoHash:`GROUP-HASH${i}`,destination:{key:i?'FBA:B':'FBA:A'},cargo:[{customerId:m.customerId,warehousePalletId:m.palletId}],blockReasons:[],requiredServices:['DELIVERY_FEE']}))})
-      }
-      if (path.endsWith('/transfer-delivery')) {
-        assert.equal(stage,'AFTER_LOADING');assert.equal(body.recordVersion,nativeVersion);assert.equal(body.groups.length,2)
-        assert.ok(body.groups.every(g=>g.fees.length===1&&g.fees[0].amount===30))
-        for(const [i,s] of state.entries()) { const m=members[i];s.outbound={outboundNo:`OUT${i}`,dispatchNo:'DS-ONE',overseasWarehouseId:'WH',customerId:m.customerId,status:'WAIT_OUTBOUND'}
-          s.delivery={order:{deliveryNo:`DL${i}`,customerId:fault==='foreign delivery'?'OTHER':m.customerId,dispatchNo:'DS-ONE',outboundNo:`OUT${i}`,status:'WAIT_DELIVERY',version:0}} }
-        arranged=true;nativeVersion++;return remember(body,{dispatchNo:'DS-ONE',outbounds:state.map((s,i)=>({...s.outbound,packageCount:1})),deliveries:deliveryRefs()},token)
-      }
-      if (path.endsWith('/depart')) {
-        if(!arranged) {
-          if(fault==='gate reorders route')[trip.trip.stops[1],trip.trip.stops[2]]=[trip.trip.stops[2],trip.trip.stops[1]]
-          if(fault==='gate mutates second customer'){state[1].stock.balances[0].holdPackages='1';state[1].stock.balances[0].availablePackages='0';state[1].stock.positions[0].holdPackages='1';state[1].stock.positions[0].availablePackages='0'}
-          return reject('请先完成装车并一次安排全部客户派送')
-        }
-        assert.equal(body.recordVersion,nativeVersion);stage='DELIVERING';nativeVersion++;trip.trip.status='IN_TRANSIT'
-        for(const [i,s]of state.entries())if(!(fault==='partial departure'&&i===1)){s.outbound.status='OUTBOUNDED';s.delivery.order.status='DELIVERING'}
-        if(fault==='depart deducts again'){state[0].stock.balances[0].availablePackages='-1';state[0].stock.positions[0].availablePackages='-1'}
-        return remember(body,{shippedPackages:2,departedAt:'2026-10-19T01:00:00Z',deliveries:deliveryRefs(),outbounds:state.map(s=>s.outbound)},token)
-      }
       const index=members.findIndex((_m,i)=>path.includes(`/OUT${i}`)||path.includes(`/DL${i}`)),row=state[index]
       if(path.includes('/outbound-orders/'))return response({outbound:row.outbound,deliveries:[row.delivery.order]})
       if(path.endsWith('/documents')) {
@@ -127,7 +109,7 @@ test('default call and import do not request, create or activate anything',async
 test('current DTO-shaped two-customer trip rejects unready gate, departs once and signs independently',async()=>{
   const m=model();const proof=await verifyFleetCrossCustomer(m.context,m.fixture,{execute:true,readInventory:m.readInventory})
   assert.equal(proof.status,'VERIFIED');assert.equal(proof.gateProof,'PREREQUISITE_REJECTION_VERIFIED');assert.equal(proof.midTransactionRollback,'NOT_TESTED')
-  assert.equal(m.calls.filter(c=>c.raw.endsWith('/depart')).length,4)
+  assert.equal(m.calls.some(c=>c.raw.endsWith('/depart')),false)
   assert.deepEqual(m.state.map(s=>s.delivery.order.status),['DELIVERED','DELIVERED'])
   assert.ok(m.calls.filter(c=>c.raw.includes('/api/pda/')).every(c=>c.token===m.fixture.pdaToken))
   assert.ok(!JSON.stringify(proof).includes(m.fixture.pdaToken))
@@ -148,10 +130,10 @@ test('explicit rollback verifier runs after both picks and before successful dep
   const m=model();let calls=0
   const proof=await verifyFleetCrossCustomer(m.context,m.fixture,{execute:true,readInventory:m.readInventory,
     verifyDepartureRollback:async({ready,departPath,departBody})=>{
-      calls++;assert.equal(ready.trip.trip.status,'PLANNED');assert.equal(ready.dispatch.stage,'AFTER_LOADING')
-      assert.ok(ready.members.every(row=>row.outbound.outbound.status==='WAIT_OUTBOUND'))
-      assert.equal(m.calls.filter(call=>call.raw.endsWith('/depart')).length,1)
-      assert.ok(departPath.includes(m.fixture.members[0].dispatchNo));assert.equal(departBody.idempotencyKey,'RUN-CROSS-DEPART')
+      calls++;assert.equal(ready.trip.trip.status,'PLANNED');assert.equal(ready.dispatch.stage,'LOADING')
+      assert.ok(ready.members.every(row=>!row.outbound))
+      assert.equal(m.calls.filter(call=>call.raw.endsWith('/loading-complete')).length,1)
+      assert.ok(departPath.includes(m.fixture.members[0].dispatchNo));assert.ok(departBody.idempotencyKey)
       return {verified:true,scope:'OWNED_TWO_CUSTOMER_DEPARTURE_ROLLBACK'}
     }})
   assert.equal(calls,1);assert.equal(proof.midTransactionRollback,'VERIFIED')
@@ -164,8 +146,8 @@ for(const failure of ['unverified','throws','mutates'])test(`rollback verificati
       if(failure==='mutates')m.state[0].stock.balances[0].availablePackages='-1'
       return {verified:failure!=='unverified',scope:'OWNED_TWO_CUSTOMER_DEPARTURE_ROLLBACK'}
     }}))
-  assert.equal(m.calls.filter(call=>call.raw.endsWith('/depart')).length,1)
-  assert.ok(m.state.every(row=>row.delivery.order.status==='WAIT_DELIVERY'))
+  assert.equal(m.calls.filter(call=>call.raw.endsWith('/loading-complete')).length,1)
+  assert.ok(m.state.every(row=>row.delivery===null))
 })
 for(const fault of ['wrong stock scope','missing PDA position','duplicate ship','gate mutates second customer','gate reorders route','outage disguised as rejection','unrelated gate rejection','partial departure','depart deducts again','signs both','foreign delivery','foreign departure actor accepted','foreign departure actor mutates']) {
   test(`fails closed without widening the claimed evidence: ${fault}`,async()=>{
@@ -194,7 +176,7 @@ async function afterLoadingModel(fault = '') {
   const priorProof = structuredClone(m.context.createdResources.fleetCrossCustomer)
   assert.equal(priorProof.status,'FAILED')
   assert.equal(priorProof.gateProof,'PREREQUISITE_REJECTION_VERIFIED')
-  assert.equal(m.fixture.tripProof.loadingCommand.result.stage,'AFTER_LOADING')
+  assert.equal(m.fixture.tripProof.loadingCommand.result.stage,'DELIVERING')
   delete m.context.createdResources.fleetCrossCustomer
   m.fixture.stage = afterLoadingContinuationContract.stage
   m.resumeAfterLoading()
@@ -227,7 +209,7 @@ test('explicit after-loading continuation reconciles original proof and never re
   const m=await afterLoadingModel(),original=structuredClone(m.priorProof),loading=structuredClone(m.fixture.tripProof.loadingCommand)
   const proof=await continueLoaded(m)
   assert.equal(proof.status,'VERIFIED');assert.equal(proof.continued,true)
-  assert.equal(proof.continuation.mode,'EXPLICIT_AFTER_LOADING')
+  assert.equal(proof.continuation.mode,'EXPLICIT_COMPLETED_LOADING')
   assert.equal(proof.continuation.gateProofSource,'PRIOR_PROOF')
   assert.match(proof.continuation.priorProofSHA256,/^[a-f0-9]{64}$/)
   const normalize=value=>Array.isArray(value)?value.map(normalize):value&&typeof value==='object'?Object.fromEntries(Object.keys(value).sort().map(key=>[key,normalize(value[key])])):value
@@ -235,33 +217,12 @@ test('explicit after-loading continuation reconciles original proof and never re
   assert.deepEqual(m.priorProof,original);assert.deepEqual(m.fixture.tripProof.loadingCommand,loading)
   assert.equal(proof.snapshots.AFTER_PICK_1,undefined,'no historical loading snapshot is fabricated in the new proof')
   assert.ok(proof.snapshots.CONTINUATION_INITIAL);assert.deepEqual(proof.continuation.originalAfterPickSnapshot,original.snapshots.AFTER_PICK_1)
-  assert.equal(writes(m).some(call=>call.raw.endsWith('/pick')||call.raw.endsWith('/loading-complete')),false)
-  assert.equal(writes(m).filter(call=>call.raw.endsWith('/transfer-delivery')).length,2,'one arrangement plus the exact original-key replay')
-  const departures=writes(m).filter(call=>call.raw.endsWith('/depart'))
-  assert.deepEqual(departures.map(call=>call.token),[m.fixture.pdaToken,m.fixture.pdaToken,m.context.token])
+  assert.equal(writes(m).some(call=>call.raw.endsWith('/pick')),false)
+  assert.equal(writes(m).some(call=>call.raw.endsWith('/transfer-delivery')||call.raw.endsWith('/depart')),false)
   assert.deepEqual(m.state.map(row=>row.delivery.order.status),['DELIVERED','DELIVERED'])
   assert.equal(JSON.stringify(proof).includes(m.fixture.pdaToken),false)
 })
 
-test('after-loading accepts the official NON_NULL preview when the unarranged field is omitted',async()=>{
-  const m=await afterLoadingModel()
-  let omitted=false
-  alterRead(m,path=>path.endsWith('/delivery-arrangement'),value=>{
-    delete value.arrangement
-    omitted=!Object.hasOwn(value,'arrangement')
-  })
-  const proof=await continueLoaded(m)
-  assert.equal(omitted,true);assert.equal(proof.status,'VERIFIED');assert.equal(proof.continued,true)
-  assert.equal(writes(m).some(call=>call.raw.endsWith('/pick')||call.raw.endsWith('/loading-complete')),false)
-})
-
-test('after-loading rejects even an empty existing arrangement object before any business write',async()=>{
-  const m=await afterLoadingModel()
-  alterRead(m,path=>path.endsWith('/delivery-arrangement'),value=>{value.arrangement={}})
-  await assert.rejects(continueLoaded(m),/Continuation has no prior arrangement/)
-  assert.equal(writes(m).length,0)
-})
-
 for(const failure of ['missing prior','marker','gate','source identity','prior picking','unknown prior write','loading result','loading manifest','loading pallet','loading version']) {
   test(`after-loading refuses incomplete or foreign source proof before any request: ${failure}`,async()=>{
     const m=await afterLoadingModel()
@@ -279,7 +240,7 @@ for(const failure of ['missing prior','marker','gate','source identity','prior p
   })
 }
 
-for(const failure of ['inventory drift','current main version','current shipped','existing outbound','current source identity','manifest drift','confirmed load drift','existing arrangement']) {
+for(const failure of ['inventory drift','current main version','current shipped','existing outbound','current source identity']) {
   test(`after-loading refuses changed current facts before arranging or departing: ${failure}`,async()=>{
     const m=await afterLoadingModel()
     if(failure==='inventory drift')m.state[0].stock.ledger.push({...m.state[0].stock.ledger[0],id:'UNEXPECTED-MOVEMENT'})

scripts/admin-test-env-modules/fleet-cross-customer-acceptance.mjs

@@ -30,8 +30,8 @@ export const fixtureContract = Object.freeze({
 
 export const afterLoadingContinuationContract = Object.freeze({
   ...fixtureContract,
-  stage: 'TWO_OWNED_CUSTOMERS_ONE_DISPATCH_AFTER_LOADING_NOT_ARRANGED',
-  preparation: 'Explicit continuation only: prior failed proof with verified gate and complete AFTER_PICK_1; original successful loadingCommand/confirmedLoad; current AFTER_LOADING with no arrangement or execution documents.',
+  stage: 'TWO_OWNED_CUSTOMERS_ONE_DISPATCH_DELIVERING',
+  preparation: 'Explicit continuation only: prior failed proof with verified gate and complete AFTER_PICK_1; original successful loadingCommand/confirmedLoad; current DELIVERING with automatically created execution documents.',
   boundary: 'Reconcile original identities, complete picked inventory and original loading receipt through current reads before any new write. Never repeat picking/loading or rewrite the prior proof.',
 })
 
@@ -42,7 +42,7 @@ export async function verifyFleetCrossCustomer(context, fixture, { execute = fal
 
 export async function continueFleetCrossCustomerAfterLoading(context, fixture, { execute = false, readInventory, verifyDepartureRollback, priorProof, completionPolling } = {}) {
   if (!execute) return afterLoadingContinuationContract
-  if (!priorProof) throw new Error('Explicit prior cross-customer proof is required for AFTER_LOADING continuation')
+  if (!priorProof) throw new Error('Explicit prior cross-customer proof is required for completed-loading continuation')
   return runCrossCustomerCore(context, { ...fixture, members: structuredClone(fixture?.members) },
     { readInventory, verifyDepartureRollback, priorProof, completionPolling })
 }
@@ -161,84 +161,29 @@ async function runCrossCustomerCore(context, fixture, { readInventory, verifyDep
     equal(after, await snapshot(`PICK_REPLAY_${index}`), 'Pick replay changes neither customer nor any execution record')
   }
   try {
-    let cargoBasis, originalLoadingHash
+    let cargoBasis
     if (continuation) {
-      const prior = priorProof.snapshots?.AFTER_PICK_1, command = fixture.tripProof.loadingCommand
-      const confirmed = command?.result?.result?.confirmedLoad
-      check('Continuation has the original failed owned proof and verified prerequisite gate', priorProof.status === 'FAILED'
-        && priorProof.marker === context.marker && priorProof.dispatchNo === fixture.dispatchNo && priorProof.tripNo === fixture.tripNo
-        && id(priorProof.warehouseId) === id(fixture.warehouseId) && priorProof.gateProof === 'PREREQUISITE_REJECTION_VERIFIED'
-        && priorProof.members?.length === 2 && !priorProof.arrangeRequest && !priorProof.departure
-        && !priorProof.members.some(member => member.outboundNo || member.deliveryNo)
-        && Array.isArray(priorProof.requests) && priorProof.requests.every(entry => ['GET','HEAD','OPTIONS'].includes(entry.method) || entry.status === 'RESPONDED'))
-      const identityFields = ['marker','customerId','incomingNo','dispatchNo','dispatchItemId','balanceId','positionId','palletId','palletNo']
-      check('Continuation preserves each original customer, source, item, balance, position and physical pallet', fixture.members.every((member,index) =>
-        identityFields.every(field => id(member[field]) === id(priorProof.members[index]?.[field]))))
-      check('Prior AFTER_PICK_1 is a complete reviewed picked but not shipped native snapshot', prior?.dispatch?.dispatchNo === fixture.dispatchNo
-        && prior.dispatch.status === 'ACTIVE' && prior.dispatch.stage === 'LOADING' && prior.dispatch.reviewState === 'APPROVED'
-        && prior.dispatch.reviews?.dispatchReview?.status === 'APPROVED' && prior.dispatch.reviews?.loadingReview?.status === 'APPROVED'
-        && integer(prior.dispatch.counts?.packageCount) === 2 && integer(prior.dispatch.counts?.pickedPackageCount) === 2
-        && integer(prior.dispatch.counts?.shippedPackageCount) === 0 && prior.task?.pickingReconciled === true
-        && prior.task.dispatchNo === fixture.dispatchNo && id(prior.task.warehouseId) === id(fixture.warehouseId)
-        && prior.task.stage === 'LOADING' && id(prior.task.recordVersion) === id(prior.dispatch.recordVersion)
-        && prior.items?.dispatchNo === fixture.dispatchNo && id(prior.items.recordVersion) === id(prior.dispatch.recordVersion)
-        && prior.items.items?.length === 2 && prior.task.items?.length === 2
-        && prior.members?.length === 2 && prior.members.every(row => row.stock && !row.outbound && !row.delivery)
-        && prior.dispatch.documents?.outbounds?.length === 0 && prior.dispatch.documents?.deliveries?.length === 0)
-      check('Original loading command has a successful explicit receipt for this main and both exact physical pallets', command?.path === `${pdaPath}/loading-complete`
-        && command.body?.idempotencyKey && command.body.manifestHash && command.result?.dispatchNo === fixture.dispatchNo
-        && command.result.action === 'LOADING_COMPLETE' && command.result.idempotencyKey === command.body.idempotencyKey
-        && command.result.status === 'ACTIVE' && command.result.stage === 'AFTER_LOADING' && command.result.result?.loadingCompletionHash
-        && id(command.body.recordVersion) === id(prior.dispatch.recordVersion)
-        && /^(0|[1-9]\d*)$/.test(id(command.result.recordVersion))
-        && /^(0|[1-9]\d*)$/.test(id(command.body.recordVersion))
-        && BigInt(id(command.result.recordVersion)) > BigInt(id(command.body.recordVersion))
-        && integer(command.result.counts?.packageCount) === 2 && integer(command.result.counts?.pickedPackageCount) === 2
-        && integer(command.result.counts?.shippedPackageCount) === 0
-        && confirmed?.manifestHash === command.body.manifestHash && confirmed.operatorId && Number.isFinite(Date.parse(confirmed.confirmedAt))
-        && canonical(confirmed) === canonical(fixture.tripProof.confirmedLoad)
-        && Array.isArray(command.body.measurements) && command.body.measurements.length === 2
-        && canonical(command.body.measurements) === canonical(confirmed.pallets)
-        && new Set(confirmed.pallets.map(row => id(row.warehousePalletId))).size === 2
-        && fixture.members.every(member => confirmed.pallets.some(row => id(row.warehousePalletId) === member.palletId
-          && Number.isSafeInteger(row.palletSpaces) && row.palletSpaces > 0
-          && ['weightKg','volumeCbm'].every(field => ['number','string'].includes(typeof row[field])
-            && /^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(String(row[field])) && Number.isFinite(Number(row[field])) && Number(row[field]) > 0)
-          && Number.isSafeInteger(row.deliveryIndex) && row.deliveryIndex > 0 && fixture.tripProof.stops?.[row.deliveryIndex]?.destinationKey)))
-      proof.continued = true
-      proof.continuation = { mode: 'EXPLICIT_AFTER_LOADING', priorProofSHA256: createHash('sha256').update(canonical(priorProof)).digest('hex'),
-        priorStatus: priorProof.status, gateProofSource: 'PRIOR_PROOF', originalAfterPickSnapshot: structuredClone(prior),
-        originalLoadingCommand: structuredClone(command), originalConfirmedLoad: structuredClone(confirmed) }
-      proof.gateProof = priorProof.gateProof
-      await context.checkpoint?.()
-      const initial = await snapshot('CONTINUATION_INITIAL')
-      check('Current main is exactly the unarranged confirmed loading version with two picked and zero shipped packages', initial.dispatch.status === 'ACTIVE'
-        && initial.dispatch.stage === 'AFTER_LOADING' && initial.task.stage === 'AFTER_LOADING' && initial.trip.trip.status === 'PLANNED'
-        && id(initial.dispatch.recordVersion) === id(command.result.recordVersion) && initial.task.pickingReconciled === true
-        && initial.dispatch.reviewState === 'APPROVED' && initial.dispatch.reviews?.dispatchReview?.status === 'APPROVED'
-        && initial.dispatch.reviews?.loadingReview?.status === 'APPROVED' && integer(initial.dispatch.counts.packageCount) === 2
-        && integer(initial.dispatch.counts.pickedPackageCount) === 2 && integer(initial.dispatch.counts.shippedPackageCount) === 0
-        && initial.dispatch.documents?.outbounds?.length === 0 && initial.dispatch.documents?.deliveries?.length === 0
-        && id(initial.trip.trip.vehicleId) === id(fixture.tripProof.vehicleId) && id(initial.trip.trip.driverId) === id(fixture.tripProof.driverId)
-        && id(prior.trip?.trip?.vehicleId) === id(fixture.tripProof.vehicleId) && id(prior.trip?.trip?.driverId) === id(fixture.tripProof.driverId)
-        && canonical(initial.trip.trip.stops) === canonical(fixture.tripProof.stops)
-        && initial.items.items.every(item => integer(item.pickedPackages) === 1) && initial.task.items.every(item => integer(item.pickedPackages) === 1))
-      equal(prior.members.map(row => row.stock), initial.members.map(row => row.stock), 'Continuation current complete inventory equals original AFTER_PICK_1 inventory')
-      const sourceItems = items => items.map(item => Object.fromEntries(['dispatchItemId','customerId','sourceKey','sourceVersion','sourceType',
-        'planPalletId','returnReceiptId','relabelNo','warehousePalletId','palletNo','orderNo','inboundCode','destination','scheduledPackages','pickedPackages']
-        .map(field => [field,item[field]]))).sort((a,b) => id(a.dispatchItemId).localeCompare(id(b.dispatchItemId)))
-      equal(sourceItems(prior.items.items), sourceItems(initial.items.items), 'Continuation preserves both picked source items and destinations')
-      const loading = await request('GET', `${pdaPath}/loading`, undefined, 'Reconcile current native manifest against original successful loading receipt', true)
-      check('Current loading preview preserves the original manifest, confirmed receipt and two reconciled physical pallets', loading.dispatchNo === fixture.dispatchNo
-        && loading.status === 'ACTIVE' && loading.stage === 'AFTER_LOADING' && id(loading.recordVersion) === id(command.result.recordVersion)
-        && loading.pickingReconciled === true && loading.manifestHash === confirmed.manifestHash
-        && canonical(loading.confirmedLoad) === canonical(confirmed) && loading.pallets?.length === 2
-        && new Set(loading.pallets.map(row => id(row.warehousePalletId))).size === 2
-        && fixture.members.every(member => loading.pallets.some(row => id(row.warehousePalletId) === member.palletId
-          && row.palletNo === member.palletNo && integer(row.scheduledPackages) === 1 && integer(row.pickedPackages) === 1)))
-      proof.continuation.currentLoadingPreview = loading
-      cargoBasis = initial
-      originalLoadingHash = command.result.result.loadingCompletionHash
+      const command = fixture.tripProof.loadingCommand
+      const prior = priorProof.snapshots?.AFTER_PICK_1
+      check('Continuation preserves original successful loading command and current-run picked inventory', priorProof.dispatchNo === fixture.dispatchNo && priorProof.marker === context.marker && priorProof.gateProof === 'PREREQUISITE_REJECTION_VERIFIED'
+        && canonical(priorProof.members) === canonical(proof.members)
+        && priorProof.requests.every(row => row.method === 'GET' || row.status === 'RESPONDED')
+        && Number(prior?.dispatch?.counts?.pickedPackageCount) === 2 && id(command?.body?.recordVersion) === id(prior?.dispatch?.recordVersion)
+        && canonical(command?.body?.measurements) === canonical(command?.result?.result?.confirmedLoad?.pallets)
+        && prior?.dispatch?.dispatchNo === fixture.dispatchNo && prior.dispatch.stage === 'LOADING'
+        && command?.body?.idempotencyKey && command.result?.action === 'LOADING_COMPLETE' && command.result.stage === 'DELIVERING'
+        && command.result.dispatchNo === fixture.dispatchNo && command.result.idempotencyKey === command.body.idempotencyKey
+        && command.result.result?.confirmedLoad?.manifestHash === command.body.manifestHash)
+      const current = await snapshot('CONTINUATION_INITIAL')
+      check('Continuation is already delivering with the original automatic documents', current.dispatch.stage === 'DELIVERING'
+        && current.task.stage === 'DELIVERING' && current.trip.trip.status === 'IN_TRANSIT'
+        && id(current.dispatch.recordVersion) === id(command.result.recordVersion) && Number(current.dispatch.counts.shippedPackageCount) === 2
+        && canonical(current.items.items) === canonical(prior.items.items)
+        && current.dispatch.documents?.outbounds?.length === 2 && current.dispatch.documents?.deliveries?.length === 2)
+      equal(prior.members.map(row => row.stock), current.members.map(row => row.stock), 'Continuation preserves complete picked inventory')
+      proof.continued = true; proof.gateProof = priorProof.gateProof
+      proof.continuation = { mode: 'EXPLICIT_COMPLETED_LOADING', gateProofSource:'PRIOR_PROOF', originalAfterPickSnapshot:structuredClone(prior), priorProofSHA256: createHash('sha256').update(canonical(priorProof)).digest('hex') }
+      cargoBasis = prior
     } else {
       const initial = await snapshot('INITIAL')
     check('Fresh native fixture is reviewed LOADING with both customer receipts untouched', initial.trip.trip.status === 'PLANNED'
@@ -257,67 +202,46 @@ async function runCrossCustomerCore(context, fixture, { readInventory, verifyDep
     await request('POST', `${pdaPath}/loading-complete`, { recordVersion: rejectedBefore.task.recordVersion, idempotencyKey: key('UNREADY-LOAD'),
       manifestHash: preview.manifestHash, measurements: [], remark: context.marker }, 'Unready second customer blocks explicit loading', true,
       message => /拣货.*核平|尚未核平/.test(message))
-    await request('POST', `${pdaPath}/depart`, { recordVersion: rejectedBefore.task.recordVersion, idempotencyKey: key('UNREADY-DEPART'), remark: context.marker },
-      'Unready second customer blocks whole trip before execution', true, message => /装车|派送/.test(message))
     equal(rejectedBefore, await snapshot('GATE_AFTER'), 'Rejected departure leaves both complete inventories/outbounds/deliveries/trip unchanged')
     proof.gateProof = 'PREREQUISITE_REJECTION_VERIFIED'
     await pick(proof.members[1], 1)
-      await confirmFleetLoading(context, MODULE, fixture.tripProof, fixture.pdaToken, fixture.loadingMeasurements)
       cargoBasis = proof.snapshots.AFTER_PICK_1
+      await confirmFleetLoading(context, MODULE, fixture.tripProof, fixture.pdaToken, fixture.loadingMeasurements, async command => {
+        if (verifyDepartureRollback === undefined) return
+        check('Explicit rollback verifier is callable', typeof verifyDepartureRollback === 'function')
+        const ready = await snapshot('READY')
+        const rollback = await verifyDepartureRollback({ context, fixture, ready, departPath: command.path, departBody: command.body, snapshot })
+        check('Mid-transaction rollback has exact owned verification', rollback?.verified === true && rollback.scope === 'OWNED_TWO_CUSTOMER_DEPARTURE_ROLLBACK')
+        equal(ready, await snapshot('ROLLBACK_RESTORED'), 'Rollback restores both complete inventory snapshots before loading completion')
+        proof.rollbackEvidence = rollback; proof.midTransactionRollback = 'VERIFIED'
+      })
     }
-    const arrangement = await request('GET', `${path}/delivery-arrangement`, undefined, 'Read native loaded per-customer delivery arrangement')
-    if (continuation) check('Continuation has no prior arrangement and retains the original loading completion hash', arrangement.arrangement == null
-      && arrangement.loadingCompletionHash === originalLoadingHash && id(arrangement.recordVersion) === id(fixture.tripProof.loadingCommand.result.recordVersion))
-    check('Loaded arrangement groups cover exactly both real customers', arrangement.dispatchNo === fixture.dispatchNo && arrangement.status === 'ACTIVE'
-      && arrangement.stage === 'AFTER_LOADING' && arrangement.arrange?.allowed === true && arrangement.cargoHash && arrangement.loadingCompletionHash
-      && arrangement.groups?.length === 2 && proof.members.every(m => arrangement.groups.some(g => id(g.customerId) === m.customerId && g.cargo?.length
-        && g.cargo.every(c => id(c.customerId) === m.customerId && id(c.warehousePalletId) === m.palletId) && g.blockReasons?.length === 0
-        && g.destination?.key === cargoBasis.items.items.find(i => id(i.customerId) === m.customerId)?.destination?.key)))
-    const arrangeBody = { recordVersion: arrangement.recordVersion, idempotencyKey: key('ARRANGE'), cargoHash: arrangement.cargoHash,
-      loadingCompletionHash: arrangement.loadingCompletionHash, groups: arrangement.groups.map(g => ({ groupKey: g.groupKey, groupCargoHash: g.groupCargoHash,
-        plannedDeliveryAt: new Date(Date.now() + 21600000).toISOString(), deliveryMethod: 'TRUCK_PALLET', pickupMethod: 'WAREHOUSE_PICKUP',
-        loadingType: 'PALLET', vehicleType: 'TRUCK', vehicleSize: '本轮实际装载', appointmentAccount: 'SELF', remark: `${context.marker} TEST合成资料`,
-        externalFreightHash: g.externalFreightHash, feeCoverageCargoHash: g.feeCoverageCargoHash, feeCoverage: [],
-        fees: (g.requiredServices || []).map(feeType => ({ feeType, feeName: 'TEST本轮派送费', direction: 'RECEIVABLE', currency: 'CNY', amount: 30 })) })) }
-    proof.arrangeRequest = arrangeBody
-    const arranged = await request('POST', `${path}/transfer-delivery`, arrangeBody, 'Arrange both customers after real loading before departure')
-    check('Native arrangement creates customer-isolated outbounds and deliveries', arranged.dispatchNo === fixture.dispatchNo && arranged.stage === 'AFTER_LOADING'
-      && arranged.result?.deliveries?.length === 2 && arranged.result.outbounds?.length === 2
-      && new Set(arranged.result.deliveries.map(d => d.deliveryNo)).size === 2 && new Set(arranged.result.outbounds.map(o => o.outboundNo)).size === 2)
+    const detail = await request('GET', path, undefined, 'Read documents created by the one loading-complete command')
+    const documents = detail.documents
+    check('Automatic loading creates both customer-isolated outbounds and deliveries', detail.dispatchNo === fixture.dispatchNo && detail.stage === 'DELIVERING'
+      && documents?.deliveries?.length === 2 && documents.outbounds?.length === 2
+      && new Set(documents.deliveries.map(d => d.deliveryNo)).size === 2 && new Set(documents.outbounds.map(o => o.outboundNo)).size === 2)
     for (const [index, member] of proof.members.entries()) {
-      const deliveries = arranged.result.deliveries.filter(d => id(d.customerId) === member.customerId)
-      check('Each customer has exactly its own source-specific delivery and outbound', deliveries.length === 1 && integer(deliveries[0].packageCount) === 1
-        && arranged.result.outbounds.some(o => id(o.customerId) === member.customerId && o.outboundNo === deliveries[0].outboundNo && integer(o.packageCount) === 1))
+      const deliveries = documents.deliveries.filter(d => id(d.customerId) === member.customerId)
+      check('Each customer has its own source destination and quantity', deliveries.length === 1 && deliveries[0].status === 'DELIVERING'
+        && integer(deliveries[0].packageCount) === 1 && deliveries[0].destination?.key === cargoBasis.items.items.find(i => id(i.customerId) === member.customerId)?.destination?.key
+        && documents.outbounds.some(o => id(o.customerId) === member.customerId && o.status === 'OUTBOUNDED' && o.outboundNo === deliveries[0].outboundNo && integer(o.packageCount) === 1))
       Object.assign(member, { outboundNo: deliveries[0].outboundNo, deliveryNo: deliveries[0].deliveryNo })
       Object.assign(fixture.members[index], { outboundNo: member.outboundNo, deliveryNo: member.deliveryNo })
     }
-    const arrangedReplay = await request('POST', `${path}/transfer-delivery`, arrangeBody, 'Replay exact native customer arrangement')
-    check('Native arrangement replay keeps original documents and main version', arrangedReplay.replayed === true && id(arrangedReplay.recordVersion) === id(arranged.recordVersion)
-      && canonical(arrangedReplay.result) === canonical(arranged.result))
-    const ready = await snapshot('READY'), departBody = { recordVersion: ready.task.recordVersion, idempotencyKey: key('DEPART'), remark: context.marker }
-    const departPath = `${pdaPath}/depart`
-    if (verifyDepartureRollback !== undefined) {
-      check('Explicit rollback verifier is callable', typeof verifyDepartureRollback === 'function')
-      const rollback = await verifyDepartureRollback({ context, fixture, ready, departPath, departBody, snapshot })
-      check('Mid-transaction rollback has exact owned verification', rollback?.verified === true && rollback.scope === 'OWNED_TWO_CUSTOMER_DEPARTURE_ROLLBACK')
-      equal(ready, await snapshot('ROLLBACK_RESTORED'), 'Mid-transaction rollback restores both complete customer execution and inventory snapshots')
-      proof.rollbackEvidence = rollback; proof.midTransactionRollback = 'VERIFIED'
-    }
-    const departed = await request('POST', departPath, departBody, 'Depart one cross-customer native dispatch once', true)
-    check('Departure includes both customers in the one actual native main', departed.dispatchNo === fixture.dispatchNo && departed.status === 'ACTIVE'
-      && departed.stage === 'DELIVERING' && integer(departed.result?.shippedPackages) === 2 && departed.result.deliveries?.length === 2)
+    const command = fixture.tripProof.loadingCommand, departed = command.result
     proof.departure = departed
     const after = await snapshot('DEPARTED')
     check('Both customer outbounds completed and main delivering', after.trip.trip.status === 'IN_TRANSIT' && after.dispatch.stage === 'DELIVERING'
       && after.members.every(row => row.outbound.outbound.status === 'OUTBOUNDED' && row.delivery.order.status === 'DELIVERING'))
-    equal(ready.members.map(row => row.stock), after.members.map(row => row.stock), 'Departure does not deduct either inventory again')
-    const replay = await request('POST', departPath, departBody, 'Original PDA actor exact replay of native departure', true)
-    check('Shared departure replay is explicit and returns original result', replay.replayed === true && id(replay.recordVersion) === id(departed.recordVersion)
+    equal(cargoBasis.members.map(row => row.stock), after.members.map(row => row.stock), 'Loading completion does not deduct either inventory again')
+    const replay = await request('POST', command.path, command.body, 'Original PDA actor exact replay of loading completion', true)
+    check('Loading replay returns the original complete result', replay.replayed === true && id(replay.recordVersion) === id(departed.recordVersion)
       && canonical(replay.result) === canonical(departed.result))
     const replayed = await snapshot('DEPART_REPLAY')
-    equal(after, replayed, 'Departure replay preserves both complete inventories and execution facts')
-    await request('POST', `${path}/depart`, departBody, 'Different platform actor cannot reuse the PDA departure command key', false, 'ACTOR_FORBIDDEN')
-    equal(replayed, await snapshot('FOREIGN_ACTOR_DEPART_REJECTED'), 'Different actor rejection preserves both complete inventories and execution facts')
+    equal(after, replayed, 'Loading replay preserves both complete inventories and execution documents')
+    await request('POST', `${path}/loading-complete`, command.body, 'Different platform actor cannot reuse the PDA loading key', false, 'ACTOR_FORBIDDEN')
+    equal(replayed, await snapshot('FOREIGN_ACTOR_DEPART_REJECTED'), 'Actor rejection preserves both complete inventories and execution facts')
     for (const [index, member] of proof.members.entries()) {
       const before = await snapshot(`BEFORE_SIGN_${index}`), documentPath = scoped(`${ROOT}/delivery-orders/${encode(member.deliveryNo)}/documents`, member.customerId)
       const docs = await request('GET', documentPath, undefined, 'Read this customer delivery document version')

scripts/admin-test-env-modules/fleet-external-dispatch-acceptance-contract.test.mjs

@@ -1,7 +1,7 @@
 import test from 'node:test'
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
-import { verifyFleetExternalDispatch, nativeArrangementGroups } from './fleet-external-dispatch-acceptance.mjs'
+import { verifyFleetExternalDispatch } from './fleet-external-dispatch-acceptance.mjs'
 
 const BASE = '/api/platform/v1/last-leg/dispatches', PDA = '/api/pda/v1/last-leg/dispatches', TRIP = '/api/platform/v1/last-leg/fleet/trips/TR-CURRENT'
 const OWN = '900719925474099301', EXT = '900719925474099302', clone = value => structuredClone(value)
@@ -21,12 +21,13 @@ function fixture(fault = '', nativeMode = false) {
   const tripProof = { tripNo: 'TR-CURRENT', dispatchNo: 'DS-OWN', warehouseId: '92', vehicleId: '71', driverId: '72', stops: [{ index: 0, destinationKey: 'ORIGIN:92' }, { index: 1, destinationKey: 'FBA:A1' }, { index: 2, destinationKey: 'FBA:A2' }],
     externalReceipt: { marker: 'CURRENT', status: 'VERIFIED', incomingNo: 'WT-CURRENT', bookingNo: 'BK-CURRENT', warehousePalletId: '33', palletNo: 'PAL-3', createRequest: { customerId: externalCustomer }, finalSegments: [segment], finalBooking: { cargo: bookingCargo, agreedAmount: 30 } } }
   if (nativeMode) tripProof.stops.pop()
-  let recordVersion = 0, fleetVersion = 0, stage = fault === 'already-loaded' ? 'AFTER_LOADING' : 'LOADING', bound = false, planned = false, review = true, saved
+  let recordVersion = 0, fleetVersion = 0, stage = fault === 'already-loaded' ? 'DELIVERING' : 'LOADING', bound = false, planned = false, review = true, saved
   const booking = () => ({ bookingNo: 'BK-CURRENT', customerId: externalCustomer, status: bound ? 'BOUND' : 'RECEIVED', incomingNo: 'WT-CURRENT', dispatchNo: bound ? 'DS-OWN' : null, recordVersion: bound ? 1 : 0, cargo: bookingCargo, agreedAmount: 30, receipt: accepted })
   const counts = rows => ({ itemCount: rows.length, palletCount: rows.length, packageCount: rows.reduce((n, i) => n + i.scheduledPackages, 0), pickedPackageCount: rows.reduce((n, i) => n + i.pickedPackages, 0), shippedPackageCount: 0 })
-  const detail = (full = false) => ({ dispatchNo: full ? 'DS-FULL' : 'DS-OWN', recordVersion: full ? 0 : recordVersion, status: 'ACTIVE', stage: full ? 'AFTER_LOADING' : stage,
+  const detail = (full = false) => ({ dispatchNo: full ? 'DS-FULL' : 'DS-OWN', recordVersion: full ? 0 : recordVersion, status: 'ACTIVE', stage: full ? 'DELIVERING' : stage,
     reviewState: review ? 'APPROVED' : 'DRAFT', reviews: { dispatchReview: { status: review ? 'APPROVED' : 'NOT_SUBMITTED' }, loadingReview: { status: review ? 'APPROVED' : 'NOT_SUBMITTED' } },
     counts: counts(full ? fullItems : items), pickingReconciled: !full && items.every(i => i.pickedPackages === i.scheduledPackages), dispatchInfo: { route: 'A1,A2' },
+    documents: stage==='DELIVERING'&&!full?documents():{outbounds:[],deliveries:[]},
     orderDetails: (full ? fullItems : items).map(i => ({ sourceKey: i.sourceKey, customerId: i.customerId, inboundCode: i.inboundCode, destinationFbaWarehouse: i.destination.warehouseCode })) })
   const ack = (action, result = {}) => ({ ...detail(), action, result, replayed: false })
   const groups = () => {
@@ -42,6 +43,7 @@ function fixture(fault = '', nativeMode = false) {
     for (const group of raw) { const previous = merged.get(group.groupKey); if (previous) { previous.cargo.push(...group.cargo); previous.externalQuotes.push(...group.externalQuotes) } else merged.set(group.groupKey, group) }
     return [...merged.values()].map(g => ({ ...g, requiredServices: g.cargo.some(c => !g.externalQuotes.some(q => q.inboundCode === c.inboundCode)) ? ['DELIVERY_FEE'] : [] }))
   }
+  const documents=()=>({outbounds:[...new Set(items.map(i=>i.customerId))].map(customerId=>({customerId,outboundNo:customerId===OWN?'OUT-OWN':'OUT-EXT',status:'OUTBOUNDED',packageCount:items.filter(i=>i.customerId===customerId).reduce((n,i)=>n+i.scheduledPackages,0)})),deliveries:groups().map((g,n)=>({groupKey:g.groupKey,customerId:g.customerId,destination:g.destination,outboundNo:g.customerId===EXT?'OUT-EXT':'OUT-OWN',deliveryNo:`DEL-${n}`,status:'DELIVERING',packageCount:g.cargo.reduce((n,c)=>n+c.packages,0)}))})
   const trip = () => ({ trip: { tripNo: 'TR-CURRENT', warehouseId: '92', vehicleId: '71', driverId: '72', recordVersion: fleetVersion, stops: tripProof.stops }, dispatches: [{ dispatchNo: fault === 'second-dispatch' ? 'DS-OTHER' : 'DS-OWN' }] })
   const response = (data, message = '') => ({ http: 200, body: { code: message ? 'A0409' : '200', message, data: clone(data) }, requestId: 'OFFLINE-REQ', traceId: 'OFFLINE-TRACE' })
   const context = { marker: 'CURRENT', createdResources: nativeMode ? { fleetTrips: [tripProof] } : { fleetTrips: [tripProof, { dispatchNo: 'DS-FULL', tripNo: 'TR-FULL', warehouseId: '92' }], fleetFeeCoverageCases: [full, currentCase] }, checkpoint: async () => {},
@@ -49,8 +51,8 @@ function fixture(fault = '', nativeMode = false) {
     async request(method, raw, body, token) {
       calls.push({ method, path: raw, body: clone(body), token })
       const path = raw.split('?')[0], params = new URLSearchParams(raw.split('?')[1]), normalized = path.replace(PDA, BASE), key = `${normalized}:${body?.idempotencyKey}`
-      if (method !== 'GET' && body?.idempotencyKey && ledger.has(key)) { const original = ledger.get(key); assert.deepEqual(body, original.body); if (fault === 'replay-row-drift' && path.endsWith('/items')) items[0].dispatchItemId = '999'; return response({ ...clone(original.data), replayed: true }) }
-      const remember = data => { if (body?.idempotencyKey) ledger.set(key, { body: clone(body), data: clone(data) }); return response(data) }
+      if (method !== 'GET' && body?.idempotencyKey && ledger.has(key)) { const original = ledger.get(key); assert.deepEqual(body, original.body); if (fault === 'replay-row-drift' && path.endsWith('/items')) items[0].dispatchItemId = '999'; if(path.endsWith('/loading-complete')&&token!==original.token)return {http:200,body:{code:'A0403',message:'该请求标识不属于当前操作员'},requestId:'R',traceId:'T'}; return response({ ...clone(original.data), replayed: true }) }
+      const remember = data => { if (body?.idempotencyKey) ledger.set(key, { body: clone(body), data: clone(data), token }); return response(data) }
       if (path === `${TRIP}/capacity-plan`) {
         if (method === 'POST') { assert.equal(body.recordVersion, fleetVersion); assert.equal(body.pallets.length, 3); assert.equal(body.pallets.find(p => p.warehousePalletId === '33').palletSpaces, 2); planned = true; fleetVersion++ }
         return response({ recordVersion: fleetVersion, manifestHash: 'c'.repeat(64), planValid: items.length === 2 || planned || fault === 'stale-plan',
@@ -74,14 +76,11 @@ function fixture(fault = '', nativeMode = false) {
       }
       const delivery = path.match(/\/delivery-orders\/DEL-(\d)$/)
       if (delivery) {
-        const index = Number(delivery[1]), group = groups()[index], input = saved.groups[index], who = group.customerId
-        assert.equal(params.get('customerId'), who)
-        const feeCoverage = input.feeCoverage.length ? { cargoHash: group.feeCoverageCargoHash, cargo: group.cargo, operatorId: 'OP', confirmedAt: '2026-10-19T01:00:00Z',
-          references: input.feeCoverage.map(s => ({ services: s.services, source: { ...group.feeSources.find(f => f.financeFeeId === s.financeFeeId), sourceType: 'INBOUND_FEE', sourceInboundId: group.cargo[0].sourceInboundId } })) } : null
-        const fees = input.fees.map(f => ({ id: String(981 + index), feeDirection: f.direction, feeType: f.feeType, amount: f.amount, currency: f.currency, sourceStatus: 'ACTIVE', reviewStatus: 'APPROVED' }))
-        if (group.externalQuotes.length) fees.push({ id: '980', feeDirection: 'RECEIVABLE', feeType: 'DELIVERY_FEE', amount: 30, currency: 'CNY', sourceStatus: 'ACTIVE', reviewStatus: 'APPROVED' })
-        if (fault === 'duplicate-fee' && group.externalQuotes.length && calls.filter(c => c.path === raw).length > 1) fees.push(clone(fees[0]))
-        return response({ order: { customerId: who, dispatchNo: 'DS-OWN', deliveryNo: `DEL-${index}`, outboundNo: who === EXT ? 'OUT-EXT' : 'OUT-OWN', destinationWarehouseCode: group.destination.warehouseCode }, fees, feeCoverage })
+        const index=Number(delivery[1]),group=groups()[index],who=group.customerId
+        assert.equal(params.get('customerId'),who)
+        const fees=group.externalQuotes.length?[{id:'980',feeDirection:'RECEIVABLE',feeType:'DELIVERY_FEE',amount:fault==='stale-price'?50:30,currency:'CNY',sourceStatus:'ACTIVE',reviewStatus:'APPROVED'}]:[]
+        if(fault==='duplicate-fee'&&fees.length)fees.push(clone(fees[0]))
+        return response({order:{customerId:who,dispatchNo:'DS-OWN',deliveryNo:`DEL-${index}`,outboundNo:who===EXT?'OUT-EXT':'OUT-OWN',destinationWarehouseCode:group.destination.warehouseCode,status:'DELIVERING',packageCount:group.cargo.reduce((n,c)=>n+c.packages,0)},fees,feeCoverage:null})
       }
       const isFull = path.startsWith(`${BASE}/DS-FULL`), data = detail(isFull), cargo = isFull ? fullItems : items
       if (method === 'GET' && normalized === `${BASE}/DS-OWN` && path.startsWith(PDA)) return response({ ...data, items: items.map((i, n) => ({ ...i, positions: [{ positionId: `6${n}`, availablePackages: i.scheduledPackages }] })) })
@@ -89,7 +88,6 @@ function fixture(fault = '', nativeMode = false) {
       if (method === 'GET' && normalized.endsWith('/route')) return response({ dispatchNo: data.dispatchNo, recordVersion: data.recordVersion, stops: tripProof.stops })
       if (method === 'GET' && normalized.endsWith('/loading')) return response({ ...data, manifestHash: 'c'.repeat(64), loadingComplete: { allowed: true }, pallets: items.map((i, n) => ({ ...i, ...(fault === 'missing-measurements' ? {} : { palletSpaces: n === 2 ? 2 : 1, weightKg: n === 2 ? 37 : 10, volumeCbm: n === 2 ? 0.7 : 0.2, deliveryIndex: nativeMode || n === 2 ? 1 : n + 1,
         evidence: [['palletSpaces', n === 2 ? 2 : 1], ['weightKg', n === 2 ? 37 : 10], ['volumeCbm', n === 2 ? 0.7 : 0.2]].map(([field, value]) => ({ field, value, actual: true, sourceType: 'MEASURED', sourceBusinessNo: i.inboundCode, observedAt: '2026-10-19T01:00:00Z' })) }) })) })
-      if (method === 'GET' && normalized.endsWith('/delivery-arrangement')) return response({ ...data, cargoHash: 'a'.repeat(64), loadingCompletionHash: 'c'.repeat(64), groups: groups(), arrange: { allowed: !saved }, arrangement: saved ? { dispatchNo: 'DS-OWN' } : null })
       if (method === 'GET') { assert.ok(normalized === `${BASE}/DS-OWN` || normalized === `${BASE}/DS-FULL`, raw); return response(data) }
       if (path.endsWith('/pick') && body.recordVersion !== recordVersion) return response(null, '公共版本已变化')
       assert.equal(body.recordVersion, recordVersion, raw)
@@ -97,32 +95,21 @@ function fixture(fault = '', nativeMode = false) {
       if (path.endsWith('/items')) { assert.equal(stage, 'BEFORE_LOADING'); assert.equal(body.cargo.length, 1); items.push(external); recordVersion++; fleetVersion++; if (fault === 'unknown-add') return { http: 0, body: null }; return remember(ack('ADD_CARGO')) }
       if (path.endsWith('/submit-review') || path.endsWith('/dispatch-review') || path.endsWith('/loading-review')) { if (path.endsWith('/loading-review') && fault !== 'review-not-applied') { review = true; stage = 'LOADING' }; recordVersion++; return remember(ack('REVIEW')) }
       if (path.endsWith('/pick')) { assert.ok(token); const itemId = path.split('/').at(-2); items.find(i => i.dispatchItemId === itemId).pickedPackages += body.packages; recordVersion++; return remember(ack('PICK')) }
-      if (path.endsWith('/loading-complete')) { assert.equal(items.every(i => i.pickedPackages === i.scheduledPackages), true); stage = 'AFTER_LOADING'; recordVersion++; return remember(ack('LOADING_COMPLETE', { confirmedLoad: { manifestHash: body.manifestHash, pallets: body.measurements } })) }
-      assert.ok(path.endsWith('/transfer-delivery'), raw); assert.equal(stage, 'AFTER_LOADING')
-      if (body.cargoHash !== 'a'.repeat(64)) return response(null, '装车或实际货物已经变化')
-      if (body.groups.some(g => g.feeCoverage.some(s => s.sourceVersion !== 1))) return response(null, '原费用版本已变化')
-      if (body.groups.some(g => g.externalFreightHash !== 'b'.repeat(64))) return response(null, '外接实收或约定运费已变化')
-      if (body.groups.some(g => new Set(g.fees.map(f => `${f.direction}:${f.feeType}`)).size !== g.fees.length)) return response(null, '同组同方向同费用不得重复登记')
-      if (body.groups.some(g => g.groupKey === 'G-PLAN:23' && g.fees.length)) return response(null, '本组服务已全部覆盖，不得重复登记应收')
-      if (!body.groups.some(g => g.fees.length)) return response(null, '本组尚有未覆盖的服务费用，请核对')
-      saved = clone(body); recordVersion++
-      if (fault === 'unknown-arrange') return { http: 0, body: null }
-      return remember(ack('ARRANGE_DELIVERY', { dispatchNo: 'DS-OWN', cargoHash: 'a'.repeat(64), outbounds: [...new Set(items.map(i => i.customerId))].map(customerId => ({ customerId, outboundNo: customerId === OWN ? 'OUT-OWN' : 'OUT-EXT', status: 'WAIT_OUTBOUND', packageCount: items.filter(i => i.customerId === customerId).reduce((n, i) => n + i.scheduledPackages, 0) })),
-        deliveries: groups().map((g, n) => ({ groupKey: g.groupKey, customerId: g.customerId, destination: g.destination, outboundNo: g.customerId === EXT ? 'OUT-EXT' : 'OUT-OWN', deliveryNo: `DEL-${n}`, status: 'WAIT_DELIVERY', packageCount: g.cargo.reduce((n, c) => n + c.packages, 0) })) }))
+      if (path.endsWith('/loading-complete')) { assert.equal(items.every(i => i.pickedPackages === i.scheduledPackages), true); stage = 'DELIVERING'; recordVersion++; return remember(ack('LOADING_COMPLETE', { confirmedLoad: { manifestHash: body.manifestHash, pallets: body.measurements } })) }
+      throw Error(`Unexpected ${method} ${raw}`)
     } }
-  const options = nativeMode ? { pickerToken: 'OFFLINE-ONLY', arrangement: { mode: 'NATIVE', marker: 'CURRENT', dispatchNo: 'DS-OWN', plannedDeliveryAt: '2026-10-22T01:00:00Z', deliveryMethod: 'TRUCK_PALLET', pickupMethod: 'WAREHOUSE_PICKUP', loadingType: 'PALLET', appointmentAccount: 'SELF',
-    groups: [{ customerId: OWN, destinationKey: 'FBA:A1', fees: [{ direction: 'RECEIVABLE', feeType: 'DELIVERY_FEE', feeName: '客户A明确派送费', currency: 'USD', amount: 11 }] }, { customerId: EXT, destinationKey: 'FBA:A1', fees: [{ direction: 'RECEIVABLE', feeType: 'DELIVERY_FEE', feeName: '客户B明确派送费', currency: 'CNY', amount: 17 }] }] } } : { coverageCase: currentCase, pickerToken: 'OFFLINE-ONLY' }
+  const options = nativeMode ? {pickerToken:'OFFLINE-ONLY'} : {coverageCase:currentCase,pickerToken:'OFFLINE-ONLY'}
   return { context, tripProof, currentCase, calls, assertions, items, options }
 }
 
 test('native external flow adds actual received cargo to same whole, re-reviews, scans, loads and arranges all customer groups', async () => {
   const f = fixture(), proof = await verifyFleetExternalDispatch(f.context, 'external', f.tripProof, f.options)
   assert.equal(proof.status, 'VERIFIED'); assert.equal(proof.dispatchNo, 'DS-OWN'); assert.equal(proof.sourceFees.length, 1); assert.equal(proof.sourceFees[0].chargeableQuantity, 2)
-  assert.equal(proof.financeAcknowledgement, 'NOT_VERIFIED'); assert.equal(f.currentCase.proof.status, 'VERIFIED'); assert.equal(f.currentCase.proof.newReceivable, 17.5)
+  assert.equal(proof.financeAcknowledgement, 'NOT_VERIFIED'); assert.equal(f.currentCase.proof.status, 'VERIFIED'); assert.equal(f.currentCase.proof.feeCoverageSelection,'NOT_APPLICABLE_AUTOMATIC_DELIVERY')
   assert.ok(f.assertions.every(a => a.passed)); assert.equal(f.calls.some(c => /pre-arrange|dispatches\/bind|dispatches\/unbind|\/cancel/.test(c.path)), false)
   assert.equal(f.calls.filter(c => c.method === 'POST' && c.path === BASE).length, 0)
   assert.ok(f.calls.findIndex(c => c.path.endsWith('/return-to-review')) < f.calls.findIndex(c => c.path.endsWith('/items') && c.method === 'POST'))
-  assert.ok(f.calls.findIndex(c => c.path.endsWith('/loading-complete')) < f.calls.findIndex(c => c.path.endsWith('/transfer-delivery')))
+  assert.equal(f.calls.some(c => c.path.endsWith('/transfer-delivery')||c.path.endsWith('/depart')),false)
   assert.equal(f.items.length, 3); await assert.rejects(verifyFleetExternalDispatch(f.context, 'external', f.tripProof, f.options), /尚未装入/)
 })
 
@@ -133,8 +120,8 @@ for (const fault of ['foreign-customer', 'stale-plan', 'double-capacity', 'revie
 })
 
 test('no external callback injection can replace real registered PARTIAL sources, current PDA or durable journal', async () => {
-  for (const mutate of [f => { delete f.options.coverageCase }, f => { delete f.options.pickerToken }, f => { delete f.context.checkpoint }]) {
-    const f = fixture(); mutate(f); await assert.rejects(verifyFleetExternalDispatch(f.context, 'external', f.tripProof, f.options), /同主单未扫码PARTIAL/); assert.equal(f.calls.length, 0)
+  for (const mutate of [f => { delete f.options.pickerToken }, f => { delete f.context.checkpoint }]) {
+    const f = fixture(); mutate(f); await assert.rejects(verifyFleetExternalDispatch(f.context, 'external', f.tripProof, f.options)); assert.equal(f.calls.length, 0)
   }
 })
 
@@ -145,52 +132,14 @@ test('server binding requires the same existing whole dispatch and public cargo
   assert.equal(source.includes('/pre-arrange'), false); assert.equal(source.includes('draftToken'), false); assert.ok(source.includes('/return-to-review')); assert.ok(source.includes("'ADD_CARGO'"))
 })
 
-test('ordinary native mode accepts two WAREHOUSE_TRANSFER sources and same-customer external cargo without FULL/PARTIAL fixtures', async () => {
-  const f = fixture('', true), proof = await verifyFleetExternalDispatch(f.context, 'external-native', f.tripProof, f.options)
-  assert.equal(proof.status, 'VERIFIED'); assert.equal(proof.arrangementMode, 'NATIVE'); assert.equal(proof.nativeArrangement.status, 'VERIFIED')
-  assert.equal(Object.hasOwn(f.context.createdResources, 'fleetFeeCoverageCases'), false); assert.equal(f.currentCase.proof, undefined)
-  assert.equal(proof.deliveries.length, 2); assert.equal(proof.deliveries.reduce((n, d) => n + d.packageCount, 0), 3)
-  assert.ok(f.items.some(i => i.inboundCode === 'WT-OWN-1') && f.items.some(i => i.inboundCode === 'WT-OWN-2')); assert.equal(f.items.length, 3)
-  const requests = f.calls.filter(c => c.method === 'POST' && c.path.endsWith('/transfer-delivery')), actual = requests.at(-1)
-  assert.deepEqual(proof.transferRequest.groups.map(g => g.fees.map(f => [f.currency, f.amount])), [[['USD', 11]], [['CNY', 17]]])
-  assert.ok(proof.transferRequest.groups.every(g => g.feeCoverage.length === 0 && !g.groupKey.startsWith('FBA:')))
-  assert.equal(requests.length, 5); assert.equal(actual.body.idempotencyKey, proof.transferRequest.idempotencyKey)
-  assert.ok(f.calls.findIndex(c => c.path.endsWith('/pick')) < f.calls.findIndex(c => c.path.endsWith('/loading-complete')))
-  assert.ok(f.calls.findIndex(c => c.path.endsWith('/loading-complete')) < f.calls.findIndex(c => c.path.endsWith('/transfer-delivery')))
-  assert.ok(f.calls.every(c => !c.path.includes('DS-FULL') && !c.path.includes('pre-arrange'))); assert.ok(f.assertions.every(a => a.passed))
-  const snapshots = proof.nativeArrangement.snapshots
-  assert.deepEqual(snapshots['DEL-0'].fees.map(f => [f.currency, f.amount]), [['USD', 11], ['CNY', 30]])
-  assert.deepEqual(snapshots['DEL-1'].fees.map(f => [f.currency, f.amount]), [['CNY', 17]])
-  assert.equal(proof.sourceFees[0].originalAmount, 30); assert.equal(proof.sourceFees[0].customerId, OWN)
+test('ordinary current sources automatically deliver without manual fee configuration',async()=>{
+  const f=fixture('',true),proof=await verifyFleetExternalDispatch(f.context,'external-native',f.tripProof,f.options)
+  assert.equal(proof.status,'VERIFIED');assert.equal(proof.fulfillmentMode,'AUTOMATIC_DELIVERY')
+  assert.equal(proof.deliveries.length,2);assert.equal(proof.deliveries.reduce((n,d)=>n+d.packageCount,0),3)
+  assert.ok(proof.deliveries.every(d=>d.status==='DELIVERING'));assert.ok(proof.loadingRequest.idempotencyKey)
+  assert.equal(f.calls.some(c=>c.path.endsWith('/transfer-delivery')||c.path.endsWith('/depart')),false)
+  assert.equal(proof.sourceFees[0].originalAmount,30)
 })
-
-test('ordinary native configuration and coverage mode are exclusive and require current explicit group configuration', async () => {
-  for (const mutate of [f => { delete f.options.arrangement }, f => { f.options.coverageCase = f.currentCase }, f => { f.options.arrangement.mode = 'SAME_ROUTE' },
-    f => { f.options.arrangement.marker = 'OLD' }, f => { f.options.arrangement.dispatchNo = 'OTHER' }, f => { f.options.arrangement.groups.push(clone(f.options.arrangement.groups[0])) },
-    f => { f.options.arrangement.groups = async () => ({ success: true }) }, f => { f.options.arrangement.groups[0].fees[0].amount = 0 }, f => { f.options.arrangement.groups[0].fees.push(clone(f.options.arrangement.groups[0].fees[0])) },
-    f => { f.options.arrangement.groups[0].feeCoverage = [] }, f => { delete f.options.pickerToken }, f => { delete f.context.checkpoint }]) {
-    const f = fixture('', true); mutate(f); await assert.rejects(verifyFleetExternalDispatch(f.context, 'external-native', f.tripProof, f.options)); assert.equal(f.calls.length, 0)
-  }
-  for (const mutate of [f => { f.options.arrangement.groups.pop() }, f => { f.options.arrangement.groups[0].customerId = '999' }]) {
-    const f = fixture('', true); mutate(f); await assert.rejects(verifyFleetExternalDispatch(f.context, 'external-native', f.tripProof, f.options), /加货前精确覆盖/); assert.equal(f.calls.some(c => c.method !== 'GET'), false)
-  }
-})
-
-for (const fault of ['foreign-customer', 'double-capacity', 'review-not-applied', 'stale-price', 'duplicate-fee', 'foreign-source-fee', 'wrong-quantity', 'replay-row-drift', 'already-loaded', 'missing-measurements', 'unknown-arrange']) test(`ordinary native flow preserves protection against ${fault}`, async () => {
-  const f = fixture(fault, true); await assert.rejects(verifyFleetExternalDispatch(f.context, 'external-native', f.tripProof, f.options)); assert.notEqual(f.tripProof.externalDispatch.status, 'VERIFIED')
-  assert.equal(Object.hasOwn(f.context.createdResources, 'fleetFeeCoverageCases'), false)
-  if (fault === 'missing-measurements') assert.equal(f.calls.some(c => c.path.endsWith('/loading-complete') || c.path.endsWith('/transfer-delivery')), false)
-  if (fault === 'unknown-arrange') { assert.equal(f.tripProof.externalDispatch.status, 'OUTCOME_UNKNOWN'); assert.equal(f.calls.at(-1).path.endsWith('/transfer-delivery'), true); assert.equal(f.context.createdResources.dispatchWriteBoundary.stopped, true); assert.ok(f.tripProof.externalDispatch.nativeArrangement.confirmationRequest.idempotencyKey) }
-})
-
-test('ordinary native plan permits explicit zero extra fee only for fully quoted cargo and never expands the quote into each group', () => {
-  const f = fixture('', true), receipt = f.tripProof.externalReceipt, plan = clone(f.options.arrangement)
-  plan.groups = [{ customerId: OWN, destinationKey: 'FBA:A1', fees: [] }]
-  const group = { groupKey: 'REAL-GROUP', customerId: OWN, destination: { key: 'FBA:A1' }, groupCargoHash: 'a'.repeat(64), externalFreightHash: 'b'.repeat(64), feeCoverageCargoHash: 'a'.repeat(64), blockReasons: [], requiredServices: [], feeSources: [],
-    cargo: [{ customerId: OWN, inboundCode: receipt.incomingNo, destination: { key: 'FBA:A1' } }], externalQuotes: [{ groupKey: 'REAL-GROUP', customerId: OWN, bookingNo: receipt.bookingNo, inboundCode: receipt.incomingNo, currency: 'CNY', amount: 30, sourceHash: 'b'.repeat(64) }] }
-  const groups = nativeArrangementGroups({ groups: [group] }, plan, receipt)
-  assert.deepEqual(groups[0].fees, []); assert.deepEqual(groups[0].feeCoverage, []); assert.equal(groups[0].groupKey, 'REAL-GROUP')
-  plan.groups[0].fees = [{ direction: 'RECEIVABLE', feeType: 'DELIVERY_FEE', feeName: 'duplicate', currency: 'CNY', amount: 30 }]
-  assert.throws(() => nativeArrangementGroups({ groups: [group] }, plan, receipt), /不得重复登记/)
-  plan.groups[0].fees = []; group.requiredServices = ['DELIVERY_FEE']; assert.throws(() => nativeArrangementGroups({ groups: [group] }, plan, receipt), /尚未覆盖/)
+for(const fault of ['foreign-customer','double-capacity','review-not-applied','stale-price','duplicate-fee','foreign-source-fee','wrong-quantity','replay-row-drift','already-loaded','missing-measurements'])test(`automatic external flow rejects ${fault}`,async()=>{
+  const f=fixture(fault,true);await assert.rejects(verifyFleetExternalDispatch(f.context,'external-native',f.tripProof,f.options));assert.notEqual(f.tripProof.externalDispatch.status,'VERIFIED')
 })

scripts/admin-test-env-modules/fleet-external-dispatch-acceptance.mjs

@@ -1,141 +1,19 @@
 import { DISPATCH_BASE as BASE, id as stringId, version, createBody, candidatePage, readDispatch, replay } from './grouped-dispatch-acceptance.mjs'
-import { fleetConsumerIo, readyFleetDispatch, stableRows, verifyFleetFeeCoverage } from './fleet-fee-coverage-acceptance.mjs'
+import { fleetConsumerIo, readyFleetDispatch, stableRows, verifyFleetFeeCoverage, readAutomaticDelivery } from './fleet-fee-coverage-acceptance.mjs'
 
 const clone = value => structuredClone(value)
 const id = value => { if (typeof value === 'number' && !Number.isSafeInteger(value)) throw Error('服务端ID精度无效，必须保留Long字符串'); return stringId(value) }
 const money = value => { const text = String(value); if (!/^\d+(?:\.\d{1,2})?$/.test(text)) throw Error('外接约定金额或单价不完整'); const [whole, fraction = ''] = text.split('.'); return BigInt(whole) * 100n + BigInt(fraction.padEnd(2, '0')) }
 const identity = item => ({ dispatchItemId: id(item.dispatchItemId), sourceKey: item.sourceKey, customerId: id(item.customerId), warehousePalletId: id(item.warehousePalletId), scheduledPackages: Number(item.scheduledPackages), pickedPackages: Number(item.pickedPackages) })
-const groupIdentity = (customerId, destinationKey) => JSON.stringify([id(customerId), destinationKey])
-const sha = value => /^[a-f0-9]{64}$/i.test(value || '')
-const feeIdentity = fee => `${fee.direction}:${fee.feeType}:${fee.currency}:${money(fee.amount)}`
-function validateNativeArrangement(context, tripProof, plan) {
-  if (plan?.mode !== 'NATIVE' || plan.marker !== context.marker || plan.dispatchNo !== tripProof.dispatchNo
-    || typeof plan.plannedDeliveryAt !== 'string' || !Number.isFinite(Date.parse(plan.plannedDeliveryAt))
-    || !plan.deliveryMethod || !plan.pickupMethod || plan.loadingType !== 'PALLET' || plan.appointmentAccount !== 'SELF'
-    || !Array.isArray(plan.groups) || !plan.groups.length) throw Error('普通原生安排须明确本轮主单、派送时间、PALLET/SELF及逐客户目的地费用')
-  const keys = new Set()
-  for (const group of plan.groups) {
-    const key = groupIdentity(group.customerId, group.destinationKey)
-    if (!/^[1-9]\d*$/.test(id(group.customerId)) || typeof group.destinationKey !== 'string' || !group.destinationKey.trim() || keys.has(key) || !Array.isArray(group.fees) || Object.hasOwn(group, 'feeCoverage')) throw Error('普通安排的客户目的地配置缺失、重复或含原费覆盖选择')
-    keys.add(key)
-    const fees = new Set()
-    for (const fee of group.fees) {
-      const feeKey = `${fee.direction}:${fee.feeType}`
-      if (!['RECEIVABLE', 'PAYABLE'].includes(fee.direction) || !['DELIVERY_FEE', 'LOADING_FEE', 'APPOINTMENT_FEE'].includes(fee.feeType)
-        || !fee.feeName || !['CNY', 'USD'].includes(fee.currency) || money(fee.amount) <= 0n || fees.has(feeKey)) throw Error('普通安排费用必须逐组明确正数、币种和服务，不得重复')
-      fees.add(feeKey)
-    }
-  }
-}
-
-// 仅将明确的客户/目的地配置映射到实时groupKey与摘要；不推算费用或原费覆盖。
-export function nativeArrangementGroups(preview, plan, receipt) {
-  const configured = new Map(plan.groups.map(g => [groupIdentity(g.customerId, g.destinationKey), g]))
-  if (!Array.isArray(preview.groups) || preview.groups.length !== configured.size || new Set(preview.groups.map(g => groupIdentity(g.customerId, g.destination?.key))).size !== configured.size) throw Error('普通安排配置必须精确覆盖全车全部真实客户目的地')
-  return preview.groups.map(group => {
-    const config = configured.get(groupIdentity(group.customerId, group.destination?.key))
-    if (!config || !group.groupKey || !sha(group.groupCargoHash) || !sha(group.externalFreightHash) || !sha(group.feeCoverageCargoHash)
-      || !Array.isArray(group.blockReasons) || group.blockReasons.length || !Array.isArray(group.requiredServices) || !Array.isArray(group.externalQuotes)
-      || !Array.isArray(group.feeSources) || !Array.isArray(group.cargo) || !group.cargo.length || group.cargo.some(c => id(c.customerId) !== id(group.customerId) || c.destination?.key !== group.destination.key)) throw Error('普通原生安排的实际分组或来源门禁不完整')
-    if (group.externalQuotes.some(q => q.bookingNo !== receipt.bookingNo || q.inboundCode !== receipt.incomingNo || id(q.customerId) !== id(group.customerId)
-      || q.groupKey !== group.groupKey || q.sourceHash !== group.externalFreightHash || q.currency !== receipt.finalBooking.cargo.currency || money(q.amount) !== money(receipt.finalBooking.agreedAmount))) throw Error('普通安排的外接报价已变化或越过客户来源')
-    if (group.requiredServices.some(service => !config.fees.some(f => f.direction === 'RECEIVABLE' && f.feeType === service))) throw Error('普通安排必须明确填写本组尚未覆盖的服务费用')
-    const quotedAll = group.cargo.every(c => group.externalQuotes.some(q => q.inboundCode === c.inboundCode))
-    if (quotedAll && config.fees.some(f => f.direction === 'RECEIVABLE' && f.feeType === 'DELIVERY_FEE')) throw Error('本组派送已由外接约定覆盖，不得重复登记应收')
-    return { groupKey: group.groupKey, groupCargoHash: group.groupCargoHash, plannedDeliveryAt: plan.plannedDeliveryAt,
-      deliveryMethod: plan.deliveryMethod, pickupMethod: plan.pickupMethod, loadingType: plan.loadingType, appointmentAccount: plan.appointmentAccount,
-      waybillNo: plan.waybillNo || null, carrierName: plan.carrierName || null, vehicleType: plan.vehicleType || null, vehicleSize: plan.vehicleSize || null, sellerName: null, remark: plan.remark || null,
-      externalFreightHash: group.externalFreightHash, feeCoverageCargoHash: group.feeCoverageCargoHash, feeCoverage: [], fees: clone(config.fees) }
-  })
-}
-
-async function arrangeNative(context, module, io, proof, tripProof, plan, pickerToken, actualMeasurements) {
-  const current = await readyFleetDispatch(context, module, io, tripProof, { pickerToken, actualMeasurements })
-  const path = `${BASE}/${encodeURIComponent(tripProof.dispatchNo)}`, preview = await io.get(`${path}/delivery-arrangement`, '普通模式读取装车后实时全车派送分组')
-  io.check('普通安排使用当前公共版本和真实实载摘要', null, preview?.dispatchNo === tripProof.dispatchNo && preview.status === 'ACTIVE' && preview.stage === 'AFTER_LOADING'
-    && id(version(preview.recordVersion)) === id(version(current.data.recordVersion)) && preview.arrange?.allowed === true && !preview.arrangement && sha(preview.cargoHash) && sha(preview.loadingCompletionHash))
-  const groups = nativeArrangementGroups(preview, plan, tripProof.externalReceipt), totals = new Map()
-  for (const group of preview.groups) for (const row of group.cargo) {
-    io.check('普通派送货物保留实际客户目的地和原物理行', null, current.items.items.some(i => id(i.dispatchItemId) === id(row.dispatchItemId) && id(i.customerId) === id(group.customerId) && i.destination.key === group.destination.key && id(i.warehousePalletId) === id(row.warehousePalletId)))
-    totals.set(id(row.dispatchItemId), (totals.get(id(row.dispatchItemId)) || 0) + Number(row.packages))
-  }
-  io.check('普通安排逐物理行箱数完整守恒', null, totals.size === current.items.items.length && current.items.items.every(i => totals.get(id(i.dispatchItemId)) === Number(i.scheduledPackages)))
-  const body = { recordVersion: version(preview.recordVersion), idempotencyKey: io.key('native-arrangement'), cargoHash: preview.cargoHash, loadingCompletionHash: preview.loadingCompletionHash, groups }
-  proof.nativeArrangement = { mode: 'NATIVE', confirmationRequest: clone(body), status: 'CHECKING' }; await context.checkpoint()
-  const noDocuments = async () => {
-    for (const customerId of new Set(preview.groups.map(g => id(g.customerId)))) {
-      const rows = []; let total
-      for (let page = 1; ; page++) {
-        const data = await io.get(`/api/platform/v1/last-leg/outbound-orders?${new URLSearchParams({ customerId, page: String(page), size: '200' })}`, '普通安排拒绝前后按客户回查无出库写入')
-        io.check('普通安排出库分页完整稳定', null, Array.isArray(data?.records) && Number.isSafeInteger(Number(data.total)) && Number(data.total) >= 0 && Number(data.page) === page && Number(data.size) === 200
-          && (total === undefined || total === Number(data.total)) && (data.records.length > 0 || rows.length === Number(data.total)))
-        total ??= Number(data.total); rows.push(...data.records); if (rows.length >= total) break
-      }
-      io.check('普通安排拒绝未生成本主单出库', null, rows.length === total && new Set(rows.map(r => r.outboundNo)).size === rows.length && rows.every(r => r.dispatchNo !== tripProof.dispatchNo))
-    }
-  }
-  const reject = async (action, changed, pattern) => {
-    const before = await readDispatch(io, tripProof.dispatchNo)
-    await io.request('POST', `${path}/transfer-delivery`, { ...clone(body), ...changed, idempotencyKey: io.key(action) }, action, pattern)
-    await noDocuments(); io.check(`${action}不改整车版本及实物`, null, JSON.stringify(await readDispatch(io, tripProof.dispatchNo)) === JSON.stringify(before))
-  }
-  await noDocuments()
-  const changedHash = hash => `${hash[0] === '0' ? '1' : '0'}${hash.slice(1)}`
-  await reject('普通安排陈旧货物摘要拒绝', { cargoHash: changedHash(body.cargoHash) }, /货物.*变化/)
-  const quoted = preview.groups.find(g => g.externalQuotes.length)
-  io.check('普通安排包含本轮已确认外接报价', null, Boolean(quoted))
-  const stale = clone(groups); stale.find(g => g.groupKey === quoted.groupKey).externalFreightHash = changedHash(quoted.externalFreightHash)
-  await reject('普通安排陈旧外接报价摘要拒绝', { groups: stale }, /外接.*变化/)
-  const duplicate = clone(groups), quote = quoted.externalQuotes[0]
-  duplicate.find(g => g.groupKey === quoted.groupKey).fees.push({ direction: 'RECEIVABLE', feeType: 'DELIVERY_FEE', feeName: '本轮重复外接应收反例', currency: quote.currency, amount: quote.amount })
-  await reject('普通安排重复外接应收拒绝', { groups: duplicate }, /重复|覆盖/)
-  const command = await io.request('POST', `${path}/transfer-delivery`, body, '普通原生模式一次安排全车全部客户目的地'), result = command?.result
-  io.check('普通原生命令完整返回真实客户出库和目的地派送', null, command?.dispatchNo === tripProof.dispatchNo && command.action === 'ARRANGE_DELIVERY' && command.status === 'ACTIVE' && command.stage === 'AFTER_LOADING'
-    && BigInt(version(command.recordVersion)) > BigInt(version(body.recordVersion)) && result?.dispatchNo === tripProof.dispatchNo && result.cargoHash === body.cargoHash
-    && result.deliveries?.length === preview.groups.length && new Set(result.deliveries.map(d => d.deliveryNo)).size === result.deliveries.length
-    && result.outbounds?.length === new Set(preview.groups.map(g => id(g.customerId))).size
-    && result.deliveries.every(d => d.deliveryNo && d.status === 'WAIT_DELIVERY' && preview.groups.some(g => g.groupKey === d.groupKey && id(g.customerId) === id(d.customerId) && g.destination.key === d.destination?.key
-      && g.cargo.reduce((n, c) => n + Number(c.packages), 0) === Number(d.packageCount)) && result.outbounds.some(o => o.outboundNo === d.outboundNo && id(o.customerId) === id(d.customerId)))
-    && result.outbounds.every(o => o.outboundNo && o.status === 'WAIT_OUTBOUND' && Number(o.packageCount) === result.deliveries.filter(d => d.outboundNo === o.outboundNo).reduce((n, d) => n + Number(d.packageCount), 0)))
-  const snapshots = {}
-  for (const ref of result.deliveries) {
-    const group = preview.groups.find(g => g.groupKey === ref.groupKey), input = groups.find(g => g.groupKey === ref.groupKey)
-    const detail = await io.get(`/api/platform/v1/last-leg/delivery-orders/${encodeURIComponent(ref.deliveryNo)}?customerId=${encodeURIComponent(id(ref.customerId))}`, '普通安排回查客户目的地及明确费用')
-    const expectedFees = [...input.fees.map(feeIdentity), ...group.externalQuotes.filter(q => money(q.amount) > 0n).map(q => feeIdentity({ direction: 'RECEIVABLE', feeType: 'DELIVERY_FEE', currency: q.currency, amount: q.amount }))]
-    io.check('普通派送保留本客户本目的地费用，无伪零、重复或原费覆盖回执', null, detail?.order?.dispatchNo === tripProof.dispatchNo && detail.order.deliveryNo === ref.deliveryNo && id(detail.order.customerId) === id(ref.customerId)
-      && detail.order.outboundNo === ref.outboundNo && id(detail.order.destinationWarehouseCode || detail.order.destinationWarehouseId) === id(group.destination.warehouseCode || group.destination.warehouseId)
-      && (detail.feeCoverage == null || detail.feeCoverage.references?.length === 0) && Array.isArray(detail.fees) && new Set(detail.fees.map(f => id(f.id))).size === detail.fees.length
-      && detail.fees.every(f => money(f.amount) > 0n && f.sourceStatus === 'ACTIVE' && f.reviewStatus === 'APPROVED')
-      && stableRows(detail.fees.map(f => feeIdentity({ direction: f.feeDirection, feeType: f.feeType, currency: f.currency, amount: f.amount }))) === stableRows(expectedFees))
-    snapshots[ref.deliveryNo] = { fees: clone(detail.fees), feeCoverage: clone(detail.feeCoverage) }
-  }
-  const again = await replay(io, `${path}/transfer-delivery`, body, command, '普通安排原键原载荷重放'); io.check('普通安排明确恢复原成功命令', null, again.replayed === true)
-  for (const ref of result.deliveries) {
-    const after = await io.get(`/api/platform/v1/last-leg/delivery-orders/${encodeURIComponent(ref.deliveryNo)}?customerId=${encodeURIComponent(id(ref.customerId))}`, '普通安排重放后核对不追加应收')
-    io.check('普通安排重放不增费不改覆盖快照', null, JSON.stringify({ fees: after.fees, feeCoverage: after.feeCoverage }) === JSON.stringify(snapshots[ref.deliveryNo]))
-  }
-  const after = await io.get(`${path}/delivery-arrangement`, '普通安排后回查报价与原费用候选未被改写')
-  const originalFacts = value => stableRows(value.groups.map(g => ({ groupKey: g.groupKey, externalQuotes: g.externalQuotes, feeSources: g.feeSources })))
-  io.check('普通安排保持报价及原费用来源快照', null, originalFacts(after) === originalFacts(preview))
-  Object.assign(proof.nativeArrangement, { status: 'VERIFIED', command, snapshots })
-  return { confirmationRequest: body, deliveries: result.deliveries, outbounds: result.outbounds }
-}
-
-/** 已确认实收来源只ADD_CARGO到原整车；复审、真实扫码、显式装车后一次安排全部客户。
- * options二选一：coverageCase为本轮PARTIAL；或arrangement={mode:'NATIVE',marker,dispatchNo,
- * plannedDeliveryAt,deliveryMethod,pickupMethod,loadingType:'PALLET',appointmentAccount:'SELF',
- * groups:[{customerId,destinationKey,fees:FeeItem[]}]}; 金额和费用覆盖均不自动推断。
- */
-export async function verifyFleetExternalDispatch(context, module, tripProof, { pickerToken, actualMeasurements, coverageCase, arrangement } = {}) {
+/** 将本轮已实收外接货加入原车，复审及真实装车后读取自动派送。 */
+export async function verifyFleetExternalDispatch(context, module, tripProof, { pickerToken, actualMeasurements, coverageCase } = {}) {
   const receipt = tripProof?.externalReceipt, cases = context.createdResources?.fleetFeeCoverageCases
   if (!context.createdResources?.fleetTrips?.includes(tripProof) || receipt?.status !== 'VERIFIED' || tripProof.externalDispatch)
     throw Error('外接只接受本轮已运营确认且尚未装入本车的真实来货')
-  if (Boolean(coverageCase) === Boolean(arrangement)) throw Error('必须且只能选择同主单未扫码PARTIAL费用覆盖或普通NATIVE安排模式')
-  if (arrangement) validateNativeArrangement(context, tripProof, arrangement)
   if (coverageCase && (!cases?.includes(coverageCase) || coverageCase.marker !== context.marker || coverageCase.mode !== 'PARTIAL'
     || coverageCase.dispatchNo !== tripProof.dispatchNo || coverageCase.proof) || !pickerToken || typeof context.checkpoint !== 'function')
     throw Error('外接加货前须有同主单未扫码PARTIAL用例及本轮PDA身份；必须先外接后扫码安排')
-  const proof = tripProof.externalDispatch = { marker: context.marker, dispatchNo: tripProof.dispatchNo, arrangementMode: arrangement ? 'NATIVE' : 'FEE_COVERAGE', status: 'CHECKING', requests: [] }
+  const proof = tripProof.externalDispatch = { marker: context.marker, dispatchNo: tripProof.dispatchNo, fulfillmentMode: 'AUTOMATIC_DELIVERY', status: 'CHECKING', requests: [] }
   const io = fleetConsumerIo(context, module, proof, `EXTERNAL-${tripProof.dispatchNo}`)
   const base = `/api/platform/v1/last-leg/fleet/trips/${encodeURIComponent(tripProof.tripNo)}`, path = `${BASE}/${encodeURIComponent(tripProof.dispatchNo)}`
   const commandReplay = async (path, body, result, label) => { const again = await replay(io, path, body, result, label); io.check(`${label}明确恢复原结果`, null, again.replayed === true) }
@@ -163,10 +41,6 @@ export async function verifyFleetExternalDispatch(context, module, tripProof, {
     io.check('候选仅为本次确认的全部真实外接来源', null, candidates.length === actual.length && candidates.every(c => c.destination.key === booking.cargo.destinationKey
       && actual.some(p => id(p.warehousePalletId) === id(c.selection.warehousePalletId) && p.palletNo === c.palletNo && Number(p.packages) === Number(c.availablePackages))))
     const addition = createBody(context.marker, `EXTERNAL-${tripProof.dispatchNo}`, candidates)
-    if (arrangement) {
-      const actualGroups = new Set([...current.items.items.map(i => groupIdentity(i.customerId, i.destination?.key)), ...candidates.map(c => groupIdentity(c.customerId, c.destination?.key))])
-      io.check('普通安排配置在加货前精确覆盖全部实际客户目的地', null, stableRows([...actualGroups]) === stableRows(arrangement.groups.map(g => groupIdentity(g.customerId, g.destinationKey))))
-    }
     if (current.data.stage === 'LOADING') {
       proof.returnRequest = { recordVersion: version(current.data.recordVersion), idempotencyKey: io.key('explicit-return'), reason: '本轮零扫码外接实收显式退回装车前，保留同一整车' }
       const returned = await io.request('POST', `${path}/return-to-review`, proof.returnRequest, '零扫码明确退回审核')
@@ -218,14 +92,10 @@ export async function verifyFleetExternalDispatch(context, module, tripProof, {
     const ready = await io.get(path, '核对两级审核恢复真实扫码资格')
     io.check('同主单两级审核通过且仍零扫码', null, ready.stage === 'LOADING' && ready.reviewState === 'APPROVED' && ready.reviews?.dispatchReview?.status === 'APPROVED'
       && ready.reviews?.loadingReview?.status === 'APPROVED' && Number(ready.counts.pickedPackageCount) === 0)
-    const execution = arrangement ? await arrangeNative(context, module, io, proof, tripProof, arrangement, pickerToken, actualMeasurements)
-      : await verifyFleetFeeCoverage(context, module, coverageCase, { pickerToken, actualMeasurements, externalTrip: tripProof })
-    const groups = await io.get(`${path}/delivery-arrangement`, '安排后回查原生外接报价快照')
-    const quotes = groups.groups.flatMap(g => g.externalQuotes), expected = receipt.finalBooking
-    const matching = quotes.filter(q => q.bookingNo === receipt.bookingNo && q.inboundCode === receipt.incomingNo && id(q.customerId) === id(booking.customerId))
-    io.check('原外接报价属于本次客户和来源且等于运营确认约定金额', null, matching.length === 1 && money(matching[0].amount) === money(expected.agreedAmount)
-      && matching[0].currency === expected.cargo.currency && matching[0].sourceHash && money(expected.agreedAmount) > 0n)
-    const deliveries = execution.deliveries.filter(d => groups.groups.some(g => g.groupKey === d.groupKey && g.externalQuotes.some(q => q.bookingNo === receipt.bookingNo)))
+    const execution = coverageCase ? await verifyFleetFeeCoverage(context, module, coverageCase, { pickerToken, actualMeasurements, externalTrip: tripProof })
+      : await readAutomaticDelivery(io, await readyFleetDispatch(context, module, io, tripProof, { pickerToken, actualMeasurements }), tripProof)
+    const expected = receipt.finalBooking
+    const deliveries = execution.deliveries.filter(d => id(d.customerId) === id(booking.customerId) && d.destination?.key === booking.cargo.destinationKey)
     io.check('本次外接来源只落入其客户目的地派送', null, deliveries.length === 1 && id(deliveries[0].customerId) === id(booking.customerId))
     proof.outboundNo = deliveries[0].outboundNo; proof.deliveryNo = deliveries[0].deliveryNo; proof.deliveries = execution.deliveries
     const delivery = await io.get(`/api/platform/v1/last-leg/delivery-orders/${encodeURIComponent(proof.deliveryNo)}?customerId=${encodeURIComponent(id(booking.customerId))}`, '回查本客户外接应收来源')
@@ -236,8 +106,8 @@ export async function verifyFleetExternalDispatch(context, module, tripProof, {
       && fees[0].originalCurrency === expected.cargo.currency && fees[0].reviewStatus === 'APPROVED' && id(fees[0].customerId) === id(booking.customerId)
       && quantity != null && Number(fees[0].chargeableQuantity) === Number(quantity) && money(fees[0].unitPrice) === money(expected.cargo.unitPrice)
       && fees[0].quantityUnit === (expected.cargo.priceBasis === 'PALLET' ? '托位' : '单')
-      && fees[0].businessNo === proof.deliveryNo && delivery.fees.some(f => id(f.id) === id(fees[0].id)))
-    proof.customerId = id(booking.customerId); proof.sourceFees = fees; proof.transferRequest = execution.confirmationRequest
+      && fees[0].businessNo === proof.deliveryNo && delivery.fees.some(f => id(f.id) === id(fees[0].id) && money(f.amount) === money(fees[0].originalAmount) && f.currency === fees[0].originalCurrency))
+    proof.customerId = id(booking.customerId); proof.sourceFees = fees; proof.loadingRequest = execution.confirmationRequest
     proof.finalTripVersion = (await io.get(base, '交接同车资源版本')).trip.recordVersion
     proof.financeAcknowledgement = 'NOT_VERIFIED'; proof.status = 'VERIFIED'; await context.checkpoint?.(); return proof
   } catch (error) { proof.status = proof.outcomeUnknown || context.createdResources.dispatchWriteBoundary?.outcomeUnknown ? 'OUTCOME_UNKNOWN' : 'UNPROVEN'; proof.error = error.message; await context.checkpoint?.(); throw error }

scripts/admin-test-env-modules/fleet-fee-coverage-acceptance-contract.test.mjs

@@ -1,122 +1,39 @@
 import test from 'node:test'
 import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { verifyFleetFeeCoverage, coveragePlan } from './fleet-fee-coverage-acceptance.mjs'
-
-const BASE = '/api/platform/v1/last-leg/dispatches', PDA = '/api/pda/v1/last-leg/dispatches', customerId = '900719925474099301'
-const clone = value => structuredClone(value)
-function fixture(mode = 'FULL', fault = '', needsLoading = false) {
-  const cases = ['FULL', 'PARTIAL'].map((mode, index) => ({ marker: 'CURRENT-TEST', mode, dispatchNo: `DS-${index + 1}`, customerId,
-    transferBody: { plannedDeliveryAt: '2026-10-22T01:00:00Z', loadingType: 'PALLET', appointmentAccount: 'SELF', fees: [{ direction: 'RECEIVABLE', feeType: 'DELIVERY_FEE', feeName: '派送费', amount: 17.5, currency: 'USD' }] } }))
-  const source = cases.find(c => c.mode === mode), calls = [], assertions = [], ledger = new Map(), saved = new Map()
-  const states = cases.map((c, n) => ({ dispatchNo: c.dispatchNo, recordVersion: 0, stage: needsLoading && c === source ? 'LOADING' : 'AFTER_LOADING', items: [1, 2].map(i => ({
-    dispatchItemId: `${n + 1}1${i}`, sourceKey: `PLAN:${n + 1}2${i}`, sourceVersion: 'a'.repeat(64), customerId, warehousePalletId: `${n + 1}3${i}`, planPalletId: `${n + 1}2${i}`,
-    inboundCode: `IN-${n + 1}-${i}`, destination: { key: `FBA:A${i}`, warehouseCode: `A${i}` }, scheduledPackages: 2, pickedPackages: needsLoading && c === source ? 0 : 2 })) }))
-  if (fault === 'overlap') states[1].items[0].warehousePalletId = states[0].items[0].warehousePalletId
-  const triples = cases.map((c, n) => ({ dispatchNo: c.dispatchNo, tripNo: `TR-${n + 1}`, warehouseId: '92', stops: [{ index: 0, destinationKey: 'ORIGIN:92' }, { index: 1, destinationKey: 'FBA:A1' }, { index: 2, destinationKey: 'FBA:A2' }] }))
-  let dirty = false, replayed = false
-  const totals = s => ({ itemCount: s.items.length, palletCount: s.items.length, packageCount: 4, pickedPackageCount: s.items.reduce((n, i) => n + i.pickedPackages, 0), shippedPackageCount: 0 })
-  const detail = s => ({ dispatchNo: s.dispatchNo, status: 'ACTIVE', stage: s.stage, recordVersion: s.recordVersion, counts: totals(s), pickingReconciled: s.items.every(i => i.pickedPackages === 2),
-    dispatchInfo: { route: 'A1,A2' }, orderDetails: s.items.map(i => ({ customerId, sourceKey: i.sourceKey, inboundCode: i.inboundCode, destinationFbaWarehouse: i.destination.warehouseCode })) })
-  const cargo = s => s.items.map((i, n) => ({ ...i, orderId: `4${s.dispatchNo.slice(-1)}${n + 1}`, sourceRegion: 'FIRSTLEG', sourceInboundId: `9007199254740994${s.dispatchNo.slice(-1)}${n + 1}`, packages: 2 }))
-  const groups = s => cargo(s).map((row, n) => ({ groupKey: `G-${s.dispatchNo}-${n}`, customerId, destination: row.destination, groupCargoHash: `${n + 1}`.repeat(64), externalFreightHash: 'b'.repeat(64), externalQuotes: [], feeCoverageCargoHash: `${n + 1}`.repeat(64), cargo: [row], blockReasons: [], requiredServices: ['DELIVERY_FEE'],
-    feeSources: fault === 'missing-source' && n === 1 ? [] : [{ financeFeeId: `9007199254740995${s.dispatchNo.slice(-1)}${n}`, customerId: fault === 'foreign-customer' && n === 0 ? '999' : customerId,
-      currency: 'CNY', amount: fault === 'mutated-original' && saved.has(s.dispatchNo) ? 201 : 200, sourceVersion: 1, sourceHash: `fee-hash-${n}`, status: 'AVAILABLE', services: ['DELIVERY_FEE'], sourceKeys: [row.sourceKey] }] }))
-  const ack = (s, action, result = {}) => ({ dispatchNo: s.dispatchNo, action, recordVersion: s.recordVersion, status: 'ACTIVE', stage: s.stage, counts: totals(s), result, replayed: false })
-  const response = (data, message = '') => ({ http: 200, body: { code: message ? 'A0409' : '200', message, data: clone(data) }, requestId: 'OFFLINE-REQ', traceId: 'OFFLINE-TRACE' })
-  const context = { marker: source.marker, createdResources: { fleetFeeCoverageCases: cases, fleetTrips: triples }, checkpoint: async () => {},
-    assert(_module, name, _response, passed) { assertions.push({ name, passed }) }, addStep(_module, name, _response, passed) { assertions.push({ name, passed }) }, addCoverageGap() {}, apiSuccess(_m, _l, r) { return r.body?.data },
-    async request(method, raw, body, token) {
-      calls.push({ method, path: raw, body: clone(body), token })
-      const path = raw.split('?')[0], params = new URLSearchParams(raw.split('?')[1]), normalized = path.replace(PDA, BASE), number = normalized.slice(BASE.length + 1).split('/')[0]
-      const state = states.find(s => s.dispatchNo === number), commandKey = `${normalized}:${body?.idempotencyKey}`
-      if (method === 'POST' && ledger.has(commandKey)) { assert.deepEqual(body, ledger.get(commandKey).body); replayed = true; return response({ ...clone(ledger.get(commandKey).data), replayed: true }) }
-      const remember = data => { ledger.set(commandKey, { body: clone(body), data: clone(data) }); return response(data) }
-      if (method === 'GET' && path === BASE) return response({ records: states.filter(s => s.dispatchNo === params.get('dispatchNo')).map(s => ({ ...detail(s), warehouseId: '92' })) })
-      if (path.includes('/outbound-orders?') || raw.includes('/outbound-orders?')) return response({ records: dirty ? [{ outboundNo: 'OUT-DIRTY', dispatchNo: source.dispatchNo }] : [], total: dirty ? 1 : 0, page: 1, size: 200 })
-      if (path.match(/\/outbound-orders\/OUT-DS-[12]$/)) { const n = path.slice(path.lastIndexOf('OUT-') + 4), s = states.find(s => s.dispatchNo === n), p = saved.get(n); return response({ outbound: { outboundNo: `OUT-${n}`, dispatchNo: n, status: 'WAIT_OUTBOUND' }, deliveries: p.groups.map((g, i) => ({ deliveryNo: `DEL-${n}-${i}`, status: 'WAIT_DELIVERY' })) }) }
-      const delivery = path.match(/\/delivery-orders\/DEL-(DS-[12])-(\d)$/)
-      if (delivery) {
-        assert.equal(params.get('customerId'), customerId)
-        const s = states.find(s => s.dispatchNo === delivery[1]), index = Number(delivery[2]), group = groups(s)[index], input = saved.get(s.dispatchNo).groups[index]
-        const references = input.feeCoverage.map(selection => ({ source: { ...group.feeSources.find(f => f.financeFeeId === selection.financeFeeId), sourceType: 'INBOUND_FEE', sourceInboundId: group.cargo[0].sourceInboundId,
-          ...(fault === 'snapshot-source-amount' ? { amount: 999 } : {}) }, services: selection.services }))
-        const evidence = input.feeCoverage.length ? { cargoHash: group.feeCoverageCargoHash, cargo: fault === 'wrong-cargo' ? cargo(s) : group.cargo,
-          references: fault === 'missing-reference' ? [] : references, operatorId: 'OP', confirmedAt: replayed && fault === 'rewrite-confirmation' ? '2026-10-19T02:00:00Z' : '2026-10-19T01:00:00Z' } : null
-        let fees = input.fees.map(f => ({ id: `8${index}`, feeDirection: f.direction, feeType: f.feeType, currency: f.currency, amount: f.amount, reviewStatus: 'APPROVED', sourceStatus: 'ACTIVE' }))
-        if (fault === 'duplicate-new-fee' && index === 0 || fault === 'replay-adds-fee' && replayed) fees.push({ id: '999', feeDirection: 'RECEIVABLE', feeType: 'DELIVERY_FEE', currency: 'USD', amount: 17.5, reviewStatus: 'APPROVED', sourceStatus: 'ACTIVE' })
-        if (fault === 'charge-covered-destination') fees = index === 0 ? [{ id: '999', feeDirection: 'RECEIVABLE', feeType: 'DELIVERY_FEE', currency: 'USD', amount: 17.5, reviewStatus: 'APPROVED', sourceStatus: 'ACTIVE' }] : []
-        return response({ order: { dispatchNo: s.dispatchNo, deliveryNo: `DEL-${s.dispatchNo}-${index}`, customerId: fault === 'wrong-delivery-customer' ? '999' : customerId, outboundNo: `OUT-${s.dispatchNo}`, destinationWarehouseCode: group.destination.warehouseCode }, fees, feeCoverage: evidence })
-      }
-      assert.ok(state, `${method} ${raw}`)
-      if (path.startsWith(PDA) && method === 'GET' && normalized.endsWith(number)) return response({ ...detail(state), items: state.items.map((i, n) => ({ ...i, positions: [{ positionId: `6${n}`, availablePackages: 2 }] })) })
-      if (method === 'POST' && normalized.endsWith('/pick')) { assert.ok(token); if (body.recordVersion !== state.recordVersion) return response(null, '公共版本已变化'); const itemId = normalized.split('/').at(-2); state.items.find(i => i.dispatchItemId === itemId).pickedPackages += body.packages; state.recordVersion++; return remember(ack(state, 'PICK')) }
-      if (method === 'GET' && normalized.endsWith('/loading')) return response({ ...detail(state), manifestHash: 'c'.repeat(64), loadingComplete: { allowed: true }, pallets: state.items.map((i, n) => ({ ...i, palletNo: `PAL-${n}`, deliveryIndex: n + 1, palletSpaces: 1, weightKg: 20, volumeCbm: 0.2,
-        evidence: ['palletSpaces', 'weightKg', 'volumeCbm'].map(field => ({ field, value: field === 'palletSpaces' ? 1 : field === 'weightKg' ? 20 : 0.2, actual: true, sourceType: 'MEASURED', sourceBusinessNo: i.inboundCode, observedAt: '2026-10-19T01:00:00Z' })) })) })
-      if (method === 'POST' && normalized.endsWith('/loading-complete')) { assert.equal(body.recordVersion, state.recordVersion); assert.equal(state.items.every(i => i.pickedPackages === 2), true); state.stage = 'AFTER_LOADING'; state.recordVersion++; return remember(ack(state, 'LOADING_COMPLETE', { confirmedLoad: { manifestHash: body.manifestHash, pallets: body.measurements } })) }
-      if (method === 'GET' && path.endsWith('/items')) return response({ dispatchNo: number, recordVersion: state.recordVersion, status: 'ACTIVE', stage: state.stage, items: state.items })
-      if (method === 'GET' && path.endsWith('/route')) return response({ dispatchNo: number, recordVersion: state.recordVersion, stops: triples.find(t => t.dispatchNo === number).stops })
-      if (method === 'GET' && path.endsWith('/delivery-arrangement')) return response({ ...detail(state), cargoHash: 'a'.repeat(64), loadingCompletionHash: 'c'.repeat(64), arrange: { allowed: !saved.has(number) }, groups: groups(state), arrangement: saved.has(number) ? { dispatchNo: number } : null })
-      if (method === 'POST' && path.endsWith('/transfer-delivery')) {
-        assert.ok(body.idempotencyKey); assert.equal(body.recordVersion, state.recordVersion); assert.equal(state.stage, 'AFTER_LOADING')
-        if (body.cargoHash !== 'a'.repeat(64)) { if (fault === 'failed-command-writes') dirty = true; return response(null, '装车或实际货物已经变化') }
-        if (body.groups.some(g => g.feeCoverage.some(f => f.sourceVersion !== 1))) return response(null, '原费用版本已变化')
-        if (source.mode === 'FULL' && body.groups.some(g => g.fees.length)) return response(null, '本组服务已全部覆盖，不得重复登记应收')
-        if (source.mode === 'PARTIAL' && !body.groups.some(g => g.fees.length)) return response(null, '本组尚有未覆盖的服务费用，请核对')
-        saved.set(number, clone(body)); state.recordVersion++
-        const result = ack(state, 'ARRANGE_DELIVERY', { dispatchNo: number, cargoHash: body.cargoHash, outbounds: [{ customerId, outboundNo: `OUT-${number}`, status: 'WAIT_OUTBOUND', packageCount: 4 }],
-          deliveries: groups(state).map((g, n) => ({ groupKey: g.groupKey, customerId, destination: g.destination, outboundNo: `OUT-${number}`, deliveryNo: `DEL-${number}-${n}`, status: 'WAIT_DELIVERY', packageCount: 2 })) })
-        if (fault === 'unknown-write') return { http: 0, body: null, raw: 'connection reset' }
-        return remember(result)
-      }
-      assert.equal(method, 'GET', raw); assert.equal(path, `${BASE}/${number}`); return response(detail(state))
-    } }
-  return { context, source, cases, calls, assertions, states, groups, clearFault() { fault = '' } }
+import { verifyFleetFeeCoverage } from './fleet-fee-coverage-acceptance.mjs'
+const BASE = '/api/platform/v1/last-leg/dispatches'
+function fixture(fault = '') {
+  const cases = ['FULL','PARTIAL'].map((mode,i)=>({marker:'RUN',mode,dispatchNo:`DS-${i}`,customerId:'C'}))
+  const trips = cases.map(c=>({dispatchNo:c.dispatchNo,tripNo:`TR-${c.mode}`,warehouseId:'92',loadingCommand:{body:{idempotencyKey:`KEY-${c.mode}`},result:{action:'LOADING_COMPLETE',dispatchNo:c.dispatchNo,stage:'DELIVERING',result:{loadingCompletionHash:'HASH'}}}}))
+  const items = cases.map((c,i)=>[{customerId:'C',warehousePalletId:fault==='overlap'?'PAL':`PAL-${i}`,sourceKey:`SOURCE-${i}`,destination:{key:'FBA:A'},pickedPackages:2,scheduledPackages:2}])
+  const docs = i=>({outbounds:[{customerId:'C',outboundNo:`OUT-${i}`,status:'OUTBOUNDED'}],deliveries:[{customerId:'C',outboundNo:`OUT-${i}`,deliveryNo:`DEL-${i}`,destination:{key:'FBA:A'},status:'DELIVERING',packageCount:2}]})
+  const detail = i=>({dispatchNo:`DS-${i}`,recordVersion:7,status:'ACTIVE',stage:'DELIVERING',pickingReconciled:true,counts:{packageCount:2,pickedPackageCount:2,shippedPackageCount:2},documents:fault==='missing-docs'?{}:docs(i)})
+  const calls=[]
+  const context={marker:'RUN',createdResources:{fleetFeeCoverageCases:cases,fleetTrips:trips},checkpoint:async()=>{},assert(_m,label,_r,ok){assert.ok(ok,label)},apiSuccess(_m,_l,r){return r.body.data},async request(method,raw){
+    calls.push({method,raw});assert.equal(method,'GET')
+    const url=new URL(raw,'https://offline.invalid'),path=url.pathname
+    let data
+    if(path===BASE){const i=Number(url.searchParams.get('dispatchNo').slice(-1));data={records:[{...detail(i),warehouseId:'92'}]}}
+    else if(path.includes('/delivery-orders/')){const i=Number(path.slice(-1));assert.equal(url.searchParams.get('customerId'),'C');data={order:{dispatchNo:`DS-${i}`,deliveryNo:`DEL-${i}`,outboundNo:`OUT-${i}`,customerId:fault==='foreign-customer'?'OTHER':'C',packageCount:2,status:'DELIVERING'},fees:fault==='duplicate-fee'?[{id:'F'},{id:'F'}]:[],feeCoverage:null}}
+    else{const i=Number(path.split('/dispatches/')[1][3]);data=path.endsWith('/items')?{...detail(i),items:items[i]}:detail(i)}
+    return {http:200,body:{code:'200',data},requestId:'REQ',traceId:'TRACE'}
+  }}
+  return {context,cases,trips,calls}
 }
-
-for (const mode of ['FULL', 'PARTIAL']) test(`${mode} uses native grouped fees, immutable confirmation evidence and original-key replay`, async () => {
-  const f = fixture(mode), proof = await verifyFleetFeeCoverage(f.context, 'coverage', f.source)
-  assert.equal(proof.status, 'VERIFIED'); assert.equal(proof.newReceivable, mode === 'FULL' ? 0 : 17.5); assert.equal(proof.deliveryNos.length, 2)
-  assert.ok(f.assertions.every(a => a.passed)); assert.ok(f.calls.every(c => !/cancel|unbind|pre-arrange|fee-coverage/.test(c.path)))
-  assert.equal(proof.confirmationRequest.recordVersion, 0); assert.equal(proof.confirmationRequest.groups.length, 2)
-  await assert.rejects(verifyFleetFeeCoverage(f.context, 'coverage', f.source), /未执行/)
+for(const index of [0,1])test(`automatic delivery reads authoritative documents for fixture ${index}`,async()=>{
+  const f=fixture(),proof=await verifyFleetFeeCoverage(f.context,'automatic',f.cases[index])
+  assert.equal(proof.status,'VERIFIED');assert.deepEqual(proof.deliveryNos,[`DEL-${index}`])
+  assert.equal(proof.feeCoverageSelection,'NOT_APPLICABLE_AUTOMATIC_DELIVERY')
+  assert.equal(Object.hasOwn(proof,'newReceivable'),false)
+  assert.deepEqual(proof.confirmationRequest,f.trips[index].loadingCommand.body)
+  assert.ok(f.calls.every(c=>c.method==='GET'))
+  assert.equal((await verifyFleetFeeCoverage(f.context,'automatic',f.cases[index],{reconcilePersisted:true})).status,'VERIFIED')
+  await assert.rejects(verifyFleetFeeCoverage(f.context,'automatic',f.cases[index]),/未执行/)
 })
-
-test('LOADING performs actual PDA picks, immutable pick replay and explicit loading completion before arranging', async () => {
-  const f = fixture('FULL', '', true), proof = await verifyFleetFeeCoverage(f.context, 'coverage', f.source, { pickerToken: 'OFFLINE-ONLY' })
-  assert.equal(proof.status, 'VERIFIED')
-  const loading = f.calls.findIndex(c => c.method === 'POST' && c.path.endsWith('/loading-complete')), arrangement = f.calls.findIndex(c => c.method === 'POST' && c.path.endsWith('/transfer-delivery'))
-  assert.ok(loading > f.calls.findIndex(c => c.path.endsWith('/pick'))); assert.ok(arrangement > loading)
+for(const fault of ['overlap','missing-docs','foreign-customer','duplicate-fee'])test(`automatic proof rejects ${fault}`,async()=>{
+  const f=fixture(fault);await assert.rejects(verifyFleetFeeCoverage(f.context,'automatic',f.cases[0]));assert.notEqual(f.cases[0].proof.status,'VERIFIED')
 })
-
-test('reviewed persisted reconciliation only replays original successful native command after actual document readback', async () => {
-  const f = fixture('FULL', 'wrong-cargo'); await assert.rejects(verifyFleetFeeCoverage(f.context, 'coverage', f.source)); assert.ok(f.source.proof.outboundNo)
-  const original = clone(f.source.proof.confirmationRequest), before = f.calls.length; f.clearFault()
-  assert.equal((await verifyFleetFeeCoverage(f.context, 'coverage', f.source, { reconcilePersisted: true })).status, 'VERIFIED')
-  assert.ok(f.calls.slice(before).filter(c => c.method === 'POST').every(c => JSON.stringify(c.body) === JSON.stringify(original)))
-})
-
-for (const fault of ['foreign-customer', 'missing-source', 'failed-command-writes', 'wrong-cargo', 'missing-reference', 'duplicate-new-fee', 'rewrite-confirmation', 'mutated-original', 'charge-covered-destination', 'replay-adds-fee', 'wrong-delivery-customer', 'overlap', 'unknown-write', 'snapshot-source-amount']) test(`native fee proof rejects ${fault}`, async () => {
-  const f = fixture(fault === 'charge-covered-destination' ? 'PARTIAL' : 'FULL', fault)
-  await assert.rejects(verifyFleetFeeCoverage(f.context, 'coverage', f.source)); assert.notEqual(f.source.proof.status, 'VERIFIED')
-  if (['foreign-customer', 'missing-source', 'overlap'].includes(fault)) assert.equal(f.calls.some(c => c.method === 'POST'), false)
-  if (fault === 'unknown-write') { assert.equal(f.source.proof.status, 'OUTCOME_UNKNOWN'); const last = f.calls.at(-1); assert.equal(last.method, 'POST'); assert.equal(f.context.createdResources.dispatchWriteBoundary.stopped, true) }
-})
-
-test('two current registered source groups are required before HTTP; missing PDA and ambiguous mixed provenance never guess', async () => {
-  const missing = fixture(); missing.context.createdResources.fleetFeeCoverageCases.pop(); await assert.rejects(verifyFleetFeeCoverage(missing.context, 'coverage', missing.source), /两组不重叠/); assert.equal(missing.calls.length, 0)
-  const noPicker = fixture('FULL', '', true); await assert.rejects(verifyFleetFeeCoverage(noPicker.context, 'coverage', noPicker.source), /PDA身份/); assert.equal(noPicker.calls.some(c => c.method === 'POST'), false)
-  const f = fixture('PARTIAL'), groups = f.groups(f.states[1]); groups[0].cargo.push({ ...groups[0].cargo[0], sourceInboundId: '999' }); assert.throws(() => coveragePlan({ groups }, f.source), /不能唯一映射/)
-  const multi = fixture('PARTIAL'), many = multi.groups(multi.states[1]), third = clone(many[1]); third.groupKey = 'GROUP-THIRD'; third.cargo[0].sourceKey = 'PLAN:999'; third.cargo[0].sourceInboundId = '999'; third.feeSources[0].financeFeeId = '9999'; third.feeSources[0].sourceKeys = ['PLAN:999']; many.push(third)
-  assert.throws(() => coveragePlan({ groups: many }, multi.source), /明确逐组费用/)
-  multi.source.transferBody.groupFees = { [many[1].groupKey]: [{ ...multi.source.transferBody.fees[0], amount: 6 }] }
-  assert.throws(() => coveragePlan({ groups: many }, multi.source), /明确逐组费用/)
-  multi.source.transferBody.groupFees[third.groupKey] = [{ ...multi.source.transferBody.fees[0], amount: 7 }]
-  assert.deepEqual(coveragePlan({ groups: many }, multi.source).groups.map(g => g.fees.map(f => f.amount)), [[], [6], [7]])
-  const unsafe = fixture(); unsafe.source.customerId = 9007199254740992; assert.throws(() => coveragePlan({ groups: unsafe.groups(unsafe.states[0]) }, unsafe.source), /ID精度无效/)
-})
-
-test('public native delivery DTO retains grouped fees and requires version and loading hashes', () => {
-  const dto = readFileSync(new URL('../../lastleg-service/src/main/java/com/baiyue/lastleg/dispatch/port/DispatchDeliveryModels.java', import.meta.url), 'utf8')
-  assert.ok(dto.includes('record ArrangeDelivery(Long recordVersion')); assert.ok(dto.includes('String loadingCompletionHash')); assert.ok(dto.includes('List<ArrangeGroup> groups'))
+test('requires original current-run loading completion receipt and registered disjoint fixtures',async()=>{
+  const f=fixture();delete f.trips[0].loadingCommand;await assert.rejects(verifyFleetFeeCoverage(f.context,'automatic',f.cases[0]))
+  const missing=fixture();missing.cases.pop();await assert.rejects(verifyFleetFeeCoverage(missing.context,'automatic',missing.cases[0]));assert.equal(missing.calls.length,0)
 })

scripts/admin-test-env-modules/fleet-fee-coverage-acceptance.mjs

@@ -1,15 +1,9 @@
-import { DISPATCH_BASE as BASE, id as stringId, version, commandKey, dispatchIo, replay, readDispatch } from './grouped-dispatch-acceptance.mjs'
+import { DISPATCH_BASE as BASE, id as stringId, dispatchIo, readDispatch } from './grouped-dispatch-acceptance.mjs'
 import { pickAll } from './phase5-overseas-fulfillment.mjs'
 import { confirmFleetLoading } from './fleet-trip-fulfillment.mjs'
 
 export const stableRows = rows => JSON.stringify(rows.map(row => JSON.stringify(row)).sort())
-const clone = value => structuredClone(value)
 const id = value => { if (typeof value === 'number' && !Number.isSafeInteger(value)) throw Error('服务端ID精度无效，必须保留Long字符串'); return stringId(value) }
-const positive = value => /^[1-9]\d*$/.test(id(value))
-const sha = value => /^[a-f0-9]{64}$/i.test(value || '')
-const cents = value => { const text = String(value); if (!/^\d+(?:\.\d{1,2})?$/.test(text)) throw Error('费用必须为明确的非负两位金额'); const [whole, fraction = ''] = text.split('.'); return BigInt(whole) * 100n + BigInt(fraction.padEnd(2, '0')) }
-const cargoIdentity = row => ({ dispatchItemId: id(row.dispatchItemId), warehousePalletId: id(row.warehousePalletId), orderId: id(row.orderId), sourceInboundId: id(row.sourceInboundId), packages: Number(row.packages) })
-const feeIdentity = fee => ({ financeFeeId: id(fee.financeFeeId), customerId: id(fee.customerId), currency: fee.currency, amount: String(fee.amount), sourceVersion: fee.sourceVersion, sourceHash: fee.sourceHash, status: fee.status, sourceKeys: [...fee.sourceKeys].sort() })
 
 export function fleetConsumerIo(context, module, proof, namespace) {
   const io = dispatchIo(context, module, proof, namespace)
@@ -27,188 +21,65 @@ export async function readyFleetDispatch(context, module, io, trip, { pickerToke
   io.check('真实履约写入须有正式持久化检查点', null, typeof context.checkpoint === 'function')
   let current = await readDispatch(io, trip.dispatchNo)
   io.check('本轮实车仓库及未发车范围', null, context.createdResources.fleetTrips?.includes(trip) && trip.tripNo
-    && current.warehouseId === id(trip.warehouseId) && current.data.status === 'ACTIVE' && Number(current.data.counts.shippedPackageCount) === 0)
+    && current.warehouseId === id(trip.warehouseId) && current.data.status === 'ACTIVE' && ['LOADING', 'DELIVERING'].includes(current.data.stage))
   if (current.data.stage === 'LOADING') {
     io.check('真实扫码需本轮PDA身份', null, typeof pickerToken === 'string' && pickerToken.length > 0)
     io.check('PDA逐来源真实扫码完成', null, await pickAll(context, pickerToken, trip.dispatchNo))
     await confirmFleetLoading(context, module, trip, pickerToken, actualMeasurements)
     current = await readDispatch(io, trip.dispatchNo)
   }
-  io.check('安排前已真实扫码并显式装车完成', null, current.data.stage === 'AFTER_LOADING' && current.data.pickingReconciled === true
+  io.check('装车完成后自动派送并保留真实拣货', null, current.data.stage === 'DELIVERING' && current.data.pickingReconciled === true
     && Number(current.data.counts.packageCount) > 0 && Number(current.data.counts.pickedPackageCount) === Number(current.data.counts.packageCount)
     && current.items.items.every(i => Number(i.pickedPackages) === Number(i.scheduledPackages)))
   return current
 }
 
-// FeeCandidate未暴露sourceInboundId，仅在sourceKeys可唯一映射到实际原入仓时选择，混托歧义直接阻断。
-export function coveragePlan(preview, source, externalReceipt) {
-  if (!preview.groups?.length) throw Error('缺少当前全车派送分组')
-  const firstleg = preview.groups.flatMap(g => g.cargo.filter(c => c.sourceRegion === 'FIRSTLEG'))
-  const inboundIds = [...new Set(firstleg.map(c => id(c.sourceInboundId)))].sort()
-  if (!inboundIds.length || inboundIds.some(v => !positive(v)) || source.mode === 'PARTIAL' && inboundIds.length < 2) throw Error('FULL/PARTIAL需要本轮真实原入仓，PARTIAL至少两票')
-  const selectedInbounds = new Set(source.mode === 'FULL' ? inboundIds : [inboundIds[0]])
-  const originalFees = [], selections = new Map(), uncovered = []
-  for (const group of preview.groups) {
-    if (!group.groupKey || !positive(group.customerId) || !group.destination?.key || !sha(group.groupCargoHash) || !sha(group.feeCoverageCargoHash)
-      || !sha(group.externalFreightHash) || !Array.isArray(group.blockReasons) || group.blockReasons.length || !Array.isArray(group.feeSources) || !Array.isArray(group.externalQuotes)
-      || !group.cargo.length || group.cargo.some(c => id(c.customerId) !== id(group.customerId) || c.destination?.key !== group.destination.key)) throw Error('客户目的地或费用预览范围不完整')
-    const own = group.cargo.filter(c => c.sourceRegion === 'FIRSTLEG')
-    if (own.some(c => id(c.customerId) !== id(source.customerId))) throw Error('原费用跨客户，不能沿其他客户确认覆盖')
-    if (group.externalQuotes.some(q => !externalReceipt || q.bookingNo !== externalReceipt.bookingNo || q.inboundCode !== externalReceipt.incomingNo
-      || id(q.customerId) !== id(group.customerId) || q.groupKey !== group.groupKey || q.sourceHash !== group.externalFreightHash
-      || q.currency !== externalReceipt.finalBooking.cargo.currency || cents(q.amount) !== cents(externalReceipt.finalBooking.agreedAmount))) throw Error('当前外接报价与本轮运营确认金额或来源摘要不一致')
-    for (const cargo of group.cargo.filter(c => c.sourceRegion !== 'FIRSTLEG')) {
-      if (!externalReceipt || cargo.inboundCode !== externalReceipt.incomingNo || !externalReceipt.createRequest
-        || id(cargo.customerId) !== id(externalReceipt.createRequest.customerId)
-        || !group.externalQuotes.some(q => q.bookingNo === externalReceipt.bookingNo && q.inboundCode === cargo.inboundCode && id(q.customerId) === id(group.customerId))) throw Error('非头程货物没有本轮已确认外接报价')
-    }
-    const byInbound = new Map()
-    for (const fee of group.feeSources) {
-      if (id(fee.customerId) !== id(group.customerId) || !positive(fee.financeFeeId) || fee.currency !== 'CNY' || !['AVAILABLE', 'SETTLED'].includes(fee.status)
-        || !Number.isSafeInteger(fee.sourceVersion) || fee.sourceVersion < 1 || !fee.sourceHash || !Array.isArray(fee.sourceKeys) || !fee.sourceKeys.length
-        || !fee.services?.includes('DELIVERY_FEE')) throw Error('原费用客户、版本或来源不可用')
-      cents(fee.amount)
-      const actual = own.filter(c => fee.sourceKeys.includes(c.sourceKey)), ids = new Set(actual.map(c => id(c.sourceInboundId)))
-      if (ids.size !== 1 || fee.sourceKeys.some(k => !actual.some(c => c.sourceKey === k))) throw Error('原费用sourceKeys不能唯一映射原入仓；需生产预览提供原费用sourceInboundId或无混托真实来源')
-      const inbound = [...ids][0]
-      if (!byInbound.has(inbound)) byInbound.set(inbound, fee)
-      originalFees.push({ groupKey: group.groupKey, ...feeIdentity(fee) })
-    }
-    if (own.some(c => !byInbound.has(id(c.sourceInboundId)))) throw Error('本轮每票必须有实际原费用，不能借其他票补齐')
-    selections.set(group.groupKey, [...byInbound].filter(([inbound]) => selectedInbounds.has(inbound)).map(([, fee]) => ({ financeFeeId: id(fee.financeFeeId), sourceVersion: fee.sourceVersion, sourceHash: fee.sourceHash, services: ['DELIVERY_FEE'] })))
-    if (own.some(c => !selectedInbounds.has(id(c.sourceInboundId)))) uncovered.push(group.groupKey)
+/** 装车完成已生成单据并发车；仅读权威单据，不补人工费用或覆盖选择。 */
+export async function readAutomaticDelivery(io, current, trip) {
+  const documents = current.data.documents
+  const deliveries = documents?.deliveries, outbounds = documents?.outbounds
+  io.check('自动派送单据完整且客户箱数守恒', null, current.data.stage === 'DELIVERING'
+    && Array.isArray(deliveries) && deliveries.length > 0 && Array.isArray(outbounds) && outbounds.length > 0
+    && new Set(deliveries.map(d => d.deliveryNo)).size === deliveries.length
+    && new Set(outbounds.map(o => o.outboundNo)).size === outbounds.length
+    && deliveries.every(d => d.deliveryNo && d.status === 'DELIVERING' && outbounds.some(o => o.outboundNo === d.outboundNo && id(o.customerId) === id(d.customerId)))
+    && outbounds.every(o => o.outboundNo && o.status === 'OUTBOUNDED')
+    && deliveries.reduce((sum, d) => sum + Number(d.packageCount), 0) === Number(current.data.counts.packageCount)
+    && current.items.items.every(i => deliveries.some(d => id(d.customerId) === id(i.customerId) && d.destination?.key === i.destination?.key)))
+  const snapshots = {}, feeRows = {}
+  for (const ref of deliveries) {
+    const detail = await io.get(`/api/platform/v1/last-leg/delivery-orders/${encodeURIComponent(ref.deliveryNo)}?customerId=${encodeURIComponent(id(ref.customerId))}`, '回查自动生成派送的客户、目的地和费用事实')
+    io.check('自动生成单据归属和货量正确', null, detail?.order?.dispatchNo === trip.dispatchNo && detail.order.deliveryNo === ref.deliveryNo
+      && id(detail.order.customerId) === id(ref.customerId) && detail.order.outboundNo === ref.outboundNo
+      && Number(detail.order.packageCount) === Number(ref.packageCount) && detail.order.status === 'DELIVERING'
+      && Array.isArray(detail.fees) && new Set(detail.fees.map(f => id(f.id))).size === detail.fees.length)
+    snapshots[ref.deliveryNo] = detail.feeCoverage; feeRows[ref.deliveryNo] = stableRows(detail.fees)
   }
-  const template = source.transferBody
-  if (template?.loadingType !== 'PALLET' || template.appointmentAccount !== 'SELF' || template.fees?.length !== 1
-    || template.fees[0].direction !== 'RECEIVABLE' || template.fees[0].feeType !== 'DELIVERY_FEE' || cents(template.fees[0].amount) <= 0n) throw Error('覆盖用例须有明确的未覆盖派送应收金额')
-  if (uncovered.length > 1 && uncovered.some(key => !Array.isArray(template.groupFees?.[key]) || template.groupFees[key].length !== 1)) throw Error('多个未覆盖目的地须由本轮用例明确逐组费用，不能自动分摊')
-  const groups = preview.groups.map(group => {
-    const fees = uncovered.includes(group.groupKey) ? clone(template.groupFees?.[group.groupKey] || template.fees) : []
-    if (uncovered.includes(group.groupKey) && fees.length !== 1 || fees.some(f => f.direction !== 'RECEIVABLE' || f.feeType !== 'DELIVERY_FEE' || cents(f.amount) <= 0n || !['CNY', 'USD'].includes(f.currency) || f.currency !== template.fees[0].currency)) throw Error('逐组未覆盖应收不完整')
-    return { groupKey: group.groupKey, groupCargoHash: group.groupCargoHash, plannedDeliveryAt: template.plannedDeliveryAt || new Date(Date.now() + 21600000).toISOString(),
-      deliveryMethod: template.deliveryMethod || 'TRUCK_PALLET', waybillNo: template.waybillNo || null, carrierName: template.carrierName || null,
-      pickupMethod: template.pickupMethod || 'WAREHOUSE_PICKUP', loadingType: 'PALLET', vehicleType: template.vehicleType || 'TRUCK', vehicleSize: template.vehicleSize || null,
-      appointmentAccount: 'SELF', sellerName: null, remark: template.remark || null, externalFreightHash: group.externalFreightHash,
-      feeCoverageCargoHash: group.feeCoverageCargoHash, feeCoverage: selections.get(group.groupKey), fees }
-  })
-  return { groups, originalFees, selectedInbounds: [...selectedInbounds], inboundIds }
+  const command = trip.loadingCommand
+  io.check('本轮装车成功回执完整', null, command?.body?.idempotencyKey && command.result?.action === 'LOADING_COMPLETE'
+    && command.result.dispatchNo === trip.dispatchNo && command.result.stage === 'DELIVERING')
+  return { outbounds, deliveries, snapshots, feeRows, confirmationRequest: command.body, command: command.result }
 }
 
-async function noDocuments(io, source, label) {
-  let total, rows = []
-  for (let page = 1; ; page++) {
-    const data = await io.get(`/api/platform/v1/last-leg/outbound-orders?${new URLSearchParams({ customerId: id(source.customerId), size: '200', page: String(page) })}`, label)
-    io.check('客户出库分页完整稳定', null, Array.isArray(data?.records) && Number.isSafeInteger(Number(data.total)) && Number(data.page) === page && Number(data.size) === 200
-      && Number(data.total) >= 0 && (total === undefined || total === Number(data.total)) && (data.records.length > 0 || rows.length === Number(data.total)))
-    total ??= Number(data.total); rows.push(...data.records); if (rows.length >= total) break
-  }
-  io.check('拒绝后无本排车出库写入', null, rows.length === total && new Set(rows.map(r => r.outboundNo)).size === rows.length && rows.every(r => r.dispatchNo !== source.dispatchNo))
-}
-
-/** 两个本轮不重叠来源用例必须先准备；从不取消已扫码FULL再复用同批实物。 */
 export async function verifyFleetFeeCoverage(context, module, source, { reconcilePersisted = false, pickerToken, actualMeasurements, externalTrip } = {}) {
   const cases = context.createdResources?.fleetFeeCoverageCases
-  if (!cases?.includes(source) || source.marker !== context.marker || !['FULL', 'PARTIAL'].includes(source.mode) || source.proof && !reconcilePersisted) throw Error('原费用验收需要本轮专用、未执行的排车用例；保留原请求')
+  if (!cases?.includes(source) || source.marker !== context.marker || !['FULL', 'PARTIAL'].includes(source.mode) || source.proof && !reconcilePersisted)
+    throw Error('验收需要本轮专用、未执行排车用例；保留原请求')
   const pair = ['FULL', 'PARTIAL'].map(mode => cases.filter(c => c.marker === context.marker && c.mode === mode))
-  if (pair.some(rows => rows.length !== 1) || pair[0][0].dispatchNo === pair[1][0].dispatchNo) throw Error('需本轮生产者预先准备FULL/PARTIAL两组不重叠真实排车，不能取消已扫码FULL复用同批实物')
-  if (reconcilePersisted && (!source.proof?.confirmationRequest || !source.proof?.outboundNo || !source.proof?.deliveryNos?.length)) throw Error('续验须有原成功命令和已持久化单据，不可重造')
+  if (pair.some(rows => rows.length !== 1) || pair[0][0].dispatchNo === pair[1][0].dispatchNo) throw Error('需本轮两组不重叠真实排车')
   const proof = reconcilePersisted ? source.proof : source.proof = { marker: context.marker, status: 'CHECKING', mode: source.mode, dispatchNo: source.dispatchNo, requests: [] }
-  const io = fleetConsumerIo(context, module, proof, `FEE-${source.mode}`), path = `${BASE}/${encodeURIComponent(source.dispatchNo)}`
+  const io = fleetConsumerIo(context, module, proof, `AUTO-${source.mode}`)
   try {
     const scopes = []
     for (const [candidate] of pair) scopes.push(await readDispatch(io, candidate.dispatchNo))
     io.check('两组真实来源和实托均不重叠', null, scopes.every(s => s.items.items.length > 0) && scopes[0].items.items.every(i => !scopes[1].items.items.some(j => id(i.warehousePalletId) === id(j.warehousePalletId) || i.sourceKey === j.sourceKey)))
     const trip = context.createdResources.fleetTrips?.find(t => t.dispatchNo === source.dispatchNo)
-    io.check('本排车有本轮正式车辆审核生产回执', null, Boolean(trip))
-    const loaded = await readyFleetDispatch(context, module, io, trip, { pickerToken, actualMeasurements })
-    const preview = await io.get(`${path}/delivery-arrangement`, '读取原生全车费用预览')
-    io.check('原生派送门禁、版本及实载证据完整', null, preview?.dispatchNo === source.dispatchNo && preview.status === 'ACTIVE' && preview.stage === 'AFTER_LOADING'
-      && id(version(preview.recordVersion)) === id(version(loaded.data.recordVersion)) && sha(preview.cargoHash) && sha(preview.loadingCompletionHash)
-      && (reconcilePersisted ? Boolean(preview.arrangement) : preview.arrange?.allowed === true && !preview.arrangement))
-    const receipt = externalTrip?.externalReceipt
-    if (externalTrip && (!context.createdResources.fleetTrips.includes(externalTrip) || externalTrip.dispatchNo !== source.dispatchNo || receipt?.status !== 'VERIFIED')) throw Error('外接费用只接受本轮同主单真实运营确认')
-    const plan = coveragePlan(preview, source, receipt)
-    const totals = new Map()
-    for (const c of preview.groups.flatMap(g => g.cargo)) totals.set(id(c.dispatchItemId), (totals.get(id(c.dispatchItemId)) || 0) + Number(c.packages))
-    io.check('费用分组逐实物客户与箱数核平', null, totals.size === loaded.items.items.length && loaded.items.items.every(i => totals.get(id(i.dispatchItemId)) === Number(i.scheduledPackages)
-      && preview.groups.filter(g => g.cargo.some(c => id(c.dispatchItemId) === id(i.dispatchItemId))).every(g => id(g.customerId) === id(i.customerId) && g.destination.key === i.destination.key)))
-    const body = reconcilePersisted ? proof.confirmationRequest : { recordVersion: version(preview.recordVersion), idempotencyKey: commandKey(context.marker, `FEE-${source.mode}-${source.dispatchNo}`, 'arrange'),
-      cargoHash: preview.cargoHash, loadingCompletionHash: preview.loadingCompletionHash, groups: plan.groups }
-    if (!reconcilePersisted) { proof.confirmationRequest = clone(body); proof.originalFees = clone(plan.originalFees); await context.checkpoint?.() }
-    else io.check('原成功请求仍为同货物和实载', null, body.cargoHash === preview.cargoHash && body.loadingCompletionHash === preview.loadingCompletionHash)
-    const reject = async (label, changed, pattern) => {
-      const before = await readDispatch(io, source.dispatchNo)
-      await io.request('POST', `${path}/transfer-delivery`, { ...clone(body), ...changed, idempotencyKey: commandKey(context.marker, `${source.dispatchNo}-${source.mode}`, label) }, label, pattern)
-      for (const customerId of new Set(preview.groups.map(g => id(g.customerId)))) await noDocuments(io, { ...source, customerId }, `${label}后无单据`)
-      io.check(`${label}后整车及实物零漂移`, null, JSON.stringify(await readDispatch(io, source.dispatchNo)) === JSON.stringify(before))
-    }
-    if (!reconcilePersisted) {
-      for (const customerId of new Set(preview.groups.map(g => id(g.customerId)))) await noDocuments(io, { ...source, customerId }, '执行前确认无出库单')
-      await reject('陈旧全车货物摘要拒绝', { cargoHash: `${body.cargoHash[0] === '0' ? '1' : '0'}${body.cargoHash.slice(1)}` }, /货物.*变化/)
-      const stale = clone(body.groups), selected = stale.find(g => g.feeCoverage.length).feeCoverage[0]; selected.sourceVersion = selected.sourceVersion === 2147483647 ? selected.sourceVersion - 1 : selected.sourceVersion + 1
-      await reject('陈旧原费用版本拒绝', { groups: stale }, /原费用版本.*变化/)
-      const wrong = clone(body.groups)
-      if (source.mode === 'FULL') wrong[0].fees = clone(source.transferBody.fees)
-      else wrong.find(g => g.fees.length).fees = []
-      await reject(source.mode === 'FULL' ? '全覆盖重复应收拒绝' : '部分覆盖漏填应收拒绝', { groups: wrong }, source.mode === 'FULL' ? /覆盖.*重复|覆盖.*登记/ : /未覆盖.*费用/)
-      if (externalTrip) {
-        const extra = clone(body.groups), quoted = preview.groups.find(g => g.externalQuotes.length), input = extra.find(g => g.groupKey === quoted.groupKey), quote = quoted.externalQuotes[0]
-        input.fees.push({ direction: 'RECEIVABLE', feeType: 'DELIVERY_FEE', feeName: '本轮重复外接派送应收反例', currency: quote.currency, amount: quote.amount })
-        await reject('外接已有约定运费禁止追加重复应收', { groups: extra }, /重复|覆盖.*登记/)
-      }
-    } else {
-      const stored = await io.get(`/api/platform/v1/last-leg/outbound-orders/${encodeURIComponent(proof.outboundNo)}`, '先核对原成功出库和派送集合')
-      io.check('原单据完整且未执行', null, stored?.outbound?.dispatchNo === source.dispatchNo && stored.outbound.status === 'WAIT_OUTBOUND'
-        && stableRows((stored.deliveries || []).map(d => d.deliveryNo)) === stableRows(proof.deliveryNos) && stored.deliveries.every(d => d.status === 'WAIT_DELIVERY'))
-    }
-    const result = await io.request('POST', `${path}/transfer-delivery`, body, '按全车真实分组确认原费用并安排派送'), arranged = result?.result
-    io.check('原生命令返回完整客户出库和客户目的地派送', null, result?.dispatchNo === source.dispatchNo && result.action === 'ARRANGE_DELIVERY' && result.status === 'ACTIVE' && result.stage === 'AFTER_LOADING'
-      && BigInt(version(result.recordVersion)) > BigInt(version(body.recordVersion))
-      && arranged?.dispatchNo === source.dispatchNo && arranged.cargoHash === body.cargoHash && arranged.deliveries?.length === preview.groups.length
-      && new Set(arranged.deliveries.map(d => d.deliveryNo)).size === arranged.deliveries.length
-      && arranged.outbounds?.length === new Set(preview.groups.map(g => id(g.customerId))).size
-      && arranged.outbounds.every(o => o.outboundNo && o.status === 'WAIT_OUTBOUND' && arranged.deliveries.filter(d => d.outboundNo === o.outboundNo).reduce((n, d) => n + Number(d.packageCount), 0) === Number(o.packageCount)) && arranged.deliveries.every(d => d.deliveryNo && d.status === 'WAIT_DELIVERY'
-        && preview.groups.some(g => g.groupKey === d.groupKey && id(g.customerId) === id(d.customerId) && g.destination.key === d.destination?.key
-          && g.cargo.reduce((n, c) => n + Number(c.packages), 0) === Number(d.packageCount))
-        && arranged.outbounds.some(o => o.outboundNo === d.outboundNo && id(o.customerId) === id(d.customerId))))
-    if (reconcilePersisted) io.check('仅恢复原出库和派送集合', null, result.replayed === true && stableRows(arranged.deliveries.map(d => d.deliveryNo)) === stableRows(proof.deliveryNos))
-    proof.outbounds = arranged.outbounds; proof.deliveries = arranged.deliveries; proof.command = result
-    proof.outboundNo = arranged.outbounds.find(o => id(o.customerId) === id(source.customerId))?.outboundNo
-    proof.deliveryNos = arranged.deliveries.map(d => d.deliveryNo).sort()
-    const snapshots = {}, feeRows = {}
-    let added = 0n
-    for (const ref of arranged.deliveries) {
-      const group = preview.groups.find(g => g.groupKey === ref.groupKey), input = body.groups.find(g => g.groupKey === ref.groupKey)
-      const detail = await io.get(`/api/platform/v1/last-leg/delivery-orders/${encodeURIComponent(ref.deliveryNo)}?customerId=${encodeURIComponent(id(ref.customerId))}`, '回查当前客户目的地费用和原费快照')
-      io.check('派送只归当前客户和目的地', null, detail?.order?.dispatchNo === source.dispatchNo && detail.order.deliveryNo === ref.deliveryNo
-        && id(detail.order.customerId) === id(group.customerId) && detail.order.outboundNo === ref.outboundNo
-        && id(detail.order.destinationWarehouseCode || detail.order.destinationWarehouseId) === id(group.destination.warehouseCode || group.destination.warehouseId))
-      const evidence = detail.feeCoverage, expectedCargo = group.cargo.map(cargoIdentity)
-      if (input.feeCoverage.length) {
-        io.check('原费快照保留真实货物、确认人、时间和每票引用', null, evidence?.cargoHash === group.feeCoverageCargoHash && evidence.operatorId && Number.isFinite(Date.parse(evidence.confirmedAt))
-          && stableRows(evidence.cargo.map(cargoIdentity)) === stableRows(expectedCargo) && Array.isArray(evidence.references)
-          && stableRows(evidence.references.map(r => ({ financeFeeId: id(r.source?.financeFeeId), sourceVersion: r.source?.sourceVersion, sourceHash: r.source?.sourceHash, services: r.services }))) === stableRows(input.feeCoverage)
-          && evidence.references.every(r => id(r.source.customerId) === id(group.customerId) && ['INBOUND_FEE', 'CONTAINER_FEE'].includes(r.source.sourceType)
-            && group.cargo.some(c => id(c.sourceInboundId) === id(r.source.sourceInboundId)) && group.feeSources.some(f => id(f.financeFeeId) === id(r.source.financeFeeId)
-              && f.currency === r.source.currency && cents(f.amount) === cents(r.source.amount) && f.status === r.source.status)))
-      } else io.check('未选原费不伪造覆盖证据', null, evidence == null || evidence.references?.length === 0)
-      io.check('费用为本客户明确正数应收列表', null, Array.isArray(detail.fees) && detail.fees.every(f => f.feeDirection && f.feeType))
-      const receivables = detail.fees.filter(f => f.feeDirection === 'RECEIVABLE' && f.feeType === 'DELIVERY_FEE' && f.sourceStatus !== 'VOIDED')
-      const expectedAmounts = [...input.fees.map(f => `${f.currency}:${cents(f.amount)}`), ...group.externalQuotes.filter(q => cents(q.amount) > 0n).map(q => `${q.currency}:${cents(q.amount)}`)].sort()
-      io.check('仅未覆盖货物和原外接报价产生应收，禁止重复或零值', null, stableRows(receivables.map(f => `${f.currency}:${cents(f.amount)}`).sort()) === stableRows(expectedAmounts)
-        && receivables.every(f => cents(f.amount) > 0n && f.sourceStatus === 'ACTIVE' && f.reviewStatus === 'APPROVED'))
-      added += input.fees.reduce((n, f) => n + cents(f.amount), 0n)
-      snapshots[ref.deliveryNo] = detail.feeCoverage; feeRows[ref.deliveryNo] = stableRows(detail.fees)
-    }
-    const replayed = await replay(io, `${path}/transfer-delivery`, body, result, '费用确认原键原载荷重放')
-    io.check('费用安排重放明确恢复原成功命令', null, replayed.replayed === true)
-    for (const ref of arranged.deliveries) {
-      const detail = await io.get(`/api/platform/v1/last-leg/delivery-orders/${encodeURIComponent(ref.deliveryNo)}?customerId=${encodeURIComponent(id(ref.customerId))}`, '原键重放后回查每客户费用')
-      io.check('重放不改确认快照也不新增应收', null, JSON.stringify(detail.feeCoverage) === JSON.stringify(snapshots[ref.deliveryNo]) && stableRows(detail.fees) === feeRows[ref.deliveryNo])
-    }
-    const after = await io.get(`${path}/delivery-arrangement`, '回查原费用来源未被确认改变')
-    const currentFees = after.groups.flatMap(g => g.feeSources.map(f => ({ groupKey: g.groupKey, ...feeIdentity(f) })))
-    io.check('原费用版本金额状态保持不变', null, stableRows(currentFees) === stableRows(proof.originalFees))
-    proof.snapshots = snapshots; proof.newReceivable = Number(added) / 100; proof.status = 'VERIFIED'; await context.checkpoint?.(); return proof
+    io.check('本排车有本轮生产回执', null, Boolean(trip) && (!externalTrip || externalTrip === trip))
+    const current = await readyFleetDispatch(context, module, io, trip, { pickerToken, actualMeasurements })
+    const execution = await readAutomaticDelivery(io, current, trip)
+    if (reconcilePersisted) io.check('恢复仅读原生成单据集合', null, stableRows(proof.deliveryNos) === stableRows(execution.deliveries.map(d => d.deliveryNo)))
+    Object.assign(proof, execution, { outboundNo: execution.outbounds.find(o => id(o.customerId) === id(source.customerId))?.outboundNo,
+      deliveryNos: execution.deliveries.map(d => d.deliveryNo).sort(), feeCoverageSelection: 'NOT_APPLICABLE_AUTOMATIC_DELIVERY', status: 'VERIFIED' })
+    await context.checkpoint?.(); return proof
   } catch (error) { proof.status = proof.outcomeUnknown ? 'OUTCOME_UNKNOWN' : 'UNPROVEN'; proof.error = error.message; await context.checkpoint?.(); throw error }
 }

scripts/admin-test-env-modules/fleet-return-redispatch-acceptance-contract.test.mjs

@@ -31,6 +31,7 @@ function fixture(fault = '') {
   const nativeItem = () => ({ dispatchItemId: '501', customerId: CUSTOMER, sourceKey: 'RETURN:300', sourceVersion: 'a'.repeat(64), sourceType: 'RETURN_RECEIPT', planPalletId: null, returnReceiptId: '300', warehousePalletId: '100', palletNo: context.palletCode,
     inboundCode: 'IN-A', destination, scheduledPackages: 2, pickedPackages: picked ? 2 : 0, positions: [{ positionId: '201', availablePackages: picked ? 0 : 2 }] })
   const detail = next => ({ dispatchNo: next ? 'DP-NEXT' : 'DP-NEW', recordVersion: next ? 0 : recordVersion, status: next && nextCancelled ? 'CANCELLED' : 'ACTIVE', stage: next ? 'BEFORE_LOADING' : newSigned ? 'DELIVERED' : stage,
+    documents: { deliveries: departed && !next ? [ref()] : [], outbounds: departed && !next ? [outbound()] : [] },
     reviewState: review ? 'APPROVED' : 'DRAFT', reviews: { dispatchReview: { status: review ? 'APPROVED' : 'NOT_SUBMITTED' }, loadingReview: { status: review ? 'APPROVED' : 'NOT_SUBMITTED' } }, counts: counts(next), pickingReconciled: picked,
     vehicleInfo: { vehicle: { vehicleId: '601' }, driver: { driverId: '701' } }, dispatchInfo: { route: next ? '' : 'ONT8' }, orderDetails: next ? [] : [{ customerId: CUSTOMER, sourceKey: 'RETURN:300', inboundCode: 'IN-A', destinationFbaWarehouse: 'ONT8' }] })
   const ref = () => ({ groupKey: 'GROUP-A', customerId: CUSTOMER, destination, outboundNo: 'OUT-NEW', deliveryNo: 'DL-NEW', status: departed ? 'DELIVERING' : 'WAIT_DELIVERY', packageCount: 2 })
@@ -41,7 +42,8 @@ function fixture(fault = '') {
   const stockLedger = () => returned ? [{ id: '901', customerId: CUSTOMER, overseasWarehouseId: WAREHOUSE, inboundCode: 'IN-A', palletNo: context.palletCode, businessType: 'RETURN_STOCK_IN', businessOrderNo: 'EX-NEW', outboundOrderNo: 'OUT-ORIGINAL', deltaPackages: 2 }] : []
   const envelope = (data, code = '200', message = '') => ({ http: 200, body: { code, message, data: copy(data) }, requestId: 'OFFLINE-REQ', traceId: 'OFFLINE-TRACE' })
   const context = { marker: 'FRESH', createdResources: { fleetTrips: [trip], fleetAcceptance: { marker: 'FRESH', customerId: CUSTOMER, warehouseId: WAREHOUSE, tripNo: trip.tripNo,
-    departure: { dispatchNo: trip.dispatchNo, action: 'DEPART', status: 'ACTIVE', stage: 'DELIVERING', result: { departedAt: '2026-10-19T01:00:00Z', deliveries: [{ customerId: CUSTOMER, deliveryNo: 'DL-ORIGINAL' }] } } } },
+    departureDeliveries: [{ customerId: CUSTOMER, deliveryNo: 'DL-ORIGINAL' }],
+    departure: { dispatchNo: trip.dispatchNo, action: 'LOADING_COMPLETE', status: 'ACTIVE', stage: 'DELIVERING', result: { confirmedLoad: { manifestHash: 'ORIGINAL' } } } } },
     assert(_m, label, _r, passed) { if (!passed) throw Error(label) }, addStep(_m, label, _r, passed) { if (!passed) throw Error(label) }, addCoverageGap() {}, apiSuccess(_m, _l, r) { return r.body?.data },
     async checkpoint() { checkpoints.push(copy(trip.returnRedispatch)) },
     async requestMultipart(method, path, file) {
@@ -52,6 +54,7 @@ function fixture(fault = '') {
     async request(method, raw, body, token) {
       requests.push({ method, path: raw, body: copy(body), token })
       const path = raw.split('?')[0], params = new URLSearchParams(raw.split('?')[1]), normalized = path.replace(PDA, DISPATCH), ledgerKey = `${method}:${normalized}:${body?.idempotencyKey}`
+      if (normalized.endsWith('/loading-complete') && !token && ledger.has(ledgerKey)) return envelope(null, 'A0403', '该请求标识不属于当前操作员')
       if (body?.idempotencyKey && ledger.has(ledgerKey) && !path.endsWith('/resources/release')) { const prior = ledger.get(ledgerKey); assert.deepEqual(body, prior.body); return envelope({ ...copy(prior.data), replayed: true }) }
       const remember = data => { if (body?.idempotencyKey) ledger.set(ledgerKey, { body: copy(body), data: copy(data) }); return envelope(data) }
       if (path === '/api/platform/inbounds') { const name = params.get('inboundCode').slice(-1), delivered = name === 'A' ? newSigned || fault === 'domestic-premature-A' && originalSigned : originalSigned && fault !== 'domestic-blocked-B'; return envelope({ records: [{ inboundCode: `IN-${name}`, processStatus: delivered ? 'DELIVERED' : 'LOADED' }] }) }
@@ -83,7 +86,7 @@ function fixture(fault = '') {
         sourceKey: 'RETURN:300', sourceVersion: 'a'.repeat(64), customerId: CUSTOMER, warehouseId: WAREHOUSE, orderNo: 'LM-A', inboundCode: 'IN-A', palletNo: context.palletCode, destination, availablePackages: fault === 'wrong-candidate' ? 4 : 2, appointmentBatches: [], blockReasons: [] }] }) }
       if (path === DISPATCH && method === 'POST') { if (!body.cargo.length) { nextCreated = true; vehicleOwner = 'TR-NEXT'; driverOwner = 'TR-NEXT'; return remember(command('CREATE', {}, true)) }; assert.equal(body.cargo[0].sourceType, 'RETURN_RECEIPT'); assert.equal(body.cargo[0].planPalletId, null); created = true; return remember(command('CREATE')) }
       if (path === DISPATCH) return envelope({ records: [{ ...detail(params.get('dispatchNo') === 'DP-NEXT'), warehouseId: WAREHOUSE }] })
-      if (path.endsWith('/master-data/vehicles')) { vehiclePlate = body.plateNumber; return envelope({ id: '601' }) }
+      if (path.endsWith('/master-data/vehicles')) { vehiclePlate = body.plateNumber.toUpperCase(); return envelope({ id: '601' }) }
       if (path.endsWith('/fleet/drivers') && method === 'POST') return envelope({ id: '701', recordVersion: 0 })
       if (path.endsWith('/fleet/drivers/701/review')) return envelope({ reviewStatus: 'APPROVED' })
       if (path === `${BASE}/fleet/trips`) { const trips = nextCreated ? [tripDetail(false).trip, tripDetail(true).trip] : [tripDetail(false).trip]; return envelope({ records: trips, page: 1, size: 200, total: trips.length }) }
@@ -121,9 +124,7 @@ function fixture(fault = '') {
       assert.equal(body.recordVersion, recordVersion, raw)
       if (/\/(submit-review|dispatch-review|loading-review)$/.test(normalized)) { if (normalized.endsWith('/loading-review')) { review = true; stage = 'LOADING' }; recordVersion++; return remember(command('REVIEW')) }
       if (normalized.endsWith('/pick')) { assert.equal(token, 'private-pda-token'); picked = true; recordVersion++; return remember(command('PICK', { packages: 2 })) }
-      if (normalized.endsWith('/loading-complete')) { assert.equal(picked, true); stage = 'AFTER_LOADING'; recordVersion++; return remember(command('LOADING_COMPLETE', { confirmedLoad: { manifestHash: body.manifestHash, pallets: body.measurements } })) }
-      if (normalized.endsWith('/transfer-delivery')) { assert.equal(stage, 'AFTER_LOADING'); arranged = true; recordVersion++; return remember(command('ARRANGE_DELIVERY', { dispatchNo: 'DP-NEW', cargoHash: body.cargoHash, outbounds: [outbound()], deliveries: [ref()] })) }
-      if (normalized.endsWith('/depart')) { assert.equal(arranged, true); departed = true; stage = 'DELIVERING'; recordVersion++; return remember(command('DEPART', { departedAt: '2026-10-19T03:00:00Z', shippedPackages: 2, outbounds: [outbound()], deliveries: [ref()] })) }
+      if (normalized.endsWith('/loading-complete')) { assert.equal(picked, true); stage = 'DELIVERING'; arranged = true; departed = true; recordVersion++; return remember(command('LOADING_COMPLETE', { confirmedLoad: { manifestHash: body.manifestHash, pallets: body.measurements } })) }
       throw Error(`Unexpected ${method} ${raw}`)
     } }
   const dependencies = { wait: async () => {}, async onBeforeRedispatchSignature(proof) { assert.equal(newSigned, false); assert.equal(originalSigned, true); assert.equal(proof.preSignatureGate.status, 'WAITING'); if (fault === 'audit-gate') throw Error('Audit gate not approved'); return { sourceAEventCount: 0, sourceBEventCount: 1, auditEvidenceSha256: 'a'.repeat(64) } } }
@@ -136,10 +137,11 @@ test('native one-main multi-source return redispatch executes real APIs through
   const f = fixture(), result = await run(f)
   assert.equal(result.status, 'HTTP_CHAIN_VERIFIED_SOURCE_EVENT_EVIDENCE_REQUIRED'); assert.equal(result.sourceEventsVerified, false); assert.equal(result.readOnlyEvidenceRequired.length, 3)
   assert.equal(result.beforeRedispatch.A.order.subOrderStatus, 'DELIVERY:WAIT_DELIVERY'); assert.equal(result.beforeRedispatch.B.order.subOrderStatus, 'DELIVERY:DELIVERED')
-  assert.equal(result.afterRedispatch.A.order.subOrderStatus, 'DELIVERY:DELIVERED'); assert.equal(result.afterRedispatch.departed.action, 'DEPART'); assert.equal(result.afterRedispatch.departed.result.shippedPackages, 2)
+  assert.equal(result.afterRedispatch.A.order.subOrderStatus, 'DELIVERY:DELIVERED'); assert.equal(result.afterRedispatch.departed.action, 'LOADING_COMPLETE'); assert.equal(result.afterRedispatch.departed.counts.shippedPackageCount, 2)
   assert.equal(result.inventory.map(s => s.ledger.length).every((n, i) => n === (i === 0 ? 0 : 1)), true)
   assert.ok(!JSON.stringify(f.checkpoints).includes('private-pda-token')); assert.ok(f.checkpoints.some(p => p.requests.at(-1)?.status === 'SENDING' && p.requests.at(-1)?.file?.sha256))
-  assert.ok(f.requests.findIndex(r => r.path.endsWith('/loading-complete')) < f.requests.findIndex(r => r.path.endsWith('/transfer-delivery')))
+  assert.ok(f.requests.some(r => r.path.endsWith('/loading-complete')))
+  assert.equal(f.requests.some(r => /\/(transfer-delivery|depart)$/.test(r.path)), false)
   assert.equal(f.requests.some(r => r.path.includes('/pre-arrange')), false)
 })
 

scripts/admin-test-env-modules/fleet-return-redispatch-acceptance.mjs

@@ -3,7 +3,7 @@ import {join,resolve} from 'node:path'
 import {redactEvidence} from '../fba-core-regression-test-env.mjs'
 import { randomUUID, createHash } from 'node:crypto'
 import { prepareFleetTrip, confirmFleetLoading, finishFleetTrip } from './fleet-trip-fulfillment.mjs'
-import { pickAll, saveReceiptAndComplete, arrangeDispatchDelivery } from './phase5-overseas-fulfillment.mjs'
+import { pickAll, saveReceiptAndComplete } from './phase5-overseas-fulfillment.mjs'
 import { version, createBody, candidatePage, readDispatch, replay as replayCommand } from './grouped-dispatch-acceptance.mjs'
 
 const BASE = '/api/platform/v1/last-leg'
@@ -34,17 +34,17 @@ export function selectReturnSources(rows) {
   return { a, b }
 }
 
-/** Owned departure only; reviewed source-selection recovery preserves prior starts. Requests are checkpointed before dispatch. */
+/** 只消费本轮自动发运事实；来源恢复保留已启动派送，每次请求发送前持久记录。 */
 export async function verifyFleetReturnRedispatch(context, module, trip, input, dependencies = {}) {
   const run = context.createdResources?.fleetAcceptance
   if (Object.keys(dependencies).some(name => !['wait', 'onBeforeRedispatchSignature'].includes(name))) throw Error('Only readonly audit and wait observers may be supplied; native production, picking and signature cannot be replaced')
   const departure = run?.departure
   if (!context.marker || !context.createdResources?.fleetTrips?.includes(trip) || run?.marker !== context.marker
-    || run.tripNo !== trip.tripNo || departure?.dispatchNo !== trip.dispatchNo || departure.status !== 'ACTIVE' || departure.stage !== 'DELIVERING' || departure.action !== 'DEPART'
-    || !departure.result?.departedAt || !input?.pickerToken
+    || run.tripNo !== trip.tripNo || departure?.dispatchNo !== trip.dispatchNo || departure.status !== 'ACTIVE' || departure.stage !== 'DELIVERING' || departure.action !== 'LOADING_COMPLETE'
+    || !departure.result?.confirmedLoad || !input?.pickerToken
     || id(run.customerId) !== id(input.customerId) || id(run.warehouseId) !== id(input.warehouseId)
     || JSON.stringify([departure.dispatchNo]) !== JSON.stringify([...(input.dispatchNos || [])].sort())
-    || JSON.stringify((departure.result.deliveries || []).filter(row => id(row.customerId) === id(input.customerId)).map(row => row.deliveryNo).sort()) !== JSON.stringify([...(input.deliveryNos || [])].sort())
+    || JSON.stringify((run.departureDeliveries || []).filter(row => id(row.customerId) === id(input.customerId)).map(row => row.deliveryNo).sort()) !== JSON.stringify([...(input.deliveryNos || [])].sort())
     || !input.deliveryNos?.length || trip.returnRedispatch || typeof context.checkpoint !== 'function')
     throw Error('Redispatch requires a new owned departure, current PDA session and durable checkpoints; no automatic restart')
   const proof = trip.returnRedispatch = { marker: context.marker, status: 'CHECKING', requests: [], returnPackages: 2,
@@ -271,20 +271,19 @@ export async function verifyFleetReturnRedispatch(context, module, trip, input,
     const picked = await inventory('RETURN_PICKED')
     check('Actual returned stock is picked once without rewriting the stock-in ledger', picked.available === 0 && picked.picked === 2 && JSON.stringify(picked.ledger) === JSON.stringify(stockIn.ledger))
     await confirmFleetLoading(io, module, newTrip, input.pickerToken, input.actualMeasurements)
-    const transfer = await arrangeDispatchDelivery(io, arranged.dispatchNo)
-    check('Redispatch produces a new single destination delivery', transfer?.deliveries?.length === 1 && !input.deliveryNos.includes(transfer.deliveries[0].deliveryNo)
-      && id(transfer.deliveries[0].customerId) === customerId && Number(transfer.deliveries[0].packageCount) === 2)
+    // 装车完成已原子生成派送并发运，只回查单据，不重复发送退役安排和发车命令。
     const current = await request('GET', `${BASE}/dispatches/${encodeURIComponent(arranged.dispatchNo)}`)
-    check('New whole is loaded and fully arranged before actual departure', current.status === 'ACTIVE' && current.stage === 'AFTER_LOADING' && Number(current.counts.pickedPackageCount) === 2 && Number(current.counts.shippedPackageCount) === 0)
-    const departBody = { recordVersion: version(current.recordVersion), idempotencyKey: key(), remark: '退回2箱重新实际发车' }
-    const departPath = `/api/pda/v1/last-leg/dispatches/${arranged.dispatchNo}/depart`
-    const departed = await request('POST', departPath, departBody, input.pickerToken)
-    check('New DEPART ships exactly two returned boxes', departed.dispatchNo === arranged.dispatchNo && departed.action === 'DEPART' && departed.status === 'ACTIVE'
-      && departed.stage === 'DELIVERING' && departed.result?.departedAt && Number(departed.result.shippedPackages) === 2
-      && departed.result.deliveries?.length === 1 && departed.result.deliveries[0].deliveryNo === transfer.deliveries[0].deliveryNo)
-    const departedAgain = await request('POST', departPath, departBody, input.pickerToken)
-    const facts = value => { const result = copy(value); delete result.replayed; return JSON.stringify(result) }
-    check('Departure replay does not duplicate shipping', departedAgain.replayed === true && facts(departedAgain) === facts(departed))
+    const transfer = current.documents
+    check('Redispatch produces a new single destination delivery', transfer?.deliveries?.length === 1 && !input.deliveryNos.includes(transfer.deliveries[0].deliveryNo)
+      && id(transfer.deliveries[0].customerId) === customerId && Number(transfer.deliveries[0].packageCount) === 2
+      && transfer.deliveries[0].status === 'DELIVERING' && transfer.outbounds?.length === 1
+      && transfer.outbounds[0].status === 'OUTBOUNDED' && transfer.outbounds[0].outboundNo === transfer.deliveries[0].outboundNo
+      && id(transfer.outbounds[0].customerId) === customerId)
+    const departed = newTrip.loadingCommand.result
+    check('Loading completion ships exactly two returned boxes', current.status === 'ACTIVE' && current.stage === 'DELIVERING'
+      && Number(current.counts.pickedPackageCount) === 2 && Number(current.counts.shippedPackageCount) === 2
+      && departed.action === 'LOADING_COMPLETE' && departed.dispatchNo === arranged.dispatchNo
+      && version(current.recordVersion) === version(departed.recordVersion))
     const shipped = await inventory('RETURN_DEPARTED'); check('Returned stock ships once and retains the original immutable stock-in ledger', shipped.available === 0 && shipped.picked === 0 && JSON.stringify(shipped.ledger) === JSON.stringify(stockIn.ledger))
     const newDelivery = await delivery(transfer.deliveries[0].deliveryNo)
     proof.preSignatureGate = { status: 'WAITING', deliveryNo: newDelivery.order.deliveryNo, newTripNo: newTrip.tripNo,

scripts/admin-test-env-modules/fleet-trip-fulfillment-contract.test.mjs

@@ -145,7 +145,7 @@ function server(fault = '') {
         assert.equal(body.recordVersion, detail.recordVersion); assert.equal(body.manifestHash, 'REAL-MANIFEST')
         assert.deepEqual(body.measurements, [{ warehousePalletId: PALLET, palletSpaces: 2, weightKg: '187.25', volumeCbm: '1.375', deliveryIndex: 1 }])
         loadingActors.set(body.idempotencyKey, token ? 'PDA' : 'PLATFORM')
-        detail.stage = 'AFTER_LOADING'; bump(); return remember('LOADING_COMPLETE', body, { confirmedLoad: { manifestHash: body.manifestHash, pallets: body.measurements } })
+        detail.stage = 'DELIVERING'; bump(); return remember('LOADING_COMPLETE', body, { confirmedLoad: { manifestHash: body.manifestHash, pallets: body.measurements } })
       }
       if (method === 'GET' && path.startsWith(`${F}/resource-occupancy?`)) {
         const query = new URL(`https://unused.test${path}`).searchParams, kind = query.get('kind')
@@ -304,7 +304,7 @@ test('PDA original-actor replay restores loading while another platform actor is
   const beforeCount = s.detail.counts.pickedPackageCount
   const v = await confirmFleetLoading(s.context, 'native', proof, 'PDA-IN-MEMORY-ONLY', receipt())
   assert.equal(v, '9007199254741004'); assert.equal(proof.reassignment.status, 'REJECTED_WITHOUT_MUTATION')
-  assert.equal(s.detail.counts.pickedPackageCount, beforeCount); assert.equal(s.detail.stage, 'AFTER_LOADING')
+  assert.equal(s.detail.counts.pickedPackageCount, beforeCount); assert.equal(s.detail.stage, 'DELIVERING')
   const writes = s.calls.filter(c => c.path.endsWith('/loading-complete'))
   assert.equal(writes.length, 3)
   assert.deepEqual(writes.map(c => c.body), [writes[0].body, writes[0].body, writes[0].body])
@@ -327,7 +327,7 @@ test('platform positive loading remains executable in its own scenario with orig
   assert.deepEqual(writes.map(c => [c.path, c.actor]), [[`${D}/loading-complete`, 'PLATFORM'], [`${D}/loading-complete`, 'PLATFORM']])
   assert.equal(proof.loadingCommand.replay.replayed, true)
   assert.equal(proof.loadingCommand.platformPositiveLoading, 'VERIFIED'); assert.equal(proof.loadingCommand.platformRejection, undefined)
-  assert.equal(s.detail.stage, 'AFTER_LOADING')
+  assert.equal(s.detail.stage, 'DELIVERING')
 })
 
 for (const fault of ['cross-actor-accepted', 'cross-actor-generic-forbidden', 'cross-actor-mutates-main', 'cross-actor-mutates-items', 'cross-actor-mutates-loading', 'cross-actor-unknown']) test(`cross-actor loading cannot claim isolation: ${fault}`, async () => {

scripts/admin-test-env-modules/fleet-trip-fulfillment.mjs

@@ -219,7 +219,7 @@ async function verifyPreDepartureReassignment(context, module, proof) {
   state.status = 'REJECTED_WITHOUT_MUTATION'
 }
 
-export async function confirmFleetLoading(context, module, proof, pdaToken, actualMeasurements) {
+export async function confirmFleetLoading(context, module, proof, pdaToken, actualMeasurements, beforeComplete) {
   if (!proof?.dispatchNo || !proof.tripNo) throw new Error('缺少本轮原生排车及唯一资源记录证明')
   if (proof.loadingCommand) throw new Error('本轮装车命令已开始；保留原请求排查，不自动重试')
   const path = `${DISPATCH}/${encodeURIComponent(proof.dispatchNo)}`, pdaPath = `${PDA}/${encodeURIComponent(proof.dispatchNo)}`
@@ -233,8 +233,9 @@ export async function confirmFleetLoading(context, module, proof, pdaToken, actu
   proof.loadingPreview = preview; proof.loadingMeasurementReceipt = actualMeasurements
   proof.loadingCommand = { path: `${pdaToken ? pdaPath : path}/loading-complete`, body: { recordVersion: preview.recordVersion,
     idempotencyKey: key(proof, 'LOADING_COMPLETE'), manifestHash: preview.manifestHash, measurements, remark: 'TEST本轮实际读取测量证据，不使用计费重量或固定值' } }
+  if (beforeComplete) await beforeComplete(proof.loadingCommand)
   const confirmed = await command(context, module, 'POST', proof.loadingCommand.path, proof.loadingCommand.body, '原生显式装车完成', pdaToken)
-  check(context, module, '显式装车才进入装车后', confirmed.dispatchNo === proof.dispatchNo && confirmed.status === 'ACTIVE' && confirmed.stage === 'AFTER_LOADING'
+  check(context, module, '装车完成即进入派送中', confirmed.dispatchNo === proof.dispatchNo && confirmed.status === 'ACTIVE' && confirmed.stage === 'DELIVERING'
     && confirmed.result?.confirmedLoad?.manifestHash === preview.manifestHash && version(confirmed.recordVersion) > version(preview.recordVersion))
   const returned = confirmed.result.confirmedLoad.pallets
   check(context, module, '实载回执逐托保留原测量且不增加货量', returned?.length === measurements.length

scripts/admin-test-env-modules/inbound-measurement.mjs

@@ -244,7 +244,8 @@ export async function verifyMeasurementApprovalReplay(context, input, payload, i
     inboundHistoryCount: after.facts.inbound.statusHistory.length }
 }
 
-async function reusablePallets(context, warehouseId) {
+/** 固定造数只允许指定托盘；显式通用模式才读取其他已有托盘。缺失不自动替换。 */
+export async function reusablePallets(context, warehouseId) {
   const cacheKey = asId(warehouseId)
   const allowAnyExistingPallet = context.context?.allowAnyExistingPallet === true
   const scopedCacheKey = `${cacheKey}:${allowAnyExistingPallet ? 'any' : 'fixed'}`
@@ -268,14 +269,16 @@ async function reusablePallets(context, warehouseId) {
       }
       pallets.push({ id: asId(exact.id), code: palletCode })
     }
-    if (missingFixed.length === 0) {
+    if (pallets.length > 0) {
       reusablePalletsByWarehouse.set(scopedCacheKey, pallets)
       return pallets
     }
-    // 固定称重托盘是环境初始化样本；缺失时降级使用当前仓库已有托盘，测量与计费仍走真实接口。
+    context.assert(MODULE, '指定称重托盘池至少存在一只可复用托盘', null, false,
+      `warehouseId=${warehouseId}, missing=${missingFixed.join(',')}`, OPTIONS)
     context.addCoverageGap?.(MODULE, 'measurement-pallet-fixture', '固定称重托盘主数据缺失',
-      `warehouseId=${warehouseId}, missing=${missingFixed.join(',')}；改用当前仓库已有托盘继续`,
-      'fixture', { blocking: false })
+      `warehouseId=${warehouseId}, missing=${missingFixed.join(',')}；停止固定托盘造数`,
+      'fixture', { blocking: true })
+    return null
   }
 
   const response = await context.request('GET',