test(appointments): require canonical dispatch calendar permission

fix(appointments): open canonical dispatch details from calendar
2026-10-20 17:02:20 +08:00 · 2026-10-20 16:36:22 +08:00
427 changed files with 3078 additions and 13736 deletions
@@ -1,10 +0,0 @@
-import subprocess, shutil, xml.etree.ElementTree as ET
-from pathlib import Path
-root=Path.cwd()
-report=root/'lastleg-service/target/surefire-reports/TEST-com.baiyue.lastleg.dispatch.service.DispatchAggregatePersistenceTest.xml'
-properties=ET.parse(report).getroot().find('properties')
-classpath=next(item.attrib['value'] for item in properties if item.attrib['name']=='java.class.path')
-sources=[str(root/'lastleg-service/src/test/java/com/baiyue/lastleg/fleet/trip'/name) for name in ['FleetTripCalendarServiceTest.java','FleetTripCalendarMapperTest.java']]
-subprocess.run(['javac','-encoding','UTF-8','--release','17','-cp',classpath,'-d',str(root/'lastleg-service/target/test-classes'),*sources],check=True)
-result=subprocess.run([shutil.which('mvn'),' -T'.strip(),'1','-DforkCount=1','-DreuseForks=true','-pl','lastleg-service','surefire:test','-Dtest=FleetTripCalendarServiceTest,FleetTripCalendarMapperTest'],check=False)
-raise SystemExit(result.returncode)
@@ -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` 只检查选择范围，不代表测试通过。
- 局部逻辑使用 `-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/数据库，除非用户明确要求。
+- Java 签名变更的最低编译门禁是 `mvn -pl <module> -am test-compile`，它必须在部署前完成并覆盖测试源码；有行为变化时继续运行 `mvn -pl <module> -am test`。`-DskipTests` 可跳过测试执行但仍须保留测试编译，`-Dmaven.test.skip=true` 会跳过测试编译，不得作为签名变更的交付验证。全量验证仍使用 `mvn -DskipTests validate`、`mvn test`；不要在本地启动 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`。实际部署仍须当前对话明确授权。
@@ -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: params.IMAGE_REPOSITORY ?: '', description: '沿用当前 Job 已配置的镜像仓库地址；首次配置或更换仓库时填写 host[:port]/owner/image')
+        string(name: 'IMAGE_REPOSITORY', defaultValue: '', description: '必须填写已核实的共享镜像仓库地址 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 前缀')
    }
@@ -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: params.IMAGE_REPOSITORY ?: '', description: '沿用当前 Job 已配置的镜像仓库基础路径，不包含服务名和标签；首次配置或更换仓库时填写')
+        string(name: 'IMAGE_REPOSITORY', defaultValue: '', description: '必须填写已核实的共享镜像仓库基础路径，不包含服务名和标签')
        string(name: 'DOCKER_BASE_IMAGE', defaultValue: 'eclipse-temurin:17-jre-alpine', description: 'Java 17 基础镜像')
    }

@@ -23,16 +23,11 @@
 ## 本地构建

 ```powershell
-# 日常按受影响模块检查；跨服务变更显式列入消费者。
-.\scripts\backend-check.ps1 -Modules order -Mode Compile
-.\scripts\backend-check.ps1 -Modules order
-# 根构建/拓扑变化等全量触发条件见 AGENTS.md。
-.\scripts\local-check.ps1 -Command @('node', '--test', 'scripts/java-topology-contract.test.mjs')
-.\scripts\backend-full-regression.ps1
+mvn -DskipTests validate
+node --test scripts/java-topology-contract.test.mjs
+mvn test
 ```

-开发中可通过 `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`。
@@ -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位大写字母");
-        }
-    }
-}
@@ -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); }
-    }
-}
@@ -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);
    }

@@ -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();
@@ -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:/customer-recharge-qr.svg}
+baiyue.finance.recharge.qr-code-url: ${FINANCE_RECHARGE_QR_CODE_URL:}
 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}
@@ -1,12 +1,6 @@
 # 单测试环境数据库空库初始化

-仓储转运到仓取货、本土卡车接入现有排车的**可重复执行汇总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 数据不倒推历史归属，匹配版本按新原生样本验收。
-
-客户“确认计费重”统一使用 `fl_inbound_fee` 最新已推送费用版本及其客户确认记录，不再维护独立重量确认表或接口。源建表定义、旧创建脚本与空库基线已移除；已有 TEST 先发布移除旧引用的 Firstleg 版本，再执行 `migrations/cn/baiyue_firstleg/V9__drop_chargeable_weight_confirmation.sql` 删除 `fl_chargeable_weight_confirmation`，不修改费用、订单或测量数据。脚本存在不表示已执行或部署。
+客户计费重独立确认新增 `fl_chargeable_weight_confirmation`，源表与国内空库基线同步；存量 TEST 使用 `migrations/cn/baiyue_firstleg/V8__chargeable_weight_confirmation.sql`，不回填费用确认。须随 Firstleg、Order、Lastleg、Admin 和 Client 匹配版本核对；本次未执行 SQL、未部署。

 费用项目默认价格结构：Firstleg 源基线 `phase2-fee-item-and-inbound-detail.sql` 与国内统一空库基线均增加可空的 `fl_fee_item.default_price DECIMAL(12,2)`。字段业务规则见工作区 `docs/入库测量与计费/README.md`；需与匹配的 Firstleg 和 Admin 一起发布。本次仅修改基线，不表示 SQL 已执行，也不能向已有测试库重放空库脚本。

@@ -60,8 +54,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_lastleg`、`baiyue_lastlag_warehouse` | 234 |
+| 国内 | `头程数据库统一增量-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` | 228 |


 - 所有服务位于同一测试环境；两份文件只分组组织服务 schema，不代表两个部署区域。`baiyue_lastlag_warehouse` 保留当前正式的 `lastlag` 拼写。
@@ -84,7 +78,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 +174,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、回填或删除测试存量。
@@ -1,7 +0,0 @@
-- 排车新编号所需独立结构；仅新建序列表，不改写已有排车业务号或业务数据。
-USE baiyue_lastleg;
-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='排车单号每日独立原子流水';
@@ -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;
@@ -0,0 +1,15 @@
+-- 仅为已初始化的头程库新增独立确认历史；不回填费用确认，不修改订单事实。
+-- 由单 schema 执行器选择 baiyue_firstleg，不在迁移内部切库。
+-- 客户独立确认计费重，不回填既有费用确认。
+CREATE TABLE IF NOT EXISTS fl_chargeable_weight_confirmation (
+ id BIGINT NOT NULL COMMENT '确认记录ID',
+ tenant_id BIGINT NOT NULL COMMENT '客户隔离ID',
+ inbound_id BIGINT NOT NULL COMMENT '独立来源入仓单ID',
+ operator_id BIGINT NOT NULL COMMENT '确认客户成员ID',
+ command_key VARCHAR(128) NOT NULL COMMENT '成员确认幂等键',
+ fingerprint CHAR(64) NOT NULL COMMENT '计费重及测量轮次摘要',
+ chargeable_weight_kg DECIMAL(18,4) NOT NULL COMMENT '客户确认计费重千克',
+ confirmed_at DATETIME(3) NOT NULL COMMENT '客户确认时间',
+ PRIMARY KEY(id), UNIQUE KEY uk_weight_confirmation_command(tenant_id,operator_id,command_key),
+ KEY idx_weight_confirmation_inbound(tenant_id,inbound_id,id)
+) ENGINE=InnoDB COMMENT='客户计费重独立确认历史';
@@ -1,4 +0,0 @@
-- 客户“确认计费重”统一确认 fl_inbound_fee 的当前推送费用版本。
-- 先发布已移除旧重量确认接口及查询的 Firstleg 版本，再执行本脚本。
-- 仅删除旧独立重量确认记录，不修改费用快照、订单或测量数据。
-DROP TABLE IF EXISTS baiyue_firstleg.fl_chargeable_weight_confirmation;
@@ -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='排车运输执行命令与凭证账本';
@@ -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;
@@ -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 '变动后实际余额',
@@ -6842,18 +6856,6 @@ INSERT INTO iam_permission (id, tenant_id, app_code, permission_type, parent_id,
 INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at) VALUES (4000001,5107361,0,CURRENT_TIMESTAMP(3));
 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 (5107362,0,'PLATFORM','BUTTON',5107360,'platform:fleet:operations:edit','更正出车实测记录',NULL,'PUT',992,'ACTIVE',1,CURRENT_TIMESTAMP(3),CURRENT_TIMESTAMP(3),0);
 INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at) VALUES (4000001,5107362,0,CURRENT_TIMESTAMP(3));
-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 (5107390,0,'PLATFORM','MENU',0,'platform:fleet:owned-business:list','自有业务','/overseas-master-data/owned-business','GET',993,'ACTIVE',1,CURRENT_TIMESTAMP(3),CURRENT_TIMESTAMP(3),0);
-INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at) VALUES (4000001,5107390,0,CURRENT_TIMESTAMP(3));
-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 (5107391,0,'PLATFORM','BUTTON',5107390,'platform:fleet:owned-business:edit','登记自有业务运营信息',NULL,'PUT',994,'ACTIVE',1,CURRENT_TIMESTAMP(3),CURRENT_TIMESTAMP(3),0);
-INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at) VALUES (4000001,5107391,0,CURRENT_TIMESTAMP(3));
-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 (5107392,0,'PLATFORM','BUTTON',5107390,'platform:fleet:owned-business:upload','上传自有业务照片',NULL,'POST',995,'ACTIVE',1,CURRENT_TIMESTAMP(3),CURRENT_TIMESTAMP(3),0);
-INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at) VALUES (4000001,5107392,0,CURRENT_TIMESTAMP(3));
-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 (5107400,0,'PLATFORM','MENU',0,'platform:fleet:outsourced-business:list','外配业务','/overseas-master-data/outsourced-business','GET',996,'ACTIVE',1,CURRENT_TIMESTAMP(3),CURRENT_TIMESTAMP(3),0);
-INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at) VALUES (4000001,5107400,0,CURRENT_TIMESTAMP(3));
-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 (5107401,0,'PLATFORM','BUTTON',5107400,'platform:fleet:outsourced-business:edit','登记外配业务承运信息',NULL,'PUT',997,'ACTIVE',1,CURRENT_TIMESTAMP(3),CURRENT_TIMESTAMP(3),0);
-INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at) VALUES (4000001,5107401,0,CURRENT_TIMESTAMP(3));
-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 (5107402,0,'PLATFORM','BUTTON',5107400,'platform:fleet:outsourced-business:upload','上传外配业务照片',NULL,'POST',998,'ACTIVE',1,CURRENT_TIMESTAMP(3),CURRENT_TIMESTAMP(3),0);
-INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at) VALUES (4000001,5107402,0,CURRENT_TIMESTAMP(3));
 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 (5107370,0,'PLATFORM','BUTTON',5107310,'platform:fleet:trip:handover','在途车辆司机交接',NULL,'POST',1000,'ACTIVE',1,CURRENT_TIMESTAMP(3),CURRENT_TIMESTAMP(3),0);
 INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at) VALUES (4000001,5107370,0,CURRENT_TIMESTAMP(3));
 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 (5107380,0,'PLATFORM','API',5105000,'platform:finance:vehicle-cost:list','查看公司车辆成本','/api/platform/finance/v1/vehicle-costs','GET',1010,'ACTIVE',1,CURRENT_TIMESTAMP(3),CURRENT_TIMESTAMP(3),0);
@@ -8383,20 +8385,4 @@ INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at)
 INSERT INTO iam_permission (id, tenant_id, app_code, permission_type, parent_id, permission_code, permission_name, route_path, http_method, sort_no, status, built_in, created_at, updated_at, deleted) VALUES (5102213,0,'PLATFORM','BUTTON',5102200,'platform:firstleg:terminal-drayage:direct-unload:confirm','登记直送目的仓实际卸货',NULL,'POST',60,'ACTIVE',1,CURRENT_TIMESTAMP(3),CURRENT_TIMESTAMP(3),0);
 INSERT INTO iam_role_permission (role_id, permission_id, tenant_id, created_at) VALUES (4000001,5102213,0,CURRENT_TIMESTAMP(3));

