fix: align actual port arrival with latest observation

2026-10-21 16:50:48 +08:00
187 changed files with 1719 additions and 5525 deletions
@@ -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`。实际部署仍须当前对话明确授权。
@@ -67,8 +67,6 @@ def parseAutoBuildState(String description, List<String> allowedServices) {
    List<String> failedServices = []
    if (state.startsWith('RESULTS')) {
        String summary = state.substring('RESULTS'.length()).trim()
-        int metadataIndex = summary.indexOf(' | ')
-        if (metadataIndex >= 0) summary = summary.substring(0, metadataIndex).trim()
        summary.split(',').collect { it.trim() }.findAll { it }.each { item ->
            int separator = item.indexOf('=')
            if (separator > 0) {
@@ -105,25 +103,6 @@ def previousAutoBuildState(def previousBuild, List<String> allowedServices) {
    return null
 }

-// 测试范围必须相对成功门禁，而非失败/取消轮次；否则补跑可能遗漏前次未通过的变更。
-def previousSuccessfulTestCommit(def previousBuild, List<String> requiredServices) {
-    def candidate = previousBuild
-    int inspected = 0
-    while (candidate != null && inspected < 30) {
-        String description = candidate.description ?: ''
-        String marker = ' | TESTS=PASSED '
-        int markerIndex = description.lastIndexOf(marker)
-        if (candidate.result == 'SUCCESS' && markerIndex >= 0) {
-            List metadata = description.substring(markerIndex + marker.length()).trim().split(' ')
-            if (metadata.size() == 2 && metadata[0] ==~ /[0-9a-fA-F]{7,40}/ &&
-                requiredServices.every { metadata[1].split(',').contains(it) }) return metadata[0]
-        }
-        candidate = candidate.previousBuild
-        inspected++
-    }
-    return ''
-}
-
 def environmentChoicesForJob(String jobBaseName) {
    return [fixedEnvironmentForJob(jobBaseName) ?: 'test']
 }
@@ -182,9 +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: '是否跳过测试执行（仍编译测试源码）')
-        choice(name: 'TEST_SCOPE', choices: ['AUTO', 'MODULE'], description: 'AUTO 对已支持的局部变更执行关联测试；公共/未知变更自动完整模块回归；MODULE 显式完整模块回归')
-        // 地址由当前 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 前缀')
    }
@@ -291,7 +268,6 @@ pipeline {
                    selected = selected.unique()

                    env.SELECTED_SERVICES = selected.join(',')
-                    env.TEST_BASE_COMMIT = previousSuccessfulTestCommit(currentBuild.previousBuild, selected)
                    env.NO_SERVICE_CHANGE = selected ? 'false' : 'true'
                    if (!selected) {
                        currentBuild.description = params.BUILD_MODE == 'AUTO'
@@ -358,22 +334,16 @@ pipeline {
                        .findAll { it }
                        .join(',')
                    echo "统一测试本次选中的服务及其公共依赖: ${selectedModules}"
-                    String testPlan = "${pwd(tmp: true)}/ci-test-plan.json"
                    lock(resource: 'firstleg-test-maven') {
                        timeout(time: 50, unit: 'MINUTES') {
                            sh """
                                test \"\$(git rev-parse HEAD)\" = \"${env.SOURCE_COMMIT}\"
                                find . -type f -path '*/target/surefire-reports/TEST-*.xml' -delete
-                                node deploy/scripts/ci-test-scope.mjs plan --modules '${selectedModules}' --base '${env.TEST_BASE_COMMIT ?: ''}' --mode '${env.RESOLVED_ENVIRONMENT == 'test' ? (params.TEST_SCOPE ?: 'AUTO') : 'MODULE'}' --plan '${testPlan}'
-                                node deploy/scripts/ci-test-scope.mjs checks --plan '${testPlan}'
-                                test_arguments=\"\$(node deploy/scripts/ci-test-scope.mjs args --plan '${testPlan}')\"
-                                sh deploy/scripts/run-ci-maven.sh --settings deploy/maven/settings-ci.xml --batch-mode --errors -pl ${selectedModules} -am test \$test_arguments
-                                node deploy/scripts/ci-test-scope.mjs verify --plan '${testPlan}'
+                                sh deploy/scripts/run-ci-maven.sh --settings deploy/maven/settings-ci.xml --batch-mode --errors -pl ${selectedModules} -am test
                            """
                        }
                    }
                    echo "统一测试门禁通过: ${env.SOURCE_COMMIT}；下游单服务任务不再重复执行测试"
-                    env.TEST_GATE_PASSED = 'true'
                }
            }
            post {
@@ -430,9 +400,6 @@ pipeline {
                    currentBuild.description = params.BUILD_MODE == 'AUTO'
                        ? "AUTO ${env.IMAGE_TAG} | RESULTS ${summary}"
                        : "${env.IMAGE_TAG} | ${summary}"
-                    if (env.TEST_GATE_PASSED == 'true') {
-                        currentBuild.description += " | TESTS=PASSED ${env.SOURCE_COMMIT} ${env.SELECTED_SERVICES}"
-                    }
                    if (failed) {
                        unstable("部分服务执行失败，但其他服务已独立完成：${failed.join(', ')}")
                    }
@@ -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`。
@@ -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,226 +0,0 @@
-#!/usr/bin/env node
-import { readFileSync, readdirSync, writeFileSync, statSync } from 'node:fs'
-import { resolve, relative, basename } from 'node:path'
-import { execFileSync } from 'node:child_process'
-import { fileURLToPath } from 'node:url'
-
-const moduleName = 'lastleg-service'
-const testClass = /(?:^Test.+|.+(?:Test|Tests|TestCase))\.java$/
-const words = source => new Set(source.match(/[A-Za-z_$][A-Za-z0-9_$]*/g) || [])
-const tables = source => new Set(source.match(/\bll_[a-z0-9_]+\b/g) || [])
-const writtenTables = source => new Set([...source.matchAll(/\b(?:UPDATE|INSERT\s+(?:IGNORE\s+)?INTO|DELETE\s+FROM)\s+(ll_[a-z0-9_]+)/gi)].map(match => match[1]))
-
-// 按完整注解比较 SQL，避免只改 SELECT 时把同一 Mapper 内未改的全部写语句扩大为全域回归。
-function writeStatements(source) {
-  const result = []
-  for (const match of source.matchAll(/@(?:Insert|Update|Delete)\s*\(/g)) {
-    let depth = 1, quote = '', index = match.index + match[0].length
-    for (; index < source.length && depth; index++) {
-      if (quote) {
-        if (source.startsWith(quote, index)) { index += quote.length - 1; quote = '' }
-        else if (source[index] === '\\' && quote.length === 1) index++
-      } else if (source.startsWith('"""', index)) { quote = '"""'; index += 2 }
-      else if (source[index] === '"' || source[index] === "'") quote = source[index]
-      else if (source[index] === '(') depth++
-      else if (source[index] === ')') depth--
-    }
-    if (depth) throw new Error('Cannot parse SQL annotation; use MODULE test scope')
-    result.push(source.slice(match.index, index))
-  }
-  return result
-}
-
-function changedWrites(node) {
-  if (node.previousSource === undefined) return writtenTables(node.source)
-  const before = writeStatements(node.previousSource), after = writeStatements(node.source)
-  const changed = [...before.filter(sql => !after.includes(sql)), ...after.filter(sql => !before.includes(sql))]
-  const oldRest = before.reduce((text, sql) => text.replace(sql, ''), node.previousSource)
-  const newRest = after.reduce((text, sql) => text.replace(sql, ''), node.source)
-  if (oldRest !== newRest) changed.push(oldRest, newRest)
-  return writtenTables(changed.join('\n'))
-}
-
-/** 宁可扩大范围，不用文件名猜测唯一测试；未识别的输入保留完整模块门禁。 */
-export function planTests({ modules, mode = 'AUTO', changes = [], sources = [], baseline = '' }) {
-  const architectureScript = `${moduleName}/scripts/analyze-lastleg-dependencies`
-  const staticChecks = changes.some(path => path.startsWith(architectureScript))
-    ? [`${architectureScript}.test.mjs`] : []
-  const full = reason => ({ scope: 'MODULE', reason, modules, baseline, tests: [], staticChecks })
-  if (mode !== 'AUTO' && mode !== 'MODULE') throw new Error('TEST_SCOPE must be AUTO or MODULE')
-  if (mode === 'MODULE') return full('显式完整模块回归')
-  if (!baseline) return full('没有成功测试基线')
-  if (modules.length !== 1 || modules[0] !== moduleName) return full('多服务或尚未核对的服务采用完整模块回归')
-  const prefix = `${moduleName}/`
-  const relevant = changes.filter(path => path.startsWith(prefix))
-  const shared = changes.some(path => path !== 'scripts/agents-index-contract.ps1' && !path.startsWith(prefix)
-    && /^(?:common-[^/]+\/|platform-bom\/|pom\.xml$|Jenkinsfile|deploy\/|config\/|scripts\/.*\.(?:mjs|sh|ps1)$)/.test(path))
-  if (shared) return full('公共能力、发布或测试基础设施变更')
-  if (!relevant.length) return full('补跑服务没有可验证的业务差异')
-  const java = `${prefix}src/main/java/com/baiyue/lastleg/`
-  const supported = path => path.startsWith(`${prefix}src/test/java/`)
-    || path.startsWith(`${prefix}src/main/resources/openapi/`)
-    || path.startsWith(architectureScript)
-    || (path.startsWith(java) && path.slice(java.length).includes('/')
-      && !/^(?:config|security|entity|dto|model|mapper|repository|service|client)\//.test(path.slice(java.length)))
-    || /\.(?:md)$/.test(path)
-  if (relevant.some(path => !supported(path))) return full('共享模型、配置、SQL、资源或未识别路径变更')
-
-  const nodes = sources.map(({ path, source, previousSource }) => ({ path, source, previousSource,
-    symbol: basename(path, '.java'), tokens: words(source), tables: tables(source),
-    test: path.startsWith(`${prefix}src/test/java/`),
-    name: `${source.match(/\bpackage\s+([\w.]+)\s*;/)?.[1] || ''}.${basename(path, '.java')}` }))
-  const byPath = new Map(nodes.map(node => [node.path, node]))
-  const bySymbol = new Map()
-  for (const node of nodes) {
-    if (!bySymbol.has(node.symbol)) bySymbol.set(node.symbol, [])
-    bySymbol.get(node.symbol).push(node)
-  }
-  const reverse = new Map(nodes.map(node => [node.path, new Set()]))
-  for (const node of nodes) {
-    // 包含反射字符串、静态 import、同包引用及测试夹具；重名类全部纳入。
-    for (const token of node.tokens) for (const dependency of bySymbol.get(token) || []) {
-      if (dependency !== node) reverse.get(dependency.path).add(node.path)
-    }
-    // 实现变化也要覆盖只依赖接口/基类的调用者，不能仅沿显式 import 反查。
-    for (const match of node.source.matchAll(/\b(?:implements|extends)\s+([^{};]+)/g)) {
-      for (const token of words(match[1])) for (const contract of bySymbol.get(token) || []) {
-        if (contract !== node) reverse.get(node.path).add(contract.path)
-      }
-    }
-  }
-  const seeds = new Set()
-  const changedTables = new Set()
-  for (const path of relevant.filter(path => path.endsWith('.java'))) {
-    const node = byPath.get(path)
-    if (node) {
-      seeds.add(path)
-      // 读查询变化不改变其他查询的数据；潜在写入变化则纳入同表读写消费者。
-      if (!node.test) for (const table of changedWrites(node)) changedTables.add(table)
-    } else {
-      // 删除/移动旧类型时，仍按旧类名查现存消费者。
-      const symbol = basename(path, '.java')
-      const consumers = nodes.filter(consumer => consumer.tokens.has(symbol))
-      if (!consumers.length) return full('删除类型缺少可追踪的现存消费者')
-      for (const consumer of consumers) seeds.add(consumer.path)
-    }
-  }
-  if (!seeds.size) return full('没有可追踪的 Java 行为差异')
-  for (const node of nodes) if ([...node.tables].some(table => changedTables.has(table))) seeds.add(node.path)
-  const affected = new Set(seeds)
-  const queue = [...seeds]
-  for (let index = 0; index < queue.length; index++) {
-    for (const consumer of reverse.get(queue[index]) || []) if (!affected.has(consumer)) {
-      affected.add(consumer); queue.push(consumer)
-    }
-  }
-  const allTests = nodes.filter(node => node.test && testClass.test(basename(node.path))
-    && /@(?:Test|ParameterizedTest|RepeatedTest|TestFactory|TestTemplate)\b/.test(node.source))
-  const contractChange = relevant.some(path => path.startsWith(`${prefix}src/main/resources/openapi/`))
-  const candidates = allTests.filter(node => affected.has(node.path)
-    || /(?:Security|Isolation|MapperRegistrationArchitecture|QueryBinding)/.test(node.symbol)
-    || (contractChange && /(?:Contract|OpenApi|Schema|Architecture|Permission)/.test(node.symbol)))
-  // 显式依赖真实环境的类仍由 MODULE/专项授权入口负责，不能把它们默认跳过算作执行成功。
-  const optIn = node => /@(?:EnabledIf(?:SystemProperty|EnvironmentVariable)|Disabled(?:IfSystemProperty|IfEnvironmentVariable)?\b)/
-    .test(node.source.slice(0, node.source.indexOf(`class ${node.symbol}`)))
-  const tests = candidates.filter(node => !optIn(node))
-  if (!tests.some(node => affected.has(node.path))) return full('没有匹配到行为测试，拒绝零测试通过')
-  if (tests.some(node => !/^com\.[\w.$]+$/.test(node.name))) return full('测试类名无法安全传入 Maven')
-  return { scope: 'AFFECTED', reason: 'Java 反向引用、接口实现、测试夹具、共享 SQL 表和相关静态合同',
-    modules, baseline, tests: tests.map(node => node.name).sort(), totalTests: allTests.length, staticChecks,
-    optInTests: candidates.filter(optIn).map(node => node.name).sort() }
-}
-
-function walk(root) {
-  const files = []
-  for (const item of readdirSync(root, { withFileTypes: true })) {
-    const path = resolve(root, item.name)
-    if (item.isDirectory()) files.push(...walk(path))
-    else if (item.isFile() && item.name.endsWith('.java')) files.push(path)
-  }
-  return files
-}
-
-/** 每个所选类必须有本轮实际执行的报告；允许上游零匹配不能变成整个门禁零测试。 */
-export function verifyReports(plan, reports) {
-  if (plan.scope !== 'AFFECTED') return
-  for (const name of plan.tests) {
-    const matches = reports.filter(report => report.name === name || report.name.startsWith(`${name}$`))
-    if (!matches.length || matches.some(report => report.failures || report.errors
-      || ['tests', 'skipped', 'failures', 'errors'].some(key => !Number.isInteger(report[key]) || report[key] < 0)
-      || report.skipped > report.tests)
-      || matches.reduce((sum, report) => sum + report.tests - report.skipped, 0) <= 0) {
-      throw new Error(`Missing, skipped or failed fresh test report: ${name}`)
-    }
-  }
-}
-
-function main(args) {
-  const [action, ...options] = args
-  const values = {}
-  for (let i = 0; i < options.length; i += 2) {
-    if (!options[i].startsWith('--') || options[i + 1] === undefined) throw new Error('Expected --name value')
-    values[options[i].slice(2)] = options[i + 1]
-  }
-  const root = process.cwd()
-  const planFile = values.plan
-  if (!planFile) throw new Error('--plan is required')
-  if (action === 'plan') {
-    const modules = (values.modules || '').split(',')
-    if (modules.some(module => !/^[a-z][a-z0-9-]+$/.test(module))) throw new Error('Invalid modules')
-    let baseline = values.base || ''
-    let changes = []
-    if (baseline) {
-      if (!/^[0-9a-f]{7,40}$/i.test(baseline)) throw new Error('Invalid baseline commit')
-      try {
-        execFileSync('git', ['merge-base', '--is-ancestor', baseline, 'HEAD'], { stdio: 'pipe' })
-        changes = execFileSync('git', ['diff', '--name-only', '-z', baseline, 'HEAD'], { encoding: 'utf8' }).split('\0').filter(Boolean)
-      } catch { baseline = '' }
-    }
-    const sources = modules.length === 1 && modules[0] === moduleName
-      ? ['main', 'test'].flatMap(set => walk(resolve(root, moduleName, 'src', set, 'java')))
-        .map(path => {
-          const key = relative(root, path).replaceAll('\\', '/')
-          const entry = { path: key, source: readFileSync(path, 'utf8') }
-          if (baseline && changes.includes(key)) {
-            try { entry.previousSource = execFileSync('git', ['show', `${baseline}:${key}`], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }) }
-            catch { entry.previousSource = '' }
-          }
-          return entry
-        }) : []
-    const plan = { ...planTests({ modules, mode: values.mode || 'AUTO', baseline, changes, sources }), startedAt: Date.now() }
-    writeFileSync(planFile, JSON.stringify(plan))
-    console.log(`CI test scope: ${plan.scope}; ${plan.reason}`)
-    if (plan.scope === 'AFFECTED') console.log(`Selected ${plan.tests.length}/${plan.totalTests} test classes:\n${plan.tests.join('\n')}`)
-    if (plan.optInTests?.length) console.log(`Explicit environment tests remain opt-in (not counted as passed): ${plan.optInTests.join(',')}`)
-    return
-  }
-  const plan = JSON.parse(readFileSync(planFile, 'utf8'))
-  if (action === 'args') {
-    if (plan.scope === 'AFFECTED') process.stdout.write(`-Dtest=${plan.tests.join(',')} -Dsurefire.failIfNoSpecifiedTests=false -Dci.sql-semantic.skip=true`)
-  } else if (action === 'checks') {
-    for (const check of plan.staticChecks || []) {
-      if (check !== `${moduleName}/scripts/analyze-lastleg-dependencies.test.mjs`) throw new Error('Unsupported static check')
-      execFileSync(process.execPath, ['--test', '--test-concurrency=2', check], { stdio: 'inherit' })
-    }
-  } else if (action === 'verify') {
-    const reports = []
-    if (plan.scope === 'AFFECTED') for (const module of plan.modules) {
-      const directory = resolve(root, module, 'target/surefire-reports')
-      for (const filename of readdirSync(directory)) {
-        if (!/^TEST-.*\.xml$/.test(filename)) continue
-        const path = resolve(directory, filename)
-        if (statSync(path).mtimeMs < plan.startedAt - 2000) continue
-        const xml = readFileSync(path, 'utf8').match(/<testsuite\b([^>]+)>/)?.[1]
-        if (!xml) continue
-        const attrs = Object.fromEntries([...xml.matchAll(/([\w-]+)="([^"]*)"/g)].map(match => [match[1], match[2]]))
-        reports.push({ name: attrs.name || '', ...Object.fromEntries(['tests', 'failures', 'errors', 'skipped'].map(key => [key, Number(attrs[key] || 0)])) })
-      }
-    }
-    verifyReports(plan, reports)
-    console.log(`CI test reports verified: ${plan.scope}`)
-  } else throw new Error(`Unknown action: ${action}`)
-}
-
-if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  try { main(process.argv.slice(2)) } catch (error) { console.error(error.message); process.exitCode = 1 }
-}
@@ -429,7 +429,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 '本趟主档或临时车辆司机的真实资源快照',
@@ -4875,7 +4874,7 @@ CREATE TABLE ll_fleet_pickup_history (
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='取货不可变操作历史';

 -- 自有业务仅保存原排车的归属证据和附加运营信息，不复制履约主单。
-CREATE TABLE ll_fleet_owned_business_ownership (
+CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_ownership (
  dispatch_id BIGINT NOT NULL COMMENT '原排车内部主键',
  resource_mode VARCHAR(16) NOT NULL COMMENT '原排车资源模式MASTER或EXTERNAL',
  vehicle_id BIGINT NULL COMMENT '真实车辆档案主键，临时外配为空',
@@ -4893,7 +4892,7 @@ CREATE TABLE ll_fleet_owned_business_ownership (
    OR (resource_mode='EXTERNAL' AND vehicle_id IS NULL AND vehicle_record_version IS NULL AND vehicle_ownership='DISPATCHED'))
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='原排车装车完成时的车辆归属证据';

-CREATE TABLE ll_fleet_owned_business_record (
+CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_record (
  id BIGINT NOT NULL COMMENT '附加运营记录内部主键',
  dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
  record_version BIGINT NOT NULL COMMENT '附加运营记录并发版本，独立于原排车版本',
@@ -4918,7 +4917,7 @@ CREATE TABLE ll_fleet_owned_business_record (
  CONSTRAINT ck_owned_business_fuel CHECK (fuel_consumption_litres_per_100km IS NULL OR fuel_consumption_litres_per_100km>=0)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='原排车自有业务附加运营信息';

-CREATE TABLE ll_fleet_owned_business_command (
+CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_command (
  id BIGINT NOT NULL COMMENT '附加运营命令内部主键',
  dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
  operator_id VARCHAR(64) NOT NULL COMMENT '原命令操作人标识',
@@ -4939,7 +4938,7 @@ CREATE TABLE ll_fleet_owned_business_command (
  CONSTRAINT ck_owned_business_command_status CHECK (status IN ('PENDING','SUCCEEDED','REJECTED','UNKNOWN_RESULT'))
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='原排车附加运营写命令及可恢复结果';

-CREATE TABLE ll_fleet_owned_business_history (
+CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_history (
  id BIGINT NOT NULL COMMENT '附加运营历史内部主键',
  dispatch_id BIGINT NOT NULL COMMENT '所属原排车内部主键',
  record_version BIGINT NOT NULL COMMENT '成功写入后的附加记录版本',
@@ -11,8 +11,6 @@ enum BusinessFileCategory {
    FLEET_TRIP_OPERATION_EVIDENCE(false, FormatPolicy.PDF_IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
    OVERSEAS_DISPATCH_VEHICLE_EVIDENCE(false, FormatPolicy.PDF_IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
    OVERSEAS_DISPATCH_DRIVER_EVIDENCE(false, FormatPolicy.PDF_IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
-    OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
-    OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
    OVERSEAS_DISPATCH_LOADING_PHOTO(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
    OVERSEAS_DISPATCH_FUEL_PHOTO(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
    FLEET_VEHICLE_RECORD_PHOTO(false, FormatPolicy.IMAGE, Limits.STANDARD, BusinessIdPolicy.POSITIVE_LONG),
@@ -80,9 +78,9 @@ enum BusinessFileCategory {
                && tenantId != 0) {
            throw new BizException(ResultCode.BAD_REQUEST, "排车运营照片必须归属平台");
        }
-        if ((this == OVERSEAS_DISPATCH_VEHICLE_EVIDENCE || this == OVERSEAS_DISPATCH_DRIVER_EVIDENCE || this == OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE || this == OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE)
+        if ((this == OVERSEAS_DISPATCH_VEHICLE_EVIDENCE || this == OVERSEAS_DISPATCH_DRIVER_EVIDENCE)
                && tenantId != 0) {
-            throw new BizException(ResultCode.BAD_REQUEST, "排车证据必须归属平台");
+            throw new BizException(ResultCode.BAD_REQUEST, "排车车辆及司机证据必须归属平台");
        }
        if (this == FLEET_TRIP_OPERATION_EVIDENCE && tenantId != 0) {
            throw new BizException(ResultCode.BAD_REQUEST, "出车实测凭证必须归属平台");
@@ -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]
@@ -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);
@@ -17,7 +17,7 @@

 拼车余位发布查 `fleet/trip/FleetCapacityOfferService.java`；整车建单与准备查 `dispatch/controller/DispatchAggregateController.java` 和 `dispatch/service/DispatchAggregateService.java`，本土业务接线查 `fleet/business/`；既有外接登记衔接合同为 `fleet-preparation-v1.yaml`，排车流程按 `../../docs/海外仓业务/排车列表统一作业改造契约.md`。

-原排车装车后运营视图分别查 `fleet/ownedbusiness/`、`fleet/outsourcedbusiness/` 与各自 `fleet-*-business-v1.yaml`；自有业务按无实际拼车货物、外配任务按已实际接入需求池货物分类；车辆归属仍读取装车快照，完整判定唯一见外配业务契约。两入口可信作用域及权限独立，外配仅整车承运金额、逐目的仓到达和五装车照片；复用四张附加表，不修改原履约/库存/财务状态。共同业务规则见 `../../docs/海外仓业务/自有业务首版开发契约.md`、`../../docs/海外仓业务/外配业务首版开发契约.md`，实际发布及HTTP只查部署主契约。
+原排车装车后运营视图分别查 `fleet/ownedbusiness/`、`fleet/outsourcedbusiness/` 与各自 `fleet-*-business-v1.yaml`；自有/外配按同事务捕获的车辆归属，不按货源区分。两入口可信作用域及权限独立，外配仅整车承运金额、逐目的仓到达和五装车照片；复用四张附加表，不修改原履约/库存/财务状态。共同业务规则见 `../../docs/海外仓业务/自有业务首版开发契约.md`、`../../docs/海外仓业务/外配业务首版开发契约.md`，实际发布及HTTP只查部署主契约。

 事件重试：`controller/EventOperationsController.java`，内部 `/internal/lastleg/event-operations/{entryId}` 查询、`/retry` 写入；仅卸柜、派送、暂扣、资金及费用事件，以 `EVENT_OPERATIONS_TOKEN` 保护。原事件不可改，DEAD→PENDING 与 `event_delivery_retry_audit` 同事务；脚本 `scripts/event-outbox-operations.mjs`。

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

 - 车次成本：`fleet/trip/FleetTripCostService.java`、`fleet-trip-costs-v1.yaml`；按DEPART实测及外接实收分摊，不产生客户账单/付款。
 - 报价/统计：`fleet/quote/`、`fleet/reporting/`，合同`fleet-quotes-v1.yaml`、`fleet-operations-v1.yaml`；实测凭证按车次归属，仅当前/历史版本引用可下载。
- 自有业务运营：`fleet/ownedbusiness/`、`fleet-owned-business-v1.yaml`，共同规则见`../../../docs/海外仓业务/自有业务首版开发契约.md`；原排车装车后三阶段按无实际拼车货物展示，车辆归属独立，仅补金额、逐目的地到达、里程、油耗与照片。原详情只经`dispatch.port.DispatchDetailReader`读取，原装车事务经`OwnedBusinessOwnershipCapture`捕获归属，不另建履约流程。
- 外配业务运营：`fleet/outsourcedbusiness/`、`fleet-outsourced-business-v1.yaml`，共同规则见`../../../docs/海外仓业务/外配业务首版开发契约.md`；原排车装车后三阶段按实际接入需求池拼车货物展示，车辆归属独立，包含MASTER/EXTERNAL两种资源模式。只登记整车承运金额、逐目的仓到达和五装车照片，无里程/油耗或成本拆分。内部可信作用域复用四表，入口权限与自有严格分开，不引入第二履约模型。
+- 自有业务运营：`fleet/ownedbusiness/`、`fleet-owned-business-v1.yaml`，共同规则见`../../../docs/海外仓业务/自有业务首版开发契约.md`；原排车装车后三阶段按装车时自有车辆归属展示，仅补金额、逐目的地到达、里程、油耗与照片。原详情只经`dispatch.port.DispatchDetailReader`读取，原装车事务经`OwnedBusinessOwnershipCapture`捕获归属，不另建履约流程。
+- 外配业务运营：`fleet/outsourcedbusiness/`、`fleet-outsourced-business-v1.yaml`，共同规则见`../../../docs/海外仓业务/外配业务首版开发契约.md`；原排车装车后三阶段按冻结DISPATCHED归属展示，包括正式MASTER/EXTERNAL两种资源模式。只登记整车承运金额、逐目的仓到达和五装车照片，无里程/油耗或成本拆分。内部可信作用域复用四表，入口权限与自有严格分开，不引入第二履约模型。
 - 外接选价合同：`fleet-quote-candidates-v1.yaml`、`fleet-trips-v1.yaml`；来源快照与成交价分开，确认承运复验。
 - 在途交接：`fleet/exception/`、`fleet-handovers-v1.yaml`；后台确认交接，旧资源分别结束任务，DEPART不重写。

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

 `fleet.ownedbusiness`只为原排车装车后的自有车辆组合运营资料。五条精确引用限`OwnedBusinessModels→DispatchViews`、`OwnedBusinessProjection→DispatchContracts`、`OwnedBusinessQueryService→DispatchContracts/DispatchTypes/DispatchDetailReader`，均为`dispatch.port`公开事实或只读应用端口；不增加`fleet→dispatch-delivery`通用许可，不共享原排车实体、Mapper或具体Service。原详情适配器在dispatch内部委托唯一提供者。`DispatchAggregateService→OwnedBusinessOwnershipCapture`仅在原装车事务捕获归属，不能反向调用运营查询；捕获失败随原确认回滚。反向合同拒绝具体持久化/Service引用、其他消费者借用端口许可及任何包循环。

-### 装车资料触发派送边界（2026-10-21）
-
-`DispatchLoadingDocumentService`、`DispatchLoadingDepartureService`及平台/PDA两个装车资料Controller只引用`fleet.ownedbusiness.port.DispatchLoadingPhotoPort`的公开照片、版本、绑定请求和结果。`DispatchLoadingPhotoAdapter`在车队内部复用原附加表、上传账本和文件校验，不反向调用排车服务。排车服务持整车父锁，在装车确认或资料保存后核对两项条件，同一事务推进派送并记录原结果。结构门禁仅开放上述四类到此端口的精确引用，不开放车队Service、Repository或Mapper，也不新增包循环。
-
 ### 外配业务原排车详情读取边界（2026-10-21）

 `OutsourcedBusinessModels → DispatchViews` 仅组合既有 `dispatch.port` 公开详情。依赖登记与已有外配反向合同同步，不开放 `fleet→dispatch-delivery` 通用许可；原排车实体、Mapper、具体 Service 及其他消费者仍由门禁拒绝。
@@ -4,10 +4,6 @@
    <modelVersion>4.0.0</modelVersion>
    <parent><groupId>com.baiyue.firstleg</groupId><artifactId>baiyue-firstleg-platform</artifactId><version>1.0.0-SNAPSHOT</version><relativePath>../pom.xml</relativePath></parent>
    <artifactId>lastleg-service</artifactId>
-    <properties>
-        <!-- 定向 -Dtest 在 default-test 执行所选类，避免后置 SQL 执行再次运行同一列表。 -->
-        <ci.sql-semantic.skip>false</ci.sql-semantic.skip>
-    </properties>
    <dependencies>
        <dependency><groupId>com.google.zxing</groupId><artifactId>core</artifactId><version>3.5.3</version></dependency>
        <dependency><groupId>com.baiyue.shared</groupId><artifactId>common-event-contract</artifactId><version>${project.version}</version></dependency>
@@ -46,7 +42,6 @@
                        <phase>test</phase>
                        <goals><goal>test</goal></goals>
                        <configuration>
-                            <skip>${ci.sql-semantic.skip}</skip>
                            <includes><include>**/*SqlSemanticTest.java</include></includes>
                            <reuseForks>false</reuseForks>
                        </configuration>
@@ -72,18 +72,11 @@ test('fleet stays a business slice and its policies have no infrastructure depen
      && edge.target === 'com.baiyue.lastleg.fleet.exception.FleetHandoverPdaQuery'
    || edge.source === 'com.baiyue.lastleg.dispatch.service.DispatchAggregateService'
      && edge.target === 'com.baiyue.lastleg.fleet.ownedbusiness.port.OwnedBusinessOwnershipCapture'
-    || ['com.baiyue.lastleg.dispatch.service.DispatchLoadingDocumentService',
-      'com.baiyue.lastleg.dispatch.service.DispatchLoadingDepartureService',
-      'com.baiyue.lastleg.dispatch.controller.DispatchLoadingDocumentController',
-      'com.baiyue.lastleg.dispatch.pda.controller.PdaDispatchLoadingDocumentController'].includes(edge.source)
-      && edge.target === 'com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort'
    || [
      'TransportTaskModels->pickup.FleetPickupModels', 'TransportTaskModels->trip.FleetTripModels',
      'TransportTaskProjection->trip.FleetTripEntity', 'TransportTaskProjection->trip.TransportTripChanged',
      'TransportTaskService->business.FleetPoolOrderQueries', 'TransportTaskService->driver.DriverService',
      'TransportTaskService->reporting.TripOperationsEvidenceGateway',
-      // 取货照片沿既有运输边界读取车次身份/时间，并复用司机资格与证照授权；不开放 Mapper。
-      'TransportReviewPhotos->driver.DriverService', 'TransportReviewPhotos->trip.FleetTripEntity',
    ].some(reference => `${edge.source}->${edge.target}` === `com.baiyue.lastleg.dispatch.transport.${reference.replace('->', '->com.baiyue.lastleg.fleet.')}`)),
    'dispatch must use fleet ports and guards, not its persistence mappers');
  const incomingEdges = report.classDependencies.filter(edge => edge.source.startsWith('com.baiyue.lastleg.transfer.') && edge.target.startsWith('com.baiyue.lastleg.fleet.'));
@@ -37,6 +37,25 @@ public class DeliveryTransferController {
        return ApiResponse.success(dispatchDelivery.preview(actor(user),dispatchNo).groups());
    }

+    /** 一次快照提供全部客户目的地、费用证据及既有安排的完整数组。 */
+    @GetMapping("/dispatches/{dispatchNo}/delivery-arrangement")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.DISPATCH_LIST + "')")
+    public ApiResponse<ArrangementPreview> arrangement(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo) {
+        requirePlatform(user);
+        return ApiResponse.success(dispatchDelivery.preview(actor(user),dispatchNo));
+    }
+
+    /** 平台一次安排本车全部客户，身份只从认证上下文获取。 */
+    @PostMapping("/dispatches/{dispatchNo}/transfer-delivery")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.DISPATCH_TRANSFER_DELIVERY + "')")
+    @Operation(summary = "按真实客户生成出库单并按客户目的地生成派送单")
+    public ApiResponse<CommandResult> transfer(
+        @AuthenticationPrincipal AuthenticatedUser user, @PathVariable String dispatchNo,
+        @Valid @RequestBody ArrangeDelivery request) {
+        requirePlatform(user);
+        return ApiResponse.success(dispatchDelivery.arrange(actor(user),dispatchNo,request));
+    }
+
    @PostMapping("/outbound-orders/one-click-dropship")
    @PreAuthorize("hasAuthority('" + OverseasPermissions.OUTBOUND_CREATE + "')")
    @Operation(summary = "Create one-click dropship outbound and push a PDA picking task")
@@ -126,51 +126,6 @@ public class DispatchDeliveryService implements DispatchDeliveryPort {
            var input=inputs.get(group.key());var coverage=fees.coverage(group,input,actor.operatorId(),external.get(group.customerId()));
            fees.validate(group,input,coverage,external.get(group.customerId()));coverages.put(group.key(),coverage);
        }
-        var fact=createDocuments(context,actor,request.idempotencyKey(),businessHash,groups,inputs,external,coverages);
-        return execution.recordArrangement(context,actor,identity,fact,false);
-    }
-
-    /** 装车父事务内自动生成全车单据；未知派送资料和未确认费用保持未登记。 */
-    @Override
-    @Transactional(propagation=Propagation.MANDATORY)
-    public ArrangementFact prepareForDeparture(Context context,Actor actor,String commandKey) {
-        if(actor==null || blank(actor.operatorId()) || blank(commandKey) || commandKey.length()>255)
-            throw conflict("缺少装车操作身份或原请求标识");
-        if(context==null || context.status()!=Status.ACTIVE || context.stage()!=Stage.AFTER_LOADING
-            || !context.pickingReconciled() || context.loadingCompletedAt()==null || blank(context.loadingCompletionHash())
-            || blank(context.cargoHash()) || context.cargo()==null || context.cargo().isEmpty())
-            throw conflict("请先完成真实拣货核平及装车确认");
-        if(actor.mode()==ActorMode.PDA && !Objects.equals(actor.boundWarehouseId(),context.warehouseId()))
-            throw conflict("排车不属于当前绑定仓");
-        var saved=repository.arrangement(context.dispatchId(),true);
-        if(saved!=null) {
-            if(!Objects.equals(saved.getOriginalCommandKey(),commandKey)
-                || !Objects.equals(saved.getCargoHash(),context.cargoHash())
-                || !Objects.equals(saved.getLoadingCompletionHash(),context.loadingCompletionHash()))
-                throw conflict("本车已有不同装车命令生成的派送事实");
-            var facts=departureFacts(context,true);
-            if(!facts.depart().allowed())throw conflict(facts.depart().blockReason());
-            return fact(saved);
-        }
-        // 不能把缺少安排事实的孤立单据补建成另一套；全部客户在同一事务中创建。
-        if(!repository.outbounds(context.dispatchId(),true).isEmpty() || !repository.deliveries(context.dispatchId(),true).isEmpty())
-            throw conflict("已存在关联单据但缺少完整安排事实，请核对");
-        var groups=grouping.groups(context);var external=fees.external(context);
-        var inputs=new HashMap<String,ArrangeGroup>();
-        for(var group:groups) {
-            String carrier=context.resources()==null || context.resources().vehicle()==null?null:context.resources().vehicle().carrierName();
-            inputs.put(group.key(),new ArrangeGroup(group.key(),group.cargoHash(),null,null,null,carrier,null,null,
-                null,null,null,null,null,external.get(group.customerId()).snapshotHash(),null,List.of(),List.of()));
-        }
-        String businessHash=grouping.hash(Arrays.asList(context.dispatchNo(),context.cargoHash(),context.loadingCompletionHash(),
-            groups.stream().map(g->inputs.get(g.key())).toList()));
-        return createDocuments(context,actor,commandKey,businessHash,groups,inputs,external,Map.of());
-    }
-
-    /** 自动装车与内部安排复用同一建单、来源锁及真实外接报价发布路径，不推定原费覆盖。 */
-    private ArrangementFact createDocuments(Context context,Actor actor,String commandKey,String businessHash,List<Group> groups,
-        Map<String,ArrangeGroup> inputs,Map<String,com.baiyue.lastleg.fleet.trip.FleetBookingFreight.Preview> external,
-        Map<String,DeliveryFeeCoverageModels.Evidence> coverages) {
        var now=Instant.now();String key="DLA"+IdWorker.getId();var outbounds=new LinkedHashMap<String,OutboundOrder>();
        for (var customer:groups.stream().map(Group::customerId).distinct().sorted().toList()) {
            var cargo=context.cargo().stream().filter(c->customer.equals(c.customerId())).toList();
@@ -214,9 +169,9 @@ public class DispatchDeliveryService implements DispatchDeliveryPort {
        var arrangement=new DispatchDeliveryArrangement();arrangement.setId(IdWorker.getId());arrangement.setDispatchOrderId(context.dispatchId());
        arrangement.setDispatchNo(context.dispatchNo());arrangement.setArrangementKey(key);arrangement.setBusinessHash(businessHash);
        arrangement.setCargoHash(context.cargoHash());arrangement.setLoadingCompletionHash(context.loadingCompletionHash());
-        arrangement.setOriginalCommandKey(commandKey);arrangement.setOriginalOperatorId(actor.operatorId());
+        arrangement.setOriginalCommandKey(request.idempotencyKey());arrangement.setOriginalOperatorId(actor.operatorId());
        arrangement.setResultJson(write(result));arrangement.setCargoJson(write(context.cargo()));arrangement.setCreatedAt(local(now));repository.create(arrangement);
-        return fact(arrangement);
+        return execution.recordArrangement(context,actor,identity,fact(arrangement),false);
    }

    /** 发车先取得全部出库锁，再取得全部派送锁，当前读取不申请来源锁。 */
@@ -326,7 +281,7 @@ public class DispatchDeliveryService implements DispatchDeliveryPort {
        var destination=group.destination();d.setDeliveryGroupKey(grouping.documentGroupKey(destination));d.setDestinationType(destination.type());
        d.setDestinationWarehouseId(destination.warehouseId());d.setDestinationWarehouseCode(destination.warehouseCode());d.setDestinationWarehouseName(destination.warehouseName());
        d.setDeliveryAddress(destination.address());d.setPostalCode(destination.postalCode());d.setContactName(destination.contactName());d.setContactPhone(destination.contactPhone());
-        d.setStatus("WAIT_DELIVERY");d.setVersion(0L);d.setDeliveryMethod(input.deliveryMethod());d.setPlannedDeliveryAt(input.plannedDeliveryAt()==null?null:local(input.plannedDeliveryAt()));
+        d.setStatus("WAIT_DELIVERY");d.setVersion(0L);d.setDeliveryMethod(input.deliveryMethod());d.setPlannedDeliveryAt(local(input.plannedDeliveryAt()));
        d.setWaybillNo(input.waybillNo());d.setCarrierName(input.carrierName());d.setPickupMethod(input.pickupMethod());d.setLoadingType(input.loadingType());
        d.setVehicleType(input.vehicleType());d.setVehicleSize(input.vehicleSize());d.setAppointmentAccount(input.appointmentAccount());d.setSellerName(input.sellerName());d.setRemark(input.remark());
        if(context.resources()!=null){if(context.resources().vehicle()!=null)d.setVehiclePlate(context.resources().vehicle().plate());
@@ -14,7 +14,7 @@ import org.springframework.web.bind.annotation.*;
@RequestMapping("/api/platform/v1/last-leg/dispatches")
 public class DispatchAggregateController {
    private final DispatchAggregateService service;
-    @jakarta.annotation.Resource private com.baiyue.lastleg.dispatch.service.DispatchLoadingDepartureService loadingDeparture;
+    @jakarta.annotation.Resource private com.baiyue.lastleg.dispatch.service.DispatchDepartureService departure;

    /** 注入本域应用服务。 */
    public DispatchAggregateController(DispatchAggregateService service) { this.service=service; }
@@ -71,21 +71,21 @@ public class DispatchAggregateController {
    public ApiResponse<com.baiyue.lastleg.dispatch.port.DispatchPlanningModels.LoadingPreview> loading(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo) {
        return ApiResponse.success(service.loading(DispatchActorFactory.platform(user),dispatchNo));
    }
-    /** 显式确认装车后自动准备派送并发车，原请求恢复最终派送中结果。 */
+    /** 显式确认装车，不复用最后扫码或实际发车操作。 */
    @PostMapping("/{dispatchNo}/loading-complete")
    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:loading-complete')")
    public ApiResponse<CommandResult> loadingComplete(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@RequestBody DispatchCommands.LoadingComplete request) {
-        return ApiResponse.success(loadingDeparture.complete(DispatchActorFactory.platform(user),dispatchNo,request));
+        return ApiResponse.success(service.loadingComplete(DispatchActorFactory.platform(user),dispatchNo,request));
    }
-    /** 派送异常登记不触发签收或退货入库。 */
-    @PostMapping("/{dispatchNo}/exceptions")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<CommandResult> markException(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@RequestBody DispatchCommands.MarkException request) {
-        return ApiResponse.success(service.markException(DispatchActorFactory.platform(user),dispatchNo,request));
+    /** 与PDA共用实际发车服务和公共版本，未完整安排派送不能发车。 */
+    @PostMapping("/{dispatchNo}/depart")
+    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:depart')")
+    public ApiResponse<CommandResult> depart(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@RequestBody DispatchCommands.Depart request) {
+        return ApiResponse.success(departure.depart(DispatchActorFactory.platform(user),dispatchNo,request));
    }
-    /** 本车证据先上传；维护和当前待审权限分别由服务端核验，引用随对应命令保存。 */
+    /** 本车证据先上传，主单引用随后走版本化编辑。 */
    @PostMapping(value="/{dispatchNo}/evidence/{kind}",consumes=org.springframework.http.MediaType.MULTIPART_FORM_DATA_VALUE)
-    @PreAuthorize("hasAnyAuthority('platform:overseas-warehouse:dispatch:edit','platform:fleet:trip:dispatch-review','platform:fleet:trip:loading-review')")
+    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
    public ApiResponse<com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.File> uploadEvidence(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,
        @PathVariable com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind kind,@RequestPart("file")org.springframework.web.multipart.MultipartFile file) {
        return ApiResponse.success(service.uploadEvidence(DispatchActorFactory.platform(user),dispatchNo,kind,file));
@@ -1,60 +0,0 @@
-package com.baiyue.lastleg.dispatch.controller;
-
-import com.baiyue.common.core.api.ApiResponse;
-import com.baiyue.common.security.AuthenticatedUser;
-import com.baiyue.lastleg.dispatch.controller.DispatchActorFactory;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort.*;
-import com.baiyue.lastleg.dispatch.service.DispatchLoadingDocumentService;
-import jakarta.validation.Valid;
-import jakarta.validation.constraints.*;
-import org.springframework.http.*;
-import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.security.core.annotation.AuthenticationPrincipal;
-import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-
-/** 平台排车装车资料入口，与另一端共用五框和自动派送门禁。 */
-@RestController
-@Validated
-@RequestMapping("/api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-documents")
-public class DispatchLoadingDocumentController {
-    private final DispatchLoadingDocumentService service;
-    /** Controller只负责会话与输入映射，所有资料和状态规则归服务。 */
-    public DispatchLoadingDocumentController(DispatchLoadingDocumentService service){this.service=service;}
-    /** 读取本车已保存照片，不以设备缓存作为上传事实。 */
-    @GetMapping
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ApiResponse<Documents> get(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo) {
-        return ApiResponse.success(service.get(DispatchActorFactory.platform(user),dispatchNo));
-    }
-    /** 上传先记录原请求，成功回执后再保存本车槽位引用。 */
-    @PostMapping(value="/{slot}/uploads",consumes=MediaType.MULTIPART_FORM_DATA_VALUE)
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<Photo> upload(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable Slot slot,
-        @RequestParam @Size(min=8,max=128) String idempotencyKey,@RequestPart("file") MultipartFile file) {
-        return ApiResponse.success(service.upload(DispatchActorFactory.platform(user),dispatchNo,slot,idempotencyKey,file));
-    }
-    /** 最后一框保存成功时自动进入派送中，不新增人工发车按钮。 */
-    @PutMapping("/{slot}")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<Documents> bind(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,
-        @PathVariable Slot slot,@Valid @RequestBody BindPhoto request) {
-        return ApiResponse.success(service.bind(DispatchActorFactory.platform(user),dispatchNo,slot,request));
-    }
-    /** 原上传仅允许当前有权限的原操作者恢复。 */
-    @GetMapping("/uploads/{idempotencyKey}")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<Photo> recover(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable String idempotencyKey) {
-        return ApiResponse.success(service.recover(DispatchActorFactory.platform(user),dispatchNo,idempotencyKey));
-    }
-    /** 每次预览核对本车当前绑定，文件不得跨车跨仓读取。 */
-    @GetMapping("/{slot}/files/{fileId}/content")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ResponseEntity<byte[]> content(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable Slot slot,@PathVariable @Positive long fileId) {
-        var value=service.content(DispatchActorFactory.platform(user),dispatchNo,slot,fileId);
-        return ResponseEntity.ok().cacheControl(CacheControl.noStore()).contentType(MediaType.parseMediaType(value.photo().contentType()))
-            .header("X-Content-Type-Options","nosniff").body(value.content());
-    }
-}
-
@@ -26,7 +26,7 @@ public class SmartDispatchController {
    /** 读取实际候选，不在草稿域复制来源筛选逻辑。 */
    @GetMapping("/candidates")
    @PreAuthorize("hasAuthority('"+OverseasPermissions.DISPATCH_LIST+"')")
-    public ApiResponse<CandidateList> candidates(@AuthenticationPrincipal AuthenticatedUser user,@RequestParam(required=false) String warehouseId,
+    public ApiResponse<CandidateList> candidates(@AuthenticationPrincipal AuthenticatedUser user,@RequestParam String warehouseId,
        @RequestParam(required=false)List<Long> planIds,@RequestParam(required=false)String orderNo,
        @RequestParam(required=false)String destinationWarehouseCode,@RequestParam(required=false)String sourceStage,@RequestParam(required=false)String draftToken,
        @RequestParam(defaultValue="1")int page,@RequestParam(defaultValue="20")int size,@RequestParam(defaultValue="ALL")String warehouseTab) {
@@ -24,7 +24,6 @@ public class DispatchAggregate {
    private String dispatchReviewJson;
    private String loadingReviewJson;
    private String resourcesJson;
-    private String exceptionsJson;
    private String vehiclePlate;
    private String route;
    private LocalDateTime plannedDepartureAt;
@@ -2,9 +2,9 @@ package com.baiyue.lastleg.dispatch.gateway;

 import org.springframework.web.multipart.MultipartFile;

-/** 车辆、司机及审核补充证据属于本张整车，不能借司机主档或客户文件授权。 */
+/** 临时车辆和司机证据属于本张整车，不能借司机主档或客户文件授权。 */
 public interface DispatchEvidenceGateway {
-    enum Kind { VEHICLE, DRIVER, DRIVER_PHOTO, EXCEPTION }
+    enum Kind { VEHICLE, DRIVER }
    record File(Long fileId,String fileName,String contentType,long sizeBytes) { }
    /** 上传只写本车、本类证据。 */
    File upload(long dispatchId,Kind kind,String operator,MultipartFile file);
@@ -29,7 +29,7 @@ public class HttpDispatchEvidenceGateway implements DispatchEvidenceGateway {
    private static String type(Kind kind) { return "OVERSEAS_DISPATCH_"+Objects.requireNonNull(kind).name()+"_EVIDENCE"; }
    /** 本车证据上传完成后仍以File返回元数据核对复合归属。 */
    @Override public File upload(long dispatch,Kind kind,String operator,MultipartFile file) {
-        if(file==null || file.isEmpty() || file.getSize()>MAX || !supportedType(kind,file.getContentType()))throw invalid();
+        if(file==null || file.isEmpty() || file.getSize()>MAX || !TYPES.contains(Objects.toString(file.getContentType(),"")))throw invalid();
        var body=new MultipartBodyBuilder();
        try { body.part("file",new ByteArrayResource(file.getBytes()) {
            /** 保留用户文件名供审阅，不把路径当业务事实。 */
@@ -80,13 +80,9 @@ public class HttpDispatchEvidenceGateway implements DispatchEvidenceGateway {
        var value=envelope.data();
        if(!Objects.equals(value.tenantId(),0L) || !type(kind).equals(value.businessType()) || !Long.toString(dispatch).equals(value.businessId())
            || value.fileId()==null || value.fileId()<=0 || id!=null&&!id.equals(value.fileId()) || value.fileName()==null || value.fileName().isBlank()
-            || !supportedType(kind,value.contentType()) || value.sizeBytes()==null || value.sizeBytes()<=0 || value.sizeBytes()>MAX)throw invalid();
+            || !TYPES.contains(Objects.toString(value.contentType(),"")) || value.sizeBytes()==null || value.sizeBytes()<=0 || value.sizeBytes()>MAX)throw invalid();
        return new File(value.fileId(),value.fileName(),value.contentType(),value.sizeBytes());
    }
-    /** 司机本人照片与异常证据只接受图片；车辆和驾驶证沿现有PDF/图片证据规则。 */
-    private static boolean supportedType(Kind kind,String contentType) {
-        return TYPES.contains(Objects.toString(contentType,"")) && ((kind!=Kind.DRIVER_PHOTO && kind!=Kind.EXCEPTION) || !"application/pdf".equals(contentType));
-    }
    /** 无效证据不能作为已核实资料。 */
    private static ResponseStatusException invalid(){return new ResponseStatusException(HttpStatus.BAD_REQUEST,"证据须为本车有效PDF、JPG或PNG，最大10MiB");}
    /** File明确拒绝归属或文件格式属于业务错误，不能伪装成服务不可用。 */
@@ -26,9 +26,6 @@ public interface DispatchAggregateMapper {
    String CURRENT_FILTER = """
        <if test='q.status != "ALL"'> AND d.status=#{q.status}</if>
        <if test='q.stage != null'> AND d.stage=#{q.stage}</if>
-        <if test='q.section == "VEHICLE_INFO"'> AND d.stage='BEFORE_LOADING' AND d.review_state IN ('DRAFT','DISPATCH_REJECTED','LOADING_REJECTED')</if>
-        <if test='q.section == "DISPATCH_REVIEW"'> AND d.stage='BEFORE_LOADING' AND d.review_state='DISPATCH_PENDING'</if>
-        <if test='q.section == "LOADING_REVIEW"'> AND d.stage='BEFORE_LOADING' AND d.review_state='LOADING_PENDING'</if>
        <if test='q.reviewStatus != null and q.section == "DISPATCH_REVIEW"'> AND (
        """ + REVIEW_DISPATCH + ")=#{q.reviewStatus}</if>"
        + "<if test='q.reviewStatus != null and q.section == \"LOADING_REVIEW\"'> AND (" + REVIEW_LOADING + ")=#{q.reviewStatus}</if>";
@@ -79,26 +76,25 @@ public interface DispatchAggregateMapper {
    @Update("""
        UPDATE ll_dispatch_order SET cargo_revision=cargo_revision+1,cargo_hash=#{hash},item_count=#{items},
          pallet_count=#{pallets},package_count=#{packages},route=#{route},review_state='DRAFT',
-          review_basis_hash=NULL,dispatch_review_json=#{dispatchReview},loading_review_json=#{loadingReview},
+          review_basis_hash=NULL,dispatch_review_json=#{pending},loading_review_json=#{pending},
          record_version=record_version+1,updated_at=#{at}
        WHERE id=#{id} AND record_version=#{version} AND status='ACTIVE' AND stage='BEFORE_LOADING'
          AND picked_package_count=0 AND shipped_package_count=0
        """)
    int changeCargo(@Param("id") long id, @Param("version") long version, @Param("hash") String hash,
                    @Param("items") int items, @Param("pallets") int pallets, @Param("packages") int packages,
-                    @Param("route") String route, @Param("dispatchReview") String dispatchReview, @Param("loadingReview") String loadingReview,
-                    @Param("at") java.time.LocalDateTime at);
+                    @Param("route") String route, @Param("pending") String pending, @Param("at") java.time.LocalDateTime at);

    /** 父锁内按公共版本保存状态及审核依据，显式清空旧依据而不依赖实体非空更新策略。 */
    @Update("""
        UPDATE ll_dispatch_order SET status=#{r.status},stage=#{r.stage},record_version=#{r.recordVersion},
          review_state=#{r.reviewState},review_round=#{r.reviewRound},review_basis_hash=#{r.reviewBasisHash},
          dispatch_review_json=#{r.dispatchReviewJson},loading_review_json=#{r.loadingReviewJson},
-          exceptions_json=#{r.exceptionsJson},cargo_hash=#{r.cargoHash},cargo_revision=#{r.cargoRevision},resources_json=#{r.resourcesJson},vehicle_plate=#{r.vehiclePlate},planned_departure_at=#{r.plannedDepartureAt},
+          cargo_hash=#{r.cargoHash},cargo_revision=#{r.cargoRevision},resources_json=#{r.resourcesJson},vehicle_plate=#{r.vehiclePlate},planned_departure_at=#{r.plannedDepartureAt},
          estimated_arrival_at=#{r.estimatedArrivalAt},remark=#{r.remark},loading_completed_at=#{r.loadingCompletedAt},
          loading_completion_hash=#{r.loadingCompletionHash},loading_confirmation_json=#{r.loadingConfirmationJson},arrangement_key=#{r.arrangementKey},
          arrangement_business_hash=#{r.arrangementBusinessHash},departed_at=#{r.departedAt},
-          delivery_completed_at=#{r.deliveryCompletedAt},package_count=#{r.packageCount},pallet_count=#{r.palletCount},picked_package_count=#{r.pickedPackageCount},
+          delivery_completed_at=#{r.deliveryCompletedAt},picked_package_count=#{r.pickedPackageCount},
          shipped_package_count=#{r.shippedPackageCount},updated_at=#{r.updatedAt}
        WHERE id=#{r.id} AND record_version=#{version}
        """)
@@ -50,8 +50,7 @@ public interface DispatchCandidatePageMapper {
        }
        /** 仓库页签也是服务端筛选，分页后不能再用本地筛选伪装完整结果。 */
        private static String filtered(boolean count) {
-            return " FROM ("+rows(count)+") candidates WHERE 1=1"
-                +"<if test='query.warehouseId != null'> AND overseasWarehouseId=#{query.warehouseId}</if>"
+            return " FROM ("+rows(count)+") candidates WHERE overseasWarehouseId=#{query.warehouseId}"
                +"<if test='query.destinationWarehouseCode != null'> AND fbaWarehouseCode=#{query.destinationWarehouseCode}</if>"
                +"<if test=\"query.warehouseTab == 'LAX'\"> AND LOWER(CONCAT(COALESCE(overseasWarehouseCode,''),' ',COALESCE(overseasWarehouseName,''))) REGEXP 'lax|洛杉矶|los angeles'</if>"
                +"<if test=\"query.warehouseTab == 'NYC'\"> AND LOWER(CONCAT(COALESCE(overseasWarehouseCode,''),' ',COALESCE(overseasWarehouseName,''))) REGEXP 'nyc|jfk|(^|[^a-z])ny([^a-z]|$)|纽约|new[ -]?york'</if>";
@@ -93,11 +93,6 @@ public interface DispatchSourceMapper {
    @Select("SELECT p.id FROM ll_inbound_plan_pallet p JOIN ll_inbound_plan ip ON ip.id=p.plan_id WHERE p.id=#{id} AND ip.customer_id=#{customer} FOR UPDATE")
    Long lockPlanPallet(@Param("customer") String customer, @Param("id") Long id);

-    /** 原计划完成实收后才能把预排估算替换为实际整托数量，避免收货中提前锁定半托。 */
-    @Select("SELECT COUNT(*) FROM ll_inbound_plan_pallet p JOIN ll_inbound_plan ip ON ip.id=p.plan_id AND ip.customer_id=p.customer_id "
-        + "WHERE p.id=#{id} AND p.customer_id=#{customer} AND ip.status IN ('COMPLETED','PENDING_RECONCILIATION')")
-    int receivedPlanCompleted(@Param("customer") String customer,@Param("id") Long id);
-
    /** 退回来源仍使用本票实际实收，不借普通入仓别名。 */
    @Select("SELECT id FROM ll_return_stock_receipt WHERE id=#{id} AND customer_id=#{customer} FOR UPDATE")
    Long lockReturn(@Param("customer") String customer, @Param("id") Long id);
@@ -20,7 +20,7 @@ public class DispatchPdaController {
    @Resource private DispatchPdaQueryService queries;
    @Resource private DispatchPickingService picking;
    @Resource private DispatchAggregateService workflow;
-    @Resource private DispatchLoadingDepartureService loadingDeparture;
+    @Resource private DispatchDepartureService departure;

    /** 批量读取当前绑定仓的整车作业。 */
    @GetMapping
@@ -36,13 +36,6 @@ public class DispatchPdaController {
        return ApiResponse.success(queries.task(DispatchActorFactory.pda(user),dispatchNo));
    }

-    /** 理货审核与后台共用同一轮次、版本和幂等账本，驳回须填写原因。 */
-    @PostMapping("/{dispatchNo}/loading-review")
-    public ApiResponse<DispatchContracts.CommandResult> loadingReview(@AuthenticationPrincipal AuthenticatedUser user,
-        @PathVariable String dispatchNo,@Valid @RequestBody DispatchCommands.ReviewCommand request) {
-        return ApiResponse.success(workflow.review(DispatchActorFactory.pda(user),dispatchNo,true,request));
-    }
-
    /** 共用公共版本和全局请求键执行一次真实库存扫码。 */
    @PostMapping("/{dispatchNo}/items/{itemId}/pick")
    public ApiResponse<DispatchContracts.CommandResult> pick(@AuthenticationPrincipal AuthenticatedUser user,
@@ -57,10 +50,18 @@ public class DispatchPdaController {
        return ApiResponse.success(workflow.loading(DispatchActorFactory.pda(user),dispatchNo));
    }

-    /** 真实扫码核平后确认装车进入装车后，两端共用同一命令并等待五张装车照片。 */
+    /** 最后一次扫码不代替显式装车确认，双方使用同一正式命令。 */
    @PostMapping("/{dispatchNo}/loading-complete")
    public ApiResponse<DispatchContracts.CommandResult> loadingComplete(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@RequestBody DispatchCommands.LoadingComplete request) {
-        return ApiResponse.success(loadingDeparture.complete(DispatchActorFactory.pda(user),dispatchNo,request));
+        return ApiResponse.success(workflow.loadingComplete(DispatchActorFactory.pda(user),dispatchNo,request));
+    }
+
+    /** 与平台共用实际发车服务，不执行第二次库存扣减。 */
+    @PostMapping("/{dispatchNo}/depart")
+    public ApiResponse<DispatchContracts.CommandResult> depart(@AuthenticationPrincipal AuthenticatedUser user,
+                                                              @PathVariable String dispatchNo,
+                                                              @Valid @RequestBody DispatchCommands.Depart request) {
+        return ApiResponse.success(departure.depart(DispatchActorFactory.pda(user),dispatchNo,request));
    }

    /** 原动作权限与绑定仓同时核对未知结果，不按单客户任务恢复。 */
@@ -1,60 +0,0 @@
-package com.baiyue.lastleg.dispatch.pda.controller;
-
-import com.baiyue.common.core.api.ApiResponse;
-import com.baiyue.common.security.AuthenticatedUser;
-import com.baiyue.lastleg.dispatch.controller.DispatchActorFactory;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort.*;
-import com.baiyue.lastleg.dispatch.service.DispatchLoadingDocumentService;
-import jakarta.validation.Valid;
-import jakarta.validation.constraints.*;
-import org.springframework.http.*;
-import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.security.core.annotation.AuthenticationPrincipal;
-import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-
-/** 绑定仓PDA装车资料入口，与另一端共用五框和自动派送门禁。 */
-@RestController
-@Validated
-@RequestMapping("/api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-documents")
-public class PdaDispatchLoadingDocumentController {
-    private final DispatchLoadingDocumentService service;
-    /** Controller只负责会话与输入映射，所有资料和状态规则归服务。 */
-    public PdaDispatchLoadingDocumentController(DispatchLoadingDocumentService service){this.service=service;}
-    /** 读取本车已保存照片，不以设备缓存作为上传事实。 */
-    @GetMapping
-    @PreAuthorize("hasAuthority('lastleg:pda:operate') and hasAuthority('ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR')")
-    public ApiResponse<Documents> get(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo) {
-        return ApiResponse.success(service.get(DispatchActorFactory.pda(user),dispatchNo));
-    }
-    /** 上传先记录原请求，成功回执后再保存本车槽位引用。 */
-    @PostMapping(value="/{slot}/uploads",consumes=MediaType.MULTIPART_FORM_DATA_VALUE)
-    @PreAuthorize("hasAuthority('lastleg:pda:operate') and hasAuthority('ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR')")
-    public ApiResponse<Photo> upload(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable Slot slot,
-        @RequestParam @Size(min=8,max=128) String idempotencyKey,@RequestPart("file") MultipartFile file) {
-        return ApiResponse.success(service.upload(DispatchActorFactory.pda(user),dispatchNo,slot,idempotencyKey,file));
-    }
-    /** 最后一框保存成功时自动进入派送中，不新增人工发车按钮。 */
-    @PutMapping("/{slot}")
-    @PreAuthorize("hasAuthority('lastleg:pda:operate') and hasAuthority('ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR')")
-    public ApiResponse<Documents> bind(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,
-        @PathVariable Slot slot,@Valid @RequestBody BindPhoto request) {
-        return ApiResponse.success(service.bind(DispatchActorFactory.pda(user),dispatchNo,slot,request));
-    }
-    /** 原上传仅允许当前有权限的原操作者恢复。 */
-    @GetMapping("/uploads/{idempotencyKey}")
-    @PreAuthorize("hasAuthority('lastleg:pda:operate') and hasAuthority('ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR')")
-    public ApiResponse<Photo> recover(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable String idempotencyKey) {
-        return ApiResponse.success(service.recover(DispatchActorFactory.pda(user),dispatchNo,idempotencyKey));
-    }
-    /** 每次预览核对本车当前绑定，文件不得跨车跨仓读取。 */
-    @GetMapping("/{slot}/files/{fileId}/content")
-    @PreAuthorize("hasAuthority('lastleg:pda:operate') and hasAuthority('ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR')")
-    public ResponseEntity<byte[]> content(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable Slot slot,@PathVariable @Positive long fileId) {
-        var value=service.content(DispatchActorFactory.pda(user),dispatchNo,slot,fileId);
-        return ResponseEntity.ok().cacheControl(CacheControl.noStore()).contentType(MediaType.parseMediaType(value.photo().contentType()))
-            .header("X-Content-Type-Options","nosniff").body(value.content());
-    }
-}
-
@@ -14,7 +14,7 @@ public interface DispatchWholePdaReadMapper {
    /** 精确单号或有界阶段列表均先在SQL限制绑定仓。 */
    @Select("<script>SELECT * FROM ll_dispatch_order WHERE overseas_warehouse_id=#{warehouse} AND status='ACTIVE' "
        +"<choose><when test='number != null'>AND dispatch_no=#{number} </when><when test='stage != null'>AND stage=#{stage} </when>"
-        +"<otherwise>AND (stage IN('LOADING','AFTER_LOADING','DELIVERING') OR (stage='BEFORE_LOADING' AND review_state='LOADING_PENDING')) </otherwise></choose>ORDER BY updated_at DESC,id DESC LIMIT 201</script>")
+        +"<otherwise>AND stage IN('LOADING','AFTER_LOADING','DELIVERING') </otherwise></choose>ORDER BY updated_at DESC,id DESC LIMIT 201</script>")
    List<DispatchAggregate> headers(@Param("warehouse")String warehouse,@Param("number")String number,@Param("stage")String stage);
    String ROOTS="<foreach collection='ids' item='id' open='(' separator=',' close=')'>#{id}</foreach>";
    /** 一次读取选中整车所有真实客户货物。 */
@@ -24,6 +24,9 @@ public final class DispatchApi {
    public static final String LOADING_REVIEW = "/{dispatchNo}/loading-review";
    public static final String RETURN_TO_REVIEW = "/{dispatchNo}/return-to-review";
    public static final String LOADING_COMPLETE = "/{dispatchNo}/loading-complete";
+    public static final String DEPART = "/{dispatchNo}/depart";
+    public static final String DELIVERY_ARRANGEMENT = "/{dispatchNo}/delivery-arrangement";
+    public static final String TRANSFER_DELIVERY = "/{dispatchNo}/transfer-delivery";

    /** 端点容器不允许实例化。 */
    private DispatchApi() { }
@@ -49,9 +49,9 @@ public final class DispatchCommands {
    }

    public record ReviewCommand(Long recordVersion, String idempotencyKey, Decision decision,
-                                 String reason, ReviewAttachments attachments) {
-        /** 两级审核都执行相同的必填版本约束，未传附件表示没有本次补充。 */
-        public ReviewCommand { recordVersion = requireVersion(recordVersion); attachments = attachments == null ? ReviewAttachments.empty() : attachments; }
+                                 String reason) {
+        /** 两级审核都执行相同的必填版本约束。 */
+        public ReviewCommand { recordVersion = requireVersion(recordVersion); }
    }

    /** 只有零真实扫码时可退回，保留原单号与审核轮次历史。 */
@@ -66,20 +66,13 @@ public final class DispatchCommands {
        public Pick { recordVersion = requireVersion(recordVersion); }
    }

-    /** 按服务端已核平的扫码托盘确认装车，不要求现场重复测量或补填箱数。 */
+    /** measurements仅为真实装载测量，禁止携带替代PDA拣货的箱数。 */
    public record LoadingComplete(Long recordVersion, String idempotencyKey, String manifestHash,
-                                    String remark) {
+                                    List<LoadingMeasurement> measurements, String remark) {
        /** 后台与PDA共用必填版本约束。 */
        public LoadingComplete { recordVersion = requireVersion(recordVersion); }
    }

-    /** 派送异常仅登记事实，不改变派送、签收或库存。 */
-    public record MarkException(Long recordVersion, String idempotencyKey, ExceptionType exceptionType,
-                                ReturnDirection returnDirection, String description, List<Long> imageFileIds) {
-        /** 必填版本用于阻止过期页面覆盖当前排车。 */
-        public MarkException { recordVersion = requireVersion(recordVersion); }
-    }
-
    public record Depart(Long recordVersion, String idempotencyKey, String remark) {
        /** 实际发车不得接受缺省版本。 */
        public Depart { recordVersion = requireVersion(recordVersion); }
@@ -25,15 +25,7 @@ public final class DispatchContracts {

    /** 临时资源证据只归本趟，不能据此自动建车辆或司机主档。 */
    public record DriverEvidence(String licenseNo, LocalDate licenseExpiresOn,
-                                 List<Long> fileIds, Instant expectedTaskEndAt, List<Long> photoFileIds,
-                                 @com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL) Long masterLicenseFileId) {
-        /** 普通派送继续按既有主档证照语义构造，取货显式记录主档引用来源。 */
-        public DriverEvidence(String licenseNo, LocalDate licenseExpiresOn, List<Long> fileIds, Instant expectedTaskEndAt, List<Long> photoFileIds) {
-            this(licenseNo, licenseExpiresOn, fileIds, expectedTaskEndAt, photoFileIds, null);
-        }
-        /** 司机照片独立于驾驶证，缺省为空且引用须有界、有效、不重复。 */
-        public DriverEvidence { photoFileIds = ReviewAttachments.checked(photoFileIds); }
-    }
+                                 List<Long> fileIds, Instant expectedTaskEndAt) { }

    public record VehicleSnapshot(ResourceMode mode, Long vehicleId, String plate,
                                  String carrierName, String vehicleStatus, Capacity capacity,
@@ -49,27 +41,7 @@ public final class DispatchContracts {
                               String contactName, String contactPhone) { }

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

    public record Reviews(Review dispatchReview, Review loadingReview) { }

@@ -7,9 +7,6 @@ import static com.baiyue.lastleg.dispatch.port.DispatchDeliveryModels.*;

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

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

    public record DispatchInfo(String route, Instant plannedDepartureAt, Instant departedAt,
                                 Instant estimatedArrivalAt, List<FbaAppointment> fbaAppointments,
-                                 List<BatchReference> appointmentBatches, List<ExceptionRecord> exceptions) { }
-
-    /** 排车级异常记录；退货去向只描述安排，不产生退货入库事实。 */
-    public record ExceptionRecord(ExceptionType exceptionType, ReturnDirection returnDirection,
-                                  String description, List<Long> imageFileIds, Instant occurredAt) { }
+                                 List<BatchReference> appointmentBatches) { }

    public record Documents(String dispatchNo, List<DispatchDeliveryModels.OutboundReference> outbounds,
                              List<DispatchDeliveryModels.DeliveryReference> deliveries,
@@ -67,7 +63,7 @@ public final class DispatchViews {
                           List<OrderDetail> orderDetails) { }

    public record PdaTask(String taskNo, String dispatchNo, String warehouseId, Status status,
-                           Stage stage, long recordVersion, Reviews reviews, Resources resources, Counts counts,
+                           Stage stage, long recordVersion, Reviews reviews, Counts counts,
                           boolean pickingReconciled, List<PdaItem> items, Map<Action, Gate> actions) { }

    public record PdaItem(Long dispatchItemId, String customerId, String customerName, String palletNo,
@@ -46,8 +46,8 @@ public class DispatchAggregateRepository {
    public int removeItem(long itemId) {return items.deleteById(itemId);}
    /** 原子更新货量并作废旧审核依据。 */
    public int changeCargo(long id, long version, String hash, int itemCount, int pallets, int packages,
-                           String route, String dispatchReview, String loadingReview, LocalDateTime at) {
-        return mapper.changeCargo(id, version, hash, itemCount, pallets, packages, route, dispatchReview, loadingReview, at);
+                           String route, String pending, LocalDateTime at) {
+        return mapper.changeCargo(id, version, hash, itemCount, pallets, packages, route, pending, at);
    }
    /** 追加不可变业务快照。 */
    public int history(long id, DispatchAggregate row, String action, String operator, String reason, String snapshot, LocalDateTime at) {
@@ -74,8 +74,6 @@ public class DispatchSourceRepository {
    public Long lockOrder(String customer, Long id) { return source.lockOrder(customer,id); }
    /** 锁定真实计划托盘根。 */
    public Long lockPlan(String customer, Long id) { return source.lockPlanPallet(customer,id); }
-    /** 只读核对原计划已经结束实际收货。 */
-    public boolean receivedPlanCompleted(String customer,Long id){return source.receivedPlanCompleted(customer,id)==1;}
    /** 锁定实际退回收据根。 */
    public Long lockReturn(String customer, Long id) { return source.lockReturn(customer,id); }
    /** 真实库存数量及版本。 */
@@ -51,7 +51,6 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
    @jakarta.annotation.Resource private com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway evidence;
    @jakarta.annotation.Resource private com.baiyue.lastleg.dispatch.repository.DispatchExecutionRepository executionReads;
    @jakarta.annotation.Resource private OwnedBusinessOwnershipCapture ownedBusinessOwnership;
-    @jakarta.annotation.Resource private com.baiyue.lastleg.dispatch.transport.TransportTaskService transportTasks;

    /** 领域编排只访问Repository和提供者应用入口。 */
    public DispatchAggregateService(DispatchAggregateRepository repository, DispatchSourceRepository sources,
@@ -147,8 +146,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
    @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
    public DispatchPlanningModels.CandidateList candidates(Actor actor,DispatchPlanningModels.CandidateQuery query) {
        requirePlatform(actor);
-        // 未指定起运仓时按区域浏览；写入草稿仍由来源确定唯一真实起运仓。
-        if(query==null || query.warehouseId()!=null && !query.warehouseId().matches("[1-9][0-9]*")) throw bad("起运仓筛选无效");
+        if(query==null || query.warehouseId()==null || !query.warehouseId().matches("[1-9][0-9]*")) throw bad("请选择真实海外起运仓");
        if(query.planIds()!=null && (query.planIds().size()>500 || query.planIds().stream().anyMatch(id->id==null || id<=0))) throw bad("计划筛选不合法");
        if(query.page()<1 || query.size()<1 || query.size()>50 || !Set.of("ALL","LAX","NYC").contains(Objects.toString(query.warehouseTab(),"")))throw bad("候选分页或仓库页签不合法");
        var normalized=new DispatchPlanningModels.CandidateQuery(query.warehouseId(),query.planIds(),trim(query.orderNo()),
@@ -237,18 +235,10 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        return saveCommand(row,actor,identity,request.reason());
    }

-    /** 上传只返回本车证据；待审按当前审核权限授权，客服阶段按维护权限授权。 */
+    /** 上传不修改主单引用；返回本车文件ID后由公共版本编辑命令保存选择。 */
    public com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.File uploadEvidence(Actor actor,String number,
        com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind kind,org.springframework.web.multipart.MultipartFile file) {
-        requirePlatform(actor);var row=required(actor,number,false);
-        if(kind==com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.EXCEPTION) {
-            requireExceptionAllowed(actor,row,row.getRecordVersion());
-            return evidence.upload(row.getId(),kind,actor.operatorId(),file);
-        }
-        requireEditing(row,row.getRecordVersion());
-        Action permission = ReviewState.DISPATCH_PENDING.name().equals(row.getReviewState()) ? Action.DISPATCH_REVIEW
-            : ReviewState.LOADING_PENDING.name().equals(row.getReviewState()) ? Action.LOADING_REVIEW : Action.EDIT;
-        if(!hasPermission(actor,permission))throw new BizException(ResultCode.FORBIDDEN,"无当前阶段附件上传权限");
+        requirePlatform(actor);var row=required(actor,number,false);requireEditing(row,row.getRecordVersion());
        return evidence.upload(row.getId(),kind,actor.operatorId(),file);
    }
    /** 列表权限含详情只读；仅冻结MASTER证照走司机归属，其余保持本车附件复合归属。 */
@@ -274,8 +264,6 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        var resources=read(row.getResourcesJson(),Resources.class);var driver=resources==null?null:resources.driver();
        if(driver==null || driver.mode()!=ResourceMode.MASTER || driver.evidence()==null || driver.evidence().fileIds()==null
            || !driver.evidence().fileIds().contains(fileId))return null;
-        // 取货允许补传本车驾驶证，仅明确冻结的主档引用才走司机归属。
-        if("PICKUP".equals(row.getTaskType()) && !Objects.equals(driver.evidence().masterLicenseFileId(),fileId))return null;
        if(driver.driverId()==null || driver.driverId()<=0)throw bad("排车冻结司机档案身份无效，不能读取证照");
        return driver.driverId();
    }
@@ -307,9 +295,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        row.setStatus(Status.ACTIVE.name()); row.setStage(Stage.BEFORE_LOADING.name()); row.setRecordVersion(0L);
        row.setCargoRevision(0L); row.setCargoHash(hashes.source(List.of())); row.setReviewState(ReviewState.DRAFT.name()); row.setReviewRound(0L);
        row.setDispatchReviewJson(write(pending(0))); row.setLoadingReviewJson(write(pending(0)));
-        var photos=request.driver()==null || request.driver().evidence()==null?List.<Long>of():request.driver().evidence().photoFileIds();
-        if(!photos.isEmpty())verifyEvidence(id,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER_PHOTO,photos);
-        Resources resources=resources(shell,photos); row.setResourcesJson(write(resources));
+        Resources resources=resources(shell); row.setResourcesJson(write(resources));
        row.setVehiclePlate(resources.vehicle()==null ? null : resources.vehicle().plate());
        row.setPlannedDepartureAt(utc(request.plannedDepartureAt())); row.setEstimatedArrivalAt(utc(request.estimatedArrivalAt()));
        row.setItemCount(0); row.setPalletCount(0); row.setPackageCount(0); row.setPickedPackageCount(0); row.setShippedPackageCount(0);
@@ -387,11 +373,8 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        var original=commands.replay(actor,number,identity);if(original.isPresent())return original.get();
        requireEditing(row,request.recordVersion());
        String before=basis(row);
-        // 本趟司机照片随资源维护保存，逐个核对本车及照片类别。
-        var photos=request.driver()==null || request.driver().evidence()==null?List.<Long>of():request.driver().evidence().photoFileIds();
-        if(!photos.isEmpty())verifyEvidence(row.getId(),com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER_PHOTO,photos);
        var actual=fleet.dispatchResources(number,fleetVehicle(request.vehicle()),fleetDriver(request.driver()));
-        row.setResourcesJson(write(resources(actual,photos)));row.setVehiclePlate(actual.vehicle()==null?null:actual.vehicle().plate());
+        row.setResourcesJson(write(resources(actual)));row.setVehiclePlate(actual.vehicle()==null?null:actual.vehicle().plate());
        row.setPlannedDepartureAt(utc(request.plannedDepartureAt()));row.setEstimatedArrivalAt(utc(request.estimatedArrivalAt()));row.setRemark(request.remark());
        if(!Objects.equals(before,basis(row)))invalidate(row,"车辆、司机或计划信息已修改");
        fleet.saveDispatchResources(number,actor.operatorId(),actual,request.plannedDepartureAt(),request.remark());
@@ -406,10 +389,10 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        requireEditing(row,request.recordVersion());
        if(!canSubmitReview(row.getReviewState()))throw conflict("当前审核已提交，请刷新核对");
        verifyReviewResources(row);
-        if(n(row.getPackageCount())<=0 || (!"PICKUP".equals(row.getTaskType()) && repository.cargo(row.getId()).isEmpty()))throw bad("空排车不能提交审核");
+        if(n(row.getPackageCount())<=0 || repository.cargo(row.getId()).isEmpty())throw bad("空排车不能提交审核");
        long round=row.getReviewRound()+1;String basis=basis(row);
        row.setReviewRound(round);row.setReviewBasisHash(basis);row.setReviewState(ReviewState.DISPATCH_PENDING.name());
-        row.setDispatchReviewJson(write(new Review(ReviewStatus.PENDING,null,null,null,round,basis,null,null)));
+        row.setDispatchReviewJson(write(new Review(ReviewStatus.PENDING,null,null,null,round,basis,null)));
        row.setLoadingReviewJson(write(pending(round)));
        return saveCommand(row,actor,identity,request.remark());
    }
@@ -417,14 +400,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
    /** 调度与理货审核按同一轮次、同一事实摘要串行执行；理货通过才进入装车。 */
    @Transactional(isolation=Isolation.READ_COMMITTED)
    public CommandResult review(Actor actor,String number,boolean loading,DispatchCommands.ReviewCommand request) {
-        Action action=loading?Action.LOADING_REVIEW:Action.DISPATCH_REVIEW;
-        // PDA仅可处理本绑定仓理货审核，原键重试也先重新核验权限和范围。
-        DispatchAggregate row;
-        if(actor!=null && actor.mode()==ActorMode.PDA) {
-            if(!loading || actor.boundWarehouseId()==null || !hasPermission(actor,action))
-                throw new BizException(ResultCode.FORBIDDEN,"仅当前绑定仓理货员可执行理货审核");
-            lockReviewRoot(actor,number);row=required(actor,number,true);
-        } else row=lockPlatform(actor,number);
+        var row=lockPlatform(actor,number);Action action=loading?Action.LOADING_REVIEW:Action.DISPATCH_REVIEW;
        var identity=identity(actor,number,action,request.recordVersion(),request.idempotencyKey(),request);
        var original=commands.replay(actor,number,identity);if(original.isPresent())return original.get();
        requireEditing(row,request.recordVersion());
@@ -437,21 +413,14 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
            var dispatch=reviews(row).dispatchReview();
            if(dispatch.status()!=ReviewStatus.APPROVED || dispatch.reviewRound()!=row.getReviewRound() || !Objects.equals(dispatch.basisHash(),row.getReviewBasisHash()))throw conflict("调度审核尚未通过或依据已失效");
        }
-        verifyReviewAttachments(row.getId(),request.attachments());
        if(request.decision()==Decision.APPROVED)verifyReviewResources(row);
-        var reviewed=new Review(request.decision()==Decision.APPROVED?ReviewStatus.APPROVED:ReviewStatus.REJECTED,trim(request.reason()),actor.operatorId(),Instant.now().truncatedTo(ChronoUnit.MILLIS),row.getReviewRound(),row.getReviewBasisHash(),null,request.attachments());
+        var reviewed=new Review(request.decision()==Decision.APPROVED?ReviewStatus.APPROVED:ReviewStatus.REJECTED,trim(request.reason()),actor.operatorId(),Instant.now().truncatedTo(ChronoUnit.MILLIS),row.getReviewRound(),row.getReviewBasisHash(),null);
        if(loading) {
            row.setLoadingReviewJson(write(reviewed));row.setReviewState(request.decision()==Decision.APPROVED?ReviewState.APPROVED.name():ReviewState.LOADING_REJECTED.name());
            if(request.decision()==Decision.APPROVED)row.setStage(Stage.LOADING.name());
        } else {
            row.setDispatchReviewJson(write(reviewed));row.setReviewState(request.decision()==Decision.APPROVED?ReviewState.LOADING_PENDING.name():ReviewState.DISPATCH_REJECTED.name());
-            row.setLoadingReviewJson(write(request.decision()==Decision.APPROVED?new Review(ReviewStatus.PENDING,null,null,null,row.getReviewRound(),row.getReviewBasisHash(),null,null):pending(row.getReviewRound())));
-        }
-        if(request.decision()==Decision.REJECTED) {
-            // 任一级驳回均回客服处理，旧调度批准不再作为可继续理货的有效依据。
-            row.setStage(Stage.BEFORE_LOADING.name());row.setReviewBasisHash(null);
-            if(loading)row.setDispatchReviewJson(write(new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,
-                row.getReviewRound(),null,"理货审核驳回，请客服修改后重新提交调度审核",reviews(row).dispatchReview().attachments())));
+            row.setLoadingReviewJson(write(request.decision()==Decision.APPROVED?new Review(ReviewStatus.PENDING,null,null,null,row.getReviewRound(),row.getReviewBasisHash(),null):pending(row.getReviewRound())));
        }
        return saveCommand(row,actor,identity,request.reason());
    }
@@ -535,10 +504,10 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
                if(weight!=null)proof.add(new DispatchPlanningModels.MeasurementEvidence("weightKg","WAREHOUSE_TRANSFER",fact.sourceNo(),instant(fact.observedAt()),weight,true));
                if(volume!=null)proof.add(new DispatchPlanningModels.MeasurementEvidence("volumeCbm","WAREHOUSE_TRANSFER",fact.sourceNo(),instant(fact.observedAt()),volume,true));
            }
-            var absent=new ArrayList<String>();if(weight==null)absent.add("weightKg");if(volume==null)absent.add("volumeCbm");if(index==null)absent.add("deliveryIndex");
+            var absent=new ArrayList<String>();absent.add("palletSpaces");if(weight==null)absent.add("weightKg");if(volume==null)absent.add("volumeCbm");if(index==null)absent.add("deliveryIndex");
            missing.addAll(absent.stream().map(field->Objects.toString(first.getPalletNo(),"未关联托盘")+":"+field).toList());
            pallets.add(new DispatchPlanningModels.LoadingPallet(entry.getKey(),first.getPalletNo(),group.stream().mapToLong(i->n(i.getPackageCount())).sum(),
-                group.stream().mapToLong(i->picked.getOrDefault(i.getId(),0L)).sum(),1,weight,volume,index,List.copyOf(absent),List.copyOf(proof)));
+                group.stream().mapToLong(i->picked.getOrDefault(i.getId(),0L)).sum(),null,weight,volume,index,List.copyOf(absent),List.copyOf(proof)));
        }
        if(items.stream().anyMatch(i->i.getWarehousePalletId()==null))missing.add("存在未关联实托来源");
        String hash=hashes.source(Arrays.asList(context.cargo(),context.resources(),stops,pallets));
@@ -548,7 +517,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
            List.copyOf(pallets),row.getLoadingConfirmationJson()==null?null:read(row.getLoadingConfirmationJson(),ConfirmedLoad.class),gate,List.copyOf(missing));
    }

-    /** 实载确认：扫码核平后保存装载证据并进入装车后，五张装车资料齐全再推进派送。 */
+    /** 最后一次扫码只核平，显式装车完成才保存实载并进入装车后。 */
    @Transactional(isolation=Isolation.READ_COMMITTED)
    public CommandResult loadingComplete(Actor actor,String number,DispatchCommands.LoadingComplete request) {
        required(actor,number,false);fleet.lockDispatchShell(number);var row=required(actor,number,true);
@@ -561,12 +530,16 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        lockExecutionSources(row,items);
        var preview=loading(actor,number);if(!preview.pickingReconciled())throw conflict("逐项真实拣货尚未核平");
        if(!Objects.equals(preview.manifestHash(),request.manifestHash()))throw conflict("真实装载清单已变化，请重新核对");
-        if(preview.pallets().stream().anyMatch(p->p.deliveryIndex()==null))throw conflict("托盘卸货站尚未匹配，请调度核对路线");
-        // 现场仅确认已扫码装车事实；每个实托计一托，已有实测自动留存，未知值不伪造为零。
-        var measurements=preview.pallets().stream().map(p->new LoadingMeasurement(p.warehousePalletId(),1,
-            p.weightKg(),p.volumeCbm(),p.deliveryIndex())).sorted(Comparator.comparing(LoadingMeasurement::warehousePalletId)).toList();
+        if(request.measurements()==null || request.measurements().size()!=preview.pallets().size())throw bad("请确认本车全部实托测量");
+        var supplied=new HashMap<Long,LoadingMeasurement>();
+        for(var m:request.measurements())if(m==null || m.warehousePalletId()==null || supplied.putIfAbsent(m.warehousePalletId(),m)!=null || m.palletSpaces()<=0 || m.weightKg()==null || m.weightKg().signum()<=0 || m.volumeCbm()==null || m.volumeCbm().signum()<=0)throw bad("实托测量必须完整且不得重复");
+        for(var p:preview.pallets()) {
+            var m=supplied.get(p.warehousePalletId());if(m==null || p.deliveryIndex()!=null && p.deliveryIndex()!=m.deliveryIndex()
+                || p.weightKg()!=null && p.weightKg().compareTo(m.weightKg())!=0 || p.volumeCbm()!=null && p.volumeCbm().compareTo(m.volumeCbm())!=0)throw conflict("已知实测或卸货站发生变化，请重新核对");
+        }
        verifyReviewResources(row);var context=context(actor,row);
        var cargo=context.cargo().stream().map(c->new FleetExecutionModels.Cargo(number,c.customerId(),c.dispatchItemId().toString(),c.warehousePalletId().toString(),c.palletNo(),Math.toIntExact(c.packages()),c.destination().key(),"PRIVATE".equals(c.destination().type())?c.destination().address():c.destination().warehouseCode())).toList();
+        var measurements=request.measurements().stream().sorted(Comparator.comparing(LoadingMeasurement::warehousePalletId)).toList();
        fleet.confirmDispatchLoad(number,actor.operatorId(),preview.manifestHash(),cargo,measurements.stream().map(m->new FleetExecutionModels.Measurement(m.warehousePalletId().toString(),m.palletSpaces(),m.weightKg(),m.volumeCbm(),m.deliveryIndex())).toList(),request.remark());
        var at=Instant.now().truncatedTo(ChronoUnit.MILLIS);var confirmed=new ConfirmedLoad(preview.manifestHash(),measurements,actor.operatorId(),at);
        row.setLoadingConfirmationJson(write(confirmed));row.setLoadingCompletionHash(hashes.source(confirmed));row.setLoadingCompletedAt(utc(at));row.setStage(Stage.AFTER_LOADING.name());
@@ -614,12 +587,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
    }

    /** 共同根锁顺序固定，当前阶段资格留给原命令恢复之后。 */
-    private DispatchAggregate lockPlatform(Actor actor,String number) { requirePlatform(actor);lockReviewRoot(actor,number);return required(actor,number,true); }
-    /** 运输取货锁原车次，仓库派送锁其整车资源；统一先父后主单。 */
-    private void lockReviewRoot(Actor actor,String number) {
-        var row=required(actor,number,false);
-        if("PICKUP".equals(row.getTaskType()))transportTasks.transport(number,true);else fleet.lockDispatchShell(number);
-    }
+    private DispatchAggregate lockPlatform(Actor actor,String number) { requirePlatform(actor);fleet.lockDispatchShell(number);return required(actor,number,true); }
    /** 严格请求身份不接收前端摘要或操作者。 */
    private CommandIdentity identity(Actor actor,String no,Action action,long version,String key,Object request) {return new CommandIdentity(action,key,version,hashes.command(actor,action,no,version,request));}
    /** 每次状态变更、历史及不可变命令结果同事务保存。 */
@@ -636,35 +604,16 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
    /** 只包含可影响两级审核的事实，不因备注修改伪造新依据。 */
    private String basis(DispatchAggregate row) {
        var facts=new TreeMap<String,Object>();facts.put("cargoHash",row.getCargoHash());facts.put("resources",read(row.getResourcesJson(),Resources.class));
-        facts.put("plannedDepartureAt",row.getPlannedDepartureAt());facts.put("estimatedArrivalAt",row.getEstimatedArrivalAt());
-        if("PICKUP".equals(row.getTaskType()))facts.put("route",transportTasks.transport(row.getDispatchNo(),false).getStopsJson());
-        else {facts.put("batches",repository.batches(row.getId()));facts.put("route",fleet.dispatchStops(row.getDispatchNo()));}
-        return hashes.source(facts);
+        facts.put("plannedDepartureAt",row.getPlannedDepartureAt());facts.put("estimatedArrivalAt",row.getEstimatedArrivalAt());facts.put("batches",repository.batches(row.getId()));facts.put("route",fleet.dispatchStops(row.getDispatchNo()));return hashes.source(facts);
    }
    /** 作废原因进入两级显式记录，旧审核证据仍保留在不可变历史中。 */
    private void invalidate(DispatchAggregate row,String reason) {
        row.setReviewState(ReviewState.DRAFT.name());row.setReviewBasisHash(null);
-        var invalid=new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,row.getReviewRound(),null,reason,null);
-        var previous=reviews(row);
-        row.setDispatchReviewJson(write(retainRejection(previous.dispatchReview(),invalid)));
-        row.setLoadingReviewJson(write(retainRejection(previous.loadingReview(),invalid)));
+        var invalid=new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,row.getReviewRound(),null,reason);
+        row.setDispatchReviewJson(write(invalid));row.setLoadingReviewJson(write(invalid));
    }
-    /** 客服改资料期间保留本轮驳回原因；下一轮提交统一重置，不复用批准。 */
-    private static Review retainRejection(Review previous,Review invalid) {
-        return previous.status()==ReviewStatus.REJECTED
-            ?new Review(previous.status(),previous.reason(),previous.reviewerId(),previous.reviewedAt(),previous.reviewRound(),null,invalid.invalidatedReason(),previous.attachments())
-            :new Review(invalid.status(),null,null,null,invalid.reviewRound(),null,invalid.invalidatedReason(),previous.attachments());
-    }
-    /** 审核附件逐个验证本车与种类；MASTER档案证照不能冒充本次上传证据。 */
-    private void verifyReviewAttachments(long dispatch,ReviewAttachments attachments) {
-        for(var id:attachments.vehicleFileIds())evidence.metadata(dispatch,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.VEHICLE,id);
-        for(var id:attachments.driverPhotoFileIds())evidence.metadata(dispatch,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER_PHOTO,id);
-        for(var id:attachments.licenseFileIds())evidence.metadata(dispatch,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER,id);
-    }
-
    /** 临时取证、有效期和实际主档资格必须在提交及通过时再次核验。 */
    void verifyReviewResources(DispatchAggregate row) {
-        if("PICKUP".equals(row.getTaskType())) {transportTasks.verifyPickupReview(row.getDispatchNo());return;}
        var r=read(row.getResourcesJson(),Resources.class);var v=r.vehicle();var d=r.driver();
        if(v==null || d==null || trim(v.plate())==null || trim(d.name())==null || trim(d.phone())==null)throw bad("请补齐车辆、司机和联系电话");
        var capacity=v.capacity();if(capacity==null || capacity.palletSpaces()==null || capacity.palletSpaces()<=0 || capacity.maxLoadKg()==null || capacity.maxLoadKg().signum()<=0 || capacity.maxVolumeCbm()==null || capacity.maxVolumeCbm().signum()<=0)throw bad("请补齐车辆真实托位、载重及容积");
@@ -672,10 +621,9 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        if(trim(e.licenseNo())==null || e.licenseExpiresOn()==null || e.licenseExpiresOn().isBefore(e.expectedTaskEndAt().atZone(ZoneOffset.UTC).toLocalDate()))throw bad("司机证照须覆盖预计任务结束日期");
        if(v.mode()==ResourceMode.EXTERNAL)verifyEvidence(row.getId(),com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.VEHICLE,v.evidenceFileIds());
        if(d.mode()==ResourceMode.EXTERNAL)verifyEvidence(row.getId(),com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER,e.fileIds());
-        if(!e.photoFileIds().isEmpty())verifyEvidence(row.getId(),com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER_PHOTO,e.photoFileIds());
        var actual=fleet.dispatchResources(row.getDispatchNo(),new FleetExecutionModels.DispatchVehicle(v.mode().name(),v.vehicleId(),v.plate(),v.carrierName(),capacity.palletSpaces(),capacity.maxLoadKg(),capacity.maxVolumeCbm(),v.evidenceFileIds()),
            new FleetExecutionModels.DispatchDriver(d.mode().name(),d.driverId(),d.name(),d.phone(),e.licenseNo(),e.licenseExpiresOn(),e.fileIds(),e.expectedTaskEndAt()));
-        if(!Objects.equals(hashes.source(r),hashes.source(resources(actual,e.photoFileIds()))))throw conflict("车辆或司机主档已变化，请重新保存并提交审核");
+        if(!Objects.equals(hashes.source(r),hashes.source(resources(actual))))throw conflict("车辆或司机主档已变化，请重新保存并提交审核");
    }
    /** 同类证据有界且必须属于当前整车，跨车文件不能用于审核。 */
    private void verifyEvidence(long dispatch,com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind kind,List<Long> ids) {
@@ -683,40 +631,6 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        for(var id:ids)evidence.metadata(dispatch,kind,id);
    }

-    /** 仅派送中登记异常；原键重试先恢复，避免追加重复记录。 */
-    @Transactional(isolation=Isolation.READ_COMMITTED)
-    public CommandResult markException(Actor actor,String number,DispatchCommands.MarkException request) {
-        var row=lockPlatform(actor,number);
-        if(!hasPermission(actor,Action.MARK_EXCEPTION))throw new BizException(ResultCode.FORBIDDEN,"无标记异常权限");
-        var identity=identity(actor,number,Action.MARK_EXCEPTION,request.recordVersion(),request.idempotencyKey(),request);
-        var replay=commands.replay(actor,number,identity);if(replay.isPresent())return replay.get();
-        requireExceptionAllowed(actor,row,request.recordVersion());
-        if(request.exceptionType()==null)throw bad("请选择异常类型");
-        var description=trim(request.description());
-        if(description!=null && description.length()>1000)throw bad("异常说明不能超过1000字");
-        var ids=request.imageFileIds()==null?List.<Long>of():request.imageFileIds();
-        if(ids.size()>20 || ids.stream().anyMatch(id->id==null || id<=0) || ids.stream().distinct().count()!=ids.size())throw bad("异常图片引用无效或超过20张");
-        // 文件须属于本车异常类别，不能借用其他车辆或审核附件。
-        for(var id:ids)evidence.metadata(row.getId(),com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.EXCEPTION,id);
-        var records=new ArrayList<>(exceptionRecords(row));
-        records.add(new DispatchViews.ExceptionRecord(request.exceptionType(),request.returnDirection(),description,List.copyOf(ids),Instant.now()));
-        row.setExceptionsJson(write(records));
-        return saveCommand(row,actor,identity,description);
-    }
-
-    /** 异常登记复用排车维护权限；版本、任务类型与阶段由服务端再次核验。 */
-    private void requireExceptionAllowed(Actor actor,DispatchAggregate row,long version) {
-        if(!hasPermission(actor,Action.MARK_EXCEPTION))throw new BizException(ResultCode.FORBIDDEN,"无标记异常权限");
-        if(row.getRecordVersion()!=version)throw conflict("排车版本已变化，请刷新后再标记异常");
-        if(!actions(actor,row).get(Action.MARK_EXCEPTION).allowed())throw conflict("仅派送中的仓库派送排车可以标记异常");
-    }
-
-    /** 尚未登记时为空集合，已登记记录按保存顺序完整回看。 */
-    private List<DispatchViews.ExceptionRecord> exceptionRecords(DispatchAggregate row) {
-        if(row.getExceptionsJson()==null)return List.of();
-        return Arrays.asList(read(row.getExceptionsJson(),DispatchViews.ExceptionRecord[].class));
-    }
-
    /** 同一只读快照返回分页、总数和基集分布，不能在前端过滤当前页。 */
    @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
    public DispatchViews.Page page(Actor actor, DispatchViews.Query query) {
@@ -753,7 +667,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        var documents=new DispatchViews.Documents(number,repository.outbounds(row.getId()),deliveries,instant(row.getCreatedAt()),instant(row.getUpdatedAt()),row.getRemark());
        return new DispatchViews.Detail(number,row.getTaskType()==null?"DELIVERY":row.getTaskType(),Status.valueOf(row.getStatus()),Stage.valueOf(row.getStage()),row.getRecordVersion(),ReviewState.valueOf(row.getReviewState()),
            reviews(row),counts(row),reconciled(row),actions(actor,row),new DispatchViews.VehicleInfo(resources.vehicle(),resources.driver()),
-            new DispatchViews.DispatchInfo(row.getRoute(),instant(row.getPlannedDepartureAt()),instant(row.getDepartedAt()),instant(row.getEstimatedArrivalAt()),appointments,batchRefs,exceptionRecords(row)),
+            new DispatchViews.DispatchInfo(row.getRoute(),instant(row.getPlannedDepartureAt()),instant(row.getDepartedAt()),instant(row.getEstimatedArrivalAt()),appointments,batchRefs),
            documents,orderDetails(cargo));
    }

@@ -812,8 +726,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        int pallets=(int)all.stream().map(i -> i.getWarehousePalletId()==null ? "PLAN:"+i.getPlanPalletId() : "PALLET:"+i.getWarehousePalletId()).distinct().count();
        String route=all.stream().map(this::destinationLabel).filter(Objects::nonNull).distinct().sorted().collect(Collectors.joining(","));
        var digest=all.stream().sorted(Comparator.comparing(DispatchItem::getSourceKey)).map(i -> List.of(i.getSourceKey(),i.getSourceVersion(),i.getCustomerId(),i.getPackageCount())).toList();
-        invalidate(row,"排车货物已修改，请客服重新提交审核");
-        if(repository.changeCargo(row.getId(),row.getRecordVersion(),hashes.source(digest),all.size(),pallets,packages,route,row.getDispatchReviewJson(),row.getLoadingReviewJson(),now())!=1) throw conflict("排车版本已变化，未保存本次货物");
+        if(repository.changeCargo(row.getId(),row.getRecordVersion(),hashes.source(digest),all.size(),pallets,packages,route,write(pending(row.getReviewRound())),now())!=1) throw conflict("排车版本已变化，未保存本次货物");
        var stops=all.stream().map(i -> new FleetExecutionModels.DispatchStop(destinationLabel(i),i.getDeliveryAddress(),destination(i).key()))
            .collect(Collectors.toMap(FleetExecutionModels.DispatchStop::destinationKey,s->s,(a,b)->a,TreeMap::new)).values().stream().toList();
        fleet.updateDispatchCargo(row.getDispatchNo(),packages,stops);
@@ -862,26 +775,13 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        // 到仓取货和本土卡车沿运输任务执行，不能进入仓内拣货、扣库存和转派送链。
        if (row.getTaskType()!=null && !"DELIVERY".equals(row.getTaskType())) {
            var blocked=new EnumMap<Action,Gate>(Action.class);
-            boolean pickup="PICKUP".equals(row.getTaskType()) && "ACTIVE".equals(row.getStatus());
-            for(var action:Action.values())if(action!=Action.ARRANGE_DELIVERY && action!=Action.DEPART) {
-                boolean state=pickup && switch(action) {
-                    case EDIT,CANCEL -> Set.of("BEFORE_LOADING","LOADING").contains(row.getStage());
-                    case SUBMIT_REVIEW -> "BEFORE_LOADING".equals(row.getStage()) && canSubmitReview(row.getReviewState());
-                    case DISPATCH_REVIEW -> "DISPATCH_PENDING".equals(row.getReviewState());
-                    case LOADING_REVIEW -> "LOADING_PENDING".equals(row.getReviewState());
-                    default -> false;
-                };
-                boolean allowed=state && hasPermission(actor,action);
-                blocked.put(action,new Gate(allowed,allowed?null:"TRANSPORT_TASK",allowed?null:"请按取货运输审核流程操作"));
-            }
+            for(var action:Action.values())blocked.put(action,new Gate(false,"TRANSPORT_TASK","请在排车运输任务中操作"));
            return Collections.unmodifiableMap(blocked);
        }
        var gates=new EnumMap<Action,Gate>(Action.class); boolean active=Status.ACTIVE.name().equals(row.getStatus());
        Stage stage=Stage.valueOf(row.getStage()); ReviewState review=ReviewState.valueOf(row.getReviewState());
        for(var action:Action.values()) {
-            if(action==Action.ARRANGE_DELIVERY || action==Action.DEPART)continue;
            boolean state=switch(action) {
-                case MARK_EXCEPTION -> active && stage==Stage.DELIVERING;
                case CREATE -> actor.mode()==ActorMode.PLATFORM;
                case EDIT,ADD_CARGO,REMOVE_CARGO,CANCEL -> active && stage==Stage.BEFORE_LOADING && n(row.getPickedPackageCount())==0;
                case SUBMIT_REVIEW -> active && stage==Stage.BEFORE_LOADING && n(row.getPickedPackageCount())==0 && canSubmitReview(row.getReviewState());
@@ -899,20 +799,11 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        return Collections.unmodifiableMap(gates);
    }

-    /** 装车发运及原结果恢复都按当前装车权限与PDA绑定身份校验。 */
-    void requireLoadingPermission(Actor actor) {
-        if(actor==null || actor.operatorId()==null || !hasPermission(actor,Action.LOADING_COMPLETE))
-            throw new BizException(ResultCode.FORBIDDEN,"当前无装车完成权限");
-    }
-
    /** 主体类型和正式动作权限逐项判断，不把list权限等同写权限。 */
    private static boolean hasPermission(Actor actor,Action action) {
-        if(action==Action.ARRANGE_DELIVERY || action==Action.DEPART)return false;
        var auth=SecurityContextHolder.getContext().getAuthentication(); if(auth==null || actor==null) return false;
-        if(actor.mode()==ActorMode.PDA) return Set.of(Action.LOADING_REVIEW,Action.PICK,Action.LOADING_COMPLETE,Action.DEPART).contains(action)
-            && actor.boundWarehouseId()!=null
-            && auth.getAuthorities().stream().anyMatch(a->"lastleg:pda:operate".equals(a.getAuthority()))
-            && auth.getAuthorities().stream().anyMatch(a->"ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR".equals(a.getAuthority()));
+        if(actor.mode()==ActorMode.PDA) return Set.of(Action.PICK,Action.LOADING_COMPLETE,Action.DEPART).contains(action)
+            && auth.getAuthorities().stream().anyMatch(a->"lastleg:pda:operate".equals(a.getAuthority()));
        if(action==Action.PICK) return false;
        String permission=switch(action) {
            case CREATE -> PREFIX+"create"; case CANCEL -> PREFIX+"cancel";
@@ -923,9 +814,6 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        return auth.getAuthorities().stream().anyMatch(a->permission.equals(a.getAuthority()));
    }

-    /** PDA审核读取整车冻结资源，与后台共用相同快照，查询不更改主档。 */
-    Resources resources(DispatchAggregate row) { return read(row.getResourcesJson(),Resources.class); }
-
    /** 统计按真整车去重并补齐全部零项。 */
    private static DispatchViews.Statistics statistics(List<DispatchAggregateMapper.Summary> groups) {
        var stages=new EnumMap<Stage,Long>(Stage.class); for(var stage:Stage.values()) stages.put(stage,0L);
@@ -933,13 +821,9 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        for(var group:groups) {
            if(Status.CANCELLED.name().equals(group.status())) { cancelled+=group.quantity(); continue; }
            active+=group.quantity(); var stage=Stage.valueOf(group.stage()); stages.merge(stage,group.quantity(),Long::sum);
-            if(stage==Stage.BEFORE_LOADING) {
-                // 三分区表示当前待办，驳回只能计入客服处理，不能留在审核队列。
-                var review=ReviewState.valueOf(group.reviewState());
-                if(canSubmitReview(review.name()))before+=group.quantity();
-                else if(review==ReviewState.DISPATCH_PENDING)dispatch[1]+=group.quantity();
-                else if(review==ReviewState.LOADING_PENDING)loading[1]+=group.quantity();
-            }
+            if(stage==Stage.BEFORE_LOADING) { before+=group.quantity(); var review=ReviewState.valueOf(group.reviewState());
+                dispatch[review==ReviewState.DRAFT?0:review==ReviewState.DISPATCH_PENDING?1:review==ReviewState.DISPATCH_REJECTED?3:2]+=group.quantity();
+                loading[review==ReviewState.LOADING_PENDING?1:review==ReviewState.LOADING_REJECTED?3:review==ReviewState.APPROVED?2:0]+=group.quantity(); }
        }
        return new DispatchViews.Statistics(active+cancelled,active,cancelled,Collections.unmodifiableMap(stages),new DispatchViews.BeforeLoadingCounts(before,
            new DispatchViews.ReviewCounts(dispatch[0],dispatch[1],dispatch[2],dispatch[3]),new DispatchViews.ReviewCounts(loading[0],loading[1],loading[2],loading[3])));
@@ -964,12 +848,12 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
        return List.copyOf(result);
    }

-    /** 合并Fleet权威资源与本趟司机照片，照片不写入司机主档。 */
-    private static Resources resources(FleetExecutionModels.DispatchShell shell,List<Long> photos) {
+    /** 把Fleet权威主档或真实临时输入转换成整车审阅快照。 */
+    private static Resources resources(FleetExecutionModels.DispatchShell shell) {
        var v=shell.vehicle(); var d=shell.driver();
        return new Resources(v==null?null:new VehicleSnapshot(ResourceMode.valueOf(v.mode()),v.vehicleId(),v.plate(),v.carrierName(),shell.vehicleStatus(),
            new Capacity(v.palletSpaces(),v.maxLoadKg(),v.maxVolumeCbm()),v.evidenceFileIds()),d==null?null:new DriverSnapshot(ResourceMode.valueOf(d.mode()),d.driverId(),d.name(),d.phone(),
-            new DriverEvidence(d.licenseNo(),d.licenseExpiresOn(),d.evidenceFileIds(),d.expectedTaskEndAt(),photos)));
+            new DriverEvidence(d.licenseNo(),d.licenseExpiresOn(),d.evidenceFileIds(),d.expectedTaskEndAt())));
    }

    /** 主档选择不接受请求覆盖其车牌和容量。 */
@@ -999,7 +883,7 @@ public class DispatchAggregateService implements DispatchExecutionPort,DispatchA
    /** 当前审核记录，不以版本相等代替轮次有效性。 */
    Reviews reviews(DispatchAggregate row) { return new Reviews(read(row.getDispatchReviewJson(),Review.class),read(row.getLoadingReviewJson(),Review.class)); }
    /** 未提交的审核不伪造待审核。 */
-    private static Review pending(long round) { return new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,round,null,null,null); }
+    private static Review pending(long round) { return new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,round,null,null); }
    /** 整车真实统计。 */
    private static Counts counts(DispatchAggregate row) { return new Counts(n(row.getItemCount()),n(row.getPalletCount()),n(row.getPackageCount()),n(row.getPickedPackageCount()),n(row.getShippedPackageCount())); }
    /** 空单永远不能核平为装车完成。 */
@@ -73,7 +73,7 @@ public final class DispatchCommandCodec {
            case DEPART -> DispatchResults.Departed.class;
            case ARRANGE_DELIVERY -> DispatchDeliveryModels.ArrangementResult.class;
            case CREATE, EDIT, ADD_CARGO, REMOVE_CARGO, CANCEL, SUBMIT_REVIEW,
-                 DISPATCH_REVIEW, LOADING_REVIEW, RETURN_TO_REVIEW, MARK_EXCEPTION -> DispatchResults.Saved.class;
+                 DISPATCH_REVIEW, LOADING_REVIEW, RETURN_TO_REVIEW -> DispatchResults.Saved.class;
        };
    }

@@ -19,7 +19,7 @@ import java.util.TreeMap;
@Component
 public final class DispatchCommandHasher {
    private static final Set<String> UNORDERED = Set.of("cargo", "groups", "fees", "feeCoverage", "services",
-        "batchAllocations", "measurements", "paymentVoucherFileIds", "evidenceFileIds", "fileIds", "photoFileIds");
+        "batchAllocations", "measurements", "paymentVoucherFileIds", "evidenceFileIds", "fileIds");
    private final ObjectMapper json;

    /** 复用已注册的时间、数值和公开字段序列化配置。 */
@@ -60,12 +60,7 @@ public final class DispatchCommandHasher {
        if (node == null || node.isNull()) return "null";
        if (node.isObject()) {
            var values = new TreeMap<String, String>();
-            node.fields().forEachRemaining(entry -> {
-                // 新增可选照片为空时沿用旧摘要，保留历史命令重放与已通过审核的依据。
-                if (entry.getKey().equals("photoFileIds") && (entry.getValue().isNull()
-                    || entry.getValue().isArray() && entry.getValue().isEmpty())) return;
-                values.put(entry.getKey(), canonical(entry.getValue(), entry.getKey()));
-            });
+            node.fields().forEachRemaining(entry -> values.put(entry.getKey(), canonical(entry.getValue(), entry.getKey())));
            var result = new ArrayList<String>();
            values.forEach((key, value) -> result.add(quoted(key) + ":" + value));
            return "{" + String.join(",", result) + "}";
@@ -1,73 +0,0 @@
-package com.baiyue.lastleg.dispatch.service;
-
-import com.baiyue.common.core.api.ResultCode;
-import com.baiyue.common.core.exception.BizException;
-import com.baiyue.lastleg.dispatch.port.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.*;
-import java.util.List;
-import static com.baiyue.lastleg.dispatch.port.DispatchContracts.*;
-import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
-
-/** 装车与资料可并行完成，两项齐全时在当前事务自动推进派送。 */
-@Service
-public class DispatchLoadingDepartureService {
-    private final DispatchAggregateService workflow;
-    private final DispatchDeliveryPort delivery;
-    private final DispatchDepartureService departure;
-    private final DispatchCommandLedger commands;
-    private final DispatchCommandHasher hashes;
-    private final DispatchLoadingPhotoPort documents;
-
-    /** 复用装车、派送和发车的真实规则，不另建库存或运输状态实现。 */
-    public DispatchLoadingDepartureService(DispatchAggregateService workflow,DispatchDeliveryPort delivery,
-        DispatchDepartureService departure,DispatchCommandLedger commands,DispatchCommandHasher hashes,
-        DispatchLoadingPhotoPort documents) {
-        this.workflow=workflow;this.delivery=delivery;this.departure=departure;this.commands=commands;this.hashes=hashes;
-        this.documents=documents;
-    }
-
-    /** 原请求记录最终阶段；重放不重复装车、创建派送或发车。 */
-    @Transactional(isolation=Isolation.READ_COMMITTED)
-    public CommandResult complete(Actor actor,String number,DispatchCommands.LoadingComplete request) {
-        workflow.requireLoadingPermission(actor);
-        var context=workflow.lockForArrangement(actor,number);
-        var identity=new CommandIdentity(Action.LOADING_COMPLETE,request.idempotencyKey(),request.recordVersion(),
-            hashes.command(actor,Action.LOADING_COMPLETE,number,request.recordVersion(),request));
-        var original=workflow.replay(context,actor,identity);if(original.isPresent())return original.get();
-        var loaded=workflow.loadingComplete(actor,number,new DispatchCommands.LoadingComplete(request.recordVersion(),
-            stepKey(number,request.idempotencyKey(),"LOAD"),request.manifestHash(),request.remark()));
-        var ready=DispatchLoadingDocumentService.complete(documents.read(context.dispatchId()).photos());
-        var finalState=ready?departAfterDocuments(actor,number,request.idempotencyKey()):loaded;
-        var result=new CommandResult(number,Action.LOADING_COMPLETE,request.idempotencyKey(),finalState.recordVersion(),
-            finalState.status(),finalState.stage(),finalState.occurredAt(),finalState.effect(),finalState.counts(),loaded.result(),false,false);
-        commands.append(context.dispatchId(),actor,identity,result);
-        return result;
-    }
-
-    /** 仅供装车资料齐全的保存事务调用；派送准备和发车失败回滚最后一张绑定。 */
-    @Transactional(propagation=Propagation.MANDATORY,isolation=Isolation.READ_COMMITTED)
-    public CommandResult departAfterDocuments(Actor actor,String number,String key) {
-        var context=workflow.lockForArrangement(actor,number);
-        if(context.stage()!=Stage.AFTER_LOADING || context.status()!=Status.ACTIVE)
-            throw new BizException(ResultCode.CONFLICT,"当前阶段不能按装车资料推进派送");
-        // 先取得本车单据锁再申请真实来源锁，后续所有步骤保持同一个整车父锁。
-        delivery.departureFacts(context,true);
-        String arrangementKey=stepKey(number,key,"ARRANGE");
-        var fact=delivery.prepareForDeparture(context,actor,arrangementKey);
-        var arrangementIdentity=new CommandIdentity(Action.ARRANGE_DELIVERY,arrangementKey,context.recordVersion(),
-            hashes.source(List.of(number,actor.operatorId(),context.recordVersion(),fact.arrangementBusinessHash())));
-        var arranged=workflow.recordArrangement(context,actor,arrangementIdentity,fact,false);
-        var departed=departure.depart(actor,number,new DispatchCommands.Depart(arranged.recordVersion(),
-            stepKey(number,key,"DEPART"),"五张装车照片已齐全，自动进入派送中"));
-        if(departed.stage()!=Stage.DELIVERING)
-            throw new BizException(ResultCode.CONFLICT,"装车发运结果未核平");
-        return departed;
-    }
-
-    /** 固定长度内部键绑定原请求和步骤，不向客户端暴露中间命令作为恢复入口。 */
-    private String stepKey(String number,String original,String step) {
-        return "AUTO_"+step+"_"+hashes.source(List.of(number,original,step));
-    }
-}
@@ -1,85 +0,0 @@
-package com.baiyue.lastleg.dispatch.service;
-
-import com.baiyue.common.core.api.ResultCode;
-import com.baiyue.common.core.exception.BizException;
-import com.baiyue.lastleg.dispatch.port.DispatchContracts.Actor;
-import com.baiyue.lastleg.dispatch.port.DispatchContracts.Context;
-import com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort.*;
-import org.springframework.security.core.context.SecurityContextHolder;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-import java.util.*;
-
-/** Admin/PDA按整车共用装车资料；通过车队公开端口保存照片，不读取其持久化。 */
-@Service
-public class DispatchLoadingDocumentService {
-    public static final List<Slot> SLOTS=List.of(Slot.values());
-    private final DispatchAggregateService workflow;
-    private final DispatchLoadingDepartureService departure;
-    private final DispatchLoadingPhotoPort photos;
-    /** 装车资料与履约原子编排留在排车域，车队只提供照片事实。 */
-    public DispatchLoadingDocumentService(DispatchAggregateService workflow,DispatchLoadingDepartureService departure,DispatchLoadingPhotoPort photos) {
-        this.workflow=workflow;this.departure=departure;this.photos=photos;
-    }
-    /** GET只读，PDA每次按可信主体重验冻结仓。 */
-    @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
-    public Documents get(Actor actor,String number) {
-        require(actor,false);var context=context(actor,number,false);return documents(context,photos.read(context.dispatchId()),allowed(actor,true));
-    }
-    /** 上传先记原请求意图，不提前绑定或推进派送。 */
-    public Photo upload(Actor actor,String number,Slot slot,String key,MultipartFile file) {
-        require(actor,true);var context=context(actor,number,false);return photos.upload(context.dispatchId(),actor.operatorId(),slot,key,file);
-    }
-    /** 原操作者仍须有权限且满足本车绑定仓范围，不能跨账号恢复。 */
-    public Photo recover(Actor actor,String number,String key) {
-        require(actor,true);var context=context(actor,number,false);return photos.recover(context.dispatchId(),actor.operatorId(),key);
-    }
-    /** 锁顺序为车次、排车、附加行；第五张绑定与派送发车共同提交或回滚。 */
-    @Transactional(isolation=Isolation.READ_COMMITTED)
-    public Documents bind(Actor actor,String number,Slot slot,BindPhoto request) {
-        require(actor,true);var context=context(actor,number,true);
-        var replay=photos.replayBind(context.dispatchId(),actor.operatorId(),slot,request);if(replay!=null)return replay;
-        var state=photos.bind(context.dispatchId(),actor.operatorId(),slot,request);
-        if(context.stage()==Stage.AFTER_LOADING && complete(state.photos())) {
-            departure.departAfterDocuments(actor,number,request.idempotencyKey());context=workflow.preview(actor,number);
-        }
-        var result=documents(context,state,true);
-        photos.recordBind(context.dispatchId(),actor.operatorId(),slot,request,result);return result;
-    }
-    /** 当前引用由照片提供者再次核验，拒绝未绑定或其他车文件。 */
-    @Transactional(readOnly=true)
-    public Download content(Actor actor,String number,Slot slot,long fileId) {
-        require(actor,false);var context=context(actor,number,false);return photos.content(context.dispatchId(),slot,fileId);
-    }
-    /** 装车中可同步上传；后续阶段仍须有真实装载证据，仓隔离沿用主流程。 */
-    private Context context(Actor actor,String number,boolean lock) {
-        var value=lock?workflow.lockForArrangement(actor,number):workflow.preview(actor,number);
-        if(value.status()!=Status.ACTIVE || !Set.of(Stage.LOADING,Stage.AFTER_LOADING,Stage.DELIVERING,Stage.DELIVERED).contains(value.stage())
-            || value.stage()!=Stage.LOADING && (value.loadingCompletedAt()==null || value.loadingCompletionHash()==null))
-            throw new BizException(ResultCode.CONFLICT,"进入装车中后才能管理装车资料");
-        return value;
-    }
-    /** 对外同时返回资料版本与当前排车阶段，二者不互相替代。 */
-    private Documents documents(Context context,State state,boolean editable) {
-        return new Documents(context.dispatchNo(),state.recordVersion(),Long.toString(context.recordVersion()),context.stage().name(),editable,complete(state.photos()),state.photos());
-    }
-    /** 按五个固定框核齐，不能用总数或重复槽位代替。 */
-    static boolean complete(List<Photo> photos) {
-        return SLOTS.stream().allMatch(slot->photos.stream().anyMatch(p->p.slot()==slot && p.fileId()!=null && !p.fileId().isBlank()));
-    }
-    /** 平台list与edit分离，PDA使用既有作业角色和绑定仓。 */
-    private void require(Actor actor,boolean write) {
-        if(actor==null || actor.operatorId()==null || !allowed(actor,write))throw new BizException(ResultCode.FORBIDDEN,"无装车资料操作权限");
-    }
-    /** 权限取当前会话，不为PDA补造平台权限。 */
-    private boolean allowed(Actor actor,boolean write) {
-        var auth=SecurityContextHolder.getContext().getAuthentication();if(auth==null || actor==null)return false;
-        var authorities=auth.getAuthorities().stream().map(a->a.getAuthority()).toList();
-        return actor.mode()==ActorMode.PDA?actor.boundWarehouseId()!=null && authorities.contains("lastleg:pda:operate")
-            && authorities.contains("ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR")
-            :authorities.contains("platform:overseas-warehouse:dispatch:"+(write?"edit":"list"));
-    }
-}
@@ -87,19 +87,44 @@ public class DispatchPdaQueryService {
            if(!sourceValid)actions.put(Action.PICK,new Gate(false,"SOURCE_COMPOSITION_CHANGED","换标来源实际位置或累计剩余额度已变化，请回平台核对"));
            if(!complete)actions.put(Action.LOADING_COMPLETE,new Gate(false,"PICKING_INCOMPLETE","逐项真实拣货来源尚未核平"));
            else actions.put(Action.PICK,new Gate(false,"PICKING_RECONCILED","本车全部来源已核平，请显式确认装车"));
-            var counts=new Counts(n(root.getItemCount()),n(root.getPalletCount()),detail.stream().mapToLong(DispatchViews.PdaItem::scheduledPackages).sum(),n(root.getPickedPackageCount()),n(root.getShippedPackageCount()));
+            var counts=new Counts(n(root.getItemCount()),n(root.getPalletCount()),n(root.getPackageCount()),n(root.getPickedPackageCount()),n(root.getShippedPackageCount()));
            // 整车作业直接以排车业务号识别；真实客户子taskId只在服务端审计保存。
-            result.add(new DispatchViews.PdaTask(root.getDispatchNo(),root.getDispatchNo(),root.getOverseasWarehouseId(),Status.valueOf(root.getStatus()),Stage.valueOf(root.getStage()),root.getRecordVersion(),workflow.reviews(root),workflow.resources(root),counts,complete,List.copyOf(detail),Collections.unmodifiableMap(actions)));
+            result.add(new DispatchViews.PdaTask(root.getDispatchNo(),root.getDispatchNo(),root.getOverseasWarehouseId(),Status.valueOf(root.getStatus()),Stage.valueOf(root.getStage()),root.getRecordVersion(),workflow.reviews(root),counts,complete,List.copyOf(detail),Collections.unmodifiableMap(actions)));
        }
        return List.copyOf(result);
    }
    /** 预排首次扫码前只解析原计划实收仓位，不在GET补写实托；真正绑定仍由pick锁内重验。 */
    private List<DispatchViews.Position> receivedPlanPositions(Actor actor,DispatchItem item,List<DispatchItem> items) {
-        var received=DispatchReceivedPlan.resolve(actor.boundWarehouseId(),item,items,sources,sourceRules);
-        if(received.isEmpty())return List.of();
-        // 只修改本次投影对象，不在GET更新排车、版本或库存。
-        item.setPackageCount(received.get().source().packageCount());
-        return received.get().positions();
+        if(!Objects.equals(actor.boundWarehouseId(),item.getOverseasWarehouseId()))return List.of();
+        var rows=sources.selectedPlan(item.getCustomerId(),item.getPlanPalletId());
+        if(rows.size()!=1)return List.of();
+        var actual=rows.get(0);
+        if(!"RECEIVED".equals(actual.sourceStage()) || actual.warehousePalletId()==null
+            || !Objects.equals(actual.planPalletId(),item.getPlanPalletId())
+            || !Objects.equals(actual.customerId(),item.getCustomerId())
+            || !Objects.equals(actual.overseasWarehouseId(),item.getOverseasWarehouseId())
+            || !Objects.equals(actual.packageCount(),item.getPackageCount())
+            || !Objects.equals(actual.destinationType(),item.getDestinationType())
+            || !Objects.equals(actual.fbaWarehouseCode(),item.getFbaWarehouseCode())
+            || !Objects.equals(actual.deliveryAddress(),item.getDeliveryAddress()))return List.of();
+        var originalOrders=sources.sourceOrders(item.getCustomerId(),null,item.getPlanPalletId());
+        if(originalOrders.isEmpty() || !new HashSet<>(originalOrders).containsAll(
+            sources.sourceOrders(item.getCustomerId(),actual.warehousePalletId(),item.getPlanPalletId())))return List.of();
+        // 同托跨客户、换标及整申请来源必须全部已在原车；不能把新合托货物暴露为原计划可拣库存。
+        var group=sourceRules.selectionGroup(actor.boundWarehouseId(),new DispatchCommands.CargoSelection(
+            SourceType.INBOUND_PLAN,item.getPlanPalletId(),null,null,actual.warehousePalletId(),null));
+        if(!group.complete() || group.sources().stream().noneMatch(s->Objects.equals(s.sourceKey(),item.getSourceKey())))return List.of();
+        for(var member:group.sources()) {
+            var selected=items.stream().filter(i->Objects.equals(i.getSourceKey(),member.sourceKey())).findFirst().orElse(null);
+            if(selected==null || !Objects.equals(selected.getCustomerId(),member.customerId())
+                || n(selected.getPackageCount())!=member.packages())return List.of();
+        }
+        var stock=sources.stock(item.getCustomerId(),actual.warehousePalletId(),false);
+        if(stock.stream().anyMatch(p->!Objects.equals(p.warehouseId(),actor.boundWarehouseId())
+            || !Objects.equals(p.palletId(),actual.warehousePalletId()))
+            || stock.stream().mapToLong(p->p.availablePackages()).sum()!=n(item.getPackageCount()))return List.of();
+        return stock.stream().filter(p->p.availablePackages()>0)
+            .map(p->new DispatchViews.Position(p.id(),p.balanceId(),p.availablePackages(),p.allocatedPackages(),p.pickedPackages())).toList();
    }
    /** 仓和操作者均来自受信身份，不接收请求自报。 */
    private static void require(Actor actor){if(actor==null || actor.mode()!=ActorMode.PDA || actor.operatorId()==null || actor.boundWarehouseId()==null)throw new BizException(ResultCode.FORBIDDEN,"仅绑定仓作业人员可读取PDA作业");}
@@ -27,7 +27,6 @@ public class DispatchPickingService {
    @jakarta.annotation.Resource private DispatchPhysicalClaimService physicalClaims;
    @jakarta.annotation.Resource private DispatchItemSourceService relabelSources;
    @jakarta.annotation.Resource private DispatchService sourceRules;
-    @jakarta.annotation.Resource private com.baiyue.lastleg.fleet.trip.FleetTripExecutionService fleet;
    private final DispatchAggregateService workflow;private final DispatchAggregateRepository repository;private final DispatchSourceRepository sources;
    private final DispatchPickingRepository picking;private final DispatchPickOrderAttributionService attribution;
    private final InventoryCommandService inventory;private final ReturnRelabelDispatchStock returns;
@@ -102,44 +101,33 @@ public class DispatchPickingService {
            new Counts(row.getItemCount(),row.getPalletCount(),row.getPackageCount(),row.getPickedPackageCount(),row.getShippedPackageCount()),new DispatchResults.Picked(itemId,request.positionId(),returnCartonId,request.packages(),before+request.packages(),complete),false,false);
        commands.append(row.getId(),actor,identity,result);return result;
    }
-    /** 首拣将本车已实收原计划按真实整托数量绑定，保持原审核身份并与扣货同事务回滚。 */
+    /** 原计划自然收货只补齐同一来源实托，数量/客户/目的地变化必须回到平台核对。 */
    private void materialize(com.baiyue.lastleg.dispatch.entity.DispatchAggregate row,DispatchItem item,Actor actor,List<DispatchItem> items) {
        long dispatch=row.getId();
        if(item.getWarehousePalletId()!=null) {
            relabelSources.validateFrozen(row,items,sourceRules.lockExecutionSources(row.getOverseasWarehouseId(),items));return;
        }
-        var received=new LinkedHashMap<DispatchItem,DispatchReceivedPlan.Fact>();
-        for(var candidate:items)DispatchReceivedPlan.resolve(actor.boundWarehouseId(),candidate,items,sources,sourceRules)
-            .ifPresent(fact->received.put(candidate,fact));
-        if(!received.containsKey(item))throw conflict("该托盘尚未完成可拣实收，或原来源、目的地、库存占用已变化，请刷新核对");
-        // 同车同实托的多个原计划一次绑定，避免首拣把其他已审核成员误判为新增货物。
-        for(var entry:received.entrySet()) {
-            entry.getKey().setWarehousePalletId(entry.getValue().source().warehousePalletId());
-            entry.getKey().setPackageCount(entry.getValue().source().packageCount());
-        }
+        if(item.getPlanPalletId()==null)throw conflict("本来源尚未关联真实实托");
+        var orders=sources.sourceOrders(item.getCustomerId(),null,item.getPlanPalletId());
+        if(orders.isEmpty())throw conflict("原计划缺少真实订单组成");
+        var rows=sources.selectedPlan(item.getCustomerId(),item.getPlanPalletId());
+        if(rows.size()!=1)throw conflict("请先完成本来源实际入仓收货");var actual=rows.get(0);
+        if(actual.warehousePalletId()==null || !Objects.equals(actual.customerId(),item.getCustomerId()) || !Objects.equals(actual.overseasWarehouseId(),item.getOverseasWarehouseId())
+            || !Objects.equals(actual.packageCount(),item.getPackageCount()) || !Objects.equals(actual.destinationType(),item.getDestinationType())
+            || !Objects.equals(actual.fbaWarehouseCode(),item.getFbaWarehouseCode()) || !Objects.equals(actual.deliveryAddress(),item.getDeliveryAddress()))throw conflict("原计划实收数量、仓或目的地已变化，请先回平台核对");
+        if(!new HashSet<>(orders).containsAll(sources.sourceOrders(item.getCustomerId(),actual.warehousePalletId(),item.getPlanPalletId())))throw conflict("实托新增了未审核的来源订单");
+        item.setWarehousePalletId(actual.warehousePalletId());
        relabelSources.validateFrozen(row,items,sourceRules.lockExecutionSources(row.getOverseasWarehouseId(),items));
-        for(var candidate:received.keySet().stream().sorted(Comparator.comparing(DispatchItem::getPlanPalletId)).toList()) {
-            if(sources.lockPlan(candidate.getCustomerId(),candidate.getPlanPalletId())==null)throw conflict("原计划来源已变化");
-            var fresh=sources.selectedPlan(candidate.getCustomerId(),candidate.getPlanPalletId());
-            if(fresh.size()!=1 || !DispatchReceivedPlan.sameIdentity(candidate,fresh.get(0))
-                || !Objects.equals(candidate.getWarehousePalletId(),fresh.get(0).warehousePalletId())
-                || !Objects.equals(candidate.getPackageCount(),fresh.get(0).packageCount()))throw conflict("实收托盘已变化，请刷新后重新扫码");
-        }
-        var at=LocalDateTime.ofInstant(Instant.now(),ZoneOffset.UTC);
-        var pallets=items.stream().map(DispatchItem::getWarehousePalletId).filter(Objects::nonNull).distinct().sorted().toList();
-        var physical=physicalClaims.reserve(new DispatchPhysicalClaimService.Owner(row.getOverseasWarehouseId(),dispatch,null,null,actor.operatorId(),null),pallets,at);
-        for(var entry:received.entrySet()) {
-            var candidate=entry.getKey();var actual=entry.getValue().source();
-            try{if(sources.materialize(dispatch,candidate.getCustomerId(),candidate.getPlanPalletId(),actual.warehousePalletId(),physical.get(actual.warehousePalletId()),at)!=1)throw conflict("原计划来源占用已变化");}
-            catch(DuplicateKeyException occupied){throw conflict("实托已经被其他排车占用");}
-            candidate.setPalletNo(actual.palletNo());candidate.setSourceStage("RECEIVED");
-            if(picking.materialize(candidate)!=1)throw conflict("本来源实际实托未保存");
-        }
-        row.setPackageCount(Math.toIntExact(items.stream().mapToLong(DispatchItem::getPackageCount).sum()));
-        var stops=items.stream().map(i->new com.baiyue.lastleg.fleet.trip.FleetExecutionModels.DispatchStop(
-            i.getDestinationWarehouseName(),i.getDeliveryAddress(),workflow.destination(i).key()))
-            .collect(java.util.stream.Collectors.toMap(com.baiyue.lastleg.fleet.trip.FleetExecutionModels.DispatchStop::destinationKey,s->s,(a,b)->a,TreeMap::new)).values().stream().toList();
-        fleet.updateDispatchCargo(row.getDispatchNo(),row.getPackageCount(),stops);
+        if(sources.lockPlan(item.getCustomerId(),item.getPlanPalletId())==null)throw conflict("原计划来源已变化");
+        var fresh=sources.selectedPlan(item.getCustomerId(),item.getPlanPalletId());
+        if(fresh.size()!=1 || !Objects.equals(actual.warehousePalletId(),fresh.get(0).warehousePalletId()) || !Objects.equals(actual.packageCount(),fresh.get(0).packageCount()))throw conflict("原计划实托组成已变化，请回平台核对");
+        var at=LocalDateTime.ofInstant(Instant.now(),ZoneOffset.UTC);sources.stock(item.getCustomerId(),actual.warehousePalletId(),true);
+        var pallets=new ArrayList<Long>();repository.cargo(dispatch).stream().map(DispatchItem::getWarehousePalletId).filter(Objects::nonNull).forEach(pallets::add);pallets.add(actual.warehousePalletId());
+        var physical=physicalClaims.reserve(new DispatchPhysicalClaimService.Owner(row.getOverseasWarehouseId(),dispatch,null,null,actor.operatorId(),null),pallets,at).get(actual.warehousePalletId());
+        try{if(sources.materialize(dispatch,item.getCustomerId(),item.getPlanPalletId(),actual.warehousePalletId(),physical,at)!=1)throw conflict("原计划来源占用已变化");}
+        catch(DuplicateKeyException occupied){throw conflict("实托已经被其他来源安排占用");}
+        item.setPalletNo(actual.palletNo());item.setSourceStage("RECEIVED");
+        if(picking.materialize(item)!=1)throw conflict("本来源实际实托未保存");
    }
    /** 库存幂等键分别标识一次实际动作，业务单号始终使用本车号。 */
    private static InventoryCommandRequests.Move move(DispatchCommands.Pick request,String dispatch,String reference,String key){return new InventoryCommandRequests.Move(request.positionId(),request.packages(),reference,dispatch,null,key,request.remark());}
@@ -1,56 +0,0 @@
-package com.baiyue.lastleg.dispatch.service;
-
-import com.baiyue.lastleg.dispatch.entity.DispatchItem;
-import com.baiyue.lastleg.dispatch.model.DispatchPalletCandidate;
-import com.baiyue.lastleg.dispatch.port.*;
-import com.baiyue.lastleg.dispatch.repository.DispatchSourceRepository;
-import java.util.*;
-import static com.baiyue.lastleg.dispatch.port.DispatchTypes.SourceType;
-
-/** 预排来源只冻结货物身份；自然实收的逐托箱数由真实库存提供，查询和首拣共用此规则。 */
-final class DispatchReceivedPlan {
-    record Fact(DispatchPalletCandidate source, List<DispatchViews.Position> positions) { }
-
-    /** 仅解析原车完整来源，禁止把新客户、新订单或冻结货物混入实收数量。 */
-    static Optional<Fact> resolve(String warehouse, DispatchItem item, List<DispatchItem> items,
-                                  DispatchSourceRepository sources, DispatchService rules) {
-        if(item.getWarehousePalletId()!=null || item.getPlanPalletId()==null
-            || !Objects.equals(warehouse,item.getOverseasWarehouseId()))return Optional.empty();
-        if(!sources.receivedPlanCompleted(item.getCustomerId(),item.getPlanPalletId()))return Optional.empty();
-        var rows=sources.selectedPlan(item.getCustomerId(),item.getPlanPalletId());
-        if(rows.size()!=1)return Optional.empty();
-        var actual=rows.get(0);
-        if(!sameIdentity(item,actual) || actual.packageCount()==null || actual.packageCount()<=0)return Optional.empty();
-        var original=sources.sourceOrders(item.getCustomerId(),null,item.getPlanPalletId());
-        if(original.isEmpty() || !new HashSet<>(original).containsAll(
-            sources.sourceOrders(item.getCustomerId(),actual.warehousePalletId(),item.getPlanPalletId())))return Optional.empty();
-        var group=rules.selectionGroup(warehouse,new DispatchCommands.CargoSelection(
-            SourceType.INBOUND_PLAN,item.getPlanPalletId(),null,null,actual.warehousePalletId(),null));
-        if(!group.complete() || group.sources().stream().noneMatch(s->Objects.equals(s.sourceKey(),item.getSourceKey())))return Optional.empty();
-        for(var member:group.sources()) {
-            var selected=items.stream().filter(i->Objects.equals(i.getSourceKey(),member.sourceKey())).findFirst().orElse(null);
-            if(selected==null || !Objects.equals(selected.getCustomerId(),member.customerId()))return Optional.empty();
-            // 原计划的估算箱数不限制实收；已经绑定或换标的冻结贡献仍严格核对。
-            if((selected.getWarehousePalletId()!=null || selected.getPlanPalletId()==null)
-                && (selected.getPackageCount()==null || selected.getPackageCount().longValue()!=member.packages()))return Optional.empty();
-        }
-        var stock=sources.stock(item.getCustomerId(),actual.warehousePalletId(),false);
-        if(stock.stream().anyMatch(p->!Objects.equals(p.warehouseId(),warehouse)
-            || !Objects.equals(p.palletId(),actual.warehousePalletId()) || p.holdPackages()!=0
-            || p.allocatedPackages()!=0 || p.pickedPackages()!=0)
-            || stock.stream().mapToLong(p->p.availablePackages()).sum()!=actual.packageCount())return Optional.empty();
-        return Optional.of(new Fact(actual,stock.stream().filter(p->p.availablePackages()>0)
-            .map(p->new DispatchViews.Position(p.id(),p.balanceId(),p.availablePackages(),p.allocatedPackages(),p.pickedPackages())).toList()));
-    }
-
-    /** 箱数允许随自然实收变化，客户、原计划、起运仓和目的地必须保持原身份。 */
-    static boolean sameIdentity(DispatchItem item,DispatchPalletCandidate actual) {
-        return "RECEIVED".equals(actual.sourceStage()) && actual.warehousePalletId()!=null
-            && Objects.equals(actual.planPalletId(),item.getPlanPalletId())
-            && Objects.equals(actual.customerId(),item.getCustomerId())
-            && Objects.equals(actual.overseasWarehouseId(),item.getOverseasWarehouseId())
-            && Objects.equals(actual.destinationType(),item.getDestinationType())
-            && Objects.equals(actual.fbaWarehouseCode(),item.getFbaWarehouseCode())
-            && Objects.equals(actual.deliveryAddress(),item.getDeliveryAddress());
-    }
-}
@@ -1,81 +0,0 @@
-package com.baiyue.lastleg.dispatch.transport;
-
-import com.baiyue.lastleg.dispatch.entity.DispatchAggregate;
-import com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway;
-import com.baiyue.lastleg.fleet.driver.DriverService;
-import com.baiyue.lastleg.fleet.trip.FleetTripEntity;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.springframework.http.HttpStatus;
-import org.springframework.stereotype.Service;
-import org.springframework.web.server.ResponseStatusException;
-import java.time.ZoneOffset;
-import java.util.*;
-import static com.baiyue.lastleg.dispatch.port.DispatchContracts.*;
-import static com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.*;
-
-/** 取货审核照片按本车分类校验，驾驶证主档引用明确区分于本车补传。 */
-@Service
-public class TransportReviewPhotos {
-    private final DispatchEvidenceGateway files;
-    private final DriverService drivers;
-    private final ObjectMapper json;
-    /** 注入正式文件归属与司机资格入口。 */
-    public TransportReviewPhotos(DispatchEvidenceGateway files, DriverService drivers, ObjectMapper json) {
-        this.files=files; this.drivers=drivers; this.json=json;
-    }
-    /** 读取已保存资源；空排车还没有照片。 */
-    public Resources resources(DispatchAggregate row) {
-        if(row.getResourcesJson()==null)return new Resources(null,null);
-        try{return json.readValue(row.getResourcesJson(),Resources.class);}
-        catch(Exception e){throw new IllegalStateException("取货照片快照读取失败",e);}
-    }
-    /** 校验三类照片及主档身份，换车或换司机不能沿用旧对象的照片。 */
-    public DriverEvidence validate(DispatchAggregate row, FleetTripEntity trip, TransportTaskModels.Assign request) {
-        var photos=request.reviewPhotos();
-        if(photos==null || photos.vehicleFileIds().isEmpty() || photos.driverPhotoFileIds().isEmpty()
-            || photos.licenseFileIds().isEmpty() && request.masterLicenseFileId()==null)
-            throw conflict("请补齐车辆图片、司机照片和驾驶证照片后保存");
-        var old=resources(row);
-        if(old.vehicle()!=null && !Objects.equals(old.vehicle().vehicleId(),request.vehicleId()))
-            rejectReused(old.vehicle().evidenceFileIds(),photos.vehicleFileIds());
-        if(old.driver()!=null && old.driver().evidence()!=null && !Objects.equals(old.driver().driverId(),request.driverId())) {
-            rejectReused(old.driver().evidence().photoFileIds(),photos.driverPhotoFileIds());
-            rejectReused(old.driver().evidence().fileIds(),photos.licenseFileIds());
-        }
-        var driver=drivers.requireDispatchable(request.driverId(),trip.getExpectedDriverEndAt().toInstant(ZoneOffset.UTC));
-        if(!"OVERSEAS".equals(driver.details().region()))throw conflict("请选择海外司机");
-        verify(row.getId(),VEHICLE,photos.vehicleFileIds());
-        verify(row.getId(),DRIVER_PHOTO,photos.driverPhotoFileIds());
-        verify(row.getId(),DRIVER,photos.licenseFileIds());
-        var licenseIds=new ArrayList<>(photos.licenseFileIds());
-        if(request.masterLicenseFileId()!=null) {
-            if(!request.masterLicenseFileId().toString().equals(driver.licenseFileId()))throw conflict("司机主档驾驶证已变化，请重新选择司机");
-            drivers.download(request.driverId(),request.masterLicenseFileId());
-            if(licenseIds.contains(request.masterLicenseFileId()))throw conflict("驾驶证主档引用不能作为本车上传重复提交");
-            licenseIds.add(request.masterLicenseFileId());
-        }
-        return new DriverEvidence(driver.details().licenseNumber(),driver.details().licenseExpiresOn(),List.copyOf(licenseIds),
-            trip.getExpectedDriverEndAt().toInstant(ZoneOffset.UTC),photos.driverPhotoFileIds(),request.masterLicenseFileId());
-    }
-    /** 提交和两级通过均复验照片，避免仅前端必填而绕过审核依据。 */
-    public void verifyReview(DispatchAggregate row, FleetTripEntity trip) {
-        var saved=resources(row);var driver=saved.driver();var vehicle=saved.vehicle();
-        if(vehicle==null || driver==null || driver.evidence()==null
-            || !Objects.equals(vehicle.vehicleId(),trip.getVehicleId()) || !Objects.equals(driver.driverId(),trip.getDriverId()))
-            throw conflict("请维护车辆司机并补齐审核照片");
-        var e=driver.evidence();
-        var licenses=e.fileIds()==null?List.<Long>of():e.fileIds().stream().filter(id->!Objects.equals(id,e.masterLicenseFileId())).toList();
-        validate(row,trip,new TransportTaskModels.Assign(trip.getRecordVersion(),trip.getVehicleId(),trip.getDriverId(),"核验取货照片",
-            row.getRecordVersion(),new ReviewAttachments(vehicle.evidenceFileIds(),e.photoFileIds(),licenses),e.masterLicenseFileId()));
-    }
-    /** 不把同排车旧司机或车辆的上传当成新对象的证据。 */
-    private void rejectReused(List<Long> old,List<Long> selected) {
-        if(old!=null && selected.stream().anyMatch(old::contains))throw conflict("车辆或司机已更换，请重新上传对应照片");
-    }
-    /** 文件网关逐项校验平台、本车和文件类别，失效或跨单引用直接失败。 */
-    private void verify(long dispatch,DispatchEvidenceGateway.Kind kind,List<Long> ids) {
-        for(long id:ids)files.metadata(dispatch,kind,id);
-    }
-    /** 返回可处理的业务冲突。 */
-    private static ResponseStatusException conflict(String message) {return new ResponseStatusException(HttpStatus.CONFLICT,message);}
-}
@@ -39,7 +39,7 @@ public class TransportTaskController {
    public ApiResponse<?> detail(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number){operator(user);return ApiResponse.success(service.detail(number));}
    /** 分配或改派真实车辆司机。 */
    @PostMapping("/{number}/assign") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<?> assign(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@Valid @RequestBody TransportTaskModels.Assign request){return ApiResponse.success(service.assign(number,operator(user),request));}
+    public ApiResponse<?> assign(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@Valid @RequestBody FleetTripModels.Assign request){return ApiResponse.success(service.assign(number,operator(user),request));}
    /** 取消未发车任务，来源回到待安排。 */
    @PostMapping("/{number}/cancel") @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:cancel')")
    public ApiResponse<?> cancel(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String number,@Valid @RequestBody FleetTripModels.Cancel request){return ApiResponse.success(service.cancel(number,operator(user),request));}
@@ -18,12 +18,6 @@ public final class TransportTaskModels {
        @NotBlank @Size(max=1000) String reason,List<@Positive Long> evidenceFileIds) { }
    public record Detail(String dispatchNo,String taskType,FleetTripModels.Detail execution,
        String customerId,String orderNo,List<FleetPickupModels.Task> pickups,
-        List<com.baiyue.lastleg.fleet.reporting.TripOperationsRecordModels.EvidenceFile> completionEvidence,
-        Long dispatchRecordVersion, com.baiyue.lastleg.dispatch.port.DispatchContracts.Resources resources) { }
-    public record Assign(@NotNull @Min(0) Long recordVersion, @NotNull @Positive Long vehicleId,
-        @NotNull @Positive Long driverId, @NotBlank @Size(max=1000) String reason,
-        @Min(0) Long dispatchRecordVersion,
-        @Valid com.baiyue.lastleg.dispatch.port.DispatchContracts.ReviewAttachments reviewPhotos,
-        @Positive Long masterLicenseFileId) { }
+        List<com.baiyue.lastleg.fleet.reporting.TripOperationsRecordModels.EvidenceFile> completionEvidence) { }
    public record TruckLink(String dispatchNo,String tripNo,String customerId,String orderNo) { }
 }
@@ -18,13 +18,12 @@ import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;

 /** 现有排车主单与运输事实同步，旧执行入口也不能留下不同步的单据。 */
@Service
-public class TransportTaskProjection implements com.baiyue.lastleg.fleet.pickup.PickupDepartureReview {
+public class TransportTaskProjection {
    private final DispatchAggregateRepository roots;
    private final TransportTaskRepository links;
    private final UsTruckOrderRepository trucks;
    private final DispatchNumberGenerator numbers;
    private final ObjectMapper json;
-    @jakarta.annotation.Resource private com.baiyue.lastleg.fleet.pickup.FleetPickupRepository pickupFacts;
    /** 注入本地聚合与原单持久化能力，无跨服务数据库访问。 */
    public TransportTaskProjection(DispatchAggregateRepository roots,TransportTaskRepository links,UsTruckOrderRepository trucks,DispatchNumberGenerator numbers,ObjectMapper json) {
        this.roots=roots;this.links=links;this.trucks=trucks;this.numbers=numbers;this.json=json;
@@ -37,7 +36,7 @@ public class TransportTaskProjection implements com.baiyue.lastleg.fleet.pickup.
        row.setOverseasWarehouseCode(trip.getWarehouseCode());row.setOverseasWarehouseName(trip.getWarehouseName());
        row.setStatus("ACTIVE");row.setStage("BEFORE_LOADING");row.setRecordVersion(trip.getRecordVersion());row.setCargoRevision(0L);
        row.setCargoHash(trip.getRequestHash());row.setReviewState("DRAFT");row.setReviewRound(0L);
-        var review=new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,0,null,null,null);
+        var review=new Review(ReviewStatus.NOT_SUBMITTED,null,null,null,0,null,null);
        row.setDispatchReviewJson(write(review));row.setLoadingReviewJson(write(review));
        resources(row,trip);row.setPlannedDepartureAt(trip.getPlannedDepartureAt());row.setEstimatedArrivalAt(trip.getExpectedDriverEndAt());
        row.setRoute(("PICKUP".equals(trip.getTripPurpose())?"到仓取货":"本土卡车")+" · "+items+"单 · "+trip.getWarehouseCode());row.setItemCount(items);row.setPalletCount(pallets);row.setPackageCount(packages);
@@ -51,22 +50,11 @@ public class TransportTaskProjection implements com.baiyue.lastleg.fleet.pickup.
        var trip=event.trip();if(!Set.of("PICKUP","LOCAL_TRUCK").contains(Objects.toString(trip.getTripPurpose(),"")))return;
        var found=links.byTrip(trip.getId());if(found==null)return;
        var row=roots.lock(found.getDispatchNo());long version=row.getRecordVersion();
-        row.setRecordVersion(version+1);row.setUpdatedAt(trip.getUpdatedAt());
+        row.setRecordVersion(trip.getRecordVersion());row.setUpdatedAt(trip.getUpdatedAt());
        row.setStatus("CANCELLED".equals(trip.getStatus())?"CANCELLED":"ACTIVE");
-        row.setStage(switch(trip.getStatus()){case "IN_TRANSIT"->"DELIVERING";case "COMPLETED"->"DELIVERED";case "PLANNED"->row.getStage();default->"BEFORE_LOADING";});
-        // 旧发车入口只记录出发事实，取货照片尚未齐全时仍在装货中。
-        if("PICKUP".equals(row.getTaskType()) && "IN_TRANSIT".equals(trip.getStatus())
-            && pickupFacts.tasks(trip.getTripNo()).stream().anyMatch(task->"ASSIGNED".equals(task.getStatus())))row.setStage("LOADING");
+        row.setStage(switch(trip.getStatus()){case "IN_TRANSIT"->"DELIVERING";case "COMPLETED"->"DELIVERED";default->"BEFORE_LOADING";});
        row.setDepartedAt(trip.getDepartedAt());row.setDeliveryCompletedAt(trip.getCompletedAt());
-        String oldResources=row.getResourcesJson();var oldDeparture=row.getPlannedDepartureAt();var oldArrival=row.getEstimatedArrivalAt();
        row.setPlannedDepartureAt(trip.getPlannedDepartureAt());row.setEstimatedArrivalAt(trip.getExpectedDriverEndAt());row.setRemark(trip.getRemark());resources(row,trip);
-        // 资源或计划改变后作废本轮审核，保留审核驳回原因供修改时核对。
-        if("PICKUP".equals(row.getTaskType()) && "PLANNED".equals(trip.getStatus())
-            && (!Objects.equals(oldResources,row.getResourcesJson()) || !Objects.equals(oldDeparture,row.getPlannedDepartureAt()) || !Objects.equals(oldArrival,row.getEstimatedArrivalAt()))) {
-            row.setReviewState("DRAFT");row.setReviewBasisHash(null);row.setStage("BEFORE_LOADING");
-            row.setDispatchReviewJson(invalidated(row.getDispatchReviewJson(),row.getReviewRound()));
-            row.setLoadingReviewJson(invalidated(row.getLoadingReviewJson(),row.getReviewRound()));
-        }
        if(roots.saveState(row,version)!=1)throw new IllegalStateException("运输排车版本保存失败");
        roots.history(IdWorker.getId(),row,event.action(),event.operator(),event.reason(),write(row),trip.getUpdatedAt());
        var link=links.truck(row.getDispatchNo());if(link==null)return;
@@ -74,30 +62,6 @@ public class TransportTaskProjection implements com.baiyue.lastleg.fleet.pickup.
        transition(link.customerId(),link.orderNo(),target,event.action(),event.operator(),event.reason(),row.getDispatchNo()+":"+trip.getRecordVersion());
        if("CANCELLED".equals(trip.getStatus()))links.cancel(row.getDispatchNo());
    }
-    /** 旧取货发车入口也必须锁定并核验同轮两级批准，不允许无主单发车。 */
-    @Override
-    public void requireApproved(long tripId) {
-        var found=links.byTrip(tripId);
-        if(found==null)throw new IllegalStateException("取货排车缺失，请先接入排车审核");
-        var row=roots.lock(found.getDispatchNo());
-        if(!"PICKUP".equals(row.getTaskType()) || !"ACTIVE".equals(row.getStatus()) || !"APPROVED".equals(row.getReviewState()) || row.getReviewBasisHash()==null)
-            throw new org.springframework.web.server.ResponseStatusException(org.springframework.http.HttpStatus.CONFLICT,"请先完成调度审核和理货员审核");
-        for(String value:List.of(row.getDispatchReviewJson(),row.getLoadingReviewJson())) {
-            try {
-                var review=json.readValue(value,Review.class);
-                if(review.status()!=ReviewStatus.APPROVED || review.reviewRound()!=row.getReviewRound() || !Objects.equals(review.basisHash(),row.getReviewBasisHash()))
-                    throw new IllegalStateException("取货审核依据已失效，请重新提交审核");
-            } catch(com.fasterxml.jackson.core.JsonProcessingException e){throw new IllegalStateException("取货审核记录读取失败",e);}
-        }
-    }
-    /** 保留驳回事实，同时明确此前批准已因资源变更失效。 */
-    private String invalidated(String value,long round) {
-        try {
-            var old=json.readValue(value,Review.class);
-            return write(new Review(old.status()==ReviewStatus.REJECTED?ReviewStatus.REJECTED:ReviewStatus.NOT_SUBMITTED,
-                old.reason(),old.reviewerId(),old.reviewedAt(),round,null,"车辆、司机、照片或计划已变更，请重新提交两级审核",old.attachments()));
-        } catch(com.fasterxml.jackson.core.JsonProcessingException e){throw new IllegalStateException("取货审核记录读取失败",e);}
-    }
    /** 本土卡车只回写真实运输状态并追加原业务不可变历史。 */
    public void transition(String customer,String number,String target,String action,String operator,String reason,String key) {
        var order=trucks.lockNo(customer,number);if(order==null)throw new IllegalStateException("关联本土卡车单不存在");
@@ -111,32 +75,9 @@ public class TransportTaskProjection implements com.baiyue.lastleg.fleet.pickup.
    }
    /** 主单仅展示真实主档分配，不伪造临时证照或仓库装载事实。 */
    private void resources(DispatchAggregate row,FleetTripEntity trip) {
-        var old=readResources(row);
        row.setVehiclePlate(trip.getVehiclePlate());row.setResourcesJson(write(new Resources(
-            trip.getVehicleId()==null?null:new VehicleSnapshot(ResourceMode.MASTER,trip.getVehicleId(),trip.getVehiclePlate(),null,null,new Capacity(trip.getMaxPalletSpaces(),trip.getMaxLoadKg(),trip.getMaxVolumeCbm()),
-                old.vehicle()!=null && Objects.equals(old.vehicle().vehicleId(),trip.getVehicleId())?old.vehicle().evidenceFileIds():List.of()),
-            trip.getDriverId()==null?null:new DriverSnapshot(ResourceMode.MASTER,trip.getDriverId(),trip.getDriverName(),trip.getDriverPhone(),
-                old.driver()!=null && Objects.equals(old.driver().driverId(),trip.getDriverId())?old.driver().evidence():null))));
-    }
-    /** 照片变更单独纳入主单版本和审核依据，资源分配失败时由外层事务一起回滚。 */
-    public void savePhotos(String number,String operator,List<Long> vehiclePhotos,DriverEvidence driverPhotos) {
-        var row=roots.lock(number);var old=readResources(row);var v=old.vehicle();var d=old.driver();
-        if(v==null || d==null)throw new IllegalStateException("请先完成车辆司机分配");
-        var next=new Resources(new VehicleSnapshot(v.mode(),v.vehicleId(),v.plate(),v.carrierName(),v.vehicleStatus(),v.capacity(),vehiclePhotos),
-            new DriverSnapshot(d.mode(),d.driverId(),d.name(),d.phone(),driverPhotos));
-        if(next.equals(old))return;
-        long version=row.getRecordVersion();row.setResourcesJson(write(next));row.setRecordVersion(version+1);
-        row.setUpdatedAt(LocalDateTime.now(ZoneOffset.UTC));row.setReviewState("DRAFT");row.setReviewBasisHash(null);row.setStage("BEFORE_LOADING");
-        row.setDispatchReviewJson(invalidated(row.getDispatchReviewJson(),row.getReviewRound()));
-        row.setLoadingReviewJson(invalidated(row.getLoadingReviewJson(),row.getReviewRound()));
-        if(roots.saveState(row,version)!=1)throw new IllegalStateException("取货照片保存版本冲突");
-        roots.history(IdWorker.getId(),row,"PICKUP_RESOURCE_PHOTOS",operator,"保存车辆、司机和驾驶证审核照片",write(row),row.getUpdatedAt());
-    }
-    /** 状态投影只保留同一资源的已保存照片，不能在运输流转中清空审核证据。 */
-    private Resources readResources(DispatchAggregate row) {
-        if(row.getResourcesJson()==null)return new Resources(null,null);
-        try{return json.readValue(row.getResourcesJson(),Resources.class);}
-        catch(Exception e){throw new IllegalStateException("运输资源照片读取失败",e);}
+            trip.getVehicleId()==null?null:new VehicleSnapshot(ResourceMode.MASTER,trip.getVehicleId(),trip.getVehiclePlate(),null,null,new Capacity(trip.getMaxPalletSpaces(),trip.getMaxLoadKg(),trip.getMaxVolumeCbm()),List.of()),
+            trip.getDriverId()==null?null:new DriverSnapshot(ResourceMode.MASTER,trip.getDriverId(),trip.getDriverName(),trip.getDriverPhone(),null))));
    }
    /** 保存明确的业务快照，失败时终止事务。 */
    private String write(Object value){try{return json.writeValueAsString(value);}catch(Exception e){throw new IllegalStateException("运输快照序列化失败",e);}}
@@ -35,7 +35,6 @@ public class TransportTaskService {
    private final FleetTransportVehicleGuard vehicles;
    private final TripOperationsEvidenceGateway files;
    private final ObjectMapper json;
-    @jakarta.annotation.Resource private TransportReviewPhotos reviewPhotos;
    /** 复用已有资格、占用、原单及凭证能力。 */
    public TransportTaskService(DispatchAggregateRepository roots,TransportTaskRepository links,TransportTaskProjection projection,
        FleetTripRepository tripRepo,FleetTripService trips,FleetPickupService pickups,FleetPickupRepository pickupFacts,
@@ -52,22 +51,6 @@ public class TransportTaskService {
        var tasks=pickups.tasks(trip.getTripNo());var row=projection.register(trip,tasks.size(),0,tasks.stream().mapToInt(FleetPickupModels.Task::packageCount).sum(),operator);
        return detail(row.getDispatchNo());
    }
-    /** 审核通过后按原单锁幂等生成待发车排车；重复审核保留原安排及取消结果。 */
-    @Transactional
-    public void ensureApprovedPickup(String customer,String number,String operator) {
-        var source=pickupFacts.source(customer,number,true);
-        if(source==null)throw missing("转运单不存在");
-        if(!"WAREHOUSE_PICKUP".equals(source.getDeliveryMethod()) || !number.equals(source.getInboundCode())
-            || !"WAIT_PDA_RECEIVING".equals(source.getStatus()))return;
-        var task=pickupFacts.lockTask(source.getId());
-        // 已安排、执行或主动取消的取货任务均不因审核重放重新建单。
-        if(task!=null)return;
-        var departure=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.SECONDS);
-        createPickup(operator,new FleetPickupModels.Create(List.of(new FleetPickupModels.Source(customer,number)),
-            departure,departure.plus(Duration.ofHours(24)),
-            "审核自动生成到仓取货排车；时间为暂定计划，调度确认后分配车辆司机",
-            "transfer-approval:"+source.getId()));
-    }
    /** 原单锁和有效关联唯一约束共同阻止同单重复排车。 */
    @Transactional
    public TransportTaskModels.Detail createTruck(String operator,TransportTaskModels.TruckCreate request) {
@@ -96,8 +79,7 @@ public class TransportTaskService {
        var trip=transport(number,false);var row=links.byTrip(trip.getId());var link=links.truck(number);
        return new TransportTaskModels.Detail(number,row.getTaskType(),trips.detail(trip.getTripNo()),link==null?null:link.customerId(),link==null?null:link.orderNo(),
            "PICKUP".equals(row.getTaskType())?pickups.tasks(trip.getTripNo()):List.of(),
-            evidenceIds(number).stream().map(id->files.metadata(trip.getId(),id)).toList(),row.getRecordVersion(),
-            "PICKUP".equals(row.getTaskType())?reviewPhotos.resources(row):null);
+            evidenceIds(number).stream().map(id->files.metadata(trip.getId(),id)).toList());
    }
    /** 仅允许读取已确认属于本排车的完成凭证，文件元数据再次核对资源归属。 */
    public byte[] evidence(String number,long id){var trip=transport(number,false);if(!evidenceIds(number).contains(id))throw missing("当前排车没有该完成凭证");files.metadata(trip.getId(),id);return files.download(trip.getId(),id);}
@@ -109,32 +91,12 @@ public class TransportTaskService {
        if(!Set.of("PICKUP","LOCAL_TRUCK").contains(Objects.toString(root.getTaskType(),"")))throw conflict("当前排车单不是运输任务");
        String tripNo=links.tripNo(root.getTripId());var trip=lock?tripRepo.lockTrip(tripNo):tripRepo.findTrip(tripNo);if(trip==null)throw missing("运输资源记录不存在");return trip;
    }
-    /** 资源与三类照片同事务保存；双版本阻止审核期间的旧页面覆盖。 */
+    /** 分配实际资源，容量超限时整次分配回滚。 */
    @Transactional
-    public TransportTaskModels.Detail assign(String number,String operator,TransportTaskModels.Assign request) {
-        var trip=transport(number,true);
-        com.baiyue.lastleg.dispatch.port.DispatchContracts.DriverEvidence photos=null;
-        if("PICKUP".equals(trip.getTripPurpose())) {
-            var row=roots.lock(number);
-            if(!Objects.equals(trip.getRecordVersion(),request.recordVersion()) || request.dispatchRecordVersion()==null
-                || !Objects.equals(row.getRecordVersion(),request.dispatchRecordVersion()))throw conflict("排车或审核信息已变化，请刷新后重试");
-            if(!"PLANNED".equals(trip.getStatus()) || pickups.tasks(trip.getTripNo()).stream().anyMatch(task->!"ASSIGNED".equals(task.status())))throw conflict("已取货的任务不能更换资源照片");
-            photos=reviewPhotos.validate(row,trip,request);
-        }
-        trips.assign(trip.getTripNo(),operator,new FleetTripModels.Assign(request.recordVersion(),request.vehicleId(),request.driverId(),request.reason()));
-        if(photos!=null)projection.savePhotos(number,operator,request.reviewPhotos().vehicleFileIds(),photos);
+    public TransportTaskModels.Detail assign(String number,String operator,FleetTripModels.Assign request) {
+        var trip=transport(number,true);trips.assign(trip.getTripNo(),operator,request);
        if("LOCAL_TRUCK".equals(trip.getTripPurpose()))capacity(tripRepo.findTrip(trip.getTripNo()),truck(number));return detail(number);
    }
-    /** 取货提交与两级通过时复验真实占用、有效证照和车辆容量。 */
-    public void verifyPickupReview(String number) {
-        var trip=transport(number,true);
-        if(!"PICKUP".equals(trip.getTripPurpose()) || !"PLANNED".equals(trip.getStatus()) || pickups.tasks(trip.getTripNo()).isEmpty())throw conflict("仅有真实取货任务的未发车排车可以审核");
-        if(trip.getPlannedDepartureAt()==null || trip.getExpectedDriverEndAt()==null || !trip.getExpectedDriverEndAt().isAfter(trip.getPlannedDepartureAt()) || !trip.getExpectedDriverEndAt().isAfter(now()))throw conflict("请维护有效的计划发车与任务结束时间");
-        var pallets=trip.getMaxPalletSpaces();var weight=trip.getMaxLoadKg();var volume=trip.getMaxVolumeCbm();
-        requireResources(trip);
-        reviewPhotos.verifyReview(roots.find(number),trip);
-        if(!Objects.equals(pallets,trip.getMaxPalletSpaces()) || !Objects.equals(weight,trip.getMaxLoadKg()) || !Objects.equals(volume,trip.getMaxVolumeCbm()))throw conflict("车辆主档已变化，请重新维护车辆信息");
-    }
    /** 取消运输并保留原单、排车及资源审计。 */
    @Transactional
    public TransportTaskModels.Detail cancel(String number,String operator,FleetTripModels.Cancel request) {
@@ -7,6 +7,5 @@ public record ContainerArrivalTimeView(
    String sourceContainerBookingId,
    LocalDateTime estimatedWarehouseArrivalAt,
    LocalDateTime actualWarehouseArrivalAt,
-    int version,
-    long planCount
+    int version
 ) { }
@@ -12,14 +12,14 @@ public final class TripCapacityPolicy {

    public record Load(int palletSpaces, BigDecimal weightKg, BigDecimal volumeCbm) {
        public Load {
-            if (palletSpaces < 0 || weightKg != null && weightKg.signum() < 0 || volumeCbm != null && volumeCbm.signum() < 0) {
+            if (palletSpaces < 0 || weightKg == null || volumeCbm == null
+                || weightKg.signum() < 0 || volumeCbm.signum() < 0) {
                throw new IllegalArgumentException("托位、重量和体积须为非负数");
            }
        }
        public Load plus(Load other) {
            return new Load(Math.addExact(palletSpaces, other.palletSpaces),
-                weightKg == null || other.weightKg == null ? null : weightKg.add(other.weightKg),
-                volumeCbm == null || other.volumeCbm == null ? null : volumeCbm.add(other.volumeCbm));
+                weightKg.add(other.weightKg), volumeCbm.add(other.volumeCbm));
        }
    }

@@ -28,7 +28,7 @@ public final class TripCapacityPolicy {
            if (bookingNo == null || bookingNo.isBlank()) throw new IllegalArgumentException("缺少承运业务编号");
            if (pickupIndex < 0 || deliveryIndex <= pickupIndex) throw new IllegalArgumentException("卸货站必须在提货站之后");
            Objects.requireNonNull(load, "load");
-            if (load.palletSpaces() == 0 || load.weightKg() != null && load.weightKg().signum() == 0 || load.volumeCbm() != null && load.volumeCbm().signum() == 0) {
+            if (load.palletSpaces() == 0 || load.weightKg().signum() == 0 || load.volumeCbm().signum() == 0) {
                throw new IllegalArgumentException("承运货物须有有效托位、重量和体积");
            }
        }
@@ -37,48 +37,31 @@ public final class TripCapacityPolicy {
    public record Segment(int fromIndex, int toIndex, Load occupied, Load remaining) { }

    public static List<Segment> calculate(int stopCount, Load capacity, List<Booking> bookings) {
-        return calculate(stopCount, capacity, bookings, false);
-    }
-
-    /** 装车使用已有测量；未知维度保留空值，仅校验已知货量，不把未知当作可售余量。 */
-    public static List<Segment> calculateActual(int stopCount, Load capacity, List<Booking> bookings) {
-        return calculate(stopCount, capacity, bookings, true);
-    }
-
-    private static List<Segment> calculate(int stopCount, Load capacity, List<Booking> bookings, boolean actual) {
        Objects.requireNonNull(capacity, "capacity");
        Objects.requireNonNull(bookings, "bookings");
        if (stopCount < 2 || stopCount > 200) throw new IllegalArgumentException("车次须有2至200个站点");
-        if (capacity.weightKg() == null || capacity.volumeCbm() == null || capacity.palletSpaces() <= 0 || capacity.weightKg().signum() <= 0 || capacity.volumeCbm().signum() <= 0) {
+        if (capacity.palletSpaces() <= 0 || capacity.weightKg().signum() <= 0 || capacity.volumeCbm().signum() <= 0) {
            throw new IllegalArgumentException("车辆容量必须大于零");
        }
        var numbers = new HashSet<String>();
        for (Booking booking : bookings) {
            Objects.requireNonNull(booking, "booking");
-            if (!actual && (booking.load().weightKg() == null || booking.load().volumeCbm() == null))
-                throw new IllegalArgumentException("计划承运货物须有重量和体积");
            if (!numbers.add(booking.bookingNo())) throw new IllegalArgumentException("承运明细重复分配");
            if (booking.deliveryIndex() >= stopCount) throw new IllegalArgumentException("承运站点不属于当前路线");
        }
        List<Segment> segments = new ArrayList<>();
        for (int index = 0; index < stopCount - 1; index++) {
            Load occupied = new Load(0, BigDecimal.ZERO, BigDecimal.ZERO);
-            BigDecimal knownWeight = BigDecimal.ZERO, knownVolume = BigDecimal.ZERO;
            for (Booking booking : bookings) {
-                if (booking.pickupIndex() <= index && index < booking.deliveryIndex()) {
-                    occupied = occupied.plus(booking.load());
-                    if (booking.load().weightKg() != null) knownWeight = knownWeight.add(booking.load().weightKg());
-                    if (booking.load().volumeCbm() != null) knownVolume = knownVolume.add(booking.load().volumeCbm());
-                }
+                if (booking.pickupIndex() <= index && index < booking.deliveryIndex()) occupied = occupied.plus(booking.load());
            }
            if (occupied.palletSpaces() > capacity.palletSpaces()
-                || knownWeight.compareTo(capacity.weightKg()) > 0
-                || knownVolume.compareTo(capacity.volumeCbm()) > 0) {
+                || occupied.weightKg().compareTo(capacity.weightKg()) > 0
+                || occupied.volumeCbm().compareTo(capacity.volumeCbm()) > 0) {
                throw new IllegalArgumentException("第" + (index + 1) + "段路线超过车辆托位、重量或容积限制");
            }
            Load remaining = new Load(capacity.palletSpaces() - occupied.palletSpaces(),
-                occupied.weightKg() == null ? null : capacity.weightKg().subtract(occupied.weightKg()),
-                occupied.volumeCbm() == null ? null : capacity.volumeCbm().subtract(occupied.volumeCbm()));
+                capacity.weightKg().subtract(occupied.weightKg()), capacity.volumeCbm().subtract(occupied.volumeCbm()));
            segments.add(new Segment(index, index + 1, occupied, remaining));
        }
        return List.copyOf(segments);
@@ -112,7 +112,7 @@ public final class FleetHandoverPolicy {
        return new Destination(cargo.customerId(), cargo.dispatchNo(), cargo.destinationKey());
    }
    private static boolean positive(Load load) {
-        return load != null && load.palletSpaces() > 0 && load.weightKg() != null && load.volumeCbm() != null && load.weightKg().signum() > 0 && load.volumeCbm().signum() > 0;
+        return load != null && load.palletSpaces() > 0 && load.weightKg().signum() > 0 && load.volumeCbm().signum() > 0;
    }
    private static boolean blank(String text) { return text == null || text.isBlank(); }
    private static IllegalArgumentException invalid(String message) { return new IllegalArgumentException(message); }
@@ -37,7 +37,7 @@ public class OutsourcedBusinessService {
    public HistoryPage history(OwnedBusinessModels.Actor actor,String number,Integer page,Integer size) {
        var result=queries.history(actor,number,page,size,SCOPE);
        return new HistoryPage(result.records().stream().map(h->new History(h.eventSource(),h.recordVersion(),h.dispatchRecordVersion(),h.action(),h.operatorName(),
-            h.occurredAt(),h.reason(),h.operations()==null?null:operations(h.operations()),h.photos().stream().filter(p->"LOADING".equals(p.category())).map(this::photo).toList())).toList(),result.page(),result.size(),result.total());
+            h.occurredAt(),h.reason(),h.operations()==null?null:operations(h.operations()),h.photos().stream().map(this::photo).toList())).toList(),result.page(),result.size(),result.total());
    }
    /** 外配只生成金额和到达的规范内部请求，不接收归属或隐藏油耗写入。 */
    public Detail save(OwnedBusinessModels.Actor actor,String number,SaveOperations request) {
@@ -71,11 +71,11 @@ public class OutsourcedBusinessService {
    }
    /** 回执公开形状不带内部里程、油耗或油耗照片摘要。 */
    private Detail detail(OwnedBusinessModels.Detail detail) {
-        return new Detail(row(detail.row(),projection.carrierName(detail)),detail.dispatch(),detail.cargo(),detail.photos().stream().filter(p->"LOADING".equals(p.category())).map(this::photo).toList());
+        return new Detail(row(detail.row(),projection.carrierName(detail)),detail.dispatch(),detail.cargo(),detail.photos().stream().map(this::photo).toList());
    }
    /** 临时车辆合法保留空vehicleId；承运商缺失保留null供页面显示破折号。 */
    private Row row(OwnedBusinessModels.Row r,String carrierName) {
-        if(!java.util.Set.of("OWNED","DISPATCHED").contains(r.vehicle().ownership()))throw conflict("外配运营快照的车辆归属或照片不合法");
+        if(!"DISPATCHED".equals(r.vehicle().ownership()) || r.photoSummary().fuelCount()!=0)throw conflict("外配运营快照与冻结归属不一致");
        return new Row(r.dispatchNo(),r.stage(),r.plannedDepartureAt(),r.loadingCompletedAt(),r.departedAt(),r.deliveryCompletedAt(),r.origin(),
            new Vehicle(r.vehicle().vehicleId(),r.vehicle().plate(),r.vehicle().ownership(),carrierName==null || carrierName.isBlank()?null:carrierName),r.driver(),r.destinations(),
            r.actualPalletCount(),operations(r.operations()),r.unitPrice(),r.recordVersion(),r.dispatchRecordVersion(),new PhotoSummary(r.photoSummary().loadingCount()),r.actions(),r.sourceIssues());
@@ -85,7 +85,7 @@ public class OutsourcedBusinessService {
        if(ops.actualDistanceMiles()!=null || ops.fuelConsumptionLitresPer100Km()!=null)throw conflict("外配业务不能包含里程或油耗登记");
        return new Operations(ops.money(),ops.arrivals());
    }
-    /** 外配照片枚举只有五框，排车油耗图片保留在共用记录中但不在外配入口输出。 */
+    /** 外配照片枚举只有五框，异常油耗历史不能借复用向外输出。 */
    private Photo photo(OwnedBusinessModels.Photo p) {
        SCOPE.requireSlot(p.slot());return new Photo(PhotoSlot.valueOf(p.slot().name()),p.category(),p.fileId(),p.fileName(),p.contentType(),p.sizeBytes(),p.uploadedAt(),p.savedAt());
    }
@@ -1,76 +0,0 @@
-package com.baiyue.lastleg.fleet.ownedbusiness.controller;
-
-import com.baiyue.common.core.api.ApiResponse;
-import com.baiyue.common.security.AuthenticatedUser;
-import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessModels.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessScope;
-import com.baiyue.lastleg.fleet.ownedbusiness.service.*;
-import jakarta.validation.Valid;
-import jakarta.validation.constraints.*;
-import org.springframework.http.*;
-import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.security.core.annotation.AuthenticationPrincipal;
-import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-import java.util.List;
-
-/** 排车资料入口复用车队原照片记录；签收及BOL仍由派送单管理。 */
-@RestController
-@Validated
-@RequestMapping("/api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents")
-public class DispatchVehicleDocumentController {
-    private static final OwnedBusinessScope SCOPE=OwnedBusinessScope.DISPATCH;
-    private final OwnedBusinessQueryService queries;
-    private final OwnedBusinessPhotoService photos;
-    private final OwnedBusinessSupport access;
-    /** 沿已有服务复用来源校验、文件归属、版本和命令账本。 */
-    public DispatchVehicleDocumentController(OwnedBusinessQueryService queries,OwnedBusinessPhotoService photos,OwnedBusinessSupport access) {
-        this.queries=queries;this.photos=photos;this.access=access;
-    }
-    public record Documents(String dispatchNo,String recordVersion,boolean editable,List<Photo> photos) {}
-    /** 只输出油耗资料，避免把车队签收照片当作派送签收文件。 */
-    private Documents documents(Detail value) {
-        return new Documents(value.row().dispatchNo(),value.row().recordVersion(),value.row().actions().upload().allowed(),
-            value.photos().stream().filter(p->"FUEL".equals(p.category())).toList());
-    }
-    /** 排车列表权限包含车辆资料只读，不扩大派送单客户访问权限。 */
-    @GetMapping
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ApiResponse<Documents> get(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo) {
-        return ApiResponse.success(documents(queries.detail(access.actor(user,SCOPE),dispatchNo,SCOPE)));
-    }
-    /** 上传和引用保存分开，沿原请求键防止重传。 */
-    @PostMapping(value="/{slot}/uploads",consumes=MediaType.MULTIPART_FORM_DATA_VALUE)
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<Photo> upload(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable PhotoSlot slot,
-        @RequestParam @Size(min=8,max=128) String idempotencyKey,@RequestPart("file") MultipartFile file) {
-        return ApiResponse.success(photos.upload(access.actor(user,SCOPE),dispatchNo,slot,idempotencyKey,file,SCOPE));
-    }
-    /** 只更新既有附加资料版本，不修改排车阶段或签收状态。 */
-    @PutMapping("/{slot}")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<Documents> bind(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable PhotoSlot slot,@Valid @RequestBody BindPhoto request) {
-        return ApiResponse.success(documents(photos.bind(access.actor(user,SCOPE),dispatchNo,slot,request,SCOPE)));
-    }
-    /** 预览只读取本车当前已经绑定的照片。 */
-    @GetMapping("/{slot}/files/{fileId}/content")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:list')")
-    public ResponseEntity<byte[]> content(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable PhotoSlot slot,@PathVariable @Positive long fileId) {
-        var value=photos.content(access.actor(user,SCOPE),dispatchNo,slot,fileId,null,SCOPE);
-        return ResponseEntity.ok().cacheControl(CacheControl.noStore()).contentType(MediaType.parseMediaType(value.photo().contentType()))
-            .header("X-Content-Type-Options","nosniff").body(value.content());
-    }
-    /** 恢复仅返回油耗上传结果，不通过排车入口暴露其他运营命令。 */
-    @GetMapping("/uploads/{idempotencyKey}")
-    @PreAuthorize("hasAuthority('platform:overseas-warehouse:dispatch:edit')")
-    public ApiResponse<Photo> recover(@AuthenticationPrincipal AuthenticatedUser user,@PathVariable String dispatchNo,@PathVariable String idempotencyKey) {
-        var actor=access.actor(user,SCOPE);
-        access.require(actor,SCOPE.uploadPermission());
-        var command=photos.command(actor,dispatchNo,idempotencyKey,SCOPE);
-        if(!"UPLOAD_PHOTO".equals(command.action()) || !"SUCCEEDED".equals(command.state()) || command.result()==null)
-            throw OwnedBusinessSupport.conflict("原上传结果尚未确认，请保留原请求稍后核对");
-        var value=access.read(access.write(command.result()),Photo.class);SCOPE.requireSlot(value.slot());
-        return ApiResponse.success(value);
-    }
-}
@@ -7,26 +7,8 @@ import java.util.List;
 /** 在原排车事实之上做自有运营分页，不复制或推进履约模型。 */
@Mapper
 public interface OwnedBusinessQueryMapper {
-    /** 拼车须实收且来源仍在本车；标识按完整字节精确比较，512字节覆盖128字符utf8mb4，避免列排序规则冲突或截断。 */
-    String POOLED_CARGO="""
-        EXISTS (SELECT 1 FROM ll_fleet_external_booking b
-          JOIN ll_warehouse_transfer_order incoming ON CAST(incoming.customer_id AS BINARY(512))=CAST(b.customer_id AS BINARY(512))
-            AND CAST(incoming.transfer_no AS BINARY(512))=CAST(b.incoming_no AS BINARY(512))
-          WHERE b.trip_id=d.trip_id AND CAST(b.dispatch_no AS BINARY(512))=CAST(d.dispatch_no AS BINARY(512)) AND b.offer_id IS NOT NULL
-            AND b.status='BOUND' AND b.receipt_json IS NOT NULL
-            AND EXISTS (SELECT 1 FROM ll_dispatch_item cargo
-              JOIN ll_inbound_plan_pallet_allocation allocation ON allocation.pallet_id=cargo.plan_pallet_id
-                AND allocation.plan_id=cargo.plan_id AND CAST(allocation.customer_id AS BINARY(512))=CAST(cargo.customer_id AS BINARY(512))
-              JOIN ll_inbound_plan_line line ON line.id=allocation.line_id AND line.plan_id=cargo.plan_id
-              WHERE cargo.dispatch_order_id=d.id AND CAST(cargo.customer_id AS BINARY(512))=CAST(b.customer_id AS BINARY(512))
-                AND CAST(line.customer_id AS BINARY(512))=CAST(b.customer_id AS BINARY(512))
-                AND CAST(line.inbound_code AS BINARY(512))=CAST(incoming.inbound_code AS BINARY(512))
-                AND cargo.warehouse_pallet_id IS NOT NULL AND cargo.package_count>0))
-        """;
    String SOURCE="""
-        SELECT
-        """+POOLED_CARGO+" AS pooled_cargo,"+"""
-        d.id,d.dispatch_no,d.status,d.stage,d.record_version,d.overseas_warehouse_id,
+        SELECT d.id,d.dispatch_no,d.status,d.stage,d.record_version,d.overseas_warehouse_id,
        d.overseas_warehouse_code,d.overseas_warehouse_name,d.planned_departure_at,d.loading_completed_at,
        d.departed_at,d.delivery_completed_at,d.loading_completion_hash,d.loading_confirmation_json,d.resources_json,
        o.vehicle_id AS owned_vehicle_id,o.resource_mode AS owned_resource_mode,
@@ -38,12 +20,10 @@ public interface OwnedBusinessQueryMapper {
    String FILTER="""
        d.status='ACTIVE' AND d.stage IN ('AFTER_LOADING','DELIVERING','DELIVERED')
        AND d.loading_completed_at IS NOT NULL AND d.loading_confirmation_json IS NOT NULL
-        AND o.vehicle_ownership IN ('OWNED','DISPATCHED')
+        AND o.vehicle_ownership=#{q.scope.ownership}
        AND CAST(o.loading_completion_hash AS BINARY(128))=CAST(d.loading_completion_hash AS BINARY(128))
        AND o.loading_completed_at=d.loading_completed_at
-        AND (o.resource_mode='MASTER' OR (o.vehicle_ownership='DISPATCHED' AND o.resource_mode='EXTERNAL'))
-        AND <if test='!q.scope.pooledCargo'>NOT</if>
-        """+POOLED_CARGO+"""
+        AND (o.resource_mode='MASTER' OR (#{q.scope.ownership}='DISPATCHED' AND o.resource_mode='EXTERNAL'))
        <if test='q.from != null'> AND d.planned_departure_at &gt;= #{q.from}</if>
        <if test='q.to != null'> AND d.planned_departure_at &lt; #{q.to}</if>
        <if test='q.stage != null'> AND d.stage=#{q.stage}</if>
@@ -14,7 +14,6 @@ public final class OwnedBusinessRows {
        private LocalDateTime ownershipCapturedAt,loadingCompletedAt;
    }
    @Data public static class Source {
-        private Boolean pooledCargo;
        private Long id,recordVersion;
        private String dispatchNo,status,stage,overseasWarehouseId,overseasWarehouseCode,overseasWarehouseName;
        private String loadingCompletionHash,loadingConfirmationJson,resourcesJson;
@@ -6,23 +6,21 @@ import com.baiyue.common.core.api.ResultCode;

 /** 仅服务端固定入口选择的作用域；不得成为浏览器请求字段或权限别名。 */
 public enum OwnedBusinessScope {
-    OWNED(false,"platform:fleet:owned-business:"),
-    OUTSOURCED(true,"platform:fleet:outsourced-business:"),
-    DISPATCH(false,"platform:overseas-warehouse:dispatch:");
-    private final boolean pooledCargo;
-    private final String prefix;
-    /** 业务入口按是否实际接入拼车货物分类，与车辆归属独立。 */
-    OwnedBusinessScope(boolean pooledCargo,String prefix){this.pooledCargo=pooledCargo;this.prefix=prefix;}
-    /** SQL绑定服务端固定分类，不接受浏览器指定作用域。 */
-    public boolean isPooledCargo(){return pooledCargo;}
+    OWNED("OWNED","platform:fleet:owned-business:"),
+    OUTSOURCED("DISPATCHED","platform:fleet:outsourced-business:");
+    private final String ownership,prefix;
+    /** 车辆归属与入口权限一一固定，不能由请求指定。 */
+    OwnedBusinessScope(String ownership,String prefix){this.ownership=ownership;this.prefix=prefix;}
+    /** SQL仅绑定此可信枚举的归属值，不拼接客户端片段。 */
+    public String getOwnership(){return ownership;}
    /** 查看权限包含本作用域详情、历史和照片读取。 */
    public String listPermission(){return prefix+"list";}
    /** 运营写权限独立，外配权限不映射成自有权限。 */
    public String editPermission(){return prefix+"edit";}
    /** 照片写权限独立，不扩大到原排车。 */
-    public String uploadPermission(){return prefix+(this==DISPATCH?"edit":"upload");}
+    public String uploadPermission(){return prefix+"upload";}
    /** 外配只支持装车五框，服务调用同样不能绕过。 */
-    public void requireSlot(PhotoSlot slot){if(slot==null || this==OUTSOURCED && !"LOADING".equals(slot.category()) || this==DISPATCH && !"FUEL".equals(slot.category()))throw new BizException(ResultCode.BAD_REQUEST,"当前业务不支持该照片框");}
+    public void requireSlot(PhotoSlot slot){if(slot==null || this==OUTSOURCED && !"LOADING".equals(slot.category()))throw new BizException(ResultCode.BAD_REQUEST,"当前业务不支持该照片框");}
    /** 不存在只显示当前业务归属，不泄露内部身份。 */
-    public BizException missing(){return new BizException(ResultCode.NOT_FOUND,this==DISPATCH?"排车单不存在":"排车单不存在或不属于当前"+(this==OWNED?"自有业务":"外配任务"));}
+    public BizException missing(){return new BizException(ResultCode.NOT_FOUND,"排车单不存在或不属于当前"+(this==OWNED?"自有":"外配")+"业务");}
 }
@@ -1,29 +0,0 @@
-package com.baiyue.lastleg.fleet.ownedbusiness.port;
-
-import jakarta.validation.constraints.*;
-import java.util.List;
-import org.springframework.web.multipart.MultipartFile;
-
-/** 整车装车资料公开端口；排车只组合资料事实，不读取车队持久化实现。 */
-public interface DispatchLoadingPhotoPort {
-    enum Slot { LOADING_SCENE, LOADING_LIST, PRE_DEPARTURE_CHECK, DRIVER_LICENSE, RECEIPT }
-    record Photo(Slot slot,String category,String fileId,String fileName,String contentType,String sizeBytes,String uploadedAt,String savedAt) {}
-    record BindPhoto(@NotBlank String recordVersion,@NotBlank @Size(min=8,max=128) String idempotencyKey,@NotBlank String fileId) {}
-    record State(String recordVersion,List<Photo> photos) {}
-    record Documents(String dispatchNo,String recordVersion,String dispatchRecordVersion,String stage,boolean editable,boolean complete,List<Photo> photos) {}
-    record Download(Photo photo,byte[] content) {}
-    /** 只读取原整车附加资料版本与五框，不初始化记录。 */
-    State read(long dispatchId);
-    /** 上传保存原请求意图；不提前计入已保存照片。 */
-    Photo upload(long dispatchId,String operator,Slot slot,String key,MultipartFile file);
-    /** 仅原操作者可恢复原上传结果。 */
-    Photo recover(long dispatchId,String operator,String key);
-    /** 先校验原槽位、完整载荷与操作者；无原成功命令时返回null。 */
-    Documents replayBind(long dispatchId,String operator,Slot slot,BindPhoto request);
-    /** 调用者已持排车父锁；保存照片、资料版本及历史但不单独提交事务。 */
-    State bind(long dispatchId,String operator,Slot slot,BindPhoto request);
-    /** 与绑定及自动发车共同提交完整原结果。 */
-    void recordBind(long dispatchId,String operator,Slot slot,BindPhoto request,Documents result);
-    /** 文件只可从本车当前已绑定槽位下载。 */
-    Download content(long dispatchId,Slot slot,long fileId);
-}
@@ -1,124 +0,0 @@
-package com.baiyue.lastleg.fleet.ownedbusiness.service;
-
-import com.baomidou.mybatisplus.core.toolkit.IdWorker;
-import com.baiyue.common.core.api.ResultCode;
-import com.baiyue.common.core.exception.BizException;
-import com.baiyue.lastleg.fleet.ownedbusiness.gateway.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessModels;
-import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessModels.PhotoSlot;
-import com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessRows;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort;
-import com.baiyue.lastleg.fleet.ownedbusiness.repository.OwnedBusinessRepository;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-import java.io.IOException;
-import java.time.Instant;
-import java.util.*;
-import static com.baiyue.lastleg.fleet.ownedbusiness.service.OwnedBusinessSupport.*;
-
-/** 在原照片表和命令账本实现装车资料端口，不反向调用排车履约服务。 */
-@Service
-public class DispatchLoadingPhotoAdapter implements DispatchLoadingPhotoPort {
-    private final OwnedBusinessRepository repository;
-    private final OwnedBusinessCommandService commands;
-    private final OwnedBusinessProjection projection;
-    private final OwnedBusinessSupport codec;
-    private final OwnedBusinessFileGateway files;
-    /** 复用现有照片、版本、历史及文件归属校验。 */
-    public DispatchLoadingPhotoAdapter(OwnedBusinessRepository repository,OwnedBusinessCommandService commands,
-        OwnedBusinessProjection projection,OwnedBusinessSupport codec,OwnedBusinessFileGateway files) {
-        this.repository=repository;this.commands=commands;this.projection=projection;this.codec=codec;this.files=files;
-    }
-    public record Binding(Slot slot,BindPhoto request) {}
-    /** GET只读；首次保存前资料版本为0。 */
-    @Override public State read(long id) {
-        var row=repository.record(id);
-        return new State(row==null?"0":row.getRecordVersion().toString(),projection.photos(row).stream()
-            .filter(p->"LOADING".equals(p.category())).map(this::publicPhoto).toList());
-    }
-    /** 先落稳定上传意图，再请求File；未知结果不允许换键重传。 */
-    @Override public Photo upload(long id,String operator,Slot slot,String key,MultipartFile multipart) {
-        codec.key(key);var originalSlot=slot(slot);
-        if(multipart==null || multipart.isEmpty() || multipart.getSize()>HttpOwnedBusinessFileGateway.MAX_SIZE)throw bad("照片须为非空JPG/PNG，最大10MiB");
-        byte[] bytes;try{bytes=multipart.getBytes();}catch(IOException failure){throw bad("无法读取待上传照片");}
-        var payload=new OwnedBusinessFileGateway.Upload(multipart.getOriginalFilename(),multipart.getContentType(),bytes);
-        HttpOwnedBusinessFileGateway.validate(payload);
-        var identity=new OwnedBusinessPhotoService.UploadIdentity(originalSlot,payload.fileName(),payload.contentType(),bytes.length,codec.digest(bytes));
-        var reservation=commands.reserveUpload(id,operator(operator),key,identity);
-        if(!reservation.created())return uploaded(reservation.command());
-        try {
-            var result=photo(originalSlot,files.upload(id,originalSlot,operator,payload));
-            commands.finishUpload(reservation.command(),"SUCCEEDED",result,null);return publicPhoto(result);
-        } catch(RuntimeException failure) {
-            try{commands.finishUpload(reservation.command(),"UNKNOWN_RESULT",null,"DISPATCH_LOADING_UPLOAD_UNKNOWN");}
-            catch(RuntimeException recording){failure.addSuppressed(recording);}
-            throw conflict("照片上传结果未知，请保留原请求键核对");
-        }
-    }
-    /** 上传结果仅限本车原操作者及装车槽位。 */
-    @Override public Photo recover(long id,String operator,String key) {
-        codec.key(key);var command=commands.existing(id,key,operator(operator));
-        if(command==null)throw new BizException(ResultCode.NOT_FOUND,"未找到本车原上传请求");return uploaded(command);
-    }
-    /** 完整原结果先于当前资料版本比较，防止重复推进。 */
-    @Override public Documents replayBind(long id,String operator,Slot slot,BindPhoto request) {
-        validate(slot,request);var old=commands.existing(id,request.idempotencyKey(),operator(operator));
-        if(old==null)return null;
-        commands.same(old,"BIND_LOADING_DOCUMENT",codec.version(request.recordVersion()),new Binding(slot,request));
-        if(!"SUCCEEDED".equals(old.getStatus()))throw conflict("原资料保存结果尚未确认");return codec.read(old.getResultJson(),Documents.class);
-    }
-    /** 父排车锁由调用者持有；附加版本竞争与最后一张发车失败沿外层事务回滚。 */
-    @Override @Transactional(propagation=Propagation.MANDATORY,isolation=Isolation.READ_COMMITTED)
-    public State bind(long id,String operator,Slot slot,BindPhoto request) {
-        validate(slot,request);long version=codec.version(request.recordVersion());var originalSlot=slot(slot);
-        var verified=photo(originalSlot,files.metadata(id,originalSlot,codec.version(request.fileId())));
-        var seed=new OwnedBusinessRows.Record();seed.setId(IdWorker.getId());seed.setDispatchId(id);
-        seed.setCreatedBy(operator);seed.setUpdatedBy(operator);seed.setCreatedAt(codec.utc(Instant.now()));seed.setUpdatedAt(seed.getCreatedAt());
-        var row=repository.lock(seed);
-        if(row==null || row.getRecordVersion()==null || row.getRecordVersion()!=version)throw conflict("装车资料已被其他操作更新，请刷新后核对");
-        var photos=new EnumMap<PhotoSlot,OwnedBusinessModels.Photo>(PhotoSlot.class);for(var p:projection.photos(row))photos.put(p.slot(),p);
-        photos.put(originalSlot,new OwnedBusinessModels.Photo(originalSlot,originalSlot.category(),verified.fileId(),verified.fileName(),verified.contentType(),verified.sizeBytes(),verified.uploadedAt(),Instant.now().toString()));
-        row.setPhotosJson(codec.write(List.copyOf(photos.values())));row.setRecordVersion(Math.addExact(version,1));row.setUpdatedBy(operator);row.setUpdatedAt(codec.utc(Instant.now()));
-        if(repository.update(row,version)!=1)throw conflict("装车资料版本竞争失败");
-        var history=new OwnedBusinessRows.History();history.setId(IdWorker.getId());history.setDispatchId(id);history.setRecordVersion(row.getRecordVersion());
-        history.setAction("BIND_LOADING_DOCUMENT");history.setOperatorId(operator);history.setReason("保存装车照片 "+(slot.ordinal()+1));history.setOccurredAt(row.getUpdatedAt());
-        history.setSnapshotJson(codec.write(new OwnedBusinessModels.Snapshot(projection.operations(row),projection.photos(row),operator)));repository.history(history);
-        return read(id);
-    }
-    /** 保存调用者提供的最终阶段，命令与资料、派送同事务提交。 */
-    @Override @Transactional(propagation=Propagation.MANDATORY)
-    public void recordBind(long id,String operator,Slot slot,BindPhoto request,Documents result) {
-        commands.success(id,operator(operator),request.idempotencyKey(),"BIND_LOADING_DOCUMENT",codec.version(request.recordVersion()),new Binding(slot,request),result);
-    }
-    /** 下载仅允许当前已保存引用，不接受未绑定上传或其他车文件。 */
-    @Override public Download content(long id,Slot slot,long fileId) {
-        var originalSlot=slot(slot);var photo=projection.photos(repository.record(id)).stream()
-            .filter(p->p.slot()==originalSlot && String.valueOf(fileId).equals(p.fileId())).findFirst()
-            .orElseThrow(()->new BizException(ResultCode.NOT_FOUND,"本车未绑定该装车照片"));
-        return new Download(publicPhoto(photo),files.content(id,originalSlot,fileId));
-    }
-    /** 原五框技术名保持文件归属，拒绝油耗框作为装车资料。 */
-    private PhotoSlot slot(Slot slot){if(slot==null)throw bad("请选择有效的装车照片框");return PhotoSlot.valueOf(slot.name());}
-    /** 版本0合法，文件编号必须为正且请求键不得缺失。 */
-    private void validate(Slot slot,BindPhoto request) {
-        slot(slot);if(request==null)throw bad("照片绑定请求缺失");codec.key(request.idempotencyKey());codec.version(request.recordVersion());
-        if(codec.version(request.fileId())<=0)throw bad("文件编号无效");
-    }
-    /** 账本只消费可信操作者；平台/PDA权限在排车入口复核。 */
-    private OwnedBusinessModels.Actor operator(String operator){return new OwnedBusinessModels.Actor(operator,operator,Set.of());}
-    /** 回执必须是已知成功上传，其他类别或未明确结果不得充数。 */
-    private Photo uploaded(OwnedBusinessRows.Command command) {
-        if(!"UPLOAD_PHOTO".equals(command.getAction()) || !"SUCCEEDED".equals(command.getStatus()) || command.getResultJson()==null)throw conflict("原上传结果尚未确认，请保留原请求");
-        var value=codec.read(command.getResultJson(),OwnedBusinessModels.Photo.class);
-        if(!"LOADING".equals(value.category()))throw bad("原上传不是装车照片");return publicPhoto(value);
-    }
-    /** 外部事实仅投影照片字段，不暴露持久化记录。 */
-    private Photo publicPhoto(OwnedBusinessModels.Photo photo) {
-        return new Photo(Slot.valueOf(photo.slot().name()),photo.category(),photo.fileId(),photo.fileName(),photo.contentType(),photo.sizeBytes(),photo.uploadedAt(),photo.savedAt());
-    }
-    /** 上传回执不伪造保存时间。 */
-    private OwnedBusinessModels.Photo photo(PhotoSlot slot,OwnedBusinessFileGateway.Evidence value) {
-        return new OwnedBusinessModels.Photo(slot,slot.category(),Long.toString(value.fileId()),value.fileName(),value.contentType(),Long.toString(value.sizeBytes()),value.uploadedAt(),null);
-    }
-}
@@ -53,7 +53,8 @@ public class OwnedBusinessProjection {
        var resources=codec.read(source.getResourcesJson(),Resources.class);
        if(resources.vehicle()==null)throw OwnedBusinessSupport.conflict("原车辆快照缺失");
        var ops=operations(record);var photos=photos(record);int pallets=palletCount(source);
-        if(scope==OwnedBusinessScope.OUTSOURCED && (ops.actualDistanceMiles()!=null || ops.fuelConsumptionLitresPer100Km()!=null))throw OwnedBusinessSupport.conflict("外配运营记录含不支持的里程、油耗或照片");
+        if(scope==OwnedBusinessScope.OUTSOURCED && (ops.actualDistanceMiles()!=null || ops.fuelConsumptionLitresPer100Km()!=null
+            || photos.stream().anyMatch(p->!"LOADING".equals(p.category()))))throw OwnedBusinessSupport.conflict("外配运营记录含不支持的里程、油耗或照片");
        var arrivals=new HashMap<String,String>();for(var a:ops.arrivals())arrivals.put(a.destinationKey(),a.actualArrivedAt());
        var destinations=new LinkedHashMap<String,Destination>();
        for(var item:cargo) {
@@ -67,7 +68,7 @@ public class OwnedBusinessProjection {
        return new Row(source.getDispatchNo(),Stage.valueOf(source.getStage()),codec.iso(source.getPlannedDepartureAt()),
            codec.iso(source.getLoadingCompletedAt()),codec.iso(source.getDepartedAt()),codec.iso(source.getDeliveryCompletedAt()),
            new Origin(source.getOverseasWarehouseId(),source.getOverseasWarehouseCode(),source.getOverseasWarehouseName()),
-            new Vehicle(resources.vehicle().vehicleId()==null?null:String.valueOf(resources.vehicle().vehicleId()),resources.vehicle().plate(),source.getOwnedVehicleOwnership()),
+            new Vehicle(resources.vehicle().vehicleId()==null?null:String.valueOf(resources.vehicle().vehicleId()),resources.vehicle().plate(),scope.getOwnership()),
            new Driver(driver==null?null:driver.name(),driver==null?null:driver.phone()),List.copyOf(destinations.values()),pallets,ops,price,
            record==null?"0":String.valueOf(record.getRecordVersion()),String.valueOf(source.getRecordVersion()),
            new PhotoSummary((int)photos.stream().filter(p->"LOADING".equals(p.category())).count(),(int)photos.stream().filter(p->"FUEL".equals(p.category())).count()),
@@ -17,7 +17,7 @@ import java.util.stream.Collectors;
 import static com.baiyue.lastleg.fleet.ownedbusiness.service.OwnedBusinessSupport.*;
 import static com.baiyue.lastleg.fleet.ownedbusiness.model.OwnedBusinessModels.*;

-/** 装车后按实际拼车货物分组；车辆归属仅保留原装车证据。 */
+/** 自有车辆装车后视图；无归属快照的旧单不在GET时回填。 */
@Service
 public class OwnedBusinessQueryService {
    private final OwnedBusinessRepository repository;
@@ -61,7 +61,7 @@ public class OwnedBusinessQueryService {
    /** 对原排车详情做组合，不创建第二份主单或履约状态。 */
    @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
    public Detail detail(Actor actor,String number){codec.require(actor,LIST);return detailForWrite(actor,requireOwned(number));}
-    /** 外配入口只读实际拼车任务，不能借自有权限取得原详情。 */
+    /** 外配入口只能读取其冻结归属，不能借自有权限取得原详情。 */
    @Transactional(readOnly=true,isolation=Isolation.REPEATABLE_READ)
    public Detail detail(Actor actor,String number,OwnedBusinessScope scope){codec.require(actor,scope.listPermission());return detailForWrite(actor,requireScoped(number,scope),scope);}
    /** 写入已经有独立权限；回执仍由相同真实来源组成。 */
@@ -82,7 +82,7 @@ public class OwnedBusinessQueryService {
        if(number==null || number.isBlank() || number.length()>128)throw bad("请指定排车单号");
        var source=repository.source(number);if(source==null)throw missing();eligible(source,OwnedBusinessScope.OWNED);return source;
    }
-    /** 共享附加表按实际拼车分类隔离，不接受浏览器业务域参数。 */
+    /** 共享附加表仍按原装车归属隔离，不接受浏览器业务域参数。 */
    public Source requireScoped(String number,OwnedBusinessScope scope) {
        if(scope==OwnedBusinessScope.OWNED)return requireOwned(number);
        if(number==null || number.isBlank() || number.length()>128)throw bad("请指定排车单号");
@@ -91,16 +91,13 @@ public class OwnedBusinessQueryService {
    /** 阶段、真实装车hash及车辆快照须与捕获证据一致。 */
    private void eligible(Source source,OwnedBusinessScope scope) {
        if(source.getOwnedVehicleOwnership()==null)throw conflict("本单缺少装车时车辆归属证据，不能归入"+(scope==OwnedBusinessScope.OWNED?"自有":"外配")+"业务");
-        if(!Set.of("OWNED","DISPATCHED").contains(source.getOwnedVehicleOwnership()))throw conflict("装车车辆归属不合法");
-        if(source.getPooledCargo()==null)throw conflict("本单缺少实际拼车分类依据");
-        if(scope!=OwnedBusinessScope.DISPATCH && scope.isPooledCargo()!=source.getPooledCargo())throw scope.missing();
+        if(!scope.getOwnership().equals(source.getOwnedVehicleOwnership()))throw scope.missing();
        if(!"ACTIVE".equals(source.getStatus()) || source.getStage()==null || !Set.of("AFTER_LOADING","DELIVERING","DELIVERED").contains(source.getStage())
            || source.getLoadingCompletedAt()==null || source.getLoadingConfirmationJson()==null)throw conflict("本单尚无合法装车完成事实");
-        if(scope==OwnedBusinessScope.DISPATCH && !Set.of("DELIVERING","DELIVERED").contains(source.getStage()))throw conflict("仅派送中和配送完成可管理车辆资料");
        var resource=codec.read(source.getResourcesJson(),DispatchContracts.Resources.class).vehicle();
        boolean master=resource!=null && resource.mode()!=null && "MASTER".equals(resource.mode().name()) && "MASTER".equals(source.getOwnedResourceMode())
            && resource.vehicleId()!=null && Objects.equals(source.getOwnedVehicleId(),resource.vehicleId());
-        boolean external="DISPATCHED".equals(source.getOwnedVehicleOwnership()) && resource!=null && resource.mode()!=null && "EXTERNAL".equals(resource.mode().name())
+        boolean external=scope==OwnedBusinessScope.OUTSOURCED && resource!=null && resource.mode()!=null && "EXTERNAL".equals(resource.mode().name())
            && "EXTERNAL".equals(source.getOwnedResourceMode()) && resource.vehicleId()==null && source.getOwnedVehicleId()==null;
        if((!master && !external) || !Objects.equals(source.getOwnedLoadingCompletionHash(),source.getLoadingCompletionHash())
            || !Objects.equals(source.getOwnedLoadingCompletedAt(),source.getLoadingCompletedAt()))throw conflict("车辆归属与原装车事实不一致");
@@ -39,9 +39,6 @@ public interface FleetPickupMapper extends BaseMapper<FleetPickupTask> {
    /** 解除计划中的取货关联，保留历史后允许再次安排。 */
    @Update("UPDATE ll_fleet_pickup_task SET trip_no=NULL,status='WAITING',updated_at=CURRENT_TIMESTAMP WHERE trip_no=#{tripNo} AND status='ASSIGNED'")
    int unassign(@Param("tripNo") String tripNo);
-    /** 原单同时取消时保留车次关联供详情和审计追溯，不再回到待安排。 */
-    @Update("UPDATE ll_fleet_pickup_task SET status='CANCELLED',updated_at=CURRENT_TIMESTAMP WHERE trip_no=#{tripNo} AND status='ASSIGNED'")
-    int cancelTasks(@Param("tripNo") String tripNo);
    /** 不可变操作历史覆盖安排、解除、取货、到仓及结案。 */
    @Insert("INSERT INTO ll_fleet_pickup_history(customer_id,transfer_no,trip_no,action,operator_id,occurred_at,detail) VALUES(#{customer},#{number},#{trip},#{action},#{operator},CURRENT_TIMESTAMP,#{detail})")
    int history(@Param("customer") String customer,@Param("number") String number,@Param("trip") String trip,
@@ -24,10 +24,7 @@ public final class FleetPickupModels {
                         @NotBlank @Size(min=8,max=128) String idempotencyKey) { }
    public record Command(@NotNull @Min(0) Long recordVersion,
                          @NotBlank @Size(min=8,max=128) String idempotencyKey,
-                          @NotBlank @Size(max=1000) String reason,List<@NotNull @Positive Long> evidenceFileIds) {
-        /** 无照片的非送仓命令保持原调用形式。 */
-        public Command(Long recordVersion,String idempotencyKey,String reason){this(recordVersion,idempotencyKey,reason,null);}
-    }
+                          @NotBlank @Size(max=1000) String reason) { }
    public record Pickup(@NotNull @Min(0) Long recordVersion,
                         @NotBlank @Size(min=8,max=128) String idempotencyKey,
                         @Min(1) @Max(5000) int actualPackages,
@@ -38,9 +35,6 @@ public final class FleetPickupModels {
                       String status, String tripNo, String vehiclePlate, String driverName, String driverPhone,
                       Instant plannedDepartureAt, Integer actualPackages, Instant pickedAt, Instant arrivedAt,
                       String remark, List<Evidence> evidence) { }
-    public record Evidence(String fileId, String fileName, String contentType, long sizeBytes,String phase) {
-        /** 旧取货凭证明确归入取货阶段，不冒充到仓照片。 */
-        public Evidence(String fileId,String fileName,String contentType,long sizeBytes){this(fileId,fileName,contentType,sizeBytes,"PICKUP");}
-    }
+    public record Evidence(String fileId, String fileName, String contentType, long sizeBytes) { }
    public record History(String action, String tripNo, String operatorId, Instant occurredAt, String detail) { }
 }
@@ -34,8 +34,6 @@ public class FleetPickupRepository {
    public FleetPickupTask lockTask(long id) { return mapper.lockTask(id); }
    /** 释放未开始的成员关联。 */
    public int unassign(String number) { return mapper.unassign(number); }
-    /** 联动取消保留原车次与转运单的可追溯关联。 */
-    public int cancelTasks(String number) { return mapper.cancelTasks(number); }
    /** 保存不可变业务操作记录。 */
    public void history(FleetPickupTask task,String action,String operator,String detail) { mapper.history(task.getCustomerId(),task.getTransferNo(),task.getTripNo(),action,operator,detail); }
    /** 核对旧拼车承运关系，防止同票走两条运输链。 */
@@ -28,13 +28,11 @@ public class FleetPickupService {
    private final VehicleRepository vehicles;
    private final TripOperationsEvidenceGateway files;
    private final ObjectMapper json;
-    private final PickupDepartureReview departureReview;
    /** 共用现有车次、司机资格、车辆占用及鉴权文件能力。 */
    public FleetPickupService(FleetPickupRepository repository,FleetTripService trips,FleetWarehouseDirectory warehouses,
-        DriverService drivers,VehicleRepository vehicles,TripOperationsEvidenceGateway files,ObjectMapper json,PickupDepartureReview departureReview) {
+        DriverService drivers,VehicleRepository vehicles,TripOperationsEvidenceGateway files,ObjectMapper json) {
        this.repository=repository;this.trips=trips;this.warehouses=warehouses;this.drivers=drivers;
        this.vehicles=vehicles;this.files=files;this.json=json;
-        this.departureReview=departureReview;
    }
    /** 审核通过的原单自动出现在候选中，客户自送和库存转运不参与。 */
    @Transactional(readOnly=true,isolation=org.springframework.transaction.annotation.Isolation.REPEATABLE_READ)
@@ -122,7 +120,6 @@ public class FleetPickupService {
        if(replayed(trip,request.idempotencyKey(),hash))return trips.detail(number);
        version(trip,request.recordVersion());
        if(!"PLANNED".equals(trip.getStatus()) || repository.tasks(number).isEmpty())throw conflict("仅有取货任务的计划车次可以发车");
-        departureReview.requireApproved(trip.getId());
        requireResources(trip);
        for(var task:repository.tasks(number))eligible(source(task.getCustomerId(),task.getTransferNo(),true));
        trip.setStatus("IN_TRANSIT");trip.setDepartedAt(now());
@@ -145,47 +142,28 @@ public class FleetPickupService {
        var trip=pickupTrip(number,true);String hash=commandHash("PICKED:"+customer+":"+transferNo,request);
        if(replayed(trip,request.idempotencyKey(),hash))return tasks(number);
        version(trip,request.recordVersion());var task=member(trip,customer,transferNo);
-        if(!Set.of("PLANNED","IN_TRANSIT").contains(trip.getStatus()) || !"ASSIGNED".equals(task.getStatus()))throw conflict("该单尚未处于可确认取货阶段");
-        if("PLANNED".equals(trip.getStatus()))departureReview.requireApproved(trip.getId());
-        if(request.actualPackages()<=0 || request.evidenceFileIds()==null || request.evidenceFileIds().isEmpty() || request.evidenceFileIds().size()>10)throw bad("请填写实提箱数并上传取货照片");
+        if(!"IN_TRANSIT".equals(trip.getStatus()) || !"ASSIGNED".equals(task.getStatus()))throw conflict("请先发车，且该单尚未确认取货");
        eligible(source(customer,transferNo,true));
        var evidence=request.evidenceFileIds().stream().distinct().map(id->{
            if(!repository.ownsUpload(task.getTransferOrderId(),number,id))throw bad("取货凭证不属于当前订单或车次");
            var file=files.metadata(trip.getId(),id);
-            if(file.contentType()==null || !file.contentType().startsWith("image/"))throw bad("请上传有效取货照片");
            return new FleetPickupModels.Evidence(String.valueOf(file.fileId()),file.fileName(),file.contentType(),file.sizeBytes());
        }).toList();
        task.setStatus("PICKED");task.setActualPackages(request.actualPackages());task.setPickedAt(now());
        task.setEvidenceJson(write(evidence));task.setRemark(blank(request.remark()));task.setUpdatedAt(now());repository.update(task);
        repository.history(task,"PICKED",operator,"实提"+request.actualPackages()+"箱；"+Objects.toString(task.getRemark(),""));
-        // 全车照片和实提数量核齐后自动进入派送中，不能以发车按钮代替取货照片。
-        if("PLANNED".equals(trip.getStatus()) && repository.tasks(number).stream().allMatch(row->"PICKED".equals(row.getStatus()))) {
-            requireResources(trip);trip.setStatus("IN_TRANSIT");trip.setDepartedAt(now());
-        }
        trips.recordExecution(trip,request.recordVersion(),"PICKUP_PICKED","确认原单取货",operator);
        repository.command(number,request.idempotencyKey(),hash);return tasks(number);
    }
-    /** 到仓照片独立归档，全部送仓后自动完成本次取货派送并开放PDA清点。 */
+    /** 到仓确认只开放 PDA 清点，不覆盖预报箱数和 SKU 件数。 */
    @Transactional
    public List<FleetPickupModels.Task> arrive(String number,String customer,String transferNo,String operator,FleetPickupModels.Command request) {
        var trip=pickupTrip(number,true);String hash=commandHash("ARRIVED:"+customer+":"+transferNo,request);
        if(replayed(trip,request.idempotencyKey(),hash))return tasks(number);
        version(trip,request.recordVersion());var task=member(trip,customer,transferNo);
        if(!"IN_TRANSIT".equals(trip.getStatus()) || !"PICKED".equals(task.getStatus()))throw conflict("请先确认该单已取货");
-        if(request.evidenceFileIds()==null || request.evidenceFileIds().isEmpty() || request.evidenceFileIds().size()>10)throw bad("请上传到仓照片");
-        var old=evidence(task);var arrival=new ArrayList<FleetPickupModels.Evidence>(old);
-        for(long id:request.evidenceFileIds().stream().distinct().toList()) {
-            if(!repository.ownsUpload(task.getTransferOrderId(),number,id) || old.stream().anyMatch(file->file.fileId().equals(String.valueOf(id))))throw bad("请上传本票新的到仓照片，不能复用取货照片");
-            var file=files.metadata(trip.getId(),id);
-            if(file.contentType()==null || !file.contentType().startsWith("image/"))throw bad("请上传有效到仓照片");
-            arrival.add(new FleetPickupModels.Evidence(String.valueOf(file.fileId()),file.fileName(),file.contentType(),file.sizeBytes(),"ARRIVAL"));
-        }
-        source(customer,transferNo,true);task.setStatus("ARRIVED");task.setArrivedAt(now());task.setEvidenceJson(write(arrival));task.setUpdatedAt(now());repository.update(task);
+        source(customer,transferNo,true);task.setStatus("ARRIVED");task.setArrivedAt(now());task.setUpdatedAt(now());repository.update(task);
        repository.history(task,"ARRIVED",operator,request.reason());
-        if(repository.tasks(number).stream().allMatch(row->"ARRIVED".equals(row.getStatus()))) {
-            trip.setStatus("COMPLETED");trip.setCompletedAt(now());
-            trip.setCompletionJson(write(new FleetCompletionModels.Completed(request.idempotencyKey(),hash,trip.getCompletedAt().toInstant(ZoneOffset.UTC),Instant.now(),operator,List.of())));
-        }
        trips.recordExecution(trip,request.recordVersion(),"PICKUP_ARRIVED",request.reason(),operator);
        repository.command(number,request.idempotencyKey(),hash);return tasks(number);
    }
@@ -1,7 +0,0 @@
-package com.baiyue.lastleg.fleet.pickup;
-
-/** 取货发车必须通过排车主单的本轮两级审核。 */
-public interface PickupDepartureReview {
-    /** 调用方已持车次锁，校验并锁定对应排车审核事实。 */
-    void requireApproved(long tripId);
-}
@@ -1,9 +0,0 @@
-package com.baiyue.lastleg.fleet.pickup;
-
-import java.util.List;
-
-/** 原单所属域负责取消未执行取货的转运业务，失败时整车取消回滚。 */
-public interface PickupOrderCancellation {
-    /** 调用方持有车次锁，按稳定来源顺序取消全部成员。 */
-    void cancel(List<FleetPickupModels.Source> sources,String tripNo,String operator,String reason);
-}
@@ -31,11 +31,7 @@ public class FleetBookingReservations {
    /** 使用当前自有货计划与全部未绑定预留计算区段，不重复计入待替换承运。 */
    public List<TripCapacityPolicy.Segment> segments(FleetTripEntity trip, FleetExecutionModels.PlannedLoad own,
        Long excludedId, FleetBookingEntity addition) {
-        return segments(trip,own.pallets(),excludedId,addition,false);
-    }
-    /** 已扫码装车无需重复测量，未知重量体积不计作可接运力。 */
-    public List<TripCapacityPolicy.Segment> actualSegments(FleetTripEntity trip,List<FleetExecutionModels.Measurement> pallets) {
-        return segments(trip,pallets,null,null,true);
+        return segments(trip,own.pallets(),excludedId,addition);
    }
    /** 已实收承运解除唯一排车后，自有货为零仍可按本票新实测和其他预留重新核容。 */
    public void requireReceiptCapacity(FleetTripEntity trip,FleetExecutionModels.Planning own,FleetBookingEntity row) {
@@ -44,20 +40,17 @@ public class FleetBookingReservations {
            throw conflict("请先重新核对自有货容量计划，再确认外接实收");
        // 空自有货只用于已有实收的重新确认；不创建计划、不允许首次实收跳过自有货计划。
        List<FleetExecutionModels.Measurement> pallets=releasedReceipt?List.of():own.capacityPlan().pallets();
-        segments(trip,pallets,row.getId(),row,false);
+        segments(trip,pallets,row.getId(),row);
    }
    /** 所有承诺使用同一容量计算，空自有货也必须保留其他承运占位及车辆上限。 */
    private List<TripCapacityPolicy.Segment> segments(FleetTripEntity trip,List<FleetExecutionModels.Measurement> own,
-        Long excludedId,FleetBookingEntity addition,boolean actual) {
+        Long excludedId,FleetBookingEntity addition) {
        var stops=stops(trip); var loads=new ArrayList<TripCapacityPolicy.Booking>();
        for (var pallet:own) loads.add(new TripCapacityPolicy.Booking("PALLET:"+pallet.warehousePalletId(),0,pallet.deliveryIndex(),
            new TripCapacityPolicy.Load(pallet.palletSpaces(),pallet.weightKg(),pallet.volumeCbm())));
        for(var row:new FleetBookingCargoRepository(bookings).listForTrip(trip.getId())) if(unbound(row) && !Objects.equals(row.getId(),excludedId)) add(loads,stops,row);
        if(addition!=null) add(loads,stops,addition);
-        try {
-            var capacity=new TripCapacityPolicy.Load(trip.getMaxPalletSpaces(),trip.getMaxLoadKg(),trip.getMaxVolumeCbm());
-            return actual?TripCapacityPolicy.calculateActual(stops.size(),capacity,loads):TripCapacityPolicy.calculate(stops.size(),capacity,loads);
-        }
+        try { return TripCapacityPolicy.calculate(stops.size(),new TripCapacityPolicy.Load(trip.getMaxPalletSpaces(),trip.getMaxLoadKg(),trip.getMaxVolumeCbm()),loads); }
        catch(IllegalArgumentException|ArithmeticException error){throw conflict(error.getMessage());}
    }
    public void requireReassignmentFits(FleetTripEntity trip, Integer spaces, java.math.BigDecimal weight, java.math.BigDecimal volume) {
@@ -303,8 +303,7 @@ public class FleetBookingService {
    private static void requireTrip(FleetTripEntity trip,long version){if("PICKUP".equals(trip.getTripPurpose()))throw conflict("取货车次不能承接出库拼车预订");if(!"PLANNED".equals(trip.getStatus()))throw conflict("仅计划中的车次允许管理外接预订");if(trip.getRecordVersion()!=version)throw conflict("车次已被修改，请刷新");}
    private static void requireVersion(FleetBookingEntity row,long version){if(row.getRecordVersion()!=version)throw conflict("外接预订已被修改，请刷新");}
    private String write(Object value){try{return json.writeValueAsString(value);}catch(Exception error){throw new IllegalStateException(error);}}
-    /** 请求对象排除重放元数据；排车来源键的数组必须保留全部元素及顺序。 */
-    private String hash(Object value){try{com.fasterxml.jackson.databind.JsonNode node=json.valueToTree(value);if(node instanceof ObjectNode object){object.remove("idempotencyKey");object.remove("tripRecordVersion");}return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(write(node).getBytes(StandardCharsets.UTF_8)));}catch(Exception error){throw new IllegalStateException(error);}}
+    private String hash(Object value){try{ObjectNode node=json.valueToTree(value);node.remove("idempotencyKey");node.remove("tripRecordVersion");return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(write(node).getBytes(StandardCharsets.UTF_8)));}catch(Exception error){throw new IllegalStateException(error);}}
    private static LocalDateTime now(){return LocalDateTime.now(ZoneOffset.UTC);}
    private static String trim(String value){return value==null||value.isBlank()?null:value.trim();}
    private static String reason(String value,String fallback){return trim(value)==null?fallback:trim(value);}
@@ -88,8 +88,9 @@ public class FleetTripExecutionService {
        List<FleetExecutionModels.Measurement> measurements,String reason) {
        var identity=history.dispatchIdentity(no);var trip=requireTrip(identity.tripNo(),true);
        if(!"PLANNED".equals(trip.getStatus()))throw conflict("本车已开始运输");
-        capacity(trip,cargo,measurements,true);
-        var segments=bookingReservations.actualSegments(trip,measurements);
+        var ownSegments=capacity(trip,cargo,measurements);
+        var plan=new FleetExecutionModels.PlannedLoad(manifestHash,cargo,measurements,ownSegments,operator,Instant.now());
+        var segments=bookingReservations.segments(trip,plan,null,null);
        // 同时核对原有外接预订占用；不因新主流程绕过已确认容量。
        var load=new FleetExecutionModels.ConfirmedLoad(manifestHash,cargo,measurements,segments,operator,Instant.now());
        trip.setLoadJson(write(load));history.recordExecution(trip,trip.getRecordVersion(),"DISPATCH_CONFIRM_LOAD",reason,operator);
@@ -102,7 +103,7 @@ public class FleetTripExecutionService {
        var load=load(trip);if(!"PLANNED".equals(trip.getStatus()) || load==null || !Objects.equals(load.manifestHash(),manifestHash))throw conflict("本车实载确认已变化，请重新核对");
        if(trip.getVehicleId()!=null)requireResource("VEHICLE",trip.getVehicleId(),trip.getId());
        if(trip.getDriverId()!=null)requireResource("DRIVER",trip.getDriverId(),trip.getId());
-        bookingReservations.actualSegments(trip,load.pallets());
+        bookingReservations.segments(trip,new FleetExecutionModels.PlannedLoad(load.manifestHash(),load.cargo(),load.pallets(),load.segments(),load.operatorId(),load.confirmedAt()),null,null);
        appointmentAllocations.requireDeparture(no);
    }

@@ -156,7 +157,7 @@ public class FleetTripExecutionService {
        String fingerprint = hash(write(cargo));
        if (!fingerprint.equals(request.manifestHash())) throw conflict("货物明细已变化，请刷新后重新核对计划容量");
        var pallets = request.pallets().stream().sorted(Comparator.comparing(FleetExecutionModels.Measurement::warehousePalletId)).toList();
-        var plan = new FleetExecutionModels.PlannedLoad(fingerprint, cargo, pallets, capacity(trip, cargo, pallets, false), operator, Instant.now());
+        var plan = new FleetExecutionModels.PlannedLoad(fingerprint, cargo, pallets, capacity(trip, cargo, pallets), operator, Instant.now());
        bookingReservations.segments(trip, plan, null, null);
        trip.setPlannedLoadJson(write(plan));
        history.recordExecution(trip, request.recordVersion(), "PLAN_CAPACITY", request.reason(), operator);
@@ -233,7 +234,7 @@ public class FleetTripExecutionService {
        return null;
    }
    private List<TripCapacityPolicy.Segment> capacity(FleetTripEntity trip, List<FleetExecutionModels.Cargo> cargo,
-                                                     List<FleetExecutionModels.Measurement> pallets, boolean actual) {
+                                                     List<FleetExecutionModels.Measurement> pallets) {
        List<FleetTripModels.Stop> stops;
        try { stops = json.readValue(trip.getStopsJson(), new TypeReference<>() { }); }
        catch (JsonProcessingException error) { throw new IllegalStateException("车次路线读取失败", error); }
@@ -261,8 +262,7 @@ public class FleetTripExecutionService {
            if (!measured.equals(destinations.keySet())) throw conflict("请确认每个实物托盘的托位、实际重量及体积");
            if (trip.getMaxPalletSpaces() == null || trip.getMaxLoadKg() == null || trip.getMaxVolumeCbm() == null)
                throw conflict("车辆容量未确认");
-            var limits = new TripCapacityPolicy.Load(trip.getMaxPalletSpaces(), trip.getMaxLoadKg(), trip.getMaxVolumeCbm());
-            return actual ? TripCapacityPolicy.calculateActual(stops.size(), limits, bookings) : TripCapacityPolicy.calculate(stops.size(), limits, bookings);
+            return TripCapacityPolicy.calculate(stops.size(), new TripCapacityPolicy.Load(trip.getMaxPalletSpaces(), trip.getMaxLoadKg(), trip.getMaxVolumeCbm()), bookings);
        } catch (IllegalArgumentException | ArithmeticException error) { throw conflict(error.getMessage()); }
    }
    private void requireResource(String kind, long id, long tripId) {
@@ -34,7 +34,6 @@ public class FleetTripService {
    @jakarta.annotation.Resource private com.baiyue.lastleg.appointmentwork.AppointmentWorkDispatchPort appointmentAllocations;
    private final FleetTripRepository repository;
    @jakarta.annotation.Resource private com.baiyue.lastleg.fleet.pickup.FleetPickupRepository pickups;
-    @jakarta.annotation.Resource private com.baiyue.lastleg.fleet.pickup.PickupOrderCancellation pickupCancellation;
    private final FleetDispatchGateway dispatches;
    private final VehicleRepository vehicles;
    private final DriverService drivers;
@@ -426,8 +425,8 @@ public class FleetTripService {
        if (trip.getLoadJson() != null) {
            var load = read(trip.getLoadJson(), FleetExecutionModels.ConfirmedLoad.class);
            if (load.segments().stream().anyMatch(segment -> segment.occupied().palletSpaces() > vehicle.maxPalletSpaces()
-                || segment.occupied().weightKg() != null && segment.occupied().weightKg().compareTo(vehicle.maxLoadKg()) > 0
-                || segment.occupied().volumeCbm() != null && segment.occupied().volumeCbm().compareTo(vehicle.maxVolumeCbm()) > 0))
+                || segment.occupied().weightKg().compareTo(vehicle.maxLoadKg()) > 0
+                || segment.occupied().volumeCbm().compareTo(vehicle.maxVolumeCbm()) > 0))
                throw bad("已确认装载超过替换车辆的托位、载重或容积，请先调整装载安排");
        }
        if (!Objects.equals(trip.getVehicleId(), vehicle.id()))
@@ -468,20 +467,18 @@ public class FleetTripService {



-    /** 取消未执行车次，取货同时取消全部转运原单并释放资源。 */
+    /** 取消未执行车次，释放资源并将取货原单退回待安排。 */
    @Transactional
    public FleetTripModels.Detail cancel(String tripNo, String operator, FleetTripModels.Cancel request) {
        FleetTripEntity trip = planned(tripNo, request.recordVersion());
        requireReason(request.reason());
        if ("PICKUP".equals(trip.getTripPurpose())) {
            // 取消车次与释放原单关联同事务，失败时全部回滚。
-            var tasks=pickups.tasks(tripNo);
-            for (var task : tasks) {
+            for (var task : pickups.tasks(tripNo)) {
                if (!"ASSIGNED".equals(task.getStatus())) throw conflict("已开始取货，不能取消车次");
+                pickups.history(task,"UNASSIGN",operator,request.reason());
            }
-            pickupCancellation.cancel(tasks.stream().map(task->new com.baiyue.lastleg.fleet.pickup.FleetPickupModels.Source(task.getCustomerId(),task.getTransferNo())).toList(),tripNo,operator,request.reason());
-            for(var task:tasks)pickups.history(task,"CANCEL",operator,"取消排车及转运单："+request.reason());
-            if(pickups.cancelTasks(tripNo)!=tasks.size())throw conflict("取货关联已变化，取消未完成");
+            pickups.unassign(tripNo);
        }
        if (!repository.listBindings(trip.getId()).isEmpty()) throw conflict("请先解除客户排车单关联，再取消车次");
        if (bookingReservations.hasConfirmed(trip.getId())) throw conflict("请先取消已确认的外接预订，再取消车次");
@@ -557,7 +554,6 @@ public class FleetTripService {
        if (trip == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "车次不存在");
        if (trip.getRecordVersion() != version) throw conflict("车次已被修改，请刷新后重试");
        if (!"PLANNED".equals(trip.getStatus())) throw conflict("仅计划中的车次允许此操作");
-        if("PICKUP".equals(trip.getTripPurpose()) && pickups.tasks(number).stream().anyMatch(task->!"ASSIGNED".equals(task.getStatus())))throw conflict("已开始取货，不能修改资源、计划或取消排车");
        return trip;
    }
    /** 复核创建请求摘要，同键不同内容不允许复用。 */
@@ -210,19 +210,12 @@ public interface LastlegOrderMapper extends BaseMapper<LastlegOrder> {
    @Select("SELECT * FROM ll_order WHERE source_container_booking_id=#{sourceContainerBookingId} ORDER BY customer_id,id FOR UPDATE")
    List<LastlegOrder> lockContainerOrders(@Param("sourceContainerBookingId") String sourceContainerBookingId);

-    /** 人工时间及计划冻结时间优先；返回计划数量供各页面统一判断默认日期。 */
    @Select("<script>SELECT o.source_container_booking_id AS sourceContainerBookingId," +
        "CASE WHEN COUNT(o.estimated_warehouse_at)=COUNT(*) AND COUNT(DISTINCT o.estimated_warehouse_at)=1 " +
-        "AND (MAX(o.arrival_time_version)&gt;0 OR EXISTS(SELECT 1 FROM ll_inbound_plan p " +
-        "JOIN ll_order po ON po.id=p.source_order_id AND po.customer_id=p.customer_id " +
-        "WHERE po.source_container_booking_id=o.source_container_booking_id)) " +
        "THEN MAX(o.estimated_warehouse_at) ELSE NULL END AS estimatedWarehouseArrivalAt," +
        "(SELECT MIN(s.receiving_at) FROM ll_receiving_container_session s " +
        "WHERE s.source_container_booking_id=o.source_container_booking_id AND s.receiving_at IS NOT NULL) AS actualWarehouseArrivalAt," +
-        "CASE WHEN COUNT(DISTINCT o.arrival_time_version)=1 THEN MAX(o.arrival_time_version) ELSE -1 END AS version," +
-        "(SELECT COUNT(*) FROM ll_inbound_plan p JOIN ll_order po " +
-        "ON po.id=p.source_order_id AND po.customer_id=p.customer_id " +
-        "WHERE po.source_container_booking_id=o.source_container_booking_id) AS planCount " +
+        "CASE WHEN COUNT(DISTINCT o.arrival_time_version)=1 THEN MAX(o.arrival_time_version) ELSE -1 END AS version " +
        "FROM ll_order o WHERE o.source_container_booking_id IN " +
        "<foreach collection='bookingIds' item='id' open='(' separator=',' close=')'>#{id}</foreach> " +
        "GROUP BY o.source_container_booking_id</script>")
@@ -1,30 +0,0 @@
-package com.baiyue.lastleg.transfer.mapper;
-
-import com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder;
-import org.apache.ibatis.annotations.*;
-
-/** 仅取消本客户外来取货的待执行原单，不释放或回滚任何已入库库存。 */
-@Mapper
-public interface TransferPickupCancellationMapper {
-    /** 与PDA共用转运原单锁，串行核验收货事实。 */
-    @Select("SELECT * FROM ll_warehouse_transfer_order WHERE customer_id=#{customer} AND transfer_no=#{number} FOR UPDATE")
-    WarehouseTransferOrder lock(@Param("customer") String customer,@Param("number") String number);
-    /** 任何收货、箱清点或托盘测量开始后均禁止普通取消。 */
-    @Select("SELECT (SELECT COUNT(*) FROM ll_warehouse_transfer_receipt WHERE customer_id=#{customer} AND transfer_order_id=#{id}) + (SELECT COUNT(*) FROM ll_warehouse_transfer_carton WHERE customer_id=#{customer} AND transfer_order_id=#{id} AND counted_at IS NOT NULL) + (SELECT COUNT(*) FROM ll_warehouse_transfer_pallet WHERE customer_id=#{customer} AND transfer_order_id=#{id})")
-    int started(@Param("customer") String customer,@Param("id") long id);
-    /** 同一取消事务只接受待PDA收货的转运单。 */
-    @Update("UPDATE ll_warehouse_transfer_order SET status='CANCELLED',updated_at=CURRENT_TIMESTAMP WHERE customer_id=#{customer} AND id=#{id} AND status='WAIT_PDA_RECEIVING'")
-    int cancelTransfer(@Param("customer") String customer,@Param("id") long id);
-    /** 写入主单取消事实并递增版本，防止旧页面继续写入。 */
-    @Update("UPDATE ll_order SET current_status='CANCELLED',sub_order_status='WAREHOUSE_TRANSFER:CANCELLED',version=version+1,updated_at=CURRENT_TIMESTAMP WHERE customer_id=#{customer} AND id=#{id} AND current_status='INBOUND_MEASURING'")
-    int cancelOrder(@Param("customer") String customer,@Param("id") long id);
-    /** 只取消尚未接货的外来入仓单。 */
-    @Update("UPDATE ll_inbound_order SET status='CANCELLED',updated_at=CURRENT_TIMESTAMP WHERE customer_id=#{customer} AND id=#{id} AND status='PENDING_INBOUND'")
-    int cancelInbound(@Param("customer") String customer,@Param("id") long id);
-    /** 只取消原转运生成且仍待PDA的唯一计划。 */
-    @Update("UPDATE ll_inbound_plan SET status='CANCELLED',version=version+1,updated_at=CURRENT_TIMESTAMP WHERE customer_id=#{customer} AND source_order_id=#{order} AND creation_mode='WAREHOUSE_TRANSFER' AND status='PDA_PENDING'")
-    int cancelPlan(@Param("customer") String customer,@Param("order") long order);
-    /** 不可变历史保留取消前状态、原车次与操作者。 */
-    @Insert("INSERT INTO ll_loading_order_status_history(customer_id,order_id,from_status,to_status,event_id,remark,created_at) SELECT customer_id,id,current_status,'CANCELLED',#{trip},CONCAT('取消取货排车及转运单；操作人：',#{operator},'；原因：',#{reason}),CURRENT_TIMESTAMP FROM ll_order WHERE customer_id=#{customer} AND id=#{id}")
-    int history(@Param("customer") String customer,@Param("id") long id,@Param("trip") String trip,@Param("operator") String operator,@Param("reason") String reason);
-}
@@ -1,24 +0,0 @@
-package com.baiyue.lastleg.transfer.repository;
-
-import com.baiyue.lastleg.transfer.mapper.TransferPickupCancellationMapper;
-import org.springframework.stereotype.Repository;
-
-/** 未执行取货取消的原单、入仓与历史持久化边界。 */
-@Repository
-public class TransferPickupCancellationRepository {
-    private final TransferPickupCancellationMapper mapper;
-    /** 注入本业务取消映射器。 */
-    public TransferPickupCancellationRepository(TransferPickupCancellationMapper mapper){this.mapper=mapper;}
-    /** 锁定真实客户所属转运来源。 */
-    public com.baiyue.lastleg.transfer.entity.WarehouseTransferOrder lock(String customer,String number){return mapper.lock(customer,number);}
-    /** 已存在清点、托盘或收货事实时禁止普通取消。 */
-    public boolean started(String customer,long id){return mapper.started(customer,id)>0;}
-    /** 取消转运并检查当前状态。 */
-    public int cancelTransfer(String customer,long id){return mapper.cancelTransfer(customer,id);}
-    /** 取消尾程主单并记录当前状态来源。 */
-    public int cancelOrder(String customer,long id,String trip,String operator,String reason){mapper.history(customer,id,trip,operator,reason);return mapper.cancelOrder(customer,id);}
-    /** 取消原入仓单，保留不可删除的业务关联。 */
-    public int cancelInbound(String customer,long id){return mapper.cancelInbound(customer,id);}
-    /** 取消待收货计划，已执行的计划导致整车取消失败。 */
-    public int cancelPlan(String customer,long order){return mapper.cancelPlan(customer,order);}
-}
@@ -1,32 +0,0 @@
-package com.baiyue.lastleg.transfer.service;
-
-import com.baiyue.lastleg.fleet.pickup.*;
-import com.baiyue.lastleg.transfer.repository.TransferPickupCancellationRepository;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.*;
-import org.springframework.http.HttpStatus;
-import org.springframework.web.server.ResponseStatusException;
-import java.util.List;
-
-/** 取货排车取消时原子取消其全部转运、尾程、入仓单及待执行入仓计划。 */
-@Service
-public class TransferPickupCancellationService implements PickupOrderCancellation {
-    private final TransferPickupCancellationRepository repository;
-    /** 取消只访问本域持久化边界，不反向调用排车服务。 */
-    public TransferPickupCancellationService(TransferPickupCancellationRepository repository){this.repository=repository;}
-    /** 任一来源已经执行或归属不符时抛错，使外层整车取消全部回滚。 */
-    @Override @Transactional(propagation=Propagation.MANDATORY)
-    public void cancel(List<FleetPickupModels.Source> sources,String tripNo,String operator,String reason) {
-        if(sources==null || sources.isEmpty())throw conflict();
-        for(var source:sources) {
-            var row=repository.lock(source.customerId(),source.transferNo());
-            if(row==null || !"WAREHOUSE_PICKUP".equals(row.getDeliveryMethod()) || !row.getTransferNo().equals(row.getInboundCode()) || !"WAIT_PDA_RECEIVING".equals(row.getStatus()) || repository.started(source.customerId(),row.getId()))throw conflict();
-            if(repository.cancelTransfer(source.customerId(),row.getId())!=1
-                || repository.cancelOrder(source.customerId(),row.getLastlegOrderId(),tripNo,operator,reason)!=1
-                || repository.cancelInbound(source.customerId(),row.getInboundOrderId())!=1
-                || repository.cancelPlan(source.customerId(),row.getLastlegOrderId())!=1)throw conflict();
-        }
-    }
-    /** 保留用户上下文，不把部分取消作为成功返回。 */
-    private static ResponseStatusException conflict(){return new ResponseStatusException(HttpStatus.CONFLICT,"转运单已开始收货或关联状态变化，不能取消排车及转运单，请刷新核对");}
-}
@@ -94,7 +94,6 @@ import java.util.stream.Collectors;
 public class WarehouseTransferService {
    @Resource private TransferQuantityService transferQuantityService;
    @Resource private com.baiyue.lastleg.fleet.pickup.FleetPickupService pickupService;
-    @Resource private com.baiyue.lastleg.dispatch.transport.TransportTaskService transportTaskService;
    /** 退货单在转运来源中的展示编码，避免把退货单号误当成普通入仓码查询。 */
    public static final String RETURN_ORDER_PREFIX = "RETURN_ORDER:";
    @Resource private com.baiyue.lastleg.service.LastlegDocumentNumberGenerator compactNumbers;
@@ -815,7 +814,6 @@ public class WarehouseTransferService {
        return new WarehouseTransferResponses.Label(transferNo, cartons, html);
    }

-    /** 审核与入仓计划、上门取货排车原子提交，重放复用原业务关联。 */
    @Transactional
    public WarehouseTransferResponses.Detail review(String customerId, String transferNo, String operatorId,
                                                     WarehouseTransferRequests.Review request) {
@@ -838,7 +836,6 @@ public class WarehouseTransferService {
                    .contains(transfer.getStatus())) {
                if (APPROVED.equals(next) && transfer.getTransferNo().equals(transfer.getInboundCode())) {
                    activateTransferInbound(customerId, transfer, LocalDateTime.now());
-                    transportTaskService.ensureApprovedPickup(customerId, transferNo, operatorId);
                }
                return detail(customerId, transferNo);
            }
@@ -868,9 +865,6 @@ public class WarehouseTransferService {
                "Warehouse transfer reviewed: " + next
                    + (StringUtils.hasText(request.remark()) ? "; " + request.remark().trim() : ""), now);
        }
-        if (APPROVED.equals(next) && incomingTransit) {
-            transportTaskService.ensureApprovedPickup(customerId, transferNo, operatorId);
-        }
        return detail(customerId, transferNo);
    }

@@ -1907,7 +1907,6 @@ CREATE TABLE IF NOT EXISTS ll_dispatch_order (
  review_state VARCHAR(32) NOT NULL DEFAULT 'DRAFT' COMMENT '审核子流程当前状态',
  review_round BIGINT NOT NULL DEFAULT 0 COMMENT '当前审核轮次',
  review_basis_hash CHAR(64) NULL COMMENT '本审核轮次核对的货物和资源依据摘要',
-  exceptions_json JSON NULL COMMENT '派送异常登记记录及图片引用，不改变派送及库存状态',
  dispatch_review_json JSON NULL COMMENT '当前调度审核事实快照',
  loading_review_json JSON NULL COMMENT '当前理货审核事实快照',
  resources_json JSON NULL COMMENT '本趟主档或临时车辆司机的真实资源快照',
@@ -1,394 +0,0 @@
-openapi: 3.0.3
-info:
-  title: 排车装车资料（Admin/PDA共用）
-  version: 1.0.0
-  description: LOADING阶段即可同步上传并保存五个整车照片框；照片齐全不会提前发车。装车确认时资料已齐则直接进入DELIVERING，否则进入AFTER_LOADING，最后一次绑定自动生成派送并进入DELIVERING。触发推进的装车确认或照片绑定与派送同事务，失败保留先前已保存资料。复用车队照片记录，技术槽位仅表示照片1至5，不代表驾驶证审核或真实签收。PDA每次核验Token冻结仓，平台list只读、edit写；原键仅原操作者恢复。
-security:
- bearerAuth: []
-paths:
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-documents:
-    get:
-      operationId: getDispatchLoadingDocuments
-      summary: 读取本车装车资料或原上传结果
-      x-permission-code: platform:overseas-warehouse:dispatch:list
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Documents'
-  /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-documents:
-    get:
-      operationId: getDispatchLoadingDocumentsPda
-      summary: 读取本车装车资料或原上传结果
-      x-permission-code: lastleg:pda:operate
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Documents'
-      x-required-role: OVERSEAS_WAREHOUSE_PDA_OPERATOR
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-documents/{slot}/uploads:
-    post:
-      operationId: uploadDispatchLoadingPhoto
-      summary: 上传整车装车照片，尚未绑定
-      x-permission-code: platform:overseas-warehouse:dispatch:edit
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Photo'
-      requestBody:
-        required: true
-        content:
-          multipart/form-data:
-            schema:
-              type: object
-              required:
-              - file
-              - idempotencyKey
-              properties:
-                file:
-                  type: string
-                  format: binary
-                  description: 非空JPG/PNG，最大10MiB
-                idempotencyKey:
-                  type: string
-                  minLength: 8
-                  maxLength: 128
-  /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-documents/{slot}/uploads:
-    post:
-      operationId: uploadDispatchLoadingPhotoPda
-      summary: 上传整车装车照片，尚未绑定
-      x-permission-code: lastleg:pda:operate
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Photo'
-      requestBody:
-        required: true
-        content:
-          multipart/form-data:
-            schema:
-              type: object
-              required:
-              - file
-              - idempotencyKey
-              properties:
-                file:
-                  type: string
-                  format: binary
-                  description: 非空JPG/PNG，最大10MiB
-                idempotencyKey:
-                  type: string
-                  minLength: 8
-                  maxLength: 128
-      x-required-role: OVERSEAS_WAREHOUSE_PDA_OPERATOR
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-documents/{slot}:
-    put:
-      operationId: bindDispatchLoadingPhoto
-      summary: 保存装车照片；五框齐全时自动进入派送中
-      x-permission-code: platform:overseas-warehouse:dispatch:edit
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Documents'
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/BindPhoto'
-  /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-documents/{slot}:
-    put:
-      operationId: bindDispatchLoadingPhotoPda
-      summary: 保存装车照片；五框齐全时自动进入派送中
-      x-permission-code: lastleg:pda:operate
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Documents'
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/BindPhoto'
-      x-required-role: OVERSEAS_WAREHOUSE_PDA_OPERATOR
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-documents/{slot}/files/{fileId}/content:
-    get:
-      operationId: readDispatchLoadingPhoto
-      summary: 读取本车装车资料或原上传结果
-      x-permission-code: platform:overseas-warehouse:dispatch:list
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      - $ref: '#/components/parameters/fileId'
-      responses:
-        '200':
-          description: no-store图片内容
-          content:
-            image/jpeg:
-              schema:
-                type: string
-                format: binary
-            image/png:
-              schema:
-                type: string
-                format: binary
-  /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-documents/{slot}/files/{fileId}/content:
-    get:
-      operationId: readDispatchLoadingPhotoPda
-      summary: 读取本车装车资料或原上传结果
-      x-permission-code: lastleg:pda:operate
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      - $ref: '#/components/parameters/fileId'
-      responses:
-        '200':
-          description: no-store图片内容
-          content:
-            image/jpeg:
-              schema:
-                type: string
-                format: binary
-            image/png:
-              schema:
-                type: string
-                format: binary
-      x-required-role: OVERSEAS_WAREHOUSE_PDA_OPERATOR
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-documents/uploads/{idempotencyKey}:
-    get:
-      operationId: recoverDispatchLoadingPhoto
-      summary: 读取本车装车资料或原上传结果
-      x-permission-code: platform:overseas-warehouse:dispatch:edit
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/idempotencyKey'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Photo'
-  /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-documents/uploads/{idempotencyKey}:
-    get:
-      operationId: recoverDispatchLoadingPhotoPda
-      summary: 读取本车装车资料或原上传结果
-      x-permission-code: lastleg:pda:operate
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/idempotencyKey'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Photo'
-      x-required-role: OVERSEAS_WAREHOUSE_PDA_OPERATOR
-components:
-  securitySchemes:
-    bearerAuth:
-      type: http
-      scheme: bearer
-      bearerFormat: JWT
-  parameters:
-    dispatchNo:
-      name: dispatchNo
-      in: path
-      required: true
-      schema:
-        type: string
-    slot:
-      name: slot
-      in: path
-      required: true
-      schema:
-        type: string
-        enum: &id001
-        - LOADING_SCENE
-        - LOADING_LIST
-        - PRE_DEPARTURE_CHECK
-        - DRIVER_LICENSE
-        - RECEIPT
-    fileId:
-      name: fileId
-      in: path
-      required: true
-      schema:
-        type: string
-    idempotencyKey:
-      name: idempotencyKey
-      in: path
-      required: true
-      schema:
-        type: string
-  schemas:
-    Photo:
-      type: object
-      required:
-      - slot
-      - fileId
-      - fileName
-      - contentType
-      - sizeBytes
-      - uploadedAt
-      properties:
-        slot:
-          type: string
-          enum: *id001
-        category:
-          type: string
-          enum:
-          - LOADING
-        fileId:
-          type: string
-        fileName:
-          type: string
-        contentType:
-          type: string
-        sizeBytes:
-          type: string
-        uploadedAt:
-          type: string
-        savedAt:
-          type: string
-          nullable: true
-    Documents:
-      type: object
-      required:
-      - dispatchNo
-      - recordVersion
-      - editable
-      - photos
-      - dispatchRecordVersion
-      - stage
-      - complete
-      properties:
-        dispatchNo:
-          type: string
-        recordVersion:
-          type: string
-        editable:
-          type: boolean
-        photos:
-          type: array
-          items:
-            $ref: '#/components/schemas/Photo'
-        dispatchRecordVersion:
-          type: string
-        stage:
-          type: string
-          enum:
-          - LOADING
-          - AFTER_LOADING
-          - DELIVERING
-          - DELIVERED
-        complete:
-          type: boolean
-          description: 五个固定框各有一张已保存照片
-    BindPhoto:
-      type: object
-      required:
-      - recordVersion
-      - idempotencyKey
-      - fileId
-      properties:
-        recordVersion:
-          type: string
-          pattern: ^(0|[1-9][0-9]*)$
-        idempotencyKey:
-          type: string
-          minLength: 8
-          maxLength: 128
-        fileId:
-          type: string
@@ -8,10 +8,6 @@ info:
    list读取、create安排、edit分配/执行/释放、depart发车、cancel取消权限前缀均为platform:overseas-warehouse:dispatch:。
    创建及执行使用稳定idempotencyKey；重试保留完整原载荷。取消仅限未发车；完成后分别释放司机、车辆。
    到仓取货逐原单确认实提和送仓，送仓只开放仓库收货门禁；本土卡车同步原单运输状态，完成须本任务凭证。
-    仓储转运上门取货入仓单审核通过时自动生成待发车排车并绑定原转运单；重复审核不重复建单，主动取消排车时对应转运、尾程、入仓单和待收货计划一并取消。
-    PICKUP 维护车辆后复用 dispatches/{dispatchNo}/submit-review、dispatch-review、loading-review 两级审核入口及版本化命令。
-    调度通过后待理货审核，任一级驳回返回车辆信息修改重提；两级通过后进入装货中；逐票上传取货照片并确认后自动进入派送中，逐票上传到仓照片并确认后自动完成取货派送，再走原仓库收货流程，不走仓内拣货扣库存。
-    车辆、司机或计划时刻变化作废本轮审核；运输版本与排车审核版本各自递增，命令使用对应详情的当前版本。
 servers:
  - url: /api/platform/v1/last-leg/dispatches/transport-tasks
 security:
@@ -42,7 +38,7 @@ paths:
      - { name: number, in: path, required: true, schema: { type: string }, description: 真实PC排车业务号 }
    get:
      summary: 排车运输详情（list）
-      description: data包含dispatchNo、taskType（PICKUP/LOCAL_TRUCK）、execution（现有资源与执行详情）、customerId、orderNo、pickups、completionEvidence（已确认凭证）、dispatchRecordVersion（排车审核版本）、resources（取货车辆司机照片快照；其他类型为null）。resources.driver.evidence.masterLicenseFileId仅表示司机主档驾驶证来源，包含在fileIds内；其他fileIds属于本车补传。
+      description: data包含dispatchNo、taskType（PICKUP/LOCAL_TRUCK）、execution（现有资源与执行详情）、customerId、orderNo、pickups、completionEvidence（已确认凭证）。
      responses: *response
  /{number}/{action}:
    parameters:
@@ -52,10 +48,6 @@ paths:
      summary: 分配、取消、资源可用性查询与实际任务释放
      description: >-
        assign(edit)：recordVersion、vehicleId、driverId、reason；cancel(cancel)：recordVersion、reason。
-        PICKUP分配还必须提交dispatchRecordVersion和reviewPhotos（vehicleFileIds、driverPhotoFileIds、licenseFileIds），每类最多20个唯一正整数ID。
-        车辆图片和司机照片各至少一张，驾驶证须有本车licenseFileIds或masterLicenseFileId；后者仅可引用所选司机当前有效主档驾驶证，不放入请求的licenseFileIds。
-        所有补传经dispatches/{number}/evidence/{VEHICLE|DRIVER_PHOTO|DRIVER}上传并校验本车类别归属；主档预览复用司机档案受权下载。
-        资源、照片与审核失效同事务，双版本过期或任一照片不合法则不分配资源。重新换车/司机不得沿用对应旧照片，照片修改必须重新两级审核，运输状态同步保留同一资源的照片。
        resource-occupancy(list)：kind=VEHICLE/DRIVER、resourceIds数组。
        release(edit)：recordVersion、resourceKind、actualEndAt、endLocation、vehicleStatus（车辆必填）、idempotencyKey、reason。
      responses: *response
@@ -1,242 +0,0 @@
-openapi: 3.0.3
-info:
-  title: 排车车辆资料
-  version: 1.0.0
-  description: 仅平台有效排车DELIVERING/DELIVERED可用；兼容有无拼车货物，沿装车归属证据校验。共享原车队照片、版本、命令与历史，不新建附件存储。派送文件仍使用delivery-orders
-    documents；不把车队RECEIPT照片当签收。列表权限只读，排车edit独立写；恢复还需list。
-security:
- bearerAuth: []
-paths:
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents:
-    get:
-      operationId: getDispatchVehicleDocuments
-      summary: 读取本车油耗图片；复用车队附加记录
-      x-permission-code: platform:overseas-warehouse:dispatch:list
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Documents'
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents/{slot}/uploads:
-    post:
-      operationId: uploadDispatchVehiclePhoto
-      summary: 准备本车油耗图片；尚未绑定保存
-      x-permission-code: platform:overseas-warehouse:dispatch:edit
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Photo'
-      requestBody:
-        required: true
-        content:
-          multipart/form-data:
-            schema:
-              type: object
-              required:
-              - file
-              - idempotencyKey
-              properties:
-                file:
-                  type: string
-                  format: binary
-                  description: 非空JPG/PNG，最大10MiB
-                idempotencyKey:
-                  type: string
-                  minLength: 8
-                  maxLength: 128
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents/{slot}:
-    put:
-      operationId: bindDispatchVehiclePhoto
-      summary: 按附加版本绑定原上传文件，不改变排车或签收状态
-      x-permission-code: platform:overseas-warehouse:dispatch:edit
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Documents'
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/BindPhoto'
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents/{slot}/files/{fileId}/content:
-    get:
-      operationId: readDispatchVehiclePhoto
-      summary: 只读取本车当前绑定图片
-      x-permission-code: platform:overseas-warehouse:dispatch:list
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/slot'
-      - $ref: '#/components/parameters/fileId'
-      responses:
-        '200':
-          description: no-store图片内容
-          content:
-            image/jpeg:
-              schema:
-                type: string
-                format: binary
-            image/png:
-              schema:
-                type: string
-                format: binary
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/vehicle-documents/uploads/{idempotencyKey}:
-    get:
-      operationId: recoverDispatchVehiclePhoto
-      summary: 只恢复当前操作者原油耗上传成功结果，未知结果拒绝重传
-      x-permission-code: platform:overseas-warehouse:dispatch:edit
-      parameters:
-      - $ref: '#/components/parameters/dispatchNo'
-      - $ref: '#/components/parameters/idempotencyKey'
-      responses:
-        '200':
-          description: 成功；业务错误沿ApiResponse返回A0400/A0403/A0404/A0409及诊断编号
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  data:
-                    $ref: '#/components/schemas/Photo'
-components:
-  securitySchemes:
-    bearerAuth:
-      type: http
-      scheme: bearer
-      bearerFormat: JWT
-  parameters:
-    dispatchNo:
-      name: dispatchNo
-      in: path
-      required: true
-      schema:
-        type: string
-    slot:
-      name: slot
-      in: path
-      required: true
-      schema:
-        type: string
-        enum:
-        - FUEL_START
-        - FUEL_END
-    fileId:
-      name: fileId
-      in: path
-      required: true
-      schema:
-        type: string
-    idempotencyKey:
-      name: idempotencyKey
-      in: path
-      required: true
-      schema:
-        type: string
-  schemas:
-    Photo:
-      type: object
-      required:
-      - slot
-      - fileId
-      - fileName
-      - contentType
-      - sizeBytes
-      - uploadedAt
-      properties:
-        slot:
-          type: string
-          enum:
-          - FUEL_START
-          - FUEL_END
-        category:
-          type: string
-          enum:
-          - FUEL
-        fileId:
-          type: string
-        fileName:
-          type: string
-        contentType:
-          type: string
-        sizeBytes:
-          type: string
-        uploadedAt:
-          type: string
-        savedAt:
-          type: string
-          nullable: true
-    Documents:
-      type: object
-      required:
-      - dispatchNo
-      - recordVersion
-      - editable
-      - photos
-      properties:
-        dispatchNo:
-          type: string
-        recordVersion:
-          type: string
-        editable:
-          type: boolean
-        photos:
-          type: array
-          items:
-            $ref: '#/components/schemas/Photo'
-    BindPhoto:
-      type: object
-      required:
-      - recordVersion
-      - idempotencyKey
-      - fileId
-      properties:
-        recordVersion:
-          type: string
-          pattern: ^(0|[1-9][0-9]*)$
-        idempotencyKey:
-          type: string
-          minLength: 8
-          maxLength: 128
-        fileId:
-          type: string
@@ -1,8 +1,8 @@
 openapi: "3.0.3"
 info:
-  title: "原排车拼车任务运营视图"
+  title: "原排车外配车辆运营视图"
  version: "1.0.0"
-  description: "仅ACTIVE且装车后/派送中/已完成。按需求池已实收绑定及本车真实货物组成判定实际拼车。车辆归属允许OWNED/DISPATCHED，MASTER/EXTERNAL只表示资源身份；无快照不回填。复用四张附加表，不推进排车、不触发库存/财务。承运金额CNY/USD显式登记；单价除以实际物理托数并HALF_UP两位。无里程、油耗及油耗照片。响应遵循NON_NULL：可空属性可省略，省略与null均表示空值，0仍是明确登记值；请求必填项仍以required及DTO校验为准。"
+  description: "仅ACTIVE且装车后/派送中/已完成。按原装车归属DISPATCHED及MASTER/EXTERNAL资源快照读取；无快照不回填。复用四张附加表，不推进排车、不触发库存/财务。承运金额CNY/USD显式登记；单价除以实际物理托数并HALF_UP两位。无里程、油耗及油耗照片。响应遵循NON_NULL：可空属性可省略，省略与null均表示空值，0仍是明确登记值；请求必填项仍以required及DTO校验为准。"
 security:
  - bearerAuth: []
 paths:
@@ -182,7 +182,7 @@ components:
      properties:
        vehicleId: { type: string, nullable: true, description: "原临时EXTERNAL车辆合法为空，档案MASTER核对原捕获ID" }
        plate: { type: string, nullable: true }
-        ownership: { type: string, enum: [OWNED, DISPATCHED] }
+        ownership: { type: string, enum: [DISPATCHED] }
        carrierName: { type: string, nullable: true, description: "只取原车辆快照，缺失显示—；不查当前档案补值" }
    PhotoSlot:
      type: string
@@ -1,8 +1,8 @@
 openapi: "3.0.3"
 info:
-  title: "原排车未拼车业务运营视图"
+  title: "原排车自有车辆运营视图"
  version: "1.0.0"
-  description: "未实际接入拼车货物的装车后排车；按需求池已实收绑定及本车真实货物组成判定。车辆OWNED/DISPATCHED只表示装车时归属，不决定业务分类；所有主单事实来自原dispatch。新增数据仅附加运营记录、命令、历史及归属证据。油耗L/100km手工登记，金额CNY/USD不默认、不换汇；零与未登记不同。响应遵循NON_NULL：可空属性可省略，省略与null均表示空值，0仍是明确登记值；请求必填项仍以required及DTO校验为准。"
+  description: "装车完成时冻结车辆OWNED/DISPATCHED；所有主单事实来自原dispatch。新增数据仅附加运营记录、命令、历史及归属证据。油耗L/100km手工登记，金额CNY/USD不默认、不换汇；零与未登记不同。响应遵循NON_NULL：可空属性可省略，省略与null均表示空值，0仍是明确登记值；请求必填项仍以required及DTO校验为准。"
 security:
  -
    bearerAuth: []
@@ -10,7 +10,7 @@ paths:
  "/api/platform/v1/last-leg/fleet/owned-business":
    get:
      operationId: "listOwnedBusiness"
-      summary: "未接入拼车货物的装车后视图及同筛选四项统计"
+      summary: "自有车辆装车后视图及同筛选四项统计"
      description: "权限：platform:fleet:owned-business:list。仅可信平台主体；只读原排车事实，不改变其状态/版本，不发布费用。"
      x-permission-code: "platform:fleet:owned-business:list"
      responses:
@@ -540,19 +540,18 @@ components:
      type: "object"
      x-java-record: "OwnedBusinessModels.Vehicle"
      required:
+        - "vehicleId"
+        - "plate"
        - "ownership"
      properties:
        vehicleId:
          type: "string"
-          nullable: true
        plate:
          type: "string"
-          nullable: true
        ownership:
          type: "string"
          enum:
            - "OWNED"
-            - "DISPATCHED"
    Driver:
      type: "object"
      x-java-record: "OwnedBusinessModels.Driver"
@@ -3,16 +3,12 @@ info:
  title: 仓储转运上门取货与车辆排车
  version: 1.0.0
  description: |
-    WAREHOUSE_PICKUP 外来转运单审核通过后，同事务自动生成绑定原单的 PICKUP 排车单（PC号），待分配车辆司机；客户自送、库存转运不自动排车。
-    自动计划暂定为审核时刻发车、24小时后结束，并在备注标明待调度确认；不填写实际发车、实提或送仓事实。
-    取货排车先维护车辆信息、提交调度审核，经调度和理货员同轮审核通过后进入装货中。逐票上传取货照片并确认实提，全车齐全后自动进入派送中；逐票上传独立到仓照片，全部到仓后自动完成取货派送，再继续原仓库收货流程。
-    修改车辆、司机或计划时刻后本轮审核失效，须重新提交；审核不触发仓内拣货或库存扣减。
-    重复审核沿原单锁复用已有任务，不重复建单，也不恢复已主动取消的任务；取消排车时对应转运单、尾程单、入仓单及待PDA计划同事务取消，不再进入取货候选。
+    审核通过的 WAREHOUSE_PICKUP 外来转运单自动进入待取货候选；客户自送、库存转运、未审核及已完成测量单不进入。
    入仓取货和出库派送共用 ll_fleet_trip 及车辆司机占用，tripPurpose 分别为 PICKUP / DELIVERY，禁止混用库存出库命令、外接预订及余位发布。
    同车多单必须送往同一公共海外仓，原客户归属与转运单保留，不重复生成尾程单、不修改预报箱唛或库存。
    取货确认必须填写实提箱数并引用本票本车已上传的 PDF/JPG/PNG 凭证；送仓后开放 PDA 清点。
    司机实提箱数不替代仓库实收。全部送仓后结案运输，车辆和司机仍通过原 resources/release 分别结束任务。
-    取消 PLANNED 车次原子取消本车全部对应转运单、尾程单、入仓单及待PDA计划并释放资源；任一成员已有清点或收货事实则全部回滚，已发车不可取消。
+    取消 PLANNED 车次原子释放资源和未执行取货关联，原单重新成为候选；已发车不可取消。
    写命令具备车次版本及请求键，同键同内容重放不重复写入，同键不同内容拒绝。普通业务返回 HTTP 200 + body.code。
 security:
  - bearerAuth: []
@@ -83,7 +79,7 @@ paths:
    parameters: [{$ref: '#/components/parameters/tripNo'}, {$ref: '#/components/parameters/customerId'}, {$ref: '#/components/parameters/transferNo'}]
    post:
      summary: 逐票确认取货
-      description: 仅平台主体，权限 platform:fleet:trip:edit。两级审核通过的计划车次或已出发车次，任务 ASSIGNED；核对本票本车图片上传归属后转 PICKED，实提箱数不覆盖预报。全车取货照片齐全后自动进入 IN_TRANSIT，排车阶段为 DELIVERING。
+      description: 仅平台主体，权限 platform:fleet:trip:edit。车次已发车且任务 ASSIGNED，核对本票本车上传归属后转 PICKED，实提箱数不覆盖预报。
      requestBody:
        required: true
        content:
@@ -102,7 +98,7 @@ paths:
    parameters: [{$ref: '#/components/parameters/tripNo'}, {$ref: '#/components/parameters/customerId'}, {$ref: '#/components/parameters/transferNo'}]
    post:
      summary: 确认本票送达海外仓
-      description: 仅平台主体，权限 platform:fleet:trip:edit。仅 PICKED 可以转 ARRIVED；evidenceFileIds 必填且为本票本车新上传的图片，不得复用取货照片。Evidence.phase 为 PICKUP 或 ARRIVAL 区分两次照片。全车均 ARRIVED 后自动完成运输，开放原 PDA 清点，不直接完成测量或入库。
+      description: 仅平台主体，权限 platform:fleet:trip:edit。仅 PICKED 可以转 ARRIVED；开放原 PDA 清点，不直接完成测量或入库。
      requestBody: {$ref: '#/components/requestBodies/command'}
      responses: {'200': {description: ApiResponse 当前本车 Task 数组；车次版本已更新}}
  /api/platform/v1/last-leg/fleet/pickups/{tripNo}/complete:
@@ -161,4 +157,3 @@ components:
              recordVersion: {type: integer, format: int64, minimum: 0}
              idempotencyKey: {type: string, minLength: 8, maxLength: 128}
              reason: {type: string, maxLength: 1000}
-              evidenceFileIds: {type: array, minItems: 1, maxItems: 10, items: {type: string}, description: 送仓确认必填，必须为本票本车新上传的到仓图片}
@@ -602,8 +602,8 @@ components:
      properties:
        warehousePalletId: {type: string}
        palletSpaces: {type: integer, minimum: 1}
-        weightKg: {type: number, nullable: true, description: 已确认装车的未知实测保持空值；计划容量输入仍须填写正数, minimum: 0.001, multipleOf: 0.001, maximum: 999999999.999}
-        volumeCbm: {type: number, nullable: true, description: 已确认装车的未知实测保持空值；计划容量输入仍须填写正数, minimum: 0.001, multipleOf: 0.001, maximum: 999999999.999}
+        weightKg: {type: number, minimum: 0.001, multipleOf: 0.001, maximum: 999999999.999}
+        volumeCbm: {type: number, minimum: 0.001, multipleOf: 0.001, maximum: 999999999.999}
        deliveryIndex: {type: integer, minimum: 1, description: 卸货站索引，起运仓固定为0}
    PlanningEnvelope:
      allOf:
@@ -641,8 +641,8 @@ components:
      type: object
      properties:
        palletSpaces: {type: integer}
-        weightKg: {type: number, nullable: true, description: 实测不完整时未知，不表示零重量或可售余量}
-        volumeCbm: {type: number, nullable: true, description: 实测不完整时未知，不表示零体积或可售余量}
+        weightKg: {type: number}
+        volumeCbm: {type: number}
    ConfirmLoad:
      type: object
      required: [recordVersion, manifestHash, pallets, reason]
@@ -920,8 +920,7 @@ paths:
      parameters:
      - name: warehouseId
        in: query
-        description: 可选真实起运仓；未指定时按 warehouseTab 跨仓分页浏览，草稿及建单仍要求同一起运仓。
-        required: false
+        required: true
        schema:
          type: string
      - name: planIds
@@ -1346,6 +1345,49 @@ paths:
      required: true
      schema:
        type: string
+  /api/platform/v1/last-leg/dispatches/{dispatchNo}/transfer-delivery:
+    post:
+      summary: 原子安排本车全部客户派送及费用
+      description: 权限 platform:overseas-warehouse:dispatch:transfer-delivery。
+      security:
+      - bearerAuth: []
+      responses:
+        '200':
+          description: 统一ApiResponse；业务失败通过code返回，不能仅凭HTTP200判断成功。
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code:
+                    type: string
+                  message:
+                    type: string
+                  requestId:
+                    type: string
+                    nullable: true
+                  traceId:
+                    type: string
+                    nullable: true
+                  timestamp:
+                    type: string
+                    format: date-time
+                  data:
+                    allOf:
+                    - $ref: '#/components/schemas/DispatchCommandResult'
+                    nullable: true
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/DispatchArrangeDelivery'
+    parameters:
+    - name: dispatchNo
+      in: path
+      required: true
+      schema:
+        type: string
  /api/platform/v1/last-leg/dispatches/{dispatchNo}/items:
    post:
      summary: 按真实来源版本向整车加货
@@ -1683,53 +1725,10 @@ paths:
      required: true
      schema:
        type: string
-  /api/platform/v1/last-leg/dispatches/{dispatchNo}/exceptions:
-    post:
-      summary: 登记派送异常
-      description: 权限 platform:overseas-warehouse:dispatch:edit；仅有效仓库派送单DELIVERING可登记，保存后阶段不变，不产生退货、签收或库存变化。原键重试恢复原结果。
-      security:
-      - bearerAuth: []
-      responses:
-        '200':
-          description: 统一ApiResponse；业务失败通过code返回，不能仅凭HTTP200判断成功。
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  requestId:
-                    type: string
-                    nullable: true
-                  traceId:
-                    type: string
-                    nullable: true
-                  timestamp:
-                    type: string
-                    format: date-time
-                  data:
-                    allOf:
-                    - $ref: '#/components/schemas/DispatchCommandResult'
-                    nullable: true
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/DispatchMarkException'
-    parameters:
-    - name: dispatchNo
-      in: path
-      required: true
-      schema:
-        type: string
  /api/platform/v1/last-leg/dispatches/{dispatchNo}/loading-complete:
    post:
-      summary: 确认装车完成，资料齐全时自动进入派送中
-      description: 权限 platform:overseas-warehouse:dispatch:loading-complete。 装车中可通过loading-documents同步保存五张装车照片。原请求保存实载确认；成功action为LOADING_COMPLETE，资料已齐时stage为DELIVERING，未齐时为AFTER_LOADING，result保留真实Loaded装车证据。装车确认与资料齐全两项均完成时自动生成派送并发车；触发该次推进的装车确认或最后一次绑定与派送同事务回滚，先前已保存照片保留。重试装车原键保持原最终阶段结果，当前阶段另行读取。
+      summary: PDA核平后确认装车完成
+      description: 权限 platform:overseas-warehouse:dispatch:loading-complete。
      security:
      - bearerAuth: []
      responses:
@@ -1879,6 +1878,43 @@ paths:
      required: true
      schema:
        type: string
+  /api/platform/v1/last-leg/dispatches/{dispatchNo}/delivery-arrangement:
+    get:
+      summary: 读取全车派送分组与费用依据
+      description: 权限 platform:overseas-warehouse:dispatch:list。
+      security:
+      - bearerAuth: []
+      responses:
+        '200':
+          description: 统一ApiResponse；业务失败通过code返回，不能仅凭HTTP200判断成功。
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code:
+                    type: string
+                  message:
+                    type: string
+                  requestId:
+                    type: string
+                    nullable: true
+                  traceId:
+                    type: string
+                    nullable: true
+                  timestamp:
+                    type: string
+                    format: date-time
+                  data:
+                    allOf:
+                    - $ref: '#/components/schemas/DispatchArrangementPreview'
+                    nullable: true
+    parameters:
+    - name: dispatchNo
+      in: path
+      required: true
+      schema:
+        type: string
  /api/platform/v1/last-leg/dispatches/{dispatchNo}/commands/{idempotencyKey}:
    get:
      summary: 恢复本人原动作不可变结果
@@ -1924,7 +1960,7 @@ paths:
  /api/platform/v1/last-leg/dispatches/{dispatchNo}/evidence/{kind}:
    post:
      summary: 上传本趟车辆或司机证据
-      description: 客服阶段使用 platform:overseas-warehouse:dispatch:edit；调度待审/理货待审分别使用 platform:fleet:trip:dispatch-review / platform:fleet:trip:loading-review，无需维护车辆权限。VEHICLE和DRIVER支持PDF/JPG/PNG，DRIVER_PHOTO和EXCEPTION仅JPG/PNG；EXCEPTION仅派送中使用排车edit权限，引用随异常登记保存。非空且不超过10MiB；平台、本车、类型复合归属。审核补充附件随ReviewCommand保存，不修改资源，不重启审核。
+      description: 权限 platform:overseas-warehouse:dispatch:edit。PDF/JPG/PNG，非空且不超过10MiB；平台、本车、类型复合归属。上传后通过版本化EDIT保存引用。
      security:
      - bearerAuth: []
      responses:
@@ -1978,8 +2014,6 @@ paths:
        enum:
        - VEHICLE
        - DRIVER
-        - DRIVER_PHOTO
-        - EXCEPTION
  /api/platform/v1/last-leg/dispatches/{dispatchNo}/evidence/{kind}/{fileId}:
    get:
      summary: 读取本车证据元数据
@@ -2025,8 +2059,6 @@ paths:
        enum:
        - VEHICLE
        - DRIVER
-        - DRIVER_PHOTO
-        - EXCEPTION
    - name: fileId
      in: path
      required: true
@@ -2069,14 +2101,55 @@ paths:
        enum:
        - VEHICLE
        - DRIVER
-        - DRIVER_PHOTO
-        - EXCEPTION
    - name: fileId
      in: path
      required: true
      schema:
        type: string
        pattern: ^[1-9][0-9]*$
+  /api/platform/v1/last-leg/dispatches/{dispatchNo}/depart:
+    post:
+      summary: 确认实际整车发车
+      description: 权限 platform:overseas-warehouse:dispatch:depart。
+      security:
+      - bearerAuth: []
+      responses:
+        '200':
+          description: 统一ApiResponse；业务失败通过code返回，不能仅凭HTTP200判断成功。
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code:
+                    type: string
+                  message:
+                    type: string
+                  requestId:
+                    type: string
+                    nullable: true
+                  traceId:
+                    type: string
+                    nullable: true
+                  timestamp:
+                    type: string
+                    format: date-time
+                  data:
+                    allOf:
+                    - $ref: '#/components/schemas/DispatchCommandResult'
+                    nullable: true
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/DispatchDepart'
+    parameters:
+    - name: dispatchNo
+      in: path
+      required: true
+      schema:
+        type: string
  /api/platform/v1/last-leg/outbound-orders:
    get:
      summary: 分页查询出库单
@@ -3550,13 +3623,12 @@ components:
        remark: { type: string, maxLength: 500, nullable: true }
    ContainerArrivalTimeView:
      type: object
-      required: [sourceContainerBookingId, version, planCount]
+      required: [sourceContainerBookingId, version]
      properties:
        sourceContainerBookingId: { type: string }
-        estimatedWarehouseArrivalAt: { type: string, format: date-time, nullable: true, description: 人工维护或入库计划冻结的整柜时间；未维护未建计划时为空，由页面按到港当地日期加两个自然日展示默认日期 }
+        estimatedWarehouseArrivalAt: { type: string, format: date-time, nullable: true }
        actualWarehouseArrivalAt: { type: string, format: date-time, nullable: true, description: 海外 PDA 首次开始收货时间 }
-        version: { type: integer, minimum: -1, description: -1表示柜内时间版本不一致 }
-        planCount: { type: integer, format: int64, minimum: 0, description: 整柜已有入库计划数量；非零时禁止默认推算及改期 }
+        version: { type: integer, minimum: 0 }
    ContainerPlanProgressDetail:
      type: object
      required: [summary, orders]
@@ -4202,10 +4274,7 @@ components:
        invalidatedReason:
          type: string
          nullable: true
-        attachments:
-          $ref: '#/components/schemas/DispatchReviewAttachments'
      required:
-      - attachments
      - status
      - reason
      - reviewerId
@@ -5190,7 +5259,6 @@ components:
      - LOADING_COMPLETE
      - ARRANGE_DELIVERY
      - DEPART
-      - MARK_EXCEPTION
    DispatchGate:
      type: object
      x-java-record: DispatchContracts.Gate
@@ -5253,19 +5321,6 @@ components:
      type: object
      x-java-record: DispatchContracts.DriverEvidence
      properties:
-        masterLicenseFileId:
-          type: string
-          pattern: ^[1-9][0-9]*$
-          nullable: true
-          description: 取货排车显式冻结的司机主档驾驶证ID，包含在响应fileIds中；其余取货证照为本车上传。普通派送沿既有MASTER证照语义。
-        photoFileIds:
-          type: array
-          maxItems: 20
-          uniqueItems: true
-          description: 维护车辆司机时保存的本趟司机照片，按DRIVER_PHOTO类别校验，与驾驶证附件独立。
-          items:
-            type: string
-            pattern: ^[1-9][0-9]*$
        licenseNo:
          type: string
          nullable: true
@@ -5888,47 +5943,6 @@ components:
      required:
      - recordVersion
      - idempotencyKey
-    DispatchReviewAttachments:
-      type: object
-      description: 本次审核补充证据；省略或null为三组空数组。每类最多20个且不得重复；逐个验证本车和类别归属，不接受MASTER档案证照冒充本车审核上传。
-      x-java-record: DispatchContracts.ReviewAttachments
-      properties:
-        vehicleFileIds:
-          type: array
-          maxItems: 20
-          uniqueItems: true
-          description: 本车VEHICLE证据文件ID。
-          items:
-            oneOf:
-            - type: string
-              pattern: ^[1-9][0-9]*$
-            - type: integer
-              format: int64
-              minimum: 1
-        driverPhotoFileIds:
-          type: array
-          maxItems: 20
-          uniqueItems: true
-          description: 本车DRIVER_PHOTO证据文件ID。
-          items:
-            oneOf:
-            - type: string
-              pattern: ^[1-9][0-9]*$
-            - type: integer
-              format: int64
-              minimum: 1
-        licenseFileIds:
-          type: array
-          maxItems: 20
-          uniqueItems: true
-          description: 本车DRIVER证据文件ID。
-          items:
-            oneOf:
-            - type: string
-              pattern: ^[1-9][0-9]*$
-            - type: integer
-              format: int64
-              minimum: 1
    DispatchReviewCommand:
      type: object
      x-java-record: DispatchCommands.ReviewCommand
@@ -5949,10 +5963,6 @@ components:
        reason:
          type: string
          nullable: true
-        attachments:
-          allOf:
-          - $ref: '#/components/schemas/DispatchReviewAttachments'
-          nullable: true
      required:
      - recordVersion
      - idempotencyKey
@@ -6023,13 +6033,18 @@ components:
        manifestHash:
          type: string
          nullable: true
+        measurements:
+          type: array
+          items:
+            $ref: '#/components/schemas/DispatchLoadingMeasurement'
+          nullable: true
        remark:
          type: string
          nullable: true
      required:
      - recordVersion
      - idempotencyKey
-      description: 必须先由真实PDA拣货核平；按已扫实托确认装车；重量体积由服务端已有测量带出，缺失不阻塞，不接受现场补填测量或箱数。
+      description: 必须先由真实PDA拣货核平；这里只确认实载，不代填拣货箱数，不等于实际发车。
    DispatchDepart:
      type: object
      x-java-record: DispatchCommands.Depart
@@ -6371,10 +6386,6 @@ components:
          items:
            $ref: '#/components/schemas/DispatchBatchReference'
          nullable: true
-        exceptions:
-          type: array
-          items:
-            $ref: '#/components/schemas/DispatchExceptionRecord'
      required:
      - route
      - plannedDepartureAt
@@ -6382,7 +6393,6 @@ components:
      - estimatedArrivalAt
      - fbaAppointments
      - appointmentBatches
-      - exceptions
    DispatchDocuments:
      type: object
      x-java-record: DispatchViews.Documents
@@ -6576,10 +6586,6 @@ components:
          allOf:
          - $ref: '#/components/schemas/DispatchReviews'
          nullable: true
-        resources:
-          allOf:
-          - $ref: '#/components/schemas/DispatchResources'
-          nullable: true
        counts:
          allOf:
          - $ref: '#/components/schemas/DispatchCounts'
@@ -6604,7 +6610,6 @@ components:
      - stage
      - recordVersion
      - reviews
-      - resources
      - counts
      - pickingReconciled
      - items
@@ -8002,66 +8007,5 @@ components:
      - sourceInboundOrderNo
      - sourceInboundCode
      - productQuantity
-
-    DispatchExceptionType:
-      type: string
-      enum: [REFUSED, PARTIAL_RECEIPT, VEHICLE_EXCEPTION]
-      description: 拒收、部分签收、车辆异常。
-    DispatchReturnDirection:
-      type: string
-      enum: [OVERSEAS_WAREHOUSE, OTHER]
-      description: 退回海外仓、其他；仅登记去向，不自动退货入库。
-    DispatchMarkException:
-      type: object
-      x-java-record: DispatchCommands.MarkException
-      required: [recordVersion, idempotencyKey, exceptionType]
-      properties:
-        recordVersion:
-          oneOf:
-          - type: string
-            pattern: ^[0-9]+$
-          - type: integer
-            minimum: 0
-        idempotencyKey:
-          type: string
-        exceptionType:
-          $ref: '#/components/schemas/DispatchExceptionType'
-        returnDirection:
-          allOf:
-          - $ref: '#/components/schemas/DispatchReturnDirection'
-          nullable: true
-        description:
-          type: string
-          maxLength: 1000
-          nullable: true
-        imageFileIds:
-          type: array
-          maxItems: 20
-          uniqueItems: true
-          items:
-            type: string
-            pattern: ^[1-9][0-9]*$
-    DispatchExceptionRecord:
-      type: object
-      x-java-record: DispatchViews.ExceptionRecord
-      required: [exceptionType, returnDirection, description, imageFileIds, occurredAt]
-      properties:
-        exceptionType:
-          $ref: '#/components/schemas/DispatchExceptionType'
-        returnDirection:
-          allOf:
-          - $ref: '#/components/schemas/DispatchReturnDirection'
-          nullable: true
-        description:
-          type: string
-          nullable: true
-        imageFileIds:
-          type: array
-          items:
-            type: string
-        occurredAt:
-          type: string
-          format: date-time
-
  securitySchemes:
    bearerAuth: { type: http, scheme: bearer, bearerFormat: JWT }
@@ -9,7 +9,7 @@ paths:
  /api/pda/v1/last-leg/dispatches:
    get:
      summary: 读取Token绑定仓五阶段整车任务
-      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。不接收客户或仓库范围参数；真实客户归属保留在items，整车公共版本及Gate由服务端返回。未指定阶段时返回待理货审核及装车、装车后、派送中的任务；车辆与司机依据读取resources。
+      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。不接收客户或仓库范围参数；真实客户归属保留在items，整车公共版本及Gate由服务端返回。
      security:
      - bearerAuth: []
      responses:
@@ -208,53 +208,10 @@ paths:
      required: true
      schema:
        type: string
-  /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-review:
-    post:
-      summary: 理货员审核整车，后台与PDA共用审核轮次
-      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。仅绑定仓且调度审核通过的本轮整车可审核；REJECTED 必填 reason 并退回客服处理，APPROVED 才进入 LOADING；公共版本拒绝双端重复审核，原键恢复仍核验本人、绑定仓和理货权限。
-      security:
-      - bearerAuth: []
-      responses:
-        '200':
-          description: 统一ApiResponse；业务失败通过code返回，不能仅凭HTTP200判断成功。
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  code:
-                    type: string
-                  message:
-                    type: string
-                  requestId:
-                    type: string
-                    nullable: true
-                  traceId:
-                    type: string
-                    nullable: true
-                  timestamp:
-                    type: string
-                    format: date-time
-                  data:
-                    allOf:
-                    - $ref: overseas-business-v1.yaml#/components/schemas/DispatchCommandResult
-                    nullable: true
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: overseas-business-v1.yaml#/components/schemas/DispatchReviewCommand
-    parameters:
-    - name: dispatchNo
-      in: path
-      required: true
-      schema:
-        type: string
  /api/pda/v1/last-leg/dispatches/{dispatchNo}/loading-complete:
    post:
-      summary: 确认装车完成，资料齐全时自动进入派送中
-      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。只用整车recordVersion和全载荷幂等键；扫码执行真实库存SHIP，装车完成和发车不重复SHIP。错误或结果未知保留原请求核对。 装车中可通过loading-documents同步保存五张装车照片。原请求保存实载确认；成功action为LOADING_COMPLETE，资料已齐时stage为DELIVERING，未齐时为AFTER_LOADING，result保留真实Loaded装车证据。装车确认与资料齐全两项均完成时自动生成派送并发车；触发该次推进的装车确认或最后一次绑定与派送同事务回滚，先前已保存照片保留。重试装车原键保持原最终阶段结果，当前阶段另行读取。
+      summary: 真实拣货核平后显式确认装车完成
+      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。只用整车recordVersion和全载荷幂等键；扫码执行真实库存SHIP，装车完成和发车不重复SHIP。错误或结果未知保留原请求核对。
      security:
      - bearerAuth: []
      responses:
@@ -294,6 +251,49 @@ paths:
      required: true
      schema:
        type: string
+  /api/pda/v1/last-leg/dispatches/{dispatchNo}/depart:
+    post:
+      summary: 完整安排派送后确认实际发车
+      description: 权限 OVERSEAS_WAREHOUSE_PDA_OPERATOR + lastleg:pda:operate。只用整车recordVersion和全载荷幂等键；扫码执行真实库存SHIP，装车完成和发车不重复SHIP。错误或结果未知保留原请求核对。
+      security:
+      - bearerAuth: []
+      responses:
+        '200':
+          description: 统一ApiResponse；业务失败通过code返回，不能仅凭HTTP200判断成功。
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  code:
+                    type: string
+                  message:
+                    type: string
+                  requestId:
+                    type: string
+                    nullable: true
+                  traceId:
+                    type: string
+                    nullable: true
+                  timestamp:
+                    type: string
+                    format: date-time
+                  data:
+                    allOf:
+                    - $ref: overseas-business-v1.yaml#/components/schemas/DispatchCommandResult
+                    nullable: true
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: overseas-business-v1.yaml#/components/schemas/DispatchDepart
+    parameters:
+    - name: dispatchNo
+      in: path
+      required: true
+      schema:
+        type: string
  /api/pda/v1/last-leg/outbound-tasks:
    get:
      summary: 查询Token绑定仓的一件代发出库任务
@@ -2,7 +2,6 @@ package com.baiyue.lastleg.calendar;

 import com.baomidou.mybatisplus.core.MybatisConfiguration;
 import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
-import com.baiyue.lastleg.mapper.LastlegOrderMapper;
 import org.apache.ibatis.mapping.Environment;
 import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
 import org.h2.jdbcx.JdbcDataSource;
@@ -29,23 +28,12 @@ class WarehouseCalendarMapperTest {
        }
        var config=new MybatisConfiguration(); config.setEnvironment(new Environment("test",new JdbcTransactionFactory(),ds));
        config.addMapper(WarehouseCalendarMapper.class);
-        config.addMapper(LastlegOrderMapper.class);
        try(var session=new MybatisSqlSessionFactoryBuilder().build(config).openSession()) {
            var rows=session.getMapper(WarehouseCalendarMapper.class).calendar(LocalDateTime.parse("2026-11-01T00:00:00"),LocalDateTime.parse("2026-12-01T00:00:00"),List.of("1"));
            assertEquals(3,rows.size());
            assertEquals("1",rows.get(0).sourceContainerBookingId()); assertNull(rows.get(0).plannedAt());
            assertEquals(2,rows.get(1).version()); assertEquals("2026-11-10T09:00",rows.get(1).plannedAt().toString());
            assertEquals(1,rows.get(2).planCount()); assertNotNull(rows.get(2).plannedAt());
-            // 清关提柜与日历必须读取相同的人工/冻结事实，默认日期由前端统一推算。
-            var customs=session.getMapper(LastlegOrderMapper.class).findContainerArrivalTimes(List.of("1","2","3"));
-            assertEquals(3,customs.size());
-            for(var calendar:rows) {
-                var arrival=customs.stream().filter(row -> row.sourceContainerBookingId().equals(calendar.sourceContainerBookingId())).findFirst().orElseThrow();
-                assertEquals(calendar.plannedAt(),arrival.estimatedWarehouseArrivalAt());
-                assertEquals(calendar.actualAt(),arrival.actualWarehouseArrivalAt());
-                assertEquals(calendar.version(),arrival.version());
-                assertEquals(calendar.planCount(),arrival.planCount());
-            }
        }
    }
 }
@@ -37,7 +37,6 @@ import static org.mockito.Mockito.*;
 /** 真实生产Mapper及事务验证任何客户或主单CAS失败时全车原子回滚。 */
 class DispatchDeliveryArrangementPersistenceTest {
    private JdbcTemplate db;
-    private org.springframework.transaction.support.TransactionTemplate tx;
    private DispatchDeliveryService service;
    private final DispatchExecutionPort execution=mock(DispatchExecutionPort.class);
    private final DispatchDeliveryFees fees=mock(DispatchDeliveryFees.class);
@@ -50,7 +49,6 @@ class DispatchDeliveryArrangementPersistenceTest {
    @BeforeEach void prepare() throws Exception {
        var ds=new DriverManagerDataSource("jdbc:h2:mem:arrangement-"+UUID.randomUUID()+";MODE=MySQL;DB_CLOSE_DELAY=-1","sa","");
        db=new JdbcTemplate(ds);
-        tx=new org.springframework.transaction.support.TransactionTemplate(new DataSourceTransactionManager(ds));
        for (var type:List.of(OutboundOrder.class,OutboundPalletItem.class,DeliveryOrder.class,LastlegOrder.class,LastlegOrderStatusHistory.class)) {
            String columns=Arrays.stream(type.getDeclaredFields()).filter(f->!Modifier.isStatic(f.getModifiers())).map(f->{
                String name=f.getName().replaceAll("([A-Z])","_$1").toLowerCase();
@@ -175,32 +173,6 @@ class DispatchDeliveryArrangementPersistenceTest {
        assertEquals(6L,frozen.stream().filter(c->c.attributionId()==4).findFirst().orElseThrow().sourceOrigin().productQuantity());
    }

-    /** 自动装车加入父事务，最终主单失败时全部客户单据与来源绑定均回滚。 */
-    @Test void automaticPreparationSharesLoadingParentTransactionAndRollback() {
-        assertThrows(IllegalStateException.class,()->tx.execute(status->{
-            service.prepareForDeparture(context,actor,"LOADING-FAIL");
-            throw new IllegalStateException("装车最终保存失败");
-        }));
-        for(var table:List.of("ll_outbound_order","ll_outbound_pallet_item","ll_delivery_order","ll_dispatch_delivery_arrangement","ll_loading_order_status_history"))
-            assertEquals(0,db.queryForObject("SELECT COUNT(*) FROM "+table,Integer.class));
-        assertEquals(2,db.queryForObject("SELECT COUNT(*) FROM ll_order WHERE outbound_order_no IS NULL AND version=0",Integer.class));
-        var fact=tx.execute(status->service.prepareForDeparture(context,actor,"LOADING-OK"));
-        assertEquals(2,fact.result().deliveries().size());
-        assertEquals(2,db.queryForObject("SELECT COUNT(*) FROM ll_delivery_order WHERE planned_delivery_at IS NULL AND delivery_method IS NULL AND pickup_method IS NULL AND loading_type IS NULL",Integer.class));
-        assertEquals(2,db.queryForObject("SELECT COUNT(*) FROM ll_outbound_order WHERE fee_coverage_json IS NULL",Integer.class));
-        clearInvocations(fees);
-        assertEquals(fact,tx.execute(status->service.prepareForDeparture(context,actor,"LOADING-OK")));
-        verifyNoInteractions(fees);
-    }
-
-    /** 外接费用发布失败同样回滚自动生成的全部客户单据，不能留下半车。 */
-    @Test void automaticExternalFreightFailureRollsBackEveryCustomer() {
-        doThrow(new IllegalStateException("外接费用发布失败")).when(fees).publish(any(),argThat(g->g.customerId().equals("102")),any(),any(),any(),any(),anyString(),anyString());
-        assertThrows(IllegalStateException.class,()->tx.execute(status->service.prepareForDeparture(context,actor,"LOADING-FAIL")));
-        assertEquals(0,db.queryForObject("SELECT COUNT(*) FROM ll_outbound_order",Integer.class));
-        assertEquals(0,db.queryForObject("SELECT COUNT(*) FROM ll_delivery_order",Integer.class));
-    }
-
    /** 按真实共享记录构造完整客户目的地请求。 */
    private ArrangeDelivery request() { return new ArrangeDelivery(3L,"ARRANGE-1","cargo-hash","loading-hash",grouping.groups(context).stream().map(g->
        new ArrangeGroup(g.key(),g.cargoHash(),DEPARTED,"TRUCK",null,null,"WAREHOUSE_PICKUP","PALLET",null,null,null,null,null,
@@ -72,38 +72,6 @@ class DispatchDeliveryServiceTest {
        verify(fees,times(3)).publish(any(),any(),any(),any(),isNull(),any(),eq("OP-A"),anyString());
    }

-    /** PDA装车自动生成完整客户目的地，不猜派送计划、不要求人工费用或原费覆盖。 */
-    @Test void loadingAutomaticallyCreatesDocumentsWithoutInventedInputsOrFees() {
-        var pda=new Actor("PDA-1",ActorMode.PDA,"1001");
-        var fact=service.prepareForDeparture(context,pda,"LOADING-1");
-        assertEquals(2,fact.result().outbounds().size());assertEquals(3,fact.result().deliveries().size());
-        assertEquals(4,fact.result().recordVersion());
-        assertTrue(deliveries.stream().allMatch(d->d.getPlannedDeliveryAt()==null && d.getDeliveryMethod()==null
-            && d.getPickupMethod()==null && d.getLoadingType()==null));
-        assertTrue(outbounds.stream().allMatch(o->o.getFeeCoverageJson()==null));
-        assertTrue(calls.indexOf("SOURCE")>calls.lastIndexOf("DELIVERY"));
-        verify(fees,never()).validate(any(),any(),any(),any());verify(fees,never()).coverage(any(),any(),any(),any());
-        var inputs=org.mockito.ArgumentCaptor.forClass(ArrangeGroup.class);
-        verify(fees,times(3)).publish(eq(context),any(),inputs.capture(),any(),isNull(),any(),eq("PDA-1"),anyString());
-        assertTrue(inputs.getAllValues().stream().allMatch(i->i.fees().isEmpty() && i.feeCoverage().isEmpty()));
-        clearInvocations(fees,repository);
-        assertEquals(fact,service.prepareForDeparture(context,pda,"LOADING-1"));
-        verifyNoInteractions(fees);verify(repository,never()).create(any(OutboundOrder.class));
-        assertThrows(org.springframework.web.server.ResponseStatusException.class,
-            ()->service.prepareForDeparture(context,pda,"DIFFERENT-KEY"));
-    }
-
-    /** 自动生成仍拒绝越仓与孤立子单，不为异常半车补造第二套事实。 */
-    @Test void automaticPreparationRejectsWrongWarehouseAndOrphanDocuments() {
-        assertThrows(org.springframework.web.server.ResponseStatusException.class,
-            ()->service.prepareForDeparture(context,new Actor("PDA-1",ActorMode.PDA,"OTHER"),"LOADING-1"));
-        verifyNoInteractions(repository,fees);
-        outbounds.add(new OutboundOrder());
-        assertThrows(org.springframework.web.server.ResponseStatusException.class,
-            ()->service.prepareForDeparture(context,actor,"LOADING-1"));
-        verifyNoInteractions(fees);
-    }
-
    /** 同实托的两申请分别冻结原货源，出库引用逐次归属且真实客户目的地与履约订单不被替换。 */
    @Test void relabelOriginsStayFrozenBehindOutboundAttributionReferences() throws Exception {
        var first=new SourceOrigin(10001L,201L,301L,401L,701L,"IN-701","CODE-701",null);
@@ -97,6 +97,8 @@ class PlatformDispatchOutboundContractTest {
            String.class, DispatchCommands.Update.class);
        Method cancel = DispatchAggregateController.class.getMethod("cancel", AuthenticatedUser.class,
            String.class, DispatchCommands.ReasonCommand.class);
+        Method transfer = DeliveryTransferController.class.getMethod("transfer", AuthenticatedUser.class,
+            String.class, com.baiyue.lastleg.dispatch.port.DispatchDeliveryModels.ArrangeDelivery.class);
        Method externalFreight = DeliveryTransferController.class.getMethod("externalFreight", AuthenticatedUser.class, String.class);
        assertPermission(externalFreight, OverseasPermissions.DISPATCH_LIST);
        Method outboundDetail = DeliveryTransferController.class.getMethod("outboundDetail",
@@ -111,12 +113,11 @@ class PlatformDispatchOutboundContractTest {
        assertEquals(Set.of("/{dispatchNo}/cancel"), Set.of(cancelRoute.value()));
        assertFalse(cancel.isAnnotationPresent(org.springframework.web.bind.annotation.DeleteMapping.class));
        assertTrue(cancel.getParameters()[2].isAnnotationPresent(org.springframework.web.bind.annotation.RequestBody.class));
-        assertTrue(Arrays.stream(DeliveryTransferController.class.getDeclaredMethods())
-            .noneMatch(method -> Set.of("transfer", "arrangement").contains(method.getName())));
+        assertPermission(transfer, OverseasPermissions.DISPATCH_TRANSFER_DELIVERY);
        assertPermission(outboundDetail, OverseasPermissions.OUTBOUND_LIST);
        assertEquals(2, outboundDetail.getParameterCount());
        assertPermission(outboundCancel, OverseasPermissions.OUTBOUND_CANCEL);
-        for (Method method : Set.of(update, cancel, externalFreight, outboundDetail, outboundCancel)) {
+        for (Method method : Set.of(update, cancel, transfer, externalFreight, outboundDetail, outboundCancel)) {
            assertTrue(Arrays.stream(method.getParameters())
                .noneMatch(parameter -> parameter.isAnnotationPresent(RequestParam.class)));
        }
@@ -201,13 +202,16 @@ class PlatformDispatchOutboundContractTest {
        assertFalse(schema.contains("uk_ll_outbound_no (customer_id,outbound_no)"));
    }

-    /** 公开协议撤销人工安排入口，内部完整派送事实仍保留多客户和多目的地数组。 */
+    /** 当前整车请求按公共版本一次提交全部组，响应保留多客户出库及多目的地派送数组。 */
    @Test
    void openApiPublishesOnlyTheFrozenPlatformProtocol() throws Exception {
        String yaml = Files.readString(Path.of("src/main/resources/openapi/overseas-business-v1.yaml"),
            StandardCharsets.UTF_8);
        String dispatchAction = slice(yaml, "  /api/platform/v1/last-leg/dispatches/{dispatchNo}:",
            "  /api/platform/v1/last-leg/dispatches/candidates:");
+        String transfer = slice(yaml,
+            "  /api/platform/v1/last-leg/dispatches/{dispatchNo}/transfer-delivery:",
+            "  /api/platform/v1/last-leg/outbound-orders:");
        String outboundDetail = slice(yaml,
            "  /api/platform/v1/last-leg/outbound-orders/{outboundNo}:",
            "  /api/platform/v1/last-leg/outbound-orders/{outboundNo}/cancel:");
@@ -215,7 +219,7 @@ class PlatformDispatchOutboundContractTest {
            "  /api/platform/v1/last-leg/outbound-orders/{outboundNo}/cancel:",
            "  /api/platform/v1/last-leg/overseas-procurements:");

-        for (String action : Set.of(dispatchAction, outboundDetail, outboundCancel)) {
+        for (String action : Set.of(dispatchAction, transfer, outboundDetail, outboundCancel)) {
            assertFalse(action.contains("name: customerId"));
        }
        assertTrue(outboundDetail.contains("pallets[].palletNo"));
@@ -224,13 +228,24 @@ class PlatformDispatchOutboundContractTest {
        assertTrue(yaml.contains("单次 SQL 返回，不逐行补查"));
        assertTrue(yaml.contains("platform:overseas-warehouse:dispatch:edit"));
        assertTrue(yaml.contains("platform:overseas-warehouse:dispatch:cancel"));
-        assertFalse(yaml.contains("  /api/platform/v1/last-leg/dispatches/{dispatchNo}/transfer-delivery:"));
-        assertFalse(yaml.contains("  /api/platform/v1/last-leg/dispatches/{dispatchNo}/delivery-arrangement:"));
+        assertTrue(yaml.contains("platform:overseas-warehouse:dispatch:transfer-delivery"));
        assertTrue(yaml.contains("platform:overseas-warehouse:outbound:list"));
        assertTrue(yaml.contains("platform:overseas-warehouse:outbound:create"));
        assertTrue(yaml.contains("platform:overseas-warehouse:outbound:cancel"));
        java.util.Map<?,?> document = new org.yaml.snakeyaml.Yaml().load(yaml);
        java.util.Map<?,?> schemas = (java.util.Map<?,?>)((java.util.Map<?,?>)document.get("components")).get("schemas");
+        java.util.Map<?,?> arrange = (java.util.Map<?,?>)schemas.get("DispatchArrangeDelivery");
+        assertNotNull(arrange);
+        assertTrue(((java.util.List<?>)arrange.get("required")).containsAll(java.util.List.of("recordVersion", "idempotencyKey")));
+        java.util.Map<?,?> fields = (java.util.Map<?,?>)arrange.get("properties");
+        assertTrue(fields.keySet().containsAll(java.util.Set.of("recordVersion", "idempotencyKey", "cargoHash", "loadingCompletionHash", "groups")));
+        assertFalse(fields.containsKey("customerId"));
+        assertFalse(fields.containsKey("expectedVersion"));
+        java.util.Map<?,?> groups = (java.util.Map<?,?>)fields.get("groups");
+        assertEquals("array", groups.get("type"));
+        assertEquals("#/components/schemas/DispatchArrangeGroup", ((java.util.Map<?,?>)groups.get("items")).get("$ref"));
+        java.util.Map<?,?> groupFields = (java.util.Map<?,?>)((java.util.Map<?,?>)schemas.get("DispatchArrangeGroup")).get("properties");
+        assertTrue(groupFields.keySet().containsAll(java.util.Set.of("groupKey", "groupCargoHash", "fees", "feeCoverage")));
        java.util.Map<?,?> resultFields = (java.util.Map<?,?>)((java.util.Map<?,?>)schemas.get("DispatchArrangementResult")).get("properties");
        assertEquals("array", ((java.util.Map<?,?>)resultFields.get("outbounds")).get("type"));
        assertEquals("array", ((java.util.Map<?,?>)resultFields.get("deliveries")).get("type"));
@@ -38,9 +38,6 @@ class SmartDispatchOpenApiContractTest {
        assertThat(map(paths.get(base+"/drafts"))).containsKey("get");
        var candidate=map(map(paths.get(base+"/candidates")).get("get"));
        var parameterNames=((List<?>)candidate.get("parameters")).stream().map(SmartDispatchOpenApiContractTest::map).map(p->p.get("name")).toList();
-        var warehouseParameter=((List<?>)candidate.get("parameters")).stream().map(SmartDispatchOpenApiContractTest::map)
-            .filter(p->"warehouseId".equals(p.get("name"))).findFirst().orElseThrow();
-        assertThat(warehouseParameter.get("required")).isEqualTo(false);
        assertThat(parameterNames).contains("warehouseId","destinationWarehouseCode","draftToken","page","size","warehouseTab").doesNotContain("customerId","fbaWarehouseCode");
        assertThat(map(map(schemas.get("DispatchCandidateList")).get("properties")).keySet())
            .containsExactlyInAnyOrder("candidates","snapshotAt","complete","total","page","size","pages");
@@ -45,16 +45,6 @@ class SmartDispatchControllerTest {
            .andExpect(status().isOk());
        verify(aggregate).candidates(actor,new CandidateQuery("92",null,null,"LAX9",null,null,1,20,"ALL"));verifyNoInteractions(planning);
    }
-    /** 区域入口无需隐藏默认仓，全部与城市均由服务端分页。 */
-    @Test void candidateHttpQueryAllowsRegionalBrowsingWithoutWarehouse()throws Exception {
-        var mvc=MockMvcBuilders.standaloneSetup(controller).setCustomArgumentResolvers(new AuthenticationPrincipalArgumentResolver()).build();
-        SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken(platform(),null,List.of()));
-        for(String tab:List.of("ALL","LAX","NYC")) {
-            mvc.perform(get("/api/platform/v1/last-leg/dispatches/candidates").param("warehouseTab",tab)).andExpect(status().isOk());
-            verify(aggregate).candidates(actor,new CandidateQuery(null,null,null,null,null,null,1,20,tab));
-        }
-        verifyNoInteractions(planning);
-    }
    /** 每个写入都将冻结DTO原样传递，拥有者只能来自认证主体。 */
    @Test void allDraftRoutesDelegateFrozenVersionedRequests(){
        var create=new CreateDraft("create","92");var container=new CreateContainer(0L,"container","d",15);
@@ -37,23 +37,6 @@ class HttpDispatchEvidenceGatewayTest {
        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",own),9,DispatchEvidenceGateway.Kind.VEHICLE,3L)).isInstanceOf(ResponseStatusException.class);
        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",own),9,DispatchEvidenceGateway.Kind.DRIVER,4L)).isInstanceOf(ResponseStatusException.class);
    }
-    /** 司机照片使用独立本车类别且禁止PDF，不与驾驶证证据串用。 */
-    @Test void driverPhotoUsesDistinctKindAndImageOnly() {
-        var photo=new HttpDispatchEvidenceGateway.Metadata(3L,0L,"OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE","9","driver.png","image/png",128L);
-        assertThat(HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",photo),9,DispatchEvidenceGateway.Kind.DRIVER_PHOTO,3L).fileId()).isEqualTo(3L);
-        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",photo),9,DispatchEvidenceGateway.Kind.DRIVER,3L)).isInstanceOf(ResponseStatusException.class);
-        var pdf=new HttpDispatchEvidenceGateway.Metadata(3L,0L,"OVERSEAS_DISPATCH_DRIVER_PHOTO_EVIDENCE","9","driver.pdf","application/pdf",128L);
-        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",pdf),9,DispatchEvidenceGateway.Kind.DRIVER_PHOTO,3L)).isInstanceOf(ResponseStatusException.class);
-    }
-    /** 异常图片独立归属本车，审核照片及PDF均不能用作异常图片。 */
-    @Test void exceptionImagesRejectOtherKindsCarsAndPdf() {
-        var photo=new HttpDispatchEvidenceGateway.Metadata(3L,0L,"OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE","9","exception.png","image/png",128L);
-        assertThat(HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",photo),9,DispatchEvidenceGateway.Kind.EXCEPTION,3L).fileId()).isEqualTo(3L);
-        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",photo),10,DispatchEvidenceGateway.Kind.EXCEPTION,3L)).isInstanceOf(ResponseStatusException.class);
-        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",photo),9,DispatchEvidenceGateway.Kind.DRIVER_PHOTO,3L)).isInstanceOf(ResponseStatusException.class);
-        var pdf=new HttpDispatchEvidenceGateway.Metadata(3L,0L,"OVERSEAS_DISPATCH_EXCEPTION_EVIDENCE","9","exception.pdf","application/pdf",128L);
-        assertThatThrownBy(()->HttpDispatchEvidenceGateway.verified(new HttpDispatchEvidenceGateway.Envelope("200",pdf),9,DispatchEvidenceGateway.Kind.EXCEPTION,3L)).isInstanceOf(ResponseStatusException.class);
-    }
    /** 客户、旧主档或缺失媒体类型均拒绝，不因为文件本身存在而放行。 */
    @Test void rejectsForeignTenantMasterScopeAndMalformedMetadata() {
        for(var value:java.util.List.of(
@@ -86,25 +86,6 @@ public class DispatchAggregatePersistenceTest {
        verify(e.files,never()).download(anyLong(),anyLong());verifyNoInteractions(e.dispatchFiles);
    }

-    /** 取货已保存的补传证照保持本车归属，只有明确主档引用可以读取司机证照。 */
-    @Test void pickupSavedLicenseUploadsDoNotBecomeMasterLicenseReferences() throws Exception {
-        var e=new DriverEvidenceFixture();var number=e.dispatch(ResourceMode.MASTER,71L,List.of(81L,91L));
-        var row=e.f.repository.find(number);
-        var resources=e.f.json.readValue(row.getResourcesJson(),DispatchContracts.Resources.class);
-        var d=resources.driver();var proof=d.evidence();
-        var next=new DispatchContracts.Resources(resources.vehicle(),new DispatchContracts.DriverSnapshot(d.mode(),d.driverId(),d.name(),d.phone(),
-            new DispatchContracts.DriverEvidence(proof.licenseNo(),proof.licenseExpiresOn(),proof.fileIds(),proof.expectedTaskEndAt(),proof.photoFileIds(),81L)));
-        e.f.db.update("UPDATE ll_dispatch_order SET task_type='PICKUP', resources_json=? WHERE dispatch_no=?",e.f.json.writeValueAsString(next),number);
-        var kind=com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.Kind.DRIVER;
-        var uploaded=new com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway.File(91L,"pickup.png","image/png",3L);
-        when(e.dispatchFiles.metadata(row.getId(),kind,91L)).thenReturn(uploaded);
-        assertThat(e.f.service.evidenceMetadata(e.f.actor,number,kind,91L)).isEqualTo(uploaded);
-        verifyNoInteractions(e.driverRows,e.history,e.files);
-        e.allowFile(81L);
-        assertThat(e.f.service.evidenceMetadata(e.f.actor,number,kind,81L).fileId()).isEqualTo(81L);
-        verify(e.files).metadata(71L,81L);
-    }
-
    /** MASTER改外配的编辑尚未保存时，新上传文件只走本车归属，不误借旧司机白名单。 */
    @Test void unsavedExternalUploadOnMasterDispatchRetainsOriginalDispatchFileReads() throws Exception {
        var e=new DriverEvidenceFixture();var number=e.dispatch(ResourceMode.MASTER,71L,List.of(81L));
@@ -167,7 +148,7 @@ public class DispatchAggregatePersistenceTest {
        String dispatch(ResourceMode mode,Long driverId,List<Long> ids) throws Exception {
            var created=f.tx.execute(t->f.service.create(f.actor,f.create("evidence-"+UUID.randomUUID(),List.of())));
            var resource=new DispatchContracts.Resources(null,new DispatchContracts.DriverSnapshot(mode,driverId,"测试司机","123456789",
-                new DispatchContracts.DriverEvidence("TEST-LICENSE",LocalDate.of(2099,1,1),ids,Instant.parse("2098-01-01T00:00:00Z"),List.of())));
+                new DispatchContracts.DriverEvidence("TEST-LICENSE",LocalDate.of(2099,1,1),ids,Instant.parse("2098-01-01T00:00:00Z"))));
            f.db.update("UPDATE ll_dispatch_order SET resources_json=? WHERE dispatch_no=?",f.json.writeValueAsString(resource),created.dispatchNo());return created.dispatchNo();
        }
        /** File内容固定为离线测试字节；真实复合归属由既有两个HTTP网关合同分别覆盖。 */
@@ -283,8 +264,10 @@ public class DispatchAggregatePersistenceTest {
        var preview=f.tx.execute(s->f.service.loading(f.actor,created.dispatchNo()));
        assertThat(preview.pallets().get(0).weightKg()).isEqualByComparingTo("100");
        assertThat(preview.pallets().get(0).evidence()).allMatch(DispatchPlanningModels.MeasurementEvidence::actual);
-        assertThat(preview.pallets().get(1).weightKg()).isNull();assertThat(preview.pallets().get(1).missingFields()).contains("weightKg","volumeCbm");
-        var request=new DispatchCommands.LoadingComplete(approved.recordVersion(),"explicit-loaded",preview.manifestHash(),"实际核对");
+        assertThat(preview.pallets().get(1).weightKg()).isNull();assertThat(preview.pallets().get(1).missingFields()).contains("weightKg","volumeCbm","palletSpaces");
+        var measurements=preview.pallets().stream().map(p->new DispatchContracts.LoadingMeasurement(p.warehousePalletId(),1,
+            p.warehousePalletId()==501L?new BigDecimal("100"):new BigDecimal("200"),p.warehousePalletId()==501L?BigDecimal.ONE:new BigDecimal("2"),p.deliveryIndex())).toList();
+        var request=new DispatchCommands.LoadingComplete(approved.recordVersion(),"explicit-loaded",preview.manifestHash(),measurements,"实际核对");
        // 捕获失败必须回滚同一原生装车事务，不能留下装车后状态或成功命令。
        org.mockito.Mockito.doThrow(new IllegalStateException("ownership-capture-failed")).doNothing()
            .when(f.ownedBusinessOwnership).capture(anyLong(),org.mockito.ArgumentMatchers.nullable(Long.class),
@@ -296,10 +279,6 @@ public class DispatchAggregatePersistenceTest {
        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_command WHERE idempotency_key='explicit-loaded'",Long.class)).isZero();
        var loaded=f.tx.execute(s->f.service.loadingComplete(f.actor,created.dispatchNo(),request));
        assertThat(loaded.stage()).isEqualTo(Stage.AFTER_LOADING);assertThat(loaded.result()).isInstanceOf(DispatchResults.Loaded.class);
-        var facts=((DispatchResults.Loaded)loaded.result()).confirmedLoad();
-        assertThat(facts.pallets()).hasSize(2);
-        assertThat(facts.pallets().get(0).weightKg()).isEqualByComparingTo("100");
-        assertThat(facts.pallets().get(1).weightKg()).isNull();assertThat(facts.pallets().get(1).volumeCbm()).isNull();
        assertThat(f.db.queryForObject("SELECT status FROM ll_fleet_trip",String.class)).isEqualTo("PLANNED");
        var replay=f.tx.execute(s->f.service.loadingComplete(f.actor,created.dispatchNo(),request));
        assertThat(replay.replayed()).isTrue();assertThat(replay.result()).isEqualTo(loaded.result());
@@ -318,7 +297,7 @@ public class DispatchAggregatePersistenceTest {
        f.db.update("UPDATE ll_dispatch_pda_pick_order SET packages=2");
        var preview=f.tx.execute(s->f.service.loading(f.actor,created.dispatchNo()));
        assertThat(preview.pickingReconciled()).isFalse();assertThat(preview.loadingComplete().allowed()).isFalse();
-        assertThatThrownBy(()->f.tx.execute(s->f.service.loadingComplete(f.actor,created.dispatchNo(),new DispatchCommands.LoadingComplete(approved.recordVersion(),"missing-rejected",preview.manifestHash(),null)))).isInstanceOf(BizException.class).hasMessageContaining("核平");
+        assertThatThrownBy(()->f.tx.execute(s->f.service.loadingComplete(f.actor,created.dispatchNo(),new DispatchCommands.LoadingComplete(approved.recordVersion(),"missing-rejected",preview.manifestHash(),List.of(),null)))).isInstanceOf(BizException.class).hasMessageContaining("核平");
        assertThat(f.db.queryForObject("SELECT stage FROM ll_dispatch_order",String.class)).isEqualTo("LOADING");
    }
    /** 已提交根的公开资格关闭；新键重复提交不改变事实，原键仍先于当前状态恢复结果。 */
@@ -361,12 +340,12 @@ public class DispatchAggregatePersistenceTest {
            assertSubmissionGate(f,created.dispatchNo(),ReviewState.DRAFT,true);
            var submitted=f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(created.recordVersion(),"submission-states-1",null)));
            assertSubmissionGate(f,created.dispatchNo(),ReviewState.DISPATCH_PENDING,false);
-            var rejected=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submitted.recordVersion(),"submission-states-dispatch-rejected",Decision.REJECTED,"核对调度",null)));
+            var rejected=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submitted.recordVersion(),"submission-states-dispatch-rejected",Decision.REJECTED,"核对调度")));
            assertSubmissionGate(f,created.dispatchNo(),ReviewState.DISPATCH_REJECTED,true);
            var resubmitted=f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(rejected.recordVersion(),"submission-states-2",null)));
-            var approved=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(resubmitted.recordVersion(),"submission-states-dispatch-approved",Decision.APPROVED,null,null)));
+            var approved=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(resubmitted.recordVersion(),"submission-states-dispatch-approved",Decision.APPROVED,null)));
            assertSubmissionGate(f,created.dispatchNo(),ReviewState.LOADING_PENDING,false);
-            var loadingRejected=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(approved.recordVersion(),"submission-states-loading-rejected",Decision.REJECTED,"核对装载",null)));
+            var loadingRejected=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(approved.recordVersion(),"submission-states-loading-rejected",Decision.REJECTED,"核对装载")));
            assertSubmissionGate(f,created.dispatchNo(),ReviewState.LOADING_REJECTED,true);
            f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(loadingRejected.recordVersion(),"submission-states-3",null)));
            assertSubmissionGate(f,created.dispatchNo(),ReviewState.DISPATCH_PENDING,false);
@@ -384,13 +363,13 @@ public class DispatchAggregatePersistenceTest {
        var f=new Fixture();var source=f.source(1,"101",501,"ONT8",3);
        var created=f.tx.execute(s->f.service.create(f.actor,f.configured("review-create",List.of(source))));
        var submit=f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(created.recordVersion(),"submit-1",null)));
-        assertThatThrownBy(()->f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(submit.recordVersion(),"wrong-order",Decision.APPROVED,null,null)))).isInstanceOf(BizException.class);
-        var rejected=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submit.recordVersion(),"reject-1",Decision.REJECTED,"补核装载计划",null)));
+        assertThatThrownBy(()->f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(submit.recordVersion(),"wrong-order",Decision.APPROVED,null)))).isInstanceOf(BizException.class);
+        var rejected=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submit.recordVersion(),"reject-1",Decision.REJECTED,"补核装载计划")));
        var resubmitted=f.tx.execute(s->f.service.submitReview(f.actor,created.dispatchNo(),new DispatchCommands.SubmitReview(rejected.recordVersion(),"submit-2",null)));
-        var approved=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(resubmitted.recordVersion(),"dispatch-approved",Decision.APPROVED,null,null)));
-        var loading=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(approved.recordVersion(),"loading-approved",Decision.APPROVED,null,null)));
+        var approved=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(resubmitted.recordVersion(),"dispatch-approved",Decision.APPROVED,null)));
+        var loading=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(approved.recordVersion(),"loading-approved",Decision.APPROVED,null)));
        assertThat(loading.stage()).isEqualTo(Stage.LOADING);
-        var replay=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submit.recordVersion(),"reject-1",Decision.REJECTED,"补核装载计划",null)));
+        var replay=f.tx.execute(s->f.service.review(f.actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submit.recordVersion(),"reject-1",Decision.REJECTED,"补核装载计划")));
        assertThat(replay.replayed()).isTrue();assertThat(replay.stage()).isEqualTo(Stage.BEFORE_LOADING);assertThat(replay.recordVersion()).isEqualTo(rejected.recordVersion());
        var returned=f.tx.execute(s->f.service.returnToReview(f.actor,created.dispatchNo(),new DispatchCommands.ReturnToReview(loading.recordVersion(),"return-zero","重新核实资源")));
        assertThat(returned.stage()).isEqualTo(Stage.BEFORE_LOADING);
@@ -440,13 +419,12 @@ public class DispatchAggregatePersistenceTest {
        assertThat(f.db.queryForList("SELECT DISTINCT customer_id FROM ll_dispatch_item ORDER BY customer_id",String.class)).containsExactly("101","202");
        assertThat(f.db.queryForObject("SELECT COUNT(DISTINCT dispatch_order_id) FROM ll_dispatch_item",Long.class)).isOne();
        assertThat(f.db.queryForObject("SELECT package_count FROM ll_fleet_trip_dispatch",Integer.class)).isEqualTo(8);
-        var query=new DispatchViews.Query(1,20,null,null,null,"101",null,StatusFilter.ACTIVE,Stage.BEFORE_LOADING,BeforeLoadingSection.VEHICLE_INFO,null);
+        var query=new DispatchViews.Query(1,20,null,null,null,"101",null,StatusFilter.ACTIVE,Stage.BEFORE_LOADING,BeforeLoadingSection.DISPATCH_REVIEW,ReviewStatus.NOT_SUBMITTED);
        var page=f.tx.execute(s->f.service.page(f.actor,query));
        assertThat(page.total()).isOne(); assertThat(page.records()).hasSize(1);
        assertThat(page.records().get(0).counts().packageCount()).isEqualTo(8);
        assertThat(page.statistics().activeTotal()).isOne(); assertThat(page.statistics().stageCounts().get(Stage.BEFORE_LOADING)).isOne();
-        assertThat(page.statistics().beforeLoadingReviewCounts().vehicleInfoTotal()).isOne();
-        assertThat(page.statistics().beforeLoadingReviewCounts().dispatchReview().notSubmitted()).isZero();
+        assertThat(page.statistics().beforeLoadingReviewCounts().dispatchReview().notSubmitted()).isOne();

        long dispatch=f.db.queryForObject("SELECT id FROM ll_dispatch_order",Long.class);
        long item=f.db.queryForObject("SELECT id FROM ll_dispatch_item WHERE customer_id='101'",Long.class);
@@ -612,15 +590,15 @@ public class DispatchAggregatePersistenceTest {
            return new DispatchCommands.Create(key,"9",new DispatchCommands.Vehicle(ResourceMode.EXTERNAL,null,"TEST-TRUCK","测试承运方",
                new DispatchContracts.Capacity(15,new BigDecimal("10000"),new BigDecimal("50")),List.of(101L)),
                new DispatchCommands.Driver(ResourceMode.EXTERNAL,null,"测试司机","123456789",
-                    new DispatchContracts.DriverEvidence("TEST-LICENSE",java.time.LocalDate.of(2099,1,1),List.of(202L),departure.plusSeconds(86400),List.of())),
+                    new DispatchContracts.DriverEvidence("TEST-LICENSE",java.time.LocalDate.of(2099,1,1),List.of(202L),departure.plusSeconds(86400))),
                departure,null,null,sources,List.of());
        }

        /** 通过实际两级流程进入装车，测试不直接伪造通过状态。 */
        public DispatchContracts.CommandResult approve(DispatchContracts.CommandResult created) {
            var submitted=tx.execute(s->service.submitReview(actor,created.dispatchNo(),new DispatchCommands.SubmitReview(created.recordVersion(),created.dispatchNo()+"-submit",null)));
-            var reviewed=tx.execute(s->service.review(actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submitted.recordVersion(),created.dispatchNo()+"-dispatch",Decision.APPROVED,null,null)));
-            return tx.execute(s->service.review(actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(reviewed.recordVersion(),created.dispatchNo()+"-loading",Decision.APPROVED,null,null)));
+            var reviewed=tx.execute(s->service.review(actor,created.dispatchNo(),false,new DispatchCommands.ReviewCommand(submitted.recordVersion(),created.dispatchNo()+"-dispatch",Decision.APPROVED,null)));
+            return tx.execute(s->service.review(actor,created.dispatchNo(),true,new DispatchCommands.ReviewCommand(reviewed.recordVersion(),created.dispatchNo()+"-loading",Decision.APPROVED,null)));
        }
        /** 只为实载端口夹具准备真实扫码/归属记录，不声称运行库存命令。 */
        public void picked(long source,String customer,long pallet,int packages) {
@@ -64,7 +64,7 @@ class DispatchDeparturePersistenceTest {
            var created=f.tx.execute(s->f.service.create(f.actor,f.configured("depart-create",List.of(a,b))));number=created.dispatchNo();var approved=f.approve(created);
            f.picked(1,"101",501,3);f.picked(2,"202",502,5);f.db.update("UPDATE ll_dispatch_order SET picked_package_count=8");
            var loading=f.tx.execute(s->f.service.loading(f.actor,number));var measurements=loading.pallets().stream().map(p->new LoadingMeasurement(p.warehousePalletId(),1,BigDecimal.ONE,BigDecimal.ONE,p.deliveryIndex())).toList();
-            f.tx.executeWithoutResult(s->f.service.loadingComplete(f.actor,number,new DispatchCommands.LoadingComplete(approved.recordVersion(),"depart-loaded",loading.manifestHash(),"实际实载")));
+            f.tx.executeWithoutResult(s->f.service.loadingComplete(f.actor,number,new DispatchCommands.LoadingComplete(approved.recordVersion(),"depart-loaded",loading.manifestHash(),measurements,"实际实载")));
            var context=f.tx.execute(s->f.service.preview(f.actor,number));
            outbounds=List.of(new OutboundReference("101","测试客户101","OUT-A","WAIT_OUTBOUND",3,1),new OutboundReference("202","测试客户202","OUT-B","WAIT_OUTBOUND",5,1));
            deliveryRefs=List.of(new DeliveryReference("GROUP-A","101","测试客户101","OUT-A","DL-A",context.cargo().get(0).destination(),"WAIT_DELIVERY",3,1),new DeliveryReference("GROUP-B","202","测试客户202","OUT-B","DL-B",context.cargo().get(1).destination(),"WAIT_DELIVERY",5,1));
@@ -1,89 +0,0 @@
-package com.baiyue.lastleg.dispatch.service;
-
-import com.baiyue.lastleg.dispatch.gateway.DispatchEvidenceGateway;
-import com.baiyue.lastleg.dispatch.port.DispatchCommands;
-import com.baiyue.lastleg.dispatch.port.DispatchContracts;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.springframework.security.authentication.TestingAuthenticationToken;
-import org.springframework.security.core.context.SecurityContextHolder;
-import org.springframework.test.util.ReflectionTestUtils;
-import java.util.List;
-import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-
-/** 通过真实Mapper和事务验证异常登记，不把登记事实解释成签收或退货。 */
-class DispatchExceptionPersistenceTest {
-    /** 登记使用排车独立维护权限。 */
-    @BeforeEach void authorize() { SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("operator-test","","platform:overseas-warehouse:dispatch:edit")); }
-    /** 清除线程身份，避免影响其他权限回归。 */
-    @AfterEach void clear() { SecurityContextHolder.clearContext(); }
-
-    /** 每种原型类型均可保存，原键重试不追加，最终完成后仍恢复原结果。 */
-    @Test void recordsAllTypesAndReplaysWithoutChangingDeliveryFacts() throws Exception {
-        var f=new DispatchAggregatePersistenceTest.Fixture();var no=create(f);long version=0;
-        var before=f.db.queryForMap("SELECT stage,shipped_package_count,departed_at,review_state FROM ll_dispatch_order");
-        for(var type:ExceptionType.values()) {
-            var body=new DispatchCommands.MarkException(version,"exception-"+type,type,ReturnDirection.OVERSEAS_WAREHOUSE,"真实异常",List.of());
-            var saved=f.tx.execute(t->f.service.markException(f.actor,no,body));
-            var replay=f.tx.execute(t->f.service.markException(f.actor,no,body));
-            assertThat(saved.stage()).isEqualTo(Stage.DELIVERING);assertThat(replay.replayed()).isTrue();
-            assertThat(replay.recordVersion()).isEqualTo(saved.recordVersion());version=saved.recordVersion();
-        }
-        var records=f.service.detail(f.actor,no).dispatchInfo().exceptions();assertThat(records).hasSize(3);
-        assertThat(records).allSatisfy(r->{assertThat(r.description()).isEqualTo("真实异常");assertThat(r.occurredAt()).isNotNull();});
-        assertThat(f.db.queryForMap("SELECT stage,shipped_package_count,departed_at,review_state FROM ll_dispatch_order")).isEqualTo(before);
-        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_inventory_ledger",Long.class)).isZero();
-        assertThat(f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_history WHERE action='MARK_EXCEPTION'",Long.class)).isEqualTo(3);
-        var first=new DispatchCommands.MarkException(0L,"exception-REFUSED",ExceptionType.REFUSED,ReturnDirection.OVERSEAS_WAREHOUSE,"真实异常",List.of());
-        f.db.update("UPDATE ll_dispatch_order SET stage='DELIVERED'");
-        assertThat(f.tx.execute(t->f.service.markException(f.actor,no,first)).replayed()).isTrue();
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,new DispatchCommands.MarkException(0L,"exception-REFUSED",ExceptionType.REFUSED,null,"改了内容",List.of())))).isInstanceOf(RuntimeException.class);
-        assertThat(f.service.detail(f.actor,no).dispatchInfo().exceptions()).hasSize(3);
-    }
-
-    /** 非派送阶段、过期版本、只读身份、PDA及运输任务不能登记。 */
-    @Test void rejectsWrongStageVersionPermissionAndTask() throws Exception {
-        var f=new DispatchAggregatePersistenceTest.Fixture();var no=create(f);var body=request(0,"blocked",List.of());
-        for(var stage:List.of("BEFORE_LOADING","LOADING","AFTER_LOADING","DELIVERED")) {
-            f.db.update("UPDATE ll_dispatch_order SET stage=?",stage);
-            assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,body))).hasMessageContaining("仅派送中");
-        }
-        f.db.update("UPDATE ll_dispatch_order SET stage='DELIVERING'");
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,request(9,"stale",List.of())))).hasMessageContaining("版本");
-        SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("operator-test","","platform:overseas-warehouse:dispatch:list"));
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,body))).hasMessageContaining("权限");
-        authorize();f.db.update("UPDATE ll_dispatch_order SET task_type='LOCAL_TRUCK'");
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,body))).hasMessageContaining("仅派送中");
-        f.db.update("UPDATE ll_dispatch_order SET task_type='DELIVERY',status='CANCELLED'");
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,body))).hasMessageContaining("仅派送中");
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(new DispatchContracts.Actor("pda",ActorMode.PDA,"9"),no,body))).hasMessageContaining("仅平台");
-        assertThat(f.db.queryForObject("SELECT record_version FROM ll_dispatch_order",Long.class)).isZero();
-    }
-
-    /** 图片严格核对当前车和类别；附件失败或缺类型不保存任何业务记录。 */
-    @Test void verifiesImageOwnershipAndKeepsFailedRequestUnchanged() throws Exception {
-        var f=new DispatchAggregatePersistenceTest.Fixture();var no=create(f);var id=f.repository.find(no).getId();
-        var files=mock(DispatchEvidenceGateway.class);ReflectionTestUtils.setField(f.service,"evidence",files);
-        when(files.metadata(id,DispatchEvidenceGateway.Kind.EXCEPTION,91L)).thenThrow(new IllegalArgumentException("文件不属于当前车"));
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,request(0,"files",List.of(91L))))).hasMessageContaining("不属于");
-        assertThat(f.service.detail(f.actor,no).dispatchInfo().exceptions()).isEmpty();
-        var missingType=new DispatchCommands.MarkException(0L,"no-type",null,null,null,List.of());
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,missingType))).hasMessageContaining("请选择异常类型");
-        assertThatThrownBy(()->f.tx.execute(t->f.service.markException(f.actor,no,request(0,"duplicates",List.of(91L,91L))))).hasMessageContaining("图片引用");
-        doReturn(new DispatchEvidenceGateway.File(91L,"现场.png","image/png",10L)).when(files).metadata(id,DispatchEvidenceGateway.Kind.EXCEPTION,91L);
-        f.tx.execute(t->f.service.markException(f.actor,no,request(0,"files",List.of(91L))));
-        assertThat(f.service.detail(f.actor,no).dispatchInfo().exceptions().get(0).imageFileIds()).containsExactly(91L);
-        verify(files,times(2)).metadata(id,DispatchEvidenceGateway.Kind.EXCEPTION,91L);
-    }
-
-    /** 创建真实排车后仅以SQL模拟已发车前置，不声称此用例执行装车流程。 */
-    private String create(DispatchAggregatePersistenceTest.Fixture f) {
-        var created=f.tx.execute(t->f.service.create(f.actor,f.configured("create",List.of())));
-        f.db.update("UPDATE ll_dispatch_order SET stage='DELIVERING',shipped_package_count=3,departed_at=CURRENT_TIMESTAMP");return created.dispatchNo();
-    }
-    /** 构造类型必填、其余选填的最小登记请求。 */
-    private DispatchCommands.MarkException request(long version,String key,List<Long> images) { return new DispatchCommands.MarkException(version,key,ExceptionType.VEHICLE_EXCEPTION,null,null,images); }
-}
@@ -1,258 +0,0 @@
-package com.baiyue.lastleg.dispatch.service;
-
-import com.baiyue.lastleg.dispatch.mapper.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.service.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.gateway.OwnedBusinessFileGateway;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort.BindPhoto;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort.Documents;
-import com.baiyue.lastleg.fleet.ownedbusiness.port.DispatchLoadingPhotoPort.Slot;
-import com.baiyue.lastleg.fleet.ownedbusiness.mapper.*;
-import com.baiyue.lastleg.fleet.ownedbusiness.repository.OwnedBusinessRepository;
-import java.nio.file.*;
-import java.util.regex.Pattern;
-import com.baiyue.lastleg.dispatch.pda.service.DispatchPdaWorkflowService;
-import com.baiyue.lastleg.dispatch.port.*;
-import com.baiyue.lastleg.dispatch.repository.*;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.AfterEach;
-import org.springframework.security.authentication.TestingAuthenticationToken;
-import org.springframework.security.core.context.SecurityContextHolder;
-import java.math.BigDecimal;
-import java.time.Instant;
-import java.util.*;
-import java.util.concurrent.*;
-import static com.baiyue.lastleg.dispatch.port.DispatchContracts.*;
-import static com.baiyue.lastleg.dispatch.port.DispatchDeliveryModels.*;
-import static com.baiyue.lastleg.dispatch.port.DispatchTypes.*;
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-import static org.mockito.ArgumentMatchers.*;
-
-/** 装车后五框门禁、保存发车共同事务及跨端竞争使用真实单据和版本。 */
-class DispatchLoadingDeparturePersistenceTest {
-    /** 每例恢复隔离身份，不影响其他服务权限测试。 */
-    @AfterEach void clearSecurity(){SecurityContextHolder.clearContext();}
-
-    /** 装车完成不发车，第五张保存自动发车，旧装车键保持原装车后结果。 */
-    @Test void loadingWaitsForFivePhotosThenDepartsOnce() throws Exception {
-        authorize();var f=new Fixture();
-        var result=f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("complete")));
-        assertThat(result.action()).isEqualTo(Action.LOADING_COMPLETE);assertThat(result.stage()).isEqualTo(Stage.AFTER_LOADING);
-        assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_delivery_order",Long.class)).isZero();
-        for(int i=0;i<4;i++)assertThat(f.bind(i,f.f.actor).stage()).isEqualTo("AFTER_LOADING");
-        assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_delivery_order",Long.class)).isZero();
-        var fifth=f.bind(4,new Actor("picker",ActorMode.PDA,"9"));assertThat(fifth.stage()).isEqualTo("DELIVERING");
-        assertThat(fifth.complete()).isTrue();assertThat(fifth.photos()).hasSize(5);
-        var replayPhoto=f.f.tx.execute(s->f.documents.bind(new Actor("picker",ActorMode.PDA,"9"),f.number,Slot.RECEIPT,new BindPhoto("4","photo-bind-4","1004")));
-        assertThat(replayPhoto).isEqualTo(fifth);
-        assertThat(result.counts().shippedPackageCount()).isZero();assertThat(result.result()).isInstanceOf(DispatchResults.Loaded.class);
-        assertThat(f.f.db.queryForList("SELECT status FROM ll_outbound_order",String.class)).containsExactly("OUTBOUNDED","OUTBOUNDED");
-        assertThat(f.f.db.queryForList("SELECT status FROM ll_delivery_order",String.class)).containsExactly("DELIVERING","DELIVERING");
-        assertThat(f.f.db.queryForObject("SELECT status FROM ll_fleet_trip",String.class)).isEqualTo("IN_TRANSIT");
-        assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_pda_pick",Long.class)).isEqualTo(2);
-        assertThat(f.f.db.queryForObject("SELECT result_json FROM ll_dispatch_command WHERE idempotency_key='complete'",String.class)).contains("AFTER_LOADING");
-        var replay=f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("complete")));
-        assertThat(replay.replayed()).isTrue();assertThat(replay.recordVersion()).isEqualTo(result.recordVersion());assertThat(replay.result()).isEqualTo(result.result());
-        assertThat(f.f.tx.execute(s->f.f.service.command(f.f.actor,f.number,"complete")).stage()).isEqualTo(Stage.AFTER_LOADING);
-        verify(f.delivery,times(1)).prepareForDeparture(any(),any(),anyString());verify(f.sourceWorkflow,times(1)).departWholeSources(any(),any(),any(),any());
-        assertThat(f.f.service.actions(f.f.actor,f.f.repository.find(f.number))).doesNotContainKeys(Action.ARRANGE_DELIVERY,Action.DEPART);
-        assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("stale-new")))).hasMessageContaining("版本或审核阶段");
-    }
-
-    /** 派送失败回滚第五张绑定，保留已确认装车和前四张资料，原文件可重试。 */
-    @Test void preparationAndDepartureFailuresRollBackTheFifthPhoto() throws Exception {
-        authorize();
-        for(boolean failPreparation:List.of(true,false)) {
-            var f=new Fixture();
-            f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("complete")));
-            for(int i=0;i<4;i++)f.bind(i,f.f.actor);
-            if(failPreparation)doThrow(new IllegalStateException("模拟单据准备失败")).when(f.delivery).prepareForDeparture(any(),any(),anyString());
-            else doThrow(new IllegalStateException("模拟来源发运失败")).when(f.sourceWorkflow).departWholeSources(any(),any(),any(),any());
-            assertThatThrownBy(()->f.bind(4,f.f.actor)).isInstanceOf(IllegalStateException.class);
-            var row=f.f.repository.find(f.number);assertThat(row.getStage()).isEqualTo("AFTER_LOADING");assertThat(row.getRecordVersion()).isEqualTo(f.version+1);
-            assertThat(row.getLoadingCompletionHash()).isNotNull();
-            assertThat(f.documents.get(f.f.actor,f.number).photos()).hasSize(4);assertThat(row.getArrangementKey()).isNull();assertThat(row.getDepartedAt()).isNull();
-            assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_outbound_order",Long.class)).isZero();
-            assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_delivery_order",Long.class)).isZero();
-            assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_command WHERE action IN ('ARRANGE_DELIVERY','DEPART')",Long.class)).isZero();
-            assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_pda_pick",Long.class)).isEqualTo(2);
-            assertThat(f.f.db.queryForObject("SELECT status FROM ll_fleet_trip",String.class)).isEqualTo("PLANNED");
-        }
-    }
-
-    /** PDA保持本仓权限、原键权限复验；不借自动流程绕开真实装载清单。 */
-    @Test void pdaUsesOnePermissionButRejectsOtherWarehouseAndInvalidEvidence() throws Exception {
-        authorize();var f=new Fixture();var pda=new Actor("picker",ActorMode.PDA,"9");
-        assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(new Actor("picker",ActorMode.PDA,"99"),f.number,f.request("foreign")))).hasMessageContaining("当前绑定仓");
-        var bad=new DispatchCommands.LoadingComplete(f.version,"bad-manifest","changed",null);
-        assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(pda,f.number,bad))).hasMessageContaining("真实装载清单已变化");
-        verify(f.delivery,never()).prepareForDeparture(any(),any(),anyString());
-        var result=f.f.tx.execute(s->f.service.complete(pda,f.number,f.request("pda")));assertThat(result.stage()).isEqualTo(Stage.AFTER_LOADING);
-        SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("picker","","ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR"));
-        assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(pda,f.number,f.request("pda")))).hasMessageContaining("装车完成权限");
-    }
-
-    /** 同一版本后台/PDA同时确认只有一次装车提交，资料未齐不发车。 */
-    @Test void concurrentAdminAndPdaCompleteOnlyOneDeparture() throws Exception {
-        authorize();var f=new Fixture();var start=new CountDownLatch(1);var workers=Executors.newFixedThreadPool(2);
-        try {
-            var a=workers.submit(()->f.tryComplete(start,f.f.actor,"admin"));
-            var b=workers.submit(()->f.tryComplete(start,new Actor("picker",ActorMode.PDA,"9"),"pda"));
-            start.countDown();assertThat(List.of(a.get(25,TimeUnit.SECONDS),b.get(25,TimeUnit.SECONDS))).containsExactlyInAnyOrder(true,false);
-        } finally {workers.shutdownNow();}
-        assertThat(f.f.repository.find(f.number).getStage()).isEqualTo("AFTER_LOADING");
-        verify(f.delivery,never()).prepareForDeparture(any(),any(),anyString());verify(f.sourceWorkflow,never()).departWholeSources(any(),any(),any(),any());
-    }
-
-    /** 装车中可上传，装车前与跨仓拒绝，平台只读权限不能保存照片。 */
-    @Test void loadingDocumentsEnforceStageWarehouseAndWritePermission() throws Exception {
-        authorize();var f=new Fixture();
-        assertThat(f.documents.get(f.f.actor,f.number).stage()).isEqualTo("LOADING");
-        f.f.db.update("UPDATE ll_dispatch_order SET stage='BEFORE_LOADING'");
-        assertThatThrownBy(()->f.documents.get(f.f.actor,f.number)).hasMessageContaining("进入装车中后");
-        f.f.db.update("UPDATE ll_dispatch_order SET stage='LOADING'");
-        f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("complete")));
-        assertThatThrownBy(()->f.documents.get(new Actor("picker",ActorMode.PDA,"99"),f.number)).hasMessageContaining("当前绑定仓");
-        assertThatThrownBy(()->f.f.tx.execute(s->f.documents.bind(f.f.actor,f.number,null,new BindPhoto("0","wrong-slot","1000")))).hasMessageContaining("装车照片框");
-        SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("reader","","platform:overseas-warehouse:dispatch:list"));
-        assertThat(f.documents.get(f.f.actor,f.number).editable()).isFalse();
-        assertThatThrownBy(()->f.bind(0,f.f.actor)).hasMessageContaining("无装车资料操作权限");
-    }
-
-    /** 两端同版本竞争第五张，仅一个绑定和一次真实派送成功。 */
-    @Test void concurrentFifthPhotoCannotDispatchTwice() throws Exception {
-        authorize();var f=new Fixture();f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("complete")));
-        for(int i=0;i<4;i++)f.bind(i,f.f.actor);
-        var start=new CountDownLatch(1);var workers=Executors.newFixedThreadPool(2);
-        try {
-            var results=new ArrayList<Future<Boolean>>();
-            for(String key:List.of("admin-last","pda-last"))results.add(workers.submit(()->{
-                authorize();try {start.await(5,TimeUnit.SECONDS);var actor=key.startsWith("pda")?new Actor("picker",ActorMode.PDA,"9"):f.f.actor;
-                    f.f.tx.execute(s->f.documents.bind(actor,f.number,Slot.RECEIPT,new BindPhoto("4",key,"1004")));return true;
-                }catch(com.baiyue.common.core.exception.BizException expected){return false;}
-                finally {SecurityContextHolder.clearContext();}
-            }));
-            start.countDown();assertThat(List.of(results.get(0).get(25,TimeUnit.SECONDS),results.get(1).get(25,TimeUnit.SECONDS))).containsExactlyInAnyOrder(true,false);
-        } finally {workers.shutdownNow();}
-        verify(f.delivery,times(1)).prepareForDeparture(any(),any(),anyString());
-        assertThat(f.documents.get(f.f.actor,f.number).photos()).hasSize(5);
-        assertThat(f.f.repository.find(f.number).getStage()).isEqualTo("DELIVERING");
-    }
-
-    /** 资料先齐不能提前发车；确认装车后直接派送，原键返回相同最终结果。 */
-    @Test void photosReadyBeforeLoadingConfirmationDepartAndReplayOnce() throws Exception {
-        authorize();var f=new Fixture();
-        for(int i=0;i<5;i++)assertThat(f.bind(i,f.f.actor).stage()).isEqualTo("LOADING");
-        verify(f.delivery,never()).prepareForDeparture(any(),any(),anyString());
-        var result=f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("ready-complete")));
-        assertThat(result.action()).isEqualTo(Action.LOADING_COMPLETE);
-        assertThat(result.stage()).isEqualTo(Stage.DELIVERING);assertThat(result.counts().shippedPackageCount()).isEqualTo(8);
-        assertThat(result.result()).isInstanceOf(DispatchResults.Loaded.class);
-        var replay=f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("ready-complete")));
-        assertThat(replay.replayed()).isTrue();assertThat(replay.stage()).isEqualTo(Stage.DELIVERING);
-        assertThat(replay.recordVersion()).isEqualTo(result.recordVersion());assertThat(replay.result()).isEqualTo(result.result());
-        assertThat(f.f.tx.execute(s->f.f.service.command(f.f.actor,f.number,"ready-complete")).stage()).isEqualTo(Stage.DELIVERING);
-        verify(f.delivery,times(1)).prepareForDeparture(any(),any(),anyString());
-        verify(f.sourceWorkflow,times(1)).departWholeSources(any(),any(),any(),any());
-    }
-
-    /** 资料先齐时派送失败回滚本次装车确认，五张已保存照片保留供原请求重试。 */
-    @Test void readyDocumentsSurviveFailedLoadingAndOriginalRequestCanRetry() throws Exception {
-        authorize();var f=new Fixture();for(int i=0;i<5;i++)f.bind(i,f.f.actor);
-        doThrow(new IllegalStateException("模拟发运失败")).when(f.sourceWorkflow).departWholeSources(any(),any(),any(),any());
-        assertThatThrownBy(()->f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("retry-ready")))).hasMessageContaining("模拟发运失败");
-        assertThat(f.f.repository.find(f.number).getStage()).isEqualTo("LOADING");
-        assertThat(f.documents.get(f.f.actor,f.number).complete()).isTrue();
-        assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_delivery_order",Long.class)).isZero();
-        assertThat(f.f.db.queryForObject("SELECT COUNT(*) FROM ll_dispatch_command WHERE idempotency_key='retry-ready'",Long.class)).isZero();
-        doNothing().when(f.sourceWorkflow).departWholeSources(any(),any(),any(),any());
-        assertThat(f.f.tx.execute(s->f.service.complete(f.f.actor,f.number,f.request("retry-ready"))).stage()).isEqualTo(Stage.DELIVERING);
-    }
-
-    /** 最后一张照片与装车确认同时提交，不论谁先拿父锁均只发车一次。 */
-    @Test void lastPhotoAndLoadingConfirmationCanFinishConcurrently() throws Exception {
-        authorize();var f=new Fixture();for(int i=0;i<4;i++)f.bind(i,f.f.actor);
-        var start=new CountDownLatch(1);var workers=Executors.newFixedThreadPool(2);
-        try {
-            var load=workers.submit(()->f.tryComplete(start,f.f.actor,"concurrent-load"));
-            var photo=workers.submit(()->{authorize();try {start.await(5,TimeUnit.SECONDS);return f.bind(4,new Actor("picker",ActorMode.PDA,"9"));}finally{SecurityContextHolder.clearContext();}});
-            start.countDown();assertThat(load.get(25,TimeUnit.SECONDS)).isTrue();assertThat(photo.get(25,TimeUnit.SECONDS)).isNotNull();
-        } finally {workers.shutdownNow();}
-        assertThat(f.f.repository.find(f.number).getStage()).isEqualTo("DELIVERING");
-        verify(f.delivery,times(1)).prepareForDeparture(any(),any(),anyString());
-        verify(f.sourceWorkflow,times(1)).departWholeSources(any(),any(),any(),any());
-    }
-
-    /** 配置资料与装车权限及PDA既有角色，不授予人工派送、发车权限。 */
-    private static void authorize(){SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("operator","",
-        "platform:overseas-warehouse:dispatch:list","platform:overseas-warehouse:dispatch:edit","platform:overseas-warehouse:dispatch:loading-complete","lastleg:pda:operate","ROLE_OVERSEAS_WAREHOUSE_PDA_OPERATOR"));}
-
-    /** 主流程与发车使用真实SQL，派送提供者受控写入真实子单来验证共同回滚。 */
-    private static final class Fixture {
-        final DispatchAggregatePersistenceTest.Fixture f=new DispatchAggregatePersistenceTest.Fixture();
-        final DispatchDeliveryPort delivery=mock(DispatchDeliveryPort.class);
-        final DispatchPdaWorkflowService sourceWorkflow=mock(DispatchPdaWorkflowService.class);
-        final DispatchLoadingDepartureService service;final DispatchLoadingDocumentService documents;final String number;final long version;final String manifest;
-        final List<LoadingMeasurement> measurements;
-        /** 创建两客户货物并走真实两级审核、真实拣货归属，不伪造已装车状态。 */
-        Fixture() throws Exception {
-            var created=f.tx.execute(s->f.service.create(f.actor,f.configured("create",List.of(f.source(1,"101",501,"ONT8",3),f.source(2,"202",502,"LAX9",5)))));
-            number=created.dispatchNo();version=f.approve(created).recordVersion();
-            f.picked(1,"101",501,3);f.picked(2,"202",502,5);f.db.update("UPDATE ll_dispatch_order SET picked_package_count=8");
-            f.db.execute("ALTER TABLE ll_order ADD detained INT DEFAULT 0");
-            var preview=f.tx.execute(s->f.service.loading(f.actor,number));manifest=preview.manifestHash();
-            measurements=preview.pallets().stream().map(p->new LoadingMeasurement(p.warehousePalletId(),1,BigDecimal.ONE,BigDecimal.ONE,p.deliveryIndex())).toList();
-            when(delivery.prepareForDeparture(any(),any(),anyString())).thenAnswer(call->{
-                Context c=call.getArgument(0);assertThat(c.stage()).isEqualTo(Stage.AFTER_LOADING);
-                var os=outbounds("WAIT_OUTBOUND");var ds=deliveries(c,"WAIT_DELIVERY");
-                for(int n=0;n<os.size();n++) {
-                    var o=os.get(n);var d=ds.get(n);
-                    f.db.update("INSERT INTO ll_outbound_order(id,customer_id,dispatch_order_id,outbound_no,status,package_count)VALUES(?,?,?,?,?,?)",6001+n,o.customerId(),c.dispatchId(),o.outboundNo(),o.status(),o.packageCount());
-                    f.db.update("INSERT INTO ll_delivery_order(id,customer_id,dispatch_order_id,outbound_order_id,outbound_no,delivery_no,status,package_count)VALUES(?,?,?,?,?,?,?,?)",7001+n,o.customerId(),c.dispatchId(),6001+n,o.outboundNo(),d.deliveryNo(),d.status(),d.packageCount());
-                }
-                return new ArrangementFact("AUTO-ARR","business-hash",c.cargoHash(),c.loadingCompletionHash(),new ArrangementResult(number,c.recordVersion()+1,"AUTO-ARR",c.cargoHash(),Instant.now(),os,ds));
-            });
-            when(delivery.departureFacts(any(),eq(true))).thenAnswer(call->{
-                Context c=call.getArgument(0);f.db.queryForList("SELECT id FROM ll_outbound_order ORDER BY id FOR UPDATE");f.db.queryForList("SELECT id FROM ll_delivery_order ORDER BY id FOR UPDATE");
-                return new DepartureFacts(number,"AUTO-ARR",c.cargoHash(),c.loadingCompletionHash(),"business-hash",outbounds("WAIT_OUTBOUND"),deliveries(c,"WAIT_DELIVERY"),c.cargo(),new Gate(true,null,null));
-            });
-            when(delivery.markDeparted(any(),any(),any(),anyString())).thenAnswer(call->{
-                Context c=call.getArgument(0);f.db.update("UPDATE ll_outbound_order SET status='OUTBOUNDED'");f.db.update("UPDATE ll_delivery_order SET status='DELIVERING'");
-                return new DepartureResult(outbounds("OUTBOUNDED"),deliveries(c,"DELIVERING"),8);
-            });
-            var ledger=new DispatchCommandLedger(new DispatchCommandRepository(f.session.getMapper(DispatchCommandMapper.class)),new DispatchCommandCodec(f.json));
-            var hashes=new DispatchCommandHasher(f.json);
-            var sources=new DispatchSourceRepository(mock(DispatchCandidateMapper.class),mock(ReturnDispatchCandidateMapper.class),f.session.getMapper(DispatchSourceMapper.class));
-            var departure=new DispatchDepartureService(f.service,f.repository,sources,delivery,sourceWorkflow,f.fleet,ledger,hashes,f.json);
-            f.session.getConfiguration().addMapper(OwnedBusinessMapper.class);
-            String schema=Files.readString(Path.of("src/main/resources/db/lastleg.sql"));
-            for(String suffix:List.of("record","command","history")) {
-                var matcher=Pattern.compile("(?s)CREATE TABLE IF NOT EXISTS ll_fleet_owned_business_"+suffix+" \\(.*?;").matcher(schema);
-                assertThat(matcher.find()).isTrue();
-                f.db.execute(matcher.group().replace(" JSON"," LONGTEXT").replace(" COLLATE utf8mb4_bin","").replaceFirst("(?s) ENGINE=InnoDB.*?;$",";"));
-            }
-            var records=new OwnedBusinessRepository(f.session.getMapper(OwnedBusinessMapper.class),mock(OwnedBusinessQueryMapper.class));
-            var codec=new OwnedBusinessSupport(f.json);var files=mock(OwnedBusinessFileGateway.class);
-            when(files.metadata(anyLong(),any(),anyLong())).thenAnswer(call->new OwnedBusinessFileGateway.Evidence(call.getArgument(2),"loading.png","image/png",12,"2026-10-21T00:00:00Z"));
-            var photos=new DispatchLoadingPhotoAdapter(records,new OwnedBusinessCommandService(records,codec),new OwnedBusinessProjection(codec),codec,files);
-            service=new DispatchLoadingDepartureService(f.service,delivery,departure,ledger,hashes,photos);
-            documents=new DispatchLoadingDocumentService(f.service,service,photos);
-        }
-        /** 每张照片保留独立版本与幂等键，复用真实附加记录保存事务。 */
-        Documents bind(int index,Actor actor) {
-            return f.tx.execute(s->documents.bind(actor,number,DispatchLoadingDocumentService.SLOTS.get(index),new BindPhoto(Integer.toString(index),"photo-bind-"+index,Long.toString(1000L+index))));
-        }
-        /** 每次请求沿用最初真实测量和版本，便于验证竞争及原键恢复。 */
-        DispatchCommands.LoadingComplete request(String key){return new DispatchCommands.LoadingComplete(version,key,manifest,"实装发车");}
-        /** 两客户子出库保持独立业务号和箱数。 */
-        List<OutboundReference> outbounds(String status){return List.of(new OutboundReference("101","客户101","OUT-A",status,3,1),new OutboundReference("202","客户202","OUT-B",status,5,1));}
-        /** 两目的地仍对应各自真实客户，不把整车合并为单客户。 */
-        List<DeliveryReference> deliveries(Context c,String status){return List.of(new DeliveryReference("GA","101","客户101","OUT-A","DL-A",c.cargo().get(0).destination(),status,3,1),new DeliveryReference("GB","202","客户202","OUT-B","DL-B",c.cargo().get(1).destination(),status,5,1));}
-        /** 各线程独立身份和数据库事务竞争同一整车父锁。 */
-        boolean tryComplete(CountDownLatch start,Actor actor,String key) throws Exception {
-            authorize();try {start.await(5,TimeUnit.SECONDS);f.tx.execute(s->service.complete(actor,number,request(key)));return true;}
-            catch(com.baiyue.common.core.exception.BizException expected){return false;}
-            finally {SecurityContextHolder.clearContext();}
-        }
-    }
-}
@@ -50,7 +50,7 @@ class DispatchLoadingEligibilityPersistenceTest {
            "ll_dispatch_pda_pick","ll_dispatch_pda_pick_order","ll_dispatch_pallet_lock","ll_dispatch_physical_pallet_lock",
            "ll_fleet_trip","ll_fleet_trip_history");
        var before=snapshot(f,tables);
-        var request=new DispatchCommands.LoadingComplete(approved.recordVersion(),"unreceived-negative",preview.manifestHash(),"未实收负例");
+        var request=new DispatchCommands.LoadingComplete(approved.recordVersion(),"unreceived-negative",preview.manifestHash(),List.of(),"未实收负例");
        assertThatThrownBy(()->f.tx.execute(t->f.service.loadingComplete(actor,created.dispatchNo(),request)))
            .isInstanceOfSatisfying(BizException.class,error->assertThat(error.getResultCode()).isEqualTo(ResultCode.CONFLICT))
            .hasMessage("逐项真实拣货尚未核平");
@@ -96,7 +96,7 @@ class DispatchMergedRelabelPersistenceTest {
        var preview=f.f.service.loading(f.f.actor,created.dispatchNo());assertThat(preview.pallets()).hasSize(1);assertThat(preview.pallets().get(0).scheduledPackages()).isEqualTo(5);
        var pallet=preview.pallets().get(0);
        var loaded=f.f.tx.execute(s->f.f.service.loadingComplete(f.picker,created.dispatchNo(),new DispatchCommands.LoadingComplete(last.recordVersion(),"load",preview.manifestHash(),
-            null)));
+            List.of(new DispatchContracts.LoadingMeasurement(501L,1,new BigDecimal("10"),BigDecimal.ONE,pallet.deliveryIndex()==null?1:pallet.deliveryIndex())),null)));
        assertThat(loaded.stage()).isEqualTo(Stage.AFTER_LOADING);
        assertThat(f.count("ll_inventory_ledger WHERE business_type='SHIP'")).isEqualTo(2);
    }
--- a/Show More
+++ b/Show More