fix(dispatch): reject unmaterialized PLAN before loading source locks

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,11 +132,7 @@
 - 数据库只访问所属服务库。模块表结构位于 `<module>/src/main/resources/db/`；开发环境按最新模块基线和 `deploy/sql/头程数据库统一增量-MySQL8.sql` 收敛，不为历史开发数据新增兼容迁移。已有名称含 `migration` 的脚本仅作结构来源和追溯，部署说明见 `deploy/sql/README.md`；生产升级另按明确发布规则处理。
 - 后端同样遵守根指引中的“开发数据和上传文件可丢弃”边界：不得为现有开发库孤儿文件、旧文件归属或历史部分失败新增删除补偿接口、兼容复用、回填或清理链路；只修复当前正式上传与持久化路径，既有开发文件由人工重新上传。
 - 通用配置在 `config/nacos/test/`；服务日志、上传文件、`target/`、`reports/` 不属于源码。
-- 后端本地验证默认使用 `scripts/backend-check.ps1`，必须显式指定 `-Modules`，不传模块直接拒绝；命令及参数见 `scripts/README.md` 的“后端分层检查”。入口自动经 `local-check.ps1` 限流，`-DryRun` 只检查选择范围，不代表测试通过。
+- Java 签名变更的最低编译门禁是 `mvn -pl <module> -am test-compile`，它必须在部署前完成并覆盖测试源码；有行为变化时继续运行 `mvn -pl <module> -am test`。`-DskipTests` 可跳过测试执行但仍须保留测试编译，`-Dmaven.test.skip=true` 会跳过测试编译，不得作为签名变更的交付验证。全量验证仍使用 `mvn -DskipTests validate`、`mvn test`；不要在本地启动 Java/Nacos/数据库，除非用户明确要求。
-- 局部逻辑使用 `-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,8 +161,7 @@ pipeline {
         choice(name: 'ENVIRONMENT', choices: environmentChoicesForJob(env.JOB_BASE_NAME), description: '部署环境')
         booleanParam(name: 'DEPLOY', defaultValue: false, description: '各服务构建成功后是否独立部署')
         booleanParam(name: 'SKIP_TESTS', defaultValue: false, description: '是否跳过测试执行（仍编译测试源码）')
-        // 地址由当前 Job 配置提供；参数声明刷新时保留已配置值，不将环境地址写入源码。
+        string(name: 'IMAGE_REPOSITORY', defaultValue: '', description: '必须填写已核实的共享镜像仓库地址 host[:port]/owner/image')
-        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,8 +49,7 @@ pipeline {
         booleanParam(name: 'ALLOW_SAME_CONTRACT_ROLLBACK', defaultValue: false, description: '仅确认相同协议与Schema时允许回滚；架构切换保持关闭')
         booleanParam(name: 'DEPLOY', defaultValue: false, description: '构建成功后是否部署本服务')
         booleanParam(name: 'SKIP_TESTS', defaultValue: false, description: '是否跳过测试')
-        // 独立构建沿用本 Job 配置，总控调度时保留其明确传入的地址。
+        string(name: 'IMAGE_REPOSITORY', defaultValue: '', description: '必须填写已核实的共享镜像仓库基础路径，不包含服务名和标签')
-        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,16 +23,11 @@
 ## 本地构建
 
 ```powershell
-# 日常按受影响模块检查；跨服务变更显式列入消费者。
+mvn -DskipTests validate
-.\scripts\backend-check.ps1 -Modules order -Mode Compile
+node --test scripts/java-topology-contract.test.mjs
-.\scripts\backend-check.ps1 -Modules order
+mvn test
-# 根构建/拓扑变化等全量触发条件见 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`。

common-core/src/main/java/com/baiyue/common/core/number/DailyDocumentNumber.java

@@ -1,44 +0,0 @@
-package com.baiyue.common.core.number;
-
-import com.baiyue.common.core.api.ResultCode;
-import com.baiyue.common.core.exception.BizException;
-import java.time.Clock;
-import java.time.LocalDate;
-import java.time.ZoneId;
-import java.time.format.DateTimeFormatter;
-import java.util.Locale;
-import java.util.function.ToLongFunction;
-
-/** 统一业务单号格式；序列仍由各服务自己的 Repository/Mapper 分配。 */
-public final class DailyDocumentNumber {
-    public static final ZoneId BUSINESS_ZONE = ZoneId.of("Asia/Shanghai");
-
-    /** 工具类不允许实例化。 */
-    private DailyDocumentNumber() {}
-
-    /** 先固定北京时间业务日，再使用前缀和日期分配跨客户、跨仓库日流水。 */
-    public static String next(String prefix, Clock clock, ToLongFunction<String> sequences) {
-        requirePrefix(prefix);
-        LocalDate date = LocalDate.now(clock.withZone(BUSINESS_ZONE));
-        String dateText = date.format(DateTimeFormatter.BASIC_ISO_DATE);
-        long value = sequences.applyAsLong(prefix + ":" + dateText);
-        return format(prefix, date, value);
-    }
-
-    /** 严格四位流水，不允许溢出后产生五位号码或退回随机编号。 */
-    public static String format(String prefix, LocalDate date, long value) {
-        requirePrefix(prefix);
-        if (value < 1 || value > 9999) {
-            throw new BizException(ResultCode.CONFLICT, "当日" + prefix + "单据四位流水号已用尽或分配失败");
-        }
-        return prefix + date.format(DateTimeFormatter.BASIC_ISO_DATE)
-            + String.format(Locale.ROOT, "%04d", value);
-    }
-
-    /** 业务类型只能使用两至四位大写字母。 */
-    private static void requirePrefix(String prefix) {
-        if (prefix == null || !prefix.matches("[A-Z]{2,4}")) {
-            throw new IllegalArgumentException("业务单据前缀必须为2至4位大写字母");
-        }
-    }
-}

common-core/src/test/java/com/baiyue/common/core/number/DailyDocumentNumberTest.java

@@ -1,45 +0,0 @@
-package com.baiyue.common.core.number;
-
-import com.baiyue.common.core.exception.BizException;
-import org.junit.jupiter.api.Test;
-import java.time.*;
-import java.util.HashMap;
-import java.util.Locale;
-import java.util.concurrent.atomic.AtomicReference;
-import static org.assertj.core.api.Assertions.*;
-
-class DailyDocumentNumberTest {
-    /** 午夜前后取号使用北京时间日期，与主机和 Clock 的时区无关。 */
-    @Test void rollsAtShanghaiMidnightAndKeepsPrefixesIndependent() {
-        var values = new HashMap<String, Long>();
-        java.util.function.ToLongFunction<String> allocate = key -> values.merge(key, 1L, Long::sum);
-        var before = Clock.fixed(Instant.parse("2026-10-19T15:59:59Z"), ZoneOffset.UTC);
-        var after = Clock.fixed(Instant.parse("2026-10-19T16:00:00Z"), ZoneId.of("America/Los_Angeles"));
-        assertThat(DailyDocumentNumber.next("FL", before, allocate)).isEqualTo("FL202610190001");
-        assertThat(DailyDocumentNumber.next("FL", after, allocate)).isEqualTo("FL202610200001");
-        assertThat(DailyDocumentNumber.next("FL", after, allocate)).isEqualTo("FL202610200002");
-        assertThat(DailyDocumentNumber.next("ZGRK", after, allocate)).isEqualTo("ZGRK202610200001");
-    }
-
-    /** 字符集和流水上限为硬边界，未知输入不能生成近似号码。 */
-    @Test void rejectsInvalidPrefixAndSequence() {
-        for (String prefix : new String[]{"F", "ABCDE", "Fl", "F1", " FL", ""}) {
-            assertThatThrownBy(() -> DailyDocumentNumber.format(prefix, LocalDate.of(2026, 10, 20), 1))
-                .isInstanceOf(IllegalArgumentException.class);
-        }
-        for (long value : new long[]{-1, 0, 10000}) {
-            assertThatThrownBy(() -> DailyDocumentNumber.format("FL", LocalDate.of(2026, 10, 20), value))
-                .isInstanceOf(BizException.class);
-        }
-        assertThat(DailyDocumentNumber.format("FL", LocalDate.of(2026, 10, 20), 9999)).isEqualTo("FL202610209999");
-    }
-
-    /** 全局 Locale 不得让数字变为本地化字符。 */
-    @Test void alwaysUsesAsciiDigits() {
-        Locale old = Locale.getDefault();
-        try {
-            Locale.setDefault(Locale.forLanguageTag("ar"));
-            assertThat(DailyDocumentNumber.format("FL", LocalDate.of(2026, 10, 20), 1)).isEqualTo("FL202610200001");
-        } finally { Locale.setDefault(old); }
-    }
-}

common-web/src/main/java/com/baiyue/common/web/GlobalExceptionHandler.java