-USE baiyue_order;
-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;
+SELECT 'PASS' AS initialization_status, 'CN' AS region, 228 AS initialized_tables;
@@ -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。
@@ -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 '本趟主档或临时车辆司机的真实资源快照',
@@ -1861,11 +1859,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 (
-  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_no_daily_sequence (
+  business_date date NOT NULL COMMENT '业务日期（Asia/Shanghai）',
+  last_sequence int NOT NULL COMMENT '当日已分配尾程单流水号',
+  PRIMARY KEY (business_date)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='尾程单号按日原子流水';

 CREATE TABLE ll_order_operation_log (
  id bigint NOT NULL COMMENT '操作记录主键',
@@ -2073,7 +2071,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 +2092,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 +2362,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 +3216,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 +3230,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 +4822,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,116 +4882,4 @@ CREATE TABLE ll_fleet_pickup_history (
  KEY idx_pickup_history_trip(trip_no,id)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='取货不可变操作历史';

-- 自有业务仅保存原排车的归属证据和附加运营信息，不复制履约主单。
-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 '真实车辆档案主键，临时外配为空',
-  vehicle_ownership VARCHAR(16) NOT NULL COMMENT '装车完成时车辆归属OWNED或DISPATCHED',
-  vehicle_record_version BIGINT NULL COMMENT '捕获归属时真实车辆档案版本',
-  ownership_captured_at DATETIME(3) NOT NULL COMMENT '归属捕获UTC时间',
-  loading_completion_hash VARCHAR(128) NOT NULL COMMENT '原排车装车确认事实摘要',
-  loading_completed_at DATETIME(3) NOT NULL COMMENT '原排车实际装车完成UTC时间',
-  PRIMARY KEY (dispatch_id),
-  KEY idx_owned_business_vehicle (vehicle_ownership,vehicle_id),
-  CONSTRAINT fk_owned_business_ownership_dispatch FOREIGN KEY (dispatch_id) REFERENCES ll_dispatch_order(id),
-  CONSTRAINT ck_owned_business_ownership CHECK (vehicle_ownership IN ('OWNED','DISPATCHED')),
-  CONSTRAINT ck_owned_business_resource_mode CHECK (
-    (resource_mode='MASTER' AND vehicle_id IS NOT NULL AND vehicle_record_version IS NOT NULL AND vehicle_record_version>=0)
-    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 (
-  id BIGINT NOT NULL COMMENT '附加运营记录内部主键',
-  dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
-  record_version BIGINT NOT NULL COMMENT '附加运营记录并发版本，独立于原排车版本',
-  currency VARCHAR(3) NULL COMMENT '整车运营金额币种CNY或USD，未登记为空',
-  total_amount DECIMAL(18,2) NULL COMMENT '人工登记整车总金额，不自动形成账务费用',
-  actual_distance_miles DECIMAL(12,3) NULL COMMENT '实际行驶英里数，未登记为空',
-  fuel_consumption_litres_per_100km DECIMAL(12,3) NULL COMMENT '人工登记油耗率，单位升每百公里',
-  arrivals_json JSON NOT NULL COMMENT '按原目的地键记录的实际到达UTC时间',
-  photos_json JSON NOT NULL COMMENT '七个照片框当前已绑定文件的分类快照',
-  created_by VARCHAR(64) NOT NULL COMMENT '首次登记操作人标识',
-  updated_by VARCHAR(64) NOT NULL COMMENT '最近登记操作人标识',
-  created_at DATETIME(3) NOT NULL COMMENT '首次登记UTC时间',
-  updated_at DATETIME(3) NOT NULL COMMENT '最近登记UTC时间',
-  PRIMARY KEY (id),
-  UNIQUE KEY uk_owned_business_record_dispatch (dispatch_id),
-  CONSTRAINT fk_owned_business_record_dispatch FOREIGN KEY (dispatch_id) REFERENCES ll_dispatch_order(id),
-  CONSTRAINT ck_owned_business_record_version CHECK (record_version>=0),
-  CONSTRAINT ck_owned_business_money CHECK (
-    (currency IS NULL AND total_amount IS NULL)
-    OR (currency IS NOT NULL AND currency IN ('CNY','USD') AND total_amount IS NOT NULL AND total_amount>=0)),
-  CONSTRAINT ck_owned_business_distance CHECK (actual_distance_miles IS NULL OR actual_distance_miles>=0),
-  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 (
-  id BIGINT NOT NULL COMMENT '附加运营命令内部主键',
-  dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
-  operator_id VARCHAR(64) NOT NULL COMMENT '原命令操作人标识',
-  idempotency_key VARCHAR(128) COLLATE utf8mb4_bin NOT NULL COMMENT '同一原排车内唯一请求键，不按操作者分组',
-  action VARCHAR(32) NOT NULL COMMENT '运营登记或照片上传绑定动作',
-  expected_version BIGINT NULL COMMENT '原请求附加版本，纯文件上传可为空',
-  request_hash CHAR(64) NOT NULL COMMENT '原操作者动作版本与完整请求摘要',
-  request_json JSON NOT NULL COMMENT '不含文件内容或凭据的完整原请求',
-  status VARCHAR(24) NOT NULL COMMENT 'PENDING或SUCCEEDED或REJECTED或UNKNOWN_RESULT',
-  result_json JSON NULL COMMENT '原命令已知成功结果或明确拒绝事实',
-  error_code VARCHAR(64) NULL COMMENT '明确拒绝或未知结果诊断码',
-  created_at DATETIME(3) NOT NULL COMMENT '命令意图创建UTC时间',
-  updated_at DATETIME(3) NOT NULL COMMENT '命令结果更新UTC时间',
-  PRIMARY KEY (id),
-  UNIQUE KEY uk_owned_business_command_key (dispatch_id,idempotency_key),
-  CONSTRAINT fk_owned_business_command_dispatch FOREIGN KEY (dispatch_id) REFERENCES ll_dispatch_order(id),
-  CONSTRAINT ck_owned_business_command_version CHECK (expected_version IS NULL OR expected_version>=0),
-  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 (
-  id BIGINT NOT NULL COMMENT '附加运营历史内部主键',
-  dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
-  record_version BIGINT NOT NULL COMMENT '成功写入后的附加记录版本',
-  action VARCHAR(32) NOT NULL COMMENT '运营登记或照片绑定动作',
-  operator_id VARCHAR(64) NOT NULL COMMENT '真实操作人标识',
-  reason VARCHAR(1000) NULL COMMENT '人工填写的登记或更正说明',
-  snapshot_json JSON NOT NULL COMMENT '操作后附加运营信息与分类照片不可变快照',
-  occurred_at DATETIME(3) NOT NULL COMMENT '操作UTC时间',
-  PRIMARY KEY (id),
-  UNIQUE KEY uk_owned_business_history_version (dispatch_id,record_version),
-  CONSTRAINT fk_owned_business_history_dispatch FOREIGN KEY (dispatch_id) REFERENCES ll_dispatch_order(id),
-  CONSTRAINT ck_owned_business_history_version CHECK (record_version>0)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='原排车自有业务附加运营不可变历史';
-
-- 运输原单接入现有排车，不产生仓内库存事实。
-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;
+SELECT 'PASS' AS initialization_status, 'OVERSEAS' AS region, 228 AS initialized_tables;
@@ -11,10 +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),
    DELIVERY_LOADING_PHOTO(true, FormatPolicy.ARBITRARY, Limits.CUSTOMS, BusinessIdPolicy.POSITIVE_LONG),
    DELIVERY_BOL(true, FormatPolicy.ARBITRARY, Limits.CUSTOMS, BusinessIdPolicy.POSITIVE_LONG),
@@ -75,14 +71,9 @@ enum BusinessFileCategory {

    /** 校验文件归属；跨客户排车证据固定为平台所有，不随货物客户变化。 */
    void validateOwner(long tenantId) {
-        // 整车运营照片归原排车单，不随同车客户变化，也不能串用装车和油耗类别。
-        if ((this == OVERSEAS_DISPATCH_LOADING_PHOTO || this == OVERSEAS_DISPATCH_FUEL_PHOTO)
+        if ((this == OVERSEAS_DISPATCH_VEHICLE_EVIDENCE || this == OVERSEAS_DISPATCH_DRIVER_EVIDENCE)
                && 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)
-                && 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, "出车实测凭证必须归属平台");
@@ -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]
@@ -1,14 +0,0 @@
-openapi: 3.0.3
-info:
-  title: 自有业务排车运营照片归属契约
-  version: 1.0.0
-  description: >-
-    自有业务消费原排车事实，仅补充运营照片，不创建另一套排车或装车状态。
-    复用InternalBusinessFileController，不增加公网File路径。
-    businessType分为OVERSEAS_DISPATCH_LOADING_PHOTO和OVERSEAS_DISPATCH_FUEL_PHOTO，
-    tenantId固定0，businessId固定原Lastleg排车内部主键，不接受车次主键、车牌或客户ID替代。
-    仅非空JPG/PNG，最大10MiB，同时校验MIME与真实内容签名；两类照片不能交叉引用。
-    Lastleg按公开dispatchNo解析原排车，负责车辆归属、可见阶段、读写权限、附加记录版本、
-    分类附件引用和历史。文件上传不代表装车确认、签收、实到或运营信息保存。
-    File不读取Lastleg表，只按客户范围、业务类别、业务ID和文件ID核对文件复合归属。
-paths: {}
@@ -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);
@@ -1,125 +0,0 @@
-package com.baiyue.file.service;
-
-import com.baomidou.mybatisplus.core.MybatisConfiguration;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
-import com.baiyue.common.core.exception.BizException;
-import com.baiyue.file.entity.FileObjectEntity;
-import com.baiyue.file.mapper.FileObjectMapper;
-import org.apache.ibatis.builder.MapperBuilderAssistant;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.io.TempDir;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
-import org.springframework.mock.web.MockMultipartFile;
-import org.springframework.test.util.ReflectionTestUtils;
-import org.springframework.web.multipart.MultipartFile;
-
-import java.io.ByteArrayOutputStream;
-import java.nio.file.Path;
-import java.util.regex.Pattern;
-
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.ArgumentMatchers.*;
-import static org.mockito.Mockito.*;
-
-class OwnedBusinessPhotoFileTest {
-    private static final String LOADING = "OVERSEAS_DISPATCH_LOADING_PHOTO";
-    private static final String FUEL = "OVERSEAS_DISPATCH_FUEL_PHOTO";
-    @TempDir Path root;
-
-    @BeforeAll static void columns() {
-        TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), "owned-business-photo"), FileObjectEntity.class);
-    }
-
-    @ParameterizedTest @ValueSource(strings = {LOADING, FUEL})
-    void rejectsNonPlatformOrInvalidDispatchIdentityBeforeAnyStorage(String type) {
-        var files = mock(FileObjectMapper.class);
-        var storage = mock(BusinessFileStorage.class);
-        var service = service(files, storage);
-        var file = new MockMultipartFile("file", "photo.png", "image/png", new byte[]{1});
-        for (long owner : new long[]{-1, 1, 900})
-            assertThatThrownBy(() -> service.upload(owner, type, "71", 7, file)).isInstanceOf(BizException.class);
-        for (String businessId : new String[]{"0", "-1", "DS-71", "../71", ""})
-            assertThatThrownBy(() -> service.upload(0, type, businessId, 7, file)).isInstanceOf(BizException.class);
-        verifyNoInteractions(files, storage);
-    }
-
-    @ParameterizedTest @ValueSource(strings = {LOADING, FUEL})
-    void storesRealImagesButRejectsPdfSpoofedEmptyAndOversizedFiles(String type) throws Exception {
-        var storage = new BusinessFileStorage();
-        ReflectionTestUtils.setField(storage, "configuredRoot", root);
-        storage.initializeRoot();
-        var category = BusinessFileCategory.require(type);
-        for (String format : new String[]{"jpeg", "png"}) {
-            byte[] bytes = image(format);
-            var upload = new MockMultipartFile("file", "photo." + format, "image/" + format, bytes);
-            var saved = storage.store(0, "71", upload, category);
-            assertThat(storage.read(saved.objectKey())).isEqualTo(bytes);
-        }
-        for (var upload : new MockMultipartFile[]{
-                new MockMultipartFile("file", "empty.png", "image/png", new byte[0]),
-                new MockMultipartFile("file", "spoof.png", "image/png", "not-image".getBytes()),
-                new MockMultipartFile("file", "receipt.pdf", "application/pdf", "%PDF-1.7\nreceipt".getBytes())})
-            assertThatThrownBy(() -> storage.store(0, "71", upload, category)).isInstanceOf(BizException.class);
-        MultipartFile oversized = mock(MultipartFile.class);
-        when(oversized.isEmpty()).thenReturn(false);
-        when(oversized.getSize()).thenReturn(10L * 1024 * 1024 + 1);
-        assertThatThrownBy(() -> storage.store(0, "71", oversized, category)).isInstanceOf(BizException.class);
-        verify(oversized, never()).getInputStream();
-    }
-
-    /** 用实际Mapper查询条件核对四元组，错车、错类别和错文件必须先拒绝再读内容。 */
-    @ParameterizedTest @ValueSource(strings = {LOADING, FUEL})
-    void metadataAndDownloadRequireExactDispatchCategoryAndFile(String type) throws Exception {
-        var files = mock(FileObjectMapper.class);
-        var storage = mock(BusinessFileStorage.class);
-        var service = service(files, storage);
-        byte[] bytes = image("png");
-        var row = new FileObjectEntity();
-        row.setId(501L); row.setTenantId(0L); row.setBusinessType(type); row.setBusinessId("71");
-        row.setOriginalName("photo.png"); row.setContentType("image/png"); row.setSizeBytes((long) bytes.length);
-        row.setObjectKey("owned-photo"); row.setSha256("a".repeat(64)); row.setCreatedAt(java.time.LocalDateTime.now());
-        when(files.selectOne(any())).thenAnswer(call -> {
-            LambdaQueryWrapper<FileObjectEntity> query = call.getArgument(0);
-            assertThat(bound(query, "status")).isEqualTo("ACTIVE");
-            assertThat(bound(query, "deleted")).isEqualTo(false);
-            return Long.valueOf(0).equals(bound(query, "tenant_id")) && type.equals(bound(query, "business_type"))
-                && "71".equals(bound(query, "business_id")) && Long.valueOf(501).equals(bound(query, "id")) ? row : null;
-        });
-        when(storage.read("owned-photo")).thenReturn(bytes);
-        assertThat(service.metadata(0, type, "71", 501).businessType()).isEqualTo(type);
-        assertThat(service.download(0, type, "71", 501).content()).isEqualTo(bytes);
-        clearInvocations(storage);
-        for (String other : new String[]{LOADING.equals(type) ? FUEL : LOADING,
-                "FLEET_VEHICLE_RECORD_PHOTO", "OVERSEAS_DISPATCH_VEHICLE_EVIDENCE", "DELIVERY_LOADING_PHOTO"}) {
-            assertThatThrownBy(() -> service.metadata(0, other, "71", 501)).isInstanceOf(BizException.class);
-            assertThatThrownBy(() -> service.download(0, other, "71", 501)).isInstanceOf(BizException.class);
-        }
-        assertThatThrownBy(() -> service.download(0, type, "72", 501)).isInstanceOf(BizException.class);
-        assertThatThrownBy(() -> service.download(0, type, "71", 502)).isInstanceOf(BizException.class);
-        assertThatThrownBy(() -> service.download(1, type, "71", 501)).isInstanceOf(BizException.class);
-        verifyNoInteractions(storage);
-    }
-
-    private static Object bound(LambdaQueryWrapper<FileObjectEntity> query, String column) {
-        var matcher = Pattern.compile("(?<![A-Za-z0-9_])" + column + " = #\\{ew\\.paramNameValuePairs\\.([^}]+)}")
-            .matcher(query.getSqlSegment());
-        assertThat(matcher.find()).as("scope column %s", column).isTrue();
-        return query.getParamNameValuePairs().get(matcher.group(1));
-    }
-
-    private static InternalBusinessFileService service(FileObjectMapper files, BusinessFileStorage storage) {
-        var service = new InternalBusinessFileService();
-        ReflectionTestUtils.setField(service, "files", files);
-        ReflectionTestUtils.setField(service, "storage", storage);
-        return service;
-    }
-
-    private static byte[] image(String format) throws Exception {
-        var bytes = new ByteArrayOutputStream();
-        assertThat(javax.imageio.ImageIO.write(new java.awt.image.BufferedImage(2, 2,
-            java.awt.image.BufferedImage.TYPE_INT_RGB), format, bytes)).isTrue();
-        return bytes.toByteArray();
-    }
-}
@@ -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、版本、客户归属、方向或金额变化时同时核对事件消费、主动快照查询、唯一约束和账单明细消费者。
@@ -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,
@@ -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();
-}
@@ -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);
-}
@@ -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;
-    }
-}
@@ -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)); }
-}
@@ -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 final DocumentSequenceRepository sequences;
+    private static final ZoneId BUSINESS_ZONE = ZoneId.of("Asia/Shanghai");
+    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) {
-        this(sequences, Clock.system(DailyDocumentNumber.BUSINESS_ZONE));
+    public FinanceDocumentNumberGenerator(JdbcTemplate jdbc) {
+        this(jdbc, Clock.system(BUSINESS_ZONE));
    }

-    /** 固定时钟用于跨日及前缀独立性验证。 */
-    FinanceDocumentNumberGenerator(DocumentSequenceRepository sequences, Clock clock) {
-        this.sequences = sequences;
+    FinanceDocumentNumberGenerator(JdbcTemplate jdbc, Clock clock) {
+        this.jdbc = jdbc;
        this.clock = clock;
    }

-    /** 只为本服务已登记的业务类型分配号码。 */
+    @Transactional(propagation = Propagation.MANDATORY)
    public String next(String prefix) {
-        if (!PREFIXES.contains(prefix)) throw new IllegalArgumentException("未登记的业务编号前缀：" + prefix);
-        return DailyDocumentNumber.next(prefix, clock, sequences::next);
+        if (!SUPPORTED_PREFIXES.contains(prefix)) {
+            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);
    }
 }
@@ -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 {
-            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 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 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);
@@ -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[] 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 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 static void requireCustomer(long tenantId) { if (tenantId <= 0) throw bad("客户范围无效"); }
    private static BizException bad(String message) { return new BizException(ResultCode.BAD_REQUEST, message); }
@@ -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,
-                                    com.baiyue.finance.repository.FinanceSettlementDetailRepository details) {
+                                    FinanceDocumentNumberGenerator documentNumbers) {
        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);
-        if (records.isEmpty()) throw error("FIN_404", "结算单不存在");
-        SettlementSummary summary = summary(records.get(0));
-        List<SettlementLine> lines = details.lines(summary.customerId(), settlementId)
+        Map<String, Object> row = one(
+            SETTLEMENT_SUMMARY_SELECT + "WHERE s.id=?",
+            "结算单不存在", 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)
-            .stream().map(this::transaction).toList());
+        List<SettlementTransaction> transactions = new ArrayList<>(jdbc.queryForList(
+            "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())
-                .stream().map(this::transaction).toList());
+            transactions.addAll(jdbc.queryForList(
+                "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", "幂等请求哈希失败");
        }
@@ -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) {
@@ -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 {
-            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_001", "幂等请求哈希失败"); }
+        try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(json(value).getBytes(StandardCharsets.UTF_8))); }
+        catch (Exception exception) { throw error("FIN_001", "幂等请求哈希失败"); }
    }

    private static LocalDateTime localTime(Object value) {
@@ -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 '变动后实际余额',
@@ -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,
@@ -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(
-            Map.entry("id", 501L), Map.entry("transaction_no", "PAY202610210001"), Map.entry("transaction_type", "PAYMENT"),
+        when(jdbc.queryForList(startsWith("SELECT id,transaction_type"), eq(10L), eq(88L))).thenReturn(List.of(Map.ofEntries(
+            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("AP")).thenReturn("AP202608180001");
-        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());
-        });
+        org.mockito.Mockito.lenient().when(documentNumbers.next("AR")).thenReturn("AR-260818-0001");
+        org.mockito.Mockito.lenient().when(documentNumbers.next("AP")).thenReturn("AP-260818-0001");
        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());
    }

@@ -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();
-        }
-    }
-}
@@ -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);
-    }
-}
@@ -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);
    }
 }
@@ -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);
-        });
-    }
-}
@@ -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 static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+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() {
-        var sequences=mock(DocumentSequenceRepository.class);
-        when(sequences.next("REC:20261020")).thenReturn(1L,2L,9999L);
-        var numbers=new FinanceDocumentNumberGenerator(sequences,CLOCK);
-        assertThat(numbers.next("REC")).isEqualTo("REC202610200001");
-        assertThat(numbers.next("REC")).isEqualTo("REC202610200002");
-        assertThat(numbers.next("REC")).isEqualTo("REC202610209999");
-        verify(sequences,times(3)).next("REC:20261020");
+
+    @Test
+    void formatsShortDailySequenceForAllThreeDocuments() {
+        JdbcTemplate jdbc = mock(JdbcTemplate.class);
+        when(jdbc.queryForObject("SELECT LAST_INSERT_ID()", Long.class)).thenReturn(1L, 2L, 38L);
+        FinanceDocumentNumberGenerator generator = new FinanceDocumentNumberGenerator(jdbc, CLOCK);
+
+        assertThat(generator.next("REC")).isEqualTo("REC-260818-0001");
+        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() {
-        var sequences=mock(DocumentSequenceRepository.class);
-        var numbers=new FinanceDocumentNumberGenerator(sequences,CLOCK);
-        assertThatThrownBy(()->numbers.next("ZZZZ")).isInstanceOf(IllegalArgumentException.class);
-        verifyNoInteractions(sequences);
-        when(sequences.next("REC:20261020")).thenReturn(10000L);
-        assertThatThrownBy(()->numbers.next("REC")).isInstanceOf(BizException.class);
+
+    @Test
+    void rejectsUnsupportedTypeAndOverflow() {
+        JdbcTemplate jdbc = mock(JdbcTemplate.class);
+        FinanceDocumentNumberGenerator generator = new FinanceDocumentNumberGenerator(jdbc, CLOCK);
+        assertThatThrownBy(() -> generator.next("PAY")).isInstanceOf(IllegalArgumentException.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"));
    }
 }
@@ -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，外部失败不得推进业务节点，不得在国内货柜履约另建查询任务。
@@ -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) {}

@@ -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 = documentNumbers.next("DECL");
+        String batchNo = trim(request.batchNo());
+        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());
@@ -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) {
@@ -71,7 +71,6 @@ public final class ColoadGroupModels {

    /** 页面只读业务摘要；内部组标识不作为用户识别键。 */
    public record BusinessSummary(
-        String groupNo,
        String status,
        int memberCount,
        List<BusinessMember> members
@@ -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
@@ -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);
-    }
-}
@@ -59,7 +59,6 @@ public final class ColoadPersistenceRows {
    @Setter
    public static class InboundGroupLookupRow {
        private Long groupId;
-        private String groupNo;
        private String groupStatus;
    }

@@ -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) {
@@ -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();
-}
@@ -23,7 +23,6 @@ public interface MerchantWorkbenchFilterMapper {
        FROM fl_inbound_order i
        JOIN fl_inbound_fee f ON f.tenant_id=i.tenant_id AND f.inbound_id=i.id
        WHERE i.tenant_id=#{tenantId} AND i.deleted=0 AND i.order_id IS NOT NULL
-          AND i.process_status != 'CANCELLED' AND i.measure_review_status='APPROVED'
          AND f.fee_status='SENT' AND f.customer_confirmed_at IS NULL
          AND NOT EXISTS (SELECT 1 FROM fl_inbound_fee newer
              WHERE newer.tenant_id=f.tenant_id AND newer.inbound_id=f.inbound_id
@@ -64,13 +63,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
-                 WHERE d.container_booking_id=owned.container_booking_id
-                   AND d.document_type='DESTINATION_CLEARANCE' AND d.file_id IS NOT NULL) THEN 3
+               WHEN EXISTS (SELECT 1 FROM fl_carrier_schedule_node_fact n
+                 WHERE n.container_booking_id=owned.container_booking_id
+                   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
@@ -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
@@ -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);
@@ -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;
-    }
-}
@@ -1,37 +0,0 @@
-package com.baiyue.firstleg.repository;
-
-import com.baiyue.firstleg.dto.MerchantWorkbenchFilters;
-import com.baiyue.firstleg.mapper.MerchantWorkbenchFilterMapper;
-import org.springframework.stereotype.Repository;
-import java.util.List;
-
-/** 客户工作台筛选事实的持久化入口。 */
-@Repository
-public class MerchantWorkbenchFilterRepository {
-    private final MerchantWorkbenchFilterMapper mapper;
-
-    /** 注入客户隔离的筛选查询。 */
-    public MerchantWorkbenchFilterRepository(MerchantWorkbenchFilterMapper mapper) {
-        this.mapper = mapper;
-    }
-
-    /** 查询物流主状态对应的订单范围。 */
-    public List<Long> byProcessStatuses(long tenantId, List<String> statuses) {
-        return mapper.byProcessStatuses(tenantId, statuses);
-    }
-
-    /** 只返回最新已推送费用仍待客户确认的订单。 */
-    public List<Long> pendingFees(long tenantId) {
-        return mapper.pendingFees(tenantId);
-    }
-
-    /** 查询待客户补齐报关资料的订单。 */
-    public List<Long> pendingCustoms(long tenantId) {
-        return mapper.pendingCustoms(tenantId);
-    }
-
-    /** 查询客户订单的实际履约片段。 */
-    public List<MerchantWorkbenchFilters.Fragment> progressFragments(long tenantId, List<Long> orderIds) {
-        return mapper.progressFragments(tenantId, orderIds);
-    }
-}
@@ -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);
        }
@@ -1,47 +1,71 @@
 package com.baiyue.firstleg.service;