@@ -40,14 +40,8 @@ public class GlobalExceptionHandler {
     @Autowired(required = false)
     private MeterRegistry meterRegistry;
 
-    /** 系统类业务失败必须记录链路和异常，普通业务校验仍只返回统一响应。 */
     @ExceptionHandler(BizException.class)
     public ResponseEntity<ApiResponse<Void>> handleBusiness(BizException exception, HttpServletRequest request) {
-        if (exception.getResultCode().httpStatus().is5xxServerError()) {
-            log.error("系统业务请求失败 method={} path={} code={} requestId={} traceId={}",
-                    request.getMethod(), request.getRequestURI(), exception.getResultCode().code(),
-                    CorrelationContext.requestId(request), CorrelationContext.traceId(request), exception);
-        }
         return failure(exception.getResultCode(), exception.getMessage(), request);
     }
 

common-web/src/test/java/com/baiyue/common/web/GlobalExceptionHandlerTest.java

@@ -5,9 +5,6 @@ import com.baiyue.common.core.exception.BizException;
 import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.springframework.boot.test.system.CapturedOutput;
-import org.springframework.boot.test.system.OutputCaptureExtension;
 import org.springframework.mock.web.MockHttpServletRequest;
 import org.springframework.core.MethodParameter;
 import org.springframework.validation.BeanPropertyBindingResult;
@@ -42,37 +39,6 @@ class GlobalExceptionHandlerTest {
         assertThat(response.getBody().requestId()).isEqualTo("r1");
     }
 
-    /** 系统类业务失败留下路径、关联标识和根因，但不打印请求参数或令牌。 */
-    @Test
-    @ExtendWith(OutputCaptureExtension.class)
-    void systemBusinessFailureLogsCorrelationAndCause(CapturedOutput output) {
-        MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/platform/v1/orders/status-counts");
-        request.setAttribute(CorrelationContext.REQUEST_ID, "status-count-request");
-        request.setAttribute(CorrelationContext.TRACE_ID, "status-count-trace");
-        request.setQueryString("keyword=private-query");
-        request.addHeader("X-Internal-Service-Token", "private-service-token");
-        BizException exception = new BizException(ResultCode.SERVICE_UNAVAILABLE, "统计暂不可用");
-        exception.initCause(new IllegalStateException("缺少尾程来源"));
-
-        var response = handler.handleBusiness(exception, request);
-
-        assertThat(response.getStatusCode().value()).isEqualTo(200);
-        assertThat(response.getBody().code()).isEqualTo("S0503");
-        assertThat(response.getBody().message()).isEqualTo("统计暂不可用");
-        assertThat(output.getOut()).contains("ERROR", "GET", "/api/platform/v1/orders/status-counts",
-                "S0503", "status-count-request", "status-count-trace", "缺少尾程来源")
-                .doesNotContain("private-query", "private-service-token");
-    }
-
-    /** 预期的业务冲突不应升级为系统错误日志。 */
-    @Test
-    @ExtendWith(OutputCaptureExtension.class)
-    void normalBusinessFailureDoesNotLogSystemError(CapturedOutput output) {
-        handler.handleBusiness(new BizException(ResultCode.CONFLICT, "normal-business-conflict"),
-                new MockHttpServletRequest());
-        assertThat(output.getAll()).doesNotContain("系统业务请求失败", "normal-business-conflict");
-    }
-
     @Test
     void invalidQueryParameterTypeMapsToBadRequest() throws Exception {
         MockHttpServletRequest request = new MockHttpServletRequest();

config/nacos/test/finance-service.yml

@@ -5,8 +5,7 @@ spring:
     password: ${FINANCE_DB_PASSWORD}
     driver-class-name: com.mysql.cj.jdbc.Driver
 baiyue.clients.warehouse.url: ${WAREHOUSE_SERVICE_URL:}
-# TEST 流程验收复用 Client 的示例图片，图片标注不可付款且不含真实收款信息。
+baiyue.finance.recharge.qr-code-url: ${FINANCE_RECHARGE_QR_CODE_URL:}
-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/README.md

@@ -1,7 +1,5 @@
 # 单测试环境数据库空库初始化
 
-仓储转运到仓取货、本土卡车接入现有排车的**可重复执行汇总SQL**为 `lastleg-dispatch-transport-tasks.sql`，文件内固定 `USE baiyue_lastleg`，对已存在字段、表安全跳过。新增 `ll_dispatch_order.task_type` 字段、`ll_dispatch_truck_task`、`ll_dispatch_transport_create`、`ll_dispatch_transport_command` 三张表，并确保既有正式排车单号日流水表存在；不回填或删除业务数据。前置是目标库已具备现有整车排车主表、FleetTrip、取货任务及本土卡车原单结构。按序先执行此 SQL，再配套发布 Lastleg 与 Admin；取消释放有效原单关联、完成保留关联。`migrations/overseas/baiyue_lastleg/V32__dispatch_transport_tasks.sql` 是迁移系统中的新增结构记录。本次仅在已授权本机执行并验收，不代表远端已部署。
-
 排车单号使用`PCyyyyMMdd0001`，日期取`Asia/Shanghai`，全平台跨客户/仓库共用独立日流水。`ll_dispatch_daily_sequence`同步Lastleg源基线与海外空库基线；已有结构的定向新增入口为`lastleg-dispatch-daily-sequence.sql`，只建序列表，不改已有业务号、不回填历史、不重放空库初始化。源码和DDL须配套发布；文件存在不表示已执行或部署。流水在独立短事务分配，回滚或取消不复用，四位范围每日0001至9999，准确单量以主单统计为准。
 
 自有业务运营视图的结构在 Lastleg 源基线及海外统一空库基线新增四张附加表：`ll_fleet_owned_business_ownership/record/command/history`，分别保存原排车装车完成时的车辆归属证据、运营信息、命令与不可变历史；不新增排车主单或第二套运输状态。权限为 IAM `lastleg-permissions.sql` 中的自有业务 list/edit/upload，并同步国内统一空库基线。业务唯一规则见工作区 `docs/海外仓业务/自有业务首版开发契约.md`。本次仅准备源码基线，无 SQL 执行、存量回填或部署；旧已装车 TEST 数据不倒推历史归属，匹配版本按新原生样本验收。
@@ -60,8 +58,8 @@ V13 收货覆盖由 `lastleg-service/src/main/resources/db/appointment-receiving
 
 | 区域 | 完整入口 | 服务 schema | 表数 |
 |---|---|---|---:|
-| 国内 | `头程数据库统一增量-MySQL8.sql` | `baiyue_auth`、`baiyue_iam`、`baiyue_order`、`baiyue_warehouse`、`baiyue_firstleg`、`baiyue_file`、`baiyue_audit`、`baiyue_finance` | 229 |
+| 国内 | `头程数据库统一增量-MySQL8.sql` | `baiyue_auth`、`baiyue_iam`、`baiyue_order`、`baiyue_warehouse`、`baiyue_firstleg`、`baiyue_file`、`baiyue_audit`、`baiyue_finance` | 227 |
-| 海外 | `海外区域统一增量-MySQL8.sql` | `baiyue_lastleg`、`baiyue_lastlag_warehouse` | 234 |
+| 海外 | `海外区域统一增量-MySQL8.sql` | `baiyue_lastleg`、`baiyue_lastlag_warehouse` | 228 |
 
 
 - 所有服务位于同一测试环境；两份文件只分组组织服务 schema，不代表两个部署区域。`baiyue_lastlag_warehouse` 保留当前正式的 `lastlag` 拼写。
@@ -84,7 +82,7 @@ V13 收货覆盖由 `lastleg-service/src/main/resources/db/appointment-receiving
 5. DDL 隐式提交，不可整体回滚。失败后停止并保留错误；经另行授权准备空库后从头执行，不针对半初始化库追加迁移或从失败行续跑。
 6. Firstleg 测量项与拆分项互为外键：建空表期间暂设会话 `foreign_key_checks=0`，随后立即恢复 `1`，再插入种子。失败时关闭连接。两边外键完整保留在 CREATE TABLE 内。
 
-成功时只在最末输出一行 `initialization_status=PASS`，并带 `region=CN/OVERSEAS`、`initialized_tables=229/234`。必须同时确认客户端退出码 0；忽略错误后出现的 PASS 不算成功。
+成功时只在最末输出一行 `initialization_status=PASS`，并带 `region=CN/OVERSEAS`、`initialized_tables=227/228`。必须同时确认客户端退出码 0；忽略错误后出现的 PASS 不算成功。
 
 ## 平台管理员密码
 
@@ -180,7 +178,3 @@ node --test scripts/admin-test-env-modules/initialization-baseline-contract.test
 货物废弃通用库存与散箱字段迁移：`migrations/overseas/baiyue_lastleg/V25__cargo_discard_generic_inventory.sql`。新增库存仓位关联及箱唛快照，须先迁移再部署 Lastleg；不回填历史废弃单。
 
 2026-10-16 拉取合并配套结构清单及执行边界见 [数据库变更汇总](20261016-数据库变更汇总.md)，已有尾程库使用 `migrations/overseas/baiyue_lastleg/V28__merge_transfer_measurement_and_compact_numbers.sql`；空库初始化海外表数同步为 209。该增量可重复执行，尚未执行到任何实际数据库。
-
-## 统一业务单号
-
-编号规则见 `../../../docs/业务单据编号契约.md`。Order、Warehouse、Lastleg 空库基线新增各自的 `ord_document_sequence`、`wh_document_sequence`、`ll_document_sequence`；Firstleg 与 Finance 复用本库编号表。Lastleg 空库基线移除无生产调用的客户日序列、逻辑秒时钟及旧尾程日序列表，保留排车日序列。采购费用新增可空 `idempotency_key` 及订单/用途/请求键唯一约束，用于退款重放，业务号统一使用 PF。此处只准备基线，不执行 SQL、回填或删除测试存量。

deploy/sql/lastleg-dispatch-transport-tasks.sql

@@ -1,108 +0,0 @@
--- MySQL 8 可重复执行增量：仓储转运到仓取货与本土卡车接入现有排车。
--- 目标数据库固定为 baiyue_lastleg；仅新增运输类型、原单关联及请求账本，不回填或删除业务数据。
--- 前置：已完成 Lastleg 现有整车排车结构升级；如部署为缺少每日流水表的旧库，也创建正式排车流水表。
-USE baiyue_lastleg;
-
-SET @dispatch_transport_column_ddl = IF(
-  EXISTS (
-    SELECT 1 FROM information_schema.columns
-    WHERE table_schema = DATABASE() AND table_name = 'll_dispatch_order' AND column_name = 'task_type'
-  ),
-  'SELECT 1',
-  'ALTER TABLE ll_dispatch_order ADD COLUMN task_type VARCHAR(32) NOT NULL DEFAULT ''DELIVERY'' COMMENT ''任务类型：仓库派送、到仓取货、本土卡车'' AFTER dispatch_no'
-);
-PREPARE dispatch_transport_column_stmt FROM @dispatch_transport_column_ddl;
-EXECUTE dispatch_transport_column_stmt;
-DEALLOCATE PREPARE dispatch_transport_column_stmt;
-
--- 旧库兼容：整车主单跨客户，原来单客户排车头字段不再要求填写。
--- 如目标库已删除旧字段则跳过；已有客户值保留，不置空、不修改。
-SET @dispatch_transport_legacy_ddl = IF(
-  EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'll_dispatch_order' AND column_name = 'customer_id' AND is_nullable = 'NO'),
-  'ALTER TABLE ll_dispatch_order MODIFY COLUMN customer_id VARCHAR(128) NULL COMMENT ''旧客户排车归属，整车主单不使用''',
-  'SELECT 1'
-);
-PREPARE dispatch_transport_legacy_stmt FROM @dispatch_transport_legacy_ddl;
-EXECUTE dispatch_transport_legacy_stmt;
-DEALLOCATE PREPARE dispatch_transport_legacy_stmt;
-
--- 旧本土卡车结构兼容：新单沿用已有的起终点联系人及pickup_at/delivery_at字段。
--- 旧单字段保留原值，仅放宽空值约束，避免新单被已弃用字段阻断。
-SET @dispatch_transport_legacy_ddl = IF(
-  EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'll_us_truck_order' AND column_name = 'contact_name' AND is_nullable = 'NO'),
-  'ALTER TABLE ll_us_truck_order MODIFY COLUMN contact_name VARCHAR(128) NULL COMMENT ''旧本土卡车联系人，新单使用起终点联系人''',
-  'SELECT 1'
-);
-PREPARE dispatch_transport_legacy_stmt FROM @dispatch_transport_legacy_ddl;
-EXECUTE dispatch_transport_legacy_stmt;
-DEALLOCATE PREPARE dispatch_transport_legacy_stmt;
-
-SET @dispatch_transport_legacy_ddl = IF(
-  EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'll_us_truck_order' AND column_name = 'contact_info' AND is_nullable = 'NO'),
-  'ALTER TABLE ll_us_truck_order MODIFY COLUMN contact_info VARCHAR(128) NULL COMMENT ''旧本土卡车联系方式，新单使用起终点联系方式''',
-  'SELECT 1'
-);
-PREPARE dispatch_transport_legacy_stmt FROM @dispatch_transport_legacy_ddl;
-EXECUTE dispatch_transport_legacy_stmt;
-DEALLOCATE PREPARE dispatch_transport_legacy_stmt;
-
-SET @dispatch_transport_legacy_ddl = IF(
-  EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'll_us_truck_order' AND column_name = 'requested_date' AND is_nullable = 'NO'),
-  'ALTER TABLE ll_us_truck_order MODIFY COLUMN requested_date DATE NULL COMMENT ''旧本土卡车请求日期，新单使用取货和送货时间''',
-  'SELECT 1'
-);
-PREPARE dispatch_transport_legacy_stmt FROM @dispatch_transport_legacy_ddl;
-EXECUTE dispatch_transport_legacy_stmt;
-DEALLOCATE PREPARE dispatch_transport_legacy_stmt;
-
-CREATE TABLE IF NOT EXISTS ll_dispatch_daily_sequence (
-  business_date DATE NOT NULL COMMENT '排车编号业务日期（Asia/Shanghai）',
-  last_sequence INT NOT NULL COMMENT '当日已分配排车流水号，范围0001至9999',
-  PRIMARY KEY (business_date)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车单号每日独立原子流水';
-
-CREATE TABLE IF NOT EXISTS ll_dispatch_truck_task (
-  dispatch_no VARCHAR(64) NOT NULL COMMENT '排车业务号',
-  trip_no VARCHAR(64) NOT NULL COMMENT '本次运输资源记录号',
-  customer_id VARCHAR(128) NOT NULL COMMENT '本土卡车原单客户标识',
-  order_no VARCHAR(64) NOT NULL COMMENT '本土卡车原单业务号',
-  active_order VARCHAR(193) NULL COMMENT '有效原单唯一键；取消置空，完成保留',
-  PRIMARY KEY (dispatch_no),
-  UNIQUE KEY uk_transport_trip (trip_no),
-  UNIQUE KEY uk_transport_source (active_order),
-  KEY idx_transport_order (customer_id, order_no)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车与本土卡车原单关联';
-
-CREATE TABLE IF NOT EXISTS ll_dispatch_transport_create (
-  trip_no VARCHAR(64) NOT NULL COMMENT '本次运输资源记录号',
-  request_hash CHAR(64) NOT NULL COMMENT '首次安排请求摘要',
-  PRIMARY KEY (trip_no)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='本土卡车排车创建请求账本';
-
-CREATE TABLE IF NOT EXISTS ll_dispatch_transport_command (
-  dispatch_no VARCHAR(64) NOT NULL COMMENT '排车业务号',
-  request_key VARCHAR(128) NOT NULL COMMENT '客户端幂等请求键',
-  request_hash CHAR(64) NOT NULL COMMENT '执行命令请求摘要',
-  evidence_json JSON NULL COMMENT '已确认运输完成凭证标识列表',
-  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '业务命令提交时间',
-  PRIMARY KEY (dispatch_no, request_key)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车运输执行命令与凭证账本';
-
--- 当前承运占用查询还依赖散板来源标识（与V33一致）；仅补结构，不创建散板业务记录。
-SET @dispatch_transport_pool_ddl = IF(
-  EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'll_fleet_external_booking' AND column_name = 'source_looseboard_order_id'),
-  'SELECT 1',
-  'ALTER TABLE ll_fleet_external_booking ADD COLUMN source_looseboard_order_id BIGINT NULL COMMENT ''客户原始散板商业单ID，取消后保留来源'''
-);
-PREPARE dispatch_transport_pool_stmt FROM @dispatch_transport_pool_ddl;
-EXECUTE dispatch_transport_pool_stmt;
-DEALLOCATE PREPARE dispatch_transport_pool_stmt;
-
-SET @dispatch_transport_pool_ddl = IF(
-  EXISTS (SELECT 1 FROM information_schema.statistics WHERE table_schema = DATABASE() AND table_name = 'll_fleet_external_booking' AND index_name = 'idx_booking_looseboard_source'),
-  'SELECT 1',
-  'ALTER TABLE ll_fleet_external_booking ADD KEY idx_booking_looseboard_source (customer_id, source_looseboard_order_id, status)'
-);
-PREPARE dispatch_transport_pool_stmt FROM @dispatch_transport_pool_ddl;
-EXECUTE dispatch_transport_pool_stmt;
-DEALLOCATE PREPARE dispatch_transport_pool_stmt;

deploy/sql/migrations/overseas/baiyue_lastleg/V32__dispatch_transport_tasks.sql

@@ -1,23 +0,0 @@
--- 仓储取货与本土卡车接入现有排车；保留旧排车用途默认值。
-ALTER TABLE ll_dispatch_order ADD COLUMN task_type VARCHAR(32) NOT NULL DEFAULT 'DELIVERY' COMMENT '任务类型：仓库派送、到仓取货、本土卡车' AFTER dispatch_no;
-CREATE TABLE ll_dispatch_truck_task (
-  dispatch_no VARCHAR(64) NOT NULL COMMENT '排车业务号',
-  trip_no VARCHAR(64) NOT NULL COMMENT '本次运输资源记录号',
-  customer_id VARCHAR(128) NOT NULL COMMENT '本土卡车原单客户标识',
-  order_no VARCHAR(64) NOT NULL COMMENT '本土卡车原单业务号',
-  active_order VARCHAR(193) NULL COMMENT '有效原单唯一键；取消置空，完成保留',
-  PRIMARY KEY(dispatch_no), UNIQUE KEY uk_transport_trip(trip_no), UNIQUE KEY uk_transport_source(active_order),
-  KEY idx_transport_order(customer_id,order_no)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车与本土卡车原单关联';
-CREATE TABLE ll_dispatch_transport_create (
-  trip_no VARCHAR(64) NOT NULL PRIMARY KEY COMMENT '本次运输资源记录号',
-  request_hash CHAR(64) NOT NULL COMMENT '首次安排请求摘要'
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='本土卡车排车创建请求账本';
-CREATE TABLE ll_dispatch_transport_command (
-  dispatch_no VARCHAR(64) NOT NULL COMMENT '排车业务号',
-  request_key VARCHAR(128) NOT NULL COMMENT '客户端幂等请求键',
-  request_hash CHAR(64) NOT NULL COMMENT '执行命令请求摘要',
-  evidence_json JSON NULL COMMENT '已确认运输完成凭证标识列表',
-  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '业务命令提交时间',
-  PRIMARY KEY(dispatch_no,request_key)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车运输执行命令与凭证账本';

deploy/sql/migrations/overseas/baiyue_lastleg/V33__looseboard_pool_demand.sql

@@ -1,13 +0,0 @@
--- Region: OVERSEAS
--- Schema: baiyue_lastleg
--- Purpose: 客户散板原单接入拼车需求池，未确认登记不占位。
--- Preconditions: MySQL 8；已选择 baiyue_lastleg；预订表已存在。
--- Postconditions: 预订原单来源列及客户来源索引存在，不回填历史来源。
-SET @looseboard_demand_ddl = IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_fleet_external_booking' AND column_name='source_looseboard_order_id'), 'SELECT 1', 'ALTER TABLE ll_fleet_external_booking ADD COLUMN source_looseboard_order_id BIGINT NULL COMMENT ''客户原始散板商业单ID，取消后保留来源''');
-PREPARE looseboard_demand_stmt FROM @looseboard_demand_ddl;
-EXECUTE looseboard_demand_stmt;
-DEALLOCATE PREPARE looseboard_demand_stmt;
-SET @looseboard_demand_ddl = IF(EXISTS (SELECT 1 FROM information_schema.statistics WHERE table_schema=DATABASE() AND table_name='ll_fleet_external_booking' AND index_name='idx_booking_looseboard_source'), 'SELECT 1', 'ALTER TABLE ll_fleet_external_booking ADD KEY idx_booking_looseboard_source (customer_id,source_looseboard_order_id,status)');
-PREPARE looseboard_demand_stmt FROM @looseboard_demand_ddl;
-EXECUTE looseboard_demand_stmt;
-DEALLOCATE PREPARE looseboard_demand_stmt;

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

@@ -1981,11 +1981,11 @@ CREATE TABLE fl_customs_clearance_result (
 ) ENGINE=InnoDB COMMENT='正式申报后的海关结果不可变事实';
 
 CREATE TABLE fl_document_sequence (
-  sequence_key varchar(32) NOT NULL COMMENT '单据序列键；日序列如LP:20260818，柜次长期序列固定为CABINET',
+  sequence_key varchar(32) NOT NULL COMMENT '单据序列键；日序列如CB:20260818，柜次长期序列固定为CABINET',
   current_value int unsigned NOT NULL COMMENT '该类型当日已分配的最大序号',
   PRIMARY KEY (sequence_key),
   CONSTRAINT chk_fl_document_sequence_value CHECK ((current_value > 0))
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='头程业务编号序列；普通单据按日，柜次全局连续，实物标签独立保留';
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='头程履约业务单号日序列；生成YYMMDD加四位当日序号';
 
 CREATE TABLE fl_fee_item (
   id bigint unsigned NOT NULL COMMENT '费用项目ID',
@@ -4437,6 +4437,20 @@ CREATE TABLE fl_inbound_split_item (
 
 SET SESSION foreign_key_checks = 1;
 
+-- 客户独立确认计费重，不回填既有费用确认。
+CREATE TABLE fl_chargeable_weight_confirmation (
+ id BIGINT NOT NULL COMMENT '确认记录ID',
+ tenant_id BIGINT NOT NULL COMMENT '客户隔离ID',
+ inbound_id BIGINT NOT NULL COMMENT '独立来源入仓单ID',
+ operator_id BIGINT NOT NULL COMMENT '确认客户成员ID',
+ command_key VARCHAR(128) NOT NULL COMMENT '成员确认幂等键',
+ fingerprint CHAR(64) NOT NULL COMMENT '计费重及测量轮次摘要',
+ chargeable_weight_kg DECIMAL(18,4) NOT NULL COMMENT '客户确认计费重千克',
+ confirmed_at DATETIME(3) NOT NULL COMMENT '客户确认时间',
+ PRIMARY KEY(id), UNIQUE KEY uk_weight_confirmation_command(tenant_id,operator_id,command_key),
+ KEY idx_weight_confirmation_inbound(tenant_id,inbound_id,id)
+) ENGINE=InnoDB COMMENT='客户计费重独立确认历史';
+
 -- 服务 schema：baiyue_file
 CREATE DATABASE IF NOT EXISTS baiyue_file DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
 USE baiyue_file;
@@ -4856,7 +4870,7 @@ CREATE TABLE fin_document_sequence (
   current_value int unsigned NOT NULL COMMENT '该类型当日已分配的最大序号',
   PRIMARY KEY (sequence_key),
   CONSTRAINT chk_fin_document_sequence_value CHECK ((current_value > 0))
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='财务业务单号日序列；生成前缀加yyyyMMdd加四位当日序号';
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='Finance业务单号日序列；生成YYMMDD加四位当日序号';
 
 CREATE TABLE fin_fee_source (
   id bigint unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',
@@ -4983,7 +4997,7 @@ CREATE TABLE fin_receipt_bill (
 CREATE TABLE fin_recharge_request (
   id bigint unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',
   customer_id bigint unsigned NOT NULL COMMENT '客户ID和隔离键',
-  request_no varchar(32) NOT NULL COMMENT '充值申请业务编号RCyyyyMMdd####',
+  request_no varchar(32) NOT NULL COMMENT '充值申请业务编号RC-yyMMdd-####',
   amount decimal(20,2) NOT NULL COMMENT '申请充值金额',
   voucher_file_id bigint unsigned NOT NULL COMMENT '付款截图File ID',
   voucher_file_name varchar(255) NOT NULL COMMENT '付款截图文件名快照',
@@ -5234,7 +5248,7 @@ CREATE TABLE fin_wallet_hold (
 CREATE TABLE fin_wallet_ledger (
   id bigint unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',
   customer_id bigint unsigned NOT NULL COMMENT '客户ID和隔离键',
-  business_no varchar(32) NOT NULL COMMENT '账户变动业务编号ACyyyyMMdd####',
+  business_no varchar(32) NOT NULL COMMENT '账户变动业务编号AC-yyMMdd-####',
   change_type varchar(16) NOT NULL COMMENT '变动类型：充值、扣款、冻结、解冻、消费或授信调整',
   amount decimal(20,2) NOT NULL COMMENT '带方向变动金额，充值为正、扣款为负',
   actual_balance_after decimal(20,2) NOT NULL COMMENT '变动后实际余额',
@@ -8383,20 +8397,4 @@ INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at)
 INSERT INTO iam_permission (id, tenant_id, app_code, permission_type, parent_id, permission_code, permission_name, route_path, http_method, sort_no, status, built_in, created_at, updated_at, deleted) VALUES (5102213,0,'PLATFORM','BUTTON',5102200,'platform:firstleg:terminal-drayage:direct-unload:confirm','登记直送目的仓实际卸货',NULL,'POST',60,'ACTIVE',1,CURRENT_TIMESTAMP(3),CURRENT_TIMESTAMP(3),0);
 INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at) VALUES (4000001,5102213,0,CURRENT_TIMESTAMP(3));
 
-USE baiyue_order;
+SELECT 'PASS' AS initialization_status, 'CN' AS region, 228 AS initialized_tables;
-CREATE TABLE ord_document_sequence (
-  sequence_key VARCHAR(32) NOT NULL COMMENT '业务前缀与北京时间日期组成的全局序列键',
-  current_value BIGINT NOT NULL COMMENT '该前缀当日已分配流水，已分配号不回收',
-  PRIMARY KEY (sequence_key),
-  CONSTRAINT chk_ord_document_sequence_value CHECK (current_value > 0)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='业务单据每日独立原子流水';
-
-USE baiyue_warehouse;
-CREATE TABLE wh_document_sequence (
-  sequence_key VARCHAR(32) NOT NULL COMMENT '业务前缀与北京时间日期组成的全局序列键',
-  current_value BIGINT NOT NULL COMMENT '该前缀当日已分配流水，已分配号不回收',
-  PRIMARY KEY (sequence_key),
-  CONSTRAINT chk_wh_document_sequence_value CHECK (current_value > 0)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='业务单据每日独立原子流水';
-
-SELECT 'PASS' AS initialization_status, 'CN' AS region, 229 AS initialized_tables;

deploy/sql/排车运输接入-数据库变更汇总.md

@@ -1,21 +0,0 @@
-# 排车运输接入数据库变更汇总
-
-执行文件：[lastleg-dispatch-transport-tasks.sql](lastleg-dispatch-transport-tasks.sql)。目标为 **MySQL 8 / baiyue_lastleg**，文件内已有 `USE baiyue_lastleg`。可整份重复执行；按 information_schema 判断字段及索引，按 IF NOT EXISTS 创建表。已在本机既有业务数据环境连续执行两次通过；未在远端环境执行。
-
-| 对象 | 新增或调整 | 用途 |
-|---|---|---|
-| ll_dispatch_order.task_type | 新增 VARCHAR(32) NOT NULL DEFAULT DELIVERY | 区分仓库派送、到仓取货、本土卡车；旧单保留派送类型 |
-| ll_dispatch_truck_task | 新表；dispatch_no、trip_no、customer_id、order_no、active_order | 真实排车关联原单；运输记录唯一、有效原单唯一；取消释放有效键，完成保留 |
-| ll_dispatch_transport_create | 新表；trip_no、request_hash | 原安排请求摘要，避免重复建单及同键更换原单 |
-| ll_dispatch_transport_command | 新表；dispatch_no、request_key、request_hash、evidence_json、created_at | 执行命令幂等、已确认完成凭证持久化 |
-| ll_dispatch_daily_sequence | 既有正式日流水表，缺失时补建 | 统一 PC 日期与四位流水；不修改历史单号 |
-| ll_dispatch_order.customer_id | 仅旧库存在且为 NOT NULL 时改为允许 NULL | 兼容整车跨客户主单；保留原值，不回填或置空 |
-| ll_us_truck_order.contact_name / contact_info / requested_date | 仅旧库仍为 NOT NULL 时改为允许 NULL | 兼容现有原单起终点联系人及取送时间模型，保留历史字段和数据 |
-| ll_fleet_external_booking.source_looseboard_order_id | 缺失时补 BIGINT NULL | 当前承运占用查询依赖，等同 V33；不创建散板业务 |
-| ll_fleet_external_booking.idx_booking_looseboard_source | 缺失时补客户、原散板ID、状态联合索引 | 原单承运占用查询 |
-
-所有新增表、字段均有中文注释。SQL不创建账号、不改角色权限、不删除表或记录、不改库存及历史单号，也不回填旧任务。
-
-前置：目标库已具备当前整车排车、FleetTrip、仓储转运取货及本土卡车业务结构；本文件是本次运输接入增量，不替代这些模块的完整升级。执行完成后配套发布 Lastleg 和 Admin。迁移系统记录为 V32，承运占用依赖结构为 V33；直接交付执行时使用本份汇总 SQL 即可，不再重复手动执行两个版本文件。
-
-本机验收中发现的旧字段约束与缺少日流水表已一并纳入。业务数据由正式 Gateway HTTP 创建，结构验证未写业务SQL。

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

@@ -416,7 +416,6 @@ CREATE TABLE ll_dispatch_item (
 CREATE TABLE ll_dispatch_order (
   id BIGINT NOT NULL COMMENT '整车排车主单内部主键',
   dispatch_no VARCHAR(64) NOT NULL COMMENT '真实排车业务号',
-  task_type VARCHAR(32) NOT NULL DEFAULT 'DELIVERY' COMMENT '任务类型：仓库派送、到仓取货、本土卡车',
   trip_id BIGINT NOT NULL COMMENT '本趟唯一车辆资源记录ID',
   overseas_warehouse_id VARCHAR(128) NOT NULL COMMENT '真实起运海外仓ID',
   overseas_warehouse_code VARCHAR(128) NULL COMMENT '起运海外仓编码快照',
@@ -429,7 +428,6 @@ 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 '本趟主档或临时车辆司机的真实资源快照',
@@ -1658,6 +1656,12 @@ CREATE TABLE ll_monthly_exchange_rate_history (
   KEY idx_ll_exchange_rate_history (exchange_rate_id,created_at)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='月度汇率变更历史';
 
+CREATE TABLE IF NOT EXISTS ll_dispatch_daily_sequence (
+  business_date DATE NOT NULL COMMENT '排车编号业务日期（Asia/Shanghai）',
+  last_sequence INT NOT NULL COMMENT '当日已分配排车流水号，范围0001至9999',
+  PRIMARY KEY(business_date)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车单号每日独立原子流水';
+
 CREATE TABLE ll_order (
   id bigint NOT NULL COMMENT '雪花 ID',
   order_no varchar(32) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '尾程单号',
@@ -1861,11 +1865,11 @@ CREATE TABLE ll_order_manual_node_history (
   KEY idx_ll_order_manual_node_history (customer_id,order_id,created_at)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='尾程订单人工节点覆盖不可变历史';
 
-CREATE TABLE ll_dispatch_daily_sequence (
+CREATE TABLE ll_order_no_daily_sequence (
-  business_date DATE NOT NULL COMMENT '排车编号业务日期（Asia/Shanghai）',
+  business_date date NOT NULL COMMENT '业务日期（Asia/Shanghai）',
-  last_sequence INT NOT NULL COMMENT '当日已分配排车流水号，范围0001至9999',
+  last_sequence int NOT NULL COMMENT '当日已分配尾程单流水号',
-  PRIMARY KEY(business_date)
+  PRIMARY KEY (business_date)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车单号每日独立原子流水';
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='尾程单号按日原子流水';
 
 CREATE TABLE ll_order_operation_log (
   id bigint NOT NULL COMMENT '操作记录主键',
@@ -2073,7 +2077,6 @@ CREATE TABLE ll_overseas_procurement_fee (
   settled_command_event_id VARCHAR(64) NULL COMMENT '成功实扣或退款的资金命令事件',
   source_fee_id BIGINT NULL COMMENT '已实扣费用来源ID',
   parent_fee_id BIGINT NULL COMMENT '原费用或预估引用',
-  idempotency_key VARCHAR(128) NULL COMMENT '退款请求幂等键，独立于业务单号',
   request_hash CHAR(64) NULL COMMENT '确认请求摘要',
   id bigint NOT NULL COMMENT '主键ID',
   order_id bigint NOT NULL COMMENT '采购订单ID',
@@ -2095,7 +2098,6 @@ CREATE TABLE ll_overseas_procurement_fee (
   updated_at datetime(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT '更新时间',
   CONSTRAINT chk_procurement_confirmation_origin CHECK(confirmation_origin IN('BUSINESS','FINANCIAL')),
   UNIQUE KEY uk_ll_procurement_fee_version(order_id,purpose,fee_item_code,fee_version),
-  UNIQUE KEY uk_ll_procurement_refund_request(order_id,purpose,idempotency_key),
   PRIMARY KEY (id),
   UNIQUE KEY uk_ll_procurement_fee_no (fee_no),
   KEY idx_ll_procurement_fee_order (customer_id,order_id,created_at),
@@ -2366,6 +2368,14 @@ CREATE TABLE ll_pda_stocktake_task (
   KEY idx_ll_pda_stocktake_list (overseas_warehouse_id,status,created_at)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='海外PDA库存盘点任务';
 
+CREATE TABLE ll_procurement_daily_sequence (
+  customer_id varchar(128) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '客户ID',
+  business_date date NOT NULL COMMENT '北京时间业务日期',
+  sequence_value int NOT NULL COMMENT '客户当日已分配最大序号',
+  PRIMARY KEY (customer_id,business_date),
+  CONSTRAINT chk_ll_procurement_sequence CHECK ((sequence_value between 1 and 9999))
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='海外采购客户日序列';
+
 CREATE TABLE ll_receiving_container_operation (
   id bigint NOT NULL COMMENT '柜号收货操作ID',
   session_id bigint NOT NULL COMMENT '柜号签收会话ID',
@@ -3212,7 +3222,6 @@ CREATE TABLE ll_fleet_external_booking (
   binding_key VARCHAR(128) NULL COMMENT '关联发运请求键',
   binding_hash CHAR(64) NULL COMMENT '关联发运摘要',
   offer_id BIGINT NULL COMMENT '来源运力发布，普通车次预订为空',
-  source_looseboard_order_id BIGINT NULL COMMENT '客户原始散板商业单ID，取消后保留来源',
   sales_owner_user_id VARCHAR(64) NULL COMMENT '登录身份冻结的销售负责人',
   business_type VARCHAR(32) NULL COMMENT '本土商业类型LOCAL_LOOSEBOARD或US_TRUCK',
   delivery_mode VARCHAR(32) NULL COMMENT '客户送仓或人工安排提货回仓',
@@ -3227,7 +3236,6 @@ CREATE TABLE ll_fleet_external_booking (
   KEY idx_fleet_booking_sales(sales_owner_user_id,offer_id,id),
   CONSTRAINT fk_fleet_booking_offer FOREIGN KEY(offer_id) REFERENCES ll_fleet_capacity_offer(id),
   CONSTRAINT chk_fleet_booking_expected_pallet CHECK(expected_pallet_count IS NULL OR expected_pallet_count > 0),
-  KEY idx_booking_looseboard_source (customer_id,source_looseboard_order_id,status),
   PRIMARY KEY(id),
   UNIQUE KEY uk_fleet_booking_no(booking_no),
   UNIQUE KEY uk_fleet_booking_create(trip_id,created_by,idempotency_key),
@@ -4820,6 +4828,12 @@ CREATE TABLE ll_appointment_work_history (
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='预约工作事项历史与幂等命令';
 
 -- 海外业务短单号分配时钟。
+CREATE TABLE ll_compact_number_clock (
+  number_key VARCHAR(16) NOT NULL COMMENT '业务前缀和客户名称缩写',
+  last_second BIGINT NOT NULL COMMENT '最后分配的Unix逻辑秒',
+  PRIMARY KEY (number_key)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='海外业务短单号分配时钟';
+
 -- 仓储转运上门取货表归尾程服务，仅用于空库初始化。
 USE baiyue_lastleg;
 CREATE TABLE ll_fleet_pickup_plan (
@@ -4874,8 +4888,7 @@ CREATE TABLE ll_fleet_pickup_history (
   KEY idx_pickup_history_trip(trip_no,id)
 ) 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 '真实车辆档案主键，临时外配为空',
@@ -4893,7 +4906,7 @@ CREATE TABLE 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 ll_fleet_owned_business_record (
+CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_record (
   id BIGINT NOT NULL COMMENT '附加运营记录内部主键',
   dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
   record_version BIGINT NOT NULL COMMENT '附加运营记录并发版本，独立于原排车版本',
@@ -4918,7 +4931,7 @@ CREATE TABLE 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 ll_fleet_owned_business_command (
+CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_command (
   id BIGINT NOT NULL COMMENT '附加运营命令内部主键',
   dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
   operator_id VARCHAR(64) NOT NULL COMMENT '原命令操作人标识',
@@ -4939,7 +4952,7 @@ CREATE TABLE 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 ll_fleet_owned_business_history (
+CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_history (
   id BIGINT NOT NULL COMMENT '附加运营历史内部主键',
   dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
   record_version BIGINT NOT NULL COMMENT '成功写入后的附加记录版本',
@@ -4954,36 +4967,4 @@ CREATE TABLE ll_fleet_owned_business_history (
   CONSTRAINT ck_owned_business_history_version CHECK (record_version>0)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='原排车自有业务附加运营不可变历史';
 
--- 运输原单接入现有排车，不产生仓内库存事实。
+SELECT 'PASS' AS initialization_status, 'OVERSEAS' AS region, 233 AS initialized_tables;
-USE baiyue_lastleg;
-CREATE TABLE ll_dispatch_truck_task (
-  dispatch_no VARCHAR(64) NOT NULL COMMENT '排车业务号',
-  trip_no VARCHAR(64) NOT NULL COMMENT '本次运输资源记录号',
-  customer_id VARCHAR(128) NOT NULL COMMENT '本土卡车原单客户标识',
-  order_no VARCHAR(64) NOT NULL COMMENT '本土卡车原单业务号',
-  active_order VARCHAR(193) NULL COMMENT '有效原单唯一键；取消置空，完成保留',
-  PRIMARY KEY(dispatch_no), UNIQUE KEY uk_transport_trip(trip_no), UNIQUE KEY uk_transport_source(active_order),
-  KEY idx_transport_order(customer_id,order_no)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车与本土卡车原单关联';
-CREATE TABLE ll_dispatch_transport_create (
-  trip_no VARCHAR(64) NOT NULL PRIMARY KEY COMMENT '本次运输资源记录号',
-  request_hash CHAR(64) NOT NULL COMMENT '首次安排请求摘要'
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='本土卡车排车创建请求账本';
-CREATE TABLE ll_dispatch_transport_command (
-  dispatch_no VARCHAR(64) NOT NULL COMMENT '排车业务号',
-  request_key VARCHAR(128) NOT NULL COMMENT '客户端幂等请求键',
-  request_hash CHAR(64) NOT NULL COMMENT '执行命令请求摘要',
-  evidence_json JSON NULL COMMENT '已确认运输完成凭证标识列表',
-  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '业务命令提交时间',
-  PRIMARY KEY(dispatch_no,request_key)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='排车运输执行命令与凭证账本';
-
-USE baiyue_lastleg;
-CREATE TABLE ll_document_sequence (
-  sequence_key VARCHAR(32) NOT NULL COMMENT '业务前缀与北京时间日期组成的全局序列键',
-  current_value BIGINT NOT NULL COMMENT '该前缀当日已分配流水，已分配号不回收',
-  PRIMARY KEY (sequence_key),
-  CONSTRAINT chk_ll_document_sequence_value CHECK (current_value > 0)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='业务单据每日独立原子流水';
-
-SELECT 'PASS' AS initialization_status, 'OVERSEAS' AS region, 234 AS initialized_tables;

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

@@ -11,8 +11,6 @@ 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),
@@ -80,9 +78,9 @@ enum BusinessFileCategory {
                 && tenantId != 0) {
             throw new BizException(ResultCode.BAD_REQUEST, "排车运营照片必须归属平台");
         }
-        if ((this == OVERSEAS_DISPATCH_VEHICLE_EVIDENCE || this == OVERSEAS_DISPATCH_DRIVER_EVIDENCE || this == OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE || this == OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE)
+        if ((this == OVERSEAS_DISPATCH_VEHICLE_EVIDENCE || this == OVERSEAS_DISPATCH_DRIVER_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_DRIVER_PHOTO_EVIDENCE，不可互换。司机本人照片DRIVER_PHOTO和排车异常图片EXCEPTION仅支持JPG/PNG；其他两类沿PDF/JPG/PNG。
+    OVERSEAS_DISPATCH_VEHICLE_EVIDENCE、OVERSEAS_DISPATCH_DRIVER_EVIDENCE，不可互换。
     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, OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE, OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE]
+      enum: [OVERSEAS_DISPATCH_VEHICLE_EVIDENCE, OVERSEAS_DISPATCH_DRIVER_EVIDENCE]
     MetadataEnvelope:
       type: object
       required: [code, data]

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

@@ -30,8 +30,6 @@ 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;
@@ -42,9 +40,9 @@ class DispatchEvidenceFileTest {
             FileObjectEntity.class);
     }
 
-    /** 三类证据只接受平台与有效排车内部 ID，非法输入不得访问数据库或磁盘。 */
+    /** 两类证据只接受平台与有效排车内部 ID，非法输入不得访问数据库或磁盘。 */
     @ParameterizedTest
-    @ValueSource(strings = {VEHICLE, DRIVER, PHOTO, EXCEPTION})
+    @ValueSource(strings = {VEHICLE, DRIVER})
     void requiresPlatformAndPositiveDispatchIdBeforeAccess(String type) {
         var files = mock(FileObjectMapper.class);
         var storage = mock(BusinessFileStorage.class);
@@ -66,19 +64,6 @@ 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})
@@ -164,7 +149,7 @@ class DispatchEvidenceFileTest {
 
     /** 元数据和下载均逐列带全复合键；错车、错类别、错文件不得读取存储内容。 */
     @ParameterizedTest
-    @ValueSource(strings = {VEHICLE, DRIVER, PHOTO, EXCEPTION})
+    @ValueSource(strings = {VEHICLE, DRIVER})
     void metadataAndDownloadEnforceEveryScopeKeyBeforeReading(String type) throws Exception {
         var files = mock(FileObjectMapper.class);
         var storage = mock(BusinessFileStorage.class);

finance/AGENTS.md

@@ -50,7 +50,7 @@
 - 平台写操作必须校验权限、目标客户、幂等键、请求哈希、乐观锁版本和审计；客户接口只能从登录态取得客户范围，不接受客户端指定客户 ID。
 - 出账后的业务来源和账单不得原地覆盖或物理删除；调整、作废、收款分配和修订必须保留可追溯记录。金额使用定点小数，当前业务币种固定为 CNY，长整型 ID 跨前端按字符串传输。
 - 对账单出账后将客户确认状态置为 `PENDING_CONFIRMATION`；已出账账单调整后必须清除原确认快照并重新待确认，作废或重开时为 `NOT_REQUIRED`。客户只能确认本企业且状态为 `ISSUED`、`PARTIALLY_PAID` 或 `PAID` 的待确认账单，必须校验登录成员、乐观锁版本和幂等键，并记录确认人姓名快照与确认时间。
-- 财务单据编号遵循 `../../docs/业务单据编号契约.md`，由本服务 Repository/Mapper 按前缀与北京时间日期原子分配；不得回退为数据库 ID 拼接、随机数或跨时区日期。
+- 对账单、应收结算单和应付结算单编号统一按北京时间生成 `REC/AR/AP-yyMMdd-####`，各前缀每日独立递增且单日最多 9999；不得回退为数据库 ID 拼接、随机数或跨时区日期。
 - 客户授信必须带晚于当天的到期日且不限制最远日期；到期日当天仍有效。有效期内消费先用实际资金，不足部分累计为已用授信；次日失效时已用授信自动并入实际余额并允许为负，充值先归还已用授信或负余额。Order 在客户提交新订单时必须拒绝负数实际余额，已存在的资金冻结仍按原业务单结算或释放。
 - 应收款统计只按正式应收结算单的生成月份汇总 CNY 应收、已收和未收，支持可选客户筛选和分页；导出必须通过 Finance Provider + File `FINANCE_RECEIVABLE_STATISTICS` 异步任务，不在 Controller 或 Admin 直接生成文件。
 - 费用入池只接受满足上游发布与结算条件的不可变来源版本；来源 ID、版本、客户归属、方向或金额变化时同时核对事件消费、主动快照查询、唯一约束和账单明细消费者。

finance/src/main/java/com/baiyue/finance/dto/FinanceSettlementDtos.java

@@ -37,7 +37,7 @@ public final class FinanceSettlementDtos {
                                  BigDecimal quantity, BigDecimal unitPrice, BigDecimal amount, String currency,
                                  String reviewStatus, String sourceStatus,
                                  boolean statementGenerated) {}
-    public record SettlementTransaction(long transactionId, String transactionNo, String transactionType, LocalDate transactionDate,
+    public record SettlementTransaction(long transactionId, String transactionType, LocalDate transactionDate,
                                         BigDecimal amount, String method, String referenceNo,
                                         List<String> voucherFileIds, long createdBy, String createdByName,
                                         LocalDateTime createdAt,

finance/src/main/java/com/baiyue/finance/mapper/DocumentSequenceMapper.java

@@ -1,21 +0,0 @@
-package com.baiyue.finance.mapper;
-
-import org.apache.ibatis.annotations.Insert;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Options;
-import org.apache.ibatis.annotations.Param;
-import org.apache.ibatis.annotations.Select;
-
-/** 本服务业务编号序列，更新与读取必须处于同一事务连接。 */
-@Mapper
-public interface DocumentSequenceMapper {
-    /** 唯一序列键原子递增，并在连接内保存本次分配值。 */
-    @Insert("INSERT INTO fin_document_sequence(sequence_key,current_value) VALUES(#{key},LAST_INSERT_ID(1)) "
-        + "ON DUPLICATE KEY UPDATE current_value=LAST_INSERT_ID(current_value+1)")
-    int allocate(@Param("key") String key);
-
-    /** 禁用一级和二级缓存，返回本事务刚刚分配的值。 */
-    @Select("SELECT LAST_INSERT_ID()")
-    @Options(useCache=false, flushCache=Options.FlushCachePolicy.TRUE)
-    Long allocatedValue();
-}

finance/src/main/java/com/baiyue/finance/mapper/FinanceSettlementDetailMapper.java

@@ -1,43 +0,0 @@
-package com.baiyue.finance.mapper;
-
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Param;
-import org.apache.ibatis.annotations.Select;
-import java.util.List;
-import java.util.Map;
-
-/** 结算详情只读SQL；子查询均保留所属客户和原结算范围。 */
-@Mapper
-public interface FinanceSettlementDetailMapper {
-    String SUMMARY_SELECT =
-        "SELECT s.id,s.tenant_id,s.settlement_no,s.direction,s.customer_name_snapshot,s.supplier_id," +
-            "s.supplier_name_snapshot,s.reconciliation_statement_id,b.bill_no reconciliation_statement_no," +
-            "s.business_period,(SELECT GROUP_CONCAT(DISTINCT fs.fee_item_name ORDER BY fs.fee_item_name SEPARATOR '、') " +
-            "FROM fin_settlement_line sl JOIN fin_fee_source fs ON fs.id=sl.fee_source_id " +
-            "WHERE sl.tenant_id=s.tenant_id AND sl.settlement_id=s.id) fee_item_summary," +
-            "s.currency_code,s.total_amount,s.paid_amount,s.outstanding_amount,s.generated_date,s.due_date," +
-            "s.payment_status,s.status,s.created_by,(SELECT a.operator_name_snapshot FROM fin_audit_log a " +
-            "WHERE a.tenant_id=s.tenant_id AND a.resource_type='FIN_SETTLEMENT' AND a.resource_id=s.id " +
-            "AND a.action='CREATE' ORDER BY a.created_at,a.id LIMIT 1) created_by_name,s.created_at,s.updated_at," +
-            "CASE WHEN s.direction='RECEIVABLE' THEN (SELECT MAX(r.created_at) FROM fin_receipt_bill rb " +
-            "JOIN fin_receipt r ON r.id=rb.receipt_id AND r.tenant_id=rb.tenant_id " +
-            "WHERE rb.tenant_id=s.tenant_id AND rb.bill_id=s.reconciliation_statement_id AND r.status='CONFIRMED') " +
-            "ELSE (SELECT MAX(p.created_at) FROM fin_settlement_payment p WHERE p.tenant_id=s.tenant_id " +
-            "AND p.settlement_id=s.id) END last_payment_at,s.version FROM fin_settlement s " +
-            "LEFT JOIN fin_bill b ON b.tenant_id=s.tenant_id AND b.id=s.reconciliation_statement_id ";
-    /** 读取平台结算主单及来源摘要。 */
-    @Select(SUMMARY_SELECT + "WHERE s.id=#{settlementId}")
-    List<Map<String, Object>> summary(@Param("settlementId") long settlementId);
-    /** 读取该客户该结算的费用明细。 */
-    @Select("SELECT f.id fee_source_id,f.source_type,f.source_fee_id,f.source_fee_version,f.direction,f.customer_id,f.order_id,f.inbound_id,f.container_id,f.fee_item_name,f.amount,f.currency_code,f.review_status,f.status,f.source_snapshot FROM fin_settlement_line sl JOIN fin_fee_source f ON f.id=sl.fee_source_id WHERE sl.tenant_id=#{customerId} AND sl.settlement_id=#{settlementId} ORDER BY sl.id")
-    List<Map<String, Object>> lines(@Param("customerId") long customerId, @Param("settlementId") long settlementId);
-    /** 读取该客户付款流水及落库业务号，不能用ID替代。 */
-    @Select("SELECT id,transaction_no,transaction_type,transaction_date,amount,method,reference_no,voucher_file_ids,created_by,created_by_name,created_at,remark FROM fin_settlement_payment WHERE tenant_id=#{customerId} AND settlement_id=#{settlementId} ORDER BY created_at,id")
-    List<Map<String, Object>> payments(@Param("customerId") long customerId, @Param("settlementId") long settlementId);
-    /** 读取对账单已确认收款；收款凭证号不是PAY业务号。 */
-    @Select("SELECT r.id,'RECEIPT' transaction_type,DATE(r.received_at) transaction_date,rb.applied_amount amount,r.payment_method method,r.voucher_no reference_no,r.voucher_file_ids,r.created_by,r.created_by_name,r.created_at,r.remark FROM fin_receipt_bill rb JOIN fin_receipt r ON r.id=rb.receipt_id AND r.tenant_id=rb.tenant_id WHERE rb.tenant_id=#{customerId} AND rb.bill_id=#{statementId} AND r.status='CONFIRMED' ORDER BY r.created_at,r.id")
-    List<Map<String, Object>> receipts(@Param("customerId") long customerId, @Param("statementId") long statementId);
-    /** 读取该客户结算修订历史。 */
-    @Select("SELECT action,reason,before_data,after_data,operator_id,operator_name_snapshot,created_at FROM fin_audit_log WHERE tenant_id=#{customerId} AND resource_type='FIN_SETTLEMENT' AND resource_id=#{settlementId} ORDER BY created_at,id")
-    List<Map<String, Object>> audits(@Param("customerId") long customerId, @Param("settlementId") long settlementId);
-}

finance/src/main/java/com/baiyue/finance/repository/DocumentSequenceRepository.java

@@ -1,24 +0,0 @@
-package com.baiyue.finance.repository;
-
-import com.baiyue.finance.mapper.DocumentSequenceMapper;
-import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Propagation;
-import org.springframework.transaction.annotation.Transactional;
-
-/** 各业务共用本库序列，独立短事务避免持有编号锁进入业务资源锁。 */
-@Repository
-public class DocumentSequenceRepository {
-    private final DocumentSequenceMapper mapper;
-
-    /** 只访问所属服务的编号表。 */
-    public DocumentSequenceRepository(DocumentSequenceMapper mapper) { this.mapper = mapper; }
-
-    /** 已分配号不因外层业务回滚而复用，允许失败请求产生断号。 */
-    @Transactional(propagation = Propagation.REQUIRES_NEW)
-    public long next(String key) {
-        mapper.allocate(key);
-        Long value = mapper.allocatedValue();
-        if (value == null || value < 1) throw new IllegalStateException("业务编号分配失败");
-        return value;
-    }
-}

finance/src/main/java/com/baiyue/finance/repository/FinanceSettlementDetailRepository.java

@@ -1,29 +0,0 @@
-package com.baiyue.finance.repository;
-
-import com.baiyue.finance.mapper.FinanceSettlementDetailMapper;
-import org.springframework.stereotype.Repository;
-import org.springframework.util.LinkedCaseInsensitiveMap;
-import java.util.List;
-import java.util.Map;
-
-/** 结算详情查询封装，列名大小写差异不改变已有字段映射语义。 */
-@Repository
-public class FinanceSettlementDetailRepository {
-    private final FinanceSettlementDetailMapper mapper;
-    /** 注入结算详情持久化入口。 */
-    public FinanceSettlementDetailRepository(FinanceSettlementDetailMapper mapper) { this.mapper = mapper; }
-    /** 保留原数据库列名不区分大小写的读取语义。 */
-    private List<Map<String, Object>> rows(List<Map<String, Object>> rows) {
-        return rows.stream().map(row -> { Map<String, Object> copy = new LinkedCaseInsensitiveMap<>(); copy.putAll(row); return copy; }).toList();
-    }
-    /** 读取平台结算主单及来源摘要。 */
-    public List<Map<String, Object>> summary(long settlementId) { return rows(mapper.summary(settlementId)); }
-    /** 读取该客户该结算的费用明细。 */
-    public List<Map<String, Object>> lines(long customerId, long settlementId) { return rows(mapper.lines(customerId, settlementId)); }
-    /** 读取该客户付款流水及落库业务号，不能用ID替代。 */
-    public List<Map<String, Object>> payments(long customerId, long settlementId) { return rows(mapper.payments(customerId, settlementId)); }
-    /** 读取对账单已确认收款；收款凭证号不是PAY业务号。 */
-    public List<Map<String, Object>> receipts(long customerId, long statementId) { return rows(mapper.receipts(customerId, statementId)); }
-    /** 读取该客户结算修订历史。 */
-    public List<Map<String, Object>> audits(long customerId, long settlementId) { return rows(mapper.audits(customerId, settlementId)); }
-}

finance/src/main/java/com/baiyue/finance/service/FinanceDocumentNumberGenerator.java

@@ -1,34 +1,55 @@
 package com.baiyue.finance.service;
 
-import com.baiyue.common.core.number.DailyDocumentNumber;
-import com.baiyue.finance.repository.DocumentSequenceRepository;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
 import java.time.Clock;
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.Locale;
 import java.util.Set;
 
-/** 按北京时间生成两至四位前缀、八位日期和四位日流水。 */
 @Component
 public class FinanceDocumentNumberGenerator {
-    private static final Set<String> PREFIXES = Set.of("REC", "AR", "AP", "RC", "AC", "VC", "VP", "PAY");
+    private static final ZoneId BUSINESS_ZONE = ZoneId.of("Asia/Shanghai");
-    private final DocumentSequenceRepository sequences;
+    private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("yyMMdd", Locale.ROOT);
+    private static final Set<String> SUPPORTED_PREFIXES = Set.of("REC", "AR", "AP", "RC", "AC", "VC", "VP");
+    private static final long MAX_DAILY_SEQUENCE = 9_999L;
+
+    private final JdbcTemplate jdbc;
     private final Clock clock;
 
-    /** 正式运行使用统一业务时区。 */
     @Autowired
-    public FinanceDocumentNumberGenerator(DocumentSequenceRepository sequences) {
+    public FinanceDocumentNumberGenerator(JdbcTemplate jdbc) {
-        this(sequences, Clock.system(DailyDocumentNumber.BUSINESS_ZONE));
+        this(jdbc, Clock.system(BUSINESS_ZONE));
     }
 
-    /** 固定时钟用于跨日及前缀独立性验证。 */
+    FinanceDocumentNumberGenerator(JdbcTemplate jdbc, Clock clock) {
-    FinanceDocumentNumberGenerator(DocumentSequenceRepository sequences, Clock clock) {
+        this.jdbc = jdbc;
-        this.sequences = sequences;
         this.clock = clock;
     }
 
-    /** 只为本服务已登记的业务类型分配号码。 */
+    @Transactional(propagation = Propagation.MANDATORY)
     public String next(String prefix) {
-        if (!PREFIXES.contains(prefix)) throw new IllegalArgumentException("未登记的业务编号前缀：" + prefix);
+        if (!SUPPORTED_PREFIXES.contains(prefix)) {
-        return DailyDocumentNumber.next(prefix, clock, sequences::next);
+            throw new IllegalArgumentException("unsupported finance document prefix: " + prefix);
+        }
+        LocalDate sequenceDate = LocalDate.now(clock);
+        String sequenceKey = prefix + ":" + DateTimeFormatter.BASIC_ISO_DATE.format(sequenceDate);
+        jdbc.update(
+            "INSERT INTO fin_document_sequence(sequence_key,current_value) " +
+                "VALUES(?,LAST_INSERT_ID(1)) ON DUPLICATE KEY UPDATE " +
+                "current_value=LAST_INSERT_ID(current_value+1)",
+            sequenceKey);
+        Long sequence = jdbc.queryForObject("SELECT LAST_INSERT_ID()", Long.class);
+        if (sequence == null || sequence <= 0 || sequence > MAX_DAILY_SEQUENCE) {
+            throw new FinanceEventException("FIN_409", "当日" + prefix + "单据编号已用尽");
+        }
+        return prefix + "-" + DATE_FORMAT.format(sequenceDate) + "-" +
+            String.format(Locale.ROOT, "%04d", sequence);
     }
 }

finance/src/main/java/com/baiyue/finance/service/FinancePhase1OperationService.java

@@ -12,7 +12,6 @@ import com.baiyue.finance.dto.FinancePhase1Dtos.FeeSourceEditRequest;
 import com.baiyue.finance.client.FirstlegFeeSourceClient;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
 import feign.FeignException;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
@@ -438,14 +437,7 @@ public class FinancePhase1OperationService {
     private static Long nullableLong(ResultSet rs, String column) throws SQLException { long value = rs.getLong(column); return rs.wasNull() ? null : value; }
     private JsonNode parse(String json) { try { return objectMapper.readTree(json); } catch (Exception e) { throw error("FIN-DATA-500", "费用来源快照损坏"); } }
     private String json(Object value) { try { return objectMapper.writeValueAsString(value); } catch (Exception e) { throw error("FIN-DATA-500", "财务数据序列化失败"); } }
-    /** 固定映射键序，使同一请求在服务重启前后使用相同摘要。 */
+    private String hash(Object value) { try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(json(value).getBytes(StandardCharsets.UTF_8))); } catch (Exception e) { throw error("FIN-DATA-500", "幂等请求哈希失败"); } }
-    private String hash(Object value) {
-        try {
-            byte[] canonical = objectMapper.writer().with(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)
-                .writeValueAsBytes(value);
-            return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(canonical));
-        } catch (Exception failure) { throw error("FIN-DATA-500", "幂等请求哈希失败"); }
-    }
     private static String text(JsonNode node, String field) { JsonNode value = node.path(field); return value.isMissingNode() || value.isNull() ? null : value.asText(); }
     private static Long jsonLong(JsonNode node, String field) {
         JsonNode value = node.path(field);

finance/src/main/java/com/baiyue/finance/service/FinanceService.java

@@ -4,7 +4,6 @@ import com.baiyue.common.core.api.ResultCode;
 import com.baiyue.common.core.exception.BizException;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.support.GeneratedKeyHolder;
 import org.springframework.jdbc.support.KeyHolder;
@@ -307,14 +306,7 @@ public class FinanceService {
             default -> throw new IllegalArgumentException("未知财务幂等操作: " + operation);
         };
     }
-    /** 固定请求映射键序，避免服务重启后拒绝同一财务命令。 */
+    private String hash(Object request) { try { byte[] bytes = java.security.MessageDigest.getInstance("SHA-256").digest(json(request).getBytes(java.nio.charset.StandardCharsets.UTF_8)); return java.util.HexFormat.of().formatHex(bytes); } catch (Exception ex) { throw new IllegalStateException("请求哈希失败", ex); } }
-    private String hash(Object request) {
-        try {
-            byte[] canonical = objectMapper.writer().with(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)
-                .writeValueAsBytes(request == null ? List.of() : request);
-            return java.util.HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-256").digest(canonical));
-        } catch (Exception ex) { throw new IllegalStateException("请求哈希失败", ex); }
-    }
 
     private static void requireCustomer(long tenantId) { if (tenantId <= 0) throw bad("客户范围无效"); }
     private static BizException bad(String message) { return new BizException(ResultCode.BAD_REQUEST, message); }

finance/src/main/java/com/baiyue/finance/service/FinanceSettlementService.java

@@ -12,7 +12,6 @@ import com.baiyue.finance.dto.FinanceSettlementDtos.SettlementActionRequest;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
 import org.slf4j.MDC;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.support.GeneratedKeyHolder;
@@ -45,29 +44,44 @@ import java.util.UUID;
 public class FinanceSettlementService {
     private static final String CNY = "CNY";
     private static final Set<String> PAYMENT_METHODS = Set.of("BANK_TRANSFER", "CASH", "OTHER");
-    private static final String SETTLEMENT_SUMMARY_SELECT = com.baiyue.finance.mapper.FinanceSettlementDetailMapper.SUMMARY_SELECT;
+    private static final String SETTLEMENT_SUMMARY_SELECT =
+        "SELECT s.id,s.tenant_id,s.settlement_no,s.direction,s.customer_name_snapshot,s.supplier_id," +
+            "s.supplier_name_snapshot,s.reconciliation_statement_id,b.bill_no reconciliation_statement_no," +
+            "s.business_period,(SELECT GROUP_CONCAT(DISTINCT fs.fee_item_name ORDER BY fs.fee_item_name SEPARATOR '、') " +
+            "FROM fin_settlement_line sl JOIN fin_fee_source fs ON fs.id=sl.fee_source_id " +
+            "WHERE sl.tenant_id=s.tenant_id AND sl.settlement_id=s.id) fee_item_summary," +
+            "s.currency_code,s.total_amount,s.paid_amount,s.outstanding_amount,s.generated_date,s.due_date," +
+            "s.payment_status,s.status,s.created_by,(SELECT a.operator_name_snapshot FROM fin_audit_log a " +
+            "WHERE a.tenant_id=s.tenant_id AND a.resource_type='FIN_SETTLEMENT' AND a.resource_id=s.id " +
+            "AND a.action='CREATE' ORDER BY a.created_at,a.id LIMIT 1) created_by_name,s.created_at,s.updated_at," +
+            "CASE WHEN s.direction='RECEIVABLE' THEN (SELECT MAX(r.created_at) FROM fin_receipt_bill rb " +
+            "JOIN fin_receipt r ON r.id=rb.receipt_id AND r.tenant_id=rb.tenant_id " +
+            "WHERE rb.tenant_id=s.tenant_id AND rb.bill_id=s.reconciliation_statement_id AND r.status='CONFIRMED') " +
+            "ELSE (SELECT MAX(p.created_at) FROM fin_settlement_payment p WHERE p.tenant_id=s.tenant_id " +
+            "AND p.settlement_id=s.id) END last_payment_at,s.version FROM fin_settlement s " +
+            "LEFT JOIN fin_bill b ON b.tenant_id=s.tenant_id AND b.id=s.reconciliation_statement_id ";
     private final JdbcTemplate jdbc;
-    private final com.baiyue.finance.repository.FinanceSettlementDetailRepository details;
     private final ObjectMapper objectMapper;
     private final FinanceVoucherValidator voucherValidator;
     private final FinanceSupplierValidator supplierValidator;
     private final FinanceDocumentNumberGenerator documentNumbers;
 
-    /** 注入统一编号组件，确保所有业务入口共用受事务保护的日流水。 */
+    public FinanceSettlementService(JdbcTemplate jdbc, ObjectMapper objectMapper, FinanceVoucherValidator voucherValidator,
+                                    FinanceSupplierValidator supplierValidator) {
+        this(jdbc, objectMapper, voucherValidator, supplierValidator, new FinanceDocumentNumberGenerator(jdbc));
+    }
+
     @Autowired
     public FinanceSettlementService(JdbcTemplate jdbc, ObjectMapper objectMapper, FinanceVoucherValidator voucherValidator,
                                     FinanceSupplierValidator supplierValidator,
-                                    FinanceDocumentNumberGenerator documentNumbers,
+                                    FinanceDocumentNumberGenerator documentNumbers) {
-                                    com.baiyue.finance.repository.FinanceSettlementDetailRepository details) {
         this.jdbc = jdbc;
-        this.details = details;
         this.objectMapper = objectMapper;
         this.voucherValidator = voucherValidator;
         this.supplierValidator = supplierValidator;
         this.documentNumbers = documentNumbers;
     }
 
-    /** 创建应收结算单，幂等请求恢复原单，首次建单分配 AR 日流水。 */
     @Transactional
     public SettlementDetail createReceivableSettlement(long operatorId, String key,
                                                         CreateReceivableSettlementRequest request) {
@@ -171,21 +185,33 @@ public class FinanceSettlementService {
         return getSettlement(settlementId);
     }
 
-    /** 读取结算及其业务流水号；全部详情数据访问经Repository和Mapper。 */
     public SettlementDetail getSettlement(long settlementId) {
         if (settlementId <= 0) throw error("FIN_404", "结算单不存在");
-        List<Map<String, Object>> records = details.summary(settlementId);
+        Map<String, Object> row = one(
-        if (records.isEmpty()) throw error("FIN_404", "结算单不存在");
+            SETTLEMENT_SUMMARY_SELECT + "WHERE s.id=?",
-        SettlementSummary summary = summary(records.get(0));
+            "结算单不存在", settlementId);
-        List<SettlementLine> lines = details.lines(summary.customerId(), settlementId)
+        SettlementSummary summary = summary(row);
+        List<SettlementLine> lines = jdbc.queryForList(
+            "SELECT f.id fee_source_id,f.source_type,f.source_fee_id,f.source_fee_version,f.direction,f.customer_id," +
+                "f.order_id,f.inbound_id,f.container_id,f.fee_item_name,f.amount,f.currency_code,f.review_status,f.status,f.source_snapshot " +
+                "FROM fin_settlement_line sl JOIN fin_fee_source f ON f.id=sl.fee_source_id " +
+                "WHERE sl.tenant_id=? AND sl.settlement_id=? ORDER BY sl.id", summary.customerId(), settlementId)
             .stream().map(source -> line(source, summary)).toList();
-        List<SettlementTransaction> transactions = new ArrayList<>(details.payments(summary.customerId(), settlementId)
+        List<SettlementTransaction> transactions = new ArrayList<>(jdbc.queryForList(
-            .stream().map(this::transaction).toList());
+            "SELECT id,transaction_type,transaction_date,amount,method,reference_no,voucher_file_ids,created_by,created_by_name,created_at,remark " +
+                "FROM fin_settlement_payment WHERE tenant_id=? AND settlement_id=? ORDER BY created_at,id",
+            summary.customerId(), settlementId).stream().map(this::transaction).toList());
         if ("RECEIVABLE".equals(summary.direction()) && summary.reconciliationStatementId() != null) {
-            transactions.addAll(details.receipts(summary.customerId(), summary.reconciliationStatementId())
+            transactions.addAll(jdbc.queryForList(
-                .stream().map(this::transaction).toList());
+                "SELECT r.id,'RECEIPT' transaction_type,DATE(r.received_at) transaction_date,rb.applied_amount amount,r.payment_method method,r.voucher_no reference_no,r.voucher_file_ids,r.created_by,r.created_by_name,r.created_at,r.remark " +
+                    "FROM fin_receipt_bill rb JOIN fin_receipt r ON r.id=rb.receipt_id AND r.tenant_id=rb.tenant_id " +
+                    "WHERE rb.tenant_id=? AND rb.bill_id=? AND r.status='CONFIRMED' ORDER BY r.created_at,r.id",
+                summary.customerId(), summary.reconciliationStatementId()).stream().map(this::transaction).toList());
         }
-        List<Map<String, Object>> audits = details.audits(summary.customerId(), settlementId);
+        List<Map<String, Object>> audits = jdbc.queryForList(
+            "SELECT action,reason,before_data,after_data,operator_id,operator_name_snapshot,created_at FROM fin_audit_log " +
+                "WHERE tenant_id=? AND resource_type='FIN_SETTLEMENT' AND resource_id=? ORDER BY created_at,id",
+            summary.customerId(), settlementId);
         List<SettlementRevision> revisions = new ArrayList<>();
         for (int index = 0; index < audits.size(); index++) revisions.add(revision(index + 1, audits.get(index)));
         return new SettlementDetail(summary, lines, transactions, List.copyOf(revisions));
@@ -453,9 +479,8 @@ public class FinanceSettlementService {
             text(row, "status"), true);
     }
 
-    /** 返回真实付款业务号；未生成PAY号的收款记录保持为空，不回退成内部ID。 */
     private SettlementTransaction transaction(Map<String, Object> row) {
-        return new SettlementTransaction(number(row, "id").longValue(), text(row, "transaction_no"), text(row, "transaction_type"),
+        return new SettlementTransaction(number(row, "id").longValue(), text(row, "transaction_type"),
             date(row, "transaction_date"), decimal(row, "amount"), text(row, "method"), text(row, "reference_no"),
             stringList(text(row, "voucher_file_ids")), number(row, "created_by").longValue(),
             text(row, "created_by_name"),
@@ -496,18 +521,15 @@ public class FinanceSettlementService {
             "outstandingAmount", decimal(settlement, "outstanding_amount"), "status", status);
     }
 
-    /** 结算收付款使用独立 PAY 日流水，重试由原业务幂等记录恢复。 */
     private String transactionNo() {
-        return documentNumbers.next("PAY");
+        return "PAY-" + LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE) + "-" +
+            UUID.randomUUID().toString().replace("-", "").substring(0, 12).toUpperCase(Locale.ROOT);
     }
 
-    /** 固定映射键序，避免 JVM 重启改变 Map.of 遍历顺序而误拒绝原请求。 */
     private String hash(Object value) {
         try {
-            String canonical = objectMapper.writer()
-                .with(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS).writeValueAsString(value);
             return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256")
-                .digest(canonical.getBytes(StandardCharsets.UTF_8)));
+                .digest(json(value).getBytes(StandardCharsets.UTF_8)));
         } catch (Exception failure) {
             throw error("FIN_001", "幂等请求哈希失败");
         }

finance/src/main/java/com/baiyue/finance/service/FinanceWalletService.java

@@ -14,7 +14,6 @@ import com.baiyue.finance.dto.FinanceWalletDtos.WalletHoldActionRequest;
 import com.baiyue.finance.dto.FinanceWalletDtos.WalletLedgerEntry;
 import com.baiyue.finance.dto.FinanceWalletDtos.WalletPage;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.dao.DuplicateKeyException;
 import org.springframework.http.ResponseEntity;
@@ -695,9 +694,8 @@ public class FinanceWalletService {
             timestamp(rs.getTimestamp("reviewed_at")));
     }
 
-    /** 摘要固定映射键序，保证充值和资金指令跨进程重放稳定。 */
     private String hash(Object value) {
-        try { return sha256(objectMapper.writer().with(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS).writeValueAsBytes(value)); }
+        try { return sha256(objectMapper.writeValueAsBytes(value)); }
         catch (Exception exception) { throw error("FIN_500", "请求摘要生成失败"); }
     }
     private String fileHash(MultipartFile file) {

finance/src/main/java/com/baiyue/finance/service/ReconciliationStatementService.java

@@ -10,7 +10,6 @@ import com.baiyue.finance.dto.ReconciliationStatementDtos.ReconciliationLine;
 import com.baiyue.finance.dto.ReconciliationStatementDtos.ReconciliationRevision;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
 import org.slf4j.MDC;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.support.GeneratedKeyHolder;
@@ -47,7 +46,10 @@ public class ReconciliationStatementService {
     private final ObjectMapper objectMapper;
     private final FinanceDocumentNumberGenerator documentNumbers;
 
-    /** 注入统一编号组件，确保所有业务入口共用受事务保护的日流水。 */
+    public ReconciliationStatementService(JdbcTemplate jdbc, ObjectMapper objectMapper) {
+        this(jdbc, objectMapper, new FinanceDocumentNumberGenerator(jdbc));
+    }
+
     @Autowired
     public ReconciliationStatementService(JdbcTemplate jdbc, ObjectMapper objectMapper,
                                           FinanceDocumentNumberGenerator documentNumbers) {
@@ -56,7 +58,6 @@ public class ReconciliationStatementService {
         this.documentNumbers = documentNumbers;
     }
 
-    /** 创建对账单并分配 REC 日流水，重复请求返回已创建记录。 */
     @Transactional
     public ReconciliationDetail create(long operatorId, String key, CreateReconciliationRequest request) {
         validateCreate(request);
@@ -522,13 +523,9 @@ public class ReconciliationStatementService {
         catch (Exception exception) { throw error("FIN_001", "财务数据序列化失败"); }
     }
 
-    /** 固定映射键序，使同一请求在服务重启前后使用相同摘要。 */
     private String hash(Object value) {
-        try {
+        try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(json(value).getBytes(StandardCharsets.UTF_8))); }
-            byte[] canonical = objectMapper.writer().with(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)
+        catch (Exception exception) { throw error("FIN_001", "幂等请求哈希失败"); }
-                .writeValueAsBytes(value);
-            return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(canonical));
-        } catch (Exception failure) { throw error("FIN_001", "幂等请求哈希失败"); }
     }
 
     private static LocalDateTime localTime(Object value) {

finance/src/main/resources/db/finance.sql

@@ -398,7 +398,7 @@ CREATE TABLE IF NOT EXISTS fin_document_sequence (
   current_value INT UNSIGNED NOT NULL COMMENT '该类型当日已分配的最大序号',
   PRIMARY KEY (sequence_key),
   CONSTRAINT chk_fin_document_sequence_value CHECK (current_value > 0)
-) ENGINE=InnoDB COMMENT='财务业务单号日序列；生成前缀加yyyyMMdd加四位当日序号';
+) ENGINE=InnoDB COMMENT='Finance业务单号日序列；生成YYMMDD加四位当日序号';
 
 CREATE TABLE IF NOT EXISTS fin_audit_log (
   id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主键ID',
@@ -524,7 +524,7 @@ CREATE TABLE IF NOT EXISTS fin_wallet_account (
 CREATE TABLE IF NOT EXISTS fin_recharge_request (
   id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主键ID',
   customer_id BIGINT UNSIGNED NOT NULL COMMENT '客户ID和隔离键',
-  request_no VARCHAR(32) NOT NULL COMMENT '充值申请业务编号RCyyyyMMdd####',
+  request_no VARCHAR(32) NOT NULL COMMENT '充值申请业务编号RC-yyMMdd-####',
   amount DECIMAL(20,2) NOT NULL COMMENT '申请充值金额',
   voucher_file_id BIGINT UNSIGNED NOT NULL COMMENT '付款截图File ID',
   voucher_file_name VARCHAR(255) NOT NULL COMMENT '付款截图文件名快照',
@@ -549,7 +549,7 @@ CREATE TABLE IF NOT EXISTS fin_recharge_request (
 CREATE TABLE IF NOT EXISTS fin_wallet_ledger (
   id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主键ID',
   customer_id BIGINT UNSIGNED NOT NULL COMMENT '客户ID和隔离键',
-  business_no VARCHAR(32) NOT NULL COMMENT '账户变动业务编号ACyyyyMMdd####',
+  business_no VARCHAR(32) NOT NULL COMMENT '账户变动业务编号AC-yyMMdd-####',
   change_type VARCHAR(16) NOT NULL COMMENT '变动类型：充值、扣款、冻结、解冻、消费或授信调整',
   amount DECIMAL(20,2) NOT NULL COMMENT '带方向变动金额，充值为正、扣款为负',
   actual_balance_after DECIMAL(20,2) NOT NULL COMMENT '变动后实际余额',

finance/src/test/java/com/baiyue/finance/FinancePlatformListContractTest.java

@@ -93,7 +93,7 @@ class FinancePlatformListContractTest {
         assertRecordFields(com.baiyue.finance.dto.ReconciliationStatementDtos.ReconciliationRevision.class,
             "operatorId", "operatorName");
         assertRecordFields(com.baiyue.finance.dto.FinanceSettlementDtos.SettlementTransaction.class,
-            "createdBy", "createdByName", "transactionNo");
+            "createdBy", "createdByName");
         assertRecordFields(com.baiyue.finance.dto.FinanceSettlementDtos.SettlementRevision.class,
             "operatorId", "operatorName");
         assertRecordFields(com.baiyue.finance.dto.FinanceSettlementDtos.SettlementSummary.class,

finance/src/test/java/com/baiyue/finance/FinanceSettlementBehaviorTest.java

@@ -236,8 +236,8 @@ class FinanceSettlementBehaviorTest {
             eq("SETTLEMENT_PAYMENT_CREATE"), eq("pay-key"))).thenReturn(List.of());
         when(jdbc.queryForList(startsWith("SELECT s.id,s.tenant_id,s.settlement_no"), eq(88L))).thenReturn(List.of(after));
         when(jdbc.queryForList(startsWith("SELECT f.id fee_source_id"), eq(10L), eq(88L))).thenReturn(List.of());
-        when(jdbc.queryForList(startsWith("SELECT id,transaction_no,transaction_type"), eq(10L), eq(88L))).thenReturn(List.of(Map.ofEntries(
+        when(jdbc.queryForList(startsWith("SELECT id,transaction_type"), eq(10L), eq(88L))).thenReturn(List.of(Map.ofEntries(
-            Map.entry("id", 501L), Map.entry("transaction_no", "PAY202610210001"), Map.entry("transaction_type", "PAYMENT"),
+            Map.entry("id", 501L), Map.entry("transaction_type", "PAYMENT"),
             Map.entry("transaction_date", Date.valueOf(LocalDate.of(2026, 8, 11))),
             Map.entry("amount", new BigDecimal("40.00")), Map.entry("method", "BANK_TRANSFER"),
             Map.entry("reference_no", "BANK-1"), Map.entry("voucher_file_ids", "[\"91\"]"),
@@ -258,7 +258,6 @@ class FinanceSettlementBehaviorTest {
         assertThat(result.transactions()).singleElement().extracting(transaction -> transaction.transactionType())
             .isEqualTo("PAYMENT");
         assertThat(result.transactions().get(0).createdByName()).isEqualTo("platform_admin");
-        assertThat(result.transactions().get(0).transactionNo()).isEqualTo("PAYMENT".equals(result.transactions().get(0).transactionType()) ? "PAY202610210001" : null);
         verify(jdbc).update(startsWith("UPDATE fin_settlement SET paid_amount"),
             any(), any(), any(), any(), any(), any(), any(), any());
     }
@@ -523,7 +522,6 @@ class FinanceSettlementBehaviorTest {
             .isEqualTo("RECEIPT");
         assertThat(result.transactions().get(0).amount()).isEqualByComparingTo("40.00");
         assertThat(result.transactions().get(0).createdByName()).isEqualTo("platform_admin");
-        assertThat(result.transactions().get(0).transactionNo()).isEqualTo("PAYMENT".equals(result.transactions().get(0).transactionType()) ? "PAY202610210001" : null);
     }
 
     @Test
@@ -622,18 +620,10 @@ class FinanceSettlementBehaviorTest {
         org.mockito.Mockito.lenient().when(jdbc.queryForList(startsWith("SELECT JSON_UNQUOTE"), anyLong(), anyLong()))
             .thenReturn(List.of(new java.util.HashMap<>(Map.of("supplier_category", "BOOKING"))));
         FinanceDocumentNumberGenerator documentNumbers = org.mockito.Mockito.mock(FinanceDocumentNumberGenerator.class);
-        org.mockito.Mockito.lenient().when(documentNumbers.next("AR")).thenReturn("AR202608180001");
+        org.mockito.Mockito.lenient().when(documentNumbers.next("AR")).thenReturn("AR-260818-0001");
-        org.mockito.Mockito.lenient().when(documentNumbers.next("AP")).thenReturn("AP202608180001");
+        org.mockito.Mockito.lenient().when(documentNumbers.next("AP")).thenReturn("AP-260818-0001");
-        org.mockito.Mockito.lenient().when(documentNumbers.next("PAY")).thenReturn("PAY202608180001");
-        // 既有业务测试保留JDBC替身，新详情路径通过真实Repository和Mapper接口适配执行。
-        var mapper = org.mockito.Mockito.mock(com.baiyue.finance.mapper.FinanceSettlementDetailMapper.class, invocation -> {
-            var select = invocation.getMethod().getAnnotation(org.apache.ibatis.annotations.Select.class);
-            if (select == null) return RETURNS_DEFAULTS.answer(invocation);
-            String sql = String.join(" ", select.value()).replaceAll("#\\{[a-zA-Z]+\\}", "?");
-            return jdbc.queryForList(sql, invocation.getArguments());
-        });
         return new FinanceSettlementService(jdbc, new ObjectMapper().findAndRegisterModules(),
-            new FinanceVoucherValidator(fileClient, "internal-token"), supplierValidator, documentNumbers, new com.baiyue.finance.repository.FinanceSettlementDetailRepository(mapper));
+            new FinanceVoucherValidator(fileClient, "internal-token"), supplierValidator, documentNumbers);
     }
 
     private static FinanceSupplierValidator supplierValidator() {
@@ -666,7 +656,7 @@ class FinanceSettlementBehaviorTest {
         when(jdbc.queryForList(startsWith("SELECT s.id,s.tenant_id,s.settlement_no"), eq(88L))).thenReturn(List.of(settlement));
         long customerId = ((Number) settlement.get("tenant_id")).longValue();
         when(jdbc.queryForList(startsWith("SELECT f.id fee_source_id"), eq(customerId), eq(88L))).thenReturn(List.of());
-        when(jdbc.queryForList(startsWith("SELECT id,transaction_no,transaction_type"), eq(customerId), eq(88L))).thenReturn(List.of());
+        when(jdbc.queryForList(startsWith("SELECT id,transaction_type"), eq(customerId), eq(88L))).thenReturn(List.of());
         when(jdbc.queryForList(startsWith("SELECT action,reason"), eq(customerId), eq(88L))).thenReturn(List.of());
     }
 

finance/src/test/java/com/baiyue/finance/FinanceSettlementDetailMapperTest.java

@@ -1,36 +0,0 @@
-package com.baiyue.finance;
-
-import com.baiyue.finance.mapper.FinanceSettlementDetailMapper;
-import com.baiyue.finance.repository.FinanceSettlementDetailRepository;
-import org.apache.ibatis.mapping.Environment;
-import org.apache.ibatis.session.Configuration;
-import org.apache.ibatis.session.SqlSessionFactoryBuilder;
-import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
-import org.junit.jupiter.api.Test;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.datasource.DriverManagerDataSource;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class FinanceSettlementDetailMapperTest {
-    /** 真实执行付款查询，业务号必须来自本客户本结算的流水，空号不以其他字段替代。 */
-    @Test
-    void paymentNumbersRemainScopedToCustomerAndSettlement() {
-        var source = new DriverManagerDataSource("jdbc:h2:mem:settlement-number;MODE=MySQL;DB_CLOSE_DELAY=-1", "sa", "");
-        var jdbc = new JdbcTemplate(source);
-        jdbc.execute("CREATE TABLE fin_settlement_payment (id BIGINT PRIMARY KEY,tenant_id BIGINT,settlement_id BIGINT,transaction_no VARCHAR(32),transaction_type VARCHAR(32),transaction_date DATE,amount DECIMAL(18,2),method VARCHAR(32),reference_no VARCHAR(64),voucher_file_ids VARCHAR(255),created_by BIGINT,created_by_name VARCHAR(64),created_at TIMESTAMP,remark VARCHAR(255))");
-        jdbc.update("INSERT INTO fin_settlement_payment (id,tenant_id,settlement_id,transaction_no,transaction_type,reference_no) VALUES (1,10,20,'PAY202610210001','PAYMENT','BANK-1'),(2,11,20,'PAY202610210002','PAYMENT','BANK-2'),(3,10,21,'PAY202610210003','PAYMENT','BANK-3'),(4,10,22,NULL,'PAYMENT','BANK-4')");
-        var configuration = new Configuration(new Environment("test", new JdbcTransactionFactory(), source));
-        configuration.addMapper(FinanceSettlementDetailMapper.class);
-        try (var session = new SqlSessionFactoryBuilder().build(configuration).openSession()) {
-            var repository = new FinanceSettlementDetailRepository(session.getMapper(FinanceSettlementDetailMapper.class));
-            var rows = repository.payments(10, 20);
-            assertThat(rows).hasSize(1);
-            assertThat(rows.get(0).get("transaction_no")).isEqualTo("PAY202610210001");
-            assertThat(rows.get(0).get("reference_no")).isEqualTo("BANK-1");
-            assertThat(repository.payments(11, 21)).isEmpty();
-            assertThat(repository.payments(10, 22)).hasSize(1);
-            assertThat(repository.payments(10, 22).get(0).get("transaction_no")).isNull();
-        }
-    }
-}

finance/src/test/java/com/baiyue/finance/FinanceSettlementRequestHashTest.java

@@ -1,47 +0,0 @@
-package com.baiyue.finance;
-
-import com.baiyue.finance.service.FinanceSettlementService;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
-import com.baiyue.finance.service.FinanceWalletService;
-import com.baiyue.finance.service.FinancePhase1OperationService;
-import com.baiyue.finance.service.FinanceService;
-import com.baiyue.finance.service.ReconciliationStatementService;
-import org.springframework.test.util.ReflectionTestUtils;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class FinanceSettlementRequestHashTest {
-    /** 模拟不同 JVM 的 Map 遍历顺序；同一付款请求必须得到相同摘要。 */
-    @ParameterizedTest
-    @ValueSource(classes = {FinanceSettlementService.class, FinanceWalletService.class,
-        FinancePhase1OperationService.class, FinanceService.class, ReconciliationStatementService.class})
-    void equivalentRequestsIgnoreMapIterationOrderButDetectChangedPayment(Class<?> serviceType) {
-        Object service = org.mockito.Mockito.mock(serviceType, org.mockito.Mockito.CALLS_REAL_METHODS);
-        ReflectionTestUtils.setField(service, "objectMapper", new ObjectMapper());
-        Map<String, Object> body = new LinkedHashMap<>();
-        body.put("amount", 190); body.put("expectedVersion", 0);
-        Map<String, Object> first = new LinkedHashMap<>();
-        first.put("path", "/settlements/202/transactions"); first.put("method", "POST");
-        first.put("customerId", 10L); first.put("body", body);
-        Map<String, Object> reversedBody = new LinkedHashMap<>();
-        reversedBody.put("expectedVersion", 0); reversedBody.put("amount", 190);
-        Map<String, Object> second = new LinkedHashMap<>();
-        second.put("body", reversedBody); second.put("customerId", 10L);
-        second.put("method", "POST"); second.put("path", "/settlements/202/transactions");
-
-        String original = ReflectionTestUtils.invokeMethod(service, "hash", first);
-        String reordered = ReflectionTestUtils.invokeMethod(service, "hash", second);
-        assertThat(reordered).isEqualTo(original);
-        reversedBody.put("amount", 191);
-        String changed = ReflectionTestUtils.invokeMethod(service, "hash", second);
-        assertThat(changed).isNotEqualTo(original);
-        second.put("customerId", 11L); reversedBody.put("amount", 190);
-        String otherCustomer = ReflectionTestUtils.invokeMethod(service, "hash", second);
-        assertThat(otherCustomer).isNotEqualTo(original);
-    }
-}

finance/src/test/java/com/baiyue/finance/ReconciliationStatementBehaviorTest.java

@@ -70,7 +70,7 @@ class ReconciliationStatementBehaviorTest {
     @Test
     void selectedModeRejectsDuplicateFeeSourcesBeforeWriting() {
         JdbcTemplate jdbc = mock(JdbcTemplate.class);
-        ReconciliationStatementService target = serviceWithNumber(jdbc);
+        ReconciliationStatementService target = new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules());
         CreateReconciliationRequest request = new CreateReconciliationRequest(9L, "CNY", "SELECTED", List.of(88L, 88L),
             LocalDate.of(2026, 8, 1), LocalDate.of(2026, 8, 31), null);
 
@@ -105,7 +105,7 @@ class ReconciliationStatementBehaviorTest {
         var result = target.create(71L, "create-key", request);
 
         assertThat(result.statementId()).isEqualTo(501L);
-        assertThat(result.statementNo()).isEqualTo("REC202608180001");
+        assertThat(result.statementNo()).isEqualTo("REC-260818-0001");
         assertThat(result.currency()).isEqualTo("CNY");
         assertThat(result.createdByName()).isEqualTo("platform_admin");
         assertThat(result.updatedByName()).isEqualTo("platform_admin");
@@ -132,7 +132,7 @@ class ReconciliationStatementBehaviorTest {
         });
         when(jdbc.queryForList(org.mockito.ArgumentMatchers.startsWith("SELECT id,customer_id"), eq(88L)))
             .thenReturn(List.of(Map.of("id", 88L, "customer_id", 10L)));
-        ReconciliationStatementService target = serviceWithNumber(jdbc);
+        ReconciliationStatementService target = new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules());
 
         assertThatThrownBy(() -> target.create(71L, "create-key", new CreateReconciliationRequest(9L, "CNY",
             "SELECTED", List.of(88L), LocalDate.of(2026, 8, 1), LocalDate.of(2026, 8, 31), null)))
@@ -144,7 +144,7 @@ class ReconciliationStatementBehaviorTest {
     @Test
     void submitUsesExpectedVersionAndPersistsRevisionBeforeStateChange() throws Exception {
         JdbcTemplate jdbc = actionJdbc("DRAFT", "PENDING_REVIEW", "submit-key");
-        ReconciliationStatementService target = serviceWithNumber(jdbc);
+        ReconciliationStatementService target = new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules());
 
         var result = target.action(71L, 501L, "submit-key",
             new ReconciliationActionRequest("SUBMIT", "提交审核", 0, List.of()));
@@ -164,7 +164,7 @@ class ReconciliationStatementBehaviorTest {
     @Test
     void approveFreezesInternalBillAndReturnsContractStatus() throws Exception {
         JdbcTemplate jdbc = actionJdbc("PENDING_REVIEW", "APPROVED", "approve-key");
-        ReconciliationStatementService target = serviceWithNumber(jdbc);
+        ReconciliationStatementService target = new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules());
 
         var result = target.action(71L, 501L, "approve-key",
             new ReconciliationActionRequest("APPROVE", "审核通过", 1, List.of()));
@@ -177,7 +177,7 @@ class ReconciliationStatementBehaviorTest {
     @Test
     void issueFreezesSourcesOnlyAfterApproval() throws Exception {
         JdbcTemplate jdbc = actionJdbc("APPROVED", "ISSUED", "issue-key");
-        ReconciliationStatementService target = serviceWithNumber(jdbc);
+        ReconciliationStatementService target = new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules());
 
         var result = target.action(71L, 501L, "issue-key",
             new ReconciliationActionRequest("ISSUE", null, 2, List.of()));
@@ -202,7 +202,7 @@ class ReconciliationStatementBehaviorTest {
             });
         when(jdbc.queryForList(org.mockito.ArgumentMatchers.startsWith("SELECT request_hash"),
             eq(9L), eq(71L), eq("RECONCILIATION_CUSTOMER_CONFIRM"), eq("confirm-key"))).thenReturn(List.of());
-        ReconciliationStatementService target = serviceWithNumber(jdbc);
+        ReconciliationStatementService target = new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules());
 
         var result = target.confirmForCustomer(9L, 71L, 501L, "confirm-key", new CustomerConfirmationRequest(3));
 
@@ -236,7 +236,7 @@ class ReconciliationStatementBehaviorTest {
         JdbcTemplate crossCustomer = mock(JdbcTemplate.class);
         when(crossCustomer.query(org.mockito.ArgumentMatchers.startsWith("SELECT b.*"), any(RowMapper.class), eq(501L), eq(9L)))
             .thenReturn(List.of());
-        assertThatThrownBy(() -> serviceWithNumber(crossCustomer).confirmForCustomer(
+        assertThatThrownBy(() -> new ReconciliationStatementService(crossCustomer, new ObjectMapper()).confirmForCustomer(
             9L, 71L, 501L, "confirm-key", new CustomerConfirmationRequest(3)))
             .isInstanceOf(FinanceEventException.class)
             .extracting(error -> ((FinanceEventException) error).code()).isEqualTo("FIN_404");
@@ -251,7 +251,7 @@ class ReconciliationStatementBehaviorTest {
             });
         when(draft.queryForList(org.mockito.ArgumentMatchers.startsWith("SELECT request_hash"),
             eq(9L), eq(71L), eq("RECONCILIATION_CUSTOMER_CONFIRM"), eq("draft-key"))).thenReturn(List.of());
-        assertThatThrownBy(() -> serviceWithNumber(draft).confirmForCustomer(
+        assertThatThrownBy(() -> new ReconciliationStatementService(draft, new ObjectMapper()).confirmForCustomer(
             9L, 71L, 501L, "draft-key", new CustomerConfirmationRequest(0)))
             .isInstanceOf(FinanceEventException.class)
             .extracting(error -> ((FinanceEventException) error).code()).isEqualTo("FIN_409");
@@ -271,7 +271,7 @@ class ReconciliationStatementBehaviorTest {
             });
         when(stale.queryForList(org.mockito.ArgumentMatchers.startsWith("SELECT request_hash"),
             eq(9L), eq(71L), eq("RECONCILIATION_CUSTOMER_CONFIRM"), eq("stale-key"))).thenReturn(List.of());
-        assertThatThrownBy(() -> serviceWithNumber(stale).confirmForCustomer(
+        assertThatThrownBy(() -> new ReconciliationStatementService(stale, new ObjectMapper()).confirmForCustomer(
             9L, 71L, 501L, "stale-key", new CustomerConfirmationRequest(2)))
             .isInstanceOf(FinanceEventException.class)
             .extracting(error -> ((FinanceEventException) error).code()).isEqualTo("FIN_409");
@@ -288,7 +288,7 @@ class ReconciliationStatementBehaviorTest {
             eq(9L), eq(71L), eq("RECONCILIATION_ACTION"), eq("used-key"))).thenReturn(List.of(Map.of(
             "request_hash", "different-request", "status", "SUCCEEDED", "result_resource_id", 501L,
             "updated_at", LocalDateTime.now())));
-        ReconciliationStatementService target = serviceWithNumber(jdbc);
+        ReconciliationStatementService target = new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules());
 
         assertThatThrownBy(() -> target.action(71L, 501L, "used-key",
             new ReconciliationActionRequest("SUBMIT", "提交审核", 0, List.of())))
@@ -300,7 +300,7 @@ class ReconciliationStatementBehaviorTest {
     @Test
     void invalidActionAndVersionConflictAreRejectedBeforeMutation() throws Exception {
         JdbcTemplate jdbc = actionJdbc("DRAFT", "DRAFT", "invalid-key");
-        ReconciliationStatementService target = serviceWithNumber(jdbc);
+        ReconciliationStatementService target = new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules());
 
         assertThatThrownBy(() -> target.action(71L, 501L, "invalid-key",
             new ReconciliationActionRequest("NOT_AN_ACTION", null, 0, List.of())))
@@ -318,7 +318,7 @@ class ReconciliationStatementBehaviorTest {
         JdbcTemplate jdbc = actionJdbc("ISSUED", "ISSUED", "adjust-key");
         when(jdbc.queryForObject(org.mockito.ArgumentMatchers.startsWith("SELECT COALESCE(SUM(amount)"), eq(BigDecimal.class), eq(9L), eq(501L)))
             .thenReturn(new BigDecimal("280.00"));
-        ReconciliationStatementService target = serviceWithNumber(jdbc);
+        ReconciliationStatementService target = new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules());
 
         target.action(71L, 501L, "adjust-key", new ReconciliationActionRequest("ADJUST", "运费更正", 3,
             List.of(new StatementAdjustmentLineRequest(601L, new BigDecimal("280.00"), "运费更正"))));
@@ -342,7 +342,7 @@ class ReconciliationStatementBehaviorTest {
                 return List.of(mapper.mapRow(rs, 0));
             });
 
-        assertThatThrownBy(() -> serviceWithNumber(jdbc).action(71L, 501L,
+        assertThatThrownBy(() -> new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules()).action(71L, 501L,
             "low-adjust-key", new ReconciliationActionRequest("ADJUST", "金额错误", 3,
                 List.of(new StatementAdjustmentLineRequest(601L, new BigDecimal("80.00"), "金额错误")))))
             .isInstanceOf(FinanceEventException.class)
@@ -355,7 +355,7 @@ class ReconciliationStatementBehaviorTest {
         JdbcTemplate jdbc = actionJdbc("ISSUED", "VOIDED", "void-key");
         when(jdbc.queryForObject(org.mockito.ArgumentMatchers.startsWith("SELECT COUNT(*) FROM fin_receipt_bill"), eq(Long.class), eq(9L), eq(501L))).thenReturn(0L);
         when(jdbc.queryForObject(org.mockito.ArgumentMatchers.startsWith("SELECT COUNT(*) FROM fin_settlement"), eq(Long.class), eq(9L), eq(501L))).thenReturn(0L);
-        ReconciliationStatementService target = serviceWithNumber(jdbc);
+        ReconciliationStatementService target = new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules());
 
         var result = target.action(71L, 501L, "void-key",
             new ReconciliationActionRequest("VOID", "客户重开账期", 3, List.of()));
@@ -372,7 +372,7 @@ class ReconciliationStatementBehaviorTest {
                 .thenReturn("receipt".equals(query) ? 1L : 0L);
             when(jdbc.queryForObject(org.mockito.ArgumentMatchers.startsWith("SELECT COUNT(*) FROM fin_settlement"), eq(Long.class), eq(9L), eq(501L)))
                 .thenReturn("settlement".equals(query) ? 1L : 0L);
-            assertThatThrownBy(() -> serviceWithNumber(jdbc).action(71L, 501L,
+            assertThatThrownBy(() -> new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules()).action(71L, 501L,
                 "void-" + query, new ReconciliationActionRequest("VOID", "作废原因", 3, List.of())))
                 .isInstanceOf(FinanceEventException.class)
                 .extracting(error -> ((FinanceEventException) error).code()).isEqualTo("FIN_409");
@@ -384,7 +384,7 @@ class ReconciliationStatementBehaviorTest {
     void reopenVoidedStatementReacquiresEveryReleasedSource() throws Exception {
         JdbcTemplate jdbc = actionJdbc("VOIDED", "DRAFT", "reopen-key");
         when(jdbc.queryForObject(org.mockito.ArgumentMatchers.startsWith("SELECT COUNT(*) FROM fin_bill_line"), eq(Integer.class), eq(9L), eq(501L))).thenReturn(1);
-        ReconciliationStatementService target = serviceWithNumber(jdbc);
+        ReconciliationStatementService target = new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules());
 
         var result = target.action(71L, 501L, "reopen-key",
             new ReconciliationActionRequest("REOPEN", "重新核对", 4, List.of()));
@@ -399,7 +399,7 @@ class ReconciliationStatementBehaviorTest {
         JdbcTemplate firstJdbc = mock(JdbcTemplate.class, invocation ->
             "update".equals(invocation.getMethod().getName()) ? 1 : RETURNS_DEFAULTS.answer(invocation));
         when(firstJdbc.queryForList(org.mockito.ArgumentMatchers.startsWith("SELECT request_hash"), eq(9L), eq(71L), eq("RECONCILIATION_ACTION"), eq("first-key"))).thenReturn(List.of());
-        ReconciliationStatementService firstService = serviceWithNumber(firstJdbc);
+        ReconciliationStatementService firstService = new ReconciliationStatementService(firstJdbc, new ObjectMapper().findAndRegisterModules());
 
         Long first = ReflectionTestUtils.invokeMethod(firstService, "reserve", 9L, 71L, "RECONCILIATION_ACTION", "first-key", "POST", "/statements/501/actions", body);
         ArgumentCaptor<String> hash = ArgumentCaptor.forClass(String.class);
@@ -412,7 +412,7 @@ class ReconciliationStatementBehaviorTest {
             .thenReturn(List.of(Map.of("request_hash", hash.getValue(), "status", "SUCCEEDED",
                 "result_resource_id", 501L, "updated_at", LocalDateTime.now())));
         assertThat((Long) ReflectionTestUtils.invokeMethod(
-            serviceWithNumber(replayJdbc),
+            new ReconciliationStatementService(replayJdbc, new ObjectMapper().findAndRegisterModules()),
             "reserve", 9L, 71L, "RECONCILIATION_ACTION", "replay-key", "POST", "/statements/501/actions", body))
             .isEqualTo(501L);
 
@@ -420,7 +420,7 @@ class ReconciliationStatementBehaviorTest {
         when(processingJdbc.queryForList(org.mockito.ArgumentMatchers.startsWith("SELECT request_hash"), eq(9L), eq(71L), eq("RECONCILIATION_ACTION"), eq("processing-key")))
             .thenReturn(List.of(Map.of("request_hash", hash.getValue(), "status", "PROCESSING", "updated_at", LocalDateTime.now())));
         assertThatThrownBy(() -> ReflectionTestUtils.invokeMethod(
-            serviceWithNumber(processingJdbc),
+            new ReconciliationStatementService(processingJdbc, new ObjectMapper().findAndRegisterModules()),
             "reserve", 9L, 71L, "RECONCILIATION_ACTION", "processing-key", "POST", "/statements/501/actions", body))
             .isInstanceOf(FinanceEventException.class)
             .extracting(error -> ((FinanceEventException) error).code()).isEqualTo("FIN_409");
@@ -431,7 +431,7 @@ class ReconciliationStatementBehaviorTest {
             .thenReturn(List.of(Map.of("request_hash", hash.getValue(), "status", "FAILED", "updated_at", LocalDateTime.now())));
         when(recoveryJdbc.queryForList(org.mockito.ArgumentMatchers.startsWith("SELECT request_hash"), eq(9L), eq(71L), eq("RECONCILIATION_ACTION"), eq("stale-key")))
             .thenReturn(List.of(Map.of("request_hash", hash.getValue(), "status", "PROCESSING", "updated_at", LocalDateTime.now().minusMinutes(10))));
-        ReconciliationStatementService recoveryService = serviceWithNumber(recoveryJdbc);
+        ReconciliationStatementService recoveryService = new ReconciliationStatementService(recoveryJdbc, new ObjectMapper().findAndRegisterModules());
 
         assertThat((Long) ReflectionTestUtils.invokeMethod(recoveryService, "reserve", 9L, 71L, "RECONCILIATION_ACTION", "failed-key", "POST", "/statements/501/actions", body)).isNull();
         assertThat((Long) ReflectionTestUtils.invokeMethod(recoveryService, "reserve", 9L, 71L, "RECONCILIATION_ACTION", "stale-key", "POST", "/statements/501/actions", body)).isNull();
@@ -556,7 +556,7 @@ class ReconciliationStatementBehaviorTest {
         ResultSet rs = mock(ResultSet.class);
         when(rs.getLong("id")).thenReturn(501L);
         when(rs.getLong("tenant_id")).thenReturn(9L);
-        when(rs.getString("bill_no")).thenReturn("REC202608180001");
+        when(rs.getString("bill_no")).thenReturn("REC-260818-0001");
         when(rs.getString("customer_name_snapshot")).thenReturn("客户9");
         when(rs.getString("status")).thenReturn(status);
         when(rs.getBigDecimal("total_amount")).thenReturn(new BigDecimal("300.00"));
@@ -591,7 +591,7 @@ class ReconciliationStatementBehaviorTest {
 
     private static ReconciliationStatementService serviceWithNumber(JdbcTemplate jdbc) {
         FinanceDocumentNumberGenerator documentNumbers = mock(FinanceDocumentNumberGenerator.class);
-        org.mockito.Mockito.lenient().when(documentNumbers.next("REC")).thenReturn("REC202608180001");
+        org.mockito.Mockito.lenient().when(documentNumbers.next("REC")).thenReturn("REC-260818-0001");
         return new ReconciliationStatementService(jdbc, new ObjectMapper().findAndRegisterModules(), documentNumbers);
     }
 }

finance/src/test/java/com/baiyue/finance/repository/DocumentSequenceRepositoryTest.java

@@ -1,76 +0,0 @@
-package com.baiyue.finance.repository;
-
-import com.baiyue.finance.mapper.DocumentSequenceMapper;
-import com.baomidou.mybatisplus.core.MybatisConfiguration;
-import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
-import org.junit.jupiter.api.Test;
-import org.mybatis.spring.SqlSessionTemplate;
-import org.springframework.aop.framework.ProxyFactory;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.datasource.*;
-import org.springframework.transaction.annotation.AnnotationTransactionAttributeSource;
-import org.springframework.transaction.interceptor.TransactionInterceptor;
-import org.springframework.transaction.support.TransactionTemplate;
-import java.util.*;
-import java.util.concurrent.*;
-import static org.assertj.core.api.Assertions.*;
-
-/** 实际 Mapper 和隔离 H2 MySQL 模式验证原子序列，不访问部署环境。 */
-class DocumentSequenceRepositoryTest {
-    private static class Fixture {
-        final JdbcTemplate jdbc;
-        final DataSourceTransactionManager transactions;
-        final DocumentSequenceMapper mapper;
-        final DocumentSequenceRepository repository;
-        /** 仅测试造表允许 JDBC；被测路径全部使用 Mapper。 */
-        Fixture() throws Exception {
-            var data=new DriverManagerDataSource("jdbc:h2:mem:"+UUID.randomUUID()+";MODE=MySQL;DB_CLOSE_DELAY=-1;LOCK_TIMEOUT=10000","sa","");
-            jdbc=new JdbcTemplate(data);transactions=new DataSourceTransactionManager(data);
-            jdbc.execute("CREATE TABLE fin_document_sequence(sequence_key VARCHAR(32) PRIMARY KEY,current_value BIGINT NOT NULL)");
-            var configuration=new MybatisConfiguration();configuration.addMapper(DocumentSequenceMapper.class);
-            var factory=new MybatisSqlSessionFactoryBean();factory.setDataSource(data);factory.setConfiguration(configuration);factory.afterPropertiesSet();
-            mapper=new SqlSessionTemplate(factory.getObject()).getMapper(DocumentSequenceMapper.class);
-            var proxy=new ProxyFactory(new DocumentSequenceRepository(mapper));proxy.setProxyTargetClass(true);
-            proxy.addAdvice(new TransactionInterceptor(transactions,new AnnotationTransactionAttributeSource()));
-            repository=(DocumentSequenceRepository)proxy.getProxy();
-        }
-    }
-    /** 日期和前缀各自独立，重复分配持续递增。 */
-    @Test void dateAndPrefixHaveIndependentSequences() throws Exception {
-        var f=new Fixture();
-        assertThat(f.repository.next("AA:20261020")).isEqualTo(1);
-        assertThat(f.repository.next("AA:20261020")).isEqualTo(2);
-        assertThat(f.repository.next("BB:20261020")).isEqualTo(1);
-        assertThat(f.repository.next("AA:20261021")).isEqualTo(1);
-    }
-    /** 两个线程使用真实事务连接并发争用，不能产生重号。 */
-    @Test void concurrentConnectionsAllocateUniqueNumbers() throws Exception {
-        var f=new Fixture();var pool=Executors.newFixedThreadPool(2);
-        try {
-            var work=new ArrayList<Callable<Long>>();
-            for(int i=0;i<64;i++)work.add(()->f.repository.next("AA:20261020"));
-            var values=new TreeSet<Long>();
-            for(var future:pool.invokeAll(work))values.add(future.get());
-            assertThat(values).hasSize(64);assertThat(values.first()).isEqualTo(1L);assertThat(values.last()).isEqualTo(64L);
-        } finally {pool.shutdownNow();}
-    }
-    /** 外层建单失败后不能把已经分配的单号再交给其他单据。 */
-    @Test void businessRollbackDoesNotReuseAllocatedNumber() throws Exception {
-        var f=new Fixture();
-        assertThatThrownBy(()->new TransactionTemplate(f.transactions).execute(status->{
-            assertThat(f.repository.next("AA:20261020")).isEqualTo(1);
-            throw new IllegalStateException("业务回滚");
-        })).isInstanceOf(IllegalStateException.class);
-        assertThat(f.repository.next("AA:20261020")).isEqualTo(2);
-    }
-    /** 同一会话中连接值变化后，读取必须绕过 MyBatis 缓存。 */
-    @Test void connectionResultIsNeverCached() throws Exception {
-        var f=new Fixture();
-        new TransactionTemplate(f.transactions).executeWithoutResult(status->{
-            f.jdbc.queryForObject("SELECT LAST_INSERT_ID(7)",Long.class);
-            assertThat(f.mapper.allocatedValue()).isEqualTo(7L);
-            f.jdbc.queryForObject("SELECT LAST_INSERT_ID(37)",Long.class);
-            assertThat(f.mapper.allocatedValue()).isEqualTo(37L);
-        });
-    }
-}

finance/src/test/java/com/baiyue/finance/service/FinanceDocumentNumberGeneratorTest.java

@@ -1,41 +1,70 @@
 package com.baiyue.finance.service;
 
-import com.baiyue.finance.repository.DocumentSequenceRepository;
-import com.baiyue.common.core.exception.BizException;
 import org.junit.jupiter.api.Test;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
-import java.time.*;
+import org.springframework.jdbc.core.JdbcTemplate;
-import static org.assertj.core.api.Assertions.*;
+
-import static org.mockito.Mockito.*;
+import java.time.Clock;
+import java.time.Instant;
+import java.time.ZoneId;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 class FinanceDocumentNumberGeneratorTest {
-    private static final Clock CLOCK=Clock.fixed(Instant.parse("2026-10-19T16:00:00Z"),ZoneOffset.UTC);
+    private static final Clock CLOCK = Clock.fixed(
+        Instant.parse("2026-08-18T02:00:00Z"), ZoneId.of("Asia/Shanghai"));
+
+    @Test
+    void startsAsASpringBeanWhenTheTestClockConstructorAlsoExists() {
+        JdbcTemplate jdbc = mock(JdbcTemplate.class);
+        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
+            context.registerBean(JdbcTemplate.class, () -> jdbc);
+            context.register(FinanceDocumentNumberGenerator.class);
+            context.refresh();
 
-    /** 多构造器情况下正式依赖可以被 Spring 正确选择。 */
-    @Test void springCreatesGeneratorWithRepository() {
-        try(var context=new AnnotationConfigApplicationContext()) {
-            context.registerBean(DocumentSequenceRepository.class,()->mock(DocumentSequenceRepository.class));
-            context.register(FinanceDocumentNumberGenerator.class);context.refresh();
             assertThat(context.getBean(FinanceDocumentNumberGenerator.class)).isNotNull();
         }
     }
-    /** 主机使用 UTC 时仍按北京时间跨午夜，且四位流水不截断。 */
+
-    @Test void usesShanghaiDateAndIndependentSequenceKey() {
+    @Test
-        var sequences=mock(DocumentSequenceRepository.class);
+    void formatsShortDailySequenceForAllThreeDocuments() {
-        when(sequences.next("REC:20261020")).thenReturn(1L,2L,9999L);
+        JdbcTemplate jdbc = mock(JdbcTemplate.class);
-        var numbers=new FinanceDocumentNumberGenerator(sequences,CLOCK);
+        when(jdbc.queryForObject("SELECT LAST_INSERT_ID()", Long.class)).thenReturn(1L, 2L, 38L);
-        assertThat(numbers.next("REC")).isEqualTo("REC202610200001");
+        FinanceDocumentNumberGenerator generator = new FinanceDocumentNumberGenerator(jdbc, CLOCK);
-        assertThat(numbers.next("REC")).isEqualTo("REC202610200002");
+
-        assertThat(numbers.next("REC")).isEqualTo("REC202610209999");
+        assertThat(generator.next("REC")).isEqualTo("REC-260818-0001");
-        verify(sequences,times(3)).next("REC:20261020");
+        assertThat(generator.next("AR")).isEqualTo("AR-260818-0002");
+        assertThat(generator.next("AP")).isEqualTo("AP-260818-0038");
+
+        verify(jdbc).update(org.mockito.ArgumentMatchers.startsWith("INSERT INTO fin_document_sequence"),
+            eq("REC:20260818"));
     }
-    /** 未登记类型不能消耗流水，分配异常或溢出时拒绝出号。 */
+
-    @Test void rejectsUnknownTypeAndOverflow() {
+    @Test
-        var sequences=mock(DocumentSequenceRepository.class);
+    void rejectsUnsupportedTypeAndOverflow() {
-        var numbers=new FinanceDocumentNumberGenerator(sequences,CLOCK);
+        JdbcTemplate jdbc = mock(JdbcTemplate.class);
-        assertThatThrownBy(()->numbers.next("ZZZZ")).isInstanceOf(IllegalArgumentException.class);
+        FinanceDocumentNumberGenerator generator = new FinanceDocumentNumberGenerator(jdbc, CLOCK);
-        verifyNoInteractions(sequences);
+        assertThatThrownBy(() -> generator.next("PAY")).isInstanceOf(IllegalArgumentException.class);
-        when(sequences.next("REC:20261020")).thenReturn(10000L);
+
-        assertThatThrownBy(()->numbers.next("REC")).isInstanceOf(BizException.class);
+        when(jdbc.queryForObject("SELECT LAST_INSERT_ID()", Long.class)).thenReturn(10_000L);
+        assertThatThrownBy(() -> generator.next("REC"))
+            .isInstanceOf(FinanceEventException.class)
+            .extracting(error -> ((FinanceEventException) error).code()).isEqualTo("FIN_409");
+    }
+
+    @Test
+    void vehicleCostsAndPaymentsUseIndependentSequenceKeys() {
+        JdbcTemplate jdbc = mock(JdbcTemplate.class);
+        when(jdbc.queryForObject("SELECT LAST_INSERT_ID()", Long.class)).thenReturn(1L);
+        FinanceDocumentNumberGenerator generator = new FinanceDocumentNumberGenerator(jdbc, CLOCK);
+        assertThat(generator.next("VC")).isEqualTo("VC-260818-0001");
+        assertThat(generator.next("VP")).isEqualTo("VP-260818-0001");
+        verify(jdbc).update(org.mockito.ArgumentMatchers.startsWith("INSERT INTO fin_document_sequence"), eq("VC:20260818"));
+        verify(jdbc).update(org.mockito.ArgumentMatchers.startsWith("INSERT INTO fin_document_sequence"), eq("VP:20260818"));
     }
 }

firstleg/docs/business-index.md

@@ -57,7 +57,7 @@
 | 直送目的仓实际卸货 | `terminaldrayage/controller/PlatformDirectDeliveryController.java`、`service/DirectDeliveryService.java`、`UnloadingEvidenceGuard.java`；按实装入仓来源逐票记录签收人与凭据，必须经 Lastleg 确认 DIRECT 路线且已提柜；不创建海外库存，全柜卸毕才可人工还空；契约 `src/main/resources/openapi/direct-delivery-v1.yaml`，基线 `src/main/resources/db/phase3-direct-delivery-schema.sql` |
 | 目的港码头拖车与还空预警 | `terminaldrayage/controller/PlatformTerminalDrayageController.java`、`service/TerminalDrayageService.java`、`mapper/TerminalDrayageMapper.java`；货柜实际到港后引用 Warehouse `ACTIVE/TRUCKING/OVERSEAS` 海外车队供应商，依次选择车队、预约提柜、确认实际提柜，海外仓卸柜或全部直送目的仓实际卸货完成后确认还柜；服务端按卸柜完成时间加 72 小时返回报空预警，实际提柜和还柜通过现有 `CarrierScheduleQueryService` 推进 `PICKED_UP/EMPTY_RETURNED`，不复制船节点或车队主档。契约 `src/main/resources/openapi/terminal-drayage-v1.yaml`，基线 `src/main/resources/db/phase3-terminal-drayage-schema.sql` 邮件由 `terminaldrayage/service/TerminalDrayageMailService.java` 入队，`TerminalDrayageMailDispatcher.java` 顺序投递，模板与 SMTP 配置见 `docs/terminal-drayage-mail.md`；首次选队不发信，换队事务内生成取消与请求两封邮件。 |
 | 船节点交接事件 | `portschedule/service/CarrierScheduleNodeOutboxService.java`；实际节点落库后按 `containerBookingId` 柜级发布 `FIRST_LEG_CONTAINER_SHIPPING_NODE_RECORDED` V1，信封固定使用 `tenantId=0` 平台技术范围且 Payload 不携带客户，复用 `LoadingCompletedOutboxRepository`/Relay 直投 Lastleg `/internal/lastleg/events`；消费见 `../lastleg-service/src/main/java/com/baiyue/lastleg/shipping/service/ContainerShippingNodeConsumer.java`，ACK/重试按 `../../docs/统一认证与服务通信契约.md` |
-| Firstleg 业务单据编号 | `service/FirstlegDocumentNumberGenerator.java`；前缀与生成规则见 `../../../docs/业务单据编号契约.md`，柜次及实物标签规则保持不变 |
+| Firstleg 业务单据编号 | `service/FirstlegDocumentNumberGenerator.java`；当前支持 `OB`、`TA`、`CB`、`CAB`、`LP` 前缀，按北京时间每日独立编号；具体业务归属以各调用服务为准 |
 | 订舱级拖车与整柜出仓调度 | `controller/PlatformTruckAppointmentController.java` 的 `/candidates`、`service/TruckAppointmentService.java`、`repository/TruckAppointmentRepository.java`、`outbound/dispatch/controller/PlatformOutboundDispatchController.java`；拖车契约 `src/main/resources/openapi/truck-appointments-v1.yaml`。预约只绑定 `RELEASED` 订舱，候选排除缺提单/有效订舱文件或已有非终态预约的订舱；API 不含客户、柜次、装柜计划或真实柜号，每订舱最多一张有效预约，已有完成单不得重建收费；PDA 完成不推进拖车状态，全部要求货柜确认国内离仓后由 `TruckAppointmentCompletionService` 自动完成并经 `TruckAppointmentFeeService` 发布应付 |
 | 整柜出口报关 | `customs/container/controller/PlatformContainerCustomsController.java`、`customs/container/controller/MerchantContainerCustomsController.java`、`customs/container/service/ContainerCustomsService.java`、`customs/container/mapper/ContainerCustomsMapper.java`；装柜完成后按柜收集退税资料，多对多覆盖入仓码，开始报关冻结，完成文件逐资料一对一回传，全买单柜由平台确认并通过导出中心取明细；正式申报批次与海关结果在同一模块独立记录，不改报关四态、PDA 或船期事实；契约 `src/main/resources/openapi/customs-v1.yaml`，基线 `src/main/resources/db/phase3-container-customs-schema.sql`；消费者为 Admin `../../apps/admin-web/src/modules/container-loading/components/ContainerCustomsPanel.vue` 和 Client `../../apps/client-web/src/modules/first-leg/components/CustomsDocumentsDialog.vue` |
 | 买单订单明细导出 Provider | `customs/container/controller/LoadingListBuyDeclarationExportController.java`、`service/LoadingListBuyDeclarationExportService.java`；只为 File 导出中心提供 `LOADING_LIST_BUY_DECLARATION_ITEMS` 的已完成装柜实际买单行，不在 Firstleg 生成文件 |
@@ -81,7 +81,7 @@
 - Order 渠道变更门禁必须检查装柜或后续状态、PDA task、预装、分柜及同柜组兼容性；任何不确定结果均失败关闭。`ORDER_DECLARATION_UPDATED_V1` 消费必须校验订单号/入仓码归属，永久保留 `eventId + payload hash` 幂等历史并按版本单调更新申报投影；不得覆盖仓库实测、箱码、测量审核或已确认费用。
 - 订舱状态固定为 `DRAFT → RELEASED`：草稿允许资料不完整并可替换或删除，放舱时校验完整持久化聚合，放舱后永久只读。创建草稿和放舱都只维护订舱聚合、三类参与方及柜型需求，不创建真实 `containerNo`、货柜行或分配关系；真实货柜只在后续提柜关联时占用已放舱柜型需求。
 - 订舱柜型需求至少一项、最多 20 项，数量必须为正整数，容量和限重必须匹配平台柜型规格。起运仓必须是启用的国内中转仓；物流渠道必须来自该仓当前 ACTIVE 价格版本，服务端保存渠道名称快照，渠道失效时失败关闭。
-- 订舱号遵循 `../../../docs/业务单据编号契约.md`；不得以实体 ID 拼接生成。提单号在订舱主表全局唯一，柜次表只保存快照；真实集装箱号只在同一订舱内唯一，不同提单允许复用。放舱不要求真实柜号，也不得为满足放舱校验伪造柜号。
+- 订舱号统一使用 `OB-yyMMdd-####`，按北京时间创建日每日独立递增且单日最多 9999；不得以实体 ID 拼接生成。提单号在订舱主表全局唯一，柜次表只保存快照；真实集装箱号只在同一订舱内唯一，不同提单允许复用。放舱不要求真实柜号，也不得为满足放舱校验伪造柜号。
 - 订舱列表 `containerCount` 固定为该订舱全部柜型需求 `quantity` 之和，与真实柜关联/解除无关；关联候选只返回 `RELEASED`、剩余数量大于 0 且 `warehouseId + channelCode + containerType` 精确匹配的需求，由服务端集合查询 ACTIVE 分配量。前端不得扇出详情计算或用已关联柜数覆盖该字段，最终关联命令仍须重验目标货柜可修改性。
 - 拖车预约是平台级订舱聚合，不是客户或柜次资源：请求、实体、查询、响应和附件不得恢复 `customerId/customerName`，公开 DTO 也不得出现 `containerBookingId/loadingPlanId/cabinetNo/containerNo`。创建候选只返回有提单号、ACTIVE `BOOKING_CONFIRMATION` 或 `BILL_OF_LADING` 且没有非终态拖车单的 `RELEASED` 订舱；创建或编辑只冻结订舱仓库/提单与 TRUCKING/DOMESTIC 国内拖车供应商快照。每订舱通过查询锁与唯一约束最多一张非终态预约，重复创建返回现有派车单号；PDA 装柜完成不得改变拖车状态；只有订舱全部柜型需求均已关联且每柜全部入仓绑定确认国内离仓，才自动完成（含草稿/晚提交）。离仓、拖车创建/编辑/操作统一先锁订舱，完成状态、`AUTO_COMPLETE` 历史、按实装体积守恒分摊的柜次应付及 Finance Outbox 同事务落库；取消/异常单不自动恢复，已有有效或完成单不得重复创建。应付拖车费仅人民币 RMB（财务快照为 CNY），固定使用 `FEE_TYPE_108`，关联 ACTIVE/TRUCKING/DOMESTIC 供应商，零金额不生成费用；正金额缺归属、有效体积或费用配置时失败关闭，不丢费、不伪造均分。手工 DEPART/COMPLETE 动作已移除。附件使用 `tenantId=0 + TRUCK_APPOINTMENT_ATTACHMENT + appointmentId`，提单文件继续归订舱。
 - 海外仓业务船节点任务从确认柜子离开国内仓库后启用，必须绑定真实订舱和柜次；十个标准节点、预计/实际时间、异常事实、供应商缺失节点和还柜停止规则统一以 `../../docs/海外仓业务/船节点标准化契约.md` 为准。`CarrierScheduleQuery` 的正常业务查询槽位固定为 `Asia/Shanghai` 每日 09:00、12:30、16:00；每分钟任务只扫描已到期 `next_allowed_at`，不是每分钟请求船司。成功、无变化、需人工或永久失败进入下一固定槽位；仅技术性 `RETRYABLE_FAILURE` 在当前槽内按15/30分钟退避，含首次最多3次且不得跨下一槽，实际 `EMPTY_RETURNED` 后停止。错过的正常槽位直接顺延，不在服务恢复时补跑；单轮按受控批次持续领取并受最大任务数保护。租约、调度尝试和内部停止入口不得暴露为平台页面 API，外部失败不得推进业务节点，不得在国内货柜履约另建查询任务。

firstleg/src/main/java/com/baiyue/firstleg/customs/container/dto/ContainerCustomsDtos.java

@@ -56,6 +56,7 @@ public final class ContainerCustomsDtos {
                                       String remark, List<ClearanceResultView> results) {}
 
     public record DeclarationBatchRequest(@Min(0) int expectedVersion,
+                                          @Size(max = 64) String batchNo,
                                           @Size(max = 64) String customsEntryNo,
                                           @Size(max = 500) String remark) {}
 

firstleg/src/main/java/com/baiyue/firstleg/customs/container/service/ContainerCustomsService.java

@@ -29,8 +29,6 @@ import java.util.stream.Collectors;
 
 @Service
 public class ContainerCustomsService {
-    @jakarta.annotation.Resource private com.baiyue.firstleg.service.FirstlegDocumentNumberGenerator documentNumbers;
-
     public static final String WAITING = "WAITING_CUSTOMER_DOCUMENTS";
     public static final String READY = "READY_TO_START";
     public static final String DECLARING = "DECLARING";
@@ -181,7 +179,6 @@ public class ContainerCustomsService {
         return platformView(planId);
     }
 
-    /** 首次发送报关资料时生成 BR 批次号，重放沿用已有批次。 */
     @Transactional
     public ContainerView sendInitialToBroker(long planId, long operatorId, String operatorName, String key,
                                              ActionRequest request) {
@@ -200,7 +197,7 @@ public class ContainerCustomsService {
             throw conflict("报关资料尚未全部冻结，不能发送给报关行");
         }
         long submissionId = IdWorker.getId();
-        String batchNo = documentNumbers.next("BR");
+        String batchNo = brokerBatchNo(planId);
         String snapshot = brokerSubmissionSnapshot(container.id());
         if (mapper.insertBrokerSubmission(submissionId, container.id(), planId, batchNo, container.version(), snapshot,
             operatorId, operatorName) != 1) throw conflict("首次发送报关行批次创建失败");
@@ -359,12 +356,11 @@ public class ContainerCustomsService {
         return mapper.declarationBatches(container.id()).stream().map(this::declarationBatchView).toList();
     }
 
-    /** 首次创建分配独立申报批次号，重复命令返回已创建批次。 */
     @Transactional
     public DeclarationBatchView createDeclarationBatch(long planId, long operatorId, String operatorName,
                                                         String key, DeclarationBatchRequest request) {
         String action = "CREATE_CUSTOMS_DECLARATION_BATCH_" + planId;
-        String requestHash = hash(action, request.expectedVersion(), request.remark());
+        String requestHash = hash(action, request.expectedVersion(), request.batchNo(), request.remark());
         CommandRow replay = claim(operatorId, action, key, requestHash);
         if (replay != null) return declarationBatchView(mapper.declarationBatch(replay.resultId()));
         ContainerRow container = mapper.lockContainer(planId);
@@ -375,8 +371,8 @@ public class ContainerCustomsService {
         }
         if (!Objects.equals(container.version(), request.expectedVersion())) throw concurrent();
         long batchId = IdWorker.getId();
-        // 申报批次号由服务端分配，外部报关单号独立保存在 customsEntryNo。
+        String batchNo = trim(request.batchNo());
-        String batchNo = documentNumbers.next("DECL");
+        if (batchNo == null) batchNo = "DECL-" + batchId;
         String snapshot = declarationSnapshot(container.id());
         if (mapper.insertDeclarationBatch(batchId, container.id(), planId, batchNo, container.version(), snapshot,
             trim(request.remark())) != 1) throw conflict("正式申报批次创建失败");
@@ -385,20 +381,20 @@ public class ContainerCustomsService {
         return declarationBatchView(mapper.declarationBatch(batchId));
     }
 
-    /** 提交只回填外部报关单号，内部批次号保持创建时的值。 */
     @Transactional
     public DeclarationBatchView submitDeclarationBatch(long batchId, long operatorId, String operatorName,
                                                         String key, DeclarationBatchRequest request) {
         String action = "SUBMIT_CUSTOMS_DECLARATION_BATCH_" + batchId;
         String entryNo = trim(request.customsEntryNo());
         if (entryNo == null) throw bad("正式申报必须回填报关单号");
-        String requestHash = hash(action, request.expectedVersion(), entryNo, request.remark());
+        String requestHash = hash(action, request.expectedVersion(), request.batchNo(), entryNo, request.remark());
         CommandRow replay = claim(operatorId, action, key, requestHash);
         if (replay != null) return declarationBatchView(mapper.declarationBatch(batchId));
         DeclarationBatchRow batch = mapper.lockDeclarationBatch(batchId);
         if (batch == null || !"READY".equals(batch.status())) throw conflict("正式申报批次不在可提交状态");
         if (!Objects.equals(batch.version(), request.expectedVersion())) throw concurrent();
-        String batchNo = batch.batchNo();
+        String batchNo = trim(request.batchNo());
+        if (batchNo == null) batchNo = batch.batchNo();
         if (mapper.submitDeclarationBatch(batchId, batch.version(), batchNo, entryNo, operatorId, operatorName,
             trim(request.remark())) != 1) throw concurrent();
         ContainerRow container = mapper.lockContainerById(batch.customsContainerId());
@@ -505,6 +501,14 @@ public class ContainerCustomsService {
         catch (JsonProcessingException ex) { throw new IllegalStateException(ex); }
     }
 
+    private String brokerBatchNo(long planId) {
+        PlanRow plan = requiredPlan(planId);
+        String planNo = trim(plan.planNo());
+        if (planNo != null && planNo.matches("[A-Za-z0-9_-]{1,52}")) return "BR-" + planNo + "-01";
+        String suffix = UUID.randomUUID().toString().replace("-", "").substring(0, 8).toUpperCase(Locale.ROOT);
+        return "BR-" + LocalDate.now() + "-" + suffix;
+    }
+
     private String brokerSubmissionSnapshot(long containerId) {
         List<Map<String,Object>> snapshot = mapper.documents(containerId, null).stream().map(document -> {
             List<ScopeRow> scopes = mapper.frozenScopes(document.id());

firstleg/src/main/java/com/baiyue/firstleg/loading/coload/controller/PlatformColoadGroupController.java

@@ -67,11 +67,10 @@ public class PlatformColoadGroupController {
             idempotencyKey, user.userId(), user.username()));
     }
 
-    /** 按入仓码返回同柜组业务编号及当前有效成员，保留平台只读权限边界。 */
     @GetMapping("/by-inbound-code/{inboundCode}")
     @PreAuthorize("hasAuthority('platform:firstleg:smart-loading:list')")
     @Operation(summary = "按入仓码查询同柜组业务摘要",
-        description = "返回真实业务组号、业务状态、有效成员数及去重后的全部成员入仓码；不返回内部组ID。")
+        description = "仅返回业务状态、有效成员数及去重后的全部成员入仓码；内部组ID和组号不作为页面识别键。")
     public ApiResponse<BusinessSummary> byInboundCode(
         @AuthenticationPrincipal AuthenticatedUser user,
         @PathVariable @Size(min = 1, max = 40) String inboundCode) {

firstleg/src/main/java/com/baiyue/firstleg/loading/coload/model/ColoadGroupModels.java

@@ -71,7 +71,6 @@ public final class ColoadGroupModels {
 
     /** 页面只读业务摘要；内部组标识不作为用户识别键。 */
     public record BusinessSummary(
-        String groupNo,
         String status,
         int memberCount,
         List<BusinessMember> members

firstleg/src/main/java/com/baiyue/firstleg/loading/coload/persistence/ColoadGroupMapper.java

@@ -108,7 +108,7 @@ public interface ColoadGroupMapper {
                                   @Param("inboundId") long inboundId);
 
     @Select("""
-        SELECT DISTINCT group_row.id groupId,group_row.group_no groupNo,group_row.group_status groupStatus
+        SELECT DISTINCT group_row.id groupId,group_row.group_status groupStatus
           FROM fl_inbound_order requested
           JOIN fl_coload_group_member member
             ON member.tenant_id=requested.tenant_id AND member.inbound_id=requested.id

firstleg/src/main/java/com/baiyue/firstleg/loading/coload/persistence/ColoadGroupQueryRepository.java

@@ -1,20 +0,0 @@
-package com.baiyue.firstleg.loading.coload.persistence;
-
-import org.springframework.stereotype.Repository;
-import java.util.List;
-
-/** 平台同柜组摘要的只读数据访问，保留原入仓片段和组状态范围。 */
-@Repository
-public class ColoadGroupQueryRepository {
-    private final ColoadGroupMapper mapper;
-    /** 注入同服务持久化入口。 */
-    public ColoadGroupQueryRepository(ColoadGroupMapper mapper) { this.mapper = mapper; }
-    /** 按业务入仓码查询当前组及其真实业务组号。 */
-    public List<ColoadPersistenceRows.InboundGroupLookupRow> groupsByInboundCode(String code) {
-        return mapper.groupsByInboundCode(code);
-    }
-    /** 读取被冻结的成员，交由服务核对缺失和重复片段。 */
-    public List<ColoadPersistenceRows.MemberCodeRow> effectiveMemberCodes(long groupId) {
-        return mapper.effectiveMemberCodes(groupId);
-    }
-}

firstleg/src/main/java/com/baiyue/firstleg/loading/coload/persistence/ColoadPersistenceRows.java

@@ -59,7 +59,6 @@ public final class ColoadPersistenceRows {
     @Setter
     public static class InboundGroupLookupRow {
         private Long groupId;
-        private String groupNo;
         private String groupStatus;
     }
 

firstleg/src/main/java/com/baiyue/firstleg/loading/coload/service/ColoadGroupService.java

@@ -38,8 +38,6 @@ import java.util.Set;
 /** 同柜不可拆组的唯一状态机与平台编排服务。 */
 @Service
 public class ColoadGroupService implements ColoadGroupAssignmentPort {
-    @jakarta.annotation.Resource private com.baiyue.firstleg.service.FirstlegDocumentNumberGenerator documentNumbers;
-
     private static final Set<String> CURRENT_GROUP_STATUSES = Set.of("ACTIVE", "LOCKED", "CONSUMED");
     private static final Set<String> PRE_LOADING_GROUP_STATUSES = Set.of(
         "PREPARING", "WAIT_MEASURE", "MEASURING", "MEASURE_PENDING", "MEASURE_REJECTED",
@@ -47,8 +45,6 @@ public class ColoadGroupService implements ColoadGroupAssignmentPort {
 
     @Resource
     private ColoadGroupMapper mapper;
-    @Resource
-    private com.baiyue.firstleg.loading.coload.persistence.ColoadGroupQueryRepository queryRepository;
     @Resource private PendingReviewOrderClient pendingReviewOrders;
     @Resource private OrderCargoClient orderCargoClient;
     @Resource private InboundOrderCreationService inboundOrderCreationService;
@@ -68,7 +64,7 @@ public class ColoadGroupService implements ColoadGroupAssignmentPort {
         validateSameRoute(candidates);
         Long lockedPlanId = validateAllocationState(candidates);
         long groupId = IdWorker.getId();
-        String groupNo = documentNumbers.next("CLG");
+        String groupNo = "CLG-" + groupId;
         InboundCandidateRow first = candidates.get(0);
         mapper.insertGroup(groupId, groupNo, first.getWarehouseId(), first.getChannelCode().trim(),
             operatorId, trim(operatorName));
@@ -120,11 +116,10 @@ public class ColoadGroupService implements ColoadGroupAssignmentPort {
         return requiredSnapshot(groupId);
     }
 
-    /** 以入仓码读取同柜组业务号及全部有效成员，不返回内部组ID。 */
     @Transactional(readOnly = true)
     public BusinessSummary queryByInboundCode(String inboundCode) {
         String code = normalizedInboundCode(inboundCode);
-        var groups = queryRepository.groupsByInboundCode(code).stream()
+        var groups = mapper.groupsByInboundCode(code).stream()
             .filter(row -> row.getGroupId() != null && CURRENT_GROUP_STATUSES.contains(row.getGroupStatus()))
             .toList();
         long distinctGroups = groups.stream().map(row -> row.getGroupId()).distinct().limit(2).count();
@@ -134,7 +129,7 @@ public class ColoadGroupService implements ColoadGroupAssignmentPort {
         if (distinctGroups > 1) throw conflict("入仓码关联多个有效同柜不可拆组");
         long groupId = groups.get(0).getGroupId();
         String status = groups.get(0).getGroupStatus();
-        var memberRows = queryRepository.effectiveMemberCodes(groupId);
+        var memberRows = mapper.effectiveMemberCodes(groupId);
         if (memberRows.isEmpty()) throw conflict("同柜不可拆组不存在有效入仓片段");
         if (memberRows.stream().anyMatch(row -> row.getMemberId() == null || row.getInboundId() == null
             || trim(row.getInboundCode()) == null)) {
@@ -145,7 +140,7 @@ public class ColoadGroupService implements ColoadGroupAssignmentPort {
             throw conflict("同柜不可拆组存在重复入仓片段业务号");
         }
         List<BusinessMember> members = inboundCodes.stream().sorted().map(BusinessMember::new).toList();
-        return new BusinessSummary(groups.get(0).getGroupNo(), status, members.size(), members);
+        return new BusinessSummary(status, members.size(), members);
     }
 
     private long requiredCurrentGroupId(String inboundCode) {

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

@@ -1,21 +0,0 @@
-package com.baiyue.firstleg.mapper;
-
-import org.apache.ibatis.annotations.Insert;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Options;
-import org.apache.ibatis.annotations.Param;
-import org.apache.ibatis.annotations.Select;
-
-/** 本服务业务编号序列，更新与读取必须处于同一事务连接。 */
-@Mapper
-public interface DocumentSequenceMapper {
-    /** 唯一序列键原子递增，并在连接内保存本次分配值。 */
-    @Insert("INSERT INTO fl_document_sequence(sequence_key,current_value) VALUES(#{key},LAST_INSERT_ID(1)) "
-        + "ON DUPLICATE KEY UPDATE current_value=LAST_INSERT_ID(current_value+1)")
-    int allocate(@Param("key") String key);
-
-    /** 禁用一级和二级缓存，返回本事务刚刚分配的值。 */
-    @Select("SELECT LAST_INSERT_ID()")
-    @Options(useCache=false, flushCache=Options.FlushCachePolicy.TRUE)
-    Long allocatedValue();
-}

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

@@ -64,13 +64,13 @@ public interface MerchantWorkbenchFilterMapper {
         ORDER BY i.order_id
         """)
     List<Long> pendingCustoms(@Param("tenantId") long tenantId);
-    /** 仅按本客户实际装柜片段读取进度；清关资料保存后立即显示已清关。 */
+    /** Only physically loaded fragments can expose container milestones to the customer. */
     @Select("""
         <script>
         SELECT o.order_id, CASE WHEN owned.container_booking_id IS NULL THEN 0
-               WHEN EXISTS (SELECT 1 FROM fl_container_document d
+               WHEN EXISTS (SELECT 1 FROM fl_carrier_schedule_node_fact n
-                 WHERE d.container_booking_id=owned.container_booking_id
+                 WHERE n.container_booking_id=owned.container_booking_id
-                   AND d.document_type='DESTINATION_CLEARANCE' AND d.file_id IS NOT NULL) THEN 3
+                   AND n.standard_node='PICKUP_READY' AND n.actual_at IS NOT NULL) THEN 3
                WHEN EXISTS (SELECT 1 FROM fl_customs_container c
                  WHERE c.loading_plan_id=owned.loading_plan_id AND c.status='COMPLETED') THEN 2
                ELSE 1 END AS stage

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

@@ -63,7 +63,6 @@ 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,
@@ -71,7 +70,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(arrival.actual_at) AS arrivedDestinationPortAt,
+               MAX(CASE WHEN f.standard_node='ARRIVED_DESTINATION_PORT' THEN f.actual_at END) 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
@@ -82,10 +81,6 @@ 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/main/java/com/baiyue/firstleg/portschedule/service/PortScheduleService.java

@@ -32,8 +32,6 @@ import java.util.Set;
 
 @Service
 public class PortScheduleService {
-    @jakarta.annotation.Resource private com.baiyue.firstleg.service.FirstlegDocumentNumberGenerator documentNumbers;
-
     private static final Set<String> SOURCE_TYPES = Set.of("MANUAL", "CARRIER", "TERMINAL", "API");
 
     @Resource private PortScheduleRepository repository;
@@ -74,7 +72,7 @@ public class PortScheduleService {
         validateLinks(request.data());
         PortScheduleEntity value = new PortScheduleEntity();
         value.setId(IdWorker.getId());
-        value.setScheduleNo(documentNumbers.next("PS"));
+        value.setScheduleNo("PS" + value.getId());
         copy(value, request.data());
         value.setCreatedBy(operatorId); value.setCreatedByName(operatorName);
         value.setUpdatedBy(operatorId); value.setUpdatedByName(operatorName);

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

@@ -1,24 +0,0 @@
-package com.baiyue.firstleg.repository;
-
-import com.baiyue.firstleg.mapper.DocumentSequenceMapper;
-import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Propagation;
-import org.springframework.transaction.annotation.Transactional;
-
-/** 各业务共用本库序列，独立短事务避免持有编号锁进入业务资源锁。 */
-@Repository
-public class DocumentSequenceRepository {
-    private final DocumentSequenceMapper mapper;
-
-    /** 只访问所属服务的编号表。 */
-    public DocumentSequenceRepository(DocumentSequenceMapper mapper) { this.mapper = mapper; }
-
-    /** 已分配号不因外层业务回滚而复用，允许失败请求产生断号。 */
-    @Transactional(propagation = Propagation.REQUIRES_NEW)
-    public long next(String key) {
-        mapper.allocate(key);
-        Long value = mapper.allocatedValue();
-        if (value == null || value < 1) throw new IllegalStateException("业务编号分配失败");
-        return value;
-    }
-}

firstleg/src/main/java/com/baiyue/firstleg/sailingcalendar/service/SailingCalendarService.java

@@ -40,8 +40,6 @@ import static com.baiyue.firstleg.sailingcalendar.dto.SailingCalendarDtos.*;
 
 @Service
 public class SailingCalendarService {
-    @jakarta.annotation.Resource private com.baiyue.firstleg.service.FirstlegDocumentNumberGenerator documentNumbers;
-
     private static final ZoneId ZONE = ZoneId.of("Asia/Shanghai");
     private static final String OPEN = "OPEN";
     @Resource private SailingCalendarRepository repository;
@@ -79,7 +77,7 @@ public class SailingCalendarService {
         if (version(request.expectedVersion()) != 0) throw bad("新建模板expectedVersion必须为0");
         SailingChannelEntity channel = resolvePriceBookChannel(request.data().channelId(), request.data().warehouseId(), null); validateTemplate(request.data(), channel);
         if (!"ACTIVE".equals(channel.getStatus())) throw conflict("停用渠道不能创建模板");
-        SailingTemplateEntity value = new SailingTemplateEntity(); value.setId(IdWorker.getId()); value.setTemplateNo(documentNumbers.next("ST"));
+        SailingTemplateEntity value = new SailingTemplateEntity(); value.setId(IdWorker.getId()); value.setTemplateNo("ST-" + value.getId());
         copy(value, request.data(), channel); value.setStatus("ACTIVE"); value.setCreatedBy(operatorId); value.setCreatedByName(operatorName);
         value.setUpdatedBy(operatorId); value.setUpdatedByName(operatorName); value.setVersion(0); now(value);
         repository.insert(value); return value;
@@ -312,7 +310,7 @@ public class SailingCalendarService {
         if (existing != null) return isCopyOf(existing, copyReason) ? detail(existing.getId())
             : throwCopyConflict(request.etdAt(), source.getVoyageNo());
 
-        SailingEntity value = new SailingEntity(); value.setId(IdWorker.getId()); value.setSailingNo(documentNumbers.next("SL")); value.setTemplateId(source.getTemplateId()); value.setChannelId(source.getChannelId()); value.setChannelCodeSnapshot(source.getChannelCodeSnapshot()); value.setChannelNameSnapshot(source.getChannelNameSnapshot()); value.setWarehouseId(source.getWarehouseId()); value.setWarehouseNameSnapshot(source.getWarehouseNameSnapshot()); value.setDeparturePortCode(source.getDeparturePortCode()); value.setDestinationPortCode(source.getDestinationPortCode()); value.setVesselName(source.getVesselName()); value.setVoyageNo(source.getVoyageNo()); value.setEtdAt(request.etdAt()); value.setWarehouseCutoffAt(request.cutoffAt()); value.setEtaAt(copyEta(source, request.etdAt())); value.setStatus("OPEN"); value.setSourceType("COPY"); value.setPlannedCapacityCbm(source.getPlannedCapacityCbm()); value.setVersion(0); value.setCreatedBy(operatorId); value.setCreatedByName(operatorName); value.setUpdatedBy(operatorId); value.setUpdatedByName(operatorName); now(value);
+        SailingEntity value = new SailingEntity(); value.setId(IdWorker.getId()); value.setSailingNo("SL-" + value.getId()); value.setTemplateId(source.getTemplateId()); value.setChannelId(source.getChannelId()); value.setChannelCodeSnapshot(source.getChannelCodeSnapshot()); value.setChannelNameSnapshot(source.getChannelNameSnapshot()); value.setWarehouseId(source.getWarehouseId()); value.setWarehouseNameSnapshot(source.getWarehouseNameSnapshot()); value.setDeparturePortCode(source.getDeparturePortCode()); value.setDestinationPortCode(source.getDestinationPortCode()); value.setVesselName(source.getVesselName()); value.setVoyageNo(source.getVoyageNo()); value.setEtdAt(request.etdAt()); value.setWarehouseCutoffAt(request.cutoffAt()); value.setEtaAt(copyEta(source, request.etdAt())); value.setStatus("OPEN"); value.setSourceType("COPY"); value.setPlannedCapacityCbm(source.getPlannedCapacityCbm()); value.setVersion(0); value.setCreatedBy(operatorId); value.setCreatedByName(operatorName); value.setUpdatedBy(operatorId); value.setUpdatedByName(operatorName); now(value);
         try { repository.insert(value); } catch (DuplicateKeyException ex) {
             SailingEntity duplicate = repository.sailingByBusinessKey(source.getWarehouseId(), source.getChannelCodeSnapshot(),
                 source.getDeparturePortCode(), source.getDestinationPortCode(), request.etdAt(), source.getVoyageNo());
@@ -364,7 +362,7 @@ public class SailingCalendarService {
         if (version(request.expectedVersion()) != 0) throw bad("新建船期expectedVersion必须为0");
         validateSailing(request.data()); SailingChannelEntity channel = resolveChannel(request.data());
         if (!"ACTIVE".equals(channel.getStatus())) throw conflict("停用渠道不能创建船期");
-        SailingEntity value = new SailingEntity(); value.setId(IdWorker.getId()); value.setSailingNo(documentNumbers.next("SL"));
+        SailingEntity value = new SailingEntity(); value.setId(IdWorker.getId()); value.setSailingNo("SL-" + value.getId());
         copy(value, request.data(), channel); value.setStatus(OPEN); value.setSourceType(normalizeSource(request.data().sourceType()));
         value.setCreatedBy(operatorId); value.setCreatedByName(operatorName); value.setUpdatedBy(operatorId); value.setUpdatedByName(operatorName); value.setVersion(0); now(value);
         try { repository.insert(value); } catch (DuplicateKeyException ex) { throw conflict("船期业务唯一键冲突"); }
@@ -400,7 +398,7 @@ public class SailingCalendarService {
         validateTemplateSnapshot(template);
         List<SailingEntity> result = new java.util.ArrayList<>();
         for (GenerationPreview preview : generationPreview(templateId, from, to)) if (!preview.conflict()) {
-            SailingEntity value = new SailingEntity(); value.setId(IdWorker.getId()); value.setSailingNo(documentNumbers.next("SL")); value.setTemplateId(templateId);
+            SailingEntity value = new SailingEntity(); value.setId(IdWorker.getId()); value.setSailingNo("SL-" + value.getId()); value.setTemplateId(templateId);
             value.setChannelId(channel.getId()); value.setChannelCodeSnapshot(channel.getChannelCode()); value.setChannelNameSnapshot(channel.getChannelName());
              value.setWarehouseId(template.getWarehouseId()); value.setWarehouseNameSnapshot(template.getWarehouseNameSnapshot()); value.setDeparturePortCode(template.getDeparturePortCode()); value.setDestinationPortCode(template.getDestinationPortCode()); value.setVesselName(template.getVesselName()); value.setVoyageNo(preview.voyageNo()); value.setEtdAt(preview.etdAt()); value.setWarehouseCutoffAt(preview.cutoffAt()); value.setStatus(OPEN); value.setSourceType("TEMPLATE"); value.setGeneratedKey(key(template, preview.etdAt(), preview.voyageNo())); value.setVersion(0); value.setCreatedBy(operatorId); value.setCreatedByName(operatorName); value.setUpdatedBy(operatorId); value.setUpdatedByName(operatorName); now(value); repository.insert(value); recordHistory(value.getId(), "GENERATE", null, OPEN, "按固定周模板生成", operatorId, operatorName, value.getCreatedAt()); result.add(value);
         }

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

@@ -1,47 +1,71 @@
 package com.baiyue.firstleg.service;
 
-import com.baiyue.common.core.number.DailyDocumentNumber;
+import com.baiyue.common.core.api.ResultCode;
-import com.baiyue.firstleg.repository.DocumentSequenceRepository;
+import com.baiyue.common.core.exception.BizException;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
 import java.time.Clock;
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.Locale;
 import java.util.Set;
 
-/** 按北京时间生成两至四位前缀、八位日期和四位日流水。 */
 @Component
 public class FirstlegDocumentNumberGenerator {
-    private static final Set<String> PREFIXES = Set.of("OB", "TA", "LP", "DECL", "BR", "PS", "SL", "ST", "CLG");
+    private static final ZoneId BUSINESS_ZONE = ZoneId.of("Asia/Shanghai");
-    private final DocumentSequenceRepository sequences;
+    private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("yyMMdd", Locale.ROOT);
+    private static final Set<String> SUPPORTED_PREFIXES = Set.of("OB", "TA", "LP", "DP");
+    private static final long MAX_DAILY_SEQUENCE = 9_999L;
+
+    private final JdbcTemplate jdbc;
     private final Clock clock;
 
-    /** 正式运行使用统一业务时区。 */
     @Autowired
-    public FirstlegDocumentNumberGenerator(DocumentSequenceRepository sequences) {
+    public FirstlegDocumentNumberGenerator(JdbcTemplate jdbc) {
-        this(sequences, Clock.system(DailyDocumentNumber.BUSINESS_ZONE));
+        this(jdbc, Clock.system(BUSINESS_ZONE));
     }
 
-    /** 固定时钟用于跨日及前缀独立性验证。 */
+    FirstlegDocumentNumberGenerator(JdbcTemplate jdbc, Clock clock) {
-    FirstlegDocumentNumberGenerator(DocumentSequenceRepository sequences, Clock clock) {
+        this.jdbc = jdbc;
-        this.sequences = sequences;
         this.clock = clock;
     }
 
-    /** 只为本服务已登记的业务类型分配号码。 */
+    @Transactional(propagation = Propagation.MANDATORY)
     public String next(String prefix) {
-        // 实物标签未纳入本次改号，DP 保留原六位日期及横杠。
+        if (!SUPPORTED_PREFIXES.contains(prefix)) {
-        if ("DP".equals(prefix)) {
+            throw new IllegalArgumentException("unsupported firstleg document prefix: " + prefix);
-            java.time.LocalDate date = java.time.LocalDate.now(clock.withZone(DailyDocumentNumber.BUSINESS_ZONE));
-            long value = sequences.next("DP:" + date.format(java.time.format.DateTimeFormatter.BASIC_ISO_DATE));
-            DailyDocumentNumber.format("DP", date, value);
-            return "DP-" + date.format(java.time.format.DateTimeFormatter.ofPattern("yyMMdd"))
-                + "-" + String.format(java.util.Locale.ROOT, "%04d", value);
         }
-        if (!PREFIXES.contains(prefix)) throw new IllegalArgumentException("未登记的业务编号前缀：" + prefix);
+        LocalDate sequenceDate = LocalDate.now(clock);
-        return DailyDocumentNumber.next(prefix, clock, sequences::next);
+        String sequenceKey = prefix + ":" + DateTimeFormatter.BASIC_ISO_DATE.format(sequenceDate);
+        long sequence = nextSequence(sequenceKey);
+        if (sequence > MAX_DAILY_SEQUENCE) {
+            throw new BizException(ResultCode.CONFLICT, "当日" + prefix + "单据编号已用尽");
+        }
+        return prefix + "-" + DATE_FORMAT.format(sequenceDate) + "-" +
+            String.format(Locale.ROOT, "%04d", sequence);
     }
 
-    /** 柜次号保持现有全局连续规则，不按日期重置，也不限制为四位。 */
+    /** 平台柜次号是长期业务身份，使用不按日期重置的 D 序号。 */
+    @Transactional(propagation = Propagation.MANDATORY)
     public String nextCabinetNo() {
-        return "D" + String.format(java.util.Locale.ROOT, "%04d", sequences.next("CABINET"));
+        return "D" + String.format(Locale.ROOT, "%04d", nextSequence("CABINET"));
+    }
+
+    private long nextSequence(String sequenceKey) {
+        jdbc.update(
+            "INSERT INTO fl_document_sequence(sequence_key,current_value) " +
+                "VALUES(?,LAST_INSERT_ID(1)) ON DUPLICATE KEY UPDATE " +
+                "current_value=LAST_INSERT_ID(current_value+1)",
+            sequenceKey);
+        Long sequence = jdbc.queryForObject("SELECT LAST_INSERT_ID()", Long.class);
+        if (sequence == null || sequence <= 0) {
+            throw new BizException(ResultCode.CONFLICT, "业务编号生成失败");
+        }
+        return sequence;
     }
 }

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

@@ -91,13 +91,12 @@ public class SmartLoadingService {
         }
         return repository.candidates(warehouseId);
     }
-    /** 按柜次渠道查询候选，关联订舱客户快照不限制其他客户的货物。 */
     public List<Candidate> candidates(long bookingId, long warehouseId) {
         ContainerBookingEntity booking = requireBooking(bookingId);
         if (!Objects.equals(booking.getWarehouseId(), warehouseId)) throw validation("柜次仓库与候选仓库不一致");
         if (!StringUtils.hasText(booking.getChannelGroupCode())) throw validation("柜次缺少计划渠道，请重新创建模拟柜");
         List<Candidate> values = candidates(warehouseId).stream()
-            .filter(candidate -> sameChannel(booking, candidate)).toList();
+            .filter(candidate -> sameChannel(booking, candidate) && sameCustomerScope(booking, candidate)).toList();
         return enrichColoadCandidates(booking, repository.planByBooking(bookingId), values);
     }
 
@@ -109,11 +108,10 @@ public class SmartLoadingService {
         return uniqueCandidateUnits(grouped.values().stream().flatMap(details -> inboundCandidates(details).stream()).toList());
     }
 
-    /** 推荐保留渠道和显式筛选范围，允许同柜包含多个客户。 */
     private List<InboundCandidate> recommendationCandidates(ContainerBookingEntity booking,
                                                             Long customerId, String inboundCode) {
         List<Candidate> values = repository.candidates(null).stream()
-            .filter(candidate -> sameChannel(booking, candidate))
+            .filter(candidate -> sameChannel(booking, candidate) && sameCustomerScope(booking, candidate))
             .filter(candidate -> customerId == null || Objects.equals(customerId, candidate.accountId()))
             .filter(candidate -> !StringUtils.hasText(inboundCode)
                 || inboundCode.trim().equals(candidate.inboundCode()))
@@ -515,7 +513,6 @@ public class SmartLoadingService {
         return view(assigned, requireBooking(assigned.getContainerBookingId()));
     }
 
-    /** 原子新增明细或整托组成，使用货物自身客户归属而非订舱客户快照。 */
     private Plan assign(long planId, AssignRequest request, long operatorId, String operatorName,
                         boolean wholeGroupAssignment, Long palletId, String palletNo,
                         Integer actualSkuQuantity, boolean primaryPalletLine, Candidate frozenCandidate,
@@ -538,6 +535,7 @@ public class SmartLoadingService {
         }
         inboundHoldGuard.requireInboundNotHeld(candidate.accountId(), candidate.inboundId());
         if (!wholeGroupAssignment) requireStandalone(candidate.accountId(), candidate.inboundId());
+        requireSameCustomerScope(booking, candidate);
         var task = loadingPickService.mutationSnapshot(planId);
         if (task.taskId() != null && "LOADING".equals(task.taskStatus())) {
             splitPreloadService.ensureForRunningLoadingAllocation(candidate.accountId(), candidate.inboundId(),
@@ -606,7 +604,10 @@ public class SmartLoadingService {
         return assignInbound(planId, request, operatorId, operatorName, false, null, true);
     }
 
-    /** 待审核订单可跨客户占位；权威订单归属和后续审核测量门禁仍必须满足。 */
+    /**
+     * Reserves declared cartons in a cabinet before order review. Review status is not an allocation
+     * gate; confirmation/PDA remains blocked until the resulting inbound reaches WAIT_SPLIT.
+     */
     @Transactional
     @BusinessAudit(event = "SMART_LOADING_PENDING_REVIEW_ASSIGN", resourceType = "LOADING_PLAN",
         resourceId = "#planId", description = "待审核订单加入装柜清单")
@@ -651,6 +652,7 @@ public class SmartLoadingService {
         for (InboundAllocation allocation : allocations) {
             if (allocation.packageCount() == 0) continue;
             Candidate candidate = allocation.candidate();
+            requireSameCustomerScope(booking, candidate);
             checkRouteAndCapacity(booking, current, candidate, allocation.packageCount(), true);
             OrderCargoClient.CargoBinding cargo = declared.stream()
                 .map(DeclaredCargo::cargo)
@@ -720,7 +722,7 @@ public class SmartLoadingService {
         LoadingPlanEntity plan = editing(planId, request.expectedVersion(), operatorId, operatorName);
         ContainerBookingEntity booking = requireBooking(plan.getContainerBookingId());
         List<Candidate> details = frozenDetails == null
-            ? manualCandidates().stream()
+            ? manualCandidates(booking).stream()
                 .filter(candidate -> Objects.equals(candidate.inboundId(), request.inboundId())).toList()
             : List.copyOf(frozenDetails);
         if (details.isEmpty()) throw conflict("入仓码不存在、已分配完或尚未完成入库");
@@ -754,7 +756,6 @@ public class SmartLoadingService {
         return view(assigned, booking);
     }
 
-    /** 按入仓单自己的客户和申报事实建立占位，不以订舱客户限制拼柜。 */
     private Plan assignDeclaredInbound(long planId, AssignInboundRequest request,
                                        InboundOrderEntity projection, String operation,
                                        String requestHash, long operatorId, String operatorName) {
@@ -785,6 +786,7 @@ public class SmartLoadingService {
         for (InboundAllocation allocation : allocations) {
             if (allocation.packageCount() == 0) continue;
             Candidate candidate = allocation.candidate();
+            requireSameCustomerScope(booking, candidate);
             checkRouteAndCapacity(booking, current, candidate, allocation.packageCount(), true);
             OrderCargoClient.CargoBinding cargo = declared.stream().map(DeclaredCargo::cargo)
                 .filter(value -> Objects.equals(value.cargoId(), candidate.inboundDetailId()))
@@ -1005,7 +1007,6 @@ public class SmartLoadingService {
     @Transactional
     @BusinessAudit(event = "SMART_LOADING_ITEM_ADJUST", resourceType = "LOADING_PLAN_ITEM",
         resourceId = "#itemId", description = "调整智能装柜明细")
-    /** 调整本计划明细箱数，保留原客户归属、可用量、拣货和容量校验。 */
     public Plan adjust(long planId, long itemId, AdjustRequest request, long operatorId, String operatorName) {
         String operation = operation(request.operationId());
         String requestHash = sha256("ADJUST|" + planId + '|' + itemId + '|'
@@ -1052,6 +1053,7 @@ public class SmartLoadingService {
         if (request.packageCount() > maxPackageCount) {
             throw validation("调整箱数超过可用箱数");
         }
+        requireSameCustomerScope(booking, candidate);
         List<LoadingPlanItemEntity> others = new ArrayList<>(repository.items(planId));
         others.removeIf(x -> Objects.equals(x.getId(), itemId));
         checkRouteAndCapacity(booking, others, candidate, request.packageCount(), true);
@@ -1358,7 +1360,7 @@ public class SmartLoadingService {
         if (!"ACTIVE".equals(group.status()) || group.lockedPlanId() != null) {
             throw conflict("同柜不可拆组已锁定或已消费");
         }
-        List<Candidate> available = manualCandidates();
+        List<Candidate> available = manualCandidates(booking);
         Map<Long, List<Candidate>> result = new LinkedHashMap<>();
         for (Member member : group.members()) {
             if (!repository.activeItemsByInbound(member.tenantId(), member.inboundId()).isEmpty()) {
@@ -1380,15 +1382,14 @@ public class SmartLoadingService {
         return result;
     }
 
-    /** 整组推荐可跨客户，但仍按柜次渠道选择候选。 */
     private List<Candidate> availableCandidates(ContainerBookingEntity booking) {
         return repository.candidates(null).stream()
-            .filter(candidate -> sameChannel(booking, candidate)).toList();
+            .filter(candidate -> sameChannel(booking, candidate) && sameCustomerScope(booking, candidate)).toList();
     }
 
-    /** 平台人工分配可拼装多个客户，明细始终保留各自的真实客户归属。 */
+    private List<Candidate> manualCandidates(ContainerBookingEntity booking) {
-    private List<Candidate> manualCandidates() {
+        return repository.candidates(null).stream()
-        return repository.candidates(null);
+            .filter(candidate -> sameCustomerScope(booking, candidate)).toList();
     }
 
     private boolean groupFits(ContainerBookingEntity booking, List<LoadingPlanItemEntity> planItems,
@@ -1806,6 +1807,12 @@ public class SmartLoadingService {
         return StringUtils.hasText(booking.getChannelGroupCode()) && candidateGroup != null
             && booking.getChannelGroupCode().equals(candidateGroup.code());
     }
+    private static boolean sameCustomerScope(ContainerBookingEntity booking, Candidate candidate) {
+        return booking.getCustomerId() == null || Objects.equals(booking.getCustomerId(), candidate.accountId());
+    }
+    private static void requireSameCustomerScope(ContainerBookingEntity booking, Candidate candidate) {
+        if (!sameCustomerScope(booking, candidate)) throw forbidden();
+    }
     /**
      * A draft may legitimately contain pre-review or pre-measurement members without a fee snapshot.
      * The pricing port reports that as NOT_READY, while any sent/customer-confirmed member fails and
@@ -1904,5 +1911,5 @@ public class SmartLoadingService {
     }
 
     private static String trim(String x){return x==null?null:x.trim();} private static BigDecimal unit(BigDecimal x){return x==null?BigDecimal.ZERO:x.max(BigDecimal.ZERO);}
-    private static void requireAccount(long x){if(x<=0)throw new BizException(ResultCode.BAD_REQUEST,"accountId必须大于零");} private static BizException conflict(String x){return new BizException(ResultCode.CONFLICT,x);} private static BizException validation(String x){return new BizException(ResultCode.VALIDATION_FAILED,x);}
+    private static void requireAccount(long x){if(x<=0)throw new BizException(ResultCode.BAD_REQUEST,"accountId必须大于零");} private static BizException conflict(String x){return new BizException(ResultCode.CONFLICT,x);} private static BizException validation(String x){return new BizException(ResultCode.VALIDATION_FAILED,x);} private static BizException forbidden(){return new BizException(ResultCode.FORBIDDEN,"客户归属不匹配");}
 }

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

@@ -17,8 +17,7 @@ public interface WorkflowFactMapper {
  +"EXISTS(SELECT 1 "+ACTUAL+" AND EXISTS(SELECT 1 FROM fl_carrier_schedule_node_fact n WHERE n.container_booking_id=b.id AND n.standard_node='DEPARTED_ORIGIN_PORT' AND n.actual_at IS NOT NULL)) departed,"
  +"EXISTS(SELECT 1 "+ACTUAL+" AND EXISTS(SELECT 1 FROM fl_container_document d WHERE d.container_booking_id=b.id AND d.document_type='DESTINATION_CLEARANCE' AND d.file_id IS NOT NULL)) clearance_uploaded,"
  +"EXISTS(SELECT 1 "+ACTUAL+" AND i.tax_mode='TAX_REFUND' AND NOT EXISTS(SELECT 1 FROM fl_customs_customer_document_inbound s JOIN fl_customs_customer_document d ON d.id=s.document_id AND d.tenant_id=i.tenant_id AND d.status='ACTIVE' JOIN fl_customs_container c ON c.id=d.customs_container_id AND c.loading_plan_id=p.id WHERE s.inbound_id=i.id AND s.tenant_id=i.tenant_id)) missing_customs,"
- +"EXISTS(SELECT 1 "+ACTUAL+" AND (i.tax_mode='BUY_DECLARATION' OR EXISTS(SELECT 1 FROM fl_customs_customer_document_inbound s JOIN fl_customs_customer_document d ON d.id=s.document_id AND d.tenant_id=i.tenant_id AND d.status='ACTIVE' JOIN fl_customs_container c ON c.id=d.customs_container_id AND c.loading_plan_id=p.id WHERE s.inbound_id=i.id AND s.tenant_id=i.tenant_id))) export_customs_ready,"
+ +"EXISTS(SELECT 1 "+ACTUAL+" AND (i.tax_mode='BUY_DECLARATION' OR EXISTS(SELECT 1 FROM fl_customs_customer_document_inbound s JOIN fl_customs_customer_document d ON d.id=s.document_id AND d.tenant_id=i.tenant_id AND d.status='ACTIVE' JOIN fl_customs_container c ON c.id=d.customs_container_id AND c.loading_plan_id=p.id WHERE s.inbound_id=i.id AND s.tenant_id=i.tenant_id))) export_customs_ready "
- +"EXISTS(SELECT 1 "+ACTUAL+" AND EXISTS(SELECT 1 FROM fl_customs_container c WHERE c.loading_plan_id=p.id AND c.status='COMPLETED')) customs_completed "
  +"FROM fl_inbound_order i WHERE i.deleted=0 AND NOT EXISTS(SELECT 1 FROM fl_inbound_order child WHERE child.tenant_id=i.tenant_id AND child.parent_inbound_id=i.id AND child.inbound_role='CHILD' AND (child.split_purpose IS NULL OR child.split_purpose != 'REMAINDER') AND child.deleted=0) AND i.process_status != 'CANCELLED' AND i.id IN "
  +"<foreach collection='ids' item='id' open='(' separator=',' close=')'>#{id}</foreach></script>")
  List<WorkflowFacts.Fact> facts(@Param("ids") List<Long> ids);

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

@@ -5,7 +5,7 @@ public final class WorkflowFacts {
  /** 仅承载事实查询契约，不允许实例化。 */
  private WorkflowFacts() {}
  public record Fact(long tenantId,long inboundId,long orderId,String reviewStatus,
- boolean departed,boolean clearanceUploaded,boolean missingCustoms,boolean exportCustomsReady,boolean customsCompleted) {}
+ boolean departed,boolean clearanceUploaded,boolean missingCustoms,boolean exportCustomsReady) {}
  public record Source(long tenantId,long inboundId) {}
  public record Request(List<Source> sources) {}
  public record Overseas(long tenantId,long inboundId,boolean outboundExists,boolean pendingOutbound,boolean delivering,boolean unloaded) {}

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

@@ -24,32 +24,27 @@ public class WorkflowTabService {
  var facts=repository.facts(batch.stream().map(InboundOrderEntity::getId).toList());
  // 确认页签复用已推送费用版本。
  for(var fee:repository.feeConfirmationRows(facts.stream().map(WorkflowFacts.Fact::inboundId).toList())) {
- if(facts.stream().noneMatch(f->f.tenantId()==fee.tenantId() && f.orderId()==fee.orderId())) throw unavailable("费用确认事实不属于本批入仓来源");
+ if(facts.stream().noneMatch(f->f.tenantId()==fee.tenantId() && f.orderId()==fee.orderId())) throw unavailable();
  result.putIfAbsent(fee.orderId()+":"+fee.mainStatus(),fee);
  }
- var sources=facts.stream().filter(f->f.departed() || f.clearanceUploaded()).map(f->new WorkflowFacts.Source(f.tenantId(),f.inboundId())).distinct().toList();
+ var sources=facts.stream().filter(WorkflowFacts.Fact::departed).map(f->new WorkflowFacts.Source(f.tenantId(),f.inboundId())).distinct().toList();
  Map<String,WorkflowFacts.Overseas> overseas=new HashMap<>();
  if(!sources.isEmpty()) {
  try {
  var response=lastleg.read(token,new WorkflowFacts.Request(sources));
- if(response==null || !response.successful() || response.data()==null) throw unavailable(
+ if(response==null || !response.successful() || response.data()==null) throw unavailable();
-     "尾程事实响应无效 code="+(response==null?null:response.code())
-     +" requestId="+(response==null?null:response.requestId())+" traceId="+(response==null?null:response.traceId()));
  var allowed=new HashSet<>(sources);
  for(var fact:response.data()) {
- if(fact==null || !allowed.contains(new WorkflowFacts.Source(fact.tenantId(),fact.inboundId()))) throw unavailable("尾程事实包含空记录或本批以外的客户/入仓来源");
+ if(fact==null || !allowed.contains(new WorkflowFacts.Source(fact.tenantId(),fact.inboundId()))) throw unavailable();
  overseas.merge(fact.tenantId()+":"+fact.inboundId(),fact,(a,b)->new WorkflowFacts.Overseas(a.tenantId(),a.inboundId(),a.outboundExists()||b.outboundExists(),a.pendingOutbound()||b.pendingOutbound(),a.delivering()||b.delivering(),a.unloaded()&&b.unloaded()));
  }
- if(overseas.size()!=sources.size()) throw unavailable("尾程事实缺少来源 expected="+sources.size()+" actual="+overseas.size()
+ if(overseas.size()!=sources.size()) throw unavailable();
-     +" missing="+sources.stream().filter(s->!overseas.containsKey(s.tenantId()+":"+s.inboundId())).limit(20).toList());
+ } catch(BizException e) { throw e; } catch(Exception e) { throw unavailable(); }
- } catch(BizException e) { throw e; } catch(Exception e) {
-     throw (BizException) new BizException(ResultCode.SERVICE_UNAVAILABLE,"订单业务页签事实暂不可用，请稍后重试").initCause(e);
- }
  }
  // SQL排除仅作汇总的父票；保留承接实际装柜数量的来源票及独立余量票。
  for(var fact:facts) {
  var inbound=expected.get(fact.inboundId());
- if(inbound==null || !Objects.equals(inbound.getTenantId(),fact.tenantId()) || !Objects.equals(inbound.getOrderId(),fact.orderId())) throw unavailable("头程事实与入仓单归属不一致 inboundId="+fact.inboundId());
+ if(inbound==null || !Objects.equals(inbound.getTenantId(),fact.tenantId()) || !Objects.equals(inbound.getOrderId(),fact.orderId())) throw unavailable();
  var o=overseas.get(fact.tenantId()+":"+fact.inboundId());
  for(String key:classify(fact,inbound.getProcessStatus(),o)) result.putIfAbsent(fact.orderId()+":"+key,new StatusRow(fact.tenantId(),fact.orderId(),key));
  }
@@ -61,18 +56,16 @@ public class WorkflowTabService {
  Set<String> keys=new LinkedHashSet<>();
  if("MEASURE_PENDING".equals(process) && "PENDING".equals(f.reviewStatus())) keys.add("MEASUREMENT_REVIEW");
  boolean signed="DELIVERED".equals(process);
- // 报关完成即进入待清关；不再等待船期接口补齐实际离港节点。
+ // 报关页签按资料与实装事实汇总，不依赖点击开始报关；实际开船后转入清关链路。
- boolean clearanceStage=f.customsCompleted() || f.departed() || f.clearanceUploaded();
+ if(!f.departed() && !signed) {
- if(!clearanceStage && !signed) {
  if(f.missingCustoms()) keys.add("WAIT_CUSTOMS_DOCS");
  if(f.exportCustomsReady()) keys.add("EXPORT_CUSTOMS");
  }
  if(signed) keys.add("SIGNED");
- if(clearanceStage && !signed) {
+ if(f.departed() && !signed) {
  if(!f.clearanceUploaded()) keys.add("SAILING_CLEARANCE");
- // 清关资料保存成功后才进入海外待办；出库事实优先于拆柜和排车待办。
+ if(o!=null) {
- if(f.clearanceUploaded() && o!=null) {
+ if(f.clearanceUploaded() && !o.unloaded()) keys.add("WAIT_UNLOAD");
- if(!o.outboundExists() && !o.unloaded()) keys.add("WAIT_UNLOAD");
  // 取消的出库不构成有效覆盖，读取事实后自动回显，不能保存永久隐藏标志。
  if(!o.outboundExists()) keys.add("WAIT_DISPATCH");
  if(o.pendingOutbound()) keys.add("OUTBOUND_DOCUMENT");
@@ -82,9 +75,5 @@ public class WorkflowTabService {
  return keys;
  }
  /** 下游缺失或归属异常不能生成部分数量。 */
- private static BizException unavailable(String reason) {
+ private static BizException unavailable() { return new BizException(ResultCode.SERVICE_UNAVAILABLE,"订单业务页签事实暂不可用，请稍后重试"); }
-     // 诊断信息只进入服务日志，公开响应保持稳定，不暴露内部来源标识。
-     return (BizException) new BizException(ResultCode.SERVICE_UNAVAILABLE,"订单业务页签事实暂不可用，请稍后重试")
-         .initCause(new IllegalStateException(reason));
- }
 }

firstleg/src/main/resources/db/phase3-smart-loading-schema.sql

@@ -27,11 +27,11 @@ CALL phase3_add_allocation_picked_count();
 DROP PROCEDURE phase3_add_allocation_picked_count;
 
 CREATE TABLE IF NOT EXISTS fl_document_sequence (
-  sequence_key VARCHAR(32) NOT NULL COMMENT '单据序列键；日序列如LP:20260818，柜次长期序列固定为CABINET',
+  sequence_key VARCHAR(32) NOT NULL COMMENT '单据序列键；日序列如CB:20260818，柜次长期序列固定为CABINET',
   current_value INT UNSIGNED NOT NULL COMMENT '该类型当日已分配的最大序号',
   PRIMARY KEY (sequence_key),
   CONSTRAINT chk_fl_document_sequence_value CHECK (current_value > 0)
-) ENGINE=InnoDB COMMENT='头程业务编号序列；普通单据按日，柜次全局连续，实物标签独立保留';
+) ENGINE=InnoDB COMMENT='头程履约业务单号日序列；生成YYMMDD加四位当日序号';
 
 CREATE TABLE IF NOT EXISTS fl_container_booking (
   id BIGINT UNSIGNED NOT NULL COMMENT '货柜预订ID（雪花ID）',

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

@@ -45,8 +45,8 @@ paths:
       summary: 按入仓码查询同柜组业务摘要
       description: >-
         需要 platform:firstleg:smart-loading:list。使用任一有效成员的全局唯一 inboundCode 查询；
-        返回真实业务组号 groupNo、组业务状态、有效成员数和全部唯一成员入仓码。任一冻结成员缺少有效 inboundCode 时失败关闭；
+        仅返回组业务状态、有效成员数和全部唯一成员入仓码。任一冻结成员缺少有效 inboundCode 时失败关闭；
-        页面不持有或展示 groupId、orderId，也不得从技术ID或订单号推导入仓码。
+        页面不持有或展示 groupId、groupNo、orderId，也不得从技术ID或订单号推导入仓码。
       parameters:
         - name: inboundCode
           in: path
@@ -147,9 +147,8 @@ components:
     ColoadGroupBusinessSummary:
       type: object
       additionalProperties: false
-      required: [groupNo, status, memberCount, members]
+      required: [status, memberCount, members]
       properties:
-        groupNo: {type: string, pattern: "^CLG[0-9]{12}$", description: 真实同柜业务组号；与创建及重放结果一致}
         status: {type: string, enum: [ACTIVE, LOCKED, CONSUMED]}
         memberCount: {type: integer, minimum: 1}
         members:

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

@@ -257,7 +257,7 @@ components:
     ContainerEnvelope: {allOf: [{$ref: '#/components/schemas/ApiEnvelope'}, {type: object, properties: {data: {allOf: [{$ref: '#/components/schemas/ContainerView'}], nullable: true, description: 装柜计划尚未完成时返回null，表示报关流程尚未生成}}}]}
     DocumentEnvelope: {allOf: [{$ref: '#/components/schemas/ApiEnvelope'}, {type: object, properties: {data: {$ref: '#/components/schemas/DocumentView'}}}]}
     ActionRequest: {type: object, required: [expectedVersion, confirm], additionalProperties: false, properties: {expectedVersion: {type: integer, minimum: 0}, confirm: {type: boolean}, remark: {type: string, maxLength: 500, nullable: true}}}
-    DeclarationBatchRequest: {type: object, required: [expectedVersion], additionalProperties: false, properties: {expectedVersion: {type: integer, minimum: 0}, customsEntryNo: {type: string, maxLength: 64, nullable: true}, remark: {type: string, maxLength: 500, nullable: true}}}
+    DeclarationBatchRequest: {type: object, required: [expectedVersion], additionalProperties: false, properties: {expectedVersion: {type: integer, minimum: 0}, batchNo: {type: string, maxLength: 64, nullable: true}, customsEntryNo: {type: string, maxLength: 64, nullable: true}, remark: {type: string, maxLength: 500, nullable: true}}}
     ClearanceResultRequest: {type: object, required: [expectedVersion, resultType, occurredAt], additionalProperties: false, properties: {expectedVersion: {type: integer, minimum: 0}, resultType: {type: string, enum: [INSPECTION, SUPPLEMENT_REQUIRED, RELEASED, DETAINED, OTHER]}, occurredAt: {type: string, format: date-time}, resolution: {type: string, maxLength: 1000, nullable: true}, evidenceFileId: {$ref: '#/components/schemas/LongId', nullable: true}, resolved: {type: boolean}}}
     ClearanceResolveRequest: {type: object, required: [expectedVersion], additionalProperties: false, properties: {expectedVersion: {type: integer, minimum: 0}, resolution: {type: string, maxLength: 1000, nullable: true}}}
     ScopeRequest: {type: object, required: [inboundIds, expectedVersion], additionalProperties: false, properties: {inboundIds: {type: array, minItems: 1, maxItems: 200, items: {$ref: '#/components/schemas/LongId'}}, expectedVersion: {type: integer, minimum: 1}}}

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

@@ -392,7 +392,7 @@ paths:
                       customsOrderIds: {type: array, items: {type: integer, format: int64}}
                       progress:
                         type: array
-                        description: 实际装载片段投影；报关要求COMPLETED，目的港清关以本柜DESTINATION_CLEARANCE资料成功绑定file_id为准，不等待PICKUP_READY船节点。
+                        description: 实际装载片段投影；报关要求COMPLETED，目的港清关要求PICKUP_READY实际时间，缺失节点不推测。
                         items:
                           type: object
                           required: [orderId, stage, partial]
@@ -700,8 +700,7 @@ paths:
         需要 platform:firstleg:smart-loading:list 权限。渠道目录只来自平台当前唯一 ACTIVE 价格版本中
         对该国内仓存在 ACTIVE 价格行的渠道；候选入仓码数、可用箱数及可编排柜次数由 Firstleg 当前事实聚合。
         零候选或零可用柜次的有效渠道仍返回，Admin 可展示空态。渠道只约束智能推荐；人工加入允许跨渠道，
-        仍由服务端重新校验国内仓、货物原客户归属、占用、同柜组、箱数和容量资格。
+        仍由服务端重新校验国内仓、客户范围、占用、同柜组、箱数和容量资格。
-        平台柜次支持跨客户拼柜，关联订舱的客户快照不限制柜内成员客户。
       parameters:
         - {name: warehouseId, in: query, required: true, schema: {type: string, pattern: '^[1-9][0-9]*$'}}
       responses:
@@ -836,7 +835,6 @@ paths:
       description: >-
         需要 platform:firstleg:smart-loading:assign 权限。customerId 与 inboundCode 均为可选推荐范围；
         传入时只推荐同时命中的候选，避免把同渠道历史候选批量加入当前柜。未传时按柜次渠道推荐全部可用候选。
-        关联订舱的客户快照不裁剪候选，未指定客户筛选时可推荐多个客户的货物。
         一件代发仍按每个已封托托盘整体加入，不得按箱拆分；同一次推荐完成后按受影响客户统一重算费用。
       parameters:
         - {name: planId, in: path, required: true, schema: {type: string, pattern: '^[1-9][0-9]*$'}}
@@ -850,8 +848,7 @@ paths:
       summary: 向预装计划新增入库单明细
       description: >-
         EDITING 或 LOADING 且 PDA task 尚未完成时可用。服务端按 planId 锁定同一 PDA task，
-        校验货物原客户归属、可用箱数、容积和限重后原子新增/累加明细；平台允许跨客户拼柜，
+        校验客户范围、可用箱数、容积和限重后原子新增/累加明细；人工加入允许订单国内仓及渠道与柜次不同，
-        不以关联订舱客户快照限定成员客户。人工加入允许订单国内仓及渠道与柜次不同，
         智能推荐仍只选择柜次渠道。LOADING 时同步到原 taskId，
         递增 planVersion、taskVersion，原 inventorySnapshotToken 随即失效。与 PDA batch/final complete 并发时，
         锁顺序为 PDA task 行锁 -> plan 乐观锁；仅先取得任务锁且持有匹配版本的一方成功，另一方返回 A0409。
@@ -873,7 +870,6 @@ paths:
         服务端在单一事务内按剩余规格箱数比例生成内部规格快照，用于体积估算及兼容 PDA/拆单；
         人工分配不限制订单国内仓及渠道与柜次一致；智能推荐允许跨国内仓，但仍只选择柜次渠道；
         占用、同柜组和容量门禁不变。
-        支持将不同客户的入仓码加入同一柜次，明细及费用仍保留各自原客户归属。
         柜内总容积和总重量分别允许达到柜型基准值的150%，超过即拒绝。
         只记录数量计划，具体实装箱号归属为 UNVERIFIED，不得将内部比例分摊宣称为现场箱号事实。
       parameters:
@@ -890,7 +886,6 @@ paths:
         需要 platform:firstleg:smart-loading:assign 权限。订单审核状态不作为清单占位门禁；服务端以
         customerId + orderId + inboundCode 重新核验 Order 权威待审核事实，幂等创建或复用 PREPARING
         入仓投影，并按订单申报箱数、重量和体积建立柜次占位。人工分配允许订单渠道与柜次渠道不同；
-        不同客户可加入同一柜次，关联订舱客户快照不作为客户准入限制。
         已被其他有效柜次占用、国内仓不一致、
         超容量或订单事实变化返回业务冲突且事务零漂移。清单中存在 PREPARING/WAIT_MEASURE 订单时不得
         确认预装或启动 PDA，审核测量完成并进入 WAIT_SPLIT 后才可继续物理装柜。
@@ -1679,7 +1674,7 @@ components:
           type: string
           enum: [PENDING_REVIEW, WAIT_MEASURE, WAIT_PALLETIZE, WAIT_SPLIT, LOADING, LOADED, DELIVERED, WAIT_WEIGHT_CONFIRM, WEIGHT_CONFIRMED, WAIT_CUSTOMS_DOCS, EXPORT_CUSTOMS, SAILING_CLEARANCE, WAIT_UNLOAD, WAIT_DISPATCH, OUTBOUND_DOCUMENT, DELIVERING, SIGNED, MEASUREMENT_REVIEW]
           nullable: true
-          description: WAIT_SPLIT 为唯一待分柜筛选值；WAIT_CUSTOMS_DOCS 为实际装柜后缺少本票客户报关资料；EXPORT_CUSTOMS 按本票资料已上传且实际装柜完成汇总，买单无需客户退税资料，不依赖点击开始报关，报关完成或实际开船后移出；SAILING_CLEARANCE 在整柜报关完成后进入，也接受实际离港事实；清关资料保存成功后才进入 WAIT_UNLOAD/WAIT_DISPATCH。WAIT_UNLOAD 持续到实际卸柜或生成有效出库单；生成出库单后进入 OUTBOUND_DOCUMENT，实际出库后进入 DELIVERING，派送完成进入 SIGNED。
+          description: WAIT_SPLIT 为唯一待分柜筛选值；WAIT_CUSTOMS_DOCS 为实际装柜后缺少本票客户报关资料；EXPORT_CUSTOMS 按本票资料已上传且实际装柜完成汇总，买单无需客户退税资料，不依赖点击开始报关，实际开船后移出；SAILING_CLEARANCE 按手动或拉取的实际离港节点进入，清关资料上传后进入 WAIT_UNLOAD，实际卸柜完成后移出。
         customerId: {type: integer, format: int64, nullable: true}
         receivingWarehouseId: {type: integer, format: int64, nullable: true}
         destinationWarehouseId: {type: integer, format: int64, nullable: true}
@@ -2381,7 +2376,7 @@ components:
         id: {type: string, pattern: '^[1-9][0-9]*$'}
         currentPortScheduleId: {type: string, pattern: '^[1-9][0-9]*$', nullable: true, readOnly: true, description: 当前运输读模型由 latestForDispatch 选中的船期记录 ID；无匹配时为空，仅用于定位关联船期，不作为业务编号展示}
         planId: {type: string, pattern: '^[1-9][0-9]*$', nullable: true, description: 关联智能装柜计划ID；未创建计划时为空}
-        planNo: {type: string, nullable: true, pattern: '^LP[0-9]{12}$', example: LP202608180001, description: 预装与确认装柜清单共用的稳定编号；未创建计划时为空}
+        planNo: {type: string, nullable: true, pattern: '^LP-[0-9]{6}-[0-9]{4}$', example: LP-260818-0001, description: 预装与确认装柜清单共用的稳定编号；未创建计划时为空}
         containerNo: {type: string, maxLength: 64, nullable: true}
         cabinetNo: {type: string, pattern: '^D[0-9]{4,}$', example: D0001, description: 平台全局连续且不按日期重置的稳定柜次号}
         sourceType: {type: string, enum: [SIMULATION, OCEAN_BOOKING], description: SIMULATION 为内部模拟柜；OCEAN_BOOKING 为订舱登记直接生成的真实柜}
@@ -2548,7 +2543,7 @@ components:
         inboundCode: {type: string, minLength: 1, maxLength: 40, description: 订单当前入仓片段业务号，UI主展示}
         orderNo: {type: string, nullable: true, description: 订单业务号，UI主展示}
         loadingPlanId: {type: string, pattern: '^[1-9][0-9]*$', nullable: true, description: 装柜计划技术关联ID}
-        loadingPlanNo: {type: string, nullable: true, pattern: '^LP[0-9]{12}$', description: 装柜计划业务号，UI主展示}
+        loadingPlanNo: {type: string, nullable: true, pattern: '^LP-[0-9]{6}-[0-9]{4}$', description: 装柜计划业务号，UI主展示}
         containerBookingId: {type: string, pattern: '^[1-9][0-9]*$', nullable: true, description: 柜次技术关联ID}
         cabinetNo: {type: string, nullable: true, description: 稳定柜次业务号，UI主展示}
         containerNo: {type: string, nullable: true, description: 真实集装箱号，UI主展示}
@@ -2681,7 +2676,7 @@ components:
       required: [id, planNo, status, bookingId, version, canAssign, canEdit, finalCompletionStatus, coLoadGroups, palletMembers, items]
       properties:
         id: {type: string}
-        planNo: {type: string, pattern: '^LP[0-9]{12}$', example: LP202608180001, description: 预装与确认装柜清单共用的稳定编号}
+        planNo: {type: string, pattern: '^LP-[0-9]{6}-[0-9]{4}$', example: LP-260818-0001, description: 预装与确认装柜清单共用的稳定编号}
         status: {type: string, enum: [EDITING, LOADING, COMPLETED]}
         bookingId: {type: string}
         containerNo: {type: string, nullable: true}

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

@@ -299,7 +299,7 @@ components:
       properties:
         planId: {$ref: '#/components/schemas/LongId'}
         containerBookingId: {$ref: '#/components/schemas/LongId'}
-        preloadNo: {type: string, pattern: '^LP[0-9]{12}$', example: LP202608180001, description: 预装单号；按北京时间创建日逐日编号，确认后继续作为同一装柜清单号使用}
+        preloadNo: {type: string, pattern: '^LP-[0-9]{6}-[0-9]{4}$', example: LP-260818-0001, description: 预装单号；按北京时间创建日逐日编号，确认后继续作为同一装柜清单号使用}
         containerNo: {type: string, nullable: true, description: 集装箱号}
         cabinetNo: {type: string, nullable: true, pattern: '^D[0-9]{4,}$', example: D0001, description: 平台全局连续且不按日期重置的稳定柜次号；不得与真实集装箱号混用}
         customers: {type: array, description: 计划包含的客户, items: {$ref: '#/components/schemas/Customer'}}
@@ -356,7 +356,7 @@ components:
       properties:
         planId: {$ref: '#/components/schemas/LongId'}
         containerBookingId: {$ref: '#/components/schemas/LongId'}
-        loadingListNo: {type: string, pattern: '^LP[0-9]{12}$', example: LP202608180001, description: 装柜清单号；沿用预装阶段生成的同一编号}
+        loadingListNo: {type: string, pattern: '^LP-[0-9]{6}-[0-9]{4}$', example: LP-260818-0001, description: 装柜清单号；沿用预装阶段生成的同一编号}
         warehouseId: {$ref: '#/components/schemas/NullableLongId'}
         warehouseName: {type: string, nullable: true, description: 仓库名称}
         containerNo: {type: string, nullable: true, description: 集装箱号}

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

@@ -313,7 +313,7 @@ components:
         oceanBooking:
           type: object
           properties:
-            bookingNo: {type: string, pattern: '^OB[0-9]{12}$', example: OB202608180001, description: 平台订舱号；按北京时间创建日逐日编号}
+            bookingNo: {type: string, pattern: '^OB-[0-9]{6}-[0-9]{4}$', example: OB-260818-0001, description: 平台订舱号；按北京时间创建日逐日编号}
         parties: {type: array}
         containerRequirements: {type: array}
         containers: {type: array, description: Existing containers allocated after port pickup linking}

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

@@ -235,9 +235,9 @@ components:
       required: [appointmentNo, carrierId, carrierName, attachmentCount]
       description: Stable booking and supplier references returned by appointment detail. Container identities are intentionally absent.
       properties:
-        appointmentNo: {type: string, pattern: '^TA[0-9]{12}$', example: TA202608180001, description: 派车单号；按北京时间创建日逐日编号}
+        appointmentNo: {type: string, pattern: '^TA-[0-9]{6}-[0-9]{4}$', example: TA-260818-0001, description: 派车单号；按北京时间创建日逐日编号}
         oceanBookingId: {type: integer, format: int64, nullable: true}
-        oceanBookingNo: {type: string, nullable: true, pattern: '^OB[0-9]{12}$', example: OB202608180001}
+        oceanBookingNo: {type: string, nullable: true, pattern: '^OB-[0-9]{6}-[0-9]{4}$', example: OB-260818-0001}
         warehouseId: {type: integer, format: int64, nullable: true}
         warehouseName: {type: string, nullable: true}
         shippingCompanyId: {type: integer, format: int64, nullable: true}

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

@@ -32,7 +32,7 @@ class InboundMeasurementReviewContractTest {
     }
 
     @Test
-    @DisplayName("测量审核不进入待客户确认，并声明幂等和字符串长ID")
+    @DisplayName("OpenAPI不包含待客户确认并声明幂等和字符串长ID")
     void shouldDocumentReviewContract() throws Exception {
         String openapi = new ClassPathResource("openapi/firstleg-v1.yaml")
             .getContentAsString(StandardCharsets.UTF_8);
@@ -46,11 +46,8 @@ class InboundMeasurementReviewContractTest {
             .contains("name: inboundId")
             .contains("schema: {type: string, pattern:")
             .doesNotContain("/api/platform/v1/inbounds/{inboundId}/measurements/reject:")
-            .doesNotContain("/api/platform/v1/inbounds/{inboundId}/measurements/exception-release:");
+            .doesNotContain("/api/platform/v1/inbounds/{inboundId}/measurements/exception-release:")
-        // 约束仅针对测量审核；客户费用确认属于另一业务，允许独立存在。
+            .doesNotContain("待客户确认");
-        int start = openapi.indexOf("  /api/platform/v1/inbounds/{inboundId}/measurements/approve:");
-        int end = openapi.indexOf("\n  /", start + 1);
-        assertThat(openapi.substring(start, end < 0 ? openapi.length() : end)).doesNotContain("待客户确认");
     }
 
     @Test

firstleg/src/test/java/com/baiyue/firstleg/customs/container/ContainerCustomsServiceTest.java

@@ -28,8 +28,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.Mockito.*;
 
 class ContainerCustomsServiceTest {
-    @org.mockito.Spy private com.baiyue.firstleg.service.FirstlegDocumentNumberGenerator documentNumbers = com.baiyue.firstleg.service.TestDocumentNumbers.documents();
-
     @Mock ContainerCustomsMapper mapper;
     @Mock CustomsFileClient files;
     @Mock ObjectMapper objectMapper;
@@ -37,58 +35,6 @@ class ContainerCustomsServiceTest {
     @InjectMocks ContainerCustomsService service;
     @BeforeEach void setUp(){MockitoAnnotations.openMocks(this);}
 
-    /** 服务端分配批次号后，命令重放必须返回原号且不再消耗流水。 */
-    @Test void declarationCreationReplayKeepsAllocatedNumber() throws Exception {
-        String action = "CREATE_CUSTOMS_DECLARATION_BATCH_9";
-        var command = new AtomicReference<ContainerCustomsMapper.CommandRow>();
-        var batch = new AtomicReference<ContainerCustomsMapper.DeclarationBatchRow>();
-        when(mapper.claimCommand(anyLong(), eq(5L), eq(action), eq("batch-key"), anyString())).thenAnswer(call -> {
-            if (command.get() != null) return 0;
-            command.set(new ContainerCustomsMapper.CommandRow(1L, 5L, action, "batch-key", call.getArgument(4), "PROCESSING", null, null, null));
-            return 1;
-        });
-        when(mapper.command(5L, action, "batch-key")).thenAnswer(call -> command.get());
-        when(mapper.lockContainer(9L)).thenReturn(container(ContainerCustomsService.DECLARING, 3));
-        when(mapper.taxRefundCount(9L)).thenReturn(1);
-        when(mapper.brokerSubmittedAt(2L)).thenReturn(java.time.LocalDateTime.of(2026, 10, 20, 9, 0));
-        when(objectMapper.writeValueAsString(any())).thenReturn("[]");
-        when(mapper.insertDeclarationBatch(anyLong(), eq(2L), eq(9L), anyString(), eq(3), eq("[]"), isNull())).thenAnswer(call -> {
-            batch.set(new ContainerCustomsMapper.DeclarationBatchRow(call.getArgument(0), 2L, 9L, call.getArgument(3),
-                "READY", 3, null, null, null, null, null, null, 0, null, null));
-            return 1;
-        });
-        when(mapper.declarationBatch(anyLong())).thenAnswer(call -> batch.get());
-        when(mapper.insertHistory(anyLong(), eq(2L), eq("CREATE_CUSTOMS_DECLARATION_BATCH"), anyString(), anyString(), anyString(), eq(5L), eq("admin"))).thenReturn(1);
-        when(mapper.completeCommand(eq(5L), eq(action), eq("batch-key"), anyLong())).thenAnswer(call -> {
-            var old = command.get();
-            command.set(new ContainerCustomsMapper.CommandRow(old.id(), 5L, action, "batch-key", old.requestHash(), "SUCCESS", call.getArgument(3), null, null));
-            return 1;
-        });
-        var request = new com.baiyue.firstleg.customs.container.dto.ContainerCustomsDtos.DeclarationBatchRequest(3, null, null);
-        var created = service.createDeclarationBatch(9L, 5L, "admin", "batch-key", request);
-        var replay = service.createDeclarationBatch(9L, 5L, "admin", "batch-key", request);
-        assertThat(created.batchNo()).isEqualTo("DECL202610200001");
-        assertThat(replay.id()).isEqualTo(created.id());
-        assertThat(replay.batchNo()).isEqualTo(created.batchNo());
-        verify(documentNumbers, times(1)).next("DECL");
-    }
-
-    /** 外部报关单号与内部批次号独立，正式提交不能修改内部号。 */
-    @Test void declarationSubmissionPreservesBatchNumber() {
-        var batch = new ContainerCustomsMapper.DeclarationBatchRow(41L, 2L, 9L, "DECL202610200001",
-            "READY", 3, null, null, null, null, null, null, 0, null, null);
-        when(mapper.claimCommand(anyLong(), eq(5L), eq("SUBMIT_CUSTOMS_DECLARATION_BATCH_41"), eq("submit-key"), anyString())).thenReturn(1);
-        when(mapper.lockDeclarationBatch(41L)).thenReturn(batch);
-        when(mapper.submitDeclarationBatch(41L, 0, batch.batchNo(), "CUSTOMS-EXTERNAL-1", 5L, "admin", null)).thenReturn(1);
-        when(mapper.completeCommand(5L, "SUBMIT_CUSTOMS_DECLARATION_BATCH_41", "submit-key", 41L)).thenReturn(1);
-        when(mapper.declarationBatch(41L)).thenReturn(batch);
-        var result = service.submitDeclarationBatch(41L, 5L, "admin", "submit-key",
-            new com.baiyue.firstleg.customs.container.dto.ContainerCustomsDtos.DeclarationBatchRequest(0, "CUSTOMS-EXTERNAL-1", null));
-        assertThat(result.batchNo()).isEqualTo(batch.batchNo());
-        verify(mapper).submitDeclarationBatch(41L, 0, batch.batchNo(), "CUSTOMS-EXTERNAL-1", 5L, "admin", null);
-        verifyNoInteractions(documentNumbers);
-    }
-
     @Test void merchantOwnBuyOrderIsNotFound(){
         assertMerchantOrderNotFound(7L,31L);
     }
@@ -265,7 +211,7 @@ class ContainerCustomsServiceTest {
         var declaring=container(ContainerCustomsService.DECLARING,3);
         var source=new ContainerCustomsMapper.DocumentRow(31L,2L,7L,10L,"source.bin","a".repeat(64),
             "application/octet-stream",1L,"ACTIVE",5L,java.time.LocalDateTime.now(),1,java.time.LocalDateTime.now(),1);
-        var submission=new ContainerCustomsMapper.BrokerSubmissionRow(41L,2L,9L,"BR202610200001","SENT",3,"admin",
+        var submission=new ContainerCustomsMapper.BrokerSubmissionRow(41L,2L,9L,"BR-LP9-01","SENT",3,"admin",
             java.time.LocalDateTime.now(),1);
         when(mapper.claimCommand(anyLong(),eq(5L),eq("SEND_CUSTOMS_INITIAL_TO_BROKER_9"),eq("send-key"),anyString())).thenReturn(1);
         when(mapper.lockContainer(9L)).thenReturn(declaring);
@@ -274,7 +220,7 @@ class ContainerCustomsServiceTest {
         when(mapper.documents(2L,null)).thenReturn(List.of(source));
         when(mapper.frozenScopes(31L)).thenReturn(List.of(new ContainerCustomsMapper.ScopeRow(31L,11L,21L,"I")));
         when(objectMapper.writeValueAsString(any())).thenReturn("[]");
-        when(mapper.insertBrokerSubmission(anyLong(),eq(2L),eq(9L),eq("BR202610200001"),eq(3),eq("[]"),eq(5L),eq("admin"))).thenReturn(1);
+        when(mapper.insertBrokerSubmission(anyLong(),eq(2L),eq(9L),eq("BR-LP9-01"),eq(3),eq("[]"),eq(5L),eq("admin"))).thenReturn(1);
         when(mapper.bumpVersionAfterBrokerSubmission(2L,3)).thenReturn(1);
         when(mapper.insertHistory(anyLong(),eq(2L),eq("SEND_CUSTOMS_INITIAL_TO_BROKER"),eq(ContainerCustomsService.DECLARING),eq(ContainerCustomsService.DECLARING),isNull(),eq(5L),eq("admin"))).thenReturn(1);
         when(mapper.completeCommand(eq(5L),eq("SEND_CUSTOMS_INITIAL_TO_BROKER_9"),eq("send-key"),anyLong())).thenReturn(1);
@@ -289,9 +235,9 @@ class ContainerCustomsServiceTest {
         var result=service.sendInitialToBroker(9L,5L,"admin","send-key",new ActionRequest(3,true,null));
 
         assertThat(result.brokerSubmission()).isNotNull();
-        assertThat(result.brokerSubmission().batchNo()).isEqualTo("BR202610200001");
+        assertThat(result.brokerSubmission().batchNo()).isEqualTo("BR-LP9-01");
         assertThat(result.brokerSubmission().sourceVersion()).isEqualTo(3);
-        verify(mapper).insertBrokerSubmission(anyLong(),eq(2L),eq(9L),eq("BR202610200001"),eq(3),eq("[]"),eq(5L),eq("admin"));
+        verify(mapper).insertBrokerSubmission(anyLong(),eq(2L),eq(9L),eq("BR-LP9-01"),eq(3),eq("[]"),eq(5L),eq("admin"));
     }
 
     @Test void initialBrokerSendRejectsStaleAggregateVersion(){
@@ -589,7 +535,7 @@ class ContainerCustomsServiceTest {
     }
 
     private static ContainerCustomsMapper.DocumentRow document(long id){return new ContainerCustomsMapper.DocumentRow(id,2L,7L,10L,"source.bin","a".repeat(64),"application/octet-stream",1L,"ACTIVE",5L,java.time.LocalDateTime.now(),1,java.time.LocalDateTime.now(),1);}
-    private static ContainerCustomsMapper.BrokerSubmissionRow brokerSubmission(){return new ContainerCustomsMapper.BrokerSubmissionRow(41L,2L,9L,"BR202610200001","SENT",3,"admin",java.time.LocalDateTime.now(),1);}
+    private static ContainerCustomsMapper.BrokerSubmissionRow brokerSubmission(){return new ContainerCustomsMapper.BrokerSubmissionRow(41L,2L,9L,"BR-LP9-01","SENT",3,"admin",java.time.LocalDateTime.now(),1);}
     private static ContainerCustomsMapper.ContainerRow container(String status,int version){return new ContainerCustomsMapper.ContainerRow(2L,9L,8L,status,null,null,null,null,null,null,null,null,version);}
     private void assertMerchantOrderNotFound(long tenantId,long orderId){
         assertThatThrownBy(()->service.merchantOrderView(tenantId,orderId))

firstleg/src/test/java/com/baiyue/firstleg/loading/coload/ColoadGroupOpenApiContractTest.java

@@ -55,7 +55,7 @@ class ColoadGroupOpenApiContractTest {
             .doesNotContain("destinationCode")
             .doesNotContain("expectedVersion")
             .doesNotContain("platform:firstleg:coload");
-        assertThat(summaryProperties).containsOnlyKeys("groupNo", "status", "memberCount", "members");
+        assertThat(summaryProperties).containsOnlyKeys("status", "memberCount", "members");
         assertThat(memberProperties).containsOnlyKeys("inboundCode");
     }
 }

firstleg/src/test/java/com/baiyue/firstleg/loading/coload/ColoadGroupServiceTest.java

@@ -37,17 +37,8 @@ import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-@SpringJUnitConfig({ColoadGroupService.class, ColoadGroupServiceTest.Numbers.class, com.baiyue.firstleg.loading.coload.persistence.ColoadGroupQueryRepository.class})
+@SpringJUnitConfig(ColoadGroupService.class)
 class ColoadGroupServiceTest {
-    @org.springframework.context.annotation.Configuration
-    static class Numbers {
-        /** 同柜组业务测试使用真实格式，序列由隔离测试替身提供。 */
-        @org.springframework.context.annotation.Bean
-        com.baiyue.firstleg.service.FirstlegDocumentNumberGenerator documentNumbers() {
-            return com.baiyue.firstleg.service.TestDocumentNumbers.documents();
-        }
-    }
-
     @MockBean
     private ColoadGroupMapper mapper;
     @MockBean private PendingReviewOrderClient pendingReviewOrders;
@@ -71,7 +62,6 @@ class ColoadGroupServiceTest {
 
         var result = service.queryByInboundCode(" IN-A ");
 
-        assertThat(result.groupNo()).isEqualTo("CLG202610210001");
         assertThat(result.status()).isEqualTo("ACTIVE");
         assertThat(result.memberCount()).isEqualTo(2);
         assertThat(result.members()).extracting("inboundCode").containsExactly("IN-A", "IN-B");
@@ -575,7 +565,6 @@ class ColoadGroupServiceTest {
     private static InboundGroupLookupRow lookup(long groupId, String status) {
         InboundGroupLookupRow value = new InboundGroupLookupRow();
         value.setGroupId(groupId);
-        value.setGroupNo("CLG202610210001");
         value.setGroupStatus(status);
         return value;
     }

firstleg/src/test/java/com/baiyue/firstleg/loading/coload/ColoadGroupSqlContractTest.java

@@ -86,8 +86,7 @@ class ColoadGroupSqlContractTest {
             .contains("requested.inbound_code=#{inboundCode}")
             .contains("requested.deleted=0")
             .contains("'ACTIVE','LOCKED','CONSUMED'")
-            .contains("group_row.group_no groupNo")
+            .doesNotContain("group_no", "order_id=#{");
-            .doesNotContain("order_id=#{");
         assertThat(memberSql)
             .contains("member.id memberId", "member.inbound_id inboundId", "inbound.inbound_code inboundCode")
             .contains("LEFT JOIN fl_inbound_order inbound")

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

@@ -44,9 +44,8 @@ class CarrierScheduleQuerySqlContractTest {
         }
     }
 
-    /** 保留批量读取，实际到港与日历采用相同的最新观测顺序。 */
     @Test
-    void batchesActualContainerFactsWithLatestObservedArrivalAndWithoutEstimatedTimes() throws Exception {
+    void batchesActualContainerFactsWithoutEstimatedOrPerNodeQueries() throws Exception {
         String sql = String.join("\n", CarrierScheduleQueryMapper.class
             .getMethod("selectContainerActualFacts", List.class)
             .getAnnotation(Select.class).value());
@@ -56,16 +55,13 @@ 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(arrival.actual_at) AS arrivedDestinationPortAt")
+            .contains("MAX(CASE WHEN f.standard_node='ARRIVED_DESTINATION_PORT'")
-            .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(5);
+        assertThat(count(sql, "fl_carrier_schedule_node_fact")).isEqualTo(3);
         assertThat(count(sql, "SELECT f2.id FROM fl_carrier_schedule_node_fact f2")).isEqualTo(1);
     }
 

firstleg/src/test/java/com/baiyue/firstleg/portschedule/service/ArrivalCalendarTest.java

@@ -14,7 +14,6 @@ class ArrivalCalendarTest {
     void rejectsInvalidRangesAndPassesTheWholeHalfOpenRangeToOneQuery() {
         var repository = mock(PortScheduleRepository.class);
         var service = new PortScheduleService();
-        org.springframework.test.util.ReflectionTestUtils.setField(service, "documentNumbers", com.baiyue.firstleg.service.TestDocumentNumbers.documents());
         ReflectionTestUtils.setField(service, "repository", repository);
         var from = LocalDate.of(2026, 9, 28);
         assertThrows(BizException.class, () -> service.arrivalCalendar(from, from));

firstleg/src/test/java/com/baiyue/firstleg/portschedule/service/PortScheduleServiceTest.java

@@ -35,8 +35,6 @@ import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 class PortScheduleServiceTest {
-    @org.mockito.Spy private com.baiyue.firstleg.service.FirstlegDocumentNumberGenerator documentNumbers = com.baiyue.firstleg.service.TestDocumentNumbers.documents();
-
     @Test
     void platformPublicQueryAllowsZeroButRejectsNegativeCustomerScope() {
         try (var factory = Validation.buildDefaultValidatorFactory()) {

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

@@ -1,76 +0,0 @@
-package com.baiyue.firstleg.repository;
-
-import com.baiyue.firstleg.mapper.DocumentSequenceMapper;
-import com.baomidou.mybatisplus.core.MybatisConfiguration;
-import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
-import org.junit.jupiter.api.Test;
-import org.mybatis.spring.SqlSessionTemplate;
-import org.springframework.aop.framework.ProxyFactory;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.datasource.*;
-import org.springframework.transaction.annotation.AnnotationTransactionAttributeSource;
-import org.springframework.transaction.interceptor.TransactionInterceptor;
-import org.springframework.transaction.support.TransactionTemplate;
-import java.util.*;
-import java.util.concurrent.*;
-import static org.assertj.core.api.Assertions.*;
-
-/** 实际 Mapper 和隔离 H2 MySQL 模式验证原子序列，不访问部署环境。 */
-class DocumentSequenceRepositoryTest {
-    private static class Fixture {
-        final JdbcTemplate jdbc;
-        final DataSourceTransactionManager transactions;
-        final DocumentSequenceMapper mapper;
-        final DocumentSequenceRepository repository;
-        /** 仅测试造表允许 JDBC；被测路径全部使用 Mapper。 */
-        Fixture() throws Exception {
-            var data=new DriverManagerDataSource("jdbc:h2:mem:"+UUID.randomUUID()+";MODE=MySQL;DB_CLOSE_DELAY=-1;LOCK_TIMEOUT=10000","sa","");
-            jdbc=new JdbcTemplate(data);transactions=new DataSourceTransactionManager(data);
-            jdbc.execute("CREATE TABLE fl_document_sequence(sequence_key VARCHAR(32) PRIMARY KEY,current_value BIGINT NOT NULL)");
-            var configuration=new MybatisConfiguration();configuration.addMapper(DocumentSequenceMapper.class);
-            var factory=new MybatisSqlSessionFactoryBean();factory.setDataSource(data);factory.setConfiguration(configuration);factory.afterPropertiesSet();
-            mapper=new SqlSessionTemplate(factory.getObject()).getMapper(DocumentSequenceMapper.class);
-            var proxy=new ProxyFactory(new DocumentSequenceRepository(mapper));proxy.setProxyTargetClass(true);
-            proxy.addAdvice(new TransactionInterceptor(transactions,new AnnotationTransactionAttributeSource()));
-            repository=(DocumentSequenceRepository)proxy.getProxy();
-        }
-    }
-    /** 日期和前缀各自独立，重复分配持续递增。 */
-    @Test void dateAndPrefixHaveIndependentSequences() throws Exception {
-        var f=new Fixture();
-        assertThat(f.repository.next("AA:20261020")).isEqualTo(1);
-        assertThat(f.repository.next("AA:20261020")).isEqualTo(2);
-        assertThat(f.repository.next("BB:20261020")).isEqualTo(1);
-        assertThat(f.repository.next("AA:20261021")).isEqualTo(1);
-    }
-    /** 两个线程使用真实事务连接并发争用，不能产生重号。 */
-    @Test void concurrentConnectionsAllocateUniqueNumbers() throws Exception {
-        var f=new Fixture();var pool=Executors.newFixedThreadPool(2);
-        try {
-            var work=new ArrayList<Callable<Long>>();
-            for(int i=0;i<64;i++)work.add(()->f.repository.next("AA:20261020"));
-            var values=new TreeSet<Long>();
-            for(var future:pool.invokeAll(work))values.add(future.get());
-            assertThat(values).hasSize(64);assertThat(values.first()).isEqualTo(1L);assertThat(values.last()).isEqualTo(64L);
-        } finally {pool.shutdownNow();}
-    }
-    /** 外层建单失败后不能把已经分配的单号再交给其他单据。 */
-    @Test void businessRollbackDoesNotReuseAllocatedNumber() throws Exception {
-        var f=new Fixture();
-        assertThatThrownBy(()->new TransactionTemplate(f.transactions).execute(status->{
-            assertThat(f.repository.next("AA:20261020")).isEqualTo(1);
-            throw new IllegalStateException("业务回滚");
-        })).isInstanceOf(IllegalStateException.class);
-        assertThat(f.repository.next("AA:20261020")).isEqualTo(2);
-    }
-    /** 同一会话中连接值变化后，读取必须绕过 MyBatis 缓存。 */
-    @Test void connectionResultIsNeverCached() throws Exception {
-        var f=new Fixture();
-        new TransactionTemplate(f.transactions).executeWithoutResult(status->{
-            f.jdbc.queryForObject("SELECT LAST_INSERT_ID(7)",Long.class);
-            assertThat(f.mapper.allocatedValue()).isEqualTo(7L);
-            f.jdbc.queryForObject("SELECT LAST_INSERT_ID(37)",Long.class);
-            assertThat(f.mapper.allocatedValue()).isEqualTo(37L);
-        });
-    }
-}

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

@@ -30,7 +30,6 @@ class MerchantWorkbenchFilterMapperTest {
         jdbc.execute("ALTER TABLE fl_loading_plan_item ADD id BIGINT GENERATED BY DEFAULT AS IDENTITY");
         jdbc.execute("CREATE TABLE fl_loading_pick_task(id BIGINT,loading_plan_id BIGINT,task_status VARCHAR(32))");
         jdbc.execute("CREATE TABLE fl_loading_pick_item(pick_task_id BIGINT,loading_plan_item_id BIGINT,item_status VARCHAR(32),picked_package_count INT)");
-        jdbc.execute("CREATE TABLE fl_container_document(container_booking_id BIGINT,document_type VARCHAR(40),file_id BIGINT)");
         jdbc.execute("CREATE TABLE fl_carrier_schedule_node_fact(container_booking_id BIGINT,standard_node VARCHAR(64),actual_at TIMESTAMP)");
         var config=new MybatisConfiguration();config.setMapUnderscoreToCamelCase(true);config.addMapper(MerchantWorkbenchFilterMapper.class);
         var factory=new MybatisSqlSessionFactoryBean();factory.setDataSource(ds);factory.setConfiguration(config);
@@ -96,12 +95,6 @@ class MerchantWorkbenchFilterMapperTest {
         jdbc.update("INSERT INTO fl_carrier_schedule_node_fact VALUES(100,'PICKUP_READY',NULL)");
         assertThat(mapper.progressFragments(11, null)).allMatch(f->f.stage()==2);
         jdbc.update("UPDATE fl_carrier_schedule_node_fact SET actual_at=CURRENT_TIMESTAMP");
-        assertThat(mapper.progressFragments(11, null)).allMatch(f->f.stage()==2);
-        // 其他柜、其他资料类型或未绑定文件不能视为清关资料提交成功。
-        jdbc.update("INSERT INTO fl_container_document VALUES(999,'DESTINATION_CLEARANCE',1),(100,'DELIVERY_ORDER',2),(100,'DESTINATION_CLEARANCE',NULL)");
-        assertThat(mapper.progressFragments(11, null)).allMatch(f->f.stage()==2);
-        jdbc.update("UPDATE fl_carrier_schedule_node_fact SET actual_at=NULL");
-        jdbc.update("UPDATE fl_container_document SET file_id=3 WHERE document_type='DESTINATION_CLEARANCE' AND container_booking_id=100");
         assertThat(mapper.progressFragments(11, null)).allMatch(f->f.stage()==3);
         assertThat(mapper.progressFragments(11,List.of(101L))).singleElement().satisfies(f->{assertThat(f.orderId()).isEqualTo(101);assertThat(f.stage()).isEqualTo(3);});
         jdbc.update("UPDATE fl_container_booking SET record_status='CANCELLED'");

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

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

firstleg/src/test/java/com/baiyue/firstleg/sailingcalendar/service/SailingCalendarServiceTest.java

@@ -24,8 +24,6 @@ import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 class SailingCalendarServiceTest {
-    @org.mockito.Spy private com.baiyue.firstleg.service.FirstlegDocumentNumberGenerator documentNumbers = com.baiyue.firstleg.service.TestDocumentNumbers.documents();
-
     @Mock private SailingCalendarRepository repository;
     @InjectMocks private SailingCalendarService service;
     private final LocalDateTime copiedDeparture = LocalDateTime.now(ZoneId.of("Asia/Shanghai")).plusDays(14);

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

@@ -1,52 +1,73 @@
 package com.baiyue.firstleg.service;
 
-import com.baiyue.firstleg.repository.DocumentSequenceRepository;
 import com.baiyue.common.core.exception.BizException;
 import org.junit.jupiter.api.Test;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
-import java.time.*;
+import org.springframework.jdbc.core.JdbcTemplate;
-import static org.assertj.core.api.Assertions.*;
+
-import static org.mockito.Mockito.*;
+import java.time.Clock;
+import java.time.Instant;
+import java.time.ZoneId;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 class FirstlegDocumentNumberGeneratorTest {
-    private static final Clock CLOCK=Clock.fixed(Instant.parse("2026-10-19T16:00:00Z"),ZoneOffset.UTC);
+    private static final Clock CLOCK = Clock.fixed(
+        Instant.parse("2026-08-18T02:00:00Z"), ZoneId.of("Asia/Shanghai"));
+
+    @Test
+    void startsAsASpringBeanWhenTheTestClockConstructorAlsoExists() {
+        JdbcTemplate jdbc = mock(JdbcTemplate.class);
+        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
+            context.registerBean(JdbcTemplate.class, () -> jdbc);
+            context.register(FirstlegDocumentNumberGenerator.class);
+            context.refresh();
 
-    /** 多构造器情况下正式依赖可以被 Spring 正确选择。 */
-    @Test void springCreatesGeneratorWithRepository() {
-        try(var context=new AnnotationConfigApplicationContext()) {
-            context.registerBean(DocumentSequenceRepository.class,()->mock(DocumentSequenceRepository.class));
-            context.register(FirstlegDocumentNumberGenerator.class);context.refresh();
             assertThat(context.getBean(FirstlegDocumentNumberGenerator.class)).isNotNull();
         }
     }
-    /** 主机使用 UTC 时仍按北京时间跨午夜，且四位流水不截断。 */
+
-    @Test void usesShanghaiDateAndIndependentSequenceKey() {
+    @Test
-        var sequences=mock(DocumentSequenceRepository.class);
+    void formatsAllOperationalDocumentPrefixes() {
-        when(sequences.next("LP:20261020")).thenReturn(1L,2L,9999L);
+        JdbcTemplate jdbc = mock(JdbcTemplate.class);
-        var numbers=new FirstlegDocumentNumberGenerator(sequences,CLOCK);
+        when(jdbc.queryForObject("SELECT LAST_INSERT_ID()", Long.class))
-        assertThat(numbers.next("LP")).isEqualTo("LP202610200001");
+            .thenReturn(1L, 1L, 1L, 1L, 1L);
-        assertThat(numbers.next("LP")).isEqualTo("LP202610200002");
+        FirstlegDocumentNumberGenerator generator = new FirstlegDocumentNumberGenerator(jdbc, CLOCK);
-        assertThat(numbers.next("LP")).isEqualTo("LP202610209999");
+
-        verify(sequences,times(3)).next("LP:20261020");
+        assertThat(generator.next("OB")).isEqualTo("OB-260818-0001");
-    }
+        assertThat(generator.next("TA")).isEqualTo("TA-260818-0001");
-    /** 未登记类型不能消耗流水，分配异常或溢出时拒绝出号。 */
+        assertThatThrownBy(() -> generator.next("CB")).isInstanceOf(IllegalArgumentException.class);
-    @Test void rejectsUnknownTypeAndOverflow() {
+        assertThat(generator.next("LP")).isEqualTo("LP-260818-0001");
-        var sequences=mock(DocumentSequenceRepository.class);
+        assertThat(generator.nextCabinetNo()).isEqualTo("D0001");
-        var numbers=new FirstlegDocumentNumberGenerator(sequences,CLOCK);
+
-        assertThatThrownBy(()->numbers.next("ZZZZ")).isInstanceOf(IllegalArgumentException.class);
+        verify(jdbc).update(org.mockito.ArgumentMatchers.startsWith("INSERT INTO fl_document_sequence"),
-        verifyNoInteractions(sequences);
+            eq("OB:20260818"));
-        when(sequences.next("LP:20261020")).thenReturn(10000L);
+        verify(jdbc).update(org.mockito.ArgumentMatchers.startsWith("INSERT INTO fl_document_sequence"),
-        assertThatThrownBy(()->numbers.next("LP")).isInstanceOf(BizException.class);
+            eq("CABINET"));
     }
 
-    /** 柜次和实物标签明确不改格式，柜次允许超过四位。 */
+    @Test
-    @Test void preservesCabinetAndPalletRules() {
+    void cabinetSequenceDoesNotResetOrStopAtFourDigits() {
-        var sequences=mock(DocumentSequenceRepository.class);
+        JdbcTemplate jdbc = mock(JdbcTemplate.class);
-        when(sequences.next("CABINET")).thenReturn(9999L,10000L);
+        when(jdbc.queryForObject("SELECT LAST_INSERT_ID()", Long.class)).thenReturn(9_999L, 10_000L);
-        when(sequences.next("DP:20261020")).thenReturn(1L);
+        FirstlegDocumentNumberGenerator generator = new FirstlegDocumentNumberGenerator(jdbc, CLOCK);
-        var numbers=new FirstlegDocumentNumberGenerator(sequences,CLOCK);
+
-        assertThat(numbers.nextCabinetNo()).isEqualTo("D9999");
+        assertThat(generator.nextCabinetNo()).isEqualTo("D9999");
-        assertThat(numbers.nextCabinetNo()).isEqualTo("D10000");
+        assertThat(generator.nextCabinetNo()).isEqualTo("D10000");
-        assertThat(numbers.next("DP")).isEqualTo("DP-261020-0001");
+    }
+
+    @Test
+    void rejectsUnsupportedTypeAndDailyOverflow() {
+        JdbcTemplate jdbc = mock(JdbcTemplate.class);
+        FirstlegDocumentNumberGenerator generator = new FirstlegDocumentNumberGenerator(jdbc, CLOCK);
+        assertThatThrownBy(() -> generator.next("MSCU")).isInstanceOf(IllegalArgumentException.class);
+
+        when(jdbc.queryForObject("SELECT LAST_INSERT_ID()", Long.class)).thenReturn(10_000L);
+        assertThatThrownBy(() -> generator.next("LP")).isInstanceOf(BizException.class);
     }
 }

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

@@ -462,9 +462,8 @@ class SmartLoadingServiceTest {
         verify(repository).occupiedOrderIds(eq(query), anySet());
     }
 
-    /** 待审核订单来自其他客户时仍可拼柜，客户归属和费用重算维持原值。 */
     @Test
-    void manuallyAssignsCrossCustomerAndChannelPendingReviewOrderAsAProvisionalContainerAllocation() {
+    void manuallyAssignsCrossChannelPendingReviewOrderAsAProvisionalContainerAllocation() {
         long customerId = 2092797167699816450L;
         long orderId = 2095052002489335810L;
         String inboundCode = "EXXHK2609020361";
@@ -504,7 +503,6 @@ class SmartLoadingServiceTest {
         assertThat(result.version()).isEqualTo(1);
         ArgumentCaptor<LoadingPlanItemEntity> item = ArgumentCaptor.forClass(LoadingPlanItemEntity.class);
         verify(repository).insert(item.capture());
-        assertThat(item.getValue().getAccountId()).isEqualTo(customerId);
         assertThat(item.getValue().getInboundId()).isEqualTo(10L);
         assertThat(item.getValue().getInboundDetailId()).isEqualTo(20L);
         assertThat(item.getValue().getPackageCount()).isEqualTo(5);
@@ -1380,31 +1378,20 @@ class SmartLoadingServiceTest {
         verify(repository, never()).touch(anyLong(), anyInt(), anyLong(), any());
     }
 
-    /** 订舱客户仅为关联资料；平台可将其他客户的货物加入同一柜次。 */
     @Test
-    void allowsManualAssignmentFromAnotherCustomerWithoutRewritingCargoOwnership() {
+    void rejectsManualAssignmentOutsideLinkedBookingCustomerScope() {
-        stubAssignment();
+        LoadingPlanEntity plan = plan("EDITING", 0);
+        ContainerBookingEntity linked = booking();
+        linked.setCustomerId(88L);
+        when(repository.plan(1L)).thenReturn(plan);
+        when(repository.booking(99L)).thenReturn(linked);
+        when(repository.candidate(1L, 10L, 20L)).thenReturn(candidate(5));
 
-        Plan result = service.assign(1L,
+        BizException error = catchThrowableOfType(() -> service.assign(1L,
-            new AssignRequest(10L, 20L, 1, 0, "assign-cross-customer"), 7L, "u");
+            new AssignRequest(10L, 20L, 1, 0, "assign-customer-mismatch"), 7L, "u"), BizException.class);
 
-        assertThat(result.version()).isEqualTo(1);
+        assertThat(error.getResultCode()).isEqualTo(ResultCode.FORBIDDEN);
-        ArgumentCaptor<LoadingPlanItemEntity> inserted = ArgumentCaptor.forClass(LoadingPlanItemEntity.class);
+        verify(repository, never()).touch(anyLong(), anyInt(), anyLong(), any());
-        verify(repository).insert(inserted.capture());
-        assertThat(inserted.getValue().getAccountId()).isEqualTo(9L);
-        assertThat(inserted.getValue().getOrderId()).isEqualTo(30L);
-        verify(cargoClient).detail(anyString(), eq(9L), eq(30L), eq(20L));
-    }
-
-    /** 同渠道候选包含不同客户，不能被订舱客户快照裁剪。 */
-    @Test
-    void listsCandidatesFromBothCustomersInALinkedBooking() {
-        when(repository.booking(99L)).thenReturn(booking());
-        when(repository.candidates(100L)).thenReturn(List.of(
-            candidate(9L, 10L, 20L, 30L, 5), candidate(88L, 11L, 21L, 31L, 4)));
-
-        assertThat(service.candidates(99L, 100L)).extracting(Candidate::accountId)
-            .containsExactly(9L, 88L);
     }
 
     @Test
@@ -2088,11 +2075,9 @@ class SmartLoadingServiceTest {
         return group;
     }
 
-    /** 所有流程默认带历史订舱客户，覆盖候选、占位、整托、调整和推荐的跨客户拼柜。 */
     private static ContainerBookingEntity booking() {
         ContainerBookingEntity value = new ContainerBookingEntity();
         value.setId(99L); value.setWarehouseId(100L); value.setDestinationWarehouseCode("FBA1");
-        value.setCustomerId(88L);
         value.setChannelGroupCode("MATSON_CLX"); value.setChannelCode(null);
         value.setContainerNo("MSCU1234567");
         value.setCapacityCbm(new BigDecimal("60")); value.setMaxWeightKg(new BigDecimal("20000"));

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

@@ -1,21 +0,0 @@
-package com.baiyue.firstleg.service;
-
-import com.baiyue.firstleg.repository.DocumentSequenceRepository;
-import java.time.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicLong;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.*;
-
-/** 业务单测使用真实格式及隔离计数器；数据库并发由 Repository 集成测试覆盖。 */
-public final class TestDocumentNumbers {
-    /** 测试工具不实例化。 */
-    private TestDocumentNumbers() {}
-    /** 每个测试生成器独立计数，类型前缀之间互不占号。 */
-    public static FirstlegDocumentNumberGenerator documents() {
-        var sequences=mock(DocumentSequenceRepository.class);
-        var counters=new ConcurrentHashMap<String,AtomicLong>();
-        lenient().when(sequences.next(anyString())).thenAnswer(call->counters.computeIfAbsent(call.getArgument(0),key->new AtomicLong()).incrementAndGet());
-        return new FirstlegDocumentNumberGenerator(sequences,Clock.fixed(Instant.parse("2026-10-20T00:00:00Z"),ZoneOffset.UTC));
-    }
-}

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

@@ -2,7 +2,6 @@ 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;
@@ -11,51 +10,6 @@ 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 {

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

@@ -13,7 +13,7 @@ import static org.mockito.Mockito.*;
 class WorkflowBoundaryTest {
     /** 真实开船来源的测试事实。 */
     private WorkflowFacts.Fact fact() {
-        return new WorkflowFacts.Fact(11,1,101,"APPROVED",true,false,false,false,false);
+        return new WorkflowFacts.Fact(11,1,101,"APPROVED",true,false,false,false);
     }
 
     /** 下游漏来源或返回其他客户均整体失败。 */
@@ -25,34 +25,12 @@ class WorkflowBoundaryTest {
         inbound.setOrderId(101L);inbound.setProcessStatus("LOADED");
         when(repository.facts(List.of(1L))).thenReturn(List.of(fact()));
         when(downstream.read(any(),any())).thenReturn(ApiResponse.success(List.of()));
-        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class)
+        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class);
-            .hasMessage("订单业务页签事实暂不可用，请稍后重试")
-            .hasRootCauseMessage("尾程事实缺少来源 expected=1 actual=0 missing=[Source[tenantId=11, inboundId=1]]");
         when(downstream.read(any(),any())).thenReturn(ApiResponse.success(List.of(
             new WorkflowFacts.Overseas(22,1,true,true,false,true))));
         assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class);
-        var failure=new IllegalStateException("unavailable");
+        when(downstream.read(any(),any())).thenThrow(new IllegalStateException("unavailable"));
-        when(downstream.read(any(),any())).thenThrow(failure);
+        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class);
-        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class).hasCause(failure);
-    }
-
-    /** 未记录离港时，报关完成即可待清关；上传清关资料后也必须查询精确海外来源。 */
-    @Test void completedCustomsAndClearanceUploadDoNotWaitForDeparture() {
-        var repository=mock(WorkflowFactRepository.class);
-        var downstream=mock(LastlegWorkflowClient.class);
-        var service=new WorkflowTabService(repository,downstream);
-        var inbound=new InboundOrderEntity();inbound.setId(1L);inbound.setTenantId(11L);
-        inbound.setOrderId(101L);inbound.setProcessStatus("LOADED");
-        when(repository.facts(List.of(1L))).thenReturn(List.of(
-            new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,false,true,true)));
-        assertThat(service.rows(List.of(inbound))).extracting(r->r.mainStatus()).containsExactly("SAILING_CLEARANCE");
-        verifyNoInteractions(downstream);
-        when(repository.facts(List.of(1L))).thenReturn(List.of(
-            new WorkflowFacts.Fact(11,1,101,"APPROVED",false,true,false,true,true)));
-        when(downstream.read(any(),any())).thenReturn(ApiResponse.success(List.of(
-            new WorkflowFacts.Overseas(11,1,false,false,false,false))));
-        assertThat(service.rows(List.of(inbound))).extracting(r->r.mainStatus()).containsExactly("WAIT_UNLOAD","WAIT_DISPATCH");
-        verify(downstream).read(any(),eq(new WorkflowFacts.Request(List.of(new WorkflowFacts.Source(11,1)))));
     }
 
 }

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

@@ -3,46 +3,33 @@ import org.junit.jupiter.api.Test;
 import static org.assertj.core.api.Assertions.*;
 /** 取消回显、分柜隔离和资料页签回归。 */
 class WorkflowBusinessTest {
-    /** 报关完成进入待清关，清关资料保存后才进入拆柜与排车待办。 */
+    /** 报关资料齐备进入汇总，实际开船及清关资料分别驱动后续页签。 */
     @Test void customsDocumentsDepartureAndClearanceDriveTabs() {
-        var missing=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,true,false,false);
+        var missing=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,true,false);
-        var uploaded=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,false,true,false);
+        var uploaded=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,false,true);
-        var departed=new WorkflowFacts.Fact(11,1,101,"APPROVED",true,false,false,true,false);
+        var departed=new WorkflowFacts.Fact(11,1,101,"APPROVED",true,false,false,true);
-        var cleared=new WorkflowFacts.Fact(11,1,101,"APPROVED",true,true,false,true,false);
+        var cleared=new WorkflowFacts.Fact(11,1,101,"APPROVED",true,true,false,true);
-        var completed=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,false,true,true);
+        var uploadedBeforeDeparture=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,true,false,true);
-        var uploadedBeforeDeparture=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,true,false,true,false);
         var pendingUnload=new WorkflowFacts.Overseas(11,1,false,false,false,false);
         var unloaded=new WorkflowFacts.Overseas(11,1,false,false,false,true);
         assertThat(WorkflowTabService.classify(missing,"LOADED",null))
             .contains("WAIT_CUSTOMS_DOCS").doesNotContain("EXPORT_CUSTOMS","SAILING_CLEARANCE","WAIT_UNLOAD");
         assertThat(WorkflowTabService.classify(uploaded,"LOADED",null))
             .contains("EXPORT_CUSTOMS").doesNotContain("WAIT_CUSTOMS_DOCS","SAILING_CLEARANCE","WAIT_UNLOAD");
-        assertThat(WorkflowTabService.classify(completed,"LOADED",null))
-            .containsExactly("SAILING_CLEARANCE");
         assertThat(WorkflowTabService.classify(uploadedBeforeDeparture,"LOADED",pendingUnload))
-            .containsExactly("WAIT_UNLOAD","WAIT_DISPATCH");
+            .contains("EXPORT_CUSTOMS").doesNotContain("SAILING_CLEARANCE","WAIT_UNLOAD");
         assertThat(WorkflowTabService.classify(departed,"LOADED",pendingUnload))
-            .containsExactly("SAILING_CLEARANCE");
+            .contains("SAILING_CLEARANCE").doesNotContain("WAIT_CUSTOMS_DOCS","EXPORT_CUSTOMS","WAIT_UNLOAD");
         assertThat(WorkflowTabService.classify(cleared,"LOADED",pendingUnload))
-            .containsExactly("WAIT_UNLOAD","WAIT_DISPATCH");
+            .contains("WAIT_UNLOAD").doesNotContain("WAIT_CUSTOMS_DOCS","EXPORT_CUSTOMS","SAILING_CLEARANCE");
         assertThat(WorkflowTabService.classify(cleared,"LOADED",unloaded))
             .doesNotContain("WAIT_UNLOAD","SAILING_CLEARANCE","EXPORT_CUSTOMS");
         assertThat(WorkflowTabService.classify(uploaded,"DELIVERED",unloaded))
             .contains("SIGNED").doesNotContain("EXPORT_CUSTOMS","WAIT_CUSTOMS_DOCS");
     }
-    /** 清关前不能被海外建单事实提前推进，清关后出库与派送依次替换待办。 */
-    @Test void downstreamFactsCannotBypassClearanceAndOutboundReplacesQueues() {
-        var pending=new WorkflowFacts.Overseas(11,1,true,true,false,false);
-        var shipped=new WorkflowFacts.Overseas(11,1,true,false,true,false);
-        assertThat(WorkflowTabService.classify(fact(1,false),"LOADED",pending)).containsExactly("SAILING_CLEARANCE");
-        assertThat(WorkflowTabService.classify(fact(1,false),"LOADED",shipped)).containsExactly("SAILING_CLEARANCE");
-        assertThat(WorkflowTabService.classify(fact(1,true),"LOADED",pending)).containsExactly("OUTBOUND_DOCUMENT");
-        assertThat(WorkflowTabService.classify(fact(1,true),"LOADED",shipped)).containsExactly("DELIVERING");
-        assertThat(WorkflowTabService.classify(fact(1,true),"DELIVERED",shipped)).containsExactly("SIGNED");
-    }
     /** 构造独立分柜来源。 */
     private WorkflowFacts.Fact fact(long id,boolean uploaded) {
-        return new WorkflowFacts.Fact(11,id,100+id,"APPROVED",true,uploaded,false,false,false);
+        return new WorkflowFacts.Fact(11,id,100+id,"APPROVED",true,uploaded,false,false);
     }
     /** 有效建单移出待排车，取消后恢复；实际出库不计未出库单。 */
     @Test void cancellationRestoresDispatchQueue() {
@@ -58,9 +45,9 @@ class WorkflowBusinessTest {
     /** 一柜资料上传不覆盖另一柜；签收不再进入待排。 */
     @Test void independentSlicesAndUploadedClearance() {
         assertThat(WorkflowTabService.classify(fact(1,false),"LOADED",new WorkflowFacts.Overseas(11,1,false,false,false,false)))
-            .containsExactly("SAILING_CLEARANCE");
+            .contains("SAILING_CLEARANCE","WAIT_DISPATCH").doesNotContain("WAIT_UNLOAD");
         assertThat(WorkflowTabService.classify(fact(2,true),"LOADED",new WorkflowFacts.Overseas(11,2,true,true,false,false)))
-            .containsExactly("OUTBOUND_DOCUMENT");
+            .contains("WAIT_UNLOAD","OUTBOUND_DOCUMENT").doesNotContain("SAILING_CLEARANCE","WAIT_DISPATCH");
         assertThat(WorkflowTabService.classify(fact(1,false),"DELIVERED",null)).contains("SIGNED").doesNotContain("WAIT_DISPATCH");
     }
 }

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

@@ -60,11 +60,10 @@ class WorkflowFactPersistenceTest {
         db.update("INSERT INTO fl_customs_customer_document VALUES(10,11,'ACTIVE',8)");
         db.update("INSERT INTO fl_customs_customer_document_inbound VALUES(1,11,10)");
         assertThat(mapper.facts(List.of(1L))).singleElement().satisfies(f->{assertThat(f.missingCustoms()).isFalse();assertThat(f.exportCustomsReady()).isTrue();});
-        // 本票资料上传后进入出口报关汇总，报关完成事实独立驱动待清关。
+        // 本票上传后即可汇总，不必等同柜其他票或点击开始报关；完成报关后仍等待实际开船。
         for (String status : List.of("READY_TO_START", "DECLARING", "COMPLETED")) {
             db.update("UPDATE fl_customs_container SET status=? WHERE id=8", status);
             assertThat(mapper.facts(List.of(1L)).get(0).exportCustomsReady()).isTrue();
-            assertThat(mapper.facts(List.of(1L)).get(0).customsCompleted()).isEqualTo("COMPLETED".equals(status));
         }
         db.update("UPDATE fl_customs_customer_document SET status='DELETED' WHERE id=10");
         assertThat(mapper.facts(List.of(1L))).singleElement().satisfies(f->{

lastleg-service/AGENTS.md

@@ -17,8 +17,6 @@
 
 拼车余位发布查 `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只查部署主契约。
-
 事件重试：`controller/EventOperationsController.java`，内部 `/internal/lastleg/event-operations/{entryId}` 查询、`/retry` 写入；仅卸柜、派送、暂扣、资金及费用事件，以 `EVENT_OPERATIONS_TOKEN` 保护。原事件不可改，DEAD→PENDING 与 `event_delivery_retry_audit` 同事务；脚本 `scripts/event-outbox-operations.mjs`。
 
 沿代码追踪；状态、权限、资源或接口边界不明时，定向检索 `docs/business-index.md`；局部任务不扩读无关约束。
@@ -57,7 +55,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`；自动发运编排`dispatch/service/DispatchLoadingDepartureService.java` |
+| 草稿、双端装发与派送安排 | `dispatch/controller/SmartDispatchController.java`、`dispatch/pda/controller/DispatchPdaController.java`；平台维护`DispatchController.java`，派送组合`delivery/controller/DeliveryTransferController.java` |
 | 仓储资源调用 | `inboundplan/pda/gateway/WarehouseResourceGateway.java` |
 | 仓储转运、历史订单/入仓绑定、可选换标联动 | `transfer/controller/WarehouseTransferController.java` |
 | 一件代发接收、SKU/箱唛库存 | `dropship/controller/DropshipOrderController.java` |
@@ -77,7 +75,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，不把计划值当实测值，资源/计划/关联变更后须重新核对 |
-| 实物装载、逐段容量与双端整车发车 | 两端`dispatches/{dispatchNo}/loading-complete`统一调用`dispatch/service/DispatchLoadingDepartureService.java`，同一事务复用实载确认、派送单准备及发车，成功直接`DELIVERING`；请求携带唯一`recordVersion`，原键恢复最终结果。公开手工安排派送、`/depart`入口已移除；内部`AFTER_LOADING`和步骤命令只用于事务编排。真实PDA拣货须核平，不重复库存SHIP，Fleet容量和资源资格仍复核；未知费用不补零、不阻塞发运，真实已明确外接报价沿原费用来源防重 |
+| 实物装载、逐段容量与双端整车发车 | `dispatch/pda/controller/DispatchPdaController.java` → `dispatch/service/DispatchAggregateService.java`（装车）、`DispatchDepartureService.java`（发车）；平台与PDA均使用本端`dispatches/{dispatchNo}/loading-complete`及`/depart`，公共DTO在`dispatch/port/`，已有单写入唯一`recordVersion`。装车前须真实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,7 @@
 
 - 车次成本：`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/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 +94,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` 为正式入口：一张排车单代表一趟车；Admin/PDA确认`loading-complete`时，同一事务自动按客户与目的仓生成派送单并发车，成功直接进入`DELIVERING`。公开手工安排派送及`/depart`入口已删除；内部`AFTER_LOADING`仅是同事务中间态。`DispatchPdaWorkflowService` 按公开 `status`、`stage`、`recordVersion` 和 `actions` 返回作业事实与资格，Admin/PDA 共用服务端规则；BOL 与签收资料归拆分后的派送单，费用按其来源去重，不以旧转派送阶段或前端推算代替资格校验。
+- 排车主流程以工作区 `docs/海外仓业务/排车列表统一作业改造契约.md` 为正式入口：一张排车单代表一趟车，装车完成后、实际发车前由后台安排派送，按客户与目的仓拆分派送单。`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/docs/lastleg-internal-modularization-baseline.md

@@ -15,7 +15,7 @@
 ### 预约、车队与导出依赖收口（2026-10-12）
 
 - 预约规划只声明 `AppointmentSourceLinker` 端口；入仓域负责创建入口与关联明细实现，入仓请求声明自己的来源 DTO，再映射到规划模型。公开 JSON、事务及来源校验保持不变，规划包不反向依赖入仓实现。
-- 车队商业单使用本域的收货证据和签收快照；派送域实现车队声明的证据端口并提供完整签收事实，车队不再导入派送实体、Mapper 或完成策略。商业单编号沿用 LB/TR 前缀，通过共享编号组件按工作区 `docs/业务单据编号契约.md` 分配，各入口共用本库日流水；`fleet.business` 不反向依赖 `fleet.trip`。既有散板、卡车商业单的同库写入不在此次拆分范围，本次门禁通过不代表完成全域解耦。
+- 车队商业单使用本域的收货证据和签收快照；派送域实现车队声明的证据端口并提供完整签收事实，车队不再导入派送实体、Mapper 或完成策略。商业单编号保持原 LB/TR 规则，由本域生成；`fleet.business` 不反向依赖 `fleet.trip`。既有散板、卡车商业单的同库写入不在此次拆分范围，本次门禁通过不代表完成全域解耦。
 - 退货客户引用与转仓 FBA 目录各由本域内部客户端读取原权威服务，移除对车队客户端的借用；接口、令牌及 URL 配置不变。退货合箱共用 PDA 仓身份、转仓实收共用仓储资源网关，两条精确类边在基线中登记。
 - 平台导出作为组合入口，仅登记 `LastlegExportProviderService` 对 12 个公开查询服务与 DTO/投影的引用，不开放整个切片；车辆仍限应用层。排车规划适配器只使用车队公开规划和收货端口。采购对海外主数据的旧依赖已不存在，移除该旧许可及入向断言。
 - 反向检查继续拒绝新消费者、导出直连持久化、车辆应用层外向依赖和任何主源码包循环。分析器继续按既有显式 import、静态 import 及同包类型引用规则检查；本次不改变其识别范围。
@@ -28,10 +28,6 @@
 
 `fleet.ownedbusiness`只为原排车装车后的自有车辆组合运营资料。五条精确引用限`OwnedBusinessModels→DispatchViews`、`OwnedBusinessProjection→DispatchContracts`、`OwnedBusinessQueryService→DispatchContracts/DispatchTypes/DispatchDetailReader`，均为`dispatch.port`公开事实或只读应用端口；不增加`fleet→dispatch-delivery`通用许可，不共享原排车实体、Mapper或具体Service。原详情适配器在dispatch内部委托唯一提供者。`DispatchAggregateService→OwnedBusinessOwnershipCapture`仅在原装车事务捕获归属，不能反向调用运营查询；捕获失败随原确认回滚。反向合同拒绝具体持久化/Service引用、其他消费者借用端口许可及任何包循环。
 
-### 外配业务原排车详情读取边界（2026-10-21）
-
-`OutsourcedBusinessModels → DispatchViews` 仅组合既有 `dispatch.port` 公开详情。依赖登记与已有外配反向合同同步，不开放 `fleet→dispatch-delivery` 通用许可；原排车实体、Mapper、具体 Service 及其他消费者仍由门禁拒绝。
-
 ### 平台自营统计边界
 
 `selfoperated/analytics/` 在依赖分析器中作为独立 `selfoperated-analytics` 切片优先匹配，其 `outbound`、`inventory` 和 `model` 子包不归入客户出库、客户库存或尾程交接切片。该子域通过内部 HTTP 使用 Integration，持久化十张独立 `ll_selfop_*` 表，不引用现有客户履约实体或 Mapper。唯一基础能力引用为 `SelfopEgressController → security.InternalServiceTokenGuard`，复用内部令牌校验；基线仅登记此精确类边，不增加共享技术切片通配许可，包循环仍按同一门禁拒绝。
@@ -40,7 +36,7 @@
 
 车次关联客户排车单新增 `dispatch-delivery→fleet`：fleet声明 `FleetDispatchGateway`，dispatch内适配器锁定自身排车/出库/派送并同步车和司机快照；子排车修改与发车使用fleet公开的关联门禁。fleet不导入dispatch实体、Mapper或业务服务，因此不新增双向切片依赖。车次与客户单据的归属不变，关联和同步处于同一Lastleg事务；客户单据已经开工时不允许通过改派覆盖执行事实。
 
-当前分析器把 `wallet.WalletCommandOutboxService` 归入 `shared-technical`，它依赖尾程Outbox实体/Mapper；粗粒度图因而存在 `fleet→shared-technical→tailleg-handoff→dispatch-delivery→fleet` 聚合环。不能把这一聚合环等同于fleet包或Spring组件循环，也不能宣称切片图无环。门禁检查实际包无环，fleet仅允许上述自有运营的五条公开只读引用及外配详情的一条公开模型引用，dispatch只使用公开端口/门禁；粗粒度切片图保留为耦合报告，不因门禁通过隐去聚合环。
+当前分析器把 `wallet.WalletCommandOutboxService` 归入 `shared-technical`，它依赖尾程Outbox实体/Mapper；粗粒度图因而存在 `fleet→shared-technical→tailleg-handoff→dispatch-delivery→fleet` 聚合环。不能把这一聚合环等同于fleet包或Spring组件循环，也不能宣称切片图无环。门禁检查实际包无环，fleet仅允许上节自有运营的五条公开只读引用，dispatch只使用公开端口/门禁；粗粒度切片图保留为耦合报告，不因门禁通过隐去聚合环。
 
 2026-10-02 新增 `fleet` 业务切片，归入当前 Lastleg 部署单元；司机档案与文件适配在 `fleet/driver`，计划与资源占用在 `fleet/trip`，纯资格、分段容量和成本分摊在 `fleet/domain`。fleet依赖技术HTTP配置，以及车辆应用层的 `VehicleRepository` / `VehicleAssignmentGuard` 端口和已有状态服务；新增 `fleet→overseas-master-data` 是同一物理车辆主档和车次占用的明确业务协作，不允许直接依赖车辆持久化适配器。车辆应用层继续只依赖自身端口，注入的占用检查实现归fleet。分析器显式分类并验证这些边界，旧统计及退役安全投影断言不代表当前架构事实。
 

lastleg-service/scripts/analyze-lastleg-dependencies.test.mjs

@@ -50,10 +50,7 @@ test('fleet stays a business slice and its policies have no infrastructure depen
   const policyClasses = classes.filter(entry => entry.packageName === 'com.baiyue.lastleg.fleet.domain');
   assert.equal(policyClasses.length, 3);
   for (const entry of policyClasses) assert.ok(entry.imports.every(imported => imported.startsWith('java.')));
-  const reviewed = JSON.parse(readFileSync(contract, 'utf8')).reviewedClassDependencies;
+  assert.deepEqual(report.sliceEdges.filter(edge => edge.source === 'fleet').map(edge => edge.target).sort(), ['dispatch-delivery', 'overseas-master-data', 'shared-technical']);
-  const commercialEdges = report.classDependencies.filter(edge => edge.source.startsWith('com.baiyue.lastleg.fleet.') && /com\.baiyue\.lastleg\.(trucking|looseboard|procurement)\./.test(edge.target));
-  assert.ok(commercialEdges.every(edge => reviewed.some(allowed => allowed.source === edge.source && allowed.target === edge.target)), 'commercial integration only uses individually reviewed class references');
-  assert.deepEqual(report.sliceEdges.filter(edge => edge.source === 'fleet').map(edge => edge.target).sort(), ['dispatch-delivery', 'overseas-master-data', ...(commercialEdges.length ? ['procurement-trucking-looseboard'] : []), 'shared-technical']);
   for (const edge of report.classDependencies.filter(edge => edge.source.startsWith('com.baiyue.lastleg.fleet.') && edge.target.startsWith(vehiclePrefix))) {
     assert.ok(edge.target.startsWith(vehiclePrefix + '.application.'), 'fleet must use vehicle application ports, not persistence adapters');
   }
@@ -71,13 +68,7 @@ test('fleet stays a business slice and its policies have no infrastructure depen
     || edge.source === 'com.baiyue.lastleg.dispatch.fleet.PdaFleetHandoverController'
       && edge.target === 'com.baiyue.lastleg.fleet.exception.FleetHandoverPdaQuery'
     || edge.source === 'com.baiyue.lastleg.dispatch.service.DispatchAggregateService'
-      && edge.target === 'com.baiyue.lastleg.fleet.ownedbusiness.port.OwnedBusinessOwnershipCapture'
+      && edge.target === 'com.baiyue.lastleg.fleet.ownedbusiness.port.OwnedBusinessOwnershipCapture'),
-    || [
-      'TransportTaskModels->pickup.FleetPickupModels', 'TransportTaskModels->trip.FleetTripModels',
-      'TransportTaskProjection->trip.FleetTripEntity', 'TransportTaskProjection->trip.TransportTripChanged',
-      'TransportTaskService->business.FleetPoolOrderQueries', 'TransportTaskService->driver.DriverService',
-      'TransportTaskService->reporting.TripOperationsEvidenceGateway',
-    ].some(reference => `${edge.source}->${edge.target}` === `com.baiyue.lastleg.dispatch.transport.${reference.replace('->', '->com.baiyue.lastleg.fleet.')}`)),
     'dispatch must use fleet ports and guards, not its persistence mappers');
   const incomingEdges = report.classDependencies.filter(edge => edge.source.startsWith('com.baiyue.lastleg.transfer.') && edge.target.startsWith('com.baiyue.lastleg.fleet.'));
   assert.ok(incomingEdges.length > 0);

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

@@ -37,6 +37,25 @@ 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/DeliveryTransferService.java

@@ -132,7 +132,6 @@ public class DeliveryTransferService {
     @Resource private com.baiyue.lastleg.delivery.repository.DeliveryCancellationRepository cancellations;
     @Resource private com.baiyue.lastleg.delivery.repository.OutboundQuantityRepository outboundQuantities;
 
-    /** 创建一件代发出库任务，使用独立的 DFCK 日流水标识。 */
     @Transactional
     public DeliveryResponses.PdaTask createOneClick(String customerId, String operatorId, DeliveryRequests.OneClickOutbound request) {
         String requestHash = oneClickRequestHash(request);
@@ -146,7 +145,7 @@ public class DeliveryTransferService {
         String selectedWarehouseId = required(firstPosition.getOverseasWarehouseId(), "库存缺少所属海外仓");
         OutboundOrder outbound = new OutboundOrder();
         outbound.setId(IdWorker.getId()); outbound.setCustomerId(customerId);
-        outbound.setOutboundNo(orderNoGenerator.next("ONE_CLICK_DROPSHIP"));
+        outbound.setOutboundNo(orderNoGenerator.next("ONE_CLICK_DROPSHIP", selectedWarehouseId, outbound.getId()));
         outbound.setOutboundType("ONE_CLICK_DROPSHIP"); outbound.setStatus("WAIT_PICK"); outbound.setRecipientInfo(request.recipient().trim());
         outbound.setPackageCount(request.items().stream().mapToInt(i -> i.packages().intValue()).sum()); outbound.setPalletCount(request.items().size());
         outbound.setIdempotencyKey(request.idempotencyKey().trim()); outbound.setCreatedBy(operatorId); outbound.setCreatedAt(now); outbound.setUpdatedAt(now);
@@ -228,7 +227,6 @@ public class DeliveryTransferService {
                 value(c.getTotalQuantity()), c.getStatus())).toList();
     }
 
-    /** 校验退货库存后建立出库和派送单，各自分配业务日流水。 */
     @Transactional
     public DeliveryResponses.PdaTask createReturnOutbound(String customerId, String operatorId,
                                                            DeliveryRequests.ReturnOutbound request) {
@@ -281,7 +279,7 @@ public class DeliveryTransferService {
         }
         OutboundOrder outbound = new OutboundOrder();
         outbound.setId(IdWorker.getId()); outbound.setCustomerId(customerId);
-        outbound.setOutboundNo(orderNoGenerator.next("RETURN_OUTBOUND"));
+        outbound.setOutboundNo(orderNoGenerator.next("RETURN_OUTBOUND", warehouseId, outbound.getId()));
         outbound.setOutboundType("RETURN_OUTBOUND"); outbound.setStatus("WAIT_PICK");
         outbound.setRecipientInfo(request.recipient().trim()); outbound.setPackageCount(locked.size()); outbound.setPalletCount("PALLET".equals(request.unitType()) ? 1 : 0);
         outbound.setOverseasWarehouseId(warehouseId); outbound.setIdempotencyKey(request.idempotencyKey().trim());
@@ -298,7 +296,7 @@ public class DeliveryTransferService {
             carton.setStatus("OUTBOUND_PENDING"); carton.setUpdatedAt(now); returnCartons.updateById(carton);
         }
         DeliveryOrder delivery = new DeliveryOrder(); delivery.setId(IdWorker.getId()); delivery.setCustomerId(customerId);
-        delivery.setDeliveryNo(orderNoGenerator.next("DELIVERY"));
+        delivery.setDeliveryNo(orderNoGenerator.next("DELIVERY", warehouseId, delivery.getId()));
         delivery.setOutboundOrderId(outbound.getId()); delivery.setOutboundNo(outbound.getOutboundNo());
         delivery.setOverseasWarehouseId(warehouseId); delivery.setDeliveryGroupKey("RETURN:" + request.returnNo().trim());
         delivery.setStatus("WAIT_DELIVERY"); delivery.setDeliveryAddress(request.recipient().trim());
@@ -360,7 +358,6 @@ public class DeliveryTransferService {
         return result;
     }
 
-    /** 为仓储转运建立普通出库和派送单，保留原库存关联。 */
     @Transactional
     public DeliveryResponses.OutboundDetail createWarehouseTransferOutbound(String customerId, String operatorId,
         DeliveryRequests.WarehouseTransferOutbound request) {
@@ -400,7 +397,7 @@ public class DeliveryTransferService {
         LocalDateTime now = LocalDateTime.now();
         OutboundOrder outbound = new OutboundOrder();
         outbound.setId(IdWorker.getId()); outbound.setCustomerId(customerId);
-        outbound.setOutboundNo(orderNoGenerator.next("OUTBOUND"));
+        outbound.setOutboundNo(orderNoGenerator.next("OUTBOUND", transfer.getOperatingWarehouseId(), outbound.getId()));
         outbound.setOverseasWarehouseId(transfer.getOperatingWarehouseId());
         outbound.setOutboundType("WAREHOUSE_TRANSFER_OUTBOUND"); outbound.setStatus("WAIT_PICK");
         outbound.setRecipientInfo("PRIVATE".equals(destinationType)
@@ -437,7 +434,7 @@ public class DeliveryTransferService {
         LastlegOrder tailOrder = tailOrders.selectById(transfer.getLastlegOrderId());
         DeliveryOrder delivery = new DeliveryOrder();
         delivery.setId(IdWorker.getId()); delivery.setCustomerId(customerId);
-        delivery.setDeliveryNo(orderNoGenerator.next("DELIVERY"));
+        delivery.setDeliveryNo(orderNoGenerator.next("DELIVERY", transfer.getOperatingWarehouseId(), delivery.getId()));
         delivery.setOutboundOrderId(outbound.getId()); delivery.setOutboundNo(outbound.getOutboundNo());
         delivery.setOverseasWarehouseId(transfer.getOperatingWarehouseId());
         delivery.setCustomerName(tailOrder == null ? null : tailOrder.getCustomerName());

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

@@ -126,56 +126,11 @@ 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();
             var order=new OutboundOrder();order.setId(IdWorker.getId());order.setCustomerId(customer);
-            order.setOutboundNo(numbers.next("OUTBOUND"));
+            order.setOutboundNo(numbers.next("OUTBOUND",context.warehouseId(),order.getId()));
             order.setDispatchOrderId(context.dispatchId());order.setDispatchNo(context.dispatchNo());order.setOverseasWarehouseId(context.warehouseId());
             order.setOutboundType("DISPATCH_DELIVERY");order.setStatus("WAIT_OUTBOUND");order.setLxCodes("");
             order.setPackageCount(Math.toIntExact(cargo.stream().mapToLong(CargoLine::packages).sum()));
@@ -214,9 +169,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(commandKey);arrangement.setOriginalOperatorId(actor.operatorId());
+        arrangement.setOriginalCommandKey(request.idempotencyKey());arrangement.setOriginalOperatorId(actor.operatorId());
         arrangement.setResultJson(write(result));arrangement.setCargoJson(write(context.cargo()));arrangement.setCreatedAt(local(now));repository.create(arrangement);
-        return fact(arrangement);
+        return execution.recordArrangement(context,actor,identity,fact(arrangement),false);
     }
 
     /** 发车先取得全部出库锁，再取得全部派送锁，当前读取不申请来源锁。 */
@@ -321,12 +276,12 @@ public class DispatchDeliveryService implements DispatchDeliveryPort {
     /** 客户、目的地和车辆司机仅来自权威事实，请求不能覆盖本趟资源。 */
     private DeliveryOrder delivery(Context context,Group group,ArrangeGroup input,OutboundOrder outbound,String operator,String key,Instant now) {
         var d=new DeliveryOrder();d.setId(IdWorker.getId());d.setCustomerId(group.customerId());d.setCustomerName(group.customerName());
-        d.setDeliveryNo(numbers.next("DELIVERY"));d.setOutboundOrderId(outbound.getId());d.setOutboundNo(outbound.getOutboundNo());
+        d.setDeliveryNo(numbers.next("DELIVERY",context.warehouseId(),d.getId()));d.setOutboundOrderId(outbound.getId());d.setOutboundNo(outbound.getOutboundNo());
         d.setDispatchOrderId(context.dispatchId());d.setDispatchNo(context.dispatchNo());d.setOverseasWarehouseId(context.warehouseId());d.setOverseasWarehouseName(context.warehouseName());
         var destination=group.destination();d.setDeliveryGroupKey(grouping.documentGroupKey(destination));d.setDestinationType(destination.type());
         d.setDestinationWarehouseId(destination.warehouseId());d.setDestinationWarehouseCode(destination.warehouseCode());d.setDestinationWarehouseName(destination.warehouseName());
         d.setDeliveryAddress(destination.address());d.setPostalCode(destination.postalCode());d.setContactName(destination.contactName());d.setContactPhone(destination.contactPhone());
-        d.setStatus("WAIT_DELIVERY");d.setVersion(0L);d.setDeliveryMethod(input.deliveryMethod());d.setPlannedDeliveryAt(input.plannedDeliveryAt()==null?null:local(input.plannedDeliveryAt()));
+        d.setStatus("WAIT_DELIVERY");d.setVersion(0L);d.setDeliveryMethod(input.deliveryMethod());d.setPlannedDeliveryAt(local(input.plannedDeliveryAt()));
         d.setWaybillNo(input.waybillNo());d.setCarrierName(input.carrierName());d.setPickupMethod(input.pickupMethod());d.setLoadingType(input.loadingType());
         d.setVehicleType(input.vehicleType());d.setVehicleSize(input.vehicleSize());d.setAppointmentAccount(input.appointmentAccount());d.setSellerName(input.sellerName());d.setRemark(input.remark());
         if(context.resources()!=null){if(context.resources().vehicle()!=null)d.setVehiclePlate(context.resources().vehicle().plate());

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

@@ -48,7 +48,7 @@ public class CargoDiscardOutboundService {
         LocalDateTime at = LocalDateTime.now();
         OutboundOrder outbound = new OutboundOrder();
         outbound.setId(IdWorker.getId()); outbound.setCustomerId(application.getCustomerId());
-        outbound.setOutboundNo(orderNoGenerator.next("OUTBOUND"));
+        outbound.setOutboundNo(orderNoGenerator.next("OUTBOUND", application.getOverseasWarehouseId(), outbound.getId()));
         outbound.setOverseasWarehouseId(application.getOverseasWarehouseId()); outbound.setOutboundType(TYPE);
         outbound.setLxCodes(null); outbound.setRecipientInfo("废弃单 " + application.getDiscardNo());
         outbound.setStatus("WAIT_PICK"); outbound.setPackageCount(com.baiyue.lastleg.discard.model.CargoDiscardQuantities.boxes(lines, false));

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

@@ -222,7 +222,7 @@ public class CargoDiscardService {
         if (!StringUtils.hasText(warehouseName)) warehouseName = warehouseNames().get(warehouseId);
         CargoDiscardApplication application = new CargoDiscardApplication();
         application.setId(IdWorker.getId()); application.setCustomerId(customerId);
-        application.setDiscardNo(orderNoGenerator.next("DISCARD"));
+        application.setDiscardNo(orderNoGenerator.next("DISCARD", warehouseId, application.getId()));
         application.setOverseasWarehouseId(warehouseId); application.setOverseasWarehouseName(warehouseName);
         application.setInboundCodes(java.util.stream.Stream.concat(
             java.util.stream.Stream.concat(orderCache.values().stream().map(LastlegOrder::getInboundCode),

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.DispatchLoadingDepartureService loadingDeparture;
+    @jakarta.annotation.Resource private com.baiyue.lastleg.dispatch.service.DispatchDepartureService departure;
 
     /** 注入本域应用服务。 */
     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(loadingDeparture.complete(DispatchActorFactory.platform(user),dispatchNo,request));
+        return ApiResponse.success(service.loadingComplete(DispatchActorFactory.platform(user),dispatchNo,request));
     }
-    /** 派送异常登记不触发签收或退货入库。 */
+    /** 与PDA共用实际发车服务和公共版本，未完整安排派送不能发车。 */
-    @PostMapping("/{dispatchNo}/exceptions")
+    @PostMapping("/{dispatchNo}/depart")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
+    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:depart')")
-    public ApiResponse<CommandResult> markException(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@RequestBody DispatchCommands.MarkException request) {
+    public ApiResponse<CommandResult> depart(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@RequestBody DispatchCommands.Depart request) {
-        return ApiResponse.success(service.markException(DispatchActorFactory.platform(user),dispatchNo,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)
-    @PreAuthorize("hasAnyAuthority('platform:overseas-warehouse:dispatch:edit','platform:fleet:trip:dispatch-review','platform:fleet:trip:loading-review')")
+    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
     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(required=false) String warehouseId,
+    public ApiResponse<CandidateList> candidates(@AuthenticationPrincipal AuthenticatedUser user,@RequestParam 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

@@ -8,7 +8,6 @@ import java.time.LocalDateTime;
 public class DispatchAggregate {
     private Long id;
     private String dispatchNo;
-    private String taskType;
     private Long tripId;
     private String overseasWarehouseId;
     private String overseasWarehouseCode;
@@ -24,7 +23,6 @@ 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, DRIVER_PHOTO, EXCEPTION }
+    enum Kind { VEHICLE, DRIVER }
     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 || !supportedType(kind,file.getContentType()))throw invalid();
+        if(file==null || file.isEmpty() || file.getSize()>MAX || !TYPES.contains(Objects.toString(file.getContentType(),"")))throw invalid();
         var body=new MultipartBodyBuilder();
         try { body.part("file",new ByteArrayResource(file.getBytes()) {
             /** 保留用户文件名供审阅，不把路径当业务事实。 */
@@ -80,13 +80,9 @@ 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()
-            || !supportedType(kind,value.contentType()) || value.sizeBytes()==null || value.sizeBytes()<=0 || value.sizeBytes()>MAX)throw invalid();
+            || !TYPES.contains(Objects.toString(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

@@ -14,11 +14,7 @@ public interface DispatchAggregateMapper {
         <if test='q.dispatchNo != null'> AND d.dispatch_no LIKE CONCAT('%',#{q.dispatchNo},'%')</if>
         <if test='q.vehiclePlate != null'> AND d.vehicle_plate LIKE CONCAT('%',#{q.vehiclePlate},'%')</if>
         <if test='q.warehouseId != null'> AND d.overseas_warehouse_id=#{q.warehouseId}</if>
-        <if test='q.customerId != null'> AND (
+        <if test='q.customerId != null'> AND EXISTS(SELECT 1 FROM ll_dispatch_item i WHERE i.dispatch_order_id=d.id AND i.customer_id=#{q.customerId})</if>
-          EXISTS(SELECT 1 FROM ll_dispatch_item i WHERE i.dispatch_order_id=d.id AND i.customer_id=#{q.customerId})
-          OR EXISTS(SELECT 1 FROM ll_dispatch_truck_task t WHERE t.dispatch_no=d.dispatch_no AND t.customer_id=#{q.customerId})
-          OR EXISTS(SELECT 1 FROM ll_fleet_pickup_task p JOIN ll_fleet_trip f ON f.trip_no=p.trip_no WHERE f.id=d.trip_id AND p.customer_id=#{q.customerId})
-        )</if>
         <if test='q.fbaAppointmentNo != null'> AND EXISTS(SELECT 1 FROM ll_dispatch_appointment_allocation a JOIN ll_inbound_fba_appointment ap ON a.batch_key=CONCAT('FBA_APPOINTMENT:',ap.id) WHERE a.dispatch_id=d.id AND ap.confirmation_no=#{q.fbaAppointmentNo})</if>
         """;
     String REVIEW_DISPATCH = "CASE d.review_state WHEN 'DRAFT' THEN 'NOT_SUBMITTED' WHEN 'DISPATCH_PENDING' THEN 'PENDING' WHEN 'DISPATCH_REJECTED' THEN 'REJECTED' ELSE 'APPROVED' END";
@@ -26,9 +22,6 @@ 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>";
@@ -40,12 +33,12 @@ public interface DispatchAggregateMapper {
 
     /** 首次创建整车所有权及初始版本，不写customer_id。 */
     @Insert("""
-        INSERT INTO ll_dispatch_order(id,dispatch_no,task_type,trip_id,overseas_warehouse_id,overseas_warehouse_code,
+        INSERT INTO ll_dispatch_order(id,dispatch_no,trip_id,overseas_warehouse_id,overseas_warehouse_code,
           overseas_warehouse_name,status,stage,record_version,cargo_revision,cargo_hash,review_state,review_round,
           dispatch_review_json,loading_review_json,resources_json,vehicle_plate,route,planned_departure_at,
           estimated_arrival_at,item_count,pallet_count,package_count,picked_package_count,shipped_package_count,
           remark,created_by,created_at,updated_at)
-        VALUES(#{r.id},#{r.dispatchNo},COALESCE(#{r.taskType},'DELIVERY'),#{r.tripId},#{r.overseasWarehouseId},#{r.overseasWarehouseCode},
+        VALUES(#{r.id},#{r.dispatchNo},#{r.tripId},#{r.overseasWarehouseId},#{r.overseasWarehouseCode},
           #{r.overseasWarehouseName},#{r.status},#{r.stage},#{r.recordVersion},#{r.cargoRevision},#{r.cargoHash},
           #{r.reviewState},#{r.reviewRound},#{r.dispatchReviewJson},#{r.loadingReviewJson},#{r.resourcesJson},
           #{r.vehiclePlate},#{r.route},#{r.plannedDepartureAt},#{r.estimatedArrivalAt},#{r.itemCount},#{r.palletCount},
@@ -79,22 +72,21 @@ 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=#{dispatchReview},loading_review_json=#{loadingReview},
+          review_basis_hash=NULL,dispatch_review_json=#{pending},loading_review_json=#{pending},
           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("dispatchReview") String dispatchReview, @Param("loadingReview") String loadingReview,
+                    @Param("route") String route, @Param("pending") String pending, @Param("at") java.time.LocalDateTime at);
-                    @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},
-          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},
+          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},