-import com.baiyue.common.core.number.DailyDocumentNumber;
-import com.baiyue.firstleg.repository.DocumentSequenceRepository;
+import com.baiyue.common.core.api.ResultCode;
+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 final DocumentSequenceRepository sequences;
+    private static final ZoneId BUSINESS_ZONE = ZoneId.of("Asia/Shanghai");
+    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) {
-        this(sequences, Clock.system(DailyDocumentNumber.BUSINESS_ZONE));
+    public FirstlegDocumentNumberGenerator(JdbcTemplate jdbc) {
+        this(jdbc, Clock.system(BUSINESS_ZONE));
    }

-    /** 固定时钟用于跨日及前缀独立性验证。 */
-    FirstlegDocumentNumberGenerator(DocumentSequenceRepository sequences, Clock clock) {
-        this.sequences = sequences;
+    FirstlegDocumentNumberGenerator(JdbcTemplate jdbc, Clock clock) {
+        this.jdbc = jdbc;
        this.clock = clock;
    }

-    /** 只为本服务已登记的业务类型分配号码。 */
+    @Transactional(propagation = Propagation.MANDATORY)
    public String next(String prefix) {
-        // 实物标签未纳入本次改号，DP 保留原六位日期及横杠。
-        if ("DP".equals(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 (!SUPPORTED_PREFIXES.contains(prefix)) {
+            throw new IllegalArgumentException("unsupported firstleg document prefix: " + prefix);
        }
-        if (!PREFIXES.contains(prefix)) throw new IllegalArgumentException("未登记的业务编号前缀：" + prefix);
-        return DailyDocumentNumber.next(prefix, clock, sequences::next);
+        LocalDate sequenceDate = LocalDate.now(clock);
+        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;
    }
 }
@@ -1,30 +1,30 @@
 package com.baiyue.firstleg.service;

 import com.baiyue.firstleg.dto.MerchantWorkbenchFilters;
-import com.baiyue.firstleg.repository.MerchantWorkbenchFilterRepository;
+import com.baiyue.firstleg.mapper.MerchantWorkbenchFilterMapper;
 import jakarta.annotation.Resource;
 import org.springframework.stereotype.Service;

@Service
 public class MerchantWorkbenchFilterService {
-    @Resource private MerchantWorkbenchFilterRepository repository;
+    @Resource private MerchantWorkbenchFilterMapper mapper;
    @Resource private UnifiedInboundQueryService unified;
+    @Resource private com.baiyue.firstleg.workflow.ChargeableWeightService weights;

-    /** 精确详情只读进度；确认计费重待办统一使用最新已推送费用的客户确认状态。 */
+    /** 精确详情只读进度；工作台待确认队列使用计费重事实，金额确认不能代替。 */
    @org.springframework.transaction.annotation.Transactional(readOnly=true)
    public MerchantWorkbenchFilters.Response read(MerchantWorkbenchFilters.Request request) {
        if (request.orderIds() != null) {
            return new MerchantWorkbenchFilters.Response(null, java.util.List.of(), java.util.List.of(),
-                progress(repository.progressFragments(request.tenantId(), request.orderIds())));
+                progress(mapper.progressFragments(request.tenantId(), request.orderIds())));
        }
        return new MerchantWorkbenchFilters.Response(
-            request.mainStatus() == null ? null : repository.byProcessStatuses(request.tenantId(),
+            request.mainStatus() == null ? null : mapper.byProcessStatuses(request.tenantId(),
                unified.internalStatuses(request.mainStatus())),
-            repository.pendingFees(request.tenantId()), repository.pendingCustoms(request.tenantId()),
-            progress(repository.progressFragments(request.tenantId(), null)));
+            weights.pendingOrders(request.tenantId()), mapper.pendingCustoms(request.tenantId()),
+            progress(mapper.progressFragments(request.tenantId(), null)));
    }

-    /** 将实装片段聚合为订单级履约进度。 */
    static java.util.List<MerchantWorkbenchFilters.Progress> progress(java.util.List<MerchantWorkbenchFilters.Fragment> facts) {
        var grouped = facts.stream().collect(java.util.stream.Collectors.groupingBy(MerchantWorkbenchFilters.Fragment::orderId));
        return grouped.entrySet().stream().sorted(java.util.Map.Entry.comparingByKey()).map(entry -> {
@@ -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() {
-        return repository.candidates(null);
+    private List<Candidate> manualCandidates(ContainerBookingEntity booking) {
+        return repository.candidates(null).stream()
+            .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,"客户归属不匹配");}
 }
@@ -0,0 +1,57 @@
+package com.baiyue.firstleg.workflow;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import com.baiyue.common.core.api.ResultCode;
+import com.baiyue.common.core.exception.BizException;
+import java.util.*;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.time.LocalDateTime;
+/** 客户独立确认计费重，金额确认和主流程不受影响。 */
+@Service
+public class ChargeableWeightService {
+ private final WorkflowFactRepository repository;
+ /** 注入当前事实和确认历史。 */
+ public ChargeableWeightService(WorkflowFactRepository repository) { this.repository=repository; }
+ /** 客户仅能读取本订单已审核的计费重。 */
+ public List<WorkflowFacts.Weight> read(long tenant,long orderId) {
+ return repository.facts(repository.orderInbounds(tenant,orderId)).stream().filter(f->f.tenantId()==tenant && eligible(f)).map(ChargeableWeightService::weight).toList();
+ }
+ /** 客户工作台按独立确认事实计算待办，不借用费用确认。 */
+ public List<Long> pendingOrders(long tenant) {
+ var ids=repository.weightCandidates(tenant);var orders=new LinkedHashSet<Long>();
+ for(int offset=0;offset<ids.size();offset+=500) for(var f:repository.facts(ids.subList(offset,Math.min(offset+500,ids.size()))))
+ if(f.tenantId()==tenant && eligible(f) && !weight(f).confirmed()) orders.add(f.orderId());
+ return List.copyOf(orders);
+ }
+ /** 值和测量轮次变化使旧确认失效，金额变化不影响计费重。 */
+ public static String fingerprint(WorkflowFacts.Fact f) {
+ try { String value=f.inboundId()+"|"+f.chargeableWeightKg().stripTrailingZeros().toPlainString()+"|"+f.measureCompletedAt();
+ return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(value.getBytes(StandardCharsets.UTF_8)));
+ } catch(java.security.NoSuchAlgorithmException e) { throw new IllegalStateException(e); }
+ }
+ /** 未审核或非正数不允许确认。 */
+ public static boolean eligible(WorkflowFacts.Fact f) { return "APPROVED".equals(f.reviewStatus()) && f.chargeableWeightKg()!=null && f.chargeableWeightKg().signum()>0; }
+ /** 只认可当前版本的确认。 */
+ public static WorkflowFacts.Weight weight(WorkflowFacts.Fact f) {
+ String hash=fingerprint(f);boolean confirmed=hash.equals(f.confirmationFingerprint());
+ return new WorkflowFacts.Weight(f.inboundId(),f.orderId(),f.chargeableWeightKg(),hash,confirmed,confirmed?f.confirmedAt():null);
+ }
+ /** 入仓锁、预期版本和幂等键防止确认旧值或异参重放。 */
+ @Transactional
+ public WorkflowFacts.Weight confirm(long tenant,long operator,long id,String key,WorkflowFacts.Confirm request) {
+ if(key==null || key.isBlank() || key.length()>128) throw new BizException(ResultCode.BAD_REQUEST,"确认幂等键不能为空且最多128字符");
+ var inbound=repository.lock(tenant,id);
+ if(inbound==null || "CANCELLED".equals(inbound.getProcessStatus())) throw new BizException(ResultCode.NOT_FOUND,"入仓单不存在");
+ var replay=repository.command(tenant,operator,key);
+ if(replay!=null && (replay.inboundId()!=id || !replay.fingerprint().equals(request.expectedFingerprint()))) throw new BizException(ResultCode.CONFLICT,"同一幂等键不能确认不同计费重");
+ var facts=repository.facts(List.of(id));
+ if(facts.isEmpty()) throw new BizException(ResultCode.CONFLICT,"请分别确认分柜后的独立订单计费重");
+ var f=facts.get(0);
+ if(!eligible(f)) throw new BizException(ResultCode.CONFLICT,"计费重尚未审核通过");
+ var current=weight(f);
+ if(!current.fingerprint().equals(request.expectedFingerprint())) throw new BizException(ResultCode.CONFLICT,"计费重已变化，请刷新后重新确认");
+ if(replay==null) repository.insert(new WorkflowFacts.Confirmation(com.baomidou.mybatisplus.core.toolkit.IdWorker.getId(),tenant,id,operator,key,current.fingerprint(),current.chargeableWeightKg(),LocalDateTime.now()));
+ return weight(repository.facts(List.of(id)).get(0));
+ }
+}
@@ -0,0 +1,26 @@
+package com.baiyue.firstleg.workflow;
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.common.security.AuthenticatedUser;
+import com.baiyue.firstleg.service.FirstlegScopeGuard;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import jakarta.validation.Valid;
+import java.util.List;
+/** 客户计费重确认入口，独立于费用确认。 */
+@RestController
+@RequestMapping("/api/merchant/v1/first-leg")
+public class MerchantChargeableWeightController {
+ private final ChargeableWeightService service;
+ /** 注入独立确认服务。 */
+ public MerchantChargeableWeightController(ChargeableWeightService service) { this.service=service; }
+ /** 客户范围取认证上下文。 */
+ @GetMapping("/orders/{orderId}/chargeable-weights")
+ @PreAuthorize("hasAuthority('merchant:order:view')")
+ public ApiResponse<List<WorkflowFacts.Weight>> read(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable long orderId) { return ApiResponse.success(service.read(FirstlegScopeGuard.merchant(user),orderId)); }
+ /** 不触发费用确认与金额锁定。 */
+ @com.baiyue.common.audit.BusinessAudit(event="CUSTOMER_CHARGEABLE_WEIGHT_CONFIRM",resourceType="INBOUND_ORDER",resourceId="#inboundId",description="客户独立确认计费重")
+ @PostMapping("/chargeable-weights/{inboundId}/confirm")
+ @PreAuthorize("hasAuthority('merchant:order:edit')")
+ public ApiResponse<WorkflowFacts.Weight> confirm(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable long inboundId,@RequestHeader("Idempotency-Key") String key,@Valid @RequestBody WorkflowFacts.Confirm request) { return ApiResponse.success(service.confirm(FirstlegScopeGuard.merchant(user),user.userId(),inboundId,key,request)); }
+}
@@ -1,7 +1,7 @@
 package com.baiyue.firstleg.workflow;
 import org.apache.ibatis.annotations.*;
 import java.util.List;
-/** 柜事实与最新费用确认状态的只读 SQL 入口。 */
+/** 柜事实和独立确认SQL入口。 */
@Mapper
 public interface WorkflowFactMapper {
 String ACTUAL="""
@@ -13,30 +13,29 @@ public interface WorkflowFactMapper {
 AND pk.item_status IN ('PICKED','PARTIAL') AND pk.picked_package_count>0
 """;
 /** 按独立实装票核验资料；来源单承接实装时，余量子单不能将来源票排除。 */
- @Select("<script>SELECT i.tenant_id,i.id inbound_id,i.order_id,i.measure_review_status review_status,"
+ @Select("<script>SELECT i.tenant_id,i.id inbound_id,i.order_id,i.measure_review_status review_status,i.chargeable_weight_kg,i.measure_completed_at,"
 +"EXISTS(SELECT 1 "+ACTUAL+" AND EXISTS(SELECT 1 FROM fl_carrier_schedule_node_fact n WHERE n.container_booking_id=b.id AND n.standard_node='DEPARTED_ORIGIN_PORT' AND n.actual_at IS NOT NULL)) departed,"
 +"EXISTS(SELECT 1 "+ACTUAL+" AND EXISTS(SELECT 1 FROM fl_container_document d WHERE d.container_booking_id=b.id AND d.document_type='DESTINATION_CLEARANCE' AND d.file_id IS NOT NULL)) clearance_uploaded,"
 +"EXISTS(SELECT 1 "+ACTUAL+" AND i.tax_mode='TAX_REFUND' AND NOT EXISTS(SELECT 1 FROM fl_customs_customer_document_inbound s JOIN fl_customs_customer_document d ON d.id=s.document_id AND d.tenant_id=i.tenant_id AND d.status='ACTIVE' JOIN fl_customs_container c ON c.id=d.customs_container_id AND c.loading_plan_id=p.id WHERE s.inbound_id=i.id AND s.tenant_id=i.tenant_id)) missing_customs,"
 +"EXISTS(SELECT 1 "+ACTUAL+" AND (i.tax_mode='BUY_DECLARATION' OR EXISTS(SELECT 1 FROM fl_customs_customer_document_inbound s JOIN fl_customs_customer_document d ON d.id=s.document_id AND d.tenant_id=i.tenant_id AND d.status='ACTIVE' JOIN fl_customs_container c ON c.id=d.customs_container_id AND c.loading_plan_id=p.id WHERE s.inbound_id=i.id AND s.tenant_id=i.tenant_id))) export_customs_ready,"
- +"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 "
+ +"(SELECT w.fingerprint FROM fl_chargeable_weight_confirmation w WHERE w.tenant_id=i.tenant_id AND w.inbound_id=i.id ORDER BY w.id DESC LIMIT 1) confirmation_fingerprint,"
+ +"(SELECT w.confirmed_at FROM fl_chargeable_weight_confirmation w WHERE w.tenant_id=i.tenant_id AND w.inbound_id=i.id ORDER BY w.id DESC LIMIT 1) confirmed_at "
 +"FROM fl_inbound_order i WHERE i.deleted=0 AND NOT EXISTS(SELECT 1 FROM fl_inbound_order child WHERE child.tenant_id=i.tenant_id AND child.parent_inbound_id=i.id AND child.inbound_role='CHILD' AND (child.split_purpose IS NULL OR child.split_purpose != 'REMAINDER') AND child.deleted=0) AND i.process_status != 'CANCELLED' AND i.id IN "
 +"<foreach collection='ids' item='id' open='(' separator=',' close=')'>#{id}</foreach></script>")
 List<WorkflowFacts.Fact> facts(@Param("ids") List<Long> ids);
- /** 客户确认页签只读取最新已推送费用版本，旧版本确认不能覆盖新版本。 */
- @Select("""
- <script>
- SELECT i.tenant_id, i.order_id,
-   CASE WHEN f.customer_confirmed_at IS NULL THEN 'WAIT_WEIGHT_CONFIRM'
-        ELSE 'WEIGHT_CONFIRMED' END AS main_status
- FROM fl_inbound_order i
- JOIN fl_inbound_fee f ON f.tenant_id=i.tenant_id AND f.inbound_id=i.id
- WHERE i.deleted=0 AND i.process_status != 'CANCELLED'
-   AND i.measure_review_status='APPROVED' AND f.fee_status='SENT'
-   AND NOT EXISTS (SELECT 1 FROM fl_inbound_fee newer
-     WHERE newer.tenant_id=f.tenant_id AND newer.inbound_id=f.inbound_id
-       AND (newer.fee_version>f.fee_version OR (newer.fee_version=f.fee_version AND newer.id>f.id)))
-   AND i.id IN <foreach collection='ids' item='id' open='(' separator=',' close=')'>#{id}</foreach>
- </script>
- """)
- List<com.baiyue.firstleg.service.UnifiedInboundQueryService.StatusRow> feeConfirmationRows(@Param("ids") List<Long> ids);
+ /** 锁定客户自己的入仓单，串行确认与测量写入。 */
+ @Select("SELECT * FROM fl_inbound_order WHERE tenant_id=#{tenantId} AND id=#{id} AND deleted=0 FOR UPDATE")
+ com.baiyue.firstleg.entity.InboundOrderEntity lock(@Param("tenantId") long tenantId,@Param("id") long id);
+ /** 客户订单下全部独立入仓单。 */
+ @Select("SELECT id FROM fl_inbound_order WHERE tenant_id=#{tenantId} AND order_id=#{orderId} AND deleted=0 AND process_status != 'CANCELLED' ORDER BY id")
+ List<Long> orderInbounds(@Param("tenantId") long tenantId,@Param("orderId") long orderId);
+ /** 客户工作台只读取审核通过且有正计费重的来源。 */
+ @Select("SELECT id FROM fl_inbound_order WHERE tenant_id=#{tenantId} AND deleted=0 AND process_status != 'CANCELLED' AND measure_review_status='APPROVED' AND chargeable_weight_kg>0 ORDER BY id")
+ List<Long> weightCandidates(@Param("tenantId") long tenantId);
+ /** 成员幂等键不允许跨确认对象复用。 */
+ @Select("SELECT * FROM fl_chargeable_weight_confirmation WHERE tenant_id=#{tenantId} AND operator_id=#{operatorId} AND command_key=#{key}")
+ WorkflowFacts.Confirmation command(@Param("tenantId") long tenantId,@Param("operatorId") long operatorId,@Param("key") String key);
+ /** 独立记录，不修改费用或物流主状态。 */
+ @Insert("INSERT INTO fl_chargeable_weight_confirmation(id,tenant_id,inbound_id,operator_id,command_key,fingerprint,chargeable_weight_kg,confirmed_at) VALUES(#{id},#{tenantId},#{inboundId},#{operatorId},#{commandKey},#{fingerprint},#{chargeableWeightKg},#{confirmedAt})")
+ int insert(WorkflowFacts.Confirmation value);
 }
@@ -1,7 +1,7 @@
 package com.baiyue.firstleg.workflow;
 import org.springframework.stereotype.Repository;
 import java.util.List;
-/** 本地柜事实与费用确认状态的只读持久化入口。 */
+/** 本地柜事实与确认记录的持久化入口。 */
@Repository
 public class WorkflowFactRepository {
 private final WorkflowFactMapper mapper;
@@ -9,8 +9,14 @@ public class WorkflowFactRepository {
 public WorkflowFactRepository(WorkflowFactMapper mapper) { this.mapper=mapper; }
 /** 空候选不读取数据。 */
 public List<WorkflowFacts.Fact> facts(List<Long> ids) { return ids.isEmpty()?List.of():mapper.facts(ids); }
- /** 按本轮有效入仓范围读取最新推送费用的客户确认状态。 */
- public List<com.baiyue.firstleg.service.UnifiedInboundQueryService.StatusRow> feeConfirmationRows(List<Long> ids) {
-     return ids.isEmpty() ? List.of() : mapper.feeConfirmationRows(ids);
- }
+ /** 锁定所属客户来源。 */
+ public com.baiyue.firstleg.entity.InboundOrderEntity lock(long tenant,long id) { return mapper.lock(tenant,id); }
+ /** 查询订单下独立来源。 */
+ public List<Long> orderInbounds(long tenant,long order) { return mapper.orderInbounds(tenant,order); }
+ /** 客户计费重待确认候选。 */
+ public List<Long> weightCandidates(long tenant) { return mapper.weightCandidates(tenant); }
+ /** 读取成员确认命令。 */
+ public WorkflowFacts.Confirmation command(long tenant,long operator,String key) { return mapper.command(tenant,operator,key); }
+ /** 追加确认历史。 */
+ public void insert(WorkflowFacts.Confirmation value) { mapper.insert(value); }
 }
@@ -1,12 +1,17 @@
 package com.baiyue.firstleg.workflow;
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
 import java.util.List;
-/** 订单业务页签的只读事实契约。 */
+/** 页签事实与独立计费重确认契约。 */
 public final class WorkflowFacts {
- /** 仅承载事实查询契约，不允许实例化。 */
+ /** 仅承载查询及确认契约，不允许实例化。 */
 private WorkflowFacts() {}
- public record Fact(long tenantId,long inboundId,long orderId,String reviewStatus,
- boolean departed,boolean clearanceUploaded,boolean missingCustoms,boolean exportCustomsReady,boolean customsCompleted) {}
+ public record Fact(long tenantId,long inboundId,long orderId,String reviewStatus,BigDecimal chargeableWeightKg,LocalDateTime measureCompletedAt,
+ boolean departed,boolean clearanceUploaded,boolean missingCustoms,boolean exportCustomsReady,String confirmationFingerprint,LocalDateTime confirmedAt) {}
 public record Source(long tenantId,long inboundId) {}
 public record Request(List<Source> sources) {}
 public record Overseas(long tenantId,long inboundId,boolean outboundExists,boolean pendingOutbound,boolean delivering,boolean unloaded) {}
+ public record Weight(long inboundId,long orderId,BigDecimal chargeableWeightKg,String fingerprint,boolean confirmed,LocalDateTime confirmedAt) {}
+ public record Confirm(@jakarta.validation.constraints.Pattern(regexp="[a-f0-9]{64}") @jakarta.validation.constraints.NotNull String expectedFingerprint) {}
+ public record Confirmation(long id,long tenantId,long inboundId,long operatorId,String commandKey,String fingerprint,BigDecimal chargeableWeightKg,LocalDateTime confirmedAt) {}
 }
@@ -22,57 +22,46 @@ public class WorkflowTabService {
 var batch=inbounds.subList(offset,Math.min(offset+500,inbounds.size()));
 var expected=new HashMap<Long,InboundOrderEntity>();batch.forEach(i->expected.put(i.getId(),i));
 var facts=repository.facts(batch.stream().map(InboundOrderEntity::getId).toList());
- // 确认页签复用已推送费用版本。
- 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("费用确认事实不属于本批入仓来源");
- 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(
-     "尾程事实响应无效 code="+(response==null?null:response.code())
-     +" requestId="+(response==null?null:response.requestId())+" traceId="+(response==null?null:response.traceId()));
+ if(response==null || !response.successful() || response.data()==null) throw unavailable();
 var allowed=new HashSet<>(sources);
 for(var fact:response.data()) {
- if(fact==null || !allowed.contains(new WorkflowFacts.Source(fact.tenantId(),fact.inboundId()))) throw unavailable("尾程事实包含空记录或本批以外的客户/入仓来源");
+ 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()
-     +" missing="+sources.stream().filter(s->!overseas.containsKey(s.tenantId()+":"+s.inboundId())).limit(20).toList());
- } catch(BizException e) { throw e; } catch(Exception e) {
-     throw (BizException) new BizException(ResultCode.SERVICE_UNAVAILABLE,"订单业务页签事实暂不可用，请稍后重试").initCause(e);
- }
+ if(overseas.size()!=sources.size()) throw unavailable();
+ } catch(BizException e) { throw e; } catch(Exception e) { throw unavailable(); }
 }
 // SQL排除仅作汇总的父票；保留承接实际装柜数量的来源票及独立余量票。
 for(var fact:facts) {
 var inbound=expected.get(fact.inboundId());
- if(inbound==null || !Objects.equals(inbound.getTenantId(),fact.tenantId()) || !Objects.equals(inbound.getOrderId(),fact.orderId())) throw unavailable("头程事实与入仓单归属不一致 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));
 }
 }
 return List.copyOf(result.values());
 }
- /** 分类为可重叠的物流待办/证据集合，客户确认由最新费用版本单独提供。 */
+ /** 分类为可重叠的待办/证据集合，计费重确认独立于费用确认。 */
 public static Set<String> classify(WorkflowFacts.Fact f,String process,WorkflowFacts.Overseas o) {
 Set<String> keys=new LinkedHashSet<>();
 if("MEASURE_PENDING".equals(process) && "PENDING".equals(f.reviewStatus())) keys.add("MEASUREMENT_REVIEW");
+ if(ChargeableWeightService.eligible(f)) keys.add(ChargeableWeightService.weight(f).confirmed()?"WEIGHT_CONFIRMED":"WAIT_WEIGHT_CONFIRM");
 boolean signed="DELIVERED".equals(process);
- // 报关完成即进入待清关；不再等待船期接口补齐实际离港节点。
- boolean clearanceStage=f.customsCompleted() || f.departed() || f.clearanceUploaded();
- if(!clearanceStage && !signed) {
+ // 报关页签按资料与实装事实汇总，不依赖点击开始报关；实际开船后转入清关链路。
+ if(!f.departed() && !signed) {
 if(f.missingCustoms()) keys.add("WAIT_CUSTOMS_DOCS");
 if(f.exportCustomsReady()) keys.add("EXPORT_CUSTOMS");
 }
 if(signed) keys.add("SIGNED");
- if(clearanceStage && !signed) {
+ if(f.departed() && !signed) {
 if(!f.clearanceUploaded()) keys.add("SAILING_CLEARANCE");
- // 清关资料保存成功后才进入海外待办；出库事实优先于拆柜和排车待办。
- if(f.clearanceUploaded() && o!=null) {
- if(!o.outboundExists() && !o.unloaded()) keys.add("WAIT_UNLOAD");
+ if(o!=null) {
+ if(f.clearanceUploaded() && !o.unloaded()) keys.add("WAIT_UNLOAD");
 // 取消的出库不构成有效覆盖，读取事实后自动回显，不能保存永久隐藏标志。
 if(!o.outboundExists()) keys.add("WAIT_DISPATCH");
 if(o.pendingOutbound()) keys.add("OUTBOUND_DOCUMENT");
@@ -82,9 +71,5 @@ public class WorkflowTabService {
 return keys;
 }
 /** 下游缺失或归属异常不能生成部分数量。 */
- private static BizException unavailable(String reason) {
-     // 诊断信息只进入服务日志，公开响应保持稳定，不暴露内部来源标识。
-     return (BizException) new BizException(ResultCode.SERVICE_UNAVAILABLE,"订单业务页签事实暂不可用，请稍后重试")
-         .initCause(new IllegalStateException(reason));
- }
+ private static BizException unavailable() { return new BizException(ResultCode.SERVICE_UNAVAILABLE,"订单业务页签事实暂不可用，请稍后重试"); }
 }
@@ -0,0 +1,13 @@
+-- 客户独立确认计费重，不回填既有费用确认。
+CREATE TABLE IF NOT EXISTS fl_chargeable_weight_confirmation (
+ id BIGINT NOT NULL COMMENT '确认记录ID',
+ tenant_id BIGINT NOT NULL COMMENT '客户隔离ID',
+ inbound_id BIGINT NOT NULL COMMENT '独立来源入仓单ID',
+ operator_id BIGINT NOT NULL COMMENT '确认客户成员ID',
+ command_key VARCHAR(128) NOT NULL COMMENT '成员确认幂等键',
+ fingerprint CHAR(64) NOT NULL COMMENT '计费重及测量轮次摘要',
+ chargeable_weight_kg DECIMAL(18,4) NOT NULL COMMENT '客户确认计费重千克',
+ confirmed_at DATETIME(3) NOT NULL COMMENT '客户确认时间',
+ PRIMARY KEY(id), UNIQUE KEY uk_weight_confirmation_command(tenant_id,operator_id,command_key),
+ KEY idx_weight_confirmation_inbound(tenant_id,inbound_id,id)
+) ENGINE=InnoDB COMMENT='客户计费重独立确认历史';
@@ -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）',
@@ -45,8 +45,8 @@ paths:
      summary: 按入仓码查询同柜组业务摘要
      description: >-
        需要 platform:firstleg:smart-loading:list。使用任一有效成员的全局唯一 inboundCode 查询；
-        返回真实业务组号 groupNo、组业务状态、有效成员数和全部唯一成员入仓码。任一冻结成员缺少有效 inboundCode 时失败关闭；
-        页面不持有或展示 groupId、orderId，也不得从技术ID或订单号推导入仓码。
+        仅返回组业务状态、有效成员数和全部唯一成员入仓码。任一冻结成员缺少有效 inboundCode 时失败关闭；
+        页面不持有或展示 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:
@@ -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}}}
@@ -355,7 +355,7 @@ paths:
  /internal/firstleg/v1/inbounds/unified-orders/workbench-filters:
    post:
      summary: 查询单一客户工作台履约筛选标识（Order内部）
-      description: 只读返回命中状态、待确认已推送费用及待上传报关资料的订单标识。feeOrderIds为最新已推送费用版本尚未由客户确认的订单，对应客户端“确认计费重”入口及费用明细弹窗。客户必须明确且为正数；不创建报关聚合，不跨Schema读取。传入orderIds为精确进度模式，仅计算progress，matchingStatusOrderIds为null，feeOrderIds和customsOrderIds为空；mainStatus在该模式不参与查询。
+      description: 只读返回命中状态、待独立确认计费重及待上传报关资料的订单标识。feeOrderIds沿用既有字段名，值为尚未确认当前计费重的订单，不代表金额确认。客户必须明确且为正数；不创建报关聚合，不跨Schema读取。传入orderIds为精确进度模式，仅计算progress，matchingStatusOrderIds为null，feeOrderIds和customsOrderIds为空；mainStatus在该模式不参与查询。
      security: [{internalServiceToken: []}]
      requestBody:
        required: true
@@ -388,11 +388,11 @@ paths:
                    required: [feeOrderIds, customsOrderIds, progress]
                    properties:
                      matchingStatusOrderIds: {type: array, nullable: true, items: {type: integer, format: int64}}
-                      feeOrderIds: {type: array, description: 待客户确认最新已推送费用版本的订单ID, items: {type: integer, format: int64}}
+                      feeOrderIds: {type: array, description: 待客户独立确认当前计费重的订单ID, items: {type: integer, format: int64}}
                      customsOrderIds: {type: array, items: {type: integer, format: int64}}
                      progress:
                        type: array
-                        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}
@@ -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: 集装箱号}
@@ -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}
@@ -0,0 +1,64 @@
+openapi: 3.0.3
+info: {title: 客户独立计费重确认, version: 1.0.0}
+security: [{bearerAuth: []}]
+paths:
+  /api/merchant/v1/first-leg/orders/{orderId}/chargeable-weights:
+    get:
+      summary: 客户读取本票全部独立入仓计费重
+      description: 认证客户隔离，要求merchant:order:view；仅返回测量审核通过且计费重为正的分片。
+      parameters:
+        - {name: orderId, in: path, required: true, schema: {type: integer, format: int64}}
+      responses:
+        '200':
+          description: 标准ApiResponse，认证客户无可确认来源时返回空数组
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code: {type: string, example: '200'}
+                  message: {type: string}
+                  data:
+                    type: array
+                    items: {$ref: '#/components/schemas/Weight'}
+  /api/merchant/v1/first-leg/chargeable-weights/{inboundId}/confirm:
+    post:
+      summary: 客户独立确认当前计费重
+      description: 要求merchant:order:edit。与费用金额确认独立；值或测量轮次变化后旧确认失效。客户范围取认证主体。
+      parameters:
+        - {name: inboundId, in: path, required: true, schema: {type: integer, format: int64}}
+        - {name: Idempotency-Key, in: header, required: true, schema: {type: string, maxLength: 128}}
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [expectedFingerprint]
+              properties:
+                expectedFingerprint: {type: string, pattern: '^[a-f0-9]{64}$'}
+      responses:
+        '200':
+          description: 标准ApiResponse；版本或异参冲突返回业务冲突码，不改变费用状态
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code: {type: string, example: '200'}
+                  message: {type: string}
+                  data: {$ref: '#/components/schemas/Weight'}
+components:
+  securitySchemes:
+    bearerAuth: {type: http, scheme: bearer, bearerFormat: JWT}
+  schemas:
+    Weight:
+      type: object
+      required: [inboundId, orderId, chargeableWeightKg, fingerprint, confirmed]
+      properties:
+        inboundId: {type: string, description: 独立来源入仓单ID}
+        orderId: {type: string, description: 独立订单ID}
+        chargeableWeightKg: {type: number}
+        fingerprint: {type: string}
+        confirmed: {type: boolean}
+        confirmedAt: {type: string, format: date-time, nullable: true}
@@ -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}
@@ -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:");
-        // 约束仅针对测量审核；客户费用确认属于另一业务，允许独立存在。
-        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("待客户确认");
+            .doesNotContain("/api/platform/v1/inbounds/{inboundId}/measurements/exception-release:")
+            .doesNotContain("待客户确认");
    }

    @Test
@@ -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))
@@ -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");
    }
 }
@@ -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;
    }
@@ -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("order_id=#{");
+            .doesNotContain("group_no", "order_id=#{");
        assertThat(memberSql)
            .contains("member.id memberId", "member.inbound_id inboundId", "inbound.inbound_code inboundCode")
            .contains("LEFT JOIN fl_inbound_order inbound")
@@ -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("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='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);
    }

@@ -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));
@@ -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()) {
@@ -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);
-        });
-    }
-}
@@ -19,7 +19,6 @@ class MerchantWorkbenchFilterMapperTest {
        var ds=new JdbcDataSource();ds.setURL("jdbc:h2:mem:workbench-facts-"+UUID.randomUUID()+";MODE=MySQL;DB_CLOSE_DELAY=-1");
        jdbc=new JdbcTemplate(ds);
        jdbc.execute("CREATE TABLE fl_inbound_order(id BIGINT PRIMARY KEY,tenant_id BIGINT,order_id BIGINT,deleted INT DEFAULT 0,tax_mode VARCHAR(32),process_status VARCHAR(32))");
-        jdbc.execute("ALTER TABLE fl_inbound_order ADD measure_review_status VARCHAR(32) DEFAULT 'APPROVED'");
        jdbc.execute("CREATE TABLE fl_inbound_fee(id BIGINT PRIMARY KEY,tenant_id BIGINT,inbound_id BIGINT,fee_version INT,fee_status VARCHAR(32),customer_confirmed_at TIMESTAMP)");
        jdbc.execute("CREATE TABLE fl_loading_plan(id BIGINT PRIMARY KEY,container_booking_id BIGINT,plan_status VARCHAR(32),confirmed_at TIMESTAMP,updated_at TIMESTAMP)");
        jdbc.execute("CREATE TABLE fl_loading_plan_item(loading_plan_id BIGINT,inbound_id BIGINT,account_id BIGINT,deleted INT DEFAULT 0)");
@@ -30,12 +29,11 @@ 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);
        mapper=new SqlSessionTemplate(factory.getObject()).getMapper(MerchantWorkbenchFilterMapper.class);
-        jdbc.update("INSERT INTO fl_inbound_order(id,tenant_id,order_id,deleted,tax_mode,process_status) VALUES(1,11,101,0,'TAX_REFUND','LOADED'),(2,11,102,0,'TAX_REFUND','DELIVERED'),(3,22,103,0,'TAX_REFUND','LOADED'),(4,11,104,1,'TAX_REFUND','LOADED'),(5,11,105,0,'BUY_DECLARATION','LOADED')");
+        jdbc.update("INSERT INTO fl_inbound_order VALUES(1,11,101,0,'TAX_REFUND','LOADED'),(2,11,102,0,'TAX_REFUND','DELIVERED'),(3,22,103,0,'TAX_REFUND','LOADED'),(4,11,104,1,'TAX_REFUND','LOADED'),(5,11,105,0,'BUY_DECLARATION','LOADED')");
        jdbc.update("INSERT INTO fl_container_booking VALUES(100,'ACTIVE')");
        jdbc.update("INSERT INTO fl_loading_plan VALUES(100,100,'COMPLETED',CURRENT_TIMESTAMP,CURRENT_TIMESTAMP)");
        jdbc.update("INSERT INTO fl_loading_plan_item(loading_plan_id,inbound_id,account_id,deleted) VALUES(100,1,11,0),(100,1,11,0),(100,2,11,0),(100,3,22,0),(100,4,11,0),(100,5,11,0)");
@@ -96,12 +94,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'");
@@ -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);
@@ -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);
@@ -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 static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+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() {
-        var sequences=mock(DocumentSequenceRepository.class);
-        when(sequences.next("LP:20261020")).thenReturn(1L,2L,9999L);
-        var numbers=new FirstlegDocumentNumberGenerator(sequences,CLOCK);
-        assertThat(numbers.next("LP")).isEqualTo("LP202610200001");
-        assertThat(numbers.next("LP")).isEqualTo("LP202610200002");
-        assertThat(numbers.next("LP")).isEqualTo("LP202610209999");
-        verify(sequences,times(3)).next("LP:20261020");
-    }
-    /** 未登记类型不能消耗流水，分配异常或溢出时拒绝出号。 */
-    @Test void rejectsUnknownTypeAndOverflow() {
-        var sequences=mock(DocumentSequenceRepository.class);
-        var numbers=new FirstlegDocumentNumberGenerator(sequences,CLOCK);
-        assertThatThrownBy(()->numbers.next("ZZZZ")).isInstanceOf(IllegalArgumentException.class);
-        verifyNoInteractions(sequences);
-        when(sequences.next("LP:20261020")).thenReturn(10000L);
-        assertThatThrownBy(()->numbers.next("LP")).isInstanceOf(BizException.class);
+
+    @Test
+    void formatsAllOperationalDocumentPrefixes() {
+        JdbcTemplate jdbc = mock(JdbcTemplate.class);
+        when(jdbc.queryForObject("SELECT LAST_INSERT_ID()", Long.class))
+            .thenReturn(1L, 1L, 1L, 1L, 1L);
+        FirstlegDocumentNumberGenerator generator = new FirstlegDocumentNumberGenerator(jdbc, CLOCK);
+
+        assertThat(generator.next("OB")).isEqualTo("OB-260818-0001");
+        assertThat(generator.next("TA")).isEqualTo("TA-260818-0001");
+        assertThatThrownBy(() -> generator.next("CB")).isInstanceOf(IllegalArgumentException.class);
+        assertThat(generator.next("LP")).isEqualTo("LP-260818-0001");
+        assertThat(generator.nextCabinetNo()).isEqualTo("D0001");
+
+        verify(jdbc).update(org.mockito.ArgumentMatchers.startsWith("INSERT INTO fl_document_sequence"),
+            eq("OB:20260818"));
+        verify(jdbc).update(org.mockito.ArgumentMatchers.startsWith("INSERT INTO fl_document_sequence"),
+            eq("CABINET"));
    }

-    /** 柜次和实物标签明确不改格式，柜次允许超过四位。 */
-    @Test void preservesCabinetAndPalletRules() {
-        var sequences=mock(DocumentSequenceRepository.class);
-        when(sequences.next("CABINET")).thenReturn(9999L,10000L);
-        when(sequences.next("DP:20261020")).thenReturn(1L);
-        var numbers=new FirstlegDocumentNumberGenerator(sequences,CLOCK);
-        assertThat(numbers.nextCabinetNo()).isEqualTo("D9999");
-        assertThat(numbers.nextCabinetNo()).isEqualTo("D10000");
-        assertThat(numbers.next("DP")).isEqualTo("DP-261020-0001");
+    @Test
+    void cabinetSequenceDoesNotResetOrStopAtFourDigits() {
+        JdbcTemplate jdbc = mock(JdbcTemplate.class);
+        when(jdbc.queryForObject("SELECT LAST_INSERT_ID()", Long.class)).thenReturn(9_999L, 10_000L);
+        FirstlegDocumentNumberGenerator generator = new FirstlegDocumentNumberGenerator(jdbc, CLOCK);
+
+        assertThat(generator.nextCabinetNo()).isEqualTo("D9999");
+        assertThat(generator.nextCabinetNo()).isEqualTo("D10000");
+    }
+
+    @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);
    }
 }
@@ -1,7 +1,7 @@
 package com.baiyue.firstleg.service;

 import com.baiyue.firstleg.dto.MerchantWorkbenchFilters;
-import com.baiyue.firstleg.repository.MerchantWorkbenchFilterRepository;
+import com.baiyue.firstleg.mapper.MerchantWorkbenchFilterMapper;
 import org.junit.jupiter.api.Test;
 import org.springframework.test.util.ReflectionTestUtils;
 import java.util.List;
@@ -9,22 +9,25 @@ import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;

 class MerchantWorkbenchFilterServiceTest {
-    /** 确认计费重待办使用费用版本的确认结果，与费用弹窗保持一致。 */
-    @Test void customerQueueUsesPublishedFeeConfirmation() {
-        var repository=mock(MerchantWorkbenchFilterRepository.class);
+    /** 金额待确认与计费重待确认不同，客户工作台只能使用后者。 */
+    @Test void customerQueueUsesIndependentWeightConfirmation() {
+        var mapper=mock(MerchantWorkbenchFilterMapper.class);
+        var weights=mock(com.baiyue.firstleg.workflow.ChargeableWeightService.class);
        var service=new MerchantWorkbenchFilterService();
-        ReflectionTestUtils.setField(service,"repository",repository);
-        when(repository.pendingFees(11)).thenReturn(List.of(101L));
+        ReflectionTestUtils.setField(service,"mapper",mapper);
+        ReflectionTestUtils.setField(service,"weights",weights);
+        when(weights.pendingOrders(11)).thenReturn(List.of(101L));
        var response=service.read(new MerchantWorkbenchFilters.Request(11L,null,null));
        assertThat(response.feeOrderIds()).containsExactly(101L);
-        verify(repository).pendingFees(11);
+        verify(weights).pendingOrders(11);
+        verify(mapper,never()).pendingFees(anyLong());
    }

    @Test void exactDetailProgressSkipsUnrelatedCustomerQueues() {
-        var mapper=mock(MerchantWorkbenchFilterRepository.class);
+        var mapper=mock(MerchantWorkbenchFilterMapper.class);
        var unified=mock(UnifiedInboundQueryService.class);
        var service=new MerchantWorkbenchFilterService();
-        ReflectionTestUtils.setField(service,"repository",mapper);
+        ReflectionTestUtils.setField(service,"mapper",mapper);
        ReflectionTestUtils.setField(service,"unified",unified);
        when(mapper.progressFragments(11,List.of(101L))).thenReturn(List.of(
            new MerchantWorkbenchFilters.Fragment(101,3),new MerchantWorkbenchFilters.Fragment(101,1)));
@@ -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() {
-        stubAssignment();
+    void rejectsManualAssignmentOutsideLinkedBookingCustomerScope() {
+        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,
-            new AssignRequest(10L, 20L, 1, 0, "assign-cross-customer"), 7L, "u");
+        BizException error = catchThrowableOfType(() -> service.assign(1L,
+            new AssignRequest(10L, 20L, 1, 0, "assign-customer-mismatch"), 7L, "u"), BizException.class);

-        assertThat(result.version()).isEqualTo(1);
-        ArgumentCaptor<LoadingPlanItemEntity> inserted = ArgumentCaptor.forClass(LoadingPlanItemEntity.class);
-        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);
+        assertThat(error.getResultCode()).isEqualTo(ResultCode.FORBIDDEN);
+        verify(repository, never()).touch(anyLong(), anyInt(), anyLong(), any());
    }

    @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"));
@@ -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));
-    }
-}
@@ -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 {
@@ -4,6 +4,8 @@ import com.baiyue.common.core.api.ApiResponse;
 import com.baiyue.common.core.exception.BizException;
 import com.baiyue.firstleg.entity.InboundOrderEntity;
 import org.junit.jupiter.api.Test;
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
 import java.util.List;
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.*;
@@ -13,7 +15,8 @@ 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",BigDecimal.TEN,
+            LocalDateTime.of(2026,10,19,10,0),true,false,false,false,null,null);
    }

    /** 下游漏来源或返回其他客户均整体失败。 */
@@ -25,34 +28,36 @@ 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)
-            .hasMessage("订单业务页签事实暂不可用，请稍后重试")
-            .hasRootCauseMessage("尾程事实缺少来源 expected=1 actual=0 missing=[Source[tenantId=11, inboundId=1]]");
+        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class);
        when(downstream.read(any(),any())).thenReturn(ApiResponse.success(List.of(
            new WorkflowFacts.Overseas(22,1,true,true,false,true))));
        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class);
-        var failure=new IllegalStateException("unavailable");
-        when(downstream.read(any(),any())).thenThrow(failure);
-        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class).hasCause(failure);
+        when(downstream.read(any(),any())).thenThrow(new IllegalStateException("unavailable"));
+        assertThatThrownBy(()->service.rows(List.of(inbound))).isInstanceOf(BizException.class);
    }

-    /** 未记录离港时，报关完成即可待清关；上传清关资料后也必须查询精确海外来源。 */
-    @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)))));
+    /** 重测同值也要求重新确认，金额没有参与摘要。 */
+    @Test void repeatedMeasurementRequiresNewConfirmation() {
+        var original=fact();
+        var measuredAgain=new WorkflowFacts.Fact(11,1,101,"APPROVED",BigDecimal.TEN,
+            original.measureCompletedAt().plusSeconds(1),true,false,false,false,
+            ChargeableWeightService.fingerprint(original),LocalDateTime.now());
+        assertThat(ChargeableWeightService.weight(measuredAgain).confirmed()).isFalse();
    }

+    /** 平台主体不得冒充客户，客户和操作者只取认证上下文。 */
+    @Test void confirmationUsesAuthenticatedCustomerAndOperator() {
+        var service=mock(ChargeableWeightService.class);
+        var controller=new MerchantChargeableWeightController(service);
+        var platform=new com.baiyue.common.security.AuthenticatedUser(7L,0L,0L,9L,"platform","PLATFORM","WEB",java.util.Set.of());
+        var request=new WorkflowFacts.Confirm("a".repeat(64));
+        assertThatThrownBy(()->controller.read(platform,101)).isInstanceOf(BizException.class);
+        assertThatThrownBy(()->controller.confirm(platform,1,"key",request)).isInstanceOf(BizException.class);
+        verifyNoInteractions(service);
+        var merchant=new com.baiyue.common.security.AuthenticatedUser(7L,11L,0L,9L,"member","MERCHANT","WEB",java.util.Set.of());
+        controller.read(merchant,101);
+        controller.confirm(merchant,1,"key",request);
+        verify(service).read(11,101);
+        verify(service).confirm(11,7,1,"key",request);
+    }
 }
@@ -1,52 +1,42 @@
 package com.baiyue.firstleg.workflow;
 import org.junit.jupiter.api.Test;
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
 import static org.assertj.core.api.Assertions.*;
-/** 取消回显、分柜隔离和资料页签回归。 */
+/** 取消回显、分柜隔离和独立计费重版本回归。 */
 class WorkflowBusinessTest {
-    /** 报关完成进入待清关，清关资料保存后才进入拆柜与排车待办。 */
+    /** 报关资料齐备进入汇总，实际开船及清关资料分别驱动后续页签。 */
    @Test void customsDocumentsDepartureAndClearanceDriveTabs() {
-        var missing=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,true,false,false);
-        var uploaded=new WorkflowFacts.Fact(11,1,101,"APPROVED",false,false,false,true,false);
-        var departed=new WorkflowFacts.Fact(11,1,101,"APPROVED",true,false,false,true,false);
-        var cleared=new WorkflowFacts.Fact(11,1,101,"APPROVED",true,true,false,true,false);
-        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,false);
+        var time=LocalDateTime.of(2026,10,19,10,0);
+        var missing=new WorkflowFacts.Fact(11,1,101,"APPROVED",BigDecimal.TEN,time,false,false,true,false,null,null);
+        var uploaded=new WorkflowFacts.Fact(11,1,101,"APPROVED",BigDecimal.TEN,time,false,false,false,true,null,null);
+        var departed=new WorkflowFacts.Fact(11,1,101,"APPROVED",BigDecimal.TEN,time,true,false,false,true,null,null);
+        var cleared=new WorkflowFacts.Fact(11,1,101,"APPROVED",BigDecimal.TEN,time,true,true,false,true,null,null);
+        var uploadedBeforeDeparture=new WorkflowFacts.Fact(11,1,101,"APPROVED",BigDecimal.TEN,time,false,true,false,true,null,null);
        var pendingUnload=new WorkflowFacts.Overseas(11,1,false,false,false,false);
        var unloaded=new WorkflowFacts.Overseas(11,1,false,false,false,true);
        assertThat(WorkflowTabService.classify(missing,"LOADED",null))
            .contains("WAIT_CUSTOMS_DOCS").doesNotContain("EXPORT_CUSTOMS","SAILING_CLEARANCE","WAIT_UNLOAD");
        assertThat(WorkflowTabService.classify(uploaded,"LOADED",null))
            .contains("EXPORT_CUSTOMS").doesNotContain("WAIT_CUSTOMS_DOCS","SAILING_CLEARANCE","WAIT_UNLOAD");
-        assertThat(WorkflowTabService.classify(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);
+    private WorkflowFacts.Fact fact(long id,String kg,String confirmed,boolean uploaded) {
+        return new WorkflowFacts.Fact(11,id,100+id,"APPROVED",new BigDecimal(kg),LocalDateTime.of(2026,10,19,10,0),true,uploaded,false,false,confirmed,null);
    }
    /** 有效建单移出待排车，取消后恢复；实际出库不计未出库单。 */
    @Test void cancellationRestoresDispatchQueue() {
-        var f=fact(1,true);
+        var f=fact(1,"100",null,true);
        var waiting=new WorkflowFacts.Overseas(11,1,false,false,false,true);
        var created=new WorkflowFacts.Overseas(11,1,true,true,false,true);
        var shipped=new WorkflowFacts.Overseas(11,1,true,false,true,true);
@@ -57,10 +47,17 @@ class WorkflowBusinessTest {
    }
    /** 一柜资料上传不覆盖另一柜；签收不再进入待排。 */
    @Test void independentSlicesAndUploadedClearance() {
-        assertThat(WorkflowTabService.classify(fact(1,false),"LOADED",new WorkflowFacts.Overseas(11,1,false,false,false,false)))
-            .containsExactly("SAILING_CLEARANCE");
-        assertThat(WorkflowTabService.classify(fact(2,true),"LOADED",new WorkflowFacts.Overseas(11,2,true,true,false,false)))
-            .containsExactly("OUTBOUND_DOCUMENT");
-        assertThat(WorkflowTabService.classify(fact(1,false),"DELIVERED",null)).contains("SIGNED").doesNotContain("WAIT_DISPATCH");
+        assertThat(WorkflowTabService.classify(fact(1,"100",null,false),"LOADED",new WorkflowFacts.Overseas(11,1,false,false,false,false)))
+            .contains("SAILING_CLEARANCE","WAIT_DISPATCH").doesNotContain("WAIT_UNLOAD");
+        assertThat(WorkflowTabService.classify(fact(2,"200",null,true),"LOADED",new WorkflowFacts.Overseas(11,2,true,true,false,false)))
+            .contains("WAIT_UNLOAD","OUTBOUND_DOCUMENT").doesNotContain("SAILING_CLEARANCE","WAIT_DISPATCH");
+        assertThat(WorkflowTabService.classify(fact(1,"100",null,false),"DELIVERED",null)).contains("SIGNED").doesNotContain("WAIT_DISPATCH");
+    }
+    /** 数值格式不改变版本，值或来源变化必须重新确认。 */
+    @Test void independentWeightVersion() {
+        var hash=ChargeableWeightService.fingerprint(fact(1,"100.0000",null,false));
+        assertThat(ChargeableWeightService.weight(fact(1,"100",hash,false)).confirmed()).isTrue();
+        assertThat(ChargeableWeightService.weight(fact(1,"101",hash,false)).confirmed()).isFalse();
+        assertThat(ChargeableWeightService.weight(fact(2,"100",hash,false)).confirmed()).isFalse();
    }
 }
@@ -5,16 +5,16 @@ import org.springframework.jdbc.core.JdbcTemplate;
 import org.mybatis.spring.SqlSessionTemplate;
 import com.baomidou.mybatisplus.core.MybatisConfiguration;
 import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
+import java.nio.file.*;
 import java.util.List;
 import static org.assertj.core.api.Assertions.*;
-/** 不创建独立重量确认表，验证资料归属和最新费用版本驱动的确认流转。 */
+/** 真实Mapper和隔离内存库验证资料归属、计费重确认和历史失效。 */
 class WorkflowFactPersistenceTest {
    /** 测试建表不连接业务数据库。 */
-    @Test void clearanceAndPublishedFeeConfirmationUseCurrentFacts() throws Exception {
+    @Test void clearanceAndWeightConfirmationPersistIndependently() throws Exception {
        var ds=new JdbcDataSource();ds.setURL("jdbc:h2:mem:weight-"+java.util.UUID.randomUUID()+";MODE=MySQL;DB_CLOSE_DELAY=-1");
        var db=new JdbcTemplate(ds);
        db.execute("CREATE TABLE fl_inbound_order(id BIGINT PRIMARY KEY,tenant_id BIGINT,order_id BIGINT,measure_review_status VARCHAR(30),chargeable_weight_kg DECIMAL(18,4),measure_completed_at TIMESTAMP,deleted INT,process_status VARCHAR(30))");
-        db.execute("CREATE TABLE fl_inbound_fee(id BIGINT PRIMARY KEY,tenant_id BIGINT,inbound_id BIGINT,fee_version INT,fee_status VARCHAR(32),customer_confirmed_at TIMESTAMP)");
        db.execute("CREATE TABLE fl_loading_plan_item(id BIGINT,inbound_id BIGINT,account_id BIGINT,loading_plan_id BIGINT,deleted INT)");
        db.execute("CREATE TABLE fl_loading_plan(id BIGINT,plan_status VARCHAR(30),container_booking_id BIGINT)");
        db.execute("CREATE TABLE fl_loading_pick_task(id BIGINT,loading_plan_id BIGINT,task_status VARCHAR(30))");
@@ -29,6 +29,7 @@ class WorkflowFactPersistenceTest {
        db.execute("ALTER TABLE fl_inbound_order ADD parent_inbound_id BIGINT");
        db.execute("ALTER TABLE fl_inbound_order ADD inbound_role VARCHAR(30)");
        db.execute("ALTER TABLE fl_inbound_order ADD split_purpose VARCHAR(30)");
+        db.execute(Files.readString(Path.of("src/main/resources/db/chargeable-weight-confirmation.sql")));
        db.update("INSERT INTO fl_inbound_order(id,tenant_id,order_id,measure_review_status,chargeable_weight_kg,measure_completed_at,deleted,process_status,tax_mode) VALUES(1,11,101,'APPROVED',100,CURRENT_TIMESTAMP,0,'LOADED','TAX_REFUND'),(2,22,102,'APPROVED',200,CURRENT_TIMESTAMP,0,'LOADED','BUY_DECLARATION')");
        db.update("INSERT INTO fl_loading_plan_item VALUES(3,1,11,4,0)");
        db.update("INSERT INTO fl_loading_plan VALUES(4,'COMPLETED',5)");
@@ -38,16 +39,15 @@ class WorkflowFactPersistenceTest {
        db.update("INSERT INTO fl_carrier_schedule_node_fact VALUES(5,'DEPARTED_ORIGIN_PORT',CURRENT_TIMESTAMP)");
        var config=new MybatisConfiguration();config.setMapUnderscoreToCamelCase(true);config.addMapper(WorkflowFactMapper.class);
        config.addMapper(com.baiyue.firstleg.mapper.ContainerBookingMapper.class);
-        config.addMapper(com.baiyue.firstleg.mapper.MerchantWorkbenchFilterMapper.class);
        var factory=new MybatisSqlSessionFactoryBean();factory.setDataSource(ds);factory.setConfiguration(config);
        var mapper=new SqlSessionTemplate(factory.getObject()).getMapper(WorkflowFactMapper.class);
        var containers=new SqlSessionTemplate(factory.getObject()).getMapper(com.baiyue.firstleg.mapper.ContainerBookingMapper.class);
-        var workbench=new SqlSessionTemplate(factory.getObject()).getMapper(com.baiyue.firstleg.mapper.MerchantWorkbenchFilterMapper.class);
        assertThat(containers.hasActualVesselDeparture(5)).isOne();
        assertThat(containers.hasActualVesselDeparture(6)).isZero();
        db.update("INSERT INTO fl_carrier_schedule_node_fact VALUES(6,'DEPARTED_ORIGIN_PORT',NULL),(6,'ARRIVED_DESTINATION_PORT',CURRENT_TIMESTAMP)");
        assertThat(containers.hasActualVesselDeparture(6)).isZero();
-        var repository=new WorkflowFactRepository(mapper);
+        var repository=new WorkflowFactRepository(mapper);var service=new ChargeableWeightService(repository);
+        assertThat(service.read(22,101)).isEmpty();
        assertThat(mapper.facts(List.of(1L))).singleElement().satisfies(f->{assertThat(f.departed()).isTrue();assertThat(f.clearanceUploaded()).isFalse();assertThat(f.missingCustoms()).isTrue();});
        db.update("INSERT INTO fl_container_document VALUES(5,'DESTINATION_CLEARANCE',99)");
        assertThat(mapper.facts(List.of(1L)).get(0).clearanceUploaded()).isTrue();
@@ -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->{
@@ -93,42 +92,29 @@ class WorkflowFactPersistenceTest {
        assertThat(mapper.facts(List.of(2L))).singleElement().satisfies(f->{
            assertThat(f.missingCustoms()).isFalse();assertThat(f.exportCustomsReady()).isTrue();
        });
-        // 未推送费用不进入确认页签；所有查询在没有独立重量确认表的库中运行。
-        var downstream=org.mockito.Mockito.mock(LastlegWorkflowClient.class);
-        org.mockito.Mockito.when(downstream.read(org.mockito.ArgumentMatchers.any(),org.mockito.ArgumentMatchers.any()))
-            .thenReturn(com.baiyue.common.core.api.ApiResponse.success(List.of(new WorkflowFacts.Overseas(11,1,false,false,false,false))));
-        var tabs=new WorkflowTabService(repository,downstream);
-        var inbound=new com.baiyue.firstleg.entity.InboundOrderEntity();
-        inbound.setId(1L);inbound.setTenantId(11L);inbound.setOrderId(101L);inbound.setProcessStatus("LOADED");
-        assertThat(tabs.rows(List.of(inbound))).noneMatch(r->r.mainStatus().equals("WAIT_WEIGHT_CONFIRM")||r.mainStatus().equals("WEIGHT_CONFIRMED"));
-        db.update("INSERT INTO fl_inbound_fee VALUES(20,11,1,1,'SENT',NULL),(21,22,2,1,'SENT',NULL)");
-        assertThat(tabs.rows(List.of(inbound))).anyMatch(r->r.mainStatus().equals("WAIT_WEIGHT_CONFIRM"))
-            .noneMatch(r->r.mainStatus().equals("WEIGHT_CONFIRMED"));
-        assertThat(workbench.pendingFees(11)).containsExactly(101L);
-        // 客户确认费用后两端同时流转；同重量的新费用版本仍必须重新确认。
-        db.update("UPDATE fl_inbound_fee SET customer_confirmed_at=CURRENT_TIMESTAMP WHERE id=20");
-        assertThat(tabs.rows(List.of(inbound))).anyMatch(r->r.mainStatus().equals("WEIGHT_CONFIRMED"))
-            .noneMatch(r->r.mainStatus().equals("WAIT_WEIGHT_CONFIRM"));
-        assertThat(workbench.pendingFees(11)).isEmpty();
-        db.update("INSERT INTO fl_inbound_fee VALUES(22,11,1,2,'CALCULATED',NULL)");
-        assertThat(tabs.rows(List.of(inbound))).noneMatch(r->r.mainStatus().equals("WAIT_WEIGHT_CONFIRM")||r.mainStatus().equals("WEIGHT_CONFIRMED"));
-        assertThat(workbench.pendingFees(11)).isEmpty();
-        db.update("UPDATE fl_inbound_fee SET fee_status='SENT' WHERE id=22");
-        assertThat(tabs.rows(List.of(inbound))).anyMatch(r->r.mainStatus().equals("WAIT_WEIGHT_CONFIRM"))
-            .noneMatch(r->r.mainStatus().equals("WEIGHT_CONFIRMED"));
-        assertThat(workbench.pendingFees(11)).containsExactly(101L);
-        assertThat(workbench.pendingFees(22)).containsExactly(102L);
-        db.update("UPDATE fl_inbound_order SET measure_review_status='PENDING' WHERE id=1");
-        assertThat(repository.feeConfirmationRows(List.of(1L))).isEmpty();
-        assertThat(workbench.pendingFees(11)).isEmpty();
-        db.update("UPDATE fl_inbound_order SET measure_review_status='APPROVED' WHERE id=1");
+        var current=service.read(11,101).get(0);
+        assertThat(service.confirm(11,7,1,"cmd",new WorkflowFacts.Confirm(current.fingerprint())).confirmed()).isTrue();
+        assertThat(service.confirm(11,7,1,"cmd",new WorkflowFacts.Confirm(current.fingerprint())).confirmed()).isTrue();
+        assertThat(db.queryForObject("SELECT COUNT(*) FROM fl_chargeable_weight_confirmation",Integer.class)).isEqualTo(1);
+        assertThatThrownBy(()->service.confirm(11,7,1,"cmd",new WorkflowFacts.Confirm("0".repeat(64)))).isInstanceOf(com.baiyue.common.core.exception.BizException.class);
+        db.update("UPDATE fl_inbound_order SET chargeable_weight_kg=101 WHERE id=1");
+        assertThat(service.read(11,101).get(0).confirmed()).isFalse();
+        assertThatThrownBy(()->service.confirm(11,7,1,"old",new WorkflowFacts.Confirm(current.fingerprint()))).isInstanceOf(com.baiyue.common.core.exception.BizException.class);
+        assertThatThrownBy(()->service.confirm(22,7,1,"foreign",new WorkflowFacts.Confirm(current.fingerprint()))).isInstanceOf(com.baiyue.common.core.exception.BizException.class);
        // 现行部分装柜由来源单承接实装，余量子单独立继续分柜，两票均应保留。
        db.update("INSERT INTO fl_inbound_order(id,tenant_id,order_id,measure_review_status,chargeable_weight_kg,measure_completed_at,deleted,process_status,tax_mode,parent_inbound_id,inbound_role,split_purpose) VALUES(3,11,103,'APPROVED',50,CURRENT_TIMESTAMP,0,'WAIT_SPLIT','BUY_DECLARATION',1,'CHILD','REMAINDER')");
        assertThat(mapper.facts(List.of(1L,3L))).hasSize(2);
        assertThat(mapper.facts(List.of(1L)).get(0).departed()).isTrue();
        assertThat(mapper.facts(List.of(3L)).get(0).departed()).isFalse();
-        // 父单仅作汇总时，不重复进入业务页签。
+        assertThat(service.read(11,101)).hasSize(1);
+        assertThat(service.read(11,103)).hasSize(1);
+        // 旧模型已将实装移至独立子票时，父汇总不能重复进入页签或确认。
        db.update("UPDATE fl_inbound_order SET process_status='LOADED',split_purpose='LOADED' WHERE id=3");
-        assertThat(mapper.facts(List.of(1L,3L))).singleElement().satisfies(f->assertThat(f.inboundId()).isEqualTo(3));
+        assertThat(service.read(11,101)).isEmpty();
+        assertThatThrownBy(()->service.confirm(11,7,1,"parent",new WorkflowFacts.Confirm(current.fingerprint()))).isInstanceOf(com.baiyue.common.core.exception.BizException.class);
+        var child=service.read(11,103).get(0);
+        assertThat(child.confirmed()).isFalse();
+        assertThatThrownBy(()->service.confirm(11,7,3,"cmd",new WorkflowFacts.Confirm(child.fingerprint()))).isInstanceOf(com.baiyue.common.core.exception.BizException.class);
+        assertThat(service.confirm(11,7,3,"child",new WorkflowFacts.Confirm(child.fingerprint())).confirmed()).isTrue();
    }
 }
@@ -98,12 +98,6 @@ VALUES
  (5107360,0,'PLATFORM','MENU',0,'platform:fleet:operations:list','出车记录','/overseas-master-data/trip-operations','GET',990,'ACTIVE',1,0),
  (5107362,0,'PLATFORM','BUTTON',5107360,'platform:fleet:operations:edit','更正出车实测记录',NULL,'PUT',992,'ACTIVE',1,0),
  (5107361,0,'PLATFORM','BUTTON',5107360,'platform:fleet:operations:export','导出出车记录',NULL,'GET',991,'ACTIVE',1,0),
-  (5107390,0,'PLATFORM','MENU',0,'platform:fleet:owned-business:list','自有业务','/overseas-master-data/owned-business','GET',993,'ACTIVE',1,0),
-  (5107391,0,'PLATFORM','BUTTON',5107390,'platform:fleet:owned-business:edit','登记自有业务运营信息',NULL,'PUT',994,'ACTIVE',1,0),
-  (5107392,0,'PLATFORM','BUTTON',5107390,'platform:fleet:owned-business:upload','上传自有业务照片',NULL,'POST',995,'ACTIVE',1,0),
-  (5107400,0,'PLATFORM','MENU',0,'platform:fleet:outsourced-business:list','外配业务','/overseas-master-data/outsourced-business','GET',996,'ACTIVE',1,0),
-  (5107401,0,'PLATFORM','BUTTON',5107400,'platform:fleet:outsourced-business:edit','登记外配业务承运信息',NULL,'PUT',997,'ACTIVE',1,0),
-  (5107402,0,'PLATFORM','BUTTON',5107400,'platform:fleet:outsourced-business:upload','上传外配业务照片',NULL,'POST',998,'ACTIVE',1,0),
  (5107370,0,'PLATFORM','BUTTON',5107310,'platform:fleet:trip:handover','在途车辆司机交接',NULL,'POST',1000,'ACTIVE',1,0),
  (5107385,0,'PLATFORM','BUTTON',5107220,'platform:overseas-master-data:vehicle:record-finance-submit','提交维修救援公司成本',NULL,'POST',1015,'ACTIVE',1,0),
  (5107340,0,'PLATFORM','BUTTON',5107310,'platform:fleet:trip:cost-create','登记车次直接成本',NULL,'POST',970,'ACTIVE',1,0),
@@ -167,7 +161,7 @@ INSERT IGNORE INTO iam_role_permission (tenant_id, role_id, permission_id, creat
 SELECT 0, role.id, permission.id, NOW(3)
 FROM iam_role role
 JOIN iam_permission permission ON permission.tenant_id=0 AND permission.app_code='PLATFORM'
-  AND permission.permission_code IN ('platform:fleet:trip:cost-create','platform:fleet:trip:cost-edit','platform:fleet:quote:list','platform:fleet:quote:create','platform:fleet:quote:edit','platform:fleet:quote:status','platform:fleet:quote:delete','platform:fleet:quote:import','platform:fleet:quote:export','platform:fleet:operations:list','platform:fleet:operations:export','platform:fleet:operations:edit','platform:fleet:owned-business:list','platform:fleet:owned-business:edit','platform:fleet:owned-business:upload','platform:fleet:outsourced-business:list','platform:fleet:outsourced-business:edit','platform:fleet:outsourced-business:upload','platform:fleet:trip:handover','platform:overseas-master-data:vehicle:record-finance-submit')
+  AND permission.permission_code IN ('platform:fleet:trip:cost-create','platform:fleet:trip:cost-edit','platform:fleet:quote:list','platform:fleet:quote:create','platform:fleet:quote:edit','platform:fleet:quote:status','platform:fleet:quote:delete','platform:fleet:quote:import','platform:fleet:quote:export','platform:fleet:operations:list','platform:fleet:operations:export','platform:fleet:operations:edit','platform:fleet:trip:handover','platform:overseas-master-data:vehicle:record-finance-submit')
 WHERE role.tenant_id=0 AND role.app_code='PLATFORM' AND role.role_code='PLATFORM_ADMIN'
  AND role.status='ACTIVE' AND role.deleted=0 AND permission.status='ACTIVE' AND permission.deleted=0;

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
ouyangxq	03a7e66fab	test(appointments): require canonical dispatch calendar permission	2026-10-20 17:02:20 +08:00
ouyangxq	6f31fa2131	fix(appointments): open canonical dispatch details from calendar	2026-10-20 16:36:22 +08:00