Merge branch 'dev-lyhfive' of http://git.buggoglobal.com/java-project/baiyue-firstleg into dev

.gitignore

@@ -28,5 +28,6 @@ reports/
 uploads/
 .codex-temp*
 .codex-tmp*
+.runtime-*/
 .codex-*.out
 .codex-*.err

common-event-contract/AGENTS.md

@@ -17,6 +17,7 @@
 | 头程装柜完成 V2（当前生产） | `FirstLegLoadingPlanCompletedV2.java`；订单级冻结 `destinationType=FBA|OVERSEAS`，FBA 可按箱数接收，OVERSEAS 逐明细冻结与实装箱数一致的 SKU/箱号；同时冻结来源/根订单与入仓标识、客户、业务类型、目的仓/备注/托盘及一键代发托盘 SKU 快照；国内生产者见 `../firstleg/src/main/java/com/baiyue/firstleg/service/LoadingCompletedOutboxService.java`，海外消费者见 `../lastleg-service/src/main/java/com/baiyue/lastleg/service/LoadingCompletedConsumer.java` |
 | 头程装柜完成 V1 解析模型 | `FirstLegLoadingPlanCompletedV1.java`；用于消费端冻结字段映射，新增生产不得回退为 V1 |
 | 海外卸柜完成 V1 | `OverseasContainerUnloadedV1.java`；按来源柜预订 ID 做柜级聚合/幂等，同一柜只发布一次；`unloadingCompletedAt` 必须是全柜 complete 时刻，不得用签收拍照时刻代替；海外生产者见 `../lastleg-service/src/main/java/com/baiyue/lastleg/inboundplan/pda/service/InboundUnloadCompletedOutboxService.java`，国内消费者见 `../firstleg/src/main/java/com/baiyue/firstleg/service/OverseasContainerEventConsumer.java` |
+| 海外入仓单暂扣变更 V1 | `OverseasInboundOrderDetainedChangedV1.java`；聚合键固定为来源头程入仓单 ID，暂扣与解除暂扣均由尾程 Outbox 回传，国内按入仓单绑定、客户归属及聚合版本单调消费 |
 | 国内船节点记录 V1 | `FirstLegContainerShippingNodeRecordedV1.java`；只接受十节点中带实际时间和完整供应商审计字段的事实，国内生产者 `../firstleg/src/main/java/com/baiyue/firstleg/portschedule/service/CarrierScheduleNodeOutboxService.java`，海外消费者 `../lastleg-service/src/main/java/com/baiyue/lastleg/shipping/service/ContainerShippingNodeConsumer.java` |
 | IAM 安全事件 V1 | `IamSecurityEventsV1.java`；账号、授权快照等安全事件的冻结模型 |
 | 契约说明 | `package-info.java` |

common-event-contract/src/main/java/com/baiyue/common/event/EventTypes.java

@@ -13,6 +13,7 @@ public final class EventTypes {
     public static final String FIRST_LEG_CONTAINER_SHIPPING_NODE_RECORDED =
         "FirstLegContainerShippingNodeRecorded";
     public static final String OVERSEAS_CONTAINER_UNLOADED = "OverseasContainerUnloaded";
+    public static final String OVERSEAS_INBOUND_ORDER_DETAINED_CHANGED = "OverseasInboundOrderDetainedChanged";
     public static final String IAM_USER_STATUS_CHANGED = "IamUserStatusChanged";
     public static final String IAM_TENANT_STATUS_CHANGED = "IamTenantStatusChanged";
     public static final String IAM_PERMISSION_VERSION_CHANGED = "IamPermissionVersionChanged";

common-event-contract/src/main/java/com/baiyue/common/event/FirstLegLoadingPlanCompletedV2.java

@@ -4,7 +4,7 @@ import com.fasterxml.jackson.annotation.JsonProperty;
 import java.math.BigDecimal;
 import java.util.List;
 
-/** 装柜完成交接快照，包含三类逐货物备注及一键代发托盘快照。 */
+/** 装柜完成交接快照，包含三类逐货物备注、推荐托数和可复用的头程托盘编号快照。 */
 public record FirstLegLoadingPlanCompletedV2(
         String loadingPlanId, String planNo,
         @JsonProperty("sourceContainerBookingId") String containerBookingId,
@@ -117,7 +117,7 @@ public record FirstLegLoadingPlanCompletedV2(
         }
     }
 
-    /** 一键代发入仓单的托盘冻结快照。 */
+    /** 头程托盘冻结快照；普通入仓用于复用打印编号，一键代发还冻结 SKU/箱唛库存。 */
     public record PalletSnapshot(String palletNo, List<SkuPackageSnapshot> skuPackages) {}
 
     /** 托盘下 SKU、箱数、数量及箱号冻结快照；cartonMarks 中每个箱号都对应 skuCode。 */

common-event-contract/src/main/java/com/baiyue/common/event/OverseasInboundOrderDetainedChangedV1.java

@@ -0,0 +1,17 @@
+package com.baiyue.common.event;
+
+import java.time.Instant;
+
+/** 海外尾程按来源入仓单回传的暂扣状态事实。 */
+public record OverseasInboundOrderDetainedChangedV1(
+    String sourceInboundId,
+    String inboundCode,
+    String lastlegOrderId,
+    String lastlegOrderNo,
+    boolean detained,
+    String reason,
+    String operatorId,
+    String operatorName,
+    Instant changedAt
+) {
+}

config/nacos/local/README.md

@@ -10,8 +10,19 @@
 powershell -ExecutionPolicy Bypass -File D:\baiyue-firstleg\scripts\publish-local-nacos-config.ps1
 ```
 
+也可以使用统一入口；`local` 会被强制限制在 `public` namespace：
+
+```powershell
+powershell -ExecutionPolicy Bypass -File D:\baiyue-firstleg\scripts\publish-nacos-config.ps1 -Environment local
+```
+
 配置发布成功后，各服务仍由自身的 Nacos Discovery 配置在启动时自动注册，不需要手工创建服务实例。
 
+本地海外链路也发布在同一 `public / BAIYUE` 作用域，包括
+`gateway-overseas.yml`、`lastleg-service.yml` 和
+`warehouse-overseas-service.yml`。这些配置默认通过 `127.0.0.1` 连接本机
+Auth、国内仓库、文件和海外服务；需要跨主机运行时使用对应环境变量覆盖。
+
 ## MyBatis SQL 日志
 
 本地公共配置使用 MyBatis `Slf4jImpl`，数据库服务的 Mapper 日志级别默认为 `DEBUG`。执行数据库操作时，控制台会打印 SQL 模板、参数和影响行数。

config/nacos/local/event-bridge-service.yml

@@ -5,5 +5,7 @@ spring.datasource:
   password: ${EVENT_BRIDGE_DB_PASSWORD:123456}
 baiyue:
   region: ${REGION_CODE:CN}
+  event-bridge:
+    accept-any-region: ${EVENT_BRIDGE_ACCEPT_ANY_REGION:true}
   deployment-cell: ${DEPLOYMENT_CELL:local-cn}
   data-residency: ${DATA_RESIDENCY:CN}

config/nacos/local/gateway-overseas.yml

@@ -0,0 +1,16 @@
+springdoc:
+  api-docs.enabled: ${SWAGGER_ENABLED:true}
+  swagger-ui.enabled: ${SWAGGER_ENABLED:true}
+baiyue:
+  security:
+    issuer: ${JWT_ISSUER:auth-service}
+    audience: ${JWT_AUDIENCE:lastleg-api}
+    jwk-set-uri: ${JWT_JWK_SET_URI:http://127.0.0.1:9100/api/auth/.well-known/jwks.json}
+    pda-session-validation:
+      auth-url: ${AUTH_SESSION_VALIDATION_URL:http://127.0.0.1:9100}
+      internal-service-token: ${INTERNAL_SERVICE_TOKEN:phase1-local-internal-token-at-least-32-bytes}
+      timeout: ${PDA_SESSION_VALIDATION_TIMEOUT:2s}
+    overseas-projection:
+      service-url: ${LASTLEG_SECURITY_SERVICE_URL:http://127.0.0.1:9303}
+      internal-service-token: ${INTERNAL_SERVICE_TOKEN:phase1-local-internal-token-at-least-32-bytes}
+      timeout: ${LASTLEG_SECURITY_VALIDATION_TIMEOUT:2s}

config/nacos/local/lastleg-service.yml

@@ -0,0 +1,29 @@
+spring:
+  datasource:
+    driver-class-name: com.mysql.cj.jdbc.Driver
+    url: ${LASTLEG_DB_URL:jdbc:mysql://127.0.0.1:3306/baiyue_lastleg?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true}
+    username: ${LASTLEG_DB_USERNAME:root}
+    password: ${LASTLEG_DB_PASSWORD:123456}
+lastleg:
+  dispatch-query-api.enabled: ${LASTLEG_DISPATCH_QUERY_API_ENABLED:true}
+  smart-dispatch-api.enabled: ${LASTLEG_SMART_DISPATCH_API_ENABLED:true}
+baiyue:
+  clients:
+    domestic-warehouse:
+      url: ${DOMESTIC_WAREHOUSE_URL:http://127.0.0.1:9205}
+      cache-ttl: ${DOMESTIC_WAREHOUSE_CACHE_TTL:30m}
+    file:
+      url: ${FILE_SERVICE_URL:http://127.0.0.1:9206}
+    event-bridge:
+      url: ${CN_EVENT_BRIDGE_URL:${FIRSTLEG_EVENT_BRIDGE_URL:http://127.0.0.1:9312}}
+  warehouse:
+    base-url: ${WAREHOUSE_OVERSEAS_SERVICE_URL:http://127.0.0.1:9305}
+  firstleg:
+    event-bridge-url: ${CN_EVENT_BRIDGE_URL:${FIRSTLEG_EVENT_BRIDGE_URL:http://127.0.0.1:9312}}
+  security:
+    internal-service-token: ${INTERNAL_SERVICE_TOKEN:phase1-local-internal-token-at-least-32-bytes}
+    jwt-mode: jwks
+    session-mode: claims
+    issuer: ${JWT_ISSUER:auth-service}
+    audience: ${JWT_AUDIENCE:lastleg-api}
+    jwk-set-uri: ${JWT_JWK_SET_URI:http://127.0.0.1:9100/api/auth/.well-known/jwks.json}

config/nacos/local/warehouse-overseas-service.yml

@@ -0,0 +1,19 @@
+spring:
+  datasource:
+    driver-class-name: com.mysql.cj.jdbc.Driver
+    url: ${WAREHOUSE_DB_URL:jdbc:mysql://127.0.0.1:3306/baiyue_lastlag_warehouse?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true}
+    username: ${WAREHOUSE_DB_USERNAME:root}
+    password: ${WAREHOUSE_DB_PASSWORD:123456}
+baiyue:
+  clients:
+    domestic-warehouse:
+      url: ${DOMESTIC_WAREHOUSE_URL:http://127.0.0.1:9205}
+      cache-ttl: ${DOMESTIC_WAREHOUSE_CACHE_TTL:30m}
+  internal-service:
+    token: ${INTERNAL_SERVICE_TOKEN:phase1-local-internal-token-at-least-32-bytes}
+  security:
+    jwt-mode: jwks
+    session-mode: claims
+    issuer: ${JWT_ISSUER:auth-service}
+    audience: ${JWT_AUDIENCE:lastleg-api}
+    jwk-set-uri: ${JWT_JWK_SET_URI:http://127.0.0.1:9100/api/auth/.well-known/jwks.json}

config/nacos/overseas/README.md

@@ -1,5 +1,19 @@
 # 海外 Nacos 配置
 
-将本目录文件按原文件名作为 Data ID 发布到 `prod-overseas` 命名空间和 `BAIYUE` 分组。配置只引用环境变量，不保存密码或访问密钥。Gateway 必须同时启用 `overseas` Profile。
+本目录是海外远程部署模板，由 dev/development、test 和 production 共用。配置只引用环境变量，不保存密码或访问密钥；三个环境必须发布到各自独立的 Nacos namespace，Gateway 必须同时启用 `overseas` Profile。
 
 海外入口与仓储 Data ID 分别为 `gateway-overseas.yml`、`warehouse-overseas-service.yml`。`print-service.yml` 对应头程仓库保留的共用打印服务，不包含尾程旧 Print 模块。
+
+发布示例：
+
+```powershell
+# 开发环境
+powershell -ExecutionPolicy Bypass -File D:\baiyue-firstleg\scripts\publish-nacos-config.ps1 `
+  -Environment development -Region overseas -ServerAddr <dev-nacos> -Namespace <dev-overseas-namespace>
+
+# 测试环境
+powershell -ExecutionPolicy Bypass -File D:\baiyue-firstleg\scripts\publish-nacos-config.ps1 `
+  -Environment test -Region overseas -ServerAddr <test-nacos> -Namespace <test-overseas-namespace>
+```
+
+远程环境禁止使用 `public` namespace。数据库、Redis、JWKS、内部服务令牌和跨区服务地址继续由对应 Jenkins Secret file 提供；不要把真实值写入本目录。

deploy/maven/settings-cn.xml

@@ -4,54 +4,36 @@
           xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.2.0 https://maven.apache.org/xsd/settings-1.2.0.xsd">
     <mirrors>
         <mirror>
-            <id>baiyue-nexus-public</id>
+            <id>aliyun-public</id>
-            <name>柏悦 Nexus Maven 聚合仓库</name>
+            <name>阿里云 Maven 公共镜像</name>
-            <url>http://8.163.30.128:18081/repository/maven-public/</url>
+            <url>https://maven.aliyun.com/repository/public</url>
-            <mirrorOf>external:*</mirrorOf>
+            <mirrorOf>central</mirrorOf>
         </mirror>
     </mirrors>
 
-    <servers>
-        <server>
-            <id>baiyue-nexus-public</id>
-            <username>${env.NEXUS_USERNAME}</username>
-            <password>${env.NEXUS_PASSWORD}</password>
-        </server>
-        <server>
-            <id>baiyue-nexus-releases</id>
-            <username>${env.NEXUS_USERNAME}</username>
-            <password>${env.NEXUS_PASSWORD}</password>
-        </server>
-        <server>
-            <id>baiyue-nexus-snapshots</id>
-            <username>${env.NEXUS_USERNAME}</username>
-            <password>${env.NEXUS_PASSWORD}</password>
-        </server>
-    </servers>
-
     <profiles>
         <profile>
-            <id>柏悦 Nexus</id>
+            <id>国内公共镜像</id>
             <repositories>
                 <repository>
-                    <id>baiyue-nexus-public</id>
+                    <id>central</id>
-                    <url>http://8.163.30.128:18081/repository/maven-public/</url>
+                    <url>https://repo.maven.apache.org/maven2</url>
                     <releases><enabled>true</enabled></releases>
-                    <snapshots><enabled>true</enabled></snapshots>
+                    <snapshots><enabled>false</enabled></snapshots>
                 </repository>
             </repositories>
             <pluginRepositories>
                 <pluginRepository>
-                    <id>baiyue-nexus-public</id>
+                    <id>central</id>
-                    <url>http://8.163.30.128:18081/repository/maven-public/</url>
+                    <url>https://repo.maven.apache.org/maven2</url>
                     <releases><enabled>true</enabled></releases>
-                    <snapshots><enabled>true</enabled></snapshots>
+                    <snapshots><enabled>false</enabled></snapshots>
                 </pluginRepository>
             </pluginRepositories>
         </profile>
     </profiles>
 
     <activeProfiles>
-        <activeProfile>柏悦 Nexus</activeProfile>
+        <activeProfile>国内公共镜像</activeProfile>
     </activeProfiles>
 </settings>

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

@@ -2502,6 +2502,7 @@ CREATE TABLE IF NOT EXISTS fl_inbound_order (
   destination_name VARCHAR(128) NULL COMMENT '目的仓名称快照',
   hold_flag TINYINT(1) NOT NULL DEFAULT 0 COMMENT '当前是否扣货',
   current_hold_reason VARCHAR(500) NULL COMMENT '当前扣货理由快照',
+  last_overseas_hold_version BIGINT UNSIGNED NULL COMMENT '海外暂扣事件最新聚合版本，用于阻止乱序覆盖',
   total_package_count INT UNSIGNED NULL COMMENT '确认后的总箱数',
   actual_gross_weight_kg DECIMAL(18,3) NULL COMMENT '确认后的实际总毛重kg',
   chargeable_weight_kg DECIMAL(18,3) NULL COMMENT '当前费用快照的计费重量kg',
@@ -2791,6 +2792,7 @@ CREATE TABLE IF NOT EXISTS fl_inbound_carton_label (
   inbound_detail_id BIGINT UNSIGNED NOT NULL COMMENT '订单货物明细ID，不建立跨库外键',
   cargo_item_no INT UNSIGNED NOT NULL COMMENT '订单货物明细序号快照',
   cargo_name VARCHAR(255) NULL COMMENT '货物名称快照',
+  sku_code VARCHAR(128) NULL COMMENT '箱唛绑定的SKU快照；二维码内容不变',
   detail_package_count INT UNSIGNED NOT NULL COMMENT '该订单货物明细箱数快照',
   inbound_code VARCHAR(40) NOT NULL COMMENT '入仓码快照',
   box_code VARCHAR(80) NOT NULL COMMENT '固定二维码内容：入仓码#总箱数-箱下标',
@@ -2828,6 +2830,7 @@ BEGIN
 END$$
 DELIMITER ;
 CALL unified_carton_label_add_column('label_version', 'INT UNSIGNED NOT NULL DEFAULT 1 COMMENT ''内部兼容批次字段，固定为1且不进入箱码'' AFTER carton_index');
+CALL unified_carton_label_add_column('sku_code', 'VARCHAR(128) NULL COMMENT ''箱唛绑定的SKU快照；二维码内容不变'' AFTER cargo_name');
 CALL unified_carton_label_add_column('batch_status', 'VARCHAR(16) NOT NULL DEFAULT ''ACTIVE'' COMMENT ''批次状态：ACTIVE有效、VOID已作废'' AFTER label_version');
 CALL unified_carton_label_add_column('cargo_fingerprint', 'CHAR(64) NULL COMMENT ''影响标签字段的SHA-256指纹'' AFTER batch_status');
 CALL unified_carton_label_add_column('voided_at', 'DATETIME(3) NULL COMMENT ''批次作废时间'' AFTER cargo_fingerprint');
@@ -5429,6 +5432,66 @@ CREATE TABLE IF NOT EXISTS fl_loading_pick_history (
   CONSTRAINT fk_loading_pick_history_item FOREIGN KEY (pick_item_id) REFERENCES fl_loading_pick_item (id)
 ) ENGINE=InnoDB COMMENT='PDA拣货幂等和操作审计历史';
 
+CREATE TABLE IF NOT EXISTS fl_loading_work_pallet (
+  id BIGINT UNSIGNED NOT NULL COMMENT '一件代发现场作业托盘ID',
+  pick_task_id BIGINT UNSIGNED NOT NULL COMMENT 'PDA装柜拣货任务ID',
+  loading_plan_id BIGINT UNSIGNED NOT NULL COMMENT '装柜计划ID快照',
+  warehouse_id BIGINT UNSIGNED NOT NULL COMMENT '作业仓库ID',
+  warehouse_pallet_id BIGINT UNSIGNED NULL COMMENT '仓库实物托盘ID；未绑定仓库资源时为空',
+  pallet_code VARCHAR(64) NOT NULL COMMENT '现场托盘号',
+  open_operation_id VARCHAR(128) NOT NULL COMMENT '开托幂等操作号',
+  seal_operation_id VARCHAR(128) NULL COMMENT '封托幂等操作号',
+  pallet_status VARCHAR(16) NOT NULL DEFAULT 'OPEN' COMMENT '托盘状态：OPEN打托中、SEALED已封托、CANCELLED已取消',
+  created_by BIGINT UNSIGNED NOT NULL COMMENT '创建操作人ID',
+  created_by_name VARCHAR(64) NULL COMMENT '创建操作人名称快照',
+  sealed_by BIGINT UNSIGNED NULL COMMENT '封托操作人ID',
+  sealed_by_name VARCHAR(64) NULL COMMENT '封托操作人名称快照',
+  sealed_at DATETIME(3) NULL COMMENT '封托时间',
+  version INT UNSIGNED NOT NULL DEFAULT 0 COMMENT '乐观锁版本号',
+  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间',
+  updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT '更新时间',
+  PRIMARY KEY (id),
+  UNIQUE KEY uk_loading_work_pallet_code (pick_task_id, pallet_code),
+  UNIQUE KEY uk_loading_work_pallet_open_operation (open_operation_id),
+  UNIQUE KEY uk_loading_work_pallet_seal_operation (seal_operation_id),
+  KEY idx_loading_work_pallet_plan (loading_plan_id, pallet_status, id),
+  CONSTRAINT fk_loading_work_pallet_task FOREIGN KEY (pick_task_id) REFERENCES fl_loading_pick_task (id),
+  CONSTRAINT fk_loading_work_pallet_plan FOREIGN KEY (loading_plan_id) REFERENCES fl_loading_plan (id),
+  CONSTRAINT chk_loading_work_pallet_status CHECK (pallet_status IN ('OPEN','SEALED','CANCELLED'))
+) ENGINE=InnoDB COMMENT='一件代发PDA现场实际托盘；允许同托盘承载多个客户订单';
+
+CREATE TABLE IF NOT EXISTS fl_loading_work_pallet_carton (
+  id BIGINT UNSIGNED NOT NULL COMMENT '一件代发现场托盘箱唛绑定ID',
+  pick_task_id BIGINT UNSIGNED NOT NULL COMMENT 'PDA装柜拣货任务ID',
+  work_pallet_id BIGINT UNSIGNED NOT NULL COMMENT '现场作业托盘ID',
+  loading_plan_item_id BIGINT UNSIGNED NOT NULL COMMENT '装柜计划货物明细ID',
+  pick_item_id BIGINT UNSIGNED NOT NULL COMMENT 'PDA拣货明细ID',
+  tenant_id BIGINT UNSIGNED NOT NULL COMMENT '箱唛所属客户ID',
+  inbound_id BIGINT UNSIGNED NOT NULL COMMENT '来源入仓单ID',
+  inbound_detail_id BIGINT UNSIGNED NOT NULL COMMENT '来源入仓货物明细ID',
+  carton_label_id BIGINT UNSIGNED NOT NULL COMMENT '稳定箱唛记录ID',
+  box_code VARCHAR(80) NOT NULL COMMENT '稳定箱唛箱码快照',
+  sku_code VARCHAR(128) NOT NULL COMMENT 'SKU编码快照',
+  units_per_carton INT UNSIGNED NULL COMMENT '每箱产品数量快照',
+  bound_by BIGINT UNSIGNED NOT NULL COMMENT '最后绑定操作人ID',
+  bound_by_name VARCHAR(64) NULL COMMENT '最后绑定操作人名称快照',
+  operation_id VARCHAR(128) NOT NULL COMMENT '最近一次绑定或移托幂等操作号',
+  version INT UNSIGNED NOT NULL DEFAULT 0 COMMENT '乐观锁版本号',
+  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '首次上托时间',
+  updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT '最后移托时间',
+  PRIMARY KEY (id),
+  UNIQUE KEY uk_loading_work_carton_task_label (pick_task_id, carton_label_id),
+  UNIQUE KEY uk_loading_work_carton_operation (operation_id),
+  KEY idx_loading_work_carton_pallet (work_pallet_id, sku_code, id),
+  KEY idx_loading_work_carton_plan_item (loading_plan_item_id, id),
+  CONSTRAINT fk_loading_work_carton_task FOREIGN KEY (pick_task_id) REFERENCES fl_loading_pick_task (id),
+  CONSTRAINT fk_loading_work_carton_pallet FOREIGN KEY (work_pallet_id) REFERENCES fl_loading_work_pallet (id),
+  CONSTRAINT fk_loading_work_carton_plan_item FOREIGN KEY (loading_plan_item_id) REFERENCES fl_loading_plan_item (id),
+  CONSTRAINT fk_loading_work_carton_pick_item FOREIGN KEY (pick_item_id) REFERENCES fl_loading_pick_item (id),
+  CONSTRAINT fk_loading_work_carton_label FOREIGN KEY (carton_label_id) REFERENCES fl_inbound_carton_label (id),
+  CONSTRAINT chk_loading_work_carton_units CHECK (units_per_carton IS NULL OR units_per_carton > 0)
+) ENGINE=InnoDB COMMENT='一件代发PDA逐箱上托事实；客户订单不合并但实际托盘可混托';
+
 DROP PROCEDURE IF EXISTS repair_phase3_loading_pick_task_foreign_keys;
 DELIMITER $$
 CREATE PROCEDURE repair_phase3_loading_pick_task_foreign_keys()
@@ -13196,6 +13259,7 @@ CALL queue_column_comment('baiyue_firstleg', 'fl_inbound_order', 'created_at', '
 CALL queue_column_comment('baiyue_firstleg', 'fl_inbound_order', 'created_by', '创建人ID');
 CALL queue_column_comment('baiyue_firstleg', 'fl_inbound_order', 'created_by_name', '创建人名称快照');
 CALL queue_column_comment('baiyue_firstleg', 'fl_inbound_order', 'current_hold_reason', '当前扣货理由快照');
+CALL queue_column_comment('baiyue_firstleg', 'fl_inbound_order', 'last_overseas_hold_version', '海外暂扣事件最新聚合版本，用于阻止乱序覆盖');
 CALL queue_column_comment('baiyue_firstleg', 'fl_inbound_order', 'customer_id', '客户逻辑ID');
 CALL queue_column_comment('baiyue_firstleg', 'fl_inbound_order', 'customer_name', '客户名称快照');
 CALL queue_column_comment('baiyue_firstleg', 'fl_inbound_order', 'customs_inspection', '是否商检');
@@ -16011,12 +16075,35 @@ DROP PROCEDURE IF EXISTS add_container_empty_report_fields;
 
 CREATE TABLE IF NOT EXISTS fl_container_event_inbox (
   event_id VARCHAR(64) NOT NULL COMMENT '跨区事件全局唯一ID', event_type VARCHAR(64) NOT NULL COMMENT '事件类型',
-  event_version INT UNSIGNED NOT NULL COMMENT '事件契约版本', aggregate_id VARCHAR(64) NOT NULL COMMENT '货柜聚合ID',
+  event_version INT UNSIGNED NOT NULL COMMENT '事件契约版本', aggregate_id VARCHAR(64) NOT NULL COMMENT '跨区业务聚合ID',
-  aggregate_version BIGINT UNSIGNED NOT NULL COMMENT '货柜聚合版本', payload_hash VARCHAR(80) NOT NULL COMMENT '规范化负载SHA-256摘要',
+  aggregate_version BIGINT UNSIGNED NOT NULL COMMENT '跨区业务聚合版本', payload_hash VARCHAR(80) NOT NULL COMMENT '规范化负载SHA-256摘要',
   payload_json JSON NOT NULL COMMENT '原始事件负载', status VARCHAR(16) NOT NULL COMMENT 'RECEIVED或PROCESSED',
   received_at DATETIME(3) NOT NULL COMMENT '接收时间（UTC）', processed_at DATETIME(3) NULL COMMENT '处理完成时间（UTC）',
   PRIMARY KEY (event_id), KEY idx_container_event_aggregate (aggregate_id,aggregate_version)
-) ENGINE=InnoDB COMMENT='海外货柜事件消费Inbox';
+) ENGINE=InnoDB COMMENT='海外到国内业务事件消费Inbox';
+
+DROP PROCEDURE IF EXISTS add_inbound_overseas_hold_version;
+DELIMITER $$
+CREATE PROCEDURE add_inbound_overseas_hold_version()
+BEGIN
+  IF NOT EXISTS (
+      SELECT 1 FROM information_schema.columns
+       WHERE table_schema=DATABASE() AND table_name='fl_inbound_order'
+         AND column_name='last_overseas_hold_version'
+  ) THEN
+    ALTER TABLE fl_inbound_order
+      ADD COLUMN last_overseas_hold_version BIGINT UNSIGNED NULL
+      COMMENT '海外暂扣事件最新聚合版本，用于阻止乱序覆盖'
+      AFTER current_hold_reason;
+  END IF;
+  ALTER TABLE fl_container_event_inbox
+    MODIFY COLUMN aggregate_id VARCHAR(64) NOT NULL COMMENT '跨区业务聚合ID',
+    MODIFY COLUMN aggregate_version BIGINT UNSIGNED NOT NULL COMMENT '跨区业务聚合版本',
+    COMMENT='海外到国内业务事件消费Inbox';
+END$$
+DELIMITER ;
+CALL add_inbound_overseas_hold_version();
+DROP PROCEDURE IF EXISTS add_inbound_overseas_hold_version;
 
 -- 标准跨区事件摘要包含 sha256: 前缀，共 71 字符；兼容既有 Finance 64 位摘要。
 ALTER TABLE fl_inbound_outbox
@@ -16063,6 +16150,9 @@ VALUES
   (5107061,0,'PLATFORM','BUTTON',5107060,'platform:overseas-warehouse:location:create','创建海外库位',NULL,'POST',761,'ACTIVE',1,0),
   (5107062,0,'PLATFORM','BUTTON',5107060,'platform:overseas-warehouse:location:edit','编辑海外库位',NULL,'PUT',762,'ACTIVE',1,0),
   (5107063,0,'PLATFORM','BUTTON',5107060,'platform:overseas-warehouse:location:delete','删除海外库位',NULL,'DELETE',763,'ACTIVE',1,0),
+  (5107090,0,'PLATFORM','MENU',0,'platform:overseas-warehouse:outbound:list','海外出库单','/overseas-warehouse/outbounds','GET',765,'ACTIVE',1,0),
+  (5107091,0,'PLATFORM','BUTTON',5107090,'platform:overseas-warehouse:outbound:create','创建海外出库单',NULL,'POST',766,'ACTIVE',1,0),
+  (5107092,0,'PLATFORM','MENU',0,'platform:overseas-warehouse:delivery:list','海外派送单','/overseas-warehouse/delivery-orders','GET',767,'ACTIVE',1,0),
   (5107100,0,'PLATFORM','MENU',0,'platform:overseas-business:purchase:list','海外采购订单','/overseas-business/purchases','GET',800,'ACTIVE',1,0),
   (5107101,0,'PLATFORM','BUTTON',5107100,'platform:overseas-business:purchase:edit','编辑海外采购订单',NULL,'PATCH',801,'ACTIVE',1,0),
   (5107102,0,'PLATFORM','BUTTON',5107100,'platform:overseas-business:purchase:review','审核海外采购订单',NULL,'POST',802,'ACTIVE',1,0),
@@ -16237,6 +16327,152 @@ WHERE role.tenant_id=0 AND role.app_code='PLATFORM'
   AND UPPER(role.role_code) IN ('PLATFORM_ADMIN','PLATFORM_CUSTOM_ADMIN')
   AND role.status='ACTIVE' AND role.deleted=0 AND permission.status='ACTIVE' AND permission.deleted=0;
 
+-- PLATFORM_CUSTOM_ADMIN needs access to the overseas outbound and delivery lists shown in the admin navigation.
+INSERT IGNORE INTO baiyue_iam.iam_role_permission (tenant_id, role_id, permission_id, created_at)
+SELECT 0, role.id, permission.id, NOW(3)
+FROM baiyue_iam.iam_role role
+JOIN baiyue_iam.iam_permission permission ON permission.tenant_id=0 AND permission.app_code='PLATFORM'
+  AND permission.permission_code IN (
+    'platform:overseas-warehouse:outbound:list',
+    'platform:overseas-warehouse:delivery:list'
+  )
+WHERE role.tenant_id=0 AND role.app_code='PLATFORM'
+  AND UPPER(role.role_code)='PLATFORM_CUSTOM_ADMIN'
+  AND role.status='ACTIVE' AND role.deleted=0 AND permission.status='ACTIVE' AND permission.deleted=0;
+
+-- 海外智能排车草稿锁：拖入即锁定，移除或关闭草稿即释放。
+CREATE DATABASE IF NOT EXISTS baiyue_lastleg
+  DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
+USE baiyue_lastleg;
+SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_order' AND column_name='source_warehouse_id'), 'SELECT 1', 'ALTER TABLE ll_order ADD COLUMN source_warehouse_id VARCHAR(128) NULL COMMENT ''来源国内装柜仓 ID 快照'' AFTER customer_name'));
+PREPARE lastleg_order_source_warehouse_stmt FROM @ddl; EXECUTE lastleg_order_source_warehouse_stmt; DEALLOCATE PREPARE lastleg_order_source_warehouse_stmt;
+SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_order' AND column_name='source_warehouse_name'), 'SELECT 1', 'ALTER TABLE ll_order ADD COLUMN source_warehouse_name VARCHAR(255) NULL COMMENT ''来源国内装柜仓名称快照'' AFTER source_warehouse_id'));
+PREPARE lastleg_order_source_warehouse_stmt FROM @ddl; EXECUTE lastleg_order_source_warehouse_stmt; DEALLOCATE PREPARE lastleg_order_source_warehouse_stmt;
+CREATE TABLE IF NOT EXISTS ll_dispatch_pallet_lock (
+  id BIGINT NOT NULL COMMENT '主键ID',
+  customer_id VARCHAR(128) NOT NULL COMMENT '客户租户ID',
+  source_pallet_key VARCHAR(160) NOT NULL COMMENT '来源托盘业务键',
+  active_key VARCHAR(160) NULL COMMENT '生效中的资源排他键',
+  plan_id BIGINT NULL COMMENT '入仓计划ID',
+  plan_pallet_id BIGINT NULL COMMENT '计划托盘ID',
+  warehouse_pallet_id BIGINT NULL COMMENT '仓库实物托盘ID',
+  dispatch_order_id BIGINT NULL COMMENT '正式派车单ID，草稿锁阶段为空',
+  draft_token VARCHAR(64) NULL COMMENT '智能排车草稿随机标识',
+  operator_id VARCHAR(128) NULL COMMENT '草稿锁操作人ID',
+  status VARCHAR(32) NOT NULL DEFAULT 'ACTIVE' COMMENT '业务状态',
+  locked_at DATETIME(3) NOT NULL COMMENT '锁定时间',
+  expires_at DATETIME(3) NULL COMMENT '草稿锁失效时间，正式派车锁为空',
+  released_at DATETIME(3) NULL COMMENT '释放时间',
+  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间',
+  updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT '更新时间',
+  PRIMARY KEY (id),
+  UNIQUE KEY uk_ll_dispatch_active_pallet (customer_id,active_key),
+  KEY idx_ll_dispatch_pallet_lock_order (customer_id,dispatch_order_id,status),
+  KEY idx_ll_dispatch_pallet_lock_source (customer_id,source_pallet_key,status)
+) ENGINE=InnoDB COMMENT='派车托盘排他锁';
+SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_dispatch_pallet_lock' AND column_name='draft_token'), 'SELECT 1', 'ALTER TABLE ll_dispatch_pallet_lock ADD COLUMN draft_token VARCHAR(64) NULL COMMENT ''智能排车草稿随机标识'' AFTER dispatch_order_id'));
+PREPARE stmt FROM @ddl; EXECUTE stmt; DEALLOCATE PREPARE stmt;
+SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_dispatch_pallet_lock' AND column_name='operator_id'), 'SELECT 1', 'ALTER TABLE ll_dispatch_pallet_lock ADD COLUMN operator_id VARCHAR(128) NULL COMMENT ''草稿锁操作人ID'' AFTER draft_token'));
+PREPARE stmt FROM @ddl; EXECUTE stmt; DEALLOCATE PREPARE stmt;
+SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_dispatch_pallet_lock' AND column_name='expires_at'), 'SELECT 1', 'ALTER TABLE ll_dispatch_pallet_lock ADD COLUMN expires_at DATETIME(3) NULL COMMENT ''草稿锁失效时间，正式派车锁为空'' AFTER locked_at'));
+PREPARE stmt FROM @ddl; EXECUTE stmt; DEALLOCATE PREPARE stmt;
+SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_dispatch_pallet_lock' AND column_name='dispatch_order_id' AND is_nullable='YES'), 'SELECT 1', 'ALTER TABLE ll_dispatch_pallet_lock MODIFY COLUMN dispatch_order_id BIGINT NULL COMMENT ''正式派车单ID，草稿锁阶段为空'''));
+PREPARE stmt FROM @ddl; EXECUTE stmt; DEALLOCATE PREPARE stmt;
+
+-- 尾程库存余额按客户入仓单与海外目的仓汇总箱数，SKU仅保留为快照。
+SET @ddl = (SELECT CASE
+  WHEN EXISTS (SELECT 1 FROM information_schema.statistics WHERE table_schema=DATABASE()
+    AND table_name='ll_inventory_balance' AND index_name='uk_ll_inventory_dimension' AND column_name='sku_code')
+    THEN 'ALTER TABLE ll_inventory_balance DROP INDEX uk_ll_inventory_dimension, ADD UNIQUE KEY uk_ll_inventory_dimension (customer_id,overseas_warehouse_id,destination_warehouse_code,inbound_order_id,inbound_code)'
+  WHEN NOT EXISTS (SELECT 1 FROM information_schema.statistics WHERE table_schema=DATABASE()
+    AND table_name='ll_inventory_balance' AND index_name='uk_ll_inventory_dimension')
+    THEN 'ALTER TABLE ll_inventory_balance ADD UNIQUE KEY uk_ll_inventory_dimension (customer_id,overseas_warehouse_id,destination_warehouse_code,inbound_order_id,inbound_code)'
+  ELSE 'SELECT 1' END);
+PREPARE lastleg_inventory_dimension_stmt FROM @ddl; EXECUTE lastleg_inventory_dimension_stmt; DEALLOCATE PREPARE lastleg_inventory_dimension_stmt;
+SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE()
+  AND table_name='ll_inventory_balance' AND column_name='sku_code'),
+  'ALTER TABLE ll_inventory_balance MODIFY COLUMN sku_code VARCHAR(128) NOT NULL DEFAULT ''UNSPECIFIED'' COMMENT ''SKU快照；多SKU汇总时为MIXED，不参与当前库存唯一维度''',
+  'SELECT 1'));
+PREPARE lastleg_inventory_dimension_stmt FROM @ddl; EXECUTE lastleg_inventory_dimension_stmt; DEALLOCATE PREPARE lastleg_inventory_dimension_stmt;
+ALTER TABLE ll_inventory_balance COMMENT='客户入仓单与海外目的仓维度实时库存余额';
+SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE()
+  AND table_name='ll_local_looseboard_order' AND column_name='lastleg_order_id'), 'SELECT 1',
+  'ALTER TABLE ll_local_looseboard_order ADD COLUMN lastleg_order_id BIGINT NULL COMMENT ''关联尾程主订单ID'' AFTER customer_id'));
+PREPARE lastleg_looseboard_tail_stmt FROM @ddl; EXECUTE lastleg_looseboard_tail_stmt; DEALLOCATE PREPARE lastleg_looseboard_tail_stmt;
+SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.statistics WHERE table_schema=DATABASE()
+  AND table_name='ll_local_looseboard_order' AND index_name='uk_ll_local_looseboard_lastleg'), 'SELECT 1',
+  'ALTER TABLE ll_local_looseboard_order ADD UNIQUE KEY uk_ll_local_looseboard_lastleg(lastleg_order_id)'));
+PREPARE lastleg_looseboard_tail_stmt FROM @ddl; EXECUTE lastleg_looseboard_tail_stmt; DEALLOCATE PREPARE lastleg_looseboard_tail_stmt;
+
+-- 派送单列表与详情快照、转派送费用及操作记录（当前上下文为尾程库）。
+SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_delivery_order' AND column_name='overseas_warehouse_name'), 'SELECT 1', 'ALTER TABLE ll_delivery_order ADD COLUMN overseas_warehouse_name VARCHAR(255) NULL COMMENT ''海外仓名称快照'', ADD COLUMN customer_name VARCHAR(255) NULL COMMENT ''客户名称快照'', ADD COLUMN waybill_no VARCHAR(128) NULL COMMENT ''承运运单号'', ADD COLUMN delivery_method VARCHAR(32) NULL COMMENT ''派送方式'', ADD COLUMN carrier_name VARCHAR(255) NULL COMMENT ''派送承运商'', ADD COLUMN pickup_method VARCHAR(64) NULL COMMENT ''提货方式'', ADD COLUMN loading_type VARCHAR(64) NULL COMMENT ''装车类型'', ADD COLUMN vehicle_type VARCHAR(64) NULL COMMENT ''车辆类型'', ADD COLUMN vehicle_size VARCHAR(64) NULL COMMENT ''车辆大小'', ADD COLUMN vehicle_plate VARCHAR(64) NULL COMMENT ''车牌号'', ADD COLUMN driver_name VARCHAR(128) NULL COMMENT ''司机或车队名称'', ADD COLUMN driver_phone VARCHAR(64) NULL COMMENT ''车队联系电话'', ADD COLUMN appointment_account VARCHAR(128) NULL COMMENT ''预约账号'', ADD COLUMN seller_name VARCHAR(128) NULL COMMENT ''卖家姓名'', ADD COLUMN total_weight_kg DECIMAL(18,4) NOT NULL DEFAULT 0 COMMENT ''总重量（千克）'', ADD COLUMN total_volume_cbm DECIMAL(18,4) NOT NULL DEFAULT 0 COMMENT ''总体积（立方米）'', ADD COLUMN planned_delivery_at DATETIME(3) NULL COMMENT ''预计派送时间'', ADD COLUMN dispatched_at DATETIME(3) NULL COMMENT ''实际派送时间'', ADD COLUMN expected_arrival_at DATETIME(3) NULL COMMENT ''预计到达时间'', ADD COLUMN signed_at DATETIME(3) NULL COMMENT ''签收时间'', ADD COLUMN remark VARCHAR(1000) NULL COMMENT ''派送备注'''));
+PREPARE delivery_detail_stmt FROM @ddl; EXECUTE delivery_detail_stmt; DEALLOCATE PREPARE delivery_detail_stmt;
+CREATE TABLE IF NOT EXISTS ll_delivery_fee (id BIGINT NOT NULL COMMENT '派送费用主键', customer_id VARCHAR(128) NOT NULL COMMENT '客户数据隔离键', delivery_order_id BIGINT NOT NULL COMMENT '派送单ID', fee_direction VARCHAR(16) NOT NULL DEFAULT 'PAYABLE' COMMENT '应收应付方向', fee_type VARCHAR(64) NOT NULL COMMENT '费用类型', currency VARCHAR(8) NOT NULL COMMENT '币种', amount DECIMAL(18,2) NOT NULL COMMENT '费用金额', remark VARCHAR(500) NULL COMMENT '费用备注', created_by VARCHAR(128) NULL COMMENT '创建人ID', created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间', PRIMARY KEY(id), KEY idx_ll_delivery_fee_order(customer_id,delivery_order_id,id)) ENGINE=InnoDB COMMENT='派送单费用明细';
+CREATE TABLE IF NOT EXISTS ll_delivery_operation (id BIGINT NOT NULL COMMENT '派送操作主键', customer_id VARCHAR(128) NOT NULL COMMENT '客户数据隔离键', delivery_order_id BIGINT NOT NULL COMMENT '派送单ID', operation_node VARCHAR(64) NOT NULL COMMENT '操作节点', operator_id VARCHAR(128) NULL COMMENT '操作人ID', operator_name VARCHAR(128) NULL COMMENT '操作人名称', result VARCHAR(500) NOT NULL COMMENT '处理结果', created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '操作时间', PRIMARY KEY(id), KEY idx_ll_delivery_operation_order(customer_id,delivery_order_id,created_at,id)) ENGINE=InnoDB COMMENT='派送单操作记录';
+
+CREATE TABLE IF NOT EXISTS ll_exception_order (
+  id BIGINT NOT NULL COMMENT '异常订单ID', customer_id VARCHAR(128) NOT NULL COMMENT '客户数据隔离键', exception_no VARCHAR(64) NOT NULL COMMENT '异常订单号',
+  exception_type VARCHAR(32) NOT NULL COMMENT '异常类型', status VARCHAR(32) NOT NULL DEFAULT 'PENDING' COMMENT '异常处理状态', reason VARCHAR(1000) NOT NULL COMMENT '异常原因',
+  last_mile_order_id BIGINT NULL COMMENT '关联尾程订单ID', last_mile_order_no VARCHAR(64) NULL COMMENT '关联尾程订单号', inbound_order_id BIGINT NULL COMMENT '关联入仓单ID', inbound_code VARCHAR(128) NULL COMMENT '关联入仓码',
+  delivery_order_id BIGINT NULL COMMENT '关联派送单ID', delivery_no VARCHAR(64) NULL COMMENT '关联派送单号', outbound_no VARCHAR(64) NULL COMMENT '关联出库单号',
+  customer_name VARCHAR(255) NULL COMMENT '客户名称快照', overseas_warehouse_id VARCHAR(128) NULL COMMENT '海外仓ID快照', overseas_warehouse_name VARCHAR(255) NULL COMMENT '海外仓名称快照',
+  sku_code VARCHAR(128) NULL COMMENT '异常货物SKU', package_count INT NULL COMMENT '异常箱数', return_direction VARCHAR(32) NULL COMMENT '退回方向', return_logistics_no VARCHAR(128) NULL COMMENT '退回物流单号',
+  handling_action VARCHAR(500) NULL COMMENT '异常处理措施', handler_id VARCHAR(128) NULL COMMENT '处理人ID', handler_name VARCHAR(128) NULL COMMENT '处理人名称',
+  source_type VARCHAR(32) NOT NULL DEFAULT 'MANUAL' COMMENT '异常来源类型', created_by VARCHAR(128) NULL COMMENT '创建人ID',
+  exception_at DATETIME(3) NOT NULL COMMENT '异常发生时间', created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间',
+  updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT '更新时间',
+  PRIMARY KEY(id), UNIQUE KEY uk_ll_exception_no(customer_id,exception_no),
+  UNIQUE KEY uk_ll_exception_delivery_return(customer_id,delivery_order_id,exception_type),
+  KEY idx_ll_exception_list(customer_id,status,exception_at), KEY idx_ll_exception_tail(customer_id,last_mile_order_no),
+  KEY idx_ll_exception_inbound(customer_id,inbound_code)
+) ENGINE=InnoDB COMMENT='海外仓异常订单';
+
+CREATE TABLE IF NOT EXISTS ll_customer_visit (
+  id BIGINT NOT NULL COMMENT '客户回访记录ID',
+  customer_id VARCHAR(128) NOT NULL COMMENT '客户数据隔离键',
+  delivery_order_id BIGINT NOT NULL COMMENT '关联派送单ID',
+  delivery_no VARCHAR(64) NOT NULL COMMENT '关联派送单号',
+  customer_name VARCHAR(255) NULL COMMENT '客户名称快照',
+  contact_name VARCHAR(128) NULL COMMENT '客户联系人姓名快照',
+  contact_phone VARCHAR(64) NULL COMMENT '客户联系人电话快照',
+  destination VARCHAR(500) NULL COMMENT '派送目的仓编码汇总快照',
+  delivery_completed_at DATETIME(3) NOT NULL COMMENT '派送完成时间',
+  status VARCHAR(32) NOT NULL DEFAULT 'PENDING' COMMENT '回访状态：PENDING待回访或COMPLETED已回访',
+  selected_last_mile_order_id BIGINT NULL COMMENT '本次回访选择的尾程订单ID',
+  selected_last_mile_order_no VARCHAR(64) NULL COMMENT '本次回访选择的尾程订单号',
+  selected_inbound_order_id BIGINT NULL COMMENT '本次回访选择的入仓单ID',
+  selected_inbound_code VARCHAR(128) NULL COMMENT '本次回访选择的入仓码',
+  visit_result VARCHAR(32) NULL COMMENT '最近一次回访结果',
+  customer_feedback VARCHAR(2000) NULL COMMENT '最近一次客户反馈',
+  remark VARCHAR(1000) NULL COMMENT '最近一次回访备注',
+  attachment_json JSON NULL COMMENT '当前回访资料文件元数据列表',
+  visited_by VARCHAR(128) NULL COMMENT '最近一次回访操作人ID',
+  visited_at DATETIME(3) NULL COMMENT '最近一次回访时间',
+  visit_count INT NOT NULL DEFAULT 0 COMMENT '累计保存回访次数',
+  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间',
+  updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT '更新时间',
+  PRIMARY KEY(id),
+  UNIQUE KEY uk_ll_customer_visit_delivery(customer_id,delivery_order_id),
+  KEY idx_ll_customer_visit_list(customer_id,status,delivery_completed_at),
+  KEY idx_ll_customer_visit_delivery_no(customer_id,delivery_no)
+) ENGINE=InnoDB COMMENT='派送单维度客户回访记录';
+
+
+INSERT INTO baiyue_iam.iam_permission
+  (id,tenant_id,app_code,permission_type,parent_id,permission_code,permission_name,route_path,http_method,sort_no,status,built_in,deleted)
+VALUES
+  (5107070,0,'PLATFORM','MENU',0,'platform:overseas-warehouse:exception-order:list','海外异常订单','/overseas-warehouse/exception-orders','GET',770,'ACTIVE',1,0),
+  (5107071,0,'PLATFORM','BUTTON',5107070,'platform:overseas-warehouse:exception-order:create','新增海外异常订单',NULL,'POST',771,'ACTIVE',1,0),
+  (5107072,0,'PLATFORM','BUTTON',5107070,'platform:overseas-warehouse:delivery:return','派送单标记退货',NULL,'POST',772,'ACTIVE',1,0)
+  ,(5107080,0,'PLATFORM','MENU',0,'platform:overseas-warehouse:customer-visit:list','客户回访','/overseas-warehouse/customer-visits','GET',780,'ACTIVE',1,0)
+  ,(5107081,0,'PLATFORM','BUTTON',5107080,'platform:overseas-warehouse:customer-visit:edit','保存客户回访',NULL,'PUT',781,'ACTIVE',1,0)
+  ,(5107082,0,'PLATFORM','BUTTON',5107080,'platform:overseas-warehouse:delivery:status','编辑派送单状态',NULL,'PUT',782,'ACTIVE',1,0)
+ON DUPLICATE KEY UPDATE permission_name=VALUES(permission_name),route_path=VALUES(route_path),http_method=VALUES(http_method),sort_no=VALUES(sort_no),status='ACTIVE',built_in=1,deleted=0;
+INSERT IGNORE INTO baiyue_iam.iam_role_permission (tenant_id,role_id,permission_id,created_at)
+SELECT 0,role.id,permission.id,NOW(3) FROM baiyue_iam.iam_role role
+JOIN baiyue_iam.iam_permission permission ON permission.id BETWEEN 5107070 AND 5107082 AND permission.tenant_id=0
+WHERE role.tenant_id=0 AND role.app_code='PLATFORM' AND role.role_code='PLATFORM_ADMIN' AND role.status='ACTIVE' AND role.deleted=0;
+
 -- IAM 客户提交即成功，默认尺寸通过持久化任务后台初始化；已有客户按历史事实标记 READY。
 USE baiyue_iam;
 SET @customer_dimension_status_ddl = (SELECT IF(
@@ -16269,6 +16505,16 @@ CREATE TABLE IF NOT EXISTS iam_customer_dimension_initialization_task (
   KEY idx_customer_dimension_task_diagnosis (status,updated_at)
 ) ENGINE=InnoDB COMMENT='IAM客户默认尺寸可靠后台初始化任务及诊断状态';
 
+-- 兼容已存在的旧表：CREATE TABLE IF NOT EXISTS 不会为旧表补充新字段。
+SET @customer_dimension_lease_ddl = (SELECT IF(
+  EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE()
+    AND table_name='iam_customer_dimension_initialization_task' AND column_name='lease_until'),
+  'SELECT 1',
+  'ALTER TABLE iam_customer_dimension_initialization_task ADD COLUMN lease_until DATETIME(3) NULL COMMENT ''当前任务租约截止时间'' AFTER lease_owner'));
+PREPARE customer_dimension_lease_stmt FROM @customer_dimension_lease_ddl;
+EXECUTE customer_dimension_lease_stmt;
+DEALLOCATE PREPARE customer_dimension_lease_stmt;
+
 USE baiyue_firstleg;
 ALTER TABLE fl_loading_pick_task MODIFY COLUMN task_status VARCHAR(24) NOT NULL DEFAULT 'LOADING'
   COMMENT 'PDA任务状态：LOADING、COMPLETING、COMPLETION_FAILED、COMPLETED';

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

@@ -195,7 +195,7 @@ CREATE TABLE IF NOT EXISTS ll_overseas_procurement_order (
   purchase_quantity BIGINT NOT NULL COMMENT '采购数量', budget_unit_price DECIMAL(18,2) NULL COMMENT '预算单价',
   currency CHAR(3) NOT NULL DEFAULT 'USD' COMMENT '币种', receiving_address VARCHAR(1000) NULL COMMENT '收货地址',
   contact_name VARCHAR(128) NOT NULL COMMENT '联系人姓名', contact_phone VARCHAR(64) NOT NULL COMMENT '联系人电话',
-  purchase_warehouse_id VARCHAR(128) NULL COMMENT '采购入仓仓库ID', purchase_warehouse_name VARCHAR(255) NULL COMMENT '采购入仓仓库名称',
+  purchase_warehouse_id VARCHAR(128) NULL COMMENT '采购入仓仓库ID', purchase_warehouse_name VARCHAR(255) NULL COMMENT '采购入仓仓库名称', outbound_details JSON NULL COMMENT '出库明细',
   inbound_quantity BIGINT NOT NULL DEFAULT 0 COMMENT '采购单据累计入库数量', domestic_carrier VARCHAR(128) NULL COMMENT '境内承运商',
   domestic_tracking_no VARCHAR(128) NULL COMMENT '境内物流单号', overseas_carrier VARCHAR(128) NULL COMMENT '海外承运商',
   overseas_tracking_no VARCHAR(128) NULL COMMENT '海外物流单号', estimated_arrival_at DATETIME(3) NULL COMMENT '预计到达时间',
@@ -211,6 +211,8 @@ CREATE TABLE IF NOT EXISTS ll_overseas_procurement_order (
   KEY idx_ll_overseas_procurement_list(customer_id,status,created_at),
   KEY idx_ll_overseas_procurement_warehouse(customer_id,purchase_warehouse_id,created_at)
 ) ENGINE=InnoDB COMMENT='海外采购订单';
+SET @ddl = (SELECT IF(EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE() AND table_name='ll_overseas_procurement_order' AND column_name='outbound_details'), 'SELECT 1', 'ALTER TABLE ll_overseas_procurement_order ADD COLUMN outbound_details JSON NULL COMMENT ''出库明细'' AFTER inbound_quantity'));
+PREPARE procurement_outbound_stmt FROM @ddl; EXECUTE procurement_outbound_stmt; DEALLOCATE PREPARE procurement_outbound_stmt;
 
 SET @ddl = (SELECT IF(EXISTS (
   SELECT 1 FROM information_schema.columns
@@ -1073,7 +1075,57 @@ DELIMITER ;
 CALL assert_phase4_pda_operations_ready();
 DROP PROCEDURE assert_phase4_pda_operations_ready;
 
+CREATE TABLE IF NOT EXISTS ll_order_fee (
+  id BIGINT NOT NULL COMMENT '费用明细主键', customer_id VARCHAR(128) NOT NULL COMMENT '客户数据隔离键',
+  order_id BIGINT NOT NULL COMMENT '尾程订单ID', fee_item VARCHAR(128) NOT NULL COMMENT '费用项目',
+  currency VARCHAR(3) NOT NULL COMMENT '币种代码', amount DECIMAL(18,2) NOT NULL COMMENT '费用金额',
+  status VARCHAR(32) NOT NULL DEFAULT 'PENDING_REVIEW' COMMENT '费用状态：PENDING_REVIEW待审核、APPROVED审核通过、REJECTED已驳回',
+  supplier_description VARCHAR(500) NULL COMMENT '供应商或费用说明', created_by VARCHAR(128) NOT NULL COMMENT '创建操作人',
+  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间',
+  updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT '更新时间',
+  PRIMARY KEY(id), KEY idx_ll_order_fee_customer_order(customer_id,order_id,created_at)
+) ENGINE=InnoDB COMMENT='尾程订单费用明细';
+
+CREATE TABLE IF NOT EXISTS ll_order_operation_log (
+  id BIGINT NOT NULL COMMENT '操作记录主键', customer_id VARCHAR(128) NOT NULL COMMENT '客户数据隔离键',
+  order_id BIGINT NOT NULL COMMENT '尾程订单ID', operation_node VARCHAR(64) NOT NULL COMMENT '操作节点',
+  operator_name VARCHAR(128) NOT NULL COMMENT '操作人名称', result VARCHAR(500) NOT NULL COMMENT '处理结果',
+  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '操作时间',
+  PRIMARY KEY(id), KEY idx_ll_order_operation_customer_order(customer_id,order_id,created_at)
+) ENGINE=InnoDB COMMENT='尾程订单操作记录';
+
+CREATE TABLE IF NOT EXISTS ll_outbound_pda_task (
+  id BIGINT NOT NULL COMMENT '主键ID', customer_id VARCHAR(128) NOT NULL COMMENT '客户数据隔离键', outbound_order_id BIGINT NOT NULL COMMENT '出库单ID',
+  task_no VARCHAR(64) NOT NULL COMMENT 'PDA任务号', status VARCHAR(32) NOT NULL DEFAULT 'PENDING' COMMENT '任务状态',
+  pushed_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '推送时间', completed_at DATETIME(3) NULL COMMENT '完成时间',
+  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间', updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT '更新时间',
+  PRIMARY KEY(id), UNIQUE KEY uk_ll_outbound_pda_task_order(customer_id,outbound_order_id), UNIQUE KEY uk_ll_outbound_pda_task_no(customer_id,task_no)
+) ENGINE=InnoDB COMMENT='一件代发出库PDA拣货任务';
+
+CREATE TABLE IF NOT EXISTS ll_outbound_pda_pick (
+  id BIGINT NOT NULL COMMENT '主键ID', customer_id VARCHAR(128) NOT NULL COMMENT '客户数据隔离键', task_id BIGINT NOT NULL COMMENT 'PDA任务ID',
+  outbound_pallet_item_id BIGINT NOT NULL COMMENT '出库托盘明细ID', inventory_position_id BIGINT NOT NULL COMMENT '库存仓位ID', packages BIGINT NOT NULL COMMENT '拣货箱数',
+  idempotency_key VARCHAR(255) NOT NULL COMMENT '拣货幂等键', picked_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '拣货时间',
+  PRIMARY KEY(id), UNIQUE KEY uk_ll_outbound_pda_pick_key(customer_id,idempotency_key)
+) ENGINE=InnoDB COMMENT='一件代发出库PDA托盘拣货记录';
+
 USE baiyue_lastleg;
+SET @ddl = (SELECT IF(EXISTS (
+  SELECT 1 FROM information_schema.columns
+   WHERE table_schema=DATABASE() AND table_name='ll_inbound_plan' AND column_name='version'
+), 'SELECT 1', 'ALTER TABLE ll_inbound_plan ADD COLUMN version INT NOT NULL DEFAULT 0 COMMENT ''入库计划乐观锁版本'' AFTER updated_at'));
+PREPARE ll_inbound_plan_version_ddl FROM @ddl;
+EXECUTE ll_inbound_plan_version_ddl;
+DEALLOCATE PREPARE ll_inbound_plan_version_ddl;
+
+SET @ddl = (SELECT IF(EXISTS (
+  SELECT 1 FROM information_schema.columns
+   WHERE table_schema=DATABASE() AND table_name='ll_order' AND column_name='pallet_merge_batch_id'
+), 'SELECT 1', 'ALTER TABLE ll_order ADD COLUMN pallet_merge_batch_id VARCHAR(64) NULL COMMENT ''平台预标记合托分组号'' AFTER pallet_merge_flag'));
+PREPARE ll_order_merge_batch_ddl FROM @ddl;
+EXECUTE ll_order_merge_batch_ddl;
+DEALLOCATE PREPARE ll_order_merge_batch_ddl;
+
 CREATE TABLE IF NOT EXISTS ll_security_event_inbox (
   event_id VARCHAR(64) NOT NULL COMMENT '跨区安全事件ID', event_type VARCHAR(96) NOT NULL COMMENT 'IAM安全事件类型',
   payload_hash CHAR(64) NOT NULL COMMENT '规范化载荷SHA-256哈希', payload_json JSON NOT NULL COMMENT '冻结事件载荷JSON',

docs/数据库环境切换说明.md

@@ -1,66 +1,62 @@
-# 数据库环境切换说明
+# Nacos 环境切换说明
 
-## 环境定义
+数据库、Redis 和服务地址均由所选环境的 Nacos 配置决定。本地启动时只切换
+Nacos 地址与 namespace，不再通过 `application-test.yml` 单独切换数据库。
 
-- `dev`：本地开发环境，连接 `127.0.0.1:3306`，默认账号为 `root/123456`。
+## 环境映射
-- `test`：联调测试环境，连接 `8.163.30.128:3306`，各微服务仍使用独立数据库。
 
-所有服务默认使用 `dev`：
+| Maven Profile | Nacos 地址 | Namespace |
+| --- | --- | --- |
+| `local` | `127.0.0.1:8848` | `public` |
+| `dev` | `dev-nacos.buggoglobal.com:8848` | `DEV_NACOS_NAMESPACE` |
+| `test` | `8.163.30.128:8848` | `d99d7998-5bb0-4ffe-a2a0-1a564ce14463` |
 
-```yaml
+本地 Nacos 使用 `nacos/nacos`。开发和测试密码不写入 Git，需在启动 IDEA
-spring:
+之前设置一次用户环境变量：
-  profiles:
+
-    active: ${SPRING_PROFILES_ACTIVE:dev}
+```powershell
+[Environment]::SetEnvironmentVariable('DEV_NACOS_PASSWORD', '<开发 Nacos 密码>', 'User')
+[Environment]::SetEnvironmentVariable('TEST_NACOS_PASSWORD', '<测试 Nacos 密码>', 'User')
+[Environment]::SetEnvironmentVariable('DEV_NACOS_NAMESPACE', '<开发海外 namespace>', 'User')
 ```
 
-建议不要直接修改配置文件。通过 IDEA 的启动配置设置 `Active profiles` 即可切换：
+设置后完全退出并重新打开 IDEA，使 Maven 能读取新环境变量。
 
-- 本地数据库：`dev`
+## IDEA 中切换
-- 测试数据库：`test`
 
-也可以使用启动参数：
+1. 在 Maven 面板的 `Profiles` 中，`local`、`dev`、`test` 只勾选一个。
+2. 重新加载 Maven 项目。
+3. 在目标服务的 Maven `Plugins > spring-boot > spring-boot:run` 启动。
 
-```text
+例如海外查询链路需要分别启动 `gateway-overseas`、`lastleg-service` 和
---spring.profiles.active=test
+`warehouse-overseas-service`。已经运行的进程不会自动切换环境，切换 Profile
+后必须停止并重新启动。
+
+IDEA 普通绿色 Run 按钮不执行 Maven，因此不会读取 Maven Profile。需要继续使用
+绿色 Run 时，请在 Run Configuration 的 Environment variables 中设置
+`NACOS_SERVER_ADDR`、`NACOS_NAMESPACE`、`NACOS_USERNAME` 和 `NACOS_PASSWORD`。
+`gateway-overseas` 已默认启用 `overseas` Spring Profile。
+
+## PowerShell 中切换
+
+也可以在当前终端加载同一套变量，然后从同一终端启动服务：
+
+```powershell
+. .\scripts\use-nacos-environment.ps1 -Environment local -Region overseas
+. .\scripts\use-nacos-environment.ps1 -Environment dev -Region overseas
+. .\scripts\use-nacos-environment.ps1 -Environment test -Region overseas
 ```
 
-## 测试数据库密码
+脚本读取 `DEV_NACOS_PASSWORD`、`TEST_NACOS_PASSWORD`，namespace 优先读取
+`*_OVERSEAS_NACOS_NAMESPACE`，未设置时读取 `*_NACOS_NAMESPACE`。命令前面的点和
+空格不能省略，否则变量只存在于脚本子进程中。
 
-测试数据库密码不写入 Git。启动 `test` 环境前，在 IDEA 启动配置的环境变量中设置：
+## 当前限制
 
-```text
+- 测试 Nacos 的 `8848` 客户端端口已确认可连接。
-TEST_DB_PASSWORD=测试数据库密码
+- 开发 Nacos 网页控制台可访问，但 `dev-nacos.buggoglobal.com:8848` 当前从本机
-```
+  无法连接。需要开放 Nacos 客户端端口以及 Nacos 2.x/3.x 所需的 gRPC 端口，
-
+  或提供一个客户端可访问的内部地址。
-公共测试连接参数支持覆盖：
+- 国内和海外存在同名 Data ID，远程环境必须使用各自独立 namespace。开发海外
-
+  namespace 尚未确认，因此通过 `DEV_NACOS_NAMESPACE` 在本机配置。
-```text
+- 不要同时勾选多个环境 Profile；Maven 对同名属性的最终取值不直观，容易连错环境。
-TEST_DB_HOST=8.163.30.128
-TEST_DB_PORT=3306
-TEST_DB_USERNAME=root
-TEST_DB_PASSWORD=测试数据库密码
-```
-
-每个服务还支持使用自己的 `*_TEST_DB_URL`、`*_TEST_DB_USERNAME` 和 `*_TEST_DB_PASSWORD` 覆盖公共参数。
-
-## 分库映射
-
-| 服务 | 测试数据库 |
-| --- | --- |
-| 认证服务 | `baiyue_auth` |
-| 权限服务 | `baiyue_iam` |
-| 订单服务 | `baiyue_order` |
-| 仓库服务 | `baiyue_warehouse` |
-| 头程履约服务 | `baiyue_firstleg` |
-| 文件服务 | `baiyue_file` |
-| 审计服务 | `baiyue_audit` |
-| 事件桥接服务 | `baiyue_event_bridge` |
-
-网关、打印和集成服务没有业务数据库，但同样支持 `dev/test` Profile。网关在两种环境下都会自动加载 `cn` 路由配置。
-
-## 注意事项
-
-- `test` 只切换数据库，Nacos 和 Redis 默认仍连接本机。
-- 环境变量优先级高于配置文件，可用于临时覆盖单个服务。
-- 修改 IDEA 环境变量后需要重启对应服务。
-- 不要把测试数据库密码提交到配置文件、启动脚本或 Git。

event-bridge-service/src/main/java/com/baiyue/eventbridge/metrics/EventBridgeMetrics.java

@@ -30,6 +30,7 @@ public class EventBridgeMetrics {
             EventTypes.FIRST_LEG_LOADING_PLAN_COMPLETED,
             EventTypes.FIRST_LEG_CONTAINER_SHIPPING_NODE_RECORDED,
             EventTypes.OVERSEAS_CONTAINER_UNLOADED,
+            EventTypes.OVERSEAS_INBOUND_ORDER_DETAINED_CHANGED,
             EventTypes.IAM_USER_STATUS_CHANGED,
             EventTypes.IAM_TENANT_STATUS_CHANGED,
             EventTypes.IAM_PERMISSION_VERSION_CHANGED,

event-bridge-service/src/main/java/com/baiyue/eventbridge/service/EventInboxService.java

@@ -31,10 +31,14 @@ public class EventInboxService {
     @Value("${baiyue.region:CN}")
     private String localRegion;
 
+    /** Local single-bridge mode may carry both regional envelopes; production keeps strict routing. */
+    @Value("${baiyue.event-bridge.accept-any-region:false}")
+    private boolean acceptAnyRegion;
+
     @Transactional
     public EventReceiveResult receive(EventEnvelope envelope) {
         envelope.requireValid();
-        if (!envelope.targetRegion().name().equalsIgnoreCase(localRegion)) {
+        if (!acceptAnyRegion && !envelope.targetRegion().name().equalsIgnoreCase(localRegion)) {
             throw new IllegalArgumentException("事件目标区域与当前事件桥区域不一致");
         }
         if (!EventPayloadHash.matches(

event-bridge-service/src/main/resources/application.yml

@@ -29,7 +29,7 @@ spring:
         namespace: ${NACOS_NAMESPACE:}
 
 baiyue:
-  region: ${REGION_CODE:OVERSEAS}
+  region: ${REGION_CODE:CN}
   event-dispatcher:
     consumer-url: ${EVENT_CONSUMER_URL:${LASTLEG_CONSUMER_URL:http://127.0.0.1:9303/internal/lastleg/events}}
     firstleg-consumer-url: ${FIRSTLEG_CONTAINER_EVENT_CONSUMER_URL:http://127.0.0.1:9202/internal/firstleg/v1/container-events}

event-bridge-service/src/test/java/com/baiyue/eventbridge/service/EventInboxServiceTest.java

@@ -151,6 +151,15 @@ class EventInboxServiceTest {
                 .hasMessageContaining("目标区域");
     }
 
+    @Test
+    void 本地单实例模式允许接收不同目标区域事件() {
+        EventInboxService localService = service("CN", true);
+        EventEnvelope envelope = withHash(envelope("sha256:placeholder"));
+
+        assertThat(localService.receive(envelope).result()).isEqualTo("已接收");
+        verify(store).insert(any(BridgeInbox.class));
+    }
+
     private EventEnvelope envelope(String hash) {
         return new EventEnvelope("550e8400-e29b-41d4-a716-446655440000", "OrderApproved", 1,
                 Instant.parse("2026-07-29T08:30:00Z"), RegionCode.CN, RegionCode.OVERSEAS,
@@ -159,11 +168,16 @@ class EventInboxServiceTest {
     }
 
     private EventInboxService service(String region) {
+        return service(region, false);
+    }
+
+    private EventInboxService service(String region, boolean acceptAnyRegion) {
         EventInboxService service = new EventInboxService();
         ReflectionTestUtils.setField(service, "inboxStore", store);
         ReflectionTestUtils.setField(service, "objectMapper", objectMapper);
         ReflectionTestUtils.setField(service, "metrics", metrics);
         ReflectionTestUtils.setField(service, "localRegion", region);
+        ReflectionTestUtils.setField(service, "acceptAnyRegion", acceptAnyRegion);
         return service;
     }
 

firstleg/AGENTS.md

@@ -15,7 +15,7 @@
 | 履约任务/分配 | `controller/PlatformFulfillmentAssignmentController.java`、`service/FulfillmentTaskService.java` |
 | 入库单查询/聚合 | `controller/PlatformInboundOrderController.java`、`service/InboundOrderQueryService.java` |
 | 平台测量/OCR | `controller/PlatformInboundMeasurementController.java`、`service/InboundMeasurementService.java`、`service/CartonMeasurementService.java`；手工单箱测量也从该 Controller 与 `CartonMeasurementService` 进入 |
-| 箱唛箱码生成、打印与测量绑定 | 审核建单生成钩子 `controller/InternalInboundOrderController.java`；生成/解析 `service/InboundCartonLabelService.java`、`repository/InboundCartonLabelRepository.java`；平台与客户打印 `controller/PlatformInboundOrderController.java`、`MerchantInboundCartonLabelController.java`、`service/InboundCartonLabelPrintService.java`；基线/升级 SQL 为 `src/main/resources/db/phase2-inbound-carton-label.sql`、`phase2-carton-label-versioning-migration.sql` |
+| 箱唛箱码生成、打印与测量绑定 | 审核建单生成钩子 `controller/InternalInboundOrderController.java`；生成/解析 `service/InboundCartonLabelService.java`、`repository/InboundCartonLabelRepository.java`；平台与客户打印 `controller/PlatformInboundOrderController.java`、`MerchantInboundCartonLabelController.java`、`service/InboundCartonLabelPrintService.java`。`fl_inbound_carton_label.sku_code` 是箱唛的 SKU 冻结快照，生成时经 `client/OrderCargoClient.java` 获取；既有记录按 `inbound_detail_id` 回填。`ONE_CLICK_DROPSHIP` 缺 SKU 时禁止生成箱唛。`box_code`、二维码内容和现有打印版式不携带 SKU，不能因该绑定改变。基线/升级 SQL 为 `src/main/resources/db/phase2-inbound-carton-label.sql`、`phase2-carton-label-versioning-migration.sql`、`../deploy/sql/头程数据库统一增量-MySQL8.sql` |
 | 墨家设备测量上传 | `controller/OpenApiInboundMeasurementController.java`、`dto/MojiaMeasurementDtos.java`、`service/MojiaMeasurementOpenApiService.java`、`security/MeasurementRequestAuthenticator.java`；接口契约见 `src/main/resources/openapi/firstleg-v1.yaml` 与 `../../docs/墨家设备测量上传接口说明-V3.md` |
 | 审核与初始计价 | `controller/PlatformInboundMeasurementReviewController.java`、`service/MeasurementReviewService.java`、`service/InitialInboundPricingService.java`、`dto/MeasurementApprovalResponse.java` |
 | FBA 主数据/计费 | `controller/PlatformFbaMasterDataController.java`、`PlatformFbaPricingController.java`、`service/FbaPricingService.java` |
@@ -35,6 +35,7 @@
 | PDA 拣货与装柜 | `controller/PlatformLoadingPdaController.java`、`loading/controller/PlatformLoadingDeliveryController.java` |
 | 装柜完成跨区事件 | `service/LoadingCompletedOutboxService.java`、`LoadingCompletedOutboxRelay.java`、`repository/LoadingCompletedOutboxRepository.java`、`mapper/LoadingCartonManifestMapper.java`、`client/EventBridgeClient.java`；从 `fl_inbound_order.destination_type` 冻结 V2 `orders[].destinationType=FBA|OVERSEAS`，OVERSEAS 按最终实装与稳定箱码冻结，FBA 可仅冻结箱数；真实生产验收 `src/test/java/com/baiyue/firstleg/service/TaillegRealProducerAcceptanceTest.java`；事件模型见 `../common-event-contract/AGENTS.md` |
 | 海外卸柜完成事件回写 | 内部入口 `controller/InternalOverseasContainerEventController.java`、消费者 `service/OverseasContainerEventConsumer.java`、Inbox `entity/ContainerEventInboxEntity.java` 与 `mapper/ContainerEventInboxMapper.java`；事件模型见 `../common-event-contract/AGENTS.md` |
+| 海外暂扣状态回写 | 同一内部事件入口、消费者 `service/OverseasInboundOrderDetainedConsumer.java`；按来源入仓单 ID 更新 `fl_inbound_order.hold_flag/current_hold_reason`，复用跨区 Inbox 并写 `fl_inbound_hold_record` |
 | 三期海运订舱、关联候选与出仓前船期资料 | `oceanbooking/controller/PlatformOceanBookingController.java`、`oceanbooking/service/OceanBookingService.java`、`oceanbooking/mapper/OceanBookingMapper.java`、`portschedule/controller/PlatformPortScheduleController.java`；关联候选入口 `/api/platform/v1/ocean-bookings/link-candidates`，订舱契约见 `src/main/resources/openapi/ocean-bookings-v1.yaml`，表结构见 `src/main/resources/db/phase3-ocean-booking-schema.sql` |
 | 四期国内出仓后船节点定时查询 | `outbound/dispatch/service/OutboundDispatchService.java` 在确认出仓事务内幂等创建现有 `CarrierScheduleQuery`；编排与租约 `portschedule/service/CarrierScheduleQueryScheduler.java`，任务/十节点事实/异常事实/不可变 attempt `CarrierScheduleQueryService.java`，平台查询与人工补录入口 `PlatformCarrierScheduleQueryController.java` 的 `/{queryId}/manual-nodes`；停止只由实际 `EMPTY_RETURNED` 节点触发，不提供无节点停止入口；外部船司/轨迹调用经 `integration-service/`；标准见 `../../docs/四期/船节点标准化契约.md` |
 | 船节点跨区交接事件 | `portschedule/service/CarrierScheduleNodeOutboxService.java`；实际节点落库后发布 `FIRST_LEG_CONTAINER_SHIPPING_NODE_RECORDED` V1，复用 `LoadingCompletedOutboxRepository`/Relay 投 Event Bridge；海外消费见 `../lastleg-service/src/main/java/com/baiyue/lastleg/shipping/service/ContainerShippingNodeConsumer.java` |
@@ -55,6 +56,7 @@
 - 价格簿查询消费者依赖 `PriceBookQueryUseCase` 或稳定查询端口，不得反向依赖持久化 Mapper；移动旧查询类时同步更新生产调用、测试、Mock 与 import，避免同一职责在根 `repository/mapper` 和 `pricebookquery/` 双写。
 - 第三方回传必须签名、时间窗、防重放、请求哈希，并绑定订单货物和 File 证据；不得信任外部客户字段。
 - 稳定箱码映射以入库快照和 Order 货物明细为事实；订单审核创建入库单时必须幂等生成，打印接口只复用或补齐同一映射，用户是否下载箱唛不得决定箱码有效性。手工测量、墨家设备和 PDA 扫码统一通过 `InboundCartonLabelService` 校验客户、入库单、货物明细、总箱数/下标和有效批次，不得在测量时临时伪造箱码或接受跨客户、跨入库箱码。
+- 一件代发以 `fl_inbound_carton_label.sku_code` 作为不可变 SKU 快照；PDA 仍只扫描稳定 `box_code`，不得将 SKU 塞入二维码或以 SKU 替代箱码。实际打托后的查询必须能按“现场托盘 -> 客户 -> SKU -> 箱数”聚合；历史箱唛仅能在同客户、同入库单范围内按 `inbound_detail_id` 回填，禁止按货名、箱规或箱号猜测 SKU。修改本链路时同步检查 `OrderCargoClient`、Order 内部货物接口及 PDA 打托实现。
 - 测量审核通过后直接进入 `WAIT_SPLIT`，费用仅作为独立初算和人工维护结果，不得阻塞或回退订单主流程；计费量、单价和附加费调整必须版本化并由服务端重算金额。状态或 DTO 变更时逐个检查 Order/Warehouse/File/Integration 消费者。
 - 报关、订舱和拖车引用的供应商必须通过 `WarehouseSupplierSnapshotService` 按 ID 向 Warehouse 校验：报关使用 `CUSTOMS`，订舱使用 `BOOKING`（不区分国内/国外 scope），拖车使用 `TRUCKING`；供应商必须为 `ACTIVE`。请求中的名称只能作为一致性提示，持久化名称必须来自 Warehouse 快照，禁止用自由文本绕过 ID、类别或启用状态校验。修改任一供应商引用 DTO、OpenAPI 或内部客户端时，必须同步检查三条业务链、Warehouse `supplier-v1.yaml`、数据库快照字段和对应契约测试。
 - 订舱状态固定为 `DRAFT → RELEASED`：草稿允许资料不完整并可替换或删除，放舱时校验完整持久化聚合，放舱后永久只读。创建草稿和放舱都只维护订舱聚合、三类参与方及柜型需求，不创建真实 `containerNo`、货柜行或分配关系；真实货柜只在后续提柜关联时占用已放舱柜型需求。

firstleg/src/main/java/com/baiyue/firstleg/client/OrderCargoClient.java

@@ -63,7 +63,12 @@ public interface OrderCargoClient {
     }
 
     record CargoLabelBinding(Long cargoId, Long orderId, Integer itemNo, String cargoName,
-                             Integer packageCount, BigDecimal lengthCm, BigDecimal widthCm,
+                             String skuNo, Integer packageCount, BigDecimal lengthCm, BigDecimal widthCm,
                              BigDecimal heightCm) {
+        public CargoLabelBinding(Long cargoId, Long orderId, Integer itemNo, String cargoName,
+                                 Integer packageCount, BigDecimal lengthCm, BigDecimal widthCm,
+                                 BigDecimal heightCm) {
+            this(cargoId, orderId, itemNo, cargoName, null, packageCount, lengthCm, widthCm, heightCm);
+        }
     }
 }

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

@@ -4,8 +4,9 @@ import com.baiyue.common.core.api.ApiResponse;
 import com.baiyue.common.core.api.ResultCode;
 import com.baiyue.common.core.exception.BizException;
 import com.baiyue.common.event.EventEnvelope;
-import com.baiyue.firstleg.entity.ContainerBookingEntity;
+import com.baiyue.common.event.EventTypes;
 import com.baiyue.firstleg.service.OverseasContainerEventConsumer;
+import com.baiyue.firstleg.service.OverseasInboundOrderDetainedConsumer;
 import lombok.RequiredArgsConstructor;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -20,14 +21,17 @@ import java.security.MessageDigest;
 @RequiredArgsConstructor
 public class InternalOverseasContainerEventController {
     private final OverseasContainerEventConsumer consumer;
+    private final OverseasInboundOrderDetainedConsumer detainedConsumer;
     @Value("${baiyue.security.internal-service-token}") private String expectedToken;
 
     @PostMapping("/internal/firstleg/v1/container-events")
-    public ApiResponse<ContainerBookingEntity> receive(
+    public ApiResponse<Object> receive(
         @RequestHeader(value = "X-Internal-Service-Token", required = false) String token,
         @RequestBody EventEnvelope event) {
         authenticate(token);
-        return ApiResponse.success(consumer.consume(event));
+        Object result = EventTypes.OVERSEAS_INBOUND_ORDER_DETAINED_CHANGED.equals(event.eventType())
+            ? detainedConsumer.consume(event) : consumer.consume(event);
+        return ApiResponse.success(result);
     }
 
     private void authenticate(String token) {

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

@@ -24,6 +24,11 @@ import org.springframework.http.ResponseEntity;
 import org.springframework.http.MediaType;
 import org.springframework.web.multipart.MultipartFile;
 import jakarta.validation.constraints.PositiveOrZero;
+import com.baiyue.firstleg.service.LoadingWorkPalletService;
+import com.baiyue.firstleg.dto.LoadingPalletDtos.OpenRequest;
+import com.baiyue.firstleg.dto.LoadingPalletDtos.ScanRequest;
+import com.baiyue.firstleg.dto.LoadingPalletDtos.SealRequest;
+import com.baiyue.firstleg.dto.LoadingPalletDtos.Pallet;
 import jakarta.annotation.Resource;
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotBlank;
@@ -51,6 +56,8 @@ public class PlatformLoadingPdaController {
     private LoadingPickService service;
     @Resource
     private CabinetLoadingEvidenceService evidenceService;
+    @Resource
+    private LoadingWorkPalletService palletService;
 
     @GetMapping("/tasks")
     @PreAuthorize("hasAuthority('platform:firstleg:pda:view')")
@@ -218,4 +225,45 @@ public class PlatformLoadingPdaController {
         FirstlegScopeGuard.platform(user);
         return ApiResponse.success(service.operations(taskId));
     }
+
+    @GetMapping("/tasks/{taskId}/pallets")
+    @PreAuthorize("hasAuthority('platform:firstleg:pda:view')")
+    public ApiResponse<List<Pallet>> pallets(@AuthenticationPrincipal AuthenticatedUser user,
+                                             @PathVariable @Positive long taskId,
+                                             @RequestParam @Positive long warehouseId) {
+        FirstlegScopeGuard.platform(user);
+        return ApiResponse.success(palletService.list(taskId, warehouseId));
+    }
+
+    @PostMapping("/tasks/{taskId}/pallets/open")
+    @PreAuthorize("hasAuthority('platform:firstleg:pda:work')")
+    public ApiResponse<Pallet> openPallet(@AuthenticationPrincipal AuthenticatedUser user,
+                                          @PathVariable @Positive long taskId,
+                                          @Valid @RequestBody OpenRequest request) {
+        FirstlegScopeGuard.platform(user);
+        return ApiResponse.success(palletService.open(taskId, request, user.userId(), user.username()));
+    }
+
+    /** 扫到其他未封托托盘上的箱唛时，同时完成按箱移托。 */
+    @PostMapping("/tasks/{taskId}/pallets/{palletId}/cartons/scan")
+    @PreAuthorize("hasAuthority('platform:firstleg:pda:work')")
+    public ApiResponse<Pallet> scanCarton(@AuthenticationPrincipal AuthenticatedUser user,
+                                          @PathVariable @Positive long taskId,
+                                          @PathVariable @Positive long palletId,
+                                          @Valid @RequestBody ScanRequest request) {
+        FirstlegScopeGuard.platform(user);
+        return ApiResponse.success(palletService.scan(taskId, palletId, request,
+            user.userId(), user.username()));
+    }
+
+    @PostMapping("/tasks/{taskId}/pallets/{palletId}/seal")
+    @PreAuthorize("hasAuthority('platform:firstleg:pda:work')")
+    public ApiResponse<Pallet> sealPallet(@AuthenticationPrincipal AuthenticatedUser user,
+                                          @PathVariable @Positive long taskId,
+                                          @PathVariable @Positive long palletId,
+                                          @Valid @RequestBody SealRequest request) {
+        FirstlegScopeGuard.platform(user);
+        return ApiResponse.success(palletService.seal(taskId, palletId, request,
+            user.userId(), user.username()));
+    }
 }

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

@@ -0,0 +1,41 @@
+package com.baiyue.firstleg.dto;
+
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+import java.util.List;
+
+/** 一件代发PDA现场打托接口模型。 */
+public final class LoadingPalletDtos {
+    private LoadingPalletDtos() {}
+
+    public record OpenRequest(
+        @NotNull @Min(1) Long warehouseId,
+        @Min(1) Long warehousePalletId,
+        @NotBlank @Size(max = 64) String palletCode,
+        @NotBlank @Size(max = 128) String operationId
+    ) {}
+
+    public record ScanRequest(
+        @NotNull @Min(1) Long warehouseId,
+        @NotBlank @Size(max = 80) String boxCode,
+        @NotBlank @Size(max = 128) String operationId
+    ) {}
+
+    public record SealRequest(
+        @NotNull @Min(1) Long warehouseId,
+        @NotNull @Min(0) Integer expectedVersion,
+        @NotBlank @Size(max = 128) String operationId
+    ) {}
+
+    public record Carton(Long id, String boxCode, String skuCode, Long tenantId,
+                         Long inboundId, Long inboundDetailId, Integer unitsPerCarton) {}
+
+    public record SkuSummary(String skuCode, Integer cartonCount, Long productQuantity) {}
+
+    public record Pallet(Long id, String palletCode, Long warehousePalletId, String status,
+                         Integer version, Integer cartonCount, Integer skuCount,
+                         Integer customerCount, List<SkuSummary> skus, List<Carton> cartons) {}
+}

firstleg/src/main/java/com/baiyue/firstleg/entity/InboundCartonLabelEntity.java

@@ -22,6 +22,7 @@ public class InboundCartonLabelEntity {
     private Long inboundDetailId;
     private Integer cargoItemNo;
     private String cargoName;
+    private String skuCode;
     private Integer detailPackageCount;
     private String inboundCode;
     private String boxCode;

firstleg/src/main/java/com/baiyue/firstleg/entity/InboundHoldRecordEntity.java

@@ -0,0 +1,24 @@
+package com.baiyue.firstleg.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+@Getter
+@Setter
+@TableName("fl_inbound_hold_record")
+public class InboundHoldRecordEntity {
+    @TableId(type = IdType.INPUT) private Long id;
+    private Long tenantId;
+    private Long inboundId;
+    private String holdAction;
+    private String reason;
+    private Long evidenceFileId;
+    private Long operatorId;
+    private String operatorName;
+    private LocalDateTime operatedAt;
+}

firstleg/src/main/java/com/baiyue/firstleg/entity/InboundOrderEntity.java

@@ -53,6 +53,7 @@ public class InboundOrderEntity extends BaseEntity {
     private String destinationName;
     private Boolean holdFlag;
     private String currentHoldReason;
+    private Long lastOverseasHoldVersion;
     private Integer totalPackageCount;
     private BigDecimal actualGrossWeightKg;
     private BigDecimal chargeableWeightKg;

firstleg/src/main/java/com/baiyue/firstleg/entity/LoadingWorkPalletCartonEntity.java

@@ -0,0 +1,37 @@
+package com.baiyue.firstleg.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.annotation.Version;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+/** 一件代发箱唛与现场实际托盘的当前绑定事实。 */
+@Getter
+@Setter
+@TableName("fl_loading_work_pallet_carton")
+public class LoadingWorkPalletCartonEntity {
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private Long pickTaskId;
+    private Long workPalletId;
+    private Long loadingPlanItemId;
+    private Long pickItemId;
+    private Long tenantId;
+    private Long inboundId;
+    private Long inboundDetailId;
+    private Long cartonLabelId;
+    private String boxCode;
+    private String skuCode;
+    private Integer unitsPerCarton;
+    private Long boundBy;
+    private String boundByName;
+    private String operationId;
+    @Version
+    private Integer version;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}

firstleg/src/main/java/com/baiyue/firstleg/entity/LoadingWorkPalletEntity.java

@@ -0,0 +1,36 @@
+package com.baiyue.firstleg.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.annotation.Version;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+/** 一件代发装柜现场的实际托盘。 */
+@Getter
+@Setter
+@TableName("fl_loading_work_pallet")
+public class LoadingWorkPalletEntity {
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private Long pickTaskId;
+    private Long loadingPlanId;
+    private Long warehouseId;
+    private Long warehousePalletId;
+    private String palletCode;
+    private String openOperationId;
+    private String sealOperationId;
+    private String palletStatus;
+    private Long createdBy;
+    private String createdByName;
+    private Long sealedBy;
+    private String sealedByName;
+    private LocalDateTime sealedAt;
+    @Version
+    private Integer version;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}

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

@@ -0,0 +1,9 @@
+package com.baiyue.firstleg.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baiyue.firstleg.entity.InboundHoldRecordEntity;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface InboundHoldRecordMapper extends BaseMapper<InboundHoldRecordEntity> {
+}

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

@@ -5,10 +5,25 @@ import com.baiyue.firstleg.entity.InboundOrderEntity;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.Update;
+import org.apache.ibatis.annotations.Select;
 
 /** 入库聚合根条件更新 Mapper，所有推进均同时校验租户、前置状态和版本。 */
 @Mapper
 public interface InboundOrderMapper extends BaseMapper<InboundOrderEntity> {
+    @Select("SELECT * FROM fl_inbound_order WHERE id=#{inboundId} AND deleted=0 FOR UPDATE")
+    InboundOrderEntity selectActiveByIdForUpdate(@Param("inboundId") long inboundId);
+
+    @Update("""
+        UPDATE fl_inbound_order
+           SET hold_flag=#{detained}, current_hold_reason=#{reason},
+               last_overseas_hold_version=#{sourceVersion}, updated_by=#{operatorId}, version=version+1
+         WHERE id=#{inboundId} AND tenant_id=#{tenantId} AND deleted=0
+           AND (last_overseas_hold_version IS NULL OR last_overseas_hold_version < #{sourceVersion})
+        """)
+    int applyOverseasHold(@Param("tenantId") long tenantId, @Param("inboundId") long inboundId,
+                          @Param("detained") boolean detained, @Param("reason") String reason,
+                          @Param("sourceVersion") long sourceVersion, @Param("operatorId") long operatorId);
+
     @Update("""
         UPDATE fl_inbound_order
            SET process_status = 'WAIT_SPLIT', measure_review_status = 'APPROVED',

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

@@ -50,11 +50,11 @@ public interface LoadingCompletedEventMapper {
         """)
     List<Row> rows(@Param("planId") long planId);
 
-    /** 读取一键代发托盘及其箱唛快照；普通订单不会使用该结果。 */
+    /** 读取头程托盘及箱唛快照；普通订单向尾程交接打印编号，一键代发同时冻结托盘库存。 */
     @Select("""
         SELECT i.account_id, i.inbound_id AS source_inbound_id,
                a.pallet_id, a.reservation_id, a.pallet_code, a.allocation_no,
-               a.picked_package_count AS allocated_package_count,
+               0 AS actual_binding, a.picked_package_count AS allocated_package_count,
                i.inbound_detail_id AS source_inbound_detail_id, i.sku_code,
                i.product_name_zh, i.package_count, i.product_quantity,
                label.box_code
@@ -80,6 +80,30 @@ public interface LoadingCompletedEventMapper {
         """)
     List<PalletRow> palletRows(@Param("planId") long planId);
 
+    /** 一件代发现场逐箱扫描结果；同一实物托盘可以包含多个客户，但行仍保留客户与入仓单归属。 */
+    @Select("""
+        SELECT carton.tenant_id AS account_id,carton.inbound_id AS source_inbound_id,
+               pallet.id AS pallet_id,1 AS actual_binding,
+               pallet.pallet_code,NULL AS allocation_no,
+               COUNT(*) OVER (PARTITION BY pallet.id,carton.tenant_id,carton.inbound_id) AS allocated_package_count,
+               carton.inbound_detail_id AS source_inbound_detail_id,carton.sku_code,
+               item.product_name_zh,item.package_count,item.product_quantity,carton.box_code
+          FROM fl_loading_work_pallet pallet
+          JOIN fl_loading_work_pallet_carton carton ON carton.work_pallet_id=pallet.id
+          JOIN fl_loading_plan_item item ON item.id=carton.loading_plan_item_id AND item.deleted=0
+          JOIN fl_loading_pick_task task ON task.id=pallet.pick_task_id
+           AND task.loading_plan_id=pallet.loading_plan_id
+         WHERE pallet.loading_plan_id=#{planId} AND pallet.pallet_status='SEALED'
+         ORDER BY carton.tenant_id,carton.inbound_id,pallet.id,item.inbound_detail_id,carton.id
+        """)
+    List<PalletRow> actualPalletRows(@Param("planId") long planId);
+
+    @Select("SELECT COUNT(*) FROM fl_loading_work_pallet WHERE loading_plan_id=#{planId} AND pallet_status<>'CANCELLED'")
+    int workPalletCount(@Param("planId") long planId);
+
+    @Select("SELECT COUNT(*) FROM fl_loading_work_pallet WHERE loading_plan_id=#{planId} AND pallet_status='OPEN'")
+    int openWorkPalletCount(@Param("planId") long planId);
+
     @Getter @Setter
     class Row {
         private Long loadingPlanId; private String planNo; private Long containerBookingId;
@@ -105,6 +129,7 @@ public interface LoadingCompletedEventMapper {
     class PalletRow {
         private Long accountId; private Long sourceInboundId; private Long palletId;
         private Long reservationId; private String palletCode;
+        private Boolean actualBinding;
         private Integer allocationNo; private Integer allocatedPackageCount;
         private Long sourceInboundDetailId; private String skuCode; private String productNameZh;
         private Integer packageCount; private Integer productQuantity; private String boxCode;

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

@@ -0,0 +1,90 @@
+package com.baiyue.firstleg.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baiyue.firstleg.entity.LoadingWorkPalletCartonEntity;
+import lombok.Getter;
+import lombok.Setter;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+import org.apache.ibatis.annotations.Update;
+
+import java.util.List;
+
+@Mapper
+public interface LoadingWorkPalletCartonMapper extends BaseMapper<LoadingWorkPalletCartonEntity> {
+    @Select("""
+        SELECT label.id carton_label_id,label.tenant_id,label.inbound_id,label.inbound_detail_id,
+               label.box_code,plan_item.id loading_plan_item_id,pick_item.id pick_item_id,
+               plan_item.sku_code,plan_item.units_per_carton
+          FROM fl_inbound_carton_label label
+          JOIN fl_loading_plan_item plan_item
+            ON plan_item.account_id=label.tenant_id AND plan_item.inbound_id=label.inbound_id
+           AND plan_item.inbound_detail_id=label.inbound_detail_id AND plan_item.deleted=0
+          JOIN fl_loading_pick_item pick_item ON pick_item.loading_plan_item_id=plan_item.id
+          JOIN fl_loading_pick_task task ON task.id=pick_item.pick_task_id
+           AND task.loading_plan_id=plan_item.loading_plan_id
+          JOIN fl_loading_plan plan ON plan.id=task.loading_plan_id
+          JOIN fl_container_booking booking ON booking.id=plan.container_booking_id
+          JOIN fl_inbound_order inbound_order ON inbound_order.id=plan_item.inbound_id
+           AND inbound_order.tenant_id=plan_item.account_id AND inbound_order.deleted=0
+         WHERE task.id=#{taskId} AND task.task_status='LOADING' AND booking.warehouse_id=#{warehouseId}
+           AND label.box_code=#{boxCode} AND label.batch_status='ACTIVE'
+           AND inbound_order.fulfillment_type='ONE_CLICK_DROPSHIP'
+           AND pick_item.item_status<>'SKIPPED'
+         ORDER BY label.tenant_id,label.id
+        """)
+    List<CartonCandidate> selectCandidates(@Param("taskId") long taskId,
+                                           @Param("warehouseId") long warehouseId,
+                                           @Param("boxCode") String boxCode);
+
+    @Select("SELECT * FROM fl_loading_work_pallet_carton WHERE pick_task_id=#{taskId} AND carton_label_id=#{labelId}")
+    LoadingWorkPalletCartonEntity selectBinding(@Param("taskId") long taskId,
+                                                @Param("labelId") long labelId);
+
+    @Select("SELECT * FROM fl_loading_work_pallet_carton WHERE operation_id=#{operationId}")
+    LoadingWorkPalletCartonEntity selectByOperation(@Param("operationId") String operationId);
+
+    @Select("SELECT * FROM fl_loading_work_pallet_carton WHERE work_pallet_id=#{palletId} ORDER BY id")
+    List<LoadingWorkPalletCartonEntity> selectPalletCartons(@Param("palletId") long palletId);
+
+    @Select("SELECT COUNT(*) FROM fl_loading_work_pallet_carton WHERE work_pallet_id=#{palletId}")
+    int countPalletCartons(@Param("palletId") long palletId);
+
+    @Select("""
+        SELECT COUNT(*) FROM (
+          SELECT carton.pick_item_id
+            FROM fl_loading_work_pallet_carton carton
+            JOIN fl_loading_pick_item pick_item ON pick_item.id=carton.pick_item_id
+           WHERE carton.pick_task_id=#{taskId}
+           GROUP BY carton.pick_item_id,pick_item.picked_package_count
+          HAVING COUNT(*)>pick_item.picked_package_count
+        ) unreconciled
+        """)
+    int countUnreconciled(@Param("taskId") long taskId);
+
+    @Update("""
+        UPDATE fl_loading_work_pallet_carton
+           SET work_pallet_id=#{targetPalletId},bound_by=#{operatorId},bound_by_name=#{operatorName},
+               operation_id=#{operationId},version=version+1
+         WHERE id=#{id} AND version=#{version}
+        """)
+    int move(@Param("id") long id, @Param("version") int version,
+             @Param("targetPalletId") long targetPalletId,
+             @Param("operatorId") long operatorId, @Param("operatorName") String operatorName,
+             @Param("operationId") String operationId);
+
+    @Getter
+    @Setter
+    class CartonCandidate {
+        private Long cartonLabelId;
+        private Long tenantId;
+        private Long inboundId;
+        private Long inboundDetailId;
+        private String boxCode;
+        private Long loadingPlanItemId;
+        private Long pickItemId;
+        private String skuCode;
+        private Integer unitsPerCarton;
+    }
+}

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

@@ -0,0 +1,77 @@
+package com.baiyue.firstleg.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baiyue.firstleg.entity.LoadingWorkPalletEntity;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+import org.apache.ibatis.annotations.Update;
+
+import java.util.List;
+
+@Mapper
+public interface LoadingWorkPalletMapper extends BaseMapper<LoadingWorkPalletEntity> {
+    @Select("""
+        SELECT task.id task_id,task.loading_plan_id,task.task_status,booking.warehouse_id,
+               assignment.assignee_id,
+               SUM(CASE WHEN inbound_order.fulfillment_type='ONE_CLICK_DROPSHIP' THEN 1 ELSE 0 END) dropship_item_count
+          FROM fl_loading_pick_task task
+          JOIN fl_loading_plan plan ON plan.id=task.loading_plan_id
+          JOIN fl_container_booking booking ON booking.id=plan.container_booking_id
+          JOIN fl_loading_pick_item pick_item ON pick_item.pick_task_id=task.id
+          JOIN fl_loading_plan_item plan_item ON plan_item.id=pick_item.loading_plan_item_id AND plan_item.deleted=0
+          JOIN fl_inbound_order inbound_order ON inbound_order.id=plan_item.inbound_id
+           AND inbound_order.tenant_id=plan_item.account_id AND inbound_order.deleted=0
+          LEFT JOIN fl_loading_pick_assignment assignment ON assignment.pick_task_id=task.id
+         WHERE task.id=#{taskId} AND booking.warehouse_id=#{warehouseId}
+         GROUP BY task.id,task.loading_plan_id,task.task_status,booking.warehouse_id,assignment.assignee_id
+        """)
+    TaskContext selectTaskContext(@Param("taskId") long taskId, @Param("warehouseId") long warehouseId);
+
+    @Select("SELECT * FROM fl_loading_work_pallet WHERE open_operation_id=#{operationId}")
+    LoadingWorkPalletEntity selectByOpenOperation(@Param("operationId") String operationId);
+
+    @Select("SELECT * FROM fl_loading_work_pallet WHERE seal_operation_id=#{operationId}")
+    LoadingWorkPalletEntity selectBySealOperation(@Param("operationId") String operationId);
+
+    @Select("""
+        SELECT pallet.*
+          FROM fl_loading_work_pallet pallet
+          JOIN fl_loading_pick_task task ON task.id=pallet.pick_task_id
+          JOIN fl_loading_plan plan ON plan.id=task.loading_plan_id
+          JOIN fl_container_booking booking ON booking.id=plan.container_booking_id
+         WHERE pallet.pick_task_id=#{taskId} AND pallet.id=#{palletId}
+           AND booking.warehouse_id=#{warehouseId}
+        """)
+    LoadingWorkPalletEntity selectScoped(@Param("taskId") long taskId,
+                                         @Param("palletId") long palletId,
+                                         @Param("warehouseId") long warehouseId);
+
+    @Select("""
+        SELECT pallet.*
+          FROM fl_loading_work_pallet pallet
+          JOIN fl_loading_pick_task task ON task.id=pallet.pick_task_id
+          JOIN fl_loading_plan plan ON plan.id=task.loading_plan_id
+          JOIN fl_container_booking booking ON booking.id=plan.container_booking_id
+         WHERE pallet.pick_task_id=#{taskId} AND booking.warehouse_id=#{warehouseId}
+           AND pallet.pallet_status<>'CANCELLED'
+         ORDER BY pallet.id
+        """)
+    List<LoadingWorkPalletEntity> selectTaskPallets(@Param("taskId") long taskId,
+                                                    @Param("warehouseId") long warehouseId);
+
+    @Update("""
+        UPDATE fl_loading_work_pallet
+           SET pallet_status='SEALED',seal_operation_id=#{operationId},sealed_by=#{operatorId},
+               sealed_by_name=#{operatorName},sealed_at=CURRENT_TIMESTAMP(3),version=version+1
+         WHERE id=#{palletId} AND pick_task_id=#{taskId} AND warehouse_id=#{warehouseId}
+           AND pallet_status='OPEN' AND version=#{expectedVersion}
+        """)
+    int seal(@Param("taskId") long taskId, @Param("palletId") long palletId,
+             @Param("warehouseId") long warehouseId, @Param("expectedVersion") int expectedVersion,
+             @Param("operationId") String operationId, @Param("operatorId") long operatorId,
+             @Param("operatorName") String operatorName);
+
+    record TaskContext(Long taskId, Long loadingPlanId, String taskStatus, Long warehouseId,
+                       Long assigneeId, Integer dropshipItemCount) {}
+}

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

@@ -62,6 +62,16 @@ public class InboundCartonLabelRepository {
             .set(InboundCartonLabelEntity::getCargoFingerprint, fingerprint));
     }
 
+    public void initializeLegacySku(long tenantId, long inboundId, long inboundDetailId, String skuCode) {
+        if (skuCode == null || skuCode.isBlank()) return;
+        labels.update(null, new LambdaUpdateWrapper<InboundCartonLabelEntity>()
+            .eq(InboundCartonLabelEntity::getTenantId, tenantId)
+            .eq(InboundCartonLabelEntity::getInboundId, inboundId)
+            .eq(InboundCartonLabelEntity::getInboundDetailId, inboundDetailId)
+            .isNull(InboundCartonLabelEntity::getSkuCode)
+            .set(InboundCartonLabelEntity::getSkuCode, skuCode.trim()));
+    }
+
     public boolean initializeOriginalPackageCount(long tenantId, long inboundId, int packageCount) {
         return inbounds.update(null, new LambdaUpdateWrapper<InboundOrderEntity>()
             .eq(InboundOrderEntity::getTenantId, tenantId)

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

@@ -50,6 +50,14 @@ public class InboundCartonLabelService implements CartonLabelBindingResolver {
             throw new BizException(ResultCode.CONFLICT, "当前入库单状态不允许首次生成箱号");
         }
         List<OrderCargoClient.CargoLabelBinding> cargoes = loadCargoes(inbound);
+        if ("ONE_CLICK_DROPSHIP".equals(inbound.getFulfillmentType())
+            && cargoes.stream().anyMatch(cargo -> cargo.skuNo() == null || cargo.skuNo().isBlank())) {
+            throw new BizException(ResultCode.VALIDATION_FAILED, "一件代发货物明细缺少SKU，不能生成箱唛");
+        }
+        existing.forEach(label -> cargoes.stream()
+            .filter(cargo -> java.util.Objects.equals(cargo.cargoId(), label.getInboundDetailId()))
+            .findFirst().ifPresent(cargo -> repository.initializeLegacySku(tenantId, inboundId,
+                label.getInboundDetailId(), cargo.skuNo())));
         String fingerprint = fingerprint(cargoes);
         if (!existing.isEmpty()) {
             String existingFingerprint = consistent.get(0).getCargoFingerprint();
@@ -202,6 +210,7 @@ public class InboundCartonLabelService implements CartonLabelBindingResolver {
         label.setInboundDetailId(cargo.cargoId());
         label.setCargoItemNo(cargo.itemNo());
         label.setCargoName(cargo.cargoName());
+        label.setSkuCode(cargo.skuNo());
         label.setDetailPackageCount(cargo.packageCount());
         label.setInboundCode(inbound.getInboundCode());
         label.setBoxCode(inbound.getInboundCode() + "#" + total + "-" + index);
@@ -256,7 +265,8 @@ public class InboundCartonLabelService implements CartonLabelBindingResolver {
 
     private String fingerprint(List<OrderCargoClient.CargoLabelBinding> cargoes) {
         String source = cargoes.stream().map(cargo -> String.join("|", String.valueOf(cargo.itemNo()),
-            cargo.cargoName() == null ? "" : cargo.cargoName().trim(), String.valueOf(cargo.packageCount()),
+            cargo.cargoName() == null ? "" : cargo.cargoName().trim(),
+            cargo.skuNo() == null ? "" : cargo.skuNo().trim(), String.valueOf(cargo.packageCount()),
             decimalOrEmpty(cargo.lengthCm()), decimalOrEmpty(cargo.widthCm()), decimalOrEmpty(cargo.heightCm())))
             .collect(java.util.stream.Collectors.joining("\n"));
         try {

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

@@ -53,13 +53,33 @@ public class LoadingCompletedOutboxService {
         validateContainerIdentity(rows);
         validateCustomerSnapshots(rows);
         Map<Long, List<String>> cartonMarks = cartonLabelPools(rows);
-        List<PalletRow> palletRows = snapshotMapper.palletRows(planId);
+        List<PalletRow> palletRows = palletRows(planId);
         rows.stream().collect(java.util.stream.Collectors.groupingBy(Row::getAccountId,
             java.util.TreeMap::new, java.util.stream.Collectors.toList()))
             .forEach((accountId, accountRows) -> insert(envelope(accountId, accountRows,
                 palletRows.stream().filter(item -> accountId.equals(item.getAccountId())).toList(), cartonMarks)));
     }
 
+    /** 已开展逐箱打托的入仓单使用现场事实；未开展的存量入仓单继续兼容原托盘分配快照。 */
+    private List<PalletRow> palletRows(long planId) {
+        int workPalletCount = snapshotMapper.workPalletCount(planId);
+        if (snapshotMapper.openWorkPalletCount(planId) > 0) {
+            throw new BizException(ResultCode.CONFLICT, "一件代发存在未封托的现场托盘，不能完成装柜交接");
+        }
+        List<PalletRow> actual = snapshotMapper.actualPalletRows(planId);
+        if (workPalletCount > 0 && actual.isEmpty()) {
+            throw new BizException(ResultCode.CONFLICT, "一件代发现场托盘没有有效箱唛，不能完成装柜交接");
+        }
+        if (actual.isEmpty()) return snapshotMapper.palletRows(planId);
+        Set<InboundPalletKey> actualInbounds = actual.stream().map(row ->
+            new InboundPalletKey(row.getAccountId(), row.getSourceInboundId())).collect(java.util.stream.Collectors.toSet());
+        List<PalletRow> result = new ArrayList<>(actual);
+        snapshotMapper.palletRows(planId).stream()
+            .filter(row -> !actualInbounds.contains(new InboundPalletKey(row.getAccountId(), row.getSourceInboundId())))
+            .forEach(result::add);
+        return result;
+    }
+
     private EventEnvelope envelope(long accountId, List<Row> rows, List<PalletRow> palletRows,
                                    Map<Long, List<String>> cartonMarks) {
         Row first = rows.get(0);
@@ -213,9 +233,13 @@ public class LoadingCompletedOutboxService {
     }
 
     private record LabelPoolKey(long accountId, long inboundId) { }
+    private record InboundPalletKey(long accountId, long inboundId) { }
 
     private List<FirstLegLoadingPlanCompletedV2.PalletSnapshot> palletSnapshots(List<Row> values, List<PalletRow> source) {
         if (source.isEmpty()) return List.of();
+        if (source.stream().anyMatch(item -> Boolean.TRUE.equals(item.getActualBinding()))) {
+            return actualPalletSnapshots(values, source);
+        }
         Map<String, List<PalletRow>> byPallet = source.stream().collect(java.util.stream.Collectors.groupingBy(
             p -> (p.getAllocationNo() == null ? "" : p.getAllocationNo()) + "|" + p.getPalletCode(),
             LinkedHashMap::new, java.util.stream.Collectors.toList()));
@@ -266,6 +290,43 @@ public class LoadingCompletedOutboxService {
         return result;
     }
 
+    /** 现场逐箱扫描已给出精确箱到托关系，不再使用旧的按托盘容量顺序推算。 */
+    private List<FirstLegLoadingPlanCompletedV2.PalletSnapshot> actualPalletSnapshots(
+        List<Row> values, List<PalletRow> source) {
+        Map<Long, Row> details = values.stream().collect(java.util.stream.Collectors.toMap(
+            Row::getSourceInboundDetailId, value -> value, (left, right) -> left, LinkedHashMap::new));
+        Map<String, List<PalletRow>> byPallet = source.stream().collect(java.util.stream.Collectors.groupingBy(
+            PalletRow::getPalletCode, LinkedHashMap::new, java.util.stream.Collectors.toList()));
+        List<FirstLegLoadingPlanCompletedV2.PalletSnapshot> result = new ArrayList<>();
+        int actualPackages = 0;
+        for (Map.Entry<String, List<PalletRow>> pallet : byPallet.entrySet()) {
+            Map<Long, List<PalletRow>> byDetail = pallet.getValue().stream().collect(
+                java.util.stream.Collectors.groupingBy(PalletRow::getSourceInboundDetailId,
+                    LinkedHashMap::new, java.util.stream.Collectors.toList()));
+            List<FirstLegLoadingPlanCompletedV2.SkuPackageSnapshot> skus = new ArrayList<>();
+            for (Map.Entry<Long, List<PalletRow>> detailRows : byDetail.entrySet()) {
+                Row detail = details.get(detailRows.getKey());
+                if (detail == null) throw new BizException(ResultCode.CONFLICT, "现场托盘箱唛无法匹配装柜货物明细");
+                List<String> marks = detailRows.getValue().stream().map(PalletRow::getBoxCode)
+                    .filter(Objects::nonNull).distinct().toList();
+                if (marks.size() != detailRows.getValue().size()) {
+                    throw new BizException(ResultCode.CONFLICT, "现场托盘包含空箱唛或重复箱唛");
+                }
+                int quantity = detail.getProductQuantity() == null ? marks.size()
+                    : (int) Math.round((double) detail.getProductQuantity() * marks.size()
+                        / Math.max(1, detail.getPackageCount()));
+                skus.add(new FirstLegLoadingPlanCompletedV2.SkuPackageSnapshot(detail.getSkuCode(),
+                    detail.getProductNameZh(), marks.size(), quantity, marks));
+                actualPackages += marks.size();
+            }
+            result.add(new FirstLegLoadingPlanCompletedV2.PalletSnapshot(pallet.getKey(), skus));
+        }
+        if (actualPackages != sumInt(values, Row::getPackageCount)) {
+            throw new BizException(ResultCode.CONFLICT, "一件代发现场托盘箱唛数与实装箱数不一致");
+        }
+        return result;
+    }
+
     private static boolean dropship(String value) {
         return "ONE_CLICK_DROPSHIP".equals(value);
     }

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

@@ -0,0 +1,206 @@
+package com.baiyue.firstleg.service;
+
+import com.baiyue.common.core.api.ResultCode;
+import com.baiyue.common.core.exception.BizException;
+import com.baiyue.firstleg.dto.LoadingPalletDtos.Carton;
+import com.baiyue.firstleg.dto.LoadingPalletDtos.OpenRequest;
+import com.baiyue.firstleg.dto.LoadingPalletDtos.Pallet;
+import com.baiyue.firstleg.dto.LoadingPalletDtos.ScanRequest;
+import com.baiyue.firstleg.dto.LoadingPalletDtos.SealRequest;
+import com.baiyue.firstleg.dto.LoadingPalletDtos.SkuSummary;
+import com.baiyue.firstleg.entity.LoadingWorkPalletCartonEntity;
+import com.baiyue.firstleg.entity.LoadingWorkPalletEntity;
+import com.baiyue.firstleg.mapper.LoadingWorkPalletCartonMapper;
+import com.baiyue.firstleg.mapper.LoadingWorkPalletCartonMapper.CartonCandidate;
+import com.baiyue.firstleg.mapper.LoadingWorkPalletMapper;
+import com.baiyue.firstleg.mapper.LoadingWorkPalletMapper.TaskContext;
+import jakarta.annotation.Resource;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/** 一件代发现场打托旁路；不改变既有拣货数量和仓库资源结算。 */
+@Service
+public class LoadingWorkPalletService {
+    @Resource private LoadingWorkPalletMapper pallets;
+    @Resource private LoadingWorkPalletCartonMapper cartons;
+
+    @Transactional
+    public Pallet open(long taskId, OpenRequest request, long operatorId, String operatorName) {
+        TaskContext context = requireWorkTask(taskId, request.warehouseId(), operatorId);
+        String code = request.palletCode().trim();
+        String operationId = request.operationId().trim();
+        LoadingWorkPalletEntity replay = pallets.selectByOpenOperation(operationId);
+        if (replay != null) {
+            if (replay.getPickTaskId() != taskId || !replay.getPalletCode().equals(code)) {
+                throw conflict("开托幂等号已用于其他请求");
+            }
+            return view(replay);
+        }
+        LoadingWorkPalletEntity value = new LoadingWorkPalletEntity();
+        value.setPickTaskId(taskId);
+        value.setLoadingPlanId(context.loadingPlanId());
+        value.setWarehouseId(request.warehouseId());
+        value.setWarehousePalletId(request.warehousePalletId());
+        value.setPalletCode(code);
+        value.setOpenOperationId(operationId);
+        value.setPalletStatus("OPEN");
+        value.setCreatedBy(operatorId);
+        value.setCreatedByName(operatorName);
+        value.setVersion(0);
+        try {
+            pallets.insert(value);
+        } catch (DuplicateKeyException exception) {
+            replay = pallets.selectByOpenOperation(operationId);
+            if (replay == null || replay.getPickTaskId() != taskId || !replay.getPalletCode().equals(code)) {
+                throw conflict("托盘号已存在或开托操作重复");
+            }
+            value = replay;
+        }
+        return view(value);
+    }
+
+    @Transactional
+    public Pallet scan(long taskId, long palletId, ScanRequest request,
+                       long operatorId, String operatorName) {
+        requireWorkTask(taskId, request.warehouseId(), operatorId);
+        LoadingWorkPalletEntity target = requireOpenPallet(taskId, palletId, request.warehouseId());
+        String operationId = request.operationId().trim();
+        LoadingWorkPalletCartonEntity replay = cartons.selectByOperation(operationId);
+        if (replay != null) {
+            if (replay.getPickTaskId() != taskId || replay.getWorkPalletId() != palletId
+                || !replay.getBoxCode().equals(request.boxCode().trim())) {
+                throw conflict("箱唛操作幂等号已用于其他请求");
+            }
+            return view(target);
+        }
+        List<CartonCandidate> candidates = cartons.selectCandidates(taskId, request.warehouseId(),
+            request.boxCode().trim());
+        if (candidates.isEmpty()) throw new BizException(ResultCode.NOT_FOUND, "箱唛不属于当前任务的一件代发货物");
+        if (candidates.size() > 1) throw conflict("箱唛在当前多客户任务中不唯一，请检查箱唛数据");
+        CartonCandidate candidate = candidates.get(0);
+        if (candidate.getSkuCode() == null || candidate.getSkuCode().isBlank()) {
+            throw conflict("一件代发箱唛缺少SKU，不能上托");
+        }
+        LoadingWorkPalletCartonEntity current = cartons.selectBinding(taskId, candidate.getCartonLabelId());
+        if (current == null) {
+            current = binding(taskId, palletId, candidate, operationId, operatorId, operatorName);
+            try {
+                cartons.insert(current);
+            } catch (DuplicateKeyException exception) {
+                LoadingWorkPalletCartonEntity concurrent = cartons.selectBinding(taskId, candidate.getCartonLabelId());
+                if (concurrent == null || concurrent.getWorkPalletId() != palletId) {
+                    throw conflict("箱唛已被其他托盘绑定");
+                }
+            }
+            return view(target);
+        }
+        if (current.getWorkPalletId() == palletId) return view(target);
+        LoadingWorkPalletEntity source = pallets.selectScoped(taskId, current.getWorkPalletId(), request.warehouseId());
+        if (source == null || !"OPEN".equals(source.getPalletStatus())) {
+            throw conflict("来源托盘已封托，不能直接移箱");
+        }
+        if (cartons.move(current.getId(), current.getVersion(), palletId, operatorId, operatorName, operationId) != 1) {
+            throw conflict("箱唛绑定已变化，请刷新后重试");
+        }
+        return view(target);
+    }
+
+    @Transactional
+    public Pallet seal(long taskId, long palletId, SealRequest request,
+                       long operatorId, String operatorName) {
+        requireWorkTask(taskId, request.warehouseId(), operatorId);
+        LoadingWorkPalletEntity replay = pallets.selectBySealOperation(request.operationId().trim());
+        if (replay != null) {
+            if (replay.getId() != palletId || replay.getPickTaskId() != taskId) {
+                throw conflict("封托幂等号已用于其他请求");
+            }
+            return view(replay);
+        }
+        requireOpenPallet(taskId, palletId, request.warehouseId());
+        if (cartons.countPalletCartons(palletId) == 0) throw conflict("空托盘不能封托");
+        if (cartons.countUnreconciled(taskId) > 0) {
+            throw conflict("现场上托箱数超过已提交拣货箱数，请先完成原PDA拣货提交");
+        }
+        if (pallets.seal(taskId, palletId, request.warehouseId(), request.expectedVersion(),
+            request.operationId().trim(), operatorId, operatorName) != 1) {
+            throw conflict("托盘状态或版本已变化，请刷新后重试");
+        }
+        return view(pallets.selectScoped(taskId, palletId, request.warehouseId()));
+    }
+
+    @Transactional(readOnly = true)
+    public List<Pallet> list(long taskId, long warehouseId) {
+        TaskContext context = pallets.selectTaskContext(taskId, warehouseId);
+        if (context == null) throw new BizException(ResultCode.NOT_FOUND, "未找到当前仓库的PDA任务");
+        return pallets.selectTaskPallets(taskId, warehouseId).stream().map(this::view).toList();
+    }
+
+    private TaskContext requireWorkTask(long taskId, long warehouseId, long operatorId) {
+        TaskContext context = pallets.selectTaskContext(taskId, warehouseId);
+        if (context == null) throw new BizException(ResultCode.NOT_FOUND, "未找到当前仓库的PDA任务");
+        if (!"LOADING".equals(context.taskStatus())) throw conflict("PDA任务已完成，不能继续打托");
+        if (context.dropshipItemCount() == null || context.dropshipItemCount() == 0) {
+            throw conflict("当前任务没有一件代发货物");
+        }
+        if (context.assigneeId() == null || context.assigneeId() != operatorId) {
+            throw conflict("请先领取PDA任务后再执行打托");
+        }
+        return context;
+    }
+
+    private LoadingWorkPalletEntity requireOpenPallet(long taskId, long palletId, long warehouseId) {
+        LoadingWorkPalletEntity pallet = pallets.selectScoped(taskId, palletId, warehouseId);
+        if (pallet == null) throw new BizException(ResultCode.NOT_FOUND, "现场托盘不存在");
+        if (!"OPEN".equals(pallet.getPalletStatus())) throw conflict("托盘不是打托中状态");
+        return pallet;
+    }
+
+    private static LoadingWorkPalletCartonEntity binding(long taskId, long palletId,
+                                                          CartonCandidate source, String operationId,
+                                                          long operatorId, String operatorName) {
+        LoadingWorkPalletCartonEntity value = new LoadingWorkPalletCartonEntity();
+        value.setPickTaskId(taskId);
+        value.setWorkPalletId(palletId);
+        value.setLoadingPlanItemId(source.getLoadingPlanItemId());
+        value.setPickItemId(source.getPickItemId());
+        value.setTenantId(source.getTenantId());
+        value.setInboundId(source.getInboundId());
+        value.setInboundDetailId(source.getInboundDetailId());
+        value.setCartonLabelId(source.getCartonLabelId());
+        value.setBoxCode(source.getBoxCode());
+        value.setSkuCode(source.getSkuCode());
+        value.setUnitsPerCarton(source.getUnitsPerCarton());
+        value.setBoundBy(operatorId);
+        value.setBoundByName(operatorName);
+        value.setOperationId(operationId);
+        value.setVersion(0);
+        return value;
+    }
+
+    private Pallet view(LoadingWorkPalletEntity pallet) {
+        List<LoadingWorkPalletCartonEntity> values = cartons.selectPalletCartons(pallet.getId());
+        Map<String, List<LoadingWorkPalletCartonEntity>> bySku = values.stream().collect(
+            java.util.stream.Collectors.groupingBy(LoadingWorkPalletCartonEntity::getSkuCode,
+                LinkedHashMap::new, java.util.stream.Collectors.toList()));
+        List<SkuSummary> skus = bySku.entrySet().stream().map(entry -> new SkuSummary(entry.getKey(),
+            entry.getValue().size(), entry.getValue().stream().map(LoadingWorkPalletCartonEntity::getUnitsPerCarton)
+                .filter(Objects::nonNull).mapToLong(Integer::longValue).sum())).toList();
+        List<Carton> cartonViews = values.stream().map(value -> new Carton(value.getId(), value.getBoxCode(),
+            value.getSkuCode(), value.getTenantId(), value.getInboundId(), value.getInboundDetailId(),
+            value.getUnitsPerCarton())).toList();
+        return new Pallet(pallet.getId(), pallet.getPalletCode(), pallet.getWarehousePalletId(),
+            pallet.getPalletStatus(), pallet.getVersion(), values.size(), bySku.size(),
+            (int) values.stream().map(LoadingWorkPalletCartonEntity::getTenantId).distinct().count(),
+            skus, cartonViews);
+    }
+
+    private static BizException conflict(String message) {
+        return new BizException(ResultCode.CONFLICT, message);
+    }
+}

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

@@ -0,0 +1,135 @@
+package com.baiyue.firstleg.service;
+
+import com.baomidou.mybatisplus.core.toolkit.IdWorker;
+import com.baiyue.common.event.EventEnvelope;
+import com.baiyue.common.event.EventPayloadCanonicalizer;
+import com.baiyue.common.event.EventPayloadHash;
+import com.baiyue.common.event.EventTypes;
+import com.baiyue.common.event.OverseasInboundOrderDetainedChangedV1;
+import com.baiyue.common.event.RegionCode;
+import com.baiyue.firstleg.entity.ContainerEventInboxEntity;
+import com.baiyue.firstleg.entity.InboundHoldRecordEntity;
+import com.baiyue.firstleg.entity.InboundOrderEntity;
+import com.baiyue.firstleg.mapper.ContainerEventInboxMapper;
+import com.baiyue.firstleg.mapper.InboundHoldRecordMapper;
+import com.baiyue.firstleg.mapper.InboundOrderMapper;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.util.Locale;
+import java.util.Objects;
+
+/** 将海外暂扣事实按来源入仓单绑定回写到国内头程入仓单。 */
+@Service
+@RequiredArgsConstructor
+public class OverseasInboundOrderDetainedConsumer {
+    private final InboundOrderMapper inboundOrders;
+    private final InboundHoldRecordMapper holdRecords;
+    private final ContainerEventInboxMapper inbox;
+    private final ObjectMapper objectMapper;
+
+    @Transactional
+    public InboundOrderEntity consume(EventEnvelope event) {
+        validateEnvelope(event);
+        OverseasInboundOrderDetainedChangedV1 payload = payload(event);
+        long inboundId = parsePositive(payload.sourceInboundId(), "来源入仓单 ID 无效");
+        long tenantId = parsePositive(event.tenantId(), "客户 ID 无效");
+        if (!payload.sourceInboundId().equals(event.aggregateId())) {
+            throw new IllegalArgumentException("事件 aggregateId 与来源入仓单 ID 不一致");
+        }
+        if (payload.changedAt() == null || payload.inboundCode() == null || payload.inboundCode().isBlank()
+            || payload.reason() == null || payload.reason().isBlank()) {
+            throw new IllegalArgumentException("暂扣事件缺少入仓码、原因或变更时间");
+        }
+
+        ContainerEventInboxEntity existing = inbox.selectById(event.eventId());
+        if (existing != null) {
+            if (!existing.getPayloadHash().equalsIgnoreCase(event.payloadHash())) {
+                throw new IllegalArgumentException("相同 eventId 对应的事件摘要冲突");
+            }
+            return requiredInbound(inboundId, tenantId, payload.inboundCode());
+        }
+        ContainerEventInboxEntity inboxRow = inbox(event);
+        try {
+            inbox.insert(inboxRow);
+        } catch (DuplicateKeyException duplicate) {
+            ContainerEventInboxEntity raced = inbox.selectById(event.eventId());
+            if (raced == null || !raced.getPayloadHash().equalsIgnoreCase(event.payloadHash())) throw duplicate;
+            return requiredInbound(inboundId, tenantId, payload.inboundCode());
+        }
+
+        InboundOrderEntity inbound = requiredInbound(inboundId, tenantId, payload.inboundCode());
+        if (inbound.getLastOverseasHoldVersion() == null
+            || event.aggregateVersion() > inbound.getLastOverseasHoldVersion()) {
+            int updated = inboundOrders.applyOverseasHold(tenantId, inboundId, payload.detained(),
+                payload.detained() ? payload.reason() : null, event.aggregateVersion(),
+                parseOperatorId(payload.operatorId()));
+            if (updated == 1) insertHistory(event, payload, tenantId, inboundId);
+        }
+        inboxRow.setStatus("PROCESSED");
+        inboxRow.setProcessedAt(LocalDateTime.now(ZoneOffset.UTC));
+        inbox.updateById(inboxRow);
+        return requiredInbound(inboundId, tenantId, payload.inboundCode());
+    }
+
+    private void validateEnvelope(EventEnvelope event) {
+        event.requireValid();
+        if (!EventTypes.OVERSEAS_INBOUND_ORDER_DETAINED_CHANGED.equals(event.eventType())
+            || event.eventVersion() != 1 || event.sourceRegion() != RegionCode.OVERSEAS
+            || event.targetRegion() != RegionCode.CN || !"INBOUND_ORDER".equals(event.aggregateType())) {
+            throw new IllegalArgumentException("不支持的海外入仓单暂扣事件");
+        }
+        if (!EventPayloadHash.matches(EventPayloadCanonicalizer.canonicalize(event.payload()), event.payloadHash())) {
+            throw new IllegalArgumentException("payloadHash 与事件负载不一致");
+        }
+    }
+
+    private OverseasInboundOrderDetainedChangedV1 payload(EventEnvelope event) {
+        try { return objectMapper.treeToValue(event.payload(), OverseasInboundOrderDetainedChangedV1.class); }
+        catch (Exception exception) { throw new IllegalArgumentException("海外入仓单暂扣事件负载无效", exception); }
+    }
+
+    private InboundOrderEntity requiredInbound(long inboundId, long tenantId, String inboundCode) {
+        InboundOrderEntity value = inboundOrders.selectActiveByIdForUpdate(inboundId);
+        if (value == null) throw new IllegalArgumentException("来源头程入仓单不存在");
+        if (!Objects.equals(value.getTenantId(), tenantId) || !Objects.equals(value.getInboundCode(), inboundCode)) {
+            throw new IllegalArgumentException("事件与来源头程入仓单归属不一致");
+        }
+        return value;
+    }
+
+    private void insertHistory(EventEnvelope event, OverseasInboundOrderDetainedChangedV1 payload,
+                               long tenantId, long inboundId) {
+        InboundHoldRecordEntity row = new InboundHoldRecordEntity();
+        row.setId(IdWorker.getId()); row.setTenantId(tenantId); row.setInboundId(inboundId);
+        row.setHoldAction(payload.detained() ? "HOLD" : "RELEASE"); row.setReason(payload.reason());
+        row.setOperatorId(parseOperatorId(payload.operatorId())); row.setOperatorName(payload.operatorName());
+        row.setOperatedAt(LocalDateTime.ofInstant(payload.changedAt(), ZoneOffset.UTC));
+        holdRecords.insert(row);
+    }
+
+    private ContainerEventInboxEntity inbox(EventEnvelope event) {
+        ContainerEventInboxEntity row = new ContainerEventInboxEntity();
+        row.setEventId(event.eventId()); row.setEventType(event.eventType()); row.setEventVersion(event.eventVersion());
+        row.setAggregateId(event.aggregateId()); row.setAggregateVersion(event.aggregateVersion());
+        row.setPayloadHash(event.payloadHash().toLowerCase(Locale.ROOT)); row.setPayloadJson(event.payload().toString());
+        row.setStatus("RECEIVED"); row.setReceivedAt(LocalDateTime.now(ZoneOffset.UTC));
+        return row;
+    }
+
+    private long parsePositive(String value, String message) {
+        try { long parsed = Long.parseLong(value); if (parsed > 0) return parsed; }
+        catch (RuntimeException ignored) { }
+        throw new IllegalArgumentException(message);
+    }
+
+    private long parseOperatorId(String value) {
+        try { return value == null ? 0L : Long.parseLong(value); }
+        catch (NumberFormatException ignored) { return 0L; }
+    }
+}

firstleg/src/main/resources/db/phase2-carton-label-versioning-migration.sql

@@ -15,6 +15,7 @@ DELIMITER ;
 CALL phase2_carton_label_add_column('label_version', 'INT UNSIGNED NOT NULL DEFAULT 1 COMMENT ''内部兼容批次字段，固定为1且不进入箱码'' AFTER carton_index');
 CALL phase2_carton_label_add_column('batch_status', 'VARCHAR(16) NOT NULL DEFAULT ''ACTIVE'' COMMENT ''批次状态：ACTIVE有效、VOID已作废'' AFTER label_version');
 CALL phase2_carton_label_add_column('cargo_fingerprint', 'CHAR(64) NULL COMMENT ''影响标签字段的SHA-256指纹'' AFTER batch_status');
+CALL phase2_carton_label_add_column('sku_code', 'VARCHAR(128) NULL COMMENT ''箱唛绑定的SKU快照；二维码内容不变'' AFTER cargo_name');
 CALL phase2_carton_label_add_column('voided_at', 'DATETIME(3) NULL COMMENT ''批次作废时间'' AFTER cargo_fingerprint');
 DROP PROCEDURE phase2_carton_label_add_column;
 

firstleg/src/main/resources/db/phase2-inbound-carton-label.sql

@@ -10,6 +10,7 @@ CREATE TABLE IF NOT EXISTS fl_inbound_carton_label (
   inbound_detail_id BIGINT UNSIGNED NOT NULL COMMENT '订单货物明细ID，不建立跨库外键',
   cargo_item_no INT UNSIGNED NOT NULL COMMENT '订单货物明细序号快照',
   cargo_name VARCHAR(255) NULL COMMENT '货物名称快照',
+  sku_code VARCHAR(128) NULL COMMENT '箱唛绑定的SKU快照；二维码内容不变',
   detail_package_count INT UNSIGNED NOT NULL COMMENT '该订单货物明细箱数快照',
   inbound_code VARCHAR(40) NOT NULL COMMENT '入仓码快照',
   box_code VARCHAR(80) NOT NULL COMMENT '固定二维码内容：入仓码#总箱数-箱下标',

firstleg/src/main/resources/db/phase2-inbound-schema.sql

@@ -42,6 +42,7 @@ CREATE TABLE IF NOT EXISTS fl_inbound_order (
   destination_name VARCHAR(128) NULL COMMENT '目的仓名称快照',
   hold_flag TINYINT(1) NOT NULL DEFAULT 0 COMMENT '当前是否扣货',
   current_hold_reason VARCHAR(500) NULL COMMENT '当前扣货理由快照',
+  last_overseas_hold_version BIGINT UNSIGNED NULL COMMENT '海外暂扣事件最新聚合版本，用于阻止乱序覆盖',
   total_package_count INT UNSIGNED NULL COMMENT '确认后的总箱数',
   actual_gross_weight_kg DECIMAL(18,3) NULL COMMENT '已确认称重图片含托盘毛重汇总kg',
   chargeable_weight_kg DECIMAL(18,3) NULL COMMENT '当前费用快照的计费重量kg',
@@ -196,6 +197,7 @@ CREATE TABLE IF NOT EXISTS fl_inbound_carton_label (
   inbound_detail_id BIGINT UNSIGNED NOT NULL COMMENT '订单货物明细ID，不建立跨库外键',
   cargo_item_no INT UNSIGNED NOT NULL COMMENT '订单货物明细序号快照',
   cargo_name VARCHAR(255) NULL COMMENT '货物名称快照',
+  sku_code VARCHAR(128) NULL COMMENT '箱唛绑定的SKU快照；二维码内容不变',
   detail_package_count INT UNSIGNED NOT NULL COMMENT '该订单货物明细箱数快照',
   inbound_code VARCHAR(40) NOT NULL COMMENT '入仓码快照',
   box_code VARCHAR(80) NOT NULL COMMENT '固定二维码内容：入仓码#总箱数-箱下标',

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

@@ -104,8 +104,8 @@ CREATE TABLE IF NOT EXISTS fl_container_event_inbox (
   event_id VARCHAR(64) NOT NULL COMMENT '跨区事件全局唯一ID',
   event_type VARCHAR(64) NOT NULL COMMENT '事件类型',
   event_version INT UNSIGNED NOT NULL COMMENT '事件契约版本',
-  aggregate_id VARCHAR(64) NOT NULL COMMENT '货柜聚合ID',
+  aggregate_id VARCHAR(64) NOT NULL COMMENT '跨区业务聚合ID',
-  aggregate_version BIGINT UNSIGNED NOT NULL COMMENT '货柜聚合版本',
+  aggregate_version BIGINT UNSIGNED NOT NULL COMMENT '跨区业务聚合版本',
   payload_hash VARCHAR(80) NOT NULL COMMENT '规范化负载SHA-256摘要',
   payload_json JSON NOT NULL COMMENT '原始事件负载',
   status VARCHAR(16) NOT NULL COMMENT 'RECEIVED或PROCESSED',
@@ -113,7 +113,7 @@ CREATE TABLE IF NOT EXISTS fl_container_event_inbox (
   processed_at DATETIME(3) NULL COMMENT '处理完成时间（UTC）',
   PRIMARY KEY (event_id),
   KEY idx_container_event_aggregate (aggregate_id, aggregate_version)
-) ENGINE=InnoDB COMMENT='海外货柜事件消费Inbox';
+) ENGINE=InnoDB COMMENT='海外到国内业务事件消费Inbox';
 
 DROP PROCEDURE IF EXISTS phase3_container_real_unit_columns;
 DELIMITER $$
@@ -673,6 +673,66 @@ CREATE TABLE IF NOT EXISTS fl_loading_pick_history (
   CONSTRAINT fk_loading_pick_history_item FOREIGN KEY (pick_item_id) REFERENCES fl_loading_pick_item (id)
 ) ENGINE=InnoDB COMMENT='PDA拣货幂等和操作审计历史';
 
+CREATE TABLE IF NOT EXISTS fl_loading_work_pallet (
+  id BIGINT UNSIGNED NOT NULL COMMENT '一件代发现场作业托盘ID',
+  pick_task_id BIGINT UNSIGNED NOT NULL COMMENT 'PDA装柜拣货任务ID',
+  loading_plan_id BIGINT UNSIGNED NOT NULL COMMENT '装柜计划ID快照',
+  warehouse_id BIGINT UNSIGNED NOT NULL COMMENT '作业仓库ID',
+  warehouse_pallet_id BIGINT UNSIGNED NULL COMMENT '仓库实物托盘ID；未绑定仓库资源时为空',
+  pallet_code VARCHAR(64) NOT NULL COMMENT '现场托盘号',
+  open_operation_id VARCHAR(128) NOT NULL COMMENT '开托幂等操作号',
+  seal_operation_id VARCHAR(128) NULL COMMENT '封托幂等操作号',
+  pallet_status VARCHAR(16) NOT NULL DEFAULT 'OPEN' COMMENT '托盘状态：OPEN打托中、SEALED已封托、CANCELLED已取消',
+  created_by BIGINT UNSIGNED NOT NULL COMMENT '创建操作人ID',
+  created_by_name VARCHAR(64) NULL COMMENT '创建操作人名称快照',
+  sealed_by BIGINT UNSIGNED NULL COMMENT '封托操作人ID',
+  sealed_by_name VARCHAR(64) NULL COMMENT '封托操作人名称快照',
+  sealed_at DATETIME(3) NULL COMMENT '封托时间',
+  version INT UNSIGNED NOT NULL DEFAULT 0 COMMENT '乐观锁版本号',
+  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '创建时间',
+  updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT '更新时间',
+  PRIMARY KEY (id),
+  UNIQUE KEY uk_loading_work_pallet_code (pick_task_id, pallet_code),
+  UNIQUE KEY uk_loading_work_pallet_open_operation (open_operation_id),
+  UNIQUE KEY uk_loading_work_pallet_seal_operation (seal_operation_id),
+  KEY idx_loading_work_pallet_plan (loading_plan_id, pallet_status, id),
+  CONSTRAINT fk_loading_work_pallet_task FOREIGN KEY (pick_task_id) REFERENCES fl_loading_pick_task (id),
+  CONSTRAINT fk_loading_work_pallet_plan FOREIGN KEY (loading_plan_id) REFERENCES fl_loading_plan (id),
+  CONSTRAINT chk_loading_work_pallet_status CHECK (pallet_status IN ('OPEN','SEALED','CANCELLED'))
+) ENGINE=InnoDB COMMENT='一件代发PDA现场实际托盘；允许同托盘承载多个客户订单';
+
+CREATE TABLE IF NOT EXISTS fl_loading_work_pallet_carton (
+  id BIGINT UNSIGNED NOT NULL COMMENT '一件代发现场托盘箱唛绑定ID',
+  pick_task_id BIGINT UNSIGNED NOT NULL COMMENT 'PDA装柜拣货任务ID',
+  work_pallet_id BIGINT UNSIGNED NOT NULL COMMENT '现场作业托盘ID',
+  loading_plan_item_id BIGINT UNSIGNED NOT NULL COMMENT '装柜计划货物明细ID',
+  pick_item_id BIGINT UNSIGNED NOT NULL COMMENT 'PDA拣货明细ID',
+  tenant_id BIGINT UNSIGNED NOT NULL COMMENT '箱唛所属客户ID',
+  inbound_id BIGINT UNSIGNED NOT NULL COMMENT '来源入仓单ID',
+  inbound_detail_id BIGINT UNSIGNED NOT NULL COMMENT '来源入仓货物明细ID',
+  carton_label_id BIGINT UNSIGNED NOT NULL COMMENT '稳定箱唛记录ID',
+  box_code VARCHAR(80) NOT NULL COMMENT '稳定箱唛箱码快照',
+  sku_code VARCHAR(128) NOT NULL COMMENT 'SKU编码快照',
+  units_per_carton INT UNSIGNED NULL COMMENT '每箱产品数量快照',
+  bound_by BIGINT UNSIGNED NOT NULL COMMENT '最后绑定操作人ID',
+  bound_by_name VARCHAR(64) NULL COMMENT '最后绑定操作人名称快照',
+  operation_id VARCHAR(128) NOT NULL COMMENT '最近一次绑定或移托幂等操作号',
+  version INT UNSIGNED NOT NULL DEFAULT 0 COMMENT '乐观锁版本号',
+  created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '首次上托时间',
+  updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3) COMMENT '最后移托时间',
+  PRIMARY KEY (id),
+  UNIQUE KEY uk_loading_work_carton_task_label (pick_task_id, carton_label_id),
+  UNIQUE KEY uk_loading_work_carton_operation (operation_id),
+  KEY idx_loading_work_carton_pallet (work_pallet_id, sku_code, id),
+  KEY idx_loading_work_carton_plan_item (loading_plan_item_id, id),
+  CONSTRAINT fk_loading_work_carton_task FOREIGN KEY (pick_task_id) REFERENCES fl_loading_pick_task (id),
+  CONSTRAINT fk_loading_work_carton_pallet FOREIGN KEY (work_pallet_id) REFERENCES fl_loading_work_pallet (id),
+  CONSTRAINT fk_loading_work_carton_plan_item FOREIGN KEY (loading_plan_item_id) REFERENCES fl_loading_plan_item (id),
+  CONSTRAINT fk_loading_work_carton_pick_item FOREIGN KEY (pick_item_id) REFERENCES fl_loading_pick_item (id),
+  CONSTRAINT fk_loading_work_carton_label FOREIGN KEY (carton_label_id) REFERENCES fl_inbound_carton_label (id),
+  CONSTRAINT chk_loading_work_carton_units CHECK (units_per_carton IS NULL OR units_per_carton > 0)
+) ENGINE=InnoDB COMMENT='一件代发PDA逐箱上托事实；客户订单不合并但实际托盘可混托';
+
 DROP PROCEDURE IF EXISTS repair_phase3_loading_pick_task_foreign_keys;
 DELIMITER $$
 CREATE PROCEDURE repair_phase3_loading_pick_task_foreign_keys()

firstleg/src/main/resources/openapi/phase3-pda-convergence-v1.yaml

@@ -170,11 +170,104 @@ paths:
                 expectedVersion: {type: integer, minimum: 0}
                 reason: {type: string, minLength: 1, maxLength: 500}
       responses: {'200': {description: 作废后柜级证据列表}}
+  /api/platform/v1/first-leg/pda-loading/tasks/{taskId}/pallets:
+    get:
+      summary: 查询一件代发现场实际托盘、SKU汇总和逐箱明细
+      parameters:
+        - {$ref: '#/components/parameters/TaskId'}
+        - {name: warehouseId, in: query, required: true, schema: {type: integer, format: int64, minimum: 1}}
+      responses:
+        '200':
+          description: 当前任务未取消的现场托盘
+          content: {application/json: {schema: {type: array, items: {$ref: '#/components/schemas/WorkPallet'}}}}
+  /api/platform/v1/first-leg/pda-loading/tasks/{taskId}/pallets/open:
+    post:
+      summary: 为已领取任务开启一个一件代发现场托盘
+      parameters: [{$ref: '#/components/parameters/TaskId'}]
+      requestBody:
+        required: true
+        content: {application/json: {schema: {$ref: '#/components/schemas/OpenPalletRequest'}}}
+      responses:
+        '200': {description: 已开启托盘或相同operationId的幂等结果}
+  /api/platform/v1/first-leg/pda-loading/tasks/{taskId}/pallets/{palletId}/cartons/scan:
+    post:
+      summary: 扫描一件代发箱唛上托；箱唛已在其他未封托托盘时按箱移托
+      description: 本操作只记录实际箱到托关系，不推进既有拣货数量、订单状态或仓库资源结算。
+      parameters: [{$ref: '#/components/parameters/TaskId'}, {$ref: '#/components/parameters/PalletId'}]
+      requestBody:
+        required: true
+        content: {application/json: {schema: {$ref: '#/components/schemas/ScanCartonRequest'}}}
+      responses:
+        '200': {description: 包含最新SKU与箱唛汇总的目标托盘}
+  /api/platform/v1/first-leg/pda-loading/tasks/{taskId}/pallets/{palletId}/seal:
+    post:
+      summary: 封托并校验现场上托箱数未超过既有PDA已提交拣货箱数
+      parameters: [{$ref: '#/components/parameters/TaskId'}, {$ref: '#/components/parameters/PalletId'}]
+      requestBody:
+        required: true
+        content: {application/json: {schema: {$ref: '#/components/schemas/SealPalletRequest'}}}
+      responses:
+        '200': {description: 已封托托盘或A0409数量/版本冲突}
 components:
   parameters:
     TaskId: {name: taskId, in: path, required: true, schema: {type: integer, format: int64, minimum: 1}}
     ItemId: {name: itemId, in: path, required: true, schema: {type: integer, format: int64, minimum: 1}}
+    PalletId: {name: palletId, in: path, required: true, schema: {type: integer, format: int64, minimum: 1}}
   schemas:
+    OpenPalletRequest:
+      type: object
+      required: [warehouseId, palletCode, operationId]
+      properties:
+        warehouseId: {type: integer, format: int64, minimum: 1}
+        warehousePalletId: {type: integer, format: int64, minimum: 1, nullable: true}
+        palletCode: {type: string, maxLength: 64}
+        operationId: {type: string, maxLength: 128}
+    ScanCartonRequest:
+      type: object
+      required: [warehouseId, boxCode, operationId]
+      properties:
+        warehouseId: {type: integer, format: int64, minimum: 1}
+        boxCode: {type: string, maxLength: 80}
+        operationId: {type: string, maxLength: 128}
+    SealPalletRequest:
+      type: object
+      required: [warehouseId, expectedVersion, operationId]
+      properties:
+        warehouseId: {type: integer, format: int64, minimum: 1}
+        expectedVersion: {type: integer, minimum: 0}
+        operationId: {type: string, maxLength: 128}
+    WorkPallet:
+      type: object
+      required: [id, palletCode, status, version, cartonCount, skuCount, customerCount, skus, cartons]
+      properties:
+        id: {type: integer, format: int64}
+        palletCode: {type: string}
+        warehousePalletId: {type: integer, format: int64, nullable: true}
+        status: {type: string, enum: [OPEN, SEALED]}
+        version: {type: integer, minimum: 0}
+        cartonCount: {type: integer, minimum: 0}
+        skuCount: {type: integer, minimum: 0}
+        customerCount: {type: integer, minimum: 0}
+        skus: {type: array, items: {$ref: '#/components/schemas/WorkPalletSku'}}
+        cartons: {type: array, items: {$ref: '#/components/schemas/WorkPalletCarton'}}
+    WorkPalletSku:
+      type: object
+      required: [skuCode, cartonCount, productQuantity]
+      properties:
+        skuCode: {type: string}
+        cartonCount: {type: integer, minimum: 1}
+        productQuantity: {type: integer, format: int64, minimum: 0}
+    WorkPalletCarton:
+      type: object
+      required: [id, boxCode, skuCode, tenantId, inboundId, inboundDetailId]
+      properties:
+        id: {type: integer, format: int64}
+        boxCode: {type: string}
+        skuCode: {type: string}
+        tenantId: {type: integer, format: int64}
+        inboundId: {type: integer, format: int64}
+        inboundDetailId: {type: integer, format: int64}
+        unitsPerCarton: {type: integer, minimum: 1, nullable: true}
     Task:
       type: object
       required: [id, loadingPlanId, containerBookingId, inboundId, inboundVersion, loadingVersion, cabinetNo, sourceType, recordStatus, taskStatus, workflowStatus, version, items]

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

@@ -24,6 +24,13 @@ class PlatformLoadingPdaControllerContractTest {
         authority("review", "platform:firstleg:pda:review", AuthenticatedUser.class, long.class, ReviewRequest.class);
         authority("complete", "platform:firstleg:pda:work", AuthenticatedUser.class, long.class, CompleteLoadingRequest.class);
         authority("operations", "platform:firstleg:pda:view", AuthenticatedUser.class, long.class);
+        authority("pallets", "platform:firstleg:pda:view", AuthenticatedUser.class, long.class, long.class);
+        authority("openPallet", "platform:firstleg:pda:work", AuthenticatedUser.class, long.class,
+            com.baiyue.firstleg.dto.LoadingPalletDtos.OpenRequest.class);
+        authority("scanCarton", "platform:firstleg:pda:work", AuthenticatedUser.class, long.class, long.class,
+            com.baiyue.firstleg.dto.LoadingPalletDtos.ScanRequest.class);
+        authority("sealPallet", "platform:firstleg:pda:work", AuthenticatedUser.class, long.class, long.class,
+            com.baiyue.firstleg.dto.LoadingPalletDtos.SealRequest.class);
     }
 
     private void authority(String name, String expected, Class<?>... parameterTypes) throws Exception {

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

@@ -290,6 +290,30 @@ class LoadingCompletedOutboxServiceTest {
         assertThat(event.payload().at("/orders/0/palletCount").asInt()).isEqualTo(2);
     }
 
+    @Test void publishesExactPdaCartonToPalletBindingsWithoutSequentialRedistribution() throws Exception {
+        Row first = row(11, 100, 101); first.setFulfillmentType("ONE_CLICK_DROPSHIP");
+        first.setPackageCount(2); first.setProductQuantity(20); first.setSkuCode("SKU-A");
+        Row second = row(11, 100, 102); second.setFulfillmentType("ONE_CLICK_DROPSHIP");
+        second.setPackageCount(2); second.setProductQuantity(10); second.setSkuCode("SKU-B");
+        when(snapshots.rows(90L)).thenReturn(List.of(first, second));
+        when(snapshots.workPalletCount(90L)).thenReturn(2);
+        when(snapshots.actualPalletRows(90L)).thenReturn(List.of(
+            actualPallet(11,100,"PLT-01",101,"SKU-A","BOX-A2"),
+            actualPallet(11,100,"PLT-01",102,"SKU-B","BOX-B1"),
+            actualPallet(11,100,"PLT-02",101,"SKU-A","BOX-A1"),
+            actualPallet(11,100,"PLT-02",102,"SKU-B","BOX-B2")));
+
+        service.publish(90L);
+
+        ArgumentCaptor<InboundOutboxEntity> captor = ArgumentCaptor.forClass(InboundOutboxEntity.class);
+        verify(outbox).insert(captor.capture());
+        EventEnvelope event = mapper.readValue(captor.getValue().getPayloadJson(), EventEnvelope.class);
+        assertThat(event.payload().at("/orders/0/pallets/0/skuPackages/0/cartonMarks/0").asText())
+            .isEqualTo("BOX-A2");
+        assertThat(event.payload().at("/orders/0/pallets/1/skuPackages/0/cartonMarks/0").asText())
+            .isEqualTo("BOX-A1");
+    }
+
     @Test
     void pricingBusinessTypeCannotTurnAStandardOrderIntoDropship() throws Exception {
         Row value = row(11, 100, 101);
@@ -347,6 +371,13 @@ class LoadingCompletedOutboxServiceTest {
         row.setPackageCount(packages); row.setProductQuantity(quantity); row.setBoxCode(boxCode); return row;
     }
 
+    private PalletRow actualPallet(long account,long inbound,String palletNo,long detail,
+                                   String sku,String boxCode) {
+        PalletRow row = pallet(account,inbound,0,palletNo,1,detail,sku,1,1,boxCode);
+        row.setActualBinding(true);
+        return row;
+    }
+
     private LabelRow label(long detailId, String boxCode) {
         LabelRow row = new LabelRow(); row.setInboundDetailId(detailId); row.setBoxCode(boxCode); return row;
     }

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

@@ -0,0 +1,86 @@
+package com.baiyue.firstleg.service;
+
+import com.baiyue.firstleg.dto.LoadingPalletDtos.ScanRequest;
+import com.baiyue.firstleg.dto.LoadingPalletDtos.SealRequest;
+import com.baiyue.firstleg.entity.LoadingWorkPalletCartonEntity;
+import com.baiyue.firstleg.entity.LoadingWorkPalletEntity;
+import com.baiyue.firstleg.mapper.LoadingWorkPalletCartonMapper;
+import com.baiyue.firstleg.mapper.LoadingWorkPalletCartonMapper.CartonCandidate;
+import com.baiyue.firstleg.mapper.LoadingWorkPalletMapper;
+import com.baiyue.firstleg.mapper.LoadingWorkPalletMapper.TaskContext;
+import jakarta.annotation.Resource;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@SpringJUnitConfig(LoadingWorkPalletService.class)
+class LoadingWorkPalletServiceTest {
+    @MockBean private LoadingWorkPalletMapper pallets;
+    @MockBean private LoadingWorkPalletCartonMapper cartons;
+    @Resource private LoadingWorkPalletService service;
+
+    @Test
+    void scansDropshipCartonOntoMixedCustomerWorkPalletWithoutChangingPickWorkflow() {
+        when(pallets.selectTaskContext(10L, 20L)).thenReturn(context());
+        LoadingWorkPalletEntity pallet = pallet(30L, "OPEN");
+        when(pallets.selectScoped(10L, 30L, 20L)).thenReturn(pallet);
+        CartonCandidate candidate = candidate();
+        when(cartons.selectCandidates(10L, 20L, "BOX-A")).thenReturn(List.of(candidate));
+        doAnswer(invocation -> {
+            LoadingWorkPalletCartonEntity value = invocation.getArgument(0);
+            value.setId(50L);
+            return 1;
+        }).when(cartons).insert(any(LoadingWorkPalletCartonEntity.class));
+        when(cartons.selectPalletCartons(30L)).thenAnswer(invocation -> List.of());
+
+        service.scan(10L, 30L, new ScanRequest(20L, "BOX-A", "SCAN-1"), 99L, "作业员");
+
+        var captor = org.mockito.ArgumentCaptor.forClass(LoadingWorkPalletCartonEntity.class);
+        verify(cartons).insert(captor.capture());
+        assertThat(captor.getValue().getTenantId()).isEqualTo(88L);
+        assertThat(captor.getValue().getLoadingPlanItemId()).isEqualTo(41L);
+        assertThat(captor.getValue().getSkuCode()).isEqualTo("SKU-A");
+    }
+
+    @Test
+    void refusesToSealUntilScannedCartonsAreReconciledByExistingPickSubmission() {
+        when(pallets.selectTaskContext(10L, 20L)).thenReturn(context());
+        when(pallets.selectScoped(10L, 30L, 20L)).thenReturn(pallet(30L, "OPEN"));
+        when(cartons.countPalletCartons(30L)).thenReturn(2);
+        when(cartons.countUnreconciled(10L)).thenReturn(1);
+
+        assertThatThrownBy(() -> service.seal(10L, 30L,
+            new SealRequest(20L, 0, "SEAL-1"), 99L, "作业员"))
+            .hasMessageContaining("原PDA拣货提交");
+    }
+
+    private static TaskContext context() {
+        return new TaskContext(10L, 11L, "LOADING", 20L, 99L, 2);
+    }
+
+    private static LoadingWorkPalletEntity pallet(long id, String status) {
+        LoadingWorkPalletEntity value = new LoadingWorkPalletEntity();
+        value.setId(id); value.setPickTaskId(10L); value.setLoadingPlanId(11L);
+        value.setWarehouseId(20L); value.setPalletCode("PLT-01");
+        value.setPalletStatus(status); value.setVersion(0);
+        return value;
+    }
+
+    private static CartonCandidate candidate() {
+        CartonCandidate value = new CartonCandidate();
+        value.setCartonLabelId(40L); value.setTenantId(88L); value.setInboundId(81L);
+        value.setInboundDetailId(82L); value.setBoxCode("BOX-A");
+        value.setLoadingPlanItemId(41L); value.setPickItemId(42L);
+        value.setSkuCode("SKU-A"); value.setUnitsPerCarton(20);
+        return value;
+    }
+}

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

@@ -0,0 +1,88 @@
+package com.baiyue.firstleg.service;
+
+import com.baiyue.common.event.EventEnvelope;
+import com.baiyue.common.event.EventPayloadCanonicalizer;
+import com.baiyue.common.event.EventPayloadHash;
+import com.baiyue.common.event.EventTypes;
+import com.baiyue.common.event.OverseasInboundOrderDetainedChangedV1;
+import com.baiyue.common.event.RegionCode;
+import com.baiyue.firstleg.entity.InboundHoldRecordEntity;
+import com.baiyue.firstleg.entity.InboundOrderEntity;
+import com.baiyue.firstleg.entity.ContainerEventInboxEntity;
+import com.baiyue.firstleg.mapper.ContainerEventInboxMapper;
+import com.baiyue.firstleg.mapper.InboundHoldRecordMapper;
+import com.baiyue.firstleg.mapper.InboundOrderMapper;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.time.Instant;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class OverseasInboundOrderDetainedConsumerTest {
+    @Mock InboundOrderMapper inboundOrders;
+    @Mock InboundHoldRecordMapper holdRecords;
+    @Mock ContainerEventInboxMapper inbox;
+    ObjectMapper objectMapper;
+    OverseasInboundOrderDetainedConsumer consumer;
+
+    @BeforeEach
+    void setUp() {
+        objectMapper = new ObjectMapper().registerModule(new JavaTimeModule());
+        consumer = new OverseasInboundOrderDetainedConsumer(inboundOrders, holdRecords, inbox, objectMapper);
+    }
+
+    @Test
+    void appliesHoldBySourceInboundIdAndWritesHistory() {
+        InboundOrderEntity inbound = inbound(null);
+        when(inboundOrders.selectActiveByIdForUpdate(1001L)).thenReturn(inbound);
+        when(inboundOrders.applyOverseasHold(88L, 1001L, true, "等待查验", 7L, 66L)).thenReturn(1);
+
+        consumer.consume(event(7, true, "等待查验"));
+
+        verify(inboundOrders).applyOverseasHold(88L, 1001L, true, "等待查验", 7L, 66L);
+        ArgumentCaptor<InboundHoldRecordEntity> history = ArgumentCaptor.forClass(InboundHoldRecordEntity.class);
+        verify(holdRecords).insert(history.capture());
+        assertThat(history.getValue().getInboundId()).isEqualTo(1001L);
+        assertThat(history.getValue().getHoldAction()).isEqualTo("HOLD");
+        verify(inbox).updateById(argThat((ContainerEventInboxEntity row) -> "PROCESSED".equals(row.getStatus())));
+    }
+
+    @Test
+    void staleReleaseCannotOverwriteNewerHoldState() {
+        when(inboundOrders.selectActiveByIdForUpdate(1001L)).thenReturn(inbound(9L));
+
+        consumer.consume(event(7, false, "解除"));
+
+        verify(inboundOrders, never()).applyOverseasHold(anyLong(), anyLong(), anyBoolean(), any(), anyLong(), anyLong());
+        verifyNoInteractions(holdRecords);
+        verify(inbox).updateById(argThat((ContainerEventInboxEntity row) -> "PROCESSED".equals(row.getStatus())));
+    }
+
+    private InboundOrderEntity inbound(Long sourceVersion) {
+        InboundOrderEntity value = new InboundOrderEntity();
+        value.setId(1001L); value.setTenantId(88L); value.setInboundCode("IN-1001");
+        value.setLastOverseasHoldVersion(sourceVersion);
+        return value;
+    }
+
+    private EventEnvelope event(long version, boolean detained, String reason) {
+        var payload = new OverseasInboundOrderDetainedChangedV1("1001", "IN-1001", "9001",
+            "LM-9001", detained, reason, "66", "海外操作员", Instant.parse("2026-08-31T06:00:00Z"));
+        var node = objectMapper.valueToTree(payload);
+        return new EventEnvelope(String.format("00000000-0000-4000-8000-%012d", version),
+            EventTypes.OVERSEAS_INBOUND_ORDER_DETAINED_CHANGED, 1, payload.changedAt(),
+            RegionCode.OVERSEAS, RegionCode.CN, "88", "INBOUND_ORDER", "1001", version, 1L,
+            "00000000-0000-4000-8000-000000000099", "hold-1001-" + version, null, node,
+            EventPayloadHash.sha256(EventPayloadCanonicalizer.canonicalize(node)));
+    }
+}

gateway-overseas/src/main/resources/application.yml

@@ -39,9 +39,9 @@ spring:
 
 baiyue:
   security:
-    issuer: ${JWT_ISSUER:https://auth.example.com}
+    issuer: ${JWT_ISSUER:auth-service}
     audience: ${JWT_AUDIENCE:lastleg-api}
-    jwk-set-uri: ${JWT_JWK_SET_URI:https://auth.example.com/.well-known/jwks.json}
+    jwk-set-uri: ${JWT_JWK_SET_URI:http://127.0.0.1:9100/api/auth/.well-known/jwks.json}
     pda-session-validation:
       auth-url: ${AUTH_SESSION_VALIDATION_URL}
       internal-service-token: ${INTERNAL_SERVICE_TOKEN}

gateway-overseas/src/test/java/com/baiyue/gateway/config/OverseasSecurityValidationDeploymentContractTest.java

@@ -9,6 +9,36 @@ import java.nio.file.Path;
 import static org.assertj.core.api.Assertions.assertThat;
 
 class OverseasSecurityValidationDeploymentContractTest {
+    @Test
+    void gatewayLocalJwtDefaultsMatchAuthAndLastleg() throws Exception {
+        String gatewayApplication = read("gateway-overseas/src/main/resources/application.yml");
+        String lastlegApplication = read("lastleg-service/src/main/resources/application.yml");
+        String localGateway = read("config/nacos/local/gateway-overseas.yml");
+        String localLastleg = read("config/nacos/local/lastleg-service.yml");
+        String localWarehouse = read("config/nacos/local/warehouse-overseas-service.yml");
+        String remoteGateway = read("config/nacos/overseas/gateway-overseas.yml");
+        String remoteLastleg = read("config/nacos/overseas/lastleg-service.yml");
+        String remoteWarehouse = read("config/nacos/overseas/warehouse-overseas-service.yml");
+
+        for (String source : new String[]{gatewayApplication, lastlegApplication, localGateway, localLastleg, localWarehouse}) {
+            assertThat(source)
+                .contains("${JWT_ISSUER:auth-service}")
+                .contains("${JWT_AUDIENCE:lastleg-api}")
+                .contains("${JWT_JWK_SET_URI:http://127.0.0.1:9100/api/auth/.well-known/jwks.json}");
+        }
+        assertThat(gatewayApplication).doesNotContain("auth.example.com");
+        assertThat(localGateway)
+            .contains("${AUTH_SESSION_VALIDATION_URL:http://127.0.0.1:9100}")
+            .contains("${LASTLEG_SECURITY_SERVICE_URL:http://127.0.0.1:9303}");
+        assertThat(localLastleg).contains("${WAREHOUSE_OVERSEAS_SERVICE_URL:http://127.0.0.1:9305}");
+        assertThat(localWarehouse).contains("${DOMESTIC_WAREHOUSE_URL:http://127.0.0.1:9205}");
+        assertThat(remoteGateway + remoteLastleg + remoteWarehouse)
+            .doesNotContain("127.0.0.1", "root", "123456");
+        assertThat(remoteGateway).contains("${LASTLEG_SECURITY_SERVICE_URL:http://lastleg-service:9303}");
+        assertThat(remoteLastleg).contains("${LASTLEG_DB_URL}", "${LASTLEG_DB_USERNAME}", "${LASTLEG_DB_PASSWORD}");
+        assertThat(remoteWarehouse).contains("${WAREHOUSE_DB_URL}", "${WAREHOUSE_DB_USERNAME}", "${WAREHOUSE_DB_PASSWORD}");
+    }
+
     @Test
     void gatewayAndEventBridgeUseLastlegSecurityEndpointsWithoutTheRetiredService() throws Exception {
         String client = read("gateway-overseas/src/main/java/com/baiyue/gateway/filter/HttpOverseasSecurityValidationClient.java");

iam/src/main/resources/db/lastleg-permissions.sql

@@ -39,6 +39,9 @@ VALUES
   (5107061,0,'PLATFORM','BUTTON',5107060,'platform:overseas-warehouse:location:create','创建海外库位',NULL,'POST',761,'ACTIVE',1,0),
   (5107062,0,'PLATFORM','BUTTON',5107060,'platform:overseas-warehouse:location:edit','编辑海外库位',NULL,'PUT',762,'ACTIVE',1,0),
   (5107063,0,'PLATFORM','BUTTON',5107060,'platform:overseas-warehouse:location:delete','删除海外库位',NULL,'DELETE',763,'ACTIVE',1,0),
+  (5107090,0,'PLATFORM','MENU',0,'platform:overseas-warehouse:outbound:list','海外出库单','/overseas-warehouse/outbounds','GET',765,'ACTIVE',1,0),
+  (5107091,0,'PLATFORM','BUTTON',5107090,'platform:overseas-warehouse:outbound:create','创建海外出库单',NULL,'POST',766,'ACTIVE',1,0),
+  (5107092,0,'PLATFORM','MENU',0,'platform:overseas-warehouse:delivery:list','海外派送单','/overseas-warehouse/delivery-orders','GET',767,'ACTIVE',1,0),
   (5107100,0,'PLATFORM','MENU',0,'platform:overseas-business:purchase:list','海外采购订单','/overseas-business/purchases','GET',800,'ACTIVE',1,0),
   (5107101,0,'PLATFORM','BUTTON',5107100,'platform:overseas-business:purchase:edit','编辑海外采购订单',NULL,'PATCH',801,'ACTIVE',1,0),
   (5107102,0,'PLATFORM','BUTTON',5107100,'platform:overseas-business:purchase:review','审核海外采购订单',NULL,'POST',802,'ACTIVE',1,0),
@@ -212,3 +215,16 @@ JOIN iam_permission permission ON permission.tenant_id=0 AND permission.app_code
 WHERE role.tenant_id=0 AND role.app_code='PLATFORM'
   AND UPPER(role.role_code) IN ('PLATFORM_ADMIN','PLATFORM_CUSTOM_ADMIN')
   AND role.status='ACTIVE' AND role.deleted=0 AND permission.status='ACTIVE' AND permission.deleted=0;
+
+-- PLATFORM_CUSTOM_ADMIN needs access to the overseas outbound and delivery lists shown in the admin navigation.
+INSERT IGNORE INTO iam_role_permission (tenant_id, role_id, permission_id, created_at)
+SELECT 0, role.id, permission.id, NOW(3)
+FROM iam_role role
+JOIN iam_permission permission ON permission.tenant_id=0 AND permission.app_code='PLATFORM'
+  AND permission.permission_code IN (
+    'platform:overseas-warehouse:outbound:list',
+    'platform:overseas-warehouse:delivery:list'
+  )
+WHERE role.tenant_id=0 AND role.app_code='PLATFORM'
+  AND UPPER(role.role_code)='PLATFORM_CUSTOM_ADMIN'
+  AND role.status='ACTIVE' AND role.deleted=0 AND permission.status='ACTIVE' AND permission.deleted=0;

iam/src/test/java/com/baiyue/iam/repository/OverseasPhase4PermissionSqlContractTest.java

@@ -41,10 +41,12 @@ class OverseasPhase4PermissionSqlContractTest {
         assertThat(sql).contains(REQUIRED.toArray(String[]::new));
         assertThat(sql).contains("'lastleg:pda:operate'");
         assertPdaPickerGrant(sql);
-        assertThat(catalog).hasSize(53).noneMatch(code -> code.endsWith(":view"));
+        assertThat(catalog).hasSize(56).noneMatch(code -> code.endsWith(":view"));
         assertThat(sql).contains("permission_code LIKE 'platform:lastleg:%'", "status='INACTIVE'", "deleted=1");
-        assertThat(sql).doesNotContain(":carton:", ":product:", ":outbound:", ":delivery:");
+        assertThat(sql).doesNotContain(":carton:", ":product:");
+        assertThat(catalog).contains("platform:overseas-warehouse:delivery:list");
         assertCustomAdminGrant(sql);
+        assertCustomAdminNavigationGrant(sql);
     }
 
     @Test
@@ -58,6 +60,7 @@ class OverseasPhase4PermissionSqlContractTest {
         assertThat(sql).contains("baiyue_iam.iam_permission", "baiyue_iam.iam_role_permission", "'lastleg:pda:operate'");
         assertPdaPickerGrant(sql);
         assertCustomAdminGrant(sql);
+        assertCustomAdminNavigationGrant(sql);
     }
 
     @Test
@@ -138,6 +141,17 @@ class OverseasPhase4PermissionSqlContractTest {
         assertThat(sql.substring(grantStart, grantEnd)).contains("lastleg:pda:operate");
     }
 
+    private static void assertCustomAdminNavigationGrant(String sql) {
+        int permissionIndex = sql.indexOf("'platform:overseas-warehouse:delivery:list'", sql.indexOf("PLATFORM_CUSTOM_ADMIN needs access"));
+        assertThat(permissionIndex).isGreaterThanOrEqualTo(0);
+        int grantStart = sql.lastIndexOf("INSERT IGNORE INTO", permissionIndex);
+        int grantEnd = sql.indexOf(';', permissionIndex);
+        assertThat(sql.substring(grantStart, grantEnd)).contains(
+            "UPPER(role.role_code)='PLATFORM_CUSTOM_ADMIN'",
+            "platform:overseas-warehouse:outbound:list",
+            "platform:overseas-warehouse:delivery:list");
+    }
+
     private static String matrixBlock(String sql) {
         int start = sql.indexOf("INSERT INTO tmp_phase4_warehouse_role_permission");
         int end = sql.indexOf("DELETE grant_row FROM", start);

lastleg-service/AGENTS.md

@@ -28,14 +28,19 @@
 | PDA 入仓、实收、上架与完成 | `inboundplan/pda/controller/ReceivingContainerController.java`、`inboundplan/pda/service/ReceivingContainerService.java`、内部编排 `InboundPdaWorkflowService.java`；公网入口固定为 `/api/pda/v1/last-leg/receiving-containers/**`，`/warehouse-profile` 只按 Token 绑定仓解析共享仓库中文名称与编码，旧 planNo/allocationId Controller 已移除 |
 | PDA 卸柜照片上传、归属校验与预览 | `ReceivingContainerController.java` 的 `/current/unload-photos/files`、`/current/unload-photos/files/{fileId}/download`，网关 `inboundplan/pda/gateway/UnloadPhotoFileGateway.java`、`HttpUnloadPhotoFileGateway.java`；File 类型固定 `OVERSEAS_UNLOAD_PHOTO`，下载只允许当前会话已签收的 fileId 并返回 `no-store` |
 | 卸柜照片与海外卸柜完成 Outbox | `ReceivingContainerController.java`、`ReceivingContainerService.java`、`inboundplan/pda/service/InboundUnloadCompletedOutboxService.java`、`entity/LastlegEventOutbox.java`、`mapper/LastlegEventOutboxMapper.java`；多计划同柜只能在全柜完成后调用 `publishContainerCompleted`，按来源柜预订 ID 幂等发布一次，完成时刻与拍照时刻分离；事件模型见 `../common-event-contract/AGENTS.md` |
+| 尾程暂扣状态回传 | `service/InboundOrderDetainedOutboxService.java`；暂扣与解除暂扣在订单更新事务内按 `sourceInboundId` 写入海外到国内 Outbox，国内按来源入仓单绑定更新 |
 | 入仓后 SKU 库存余额、库位和流水 | `inventory/`；平台只读查询与非出库库存命令分别从 `inventory/query/controller/InventoryQueryController.java`、`inventory/command/controller/InventoryCommandController.java` 进入 |
 | 海外PDA盘点、同仓整托移库、托盘组拆换绑与换标现场作业 | `pda/stocktake/`、`pda/move/`、`palletops/`、`relabel/pda/`；版本化契约 `src/main/resources/openapi/overseas-pda-operations-v1.yaml`；全部范围取自PDA Token，不含出库和派送 |
+| PDA 仓内通用扫码与操作历史 | `pda/warehouse/controller/PdaWarehouseController.java`、`pda/warehouse/service/PdaWarehouseService.java`；解析库存、库位和托盘码并查询操作历史，固定要求 `lastleg:pda:operate` 与 `ROLE_WAREHOUSE_PICKER`，仓库范围只能取自 PDA Token |
 | 船节点接收与海外 PDA 可收货门禁 | `shipping/service/ContainerShippingNodeConsumer.java`、`shipping/entity/ContainerShippingGate.java`、`shipping/mapper/ContainerShippingGateMapper.java`；只单调接受实际标准节点，`PICKUP_READY` 及以后才允许对应柜进入 PDA 收货候选 |
 | 平台排车列表/详情与智能预排 | `dispatch/controller/DispatchQueryController.java`、`SmartDispatchController.java`、`dispatch/mapper/DispatchCandidateMapper.java`、`dispatch/service/DispatchService.java`；草稿柜 `entity/DispatchDraftContainer.java`、`mapper/DispatchDraftContainerMapper.java`，托盘锁 `DispatchPalletLock.java`；入口 `/api/platform/v1/last-leg/dispatches`，范围开关与禁用写操作见“四期开发范围路由” |
+| 排车编辑、PDA 出库、派送与交接 | `dispatch/controller/DispatchController.java`、`dispatch/pda/controller/DispatchPdaController.java`、`delivery/controller/DeliveryTransferController.java`、`MerchantDeliveryController.java`、`OutboundPdaController.java` |
 | 仓储资源调用 | `inboundplan/pda/gateway/WarehouseResourceGateway.java`、`HttpWarehouseResourceGateway.java` |
 | 仓储转运、历史订单/入仓绑定、可选换标联动 | `transfer/controller/WarehouseTransferController.java`、`transfer/service/WarehouseTransferService.java` |
-| 一件代发接收、SKU/箱唛库存 | `dropship/service/DropshipOrderService.java`、`dropship/entity/`、`dropship/mapper/` |
+| 一件代发接收、SKU/箱唛库存 | 内部接收入口 `dropship/controller/DropshipOrderController.java` 的 `/internal/v1/lastleg/dropship/receive`，必须经 `InternalServiceTokenGuard`；处理 `dropship/service/DropshipOrderService.java`、`dropship/entity/`、`dropship/mapper/` |
 | 货物废弃、待审锁箱、审批扣减 | `discard/controller/CargoDiscardController.java`、`discard/service/CargoDiscardService.java` |
+| 客户拜访、派送状态与签收附件 | `customervisit/controller/CustomerVisitController.java`、`customervisit/service/CustomerVisitService.java`；平台维护拜访、附件上传、派送完成/状态 |
+| 异常订单与派送退回入仓 | `exceptionorder/controller/ExceptionOrderController.java`、`exceptionorder/service/ExceptionOrderService.java`；异常订单建档、关联解析、派送退回候选与标记 |
 | 海外采购、客户下单、采购审核、客户/采购仓候选与操作流水 | `procurement/controller/`、`procurement/service/OverseasProcurementService.java`；OpenAPI `src/main/resources/openapi/overseas-business-v1.yaml` |
 | 美国/本土卡车订单 | `trucking/controller/PlatformUsTruckOrderController.java`、`MerchantUsTruckOrderController.java` 及同子域 Service/DTO |
 | 本土散板订单 | `looseboard/controller/PlatformLocalLooseboardController.java` 及同子域 Service/DTO/Entity/Mapper；OpenAPI `src/main/resources/openapi/overseas-business-v1.yaml` |
@@ -47,9 +52,8 @@
 
 ## 四期开发范围路由
 
-- 四期在本服务内只进入尾程订单、入仓计划/PDA 入仓、换标、产品与箱唛快照、库存、海外采购和本土卡车；本土散板新增实现也归本服务的独立稳定子域。
+- 尾程服务覆盖尾程订单、入仓计划/PDA 入仓、换标、产品与箱唛快照、库存、海外采购、本土卡车、本土散板、排车、出库、派送、客户拜访及异常退回等完整业务域。
-- `dispatch/`、`delivery/`、出库单、PDA 出库拣货、派送和其他库存离仓能力虽然已存在于服务代码或表结构中，但不属于当前四期开发与验收范围，不得因代码已存在而自动纳入。
+- 排车编辑/取消/出库、PDA 出库和 `delivery/` Controller 与其他尾程业务接口一同注册，不受功能开关控制。平台排车列表与详情仍由 `lastleg.dispatch-query-api.enabled=true` 独立启用；入库单智能排车候选、草稿锁定/解锁/释放和预排创建仍由 `lastleg.smart-dispatch-api.enabled=true` 独立启用。这些排车平台入口均不接收 `customerId`：排车列表跨客户分页，详情按全局排车单号定位后使用记录自身客户范围加载明细；智能排车候选未传计划 ID 时跨客户查询，传入时根据计划 ID 解析范围；托盘移入草稿时立即以操作人和随机草稿标识锁定，移除或关闭时释放，草稿锁超时失效；预排创建根据所选托盘 ID 在服务端解析并校验唯一客户范围，并将当前操作人的草稿锁原子转换为正式排车锁。
-- 历史排车编辑/取消/出库、PDA 出库和 `delivery/` Controller 默认不注册；只有后续阶段明确启用 `lastleg.future-outbound-api.enabled=true` 才可恢复。平台排车列表与详情由 `lastleg.dispatch-query-api.enabled=true` 独立启用；入库单智能排车候选、草稿锁定/解锁/释放和预排创建由 `lastleg.smart-dispatch-api.enabled=true` 独立启用。这些排车平台入口均不接收 `customerId`：排车列表跨客户分页，详情按全局排车单号定位后使用记录自身客户范围加载明细；智能排车候选未传计划 ID 时跨客户查询，传入时根据计划 ID 解析范围；托盘移入草稿时立即以操作人和随机草稿标识锁定，移除或关闭时释放，草稿锁超时失效；预排创建根据所选托盘 ID 在服务端解析并校验唯一客户范围，并将当前操作人的草稿锁原子转换为正式排车锁。预排只能创建待出库排车并锁定托盘，不得借此开放编辑、取消、depart、PDA 出库或派送。四期平台库存 Controller 不映射 allocate、unallocate、pick、ship。
 - 仓库 ID、类型、状态、地址和能力唯一权威归国内 `warehouse-service`；海外库位、实物托盘和资源锁归 `warehouse-overseas-service/` 且只引用同一国内 `warehouseId`。Lastleg PDA 通过 Warehouse Overseas 内部资源入口校验该国内共享收货仓，不得要求海外数据库重复建仓；浏览器 API 统一经 `gateway-overseas/`。
 
 ## 数据库表索引与注释约束
@@ -75,7 +79,7 @@
 - 只接受冻结契约支持的事件类型和版本；校验事件 ID、租户、区域、Payload 哈希及必要字段。
 - 同一实际集装箱 `containerNo` 生成一个共享业务尾程单号；`payload.orders` 每项按 `sourceInboundId` 独立落一条雪花 ID `ll_order`，并保存对应明细和初始状态历史。整柜操作不使用 `cabinetNo`。
 - `ONE_CLICK_DROPSHIP` 每个来源入仓单必须携带一个或多个不可变来源托盘快照；每托按 SKU 携带箱数、数量和箱唛。校验订单汇总一致、托盘号/SKU/箱唛唯一后，按托建立档案及 SKU 库存，并建立箱唛和流水。仓库实物托盘由 Warehouse API 分配，不得覆盖来源托盘快照。
-- 其他订单类型只建立入仓单维度的尾程订单与冻结明细，来源 `palletCount` 强制为 0；后续 PDA 托盘属于海外仓作业资源。
+- 其他订单类型建立入仓单维度的尾程订单与冻结明细，并保留头程推荐托数；尾程入仓计划至少按推荐托数生成计划托盘，PDA 再把箱级事实绑定到海外仓实物托盘。
 - 整个事件消费在一个事务内完成；任意订单失败时不得留下部分订单。
 - 相同事件重复投递返回既有结果，不重新生成单号或插入明细。来源入仓单唯一约束是最终防线。
 - 装柜完成事件只把尾程订单建立为 `PENDING_ASSIGNMENT`。`FIRST_LEG` 在途库存使用不可变来源入仓码作为计划生成前的 `inbound_order_no` 展示快照；平台人工转换成功后，同一事务将订单推进为 `INBOUND_PLANNED`，并把对应库存余额的该快照收口为新 `planNo`。
@@ -94,7 +98,7 @@
 - 列表、详情、导出和更新必须使用同一租户边界，不能仅在列表过滤而让详情或更新越权。
 - 目的仓变更必须写状态/操作历史或审计证据，并使用版本控制防止并发覆盖。
 - 货物废弃只使用可核对 SKU 和箱唛的一件代发库存。创建申请只能将箱从 `AVAILABLE` 锁定为 `DISCARD_PENDING`，不得扣减 SKU 箱数；实际扣库存节点固定为具备 `lastleg:cargo-discard:approve` 权限的仓库/PDA 审核人确认废弃时，并且必须在审核事务内调用专用 discard adjustment。该 adjustment 必须将箱改为 `DISCARDED`、写逐箱业务流水及唯一幂等键，并校验 `扣减前箱数 - 废弃箱数 = 扣减后箱数` 且逐箱数等于申请总箱数；任一环节失败须整体回滚。拒绝申请只释放锁箱，不得扣库存。
-- 海外采购客户下单固定进入 `PENDING_REVIEW`；四期采购只维护采购订单、审核、入库数量、候选快照和操作流水，不提供采购出库端点、出库记录或出库数量。采购单据不得写入或冒充 `available_packages`；只有海外仓 PDA 完成实收后，`InboundStockReceiptService` 才能以 `PDA_STOCK_IN:{taskId}:{allocationId}` 幂等键调用库存 `stockIn` 转入可用库存。禁止通过通用平台接口绕过 PDA 入可用库存。
+- 海外采购客户下单固定进入 `PENDING_REVIEW`；采购编辑可维护入库数量和采购出库明细，出库量为明细数量汇总，审核通过且有入库量后按 `PENDING_OUTBOUND`、`PARTIALLY_OUTBOUND`、`OUTBOUNDED` 派生展示状态。采购出库只记录采购单据流转，不得写入或冒充 `available_packages`；只有海外仓 PDA 完成实收后，`InboundStockReceiptService` 才能以 `PDA_STOCK_IN:{taskId}:{allocationId}` 幂等键调用库存 `stockIn` 转入可用库存。禁止通过通用平台接口绕过 PDA 入可用库存。
 - 派车状态只允许 PDA 拣货、完成和出库动作推进，普通派车编辑接口不得修改状态。PDA 写操作要求 `lastleg:pda:operate`；后台库存表单操作要求 `lastleg:inventory:manage`，盘点调整另要求 `lastleg:inventory:adjust`，转仓库存操作要求 `lastleg:warehouse-transfer:manage`。
 - `ll_order.current_status` 只保存尾程主流程状态；换标、转仓、出库和派送等子单精确状态保存到各自单据并汇总到 `sub_order_status`，不得再用子单状态覆盖主流程状态。PDA 入仓及库存落账完成后，主流程状态固定推进为 `INBOUND_COMPLETED`。
 

lastleg-service/src/main/java/com/baiyue/lastleg/config/LastlegRestClientProperties.java

@@ -10,6 +10,7 @@ import java.time.Duration;
 public class LastlegRestClientProperties {
     private ClientTimeouts unloadPhotoFile = new ClientTimeouts(Duration.ofSeconds(3), Duration.ofSeconds(30));
     private ClientTimeouts relabelPhotoFile = new ClientTimeouts(Duration.ofSeconds(3), Duration.ofSeconds(30));
+    private ClientTimeouts customerVisitFile = new ClientTimeouts(Duration.ofSeconds(3), Duration.ofSeconds(30));
     private ClientTimeouts warehouseResource = new ClientTimeouts(Duration.ofSeconds(3), Duration.ofSeconds(5));
     private ClientTimeouts palletPhysical = new ClientTimeouts(Duration.ofSeconds(3), Duration.ofSeconds(5));
 
@@ -17,6 +18,8 @@ public class LastlegRestClientProperties {
     public void setUnloadPhotoFile(ClientTimeouts value) { unloadPhotoFile = required(value, "unload-photo-file"); }
     public ClientTimeouts getRelabelPhotoFile() { return relabelPhotoFile; }
     public void setRelabelPhotoFile(ClientTimeouts value) { relabelPhotoFile = required(value, "relabel-photo-file"); }
+    public ClientTimeouts getCustomerVisitFile() { return customerVisitFile; }
+    public void setCustomerVisitFile(ClientTimeouts value) { customerVisitFile = required(value, "customer-visit-file"); }
     public ClientTimeouts getWarehouseResource() { return warehouseResource; }
     public void setWarehouseResource(ClientTimeouts value) { warehouseResource = required(value, "warehouse-resource"); }
     public ClientTimeouts getPalletPhysical() { return palletPhysical; }
@@ -51,4 +54,3 @@ public class LastlegRestClientProperties {
         }
     }
 }
-

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

@@ -9,6 +9,7 @@ import com.baiyue.lastleg.dto.LastlegOrderRequests;
 import com.baiyue.lastleg.dto.LastlegOrderSummary;
 import com.baiyue.lastleg.dto.ContainerPlanProgressDetail;
 import com.baiyue.lastleg.dto.ContainerPlanProgressSummary;
+import com.baiyue.lastleg.entity.LastlegOrderFee;
 import com.baiyue.lastleg.security.InternalServiceTokenGuard;
 import com.baiyue.lastleg.security.OverseasPermissions;
 import com.baiyue.lastleg.service.LastlegOrderService;
@@ -107,6 +108,54 @@ public class LastlegOrderController {
         return ApiResponse.success(orderService.detail(platformScope(user, customerId), id));
     }
 
+    @PostMapping("/api/platform/v1/last-leg/orders/{id}/fees")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.LAST_MILE_ORDER_EDIT + "')")
+    @Operation(summary = "Add a fee to one tail-leg order", description = "Required authority: " + OverseasPermissions.LAST_MILE_ORDER_EDIT)
+    public ApiResponse<LastlegOrderFee> createFee(
+        @AuthenticationPrincipal AuthenticatedUser user,
+        @RequestParam(required = false) String customerId,
+        @PathVariable long id,
+        @Valid @RequestBody LastlegOrderRequests.CreateFee request) {
+        return ApiResponse.success(orderService.createFee(platformScope(user, customerId), id, request, operatorName(user)));
+    }
+
+    @PutMapping("/api/platform/v1/last-leg/orders/{id}/detained")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.LAST_MILE_ORDER_EDIT + "')")
+    @Operation(summary = "Set tail-leg order hold status", description = "Required authority: " + OverseasPermissions.LAST_MILE_ORDER_EDIT)
+    public ApiResponse<Void> setDetained(
+        @AuthenticationPrincipal AuthenticatedUser user,
+        @RequestParam(required = false) String customerId,
+        @PathVariable long id,
+        @Valid @RequestBody LastlegOrderRequests.SetDetained request) {
+        orderService.setDetained(platformScope(user, customerId), id, request,
+            String.valueOf(user.userId()), operatorName(user));
+        return ApiResponse.success(null);
+    }
+
+    @PutMapping("/api/platform/v1/last-leg/orders/{id}/pallet-merge-required")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.LAST_MILE_ORDER_EDIT + "')")
+    @Operation(summary = "Set the PDA pallet-merge reminder for one tail-leg order",
+        description = "Required authority: " + OverseasPermissions.LAST_MILE_ORDER_EDIT)
+    public ApiResponse<Void> setPalletMergeRequired(
+        @AuthenticationPrincipal AuthenticatedUser user,
+        @RequestParam(required = false) String customerId,
+        @PathVariable long id,
+        @Valid @RequestBody LastlegOrderRequests.SetPalletMergeRequired request) {
+        orderService.setPalletMergeRequired(platformScope(user, customerId), id, request, operatorName(user));
+        return ApiResponse.success(null);
+    }
+
+    @PutMapping("/api/platform/v1/last-leg/orders/pallet-merge-required/batch")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.LAST_MILE_ORDER_EDIT + "')")
+    @Operation(summary = "Mark a selected tail-leg order group for PDA pallet merge")
+    public ApiResponse<Void> setPalletMergeBatch(
+        @AuthenticationPrincipal AuthenticatedUser user,
+        @RequestParam(required = false) String customerId,
+        @Valid @RequestBody LastlegOrderRequests.SetPalletMergeBatch request) {
+        orderService.setPalletMergeBatch(platformScope(user, customerId), request, operatorName(user));
+        return ApiResponse.success(null);
+    }
+
     @GetMapping(value = "/api/platform/v1/last-leg/orders/export", produces = "text/csv")
     @PreAuthorize("hasAuthority('" + OverseasPermissions.LAST_MILE_ORDER_EXPORT + "')")
     @Operation(summary = "Export filtered tail-leg orders as UTF-8 CSV", description = "Required authority: " + OverseasPermissions.LAST_MILE_ORDER_EXPORT)
@@ -156,4 +205,8 @@ public class LastlegOrderController {
         return requestedCustomer == null || requestedCustomer.isBlank() || "0".equals(requestedCustomer)
             ? null : requestedCustomer.trim();
     }
+
+    private String operatorName(AuthenticatedUser user) {
+        return user.username() == null || user.username().isBlank() ? String.valueOf(user.userId()) : user.username();
+    }
 }

lastleg-service/src/main/java/com/baiyue/lastleg/customervisit/controller/CustomerVisitController.java

@@ -0,0 +1,92 @@
+package com.baiyue.lastleg.customervisit.controller;
+
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.common.security.AuthenticatedUser;
+import com.baiyue.lastleg.customervisit.dto.CustomerVisitRequests;
+import com.baiyue.lastleg.customervisit.dto.CustomerVisitResponses;
+import com.baiyue.lastleg.customervisit.service.CustomerVisitService;
+import jakarta.annotation.Resource;
+import jakarta.validation.Valid;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.util.StringUtils;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RequestPart;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.server.ResponseStatusException;
+
+@RestController
+@RequestMapping("/api/platform/v1/last-leg")
+public class CustomerVisitController {
+    @Resource private CustomerVisitService service;
+
+    @GetMapping("/customer-visits")
+    public ApiResponse<CustomerVisitResponses.Page> page(@AuthenticationPrincipal AuthenticatedUser user,
+                                                          @Valid CustomerVisitRequests.Query query) {
+        return ApiResponse.success(service.page(scope(user), query));
+    }
+
+    @GetMapping("/customer-visits/{visitId}")
+    public ApiResponse<CustomerVisitResponses.Detail> detail(@AuthenticationPrincipal AuthenticatedUser user,
+                                                              @RequestParam(required = false) String customerId,
+                                                              @PathVariable long visitId) {
+        return ApiResponse.success(service.detail(requiredScope(user, customerId), visitId));
+    }
+
+    @PutMapping("/customer-visits/{visitId}")
+    public ApiResponse<CustomerVisitResponses.Detail> save(@AuthenticationPrincipal AuthenticatedUser user,
+                                                            @RequestParam(required = false) String customerId,
+                                                            @PathVariable long visitId,
+                                                            @Valid @RequestBody CustomerVisitRequests.Save request) {
+        return ApiResponse.success(service.save(requiredScope(user, customerId), operator(user), visitId, request));
+    }
+
+    @PostMapping(value = "/customer-visits/{visitId}/attachments", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    public ApiResponse<CustomerVisitResponses.UploadedFile> upload(@AuthenticationPrincipal AuthenticatedUser user,
+                                                                   @RequestParam(required = false) String customerId,
+                                                                   @PathVariable long visitId,
+                                                                   @RequestPart("file") MultipartFile file) {
+        if (user.userId() == null) throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "当前用户缺少有效ID");
+        return ApiResponse.success(service.upload(requiredScope(user, customerId), user.userId(), visitId, file));
+    }
+
+    @PostMapping("/delivery-orders/{deliveryNo}/complete")
+    public ApiResponse<CustomerVisitResponses.Completed> completeDelivery(
+        @AuthenticationPrincipal AuthenticatedUser user, @RequestParam(required = false) String customerId,
+        @PathVariable String deliveryNo) {
+        return ApiResponse.success(service.completeDelivery(requiredScope(user, customerId), operator(user), deliveryNo));
+    }
+
+    @PutMapping("/delivery-orders/{deliveryNo}/status")
+    public ApiResponse<CustomerVisitResponses.Completed> updateDeliveryStatus(
+        @AuthenticationPrincipal AuthenticatedUser user, @RequestParam(required = false) String customerId,
+        @PathVariable String deliveryNo, @Valid @RequestBody CustomerVisitRequests.DeliveryStatus request) {
+        return ApiResponse.success(service.updateDeliveryStatus(
+            requiredScope(user, customerId), operator(user), deliveryNo, request));
+    }
+
+    private String scope(AuthenticatedUser user) {
+        if (user == null || user.tenantId() == null) throw new ResponseStatusException(HttpStatus.UNAUTHORIZED);
+        return "PLATFORM".equals(user.appCode()) && user.tenantId() == 0L ? null : String.valueOf(user.tenantId());
+    }
+
+    private String requiredScope(AuthenticatedUser user, String requestedCustomer) {
+        String own = scope(user);
+        if (own != null) return own;
+        if (!StringUtils.hasText(requestedCustomer)) throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "请选择客户");
+        return requestedCustomer.trim();
+    }
+
+    private String operator(AuthenticatedUser user) {
+        return user.userId() == null ? user.username() : String.valueOf(user.userId());
+    }
+
+}

lastleg-service/src/main/java/com/baiyue/lastleg/customervisit/dto/CustomerVisitRequests.java

@@ -0,0 +1,35 @@
+package com.baiyue.lastleg.customervisit.dto;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.Max;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+public final class CustomerVisitRequests {
+    private CustomerVisitRequests() { }
+
+    public record Query(@Min(1) long page, @Min(1) @Max(200) long size,
+                        String keyword, String status, String customerId,
+                        LocalDateTime completedFrom, LocalDateTime completedTo) {
+        public Query { if (page == 0) page = 1; if (size == 0) size = 20; }
+    }
+
+    public record Save(@NotNull Long selectedInboundOrderId,
+                       @NotBlank @Size(max = 32) String visitResult,
+                       @Size(max = 2000) String customerFeedback,
+                       @Size(max = 1000) String remark,
+                       @Valid @Size(max = 20) List<Attachment> attachments) { }
+
+    public record Attachment(@NotNull Long fileId,
+                             @NotBlank @Size(max = 255) String fileName,
+                             @Size(max = 128) String contentType,
+                             @NotNull @Min(0) Long sizeBytes) { }
+
+    public record DeliveryStatus(@NotBlank @Size(max = 32) String status,
+                                 @Size(max = 500) String remark) { }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/customervisit/dto/CustomerVisitResponses.java

@@ -0,0 +1,31 @@
+package com.baiyue.lastleg.customervisit.dto;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+public final class CustomerVisitResponses {
+    private CustomerVisitResponses() { }
+
+    public record Row(Long id, String customerId, String deliveryNo, String customerName,
+                      String contactName, String contactPhone, String destination,
+                      LocalDateTime deliveryCompletedAt, String status,
+                      String selectedInboundCode, String visitResult, LocalDateTime visitedAt,
+                      int visitCount, List<Attachment> attachments) { }
+
+    public record Page(List<Row> records, long current, long size, long total, long pages,
+                       long visitable, long pending, long completed) { }
+
+    public record InboundOption(Long inboundOrderId, String inboundCode, Long lastMileOrderId,
+                                String lastMileOrderNo, String destinationWarehouseCode,
+                                String destinationWarehouseName, int packageCount) { }
+
+    public record Attachment(Long fileId, String fileName, String contentType, long sizeBytes) { }
+
+    public record Detail(Row visit, List<InboundOption> inboundOrders,
+                         String customerFeedback, String remark, String visitedBy) { }
+
+    public record UploadedFile(Long fileId, String fileName, String contentType, long sizeBytes) { }
+
+    public record Completed(Long visitId, String deliveryNo, String deliveryStatus,
+                            String visitStatus, boolean replayed) { }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/customervisit/entity/CustomerVisit.java

@@ -0,0 +1,37 @@
+package com.baiyue.lastleg.customervisit.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Data
+@TableName("ll_customer_visit")
+public class CustomerVisit {
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private String customerId;
+    private Long deliveryOrderId;
+    private String deliveryNo;
+    private String customerName;
+    private String contactName;
+    private String contactPhone;
+    private String destination;
+    private LocalDateTime deliveryCompletedAt;
+    private String status;
+    private Long selectedLastMileOrderId;
+    private String selectedLastMileOrderNo;
+    private Long selectedInboundOrderId;
+    private String selectedInboundCode;
+    private String visitResult;
+    private String customerFeedback;
+    private String remark;
+    private String attachmentJson;
+    private String visitedBy;
+    private LocalDateTime visitedAt;
+    private Integer visitCount;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}

lastleg-service/src/main/java/com/baiyue/lastleg/customervisit/gateway/CustomerVisitFileGateway.java

@@ -0,0 +1,10 @@
+package com.baiyue.lastleg.customervisit.gateway;
+
+import org.springframework.web.multipart.MultipartFile;
+
+public interface CustomerVisitFileGateway {
+    UploadedFile upload(String customerId, long visitId, long operatorId, MultipartFile file);
+    void validate(String customerId, long visitId, long fileId);
+
+    record UploadedFile(long fileId, String fileName, String contentType, long sizeBytes) { }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/customervisit/gateway/HttpCustomerVisitFileGateway.java

@@ -0,0 +1,101 @@
+package com.baiyue.lastleg.customervisit.gateway;
+
+import com.baiyue.lastleg.config.LastlegRestClientFactory;
+import com.baiyue.lastleg.config.LastlegRestClientProperties;
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.Resource;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.core.io.ByteArrayResource;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.HttpStatusCode;
+import org.springframework.http.MediaType;
+import org.springframework.http.client.MultipartBodyBuilder;
+import org.springframework.stereotype.Component;
+import org.springframework.web.client.RestClient;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.io.IOException;
+
+@Component
+public class HttpCustomerVisitFileGateway implements CustomerVisitFileGateway {
+    private static final String BUSINESS_TYPE = "OVERSEAS_CUSTOMER_VISIT";
+    @Resource private RestClient.Builder restClientBuilder;
+    @Resource private LastlegRestClientFactory restClientFactory;
+    @Resource private LastlegRestClientProperties restClientProperties;
+    @Value("${baiyue.clients.file.url:http://127.0.0.1:9205}") private String baseUrl;
+    @Value("${baiyue.security.internal-service-token:}") private String internalToken;
+    private RestClient client;
+
+    @PostConstruct
+    void initializeClient() {
+        client = restClientFactory.build(restClientBuilder, baseUrl, restClientProperties.getCustomerVisitFile());
+    }
+
+    @Override
+    public UploadedFile upload(String customerId, long visitId, long operatorId, MultipartFile file) {
+        MultipartBodyBuilder body = new MultipartBodyBuilder();
+        try {
+            body.part("file", new ByteArrayResource(file.getBytes()) {
+                @Override public String getFilename() { return file.getOriginalFilename(); }
+            }).contentType(file.getContentType() == null ? MediaType.APPLICATION_OCTET_STREAM
+                : MediaType.parseMediaType(file.getContentType()));
+        } catch (IOException exception) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "无法读取回访资料", exception);
+        }
+        MetadataEnvelope response = client.post()
+            .uri("/internal/file/v1/business-files/{tenantId}/{businessType}/{businessId}",
+                tenantId(customerId), BUSINESS_TYPE, visitId)
+            .header("X-Internal-Service-Token", internalToken)
+            .header("X-Operator-Id", String.valueOf(operatorId))
+            .contentType(MediaType.MULTIPART_FORM_DATA).body(body.build()).retrieve()
+            .onStatus(HttpStatusCode::isError, (request, result) -> {
+                throw new ResponseStatusException(result.getStatusCode().is4xxClientError()
+                    ? HttpStatus.BAD_REQUEST : HttpStatus.SERVICE_UNAVAILABLE, "回访资料上传失败");
+            }).body(MetadataEnvelope.class);
+        requireSuccess(response, "回访资料上传失败");
+        Metadata data = response == null ? null : response.data();
+        if (data == null || data.fileId() == null) throw new ResponseStatusException(
+            HttpStatus.SERVICE_UNAVAILABLE, "文件服务未返回回访资料元数据");
+        return new UploadedFile(data.fileId(), data.fileName(), data.contentType(),
+            data.sizeBytes() == null ? 0L : data.sizeBytes());
+    }
+
+    @Override
+    public void validate(String customerId, long visitId, long fileId) {
+        long tenantId = tenantId(customerId);
+        MetadataEnvelope response = client.get()
+            .uri("/internal/file/v1/business-files/{tenantId}/{businessType}/{businessId}/{fileId}",
+                tenantId, BUSINESS_TYPE, visitId, fileId)
+            .header("X-Internal-Service-Token", internalToken).retrieve()
+            .onStatus(HttpStatusCode::isError, (request, result) -> {
+                throw new ResponseStatusException(result.getStatusCode().is4xxClientError()
+                    ? HttpStatus.BAD_REQUEST : HttpStatus.SERVICE_UNAVAILABLE, "回访资料不存在或归属不正确");
+            }).body(MetadataEnvelope.class);
+        requireSuccess(response, "回访资料不存在或归属不正确");
+        Metadata data = response == null ? null : response.data();
+        if (data == null || data.fileId() == null || data.fileId() != fileId
+            || data.tenantId() == null || data.tenantId() != tenantId
+            || !BUSINESS_TYPE.equals(data.businessType()) || !String.valueOf(visitId).equals(data.businessId())) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "回访资料与当前记录不匹配");
+        }
+    }
+
+    private static long tenantId(String customerId) {
+        try { return Long.parseLong(customerId); }
+        catch (NumberFormatException exception) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "客户ID格式无效", exception);
+        }
+    }
+
+    private static void requireSuccess(MetadataEnvelope response, String fallback) {
+        if (response == null) throw new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE, fallback);
+        if ("200".equals(response.code())) return;
+        throw new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,
+            response.message() == null || response.message().isBlank() ? fallback : response.message());
+    }
+
+    private record MetadataEnvelope(String code, String message, Metadata data) { }
+    private record Metadata(Long fileId, Long tenantId, String businessType, String businessId,
+                            String fileName, String contentType, Long sizeBytes) { }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/customervisit/mapper/CustomerVisitMapper.java

@@ -0,0 +1,17 @@
+package com.baiyue.lastleg.customervisit.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baiyue.lastleg.customervisit.entity.CustomerVisit;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+@Mapper
+public interface CustomerVisitMapper extends BaseMapper<CustomerVisit> {
+    @Select("SELECT * FROM ll_customer_visit WHERE customer_id=#{customerId} AND delivery_order_id=#{deliveryOrderId} LIMIT 1")
+    CustomerVisit findByDelivery(@Param("customerId") String customerId,
+                                 @Param("deliveryOrderId") Long deliveryOrderId);
+
+    @Select("SELECT * FROM ll_customer_visit WHERE customer_id=#{customerId} AND id=#{id} LIMIT 1 FOR UPDATE")
+    CustomerVisit lockById(@Param("customerId") String customerId, @Param("id") Long id);
+}

lastleg-service/src/main/java/com/baiyue/lastleg/customervisit/service/CustomerVisitService.java

@@ -0,0 +1,315 @@
+package com.baiyue.lastleg.customervisit.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.IdWorker;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baiyue.lastleg.customervisit.dto.CustomerVisitRequests;
+import com.baiyue.lastleg.customervisit.dto.CustomerVisitResponses;
+import com.baiyue.lastleg.customervisit.entity.CustomerVisit;
+import com.baiyue.lastleg.customervisit.gateway.CustomerVisitFileGateway;
+import com.baiyue.lastleg.customervisit.mapper.CustomerVisitMapper;
+import com.baiyue.lastleg.delivery.entity.DeliveryOperation;
+import com.baiyue.lastleg.delivery.entity.DeliveryOrder;
+import com.baiyue.lastleg.delivery.mapper.DeliveryOperationMapper;
+import com.baiyue.lastleg.delivery.mapper.DeliveryOrderMapper;
+import com.baiyue.lastleg.entity.LastlegInboundOrder;
+import com.baiyue.lastleg.entity.LastlegOrder;
+import com.baiyue.lastleg.entity.LastlegOrderStatusHistory;
+import com.baiyue.lastleg.mapper.LastlegInboundOrderMapper;
+import com.baiyue.lastleg.mapper.LastlegOrderMapper;
+import com.baiyue.lastleg.mapper.LastlegOrderStatusHistoryMapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.annotation.Resource;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+@Service
+public class CustomerVisitService {
+    private static final Set<String> RESULTS = Set.of("SATISFIED", "NORMAL", "FOLLOW_UP", "NO_CONTACT");
+    private static final long MAX_FILE_BYTES = 20L * 1024L * 1024L;
+    private static final Set<String> FILE_EXTENSIONS = Set.of(
+        "pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "jpg", "jpeg", "png", "webp");
+
+    @Resource private CustomerVisitMapper visits;
+    @Resource private DeliveryOrderMapper deliveryOrders;
+    @Resource private DeliveryOperationMapper deliveryOperations;
+    @Resource private LastlegOrderMapper lastMileOrders;
+    @Resource private LastlegInboundOrderMapper inboundOrders;
+    @Resource private LastlegOrderStatusHistoryMapper histories;
+    @Resource private CustomerVisitFileGateway files;
+    @Resource private ObjectMapper objectMapper;
+
+    public CustomerVisitResponses.Page page(String scopedCustomerId, CustomerVisitRequests.Query query) {
+        String customerId = customerScope(scopedCustomerId, query.customerId());
+        LambdaQueryWrapper<CustomerVisit> filter = filter(customerId, query);
+        Page<CustomerVisit> result = visits.selectPage(new Page<>(query.page(), query.size()),
+            filter.orderByDesc(CustomerVisit::getDeliveryCompletedAt).orderByDesc(CustomerVisit::getId));
+        LambdaQueryWrapper<CustomerVisit> countScope = new LambdaQueryWrapper<CustomerVisit>()
+            .eq(StringUtils.hasText(customerId), CustomerVisit::getCustomerId, customerId);
+        long visitable = visits.selectCount(countScope);
+        long pending = visits.selectCount(new LambdaQueryWrapper<CustomerVisit>()
+            .eq(StringUtils.hasText(customerId), CustomerVisit::getCustomerId, customerId)
+            .eq(CustomerVisit::getStatus, "PENDING"));
+        long completed = visits.selectCount(new LambdaQueryWrapper<CustomerVisit>()
+            .eq(StringUtils.hasText(customerId), CustomerVisit::getCustomerId, customerId)
+            .eq(CustomerVisit::getStatus, "COMPLETED"));
+        return new CustomerVisitResponses.Page(result.getRecords().stream().map(this::row).toList(),
+            result.getCurrent(), result.getSize(), result.getTotal(), result.getPages(), visitable, pending, completed);
+    }
+
+    public CustomerVisitResponses.Detail detail(String customerId, long visitId) {
+        CustomerVisit visit = required(customerId, visitId);
+        return detail(visit);
+    }
+
+    @Transactional
+    public CustomerVisitResponses.Completed completeDelivery(String customerId, String operatorId, String deliveryNo) {
+        DeliveryOrder delivery = deliveryOrders.findByNo(customerId, deliveryNo);
+        if (delivery == null) throw notFound("派送单不存在");
+        if (Set.of("RETURN_PENDING", "REJECTED", "CANCELLED").contains(delivery.getStatus())) {
+            throw conflict("当前派送状态不能标记为派送完成");
+        }
+        boolean replayed = "DELIVERED".equals(delivery.getStatus());
+        LocalDateTime now = replayed && delivery.getSignedAt() != null ? delivery.getSignedAt() : LocalDateTime.now();
+        if (!replayed) {
+            delivery.setStatus("DELIVERED");
+            delivery.setSignedAt(now);
+            delivery.setUpdatedAt(now);
+            deliveryOrders.updateById(delivery);
+            for (LastlegOrder order : lastMileOrders.selectList(new LambdaQueryWrapper<LastlegOrder>()
+                .eq(LastlegOrder::getCustomerId, customerId)
+                .eq(LastlegOrder::getDeliveryOrderNo, deliveryNo))) {
+                String from = order.getCurrentStatus();
+                order.setCurrentStatus("DELIVERED");
+                order.setSubOrderStatus("DELIVERY:DELIVERED");
+                order.setUpdatedAt(now);
+                lastMileOrders.updateById(order);
+                LastlegOrderStatusHistory history = new LastlegOrderStatusHistory();
+                history.setCustomerId(customerId); history.setOrderId(order.getId()); history.setFromStatus(from);
+                history.setToStatus("DELIVERED"); history.setEventId("DELIVERY_COMPLETED:" + deliveryNo);
+                history.setRemark("派送完成"); history.setCreatedAt(now); histories.insert(history);
+            }
+            recordOperation(delivery, operatorId, "COMPLETE_DELIVERY", "派送完成并生成客户回访记录", now);
+        }
+        CustomerVisit visit = ensureVisit(delivery, now);
+        return new CustomerVisitResponses.Completed(visit.getId(), deliveryNo, delivery.getStatus(), visit.getStatus(), replayed);
+    }
+
+    @Transactional
+    public CustomerVisitResponses.Completed updateDeliveryStatus(String customerId, String operatorId,
+                                                                  String deliveryNo,
+                                                                  CustomerVisitRequests.DeliveryStatus request) {
+        String target = trim(request.status()).toUpperCase(Locale.ROOT);
+        if (!Set.of("WAIT_DELIVERY", "DELIVERING", "DELIVERED", "REJECTED", "CANCELLED").contains(target)) {
+            throw badRequest("不支持的派送状态");
+        }
+        if ("DELIVERED".equals(target)) return completeDelivery(customerId, operatorId, deliveryNo);
+        DeliveryOrder delivery = deliveryOrders.findByNo(customerId, deliveryNo);
+        if (delivery == null) throw notFound("派送单不存在");
+        if ("RETURN_PENDING".equals(delivery.getStatus())) throw conflict("退货处理中的派送单不能直接修改状态");
+        if (target.equals(delivery.getStatus())) {
+            CustomerVisit existing = visits.findByDelivery(customerId, delivery.getId());
+            return new CustomerVisitResponses.Completed(existing == null ? null : existing.getId(), deliveryNo,
+                delivery.getStatus(), existing == null ? null : existing.getStatus(), true);
+        }
+        String from = delivery.getStatus();
+        LocalDateTime now = LocalDateTime.now();
+        delivery.setStatus(target);
+        if ("DELIVERING".equals(target) && delivery.getDispatchedAt() == null) delivery.setDispatchedAt(now);
+        delivery.setUpdatedAt(now);
+        deliveryOrders.updateById(delivery);
+        String result = "派送状态由 " + from + " 修改为 " + target;
+        if (StringUtils.hasText(request.remark())) result += "，备注：" + trim(request.remark());
+        recordOperation(delivery, operatorId, "UPDATE_DELIVERY_STATUS", result, now);
+        CustomerVisit existing = visits.findByDelivery(customerId, delivery.getId());
+        return new CustomerVisitResponses.Completed(existing == null ? null : existing.getId(), deliveryNo,
+            delivery.getStatus(), existing == null ? null : existing.getStatus(), false);
+    }
+
+    @Transactional
+    public CustomerVisitResponses.Detail save(String customerId, String operatorId, long visitId,
+                                               CustomerVisitRequests.Save request) {
+        CustomerVisit visit = visits.lockById(customerId, visitId);
+        if (visit == null) throw notFound("回访记录不存在");
+        CustomerVisitResponses.InboundOption selected = inboundOptions(visit).stream()
+            .filter(option -> Objects.equals(option.inboundOrderId(), request.selectedInboundOrderId()))
+            .findFirst().orElseThrow(() -> conflict("所选入仓单不属于该派送单"));
+        String result = trim(request.visitResult()).toUpperCase(Locale.ROOT);
+        if (!RESULTS.contains(result)) throw badRequest("不支持的回访结果");
+        List<CustomerVisitResponses.Attachment> attachments = new ArrayList<>();
+        Map<Long, CustomerVisitResponses.Attachment> unique = new LinkedHashMap<>();
+        if (request.attachments() != null) {
+            for (CustomerVisitRequests.Attachment attachment : request.attachments()) {
+                files.validate(customerId, visitId, attachment.fileId());
+                unique.put(attachment.fileId(), new CustomerVisitResponses.Attachment(attachment.fileId(),
+                    trim(attachment.fileName()), trim(attachment.contentType()), attachment.sizeBytes()));
+            }
+        }
+        attachments.addAll(unique.values());
+        LocalDateTime now = LocalDateTime.now();
+        visit.setSelectedInboundOrderId(selected.inboundOrderId());
+        visit.setSelectedInboundCode(selected.inboundCode());
+        visit.setSelectedLastMileOrderId(selected.lastMileOrderId());
+        visit.setSelectedLastMileOrderNo(selected.lastMileOrderNo());
+        visit.setVisitResult(result);
+        visit.setCustomerFeedback(trim(request.customerFeedback()));
+        visit.setRemark(trim(request.remark()));
+        visit.setAttachmentJson(writeAttachments(attachments));
+        visit.setStatus("COMPLETED");
+        visit.setVisitedBy(operatorId);
+        visit.setVisitedAt(now);
+        visit.setVisitCount(Objects.requireNonNullElse(visit.getVisitCount(), 0) + 1);
+        visit.setUpdatedAt(now);
+        visits.updateById(visit);
+        DeliveryOrder delivery = deliveryOrders.findByNo(customerId, visit.getDeliveryNo());
+        if (delivery != null) recordOperation(delivery, operatorId, "CUSTOMER_VISIT",
+            "已完成第" + visit.getVisitCount() + "次客户回访，入仓单 " + selected.inboundCode(), now);
+        return detail(visit);
+    }
+
+    public CustomerVisitResponses.UploadedFile upload(String customerId, long operatorId, long visitId,
+                                                       MultipartFile file) {
+        required(customerId, visitId);
+        validateFile(file);
+        CustomerVisitFileGateway.UploadedFile uploaded = files.upload(customerId, visitId, operatorId, file);
+        return new CustomerVisitResponses.UploadedFile(uploaded.fileId(), uploaded.fileName(),
+            uploaded.contentType(), uploaded.sizeBytes());
+    }
+
+    private CustomerVisit ensureVisit(DeliveryOrder delivery, LocalDateTime completedAt) {
+        CustomerVisit existing = visits.findByDelivery(delivery.getCustomerId(), delivery.getId());
+        if (existing != null) return existing;
+        List<LastlegOrder> orders = orders(delivery);
+        CustomerVisit value = new CustomerVisit();
+        value.setId(IdWorker.getId()); value.setCustomerId(delivery.getCustomerId());
+        value.setDeliveryOrderId(delivery.getId()); value.setDeliveryNo(delivery.getDeliveryNo());
+        value.setCustomerName(delivery.getCustomerName());
+        value.setDestination(orders.stream().map(LastlegOrder::getFbaWarehouseCode)
+            .filter(StringUtils::hasText).distinct().reduce((left, right) -> left + ", " + right).orElse(null));
+        value.setDeliveryCompletedAt(completedAt); value.setStatus("PENDING"); value.setVisitCount(0);
+        value.setAttachmentJson("[]"); value.setCreatedAt(LocalDateTime.now()); value.setUpdatedAt(value.getCreatedAt());
+        try { visits.insert(value); }
+        catch (DuplicateKeyException exception) {
+            CustomerVisit concurrent = visits.findByDelivery(delivery.getCustomerId(), delivery.getId());
+            if (concurrent != null) return concurrent;
+            throw exception;
+        }
+        return value;
+    }
+
+    private CustomerVisitResponses.Detail detail(CustomerVisit visit) {
+        return new CustomerVisitResponses.Detail(row(visit), inboundOptions(visit), visit.getCustomerFeedback(),
+            visit.getRemark(), visit.getVisitedBy());
+    }
+
+    private List<CustomerVisitResponses.InboundOption> inboundOptions(CustomerVisit visit) {
+        List<LastlegOrder> orders = lastMileOrders.selectList(new LambdaQueryWrapper<LastlegOrder>()
+            .eq(LastlegOrder::getCustomerId, visit.getCustomerId())
+            .eq(LastlegOrder::getDeliveryOrderNo, visit.getDeliveryNo())
+            .orderByAsc(LastlegOrder::getInboundCode));
+        if (orders.isEmpty()) return List.of();
+        List<String> codes = orders.stream().map(LastlegOrder::getInboundCode).filter(StringUtils::hasText).distinct().toList();
+        Map<String, LastlegInboundOrder> byCode = new LinkedHashMap<>();
+        if (!codes.isEmpty()) inboundOrders.selectList(new LambdaQueryWrapper<LastlegInboundOrder>()
+            .eq(LastlegInboundOrder::getCustomerId, visit.getCustomerId()).in(LastlegInboundOrder::getInboundCode, codes))
+            .forEach(value -> byCode.putIfAbsent(value.getInboundCode(), value));
+        return orders.stream().map(order -> {
+            LastlegInboundOrder inbound = byCode.get(order.getInboundCode());
+            return new CustomerVisitResponses.InboundOption(inbound == null ? null : inbound.getId(),
+                order.getInboundCode(), order.getId(), order.getOrderNo(), order.getFbaWarehouseCode(),
+                inbound == null ? null : inbound.getDestinationWarehouseName(),
+                Objects.requireNonNullElse(order.getPackageCount(), 0));
+        }).filter(option -> option.inboundOrderId() != null).toList();
+    }
+
+    private List<LastlegOrder> orders(DeliveryOrder delivery) {
+        return lastMileOrders.selectList(new LambdaQueryWrapper<LastlegOrder>()
+            .eq(LastlegOrder::getCustomerId, delivery.getCustomerId())
+            .eq(LastlegOrder::getDeliveryOrderNo, delivery.getDeliveryNo()));
+    }
+
+    private CustomerVisitResponses.Row row(CustomerVisit value) {
+        return new CustomerVisitResponses.Row(value.getId(), value.getCustomerId(), value.getDeliveryNo(),
+            value.getCustomerName(), value.getContactName(), value.getContactPhone(), value.getDestination(),
+            value.getDeliveryCompletedAt(), value.getStatus(), value.getSelectedInboundCode(), value.getVisitResult(),
+            value.getVisitedAt(), Objects.requireNonNullElse(value.getVisitCount(), 0), readAttachments(value.getAttachmentJson()));
+    }
+
+    private LambdaQueryWrapper<CustomerVisit> filter(String customerId, CustomerVisitRequests.Query query) {
+        return new LambdaQueryWrapper<CustomerVisit>()
+            .eq(StringUtils.hasText(customerId), CustomerVisit::getCustomerId, customerId)
+            .and(StringUtils.hasText(query.keyword()), wrapper -> wrapper
+                .like(CustomerVisit::getDeliveryNo, trim(query.keyword()))
+                .or().like(CustomerVisit::getCustomerName, trim(query.keyword()))
+                .or().like(CustomerVisit::getContactName, trim(query.keyword()))
+                .or().like(CustomerVisit::getContactPhone, trim(query.keyword())))
+            .eq(StringUtils.hasText(query.status()), CustomerVisit::getStatus, trim(query.status()))
+            .ge(query.completedFrom() != null, CustomerVisit::getDeliveryCompletedAt, query.completedFrom())
+            .le(query.completedTo() != null, CustomerVisit::getDeliveryCompletedAt, query.completedTo());
+    }
+
+    private CustomerVisit required(String customerId, long visitId) {
+        CustomerVisit value = visits.selectOne(new LambdaQueryWrapper<CustomerVisit>()
+            .eq(CustomerVisit::getCustomerId, customerId).eq(CustomerVisit::getId, visitId));
+        if (value == null) throw notFound("回访记录不存在");
+        return value;
+    }
+
+    private void recordOperation(DeliveryOrder delivery, String operatorId, String node, String result, LocalDateTime now) {
+        DeliveryOperation operation = new DeliveryOperation();
+        operation.setCustomerId(delivery.getCustomerId()); operation.setDeliveryOrderId(delivery.getId());
+        operation.setOperationNode(node); operation.setOperatorId(operatorId); operation.setOperatorName(operatorId);
+        operation.setResult(result); operation.setCreatedAt(now); deliveryOperations.insert(operation);
+    }
+
+    private String writeAttachments(List<CustomerVisitResponses.Attachment> values) {
+        try { return objectMapper.writeValueAsString(values); }
+        catch (JsonProcessingException exception) { throw new IllegalStateException("无法保存回访资料", exception); }
+    }
+
+    private List<CustomerVisitResponses.Attachment> readAttachments(String value) {
+        if (!StringUtils.hasText(value)) return List.of();
+        try { return objectMapper.readValue(value, new TypeReference<>() { }); }
+        catch (JsonProcessingException exception) { throw new IllegalStateException("回访资料数据损坏", exception); }
+    }
+
+    private static void validateFile(MultipartFile file) {
+        if (file == null || file.isEmpty()) throw badRequest("请选择回访资料文件");
+        if (file.getSize() > MAX_FILE_BYTES) throw badRequest("单个回访资料不能超过20MB");
+        String name = Objects.requireNonNullElse(file.getOriginalFilename(), "");
+        int dot = name.lastIndexOf('.');
+        String extension = dot < 0 ? "" : name.substring(dot + 1).toLowerCase(Locale.ROOT);
+        if (!FILE_EXTENSIONS.contains(extension)) throw badRequest("仅支持PDF、Office、JPG、PNG和WEBP文件");
+    }
+
+    private static String customerScope(String scopedCustomerId, String requestedCustomerId) {
+        if (StringUtils.hasText(scopedCustomerId)) {
+            if (StringUtils.hasText(requestedCustomerId) && !scopedCustomerId.equals(trim(requestedCustomerId))) {
+                throw new ResponseStatusException(HttpStatus.FORBIDDEN, "不能访问其他客户数据");
+            }
+            return scopedCustomerId;
+        }
+        return trim(requestedCustomerId);
+    }
+
+    private static String trim(String value) { return StringUtils.hasText(value) ? value.trim() : null; }
+    private static ResponseStatusException badRequest(String message) { return new ResponseStatusException(HttpStatus.BAD_REQUEST, message); }
+    private static ResponseStatusException notFound(String message) { return new ResponseStatusException(HttpStatus.NOT_FOUND, message); }
+    private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT, message); }
+}

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

@@ -6,18 +6,18 @@ import com.baiyue.common.security.AuthenticatedUser;
 import com.baiyue.lastleg.delivery.dto.DeliveryRequests;
 import com.baiyue.lastleg.delivery.dto.DeliveryResponses;
 import com.baiyue.lastleg.delivery.service.DeliveryTransferService;
+import com.baiyue.lastleg.security.OverseasPermissions;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.annotation.Resource;
 import jakarta.validation.Valid;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.http.HttpStatus;
+import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.server.ResponseStatusException;
 
 @RestController
-@ConditionalOnProperty(name = "lastleg.future-outbound-api.enabled", havingValue = "true")
 @RequestMapping("/api/platform/v1/last-leg")
 @Tag(name = "Outbound and delivery")
 public class DeliveryTransferController {
@@ -32,11 +32,19 @@ public class DeliveryTransferController {
         return ApiResponse.success(service.transfer(scope(user, customerId), dispatchNo, operator(user), request));
     }
 
+    @PostMapping("/outbound-orders/one-click-dropship")
+    @Operation(summary = "Create one-click dropship outbound and push a PDA picking task")
+    public ApiResponse<DeliveryResponses.PdaTask> createOneClick(
+        @AuthenticationPrincipal AuthenticatedUser user, @RequestParam(required = false) String customerId,
+        @Valid @RequestBody DeliveryRequests.OneClickOutbound request) {
+        return ApiResponse.success(service.createOneClick(scope(user, customerId), operator(user), request));
+    }
+
     @GetMapping("/outbound-orders")
     public ApiResponse<PageResult<DeliveryResponses.OutboundRow>> outboundPage(
         @AuthenticationPrincipal AuthenticatedUser user, @RequestParam(required = false) String customerId,
         @Valid DeliveryRequests.Query query) {
-        return ApiResponse.success(service.outboundPage(scope(user, customerId), query));
+        return ApiResponse.success(service.outboundPage(listScope(user, customerId), query));
     }
 
     @GetMapping("/outbound-orders/{outboundNo}")
@@ -46,18 +54,30 @@ public class DeliveryTransferController {
         return ApiResponse.success(service.outboundDetail(scope(user, customerId), outboundNo, query));
     }
 
+    @PostMapping("/outbound-orders/{outboundNo}/cancel")
+    @Operation(summary = "Cancel outbound and linked delivery, restoring inventory")
+    public ApiResponse<Void> cancelOutbound(@AuthenticationPrincipal AuthenticatedUser user,
+                                             @RequestParam(required = false) String customerId,
+                                             @PathVariable String outboundNo,
+                                             @Valid @RequestBody DeliveryRequests.Cancel request) {
+        service.cancelOutbound(scope(user, customerId), operator(user), outboundNo, request);
+        return ApiResponse.success(null);
+    }
+
     @GetMapping("/delivery-orders")
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.DELIVERY_LIST + "')")
     public ApiResponse<PageResult<DeliveryResponses.DeliveryRow>> deliveryPage(
         @AuthenticationPrincipal AuthenticatedUser user, @RequestParam(required = false) String customerId,
         @Valid DeliveryRequests.Query query) {
-        return ApiResponse.success(service.deliveryPage(scope(user, customerId), query));
+        return ApiResponse.success(service.deliveryPage(listScope(user, customerId), query));
     }
 
     @GetMapping("/delivery-orders/{deliveryNo}")
-    public ApiResponse<DeliveryResponses.OutboundDetail> deliveryDetail(
+    @PreAuthorize("hasAuthority('" + OverseasPermissions.DELIVERY_LIST + "')")
+    public ApiResponse<DeliveryResponses.DeliveryDetail> deliveryDetail(
         @AuthenticationPrincipal AuthenticatedUser user, @RequestParam(required = false) String customerId,
-        @PathVariable String deliveryNo, @Valid DeliveryRequests.PalletQuery query) {
+        @PathVariable String deliveryNo) {
-        return ApiResponse.success(service.deliveryDetail(scope(user, customerId), deliveryNo, query));
+        return ApiResponse.success(service.deliveryDetail(scope(user, customerId), deliveryNo));
     }
 
     private String scope(AuthenticatedUser user, String requestedCustomer) {
@@ -73,4 +93,9 @@ public class DeliveryTransferController {
     private String operator(AuthenticatedUser user) {
         return user.userId() == null ? user.username() : String.valueOf(user.userId());
     }
+    private String listScope(AuthenticatedUser user, String requestedCustomer) {
+        if (user == null || user.tenantId() == null) throw new ResponseStatusException(HttpStatus.UNAUTHORIZED);
+        if ("PLATFORM".equals(user.appCode()) && user.tenantId() == 0L) return requestedCustomer == null || requestedCustomer.isBlank() ? null : requestedCustomer.trim();
+        return String.valueOf(user.tenantId());
+    }
 }

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

@@ -0,0 +1,46 @@
+package com.baiyue.lastleg.delivery.controller;
+
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.common.core.api.PageResult;
+import com.baiyue.common.security.AuthenticatedUser;
+import com.baiyue.lastleg.delivery.dto.DeliveryRequests;
+import com.baiyue.lastleg.delivery.dto.DeliveryResponses;
+import com.baiyue.lastleg.delivery.service.DeliveryTransferService;
+import jakarta.annotation.Resource;
+import jakarta.validation.Valid;
+import org.springframework.http.HttpStatus;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.server.ResponseStatusException;
+
+@RestController
+@RequestMapping("/api/merchant/v1/last-leg/delivery-orders")
+public class MerchantDeliveryController {
+    @Resource private DeliveryTransferService service;
+
+    @GetMapping
+    public ApiResponse<PageResult<DeliveryResponses.DeliveryRow>> page(@AuthenticationPrincipal AuthenticatedUser user,
+                                                                        @Valid DeliveryRequests.Query query) {
+        return ApiResponse.success(service.deliveryPage(customer(user), query));
+    }
+
+    @PostMapping
+    public ApiResponse<DeliveryResponses.TransferResult> create(@AuthenticationPrincipal AuthenticatedUser user,
+                                                                 @RequestParam String dispatchNo,
+                                                                 @Valid @RequestBody DeliveryRequests.Transfer request) {
+        return ApiResponse.success(service.transfer(customer(user), dispatchNo, operator(user), request));
+    }
+
+    @GetMapping("/{deliveryNo}")
+    public ApiResponse<DeliveryResponses.DeliveryDetail> detail(@AuthenticationPrincipal AuthenticatedUser user,
+                                                                 @PathVariable String deliveryNo) {
+        return ApiResponse.success(service.deliveryDetail(customer(user), deliveryNo));
+    }
+
+    private String customer(AuthenticatedUser user) {
+        if (user == null || user.tenantId() == null) throw new ResponseStatusException(HttpStatus.UNAUTHORIZED);
+        if ("PLATFORM".equals(user.appCode()) || user.tenantId() == 0L) throw new ResponseStatusException(HttpStatus.FORBIDDEN, "Merchant identity is required");
+        return String.valueOf(user.tenantId());
+    }
+    private String operator(AuthenticatedUser user) { return user.userId() == null ? user.username() : String.valueOf(user.userId()); }
+}

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

@@ -0,0 +1,41 @@
+package com.baiyue.lastleg.delivery.controller;
+
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.common.security.AuthenticatedUser;
+import com.baiyue.lastleg.delivery.dto.DeliveryRequests;
+import com.baiyue.lastleg.delivery.dto.DeliveryResponses;
+import com.baiyue.lastleg.delivery.service.DeliveryTransferService;
+import jakarta.annotation.Resource;
+import jakarta.validation.Valid;
+import org.springframework.http.HttpStatus;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.server.ResponseStatusException;
+
+@RestController
+@RequestMapping("/api/pda/v1/last-leg/outbound-tasks")
+public class OutboundPdaController {
+    @Resource private DeliveryTransferService service;
+    @PostMapping("/{taskNo}/pick")
+    public ApiResponse<DeliveryResponses.PdaTask> pick(@AuthenticationPrincipal AuthenticatedUser user,
+        @PathVariable String taskNo, @RequestParam(required=false) String customerId,
+        @Valid @RequestBody DeliveryRequests.PdaPick request) {
+        return ApiResponse.success(service.pdaPick(scope(user, customerId), operator(user), taskNo, request));
+    }
+    @GetMapping
+    public ApiResponse<java.util.List<DeliveryResponses.PdaTask>> list(@AuthenticationPrincipal AuthenticatedUser user,
+        @RequestParam(required=false) String customerId, @RequestParam(required=false) String status) {
+        return ApiResponse.success(service.pdaTasks(scope(user, customerId), status));
+    }
+    @PostMapping("/{taskNo}/complete")
+    public ApiResponse<DeliveryResponses.PdaTask> complete(@AuthenticationPrincipal AuthenticatedUser user,
+        @PathVariable String taskNo, @RequestParam(required=false) String customerId) {
+        return ApiResponse.success(service.completePda(scope(user, customerId), taskNo));
+    }
+    private String scope(AuthenticatedUser user, String requested) {
+        if (user == null || user.tenantId() == null) throw new ResponseStatusException(HttpStatus.UNAUTHORIZED);
+        if (requested != null && !requested.isBlank()) return requested.trim();
+        return String.valueOf(user.tenantId());
+    }
+    private String operator(AuthenticatedUser user) { return user.userId() == null ? user.username() : String.valueOf(user.userId()); }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/dto/DeliveryRequests.java

@@ -3,16 +3,43 @@ package com.baiyue.lastleg.delivery.dto;
 import jakarta.validation.constraints.Max;
 import jakarta.validation.constraints.Min;
 import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Size;
+import jakarta.validation.Valid;
+import java.util.List;
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
 
 public final class DeliveryRequests {
     private DeliveryRequests() {}
 
     public record Transfer(@NotBlank @Size(max = 255) String idempotencyKey,
-                           @Size(max = 1000) String remark) {}
+                           @NotNull LocalDateTime plannedDeliveryAt,
+                           @NotBlank @Size(max = 32) String deliveryMethod,
+                           @Size(max = 128) String waybillNo,
+                           @Size(max = 255) String carrierName,
+                           @NotBlank @Size(max = 64) String pickupMethod,
+                           @NotBlank @Size(max = 64) String loadingType,
+                           @Size(max = 64) String vehicleType,
+                           @Size(max = 64) String vehicleSize,
+                           @Size(max = 128) String driverName,
+                           @Size(max = 64) String driverPhone,
+                           @Size(max = 64) String vehiclePlate,
+                           @Size(max = 128) String appointmentAccount,
+                           @Size(max = 128) String sellerName,
+                           @Size(max = 1000) String remark,
+                           @NotNull @Valid @Size(min = 1, max = 20) List<FeeItem> fees) {}
+
+    public record FeeItem(@NotBlank @Size(max = 64) String feeType,
+                          @NotBlank @Size(max = 8) String currency,
+                          @NotNull @Min(0) BigDecimal amount,
+                          @Size(max = 500) String remark) {}
 
     public record Query(@Min(1) long page, @Min(1) @Max(200) long size,
-                        String documentNo, String warehouseId, String status) {
+                        String documentNo, String warehouseId, String status,
+                        String dispatchNo, String waybillNo, String vehiclePlate,
+                        String driverName, String deliveryMethod,
+                        LocalDateTime plannedFrom, LocalDateTime plannedTo) {
         public Query { if (page == 0) page = 1; if (size == 0) size = 20; }
     }
 
@@ -20,4 +47,14 @@ public final class DeliveryRequests {
                               String destinationWarehouseCode) {
         public PalletQuery { if (page == 0) page = 1; if (size == 0) size = 20; }
     }
+
+    public record OneClickOutbound(@NotBlank @Size(max=1000) String recipient,
+                                   @NotNull @Size(min=1, max=200) List<@Valid OneClickItem> items,
+                                   @Size(max=1000) String remark,
+                                   @NotBlank @Size(max=255) String idempotencyKey) {}
+    public record OneClickItem(@NotNull Long inventoryPositionId, @NotNull @Min(1) Long packages,
+                               @NotBlank @Size(max=128) String sku) {}
+    public record PdaPick(@NotNull Long outboundPalletItemId, @NotNull Long inventoryPositionId,
+                          @NotNull @Min(1) Long packages, @NotBlank @Size(max=255) String idempotencyKey) {}
+    public record Cancel(@NotBlank @Size(max=1000) String reason) {}
 }

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/dto/DeliveryResponses.java

@@ -1,6 +1,8 @@
 package com.baiyue.lastleg.delivery.dto;
 
 import java.time.LocalDateTime;
+import java.math.BigDecimal;
+import java.util.List;
 
 public final class DeliveryResponses {
     private DeliveryResponses() {}
@@ -12,9 +14,32 @@ public final class DeliveryResponses {
     public record OutboundRow(Long id, String outboundNo, String dispatchNo, String overseasWarehouseId,
                               String status, int palletCount, int packageCount, LocalDateTime createdAt) {}
 
-    public record DeliveryRow(Long id, String deliveryNo, String outboundNo, String dispatchNo,
+    public record DeliveryRow(Long id, String customerId, String customerName, String deliveryNo,
-                              String overseasWarehouseId, String status, int palletCount,
+                              String outboundNo, String dispatchNo, String overseasWarehouseId,
-                              int packageCount, LocalDateTime createdAt) {}
+                              String overseasWarehouseName, String status, String waybillNo,
+                              String deliveryMethod, String carrierName, String pickupMethod,
+                              String loadingType, String vehicleType, String vehicleSize,
+                              String vehiclePlate, String driverName, String driverPhone,
+                              String appointmentAccount, String sellerName, int palletCount,
+                              int packageCount, BigDecimal totalWeightKg, BigDecimal totalVolumeCbm,
+                              LocalDateTime plannedDeliveryAt, LocalDateTime dispatchedAt,
+                              LocalDateTime expectedArrivalAt, LocalDateTime signedAt,
+                              String remark, LocalDateTime createdAt) {}
+
+    public record DeliverySku(String inboundCode, String customerName, String destinationWarehouseCode,
+                              String receivingAddress, String shipmentNo, String fbaTrackingNo,
+                              String skuCode, String productName, int packageCount,
+                              BigDecimal weightKg, BigDecimal volumeCbm) {}
+
+    public record DeliveryFeeRow(Long id, String feeDirection, String feeType, String currency,
+                                 BigDecimal amount, String remark) {}
+
+    public record DeliveryOperationRow(Long id, LocalDateTime operatedAt, String operationNode,
+                                       String operatorName, String result) {}
+
+    public record DeliveryDetail(DeliveryRow order, List<DeliverySku> skus,
+                                 List<DeliveryFeeRow> fees, List<DeliveryOperationRow> operations) {}
 
     public record OutboundDetail(OutboundRow outbound, DeliveryRow delivery) {}
+    public record PdaTask(Long id, String taskNo, String status, String outboundNo, LocalDateTime pushedAt, LocalDateTime completedAt) {}
 }

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/entity/DeliveryFee.java

@@ -0,0 +1,24 @@
+package com.baiyue.lastleg.delivery.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+@Data
+@TableName("ll_delivery_fee")
+public class DeliveryFee {
+    @TableId(type = IdType.ASSIGN_ID) private Long id;
+    private String customerId;
+    private Long deliveryOrderId;
+    private String feeDirection;
+    private String feeType;
+    private String currency;
+    private BigDecimal amount;
+    private String remark;
+    private String createdBy;
+    private LocalDateTime createdAt;
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/entity/DeliveryOperation.java

@@ -0,0 +1,21 @@
+package com.baiyue.lastleg.delivery.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Data
+@TableName("ll_delivery_operation")
+public class DeliveryOperation {
+    @TableId(type = IdType.ASSIGN_ID) private Long id;
+    private String customerId;
+    private Long deliveryOrderId;
+    private String operationNode;
+    private String operatorId;
+    private String operatorName;
+    private String result;
+    private LocalDateTime createdAt;
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/entity/DeliveryOrder.java

@@ -5,6 +5,7 @@ import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 
+import java.math.BigDecimal;
 import java.time.LocalDateTime;
 
 /** Delivery document linked one-to-one to its outbound document and dispatch. */
@@ -20,9 +21,30 @@ public class DeliveryOrder {
     private Long dispatchOrderId;
     private String dispatchNo;
     private String overseasWarehouseId;
+    private String overseasWarehouseName;
+    private String customerName;
     private String status;
+    private String waybillNo;
+    private String deliveryMethod;
+    private String carrierName;
+    private String pickupMethod;
+    private String loadingType;
+    private String vehicleType;
+    private String vehicleSize;
+    private String vehiclePlate;
+    private String driverName;
+    private String driverPhone;
+    private String appointmentAccount;
+    private String sellerName;
     private Integer packageCount;
     private Integer palletCount;
+    private BigDecimal totalWeightKg;
+    private BigDecimal totalVolumeCbm;
+    private LocalDateTime plannedDeliveryAt;
+    private LocalDateTime dispatchedAt;
+    private LocalDateTime expectedArrivalAt;
+    private LocalDateTime signedAt;
+    private String remark;
     private String idempotencyKey;
     private String createdBy;
     private LocalDateTime createdAt;

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/entity/OutboundOrder.java

@@ -18,6 +18,8 @@ public class OutboundOrder {
     private Long dispatchOrderId;
     private String dispatchNo;
     private String overseasWarehouseId;
+    private String outboundType;
+    private String recipientInfo;
     private String status;
     private Integer packageCount;
     private Integer palletCount;

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/entity/OutboundPalletItem.java

@@ -21,6 +21,9 @@ public class OutboundPalletItem {
     private String destinationWarehouseCode;
     private String destinationWarehouseName;
     private Integer packageCount;
+    private Integer pickedPackageCount;
+    private String status;
+    private String skuCode;
     private String orderRefs;
     private String inboundCode;
     private LocalDateTime createdAt;

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/entity/OutboundPdaPick.java

@@ -0,0 +1,20 @@
+package com.baiyue.lastleg.delivery.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import java.time.LocalDateTime;
+
+@Data
+@TableName("ll_outbound_pda_pick")
+public class OutboundPdaPick {
+    @TableId(type = IdType.ASSIGN_ID) private Long id;
+    private String customerId;
+    private Long taskId;
+    private Long outboundPalletItemId;
+    private Long inventoryPositionId;
+    private Long packages;
+    private String idempotencyKey;
+    private LocalDateTime pickedAt;
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/entity/OutboundPdaTask.java

@@ -0,0 +1,21 @@
+package com.baiyue.lastleg.delivery.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import java.time.LocalDateTime;
+
+@Data
+@TableName("ll_outbound_pda_task")
+public class OutboundPdaTask {
+    @TableId(type = IdType.ASSIGN_ID) private Long id;
+    private String customerId;
+    private Long outboundOrderId;
+    private String taskNo;
+    private String status;
+    private LocalDateTime pushedAt;
+    private LocalDateTime completedAt;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/mapper/DeliveryFeeMapper.java

@@ -0,0 +1,16 @@
+package com.baiyue.lastleg.delivery.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baiyue.lastleg.delivery.entity.DeliveryFee;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.List;
+
+@Mapper
+public interface DeliveryFeeMapper extends BaseMapper<DeliveryFee> {
+    @Select("SELECT * FROM ll_delivery_fee WHERE customer_id=#{customerId} AND delivery_order_id=#{deliveryOrderId} ORDER BY id")
+    List<DeliveryFee> findByDelivery(@Param("customerId") String customerId,
+                                     @Param("deliveryOrderId") Long deliveryOrderId);
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/mapper/DeliveryOperationMapper.java

@@ -0,0 +1,16 @@
+package com.baiyue.lastleg.delivery.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baiyue.lastleg.delivery.entity.DeliveryOperation;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.List;
+
+@Mapper
+public interface DeliveryOperationMapper extends BaseMapper<DeliveryOperation> {
+    @Select("SELECT * FROM ll_delivery_operation WHERE customer_id=#{customerId} AND delivery_order_id=#{deliveryOrderId} ORDER BY created_at,id")
+    List<DeliveryOperation> findByDelivery(@Param("customerId") String customerId,
+                                           @Param("deliveryOrderId") Long deliveryOrderId);
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/mapper/OutboundOrderMapper.java

@@ -14,4 +14,6 @@ public interface OutboundOrderMapper extends BaseMapper<OutboundOrder> {
     OutboundOrder findByIdempotency(@Param("customerId") String customerId, @Param("key") String key);
     @Select("SELECT * FROM ll_outbound_order WHERE customer_id=#{customerId} AND dispatch_order_id=#{dispatchOrderId} LIMIT 1 FOR UPDATE")
     OutboundOrder lockByDispatch(@Param("customerId") String customerId, @Param("dispatchOrderId") Long dispatchOrderId);
+    @Select("SELECT * FROM ll_outbound_order WHERE customer_id=#{customerId} AND outbound_no=#{outboundNo} LIMIT 1 FOR UPDATE")
+    OutboundOrder lockByNo(@Param("customerId") String customerId, @Param("outboundNo") String outboundNo);
 }

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/mapper/OutboundPdaPickMapper.java

@@ -0,0 +1,14 @@
+package com.baiyue.lastleg.delivery.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baiyue.lastleg.delivery.entity.OutboundPdaPick;
+import org.apache.ibatis.annotations.*;
+import java.util.List;
+
+@Mapper
+public interface OutboundPdaPickMapper extends BaseMapper<OutboundPdaPick> {
+    @Select("SELECT * FROM ll_outbound_pda_pick WHERE customer_id=#{customerId} AND idempotency_key=#{key} LIMIT 1")
+    OutboundPdaPick findByKey(@Param("customerId") String customerId, @Param("key") String key);
+    @Select("SELECT * FROM ll_outbound_pda_pick WHERE customer_id=#{customerId} AND task_id IN (SELECT id FROM ll_outbound_pda_task WHERE customer_id=#{customerId} AND outbound_order_id=#{outboundId})")
+    List<OutboundPdaPick> findByOutbound(@Param("customerId") String customerId, @Param("outboundId") Long outboundId);
+}

lastleg-service/src/main/java/com/baiyue/lastleg/delivery/mapper/OutboundPdaTaskMapper.java

@@ -0,0 +1,16 @@
+package com.baiyue.lastleg.delivery.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baiyue.lastleg.delivery.entity.OutboundPdaTask;
+import org.apache.ibatis.annotations.*;
+import java.util.List;
+
+@Mapper
+public interface OutboundPdaTaskMapper extends BaseMapper<OutboundPdaTask> {
+    @Select("SELECT * FROM ll_outbound_pda_task WHERE customer_id=#{customerId} AND outbound_order_id=#{outboundOrderId} LIMIT 1 FOR UPDATE")
+    OutboundPdaTask lockByOutbound(@Param("customerId") String customerId, @Param("outboundOrderId") Long outboundOrderId);
+    @Select("SELECT * FROM ll_outbound_pda_task WHERE customer_id=#{customerId} AND task_no=#{taskNo} LIMIT 1 FOR UPDATE")
+    OutboundPdaTask lockByNo(@Param("customerId") String customerId, @Param("taskNo") String taskNo);
+    @Select("SELECT * FROM ll_outbound_pda_task WHERE customer_id=#{customerId} AND (#{status} IS NULL OR status=#{status}) ORDER BY pushed_at DESC LIMIT 200")
+    List<OutboundPdaTask> list(@Param("customerId") String customerId, @Param("status") String status);
+}

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

@@ -7,9 +7,13 @@ import com.baiyue.common.core.api.PageResult;
 import com.baiyue.lastleg.delivery.dto.DeliveryRequests;
 import com.baiyue.lastleg.delivery.dto.DeliveryResponses;
 import com.baiyue.lastleg.delivery.entity.DeliveryOrder;
+import com.baiyue.lastleg.delivery.entity.DeliveryFee;
+import com.baiyue.lastleg.delivery.entity.DeliveryOperation;
 import com.baiyue.lastleg.delivery.entity.OutboundOrder;
 import com.baiyue.lastleg.delivery.entity.OutboundPalletItem;
 import com.baiyue.lastleg.delivery.mapper.DeliveryOrderMapper;
+import com.baiyue.lastleg.delivery.mapper.DeliveryFeeMapper;
+import com.baiyue.lastleg.delivery.mapper.DeliveryOperationMapper;
 import com.baiyue.lastleg.delivery.mapper.OutboundOrderMapper;
 import com.baiyue.lastleg.delivery.mapper.OutboundPalletItemMapper;
 import com.baiyue.lastleg.dispatch.entity.DispatchItem;
@@ -18,12 +22,27 @@ import com.baiyue.lastleg.dispatch.mapper.DispatchItemMapper;
 import com.baiyue.lastleg.dispatch.mapper.DispatchOrderMapper;
 import com.baiyue.lastleg.entity.LastlegOrder;
 import com.baiyue.lastleg.entity.LastlegOrderStatusHistory;
+import com.baiyue.lastleg.entity.LastlegOrderDetail;
 import com.baiyue.lastleg.inboundplan.entity.InboundPlanLine;
 import com.baiyue.lastleg.inboundplan.entity.InboundPlanPalletAllocation;
 import com.baiyue.lastleg.inboundplan.mapper.InboundPlanLineMapper;
 import com.baiyue.lastleg.inboundplan.mapper.InboundPlanPalletAllocationMapper;
+import com.baiyue.lastleg.delivery.entity.OutboundPdaTask;
+import com.baiyue.lastleg.delivery.entity.OutboundPdaPick;
+import com.baiyue.lastleg.delivery.mapper.OutboundPdaTaskMapper;
+import com.baiyue.lastleg.delivery.mapper.OutboundPdaPickMapper;
+import com.baiyue.lastleg.inventory.command.dto.InventoryCommandRequests;
+import com.baiyue.lastleg.inventory.command.service.InventoryCommandService;
+import com.baiyue.lastleg.inventory.entity.InventoryPosition;
+import com.baiyue.lastleg.inventory.mapper.InventoryPositionMapper;
+import com.baiyue.lastleg.dropship.entity.DropshipOrderProfile;
+import com.baiyue.lastleg.dropship.entity.DropshipCarton;
+import com.baiyue.lastleg.dropship.mapper.DropshipOrderProfileMapper;
+import com.baiyue.lastleg.dropship.mapper.DropshipCartonMapper;
+import com.baiyue.lastleg.dropship.mapper.DropshipSkuInventoryMapper;
 import com.baiyue.lastleg.mapper.LastlegOrderMapper;
 import com.baiyue.lastleg.mapper.LastlegOrderStatusHistoryMapper;
+import com.baiyue.lastleg.mapper.LastlegOrderDetailMapper;
 import jakarta.annotation.Resource;
 import org.springframework.dao.DuplicateKeyException;
 import org.springframework.http.HttpStatus;
@@ -34,6 +53,8 @@ import org.springframework.web.server.ResponseStatusException;
 
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
+import com.baiyue.lastleg.service.LastlegOrderNoGenerator;
+import java.math.BigDecimal;
 import java.util.*;
 
 @Service
@@ -43,10 +64,21 @@ public class DeliveryTransferService {
     @Resource private OutboundOrderMapper outboundOrders;
     @Resource private OutboundPalletItemMapper outboundPallets;
     @Resource private DeliveryOrderMapper deliveryOrders;
+    @Resource private DeliveryFeeMapper deliveryFees;
+    @Resource private DeliveryOperationMapper deliveryOperations;
+    @Resource private OutboundPdaTaskMapper pdaTasks;
+    @Resource private OutboundPdaPickMapper pdaPicks;
+    @Resource private InventoryPositionMapper inventoryPositions;
+    @Resource private InventoryCommandService inventoryCommands;
+    @Resource private DropshipOrderProfileMapper dropshipProfiles;
+    @Resource private DropshipCartonMapper dropshipCartons;
+    @Resource private DropshipSkuInventoryMapper dropshipSkuInventory;
     @Resource private InboundPlanPalletAllocationMapper planAllocations;
     @Resource private InboundPlanLineMapper planLines;
     @Resource private LastlegOrderMapper tailOrders;
     @Resource private LastlegOrderStatusHistoryMapper histories;
+    @Resource private LastlegOrderDetailMapper tailOrderDetails;
+    @Resource private LastlegOrderNoGenerator orderNoGenerator;
 
     @Transactional
     public DeliveryResponses.TransferResult transfer(String customerId, String dispatchNo, String operatorId,
@@ -70,13 +102,14 @@ public class DeliveryTransferService {
             throw conflict("All dispatch pallets must be received before transfer to delivery");
         }
         if (!StringUtils.hasText(dispatch.getOverseasWarehouseId())) throw conflict("Dispatch warehouse is required");
+        validateTransferFees(request);
 
         LocalDateTime now = LocalDateTime.now();
         OutboundOrder outbound = new OutboundOrder();
         outbound.setId(IdWorker.getId()); outbound.setCustomerId(customerId);
-        outbound.setOutboundNo("OUT" + now.format(DateTimeFormatter.BASIC_ISO_DATE) + outbound.getId());
+        outbound.setOutboundNo(orderNoGenerator.next("OUTBOUND", dispatch.getOverseasWarehouseId(), outbound.getId()));
         outbound.setDispatchOrderId(dispatch.getId()); outbound.setDispatchNo(dispatch.getDispatchNo());
-        outbound.setOverseasWarehouseId(dispatch.getOverseasWarehouseId()); outbound.setStatus("WAIT_OUTBOUND");
+        outbound.setOverseasWarehouseId(dispatch.getOverseasWarehouseId()); outbound.setStatus("WAIT_OUTBOUND"); outbound.setOutboundType("DISPATCH_DELIVERY");
         outbound.setPackageCount(items.stream().map(DispatchItem::getPackageCount).filter(Objects::nonNull).mapToInt(Integer::intValue).sum());
         outbound.setPalletCount(items.size()); outbound.setIdempotencyKey(request.idempotencyKey().trim());
         outbound.setCreatedBy(operatorId); outbound.setCreatedAt(now); outbound.setUpdatedAt(now);
@@ -103,27 +136,179 @@ public class DeliveryTransferService {
             item.setDestinationWarehouseId(source.getDestinationWarehouseId());
             item.setDestinationWarehouseCode(source.getDestinationWarehouseCode());
             item.setDestinationWarehouseName(source.getDestinationWarehouseName());
-            item.setPackageCount(Objects.requireNonNullElse(source.getPackageCount(), 0));
+            item.setPackageCount(Objects.requireNonNullElse(source.getPackageCount(), 0)); item.setPickedPackageCount(0); item.setStatus("WAIT_PICK");
             item.setOrderRefs(source.getOrderRefs()); item.setInboundCode(source.getInboundCode()); item.setCreatedAt(now);
             outboundPallets.insert(item);
         }
 
         DeliveryOrder delivery = new DeliveryOrder();
         delivery.setId(IdWorker.getId()); delivery.setCustomerId(customerId);
-        delivery.setDeliveryNo("DEL" + now.format(DateTimeFormatter.BASIC_ISO_DATE) + delivery.getId());
+        delivery.setDeliveryNo(orderNoGenerator.next("DELIVERY", dispatch.getOverseasWarehouseId(), delivery.getId()));
         delivery.setOutboundOrderId(outbound.getId()); delivery.setOutboundNo(outbound.getOutboundNo());
         delivery.setDispatchOrderId(dispatch.getId()); delivery.setDispatchNo(dispatch.getDispatchNo());
-        delivery.setOverseasWarehouseId(dispatch.getOverseasWarehouseId()); delivery.setStatus("WAIT_DELIVERY");
+        delivery.setOverseasWarehouseId(dispatch.getOverseasWarehouseId()); delivery.setOverseasWarehouseName(dispatch.getOverseasWarehouseName());
+        LastlegOrder firstOrder = firstTailOrder(customerId, items);
+        delivery.setCustomerName(firstOrder == null ? null : firstOrder.getCustomerName()); delivery.setStatus("WAIT_DELIVERY");
+        delivery.setWaybillNo(trim(request.waybillNo())); delivery.setDeliveryMethod(request.deliveryMethod().trim());
+        delivery.setCarrierName(firstText(request.carrierName(), dispatch.getCarrierName())); delivery.setPickupMethod(trim(request.pickupMethod()));
+        delivery.setLoadingType(trim(request.loadingType())); delivery.setVehicleType(trim(request.vehicleType())); delivery.setVehicleSize(trim(request.vehicleSize()));
+        delivery.setVehiclePlate(firstText(request.vehiclePlate(), dispatch.getVehiclePlate())); delivery.setDriverName(firstText(request.driverName(), dispatch.getDriverName()));
+        delivery.setDriverPhone(firstText(request.driverPhone(), dispatch.getDriverPhone())); delivery.setAppointmentAccount(trim(request.appointmentAccount()));
+        delivery.setSellerName(trim(request.sellerName())); delivery.setPlannedDeliveryAt(request.plannedDeliveryAt());
         delivery.setPackageCount(outbound.getPackageCount()); delivery.setPalletCount(outbound.getPalletCount());
+        delivery.setTotalVolumeCbm(items.stream().map(DispatchItem::getVolumeCbm).filter(Objects::nonNull).reduce(BigDecimal.ZERO, BigDecimal::add));
+        delivery.setTotalWeightKg(totalWeight(customerId, items)); delivery.setExpectedArrivalAt(dispatch.getEstimatedArrivalAt()); delivery.setRemark(trim(request.remark()));
         delivery.setIdempotencyKey(request.idempotencyKey().trim()); delivery.setCreatedBy(operatorId);
         delivery.setCreatedAt(now); delivery.setUpdatedAt(now); deliveryOrders.insert(delivery);
+        List<DeliveryRequests.FeeItem> feeInputs = request.fees() == null ? List.of() : request.fees();
+        for (DeliveryRequests.FeeItem input : feeInputs) {
+            DeliveryFee fee = new DeliveryFee(); fee.setCustomerId(customerId); fee.setDeliveryOrderId(delivery.getId());
+            fee.setFeeDirection("PAYABLE"); fee.setFeeType(input.feeType().trim()); fee.setCurrency(input.currency().trim().toUpperCase(Locale.ROOT));
+            fee.setAmount(input.amount()); fee.setRemark(trim(input.remark())); fee.setCreatedBy(operatorId); fee.setCreatedAt(now); deliveryFees.insert(fee);
+        }
+        recordOperation(customerId, delivery.getId(), operatorId, "CREATE_DELIVERY", "CREATED", now);
         bindTailOrders(customerId, items, outbound.getOutboundNo(), delivery.getDeliveryNo(), request.remark(), now);
         return result(outbound, delivery, false);
     }
 
+    private void validateTransferFees(DeliveryRequests.Transfer request) {
+        List<DeliveryRequests.FeeItem> inputs = request.fees() == null ? List.of() : request.fees();
+        if (inputs.isEmpty()) throw conflict("Delivery fee is required");
+        Set<String> allowed = Set.of("DELIVERY_FEE", "LOADING_FEE", "APPOINTMENT_FEE");
+        Set<String> seen = new HashSet<>();
+        for (DeliveryRequests.FeeItem input : inputs) {
+            String feeType = input.feeType().trim().toUpperCase(Locale.ROOT);
+            if (!allowed.contains(feeType)) throw conflict("Unsupported delivery fee type: " + feeType);
+            if (!seen.add(feeType)) throw conflict("Duplicate delivery fee type: " + feeType);
+            if (!"USD".equalsIgnoreCase(input.currency().trim())) throw conflict("Delivery fees must use USD");
+            if (input.amount().signum() < 0) throw conflict("Delivery fee amount cannot be negative");
+        }
+        if (!seen.contains("DELIVERY_FEE")) throw conflict("Delivery fee is required");
+        if (Set.of("FLOOR", "MIXED").contains(request.loadingType().trim().toUpperCase(Locale.ROOT))
+            && !seen.contains("LOADING_FEE")) {
+            throw conflict("Loading fee is required for floor or mixed loading");
+        }
+        if ("BUY_APPOINTMENT".equalsIgnoreCase(trim(request.appointmentAccount()))) {
+            if (!StringUtils.hasText(request.sellerName())) throw conflict("Seller name is required when buying an appointment");
+            if (!seen.contains("APPOINTMENT_FEE")) throw conflict("Appointment fee is required when buying an appointment");
+        }
+    }
+
+    @Transactional
+    public DeliveryResponses.PdaTask createOneClick(String customerId, String operatorId, DeliveryRequests.OneClickOutbound request) {
+        OutboundOrder existing = outboundOrders.findByIdempotency(customerId, request.idempotencyKey().trim());
+        if (existing != null) return taskResult(existing, pdaTasks.lockByOutbound(customerId, existing.getId()));
+        LocalDateTime now = LocalDateTime.now();
+        InventoryPosition firstPosition = inventoryPositions.selectById(request.items().get(0).inventoryPositionId());
+        if (firstPosition == null || !customerId.equals(firstPosition.getCustomerId())) throw notFound("Inventory position not found");
+        String selectedWarehouseId = firstPosition.getOverseasWarehouseId();
+        OutboundOrder outbound = new OutboundOrder();
+        outbound.setId(IdWorker.getId()); outbound.setCustomerId(customerId);
+        outbound.setOutboundNo(orderNoGenerator.next("ONE_CLICK_DROPSHIP", selectedWarehouseId, outbound.getId()));
+        outbound.setOutboundType("ONE_CLICK_DROPSHIP"); outbound.setStatus("WAIT_PICK"); outbound.setRecipientInfo(request.recipient().trim());
+        outbound.setPackageCount(request.items().stream().mapToInt(i -> i.packages().intValue()).sum()); outbound.setPalletCount(request.items().size());
+        outbound.setIdempotencyKey(request.idempotencyKey().trim()); outbound.setCreatedBy(operatorId); outbound.setCreatedAt(now); outbound.setUpdatedAt(now);
+        outboundOrders.insert(outbound);
+        for (DeliveryRequests.OneClickItem input : request.items()) {
+            InventoryPosition position = inventoryPositions.selectById(input.inventoryPositionId());
+            if (position == null || !customerId.equals(position.getCustomerId())) throw notFound("Inventory position not found");
+            DropshipOrderProfile profile = dropshipProfiles.findPosition(customerId, position.getId());
+            if (profile == null) throw conflict("Selected pallet is not one-click dropship inventory");
+            if (selectedWarehouseId == null) selectedWarehouseId = position.getOverseasWarehouseId();
+            else if (!Objects.equals(selectedWarehouseId, position.getOverseasWarehouseId())) throw conflict("One outbound order must use inventory from the same overseas warehouse");
+            if (value(position.getAvailablePackages()) < input.packages()) throw conflict("Insufficient available inventory for pallet " + position.getPalletNo());
+            OutboundPalletItem item = new OutboundPalletItem(); item.setId(IdWorker.getId()); item.setCustomerId(customerId); item.setOutboundOrderId(outbound.getId());
+            item.setWarehousePalletId(position.getPalletId()); item.setPalletNo(position.getPalletNo()); item.setPackageCount(input.packages().intValue()); item.setPickedPackageCount(0); item.setStatus("WAIT_PICK"); item.setSkuCode(input.sku().trim()); item.setCreatedAt(now);
+            outboundPallets.insert(item);
+        }
+        outbound.setOverseasWarehouseId(selectedWarehouseId); outboundOrders.updateById(outbound);
+        OutboundPdaTask task = new OutboundPdaTask(); task.setId(IdWorker.getId()); task.setCustomerId(customerId); task.setOutboundOrderId(outbound.getId());
+        task.setTaskNo("PDA" + now.format(DateTimeFormatter.BASIC_ISO_DATE) + task.getId()); task.setStatus("PENDING"); task.setPushedAt(now); task.setCreatedAt(now); task.setUpdatedAt(now); pdaTasks.insert(task);
+        return taskResult(outbound, task);
+    }
+
+    @Transactional
+    public DeliveryResponses.PdaTask pdaPick(String customerId, String operatorId, String taskNo, DeliveryRequests.PdaPick request) {
+        OutboundPdaTask task = pdaTasks.lockByNo(customerId, taskNo); if (task == null) throw notFound("PDA task not found");
+        OutboundPdaPick replay = pdaPicks.findByKey(customerId, request.idempotencyKey().trim()); if (replay != null) return taskResult(outboundOrders.selectById(task.getOutboundOrderId()), task);
+        OutboundOrder outbound = outboundOrders.lockByNo(customerId, outboundNo(task.getOutboundOrderId()));
+        OutboundPalletItem item = outboundPallets.selectById(request.outboundPalletItemId());
+        if (item == null || !task.getOutboundOrderId().equals(item.getOutboundOrderId())) throw notFound("Outbound pallet item not found");
+        if (request.packages() > item.getPackageCount() - value(item.getPickedPackageCount())) throw conflict("Picked quantity exceeds outbound pallet quantity");
+        InventoryPosition selectedPosition = inventoryPositions.selectById(request.inventoryPositionId());
+        if (selectedPosition == null || !customerId.equals(selectedPosition.getCustomerId()) || !Objects.equals(selectedPosition.getPalletId(), item.getWarehousePalletId())) throw conflict("Scanned inventory position does not belong to the outbound pallet");
+        DropshipOrderProfile profile = dropshipProfiles.findPosition(customerId, request.inventoryPositionId());
+        if (profile == null) throw conflict("Scanned pallet is not one-click dropship inventory");
+        List<DropshipCarton> cartons = dropshipCartons.lockAvailable(customerId, profile.getId(), item.getSkuCode(), request.packages());
+        if (cartons.size() != request.packages()) throw conflict("Insufficient available one-click dropship cartons");
+        InventoryCommandRequests.Move move = new InventoryCommandRequests.Move(request.inventoryPositionId(), request.packages(), outbound.getOutboundNo(), outbound.getOutboundNo(), null, request.idempotencyKey() + ":ALLOCATE", null);
+        inventoryCommands.allocate(customerId, operatorId, move);
+        inventoryCommands.pick(customerId, operatorId, new InventoryCommandRequests.Move(request.inventoryPositionId(), request.packages(), outbound.getOutboundNo(), outbound.getOutboundNo(), null, request.idempotencyKey() + ":PICK", null));
+        inventoryCommands.ship(customerId, operatorId, new InventoryCommandRequests.Move(request.inventoryPositionId(), request.packages(), outbound.getOutboundNo(), outbound.getOutboundNo(), null, request.idempotencyKey() + ":SHIP", null));
+        if (dropshipSkuInventory.deduct(customerId, profile.getId(), item.getSkuCode(), request.packages()) != 1) throw conflict("Insufficient one-click dropship SKU inventory");
+        for (DropshipCarton carton : cartons) { carton.setStatus("SHIPPED"); carton.setOutboundOrderNo(outbound.getOutboundNo()); carton.setVersion((carton.getVersion() == null ? 0 : carton.getVersion()) + 1); carton.setUpdatedAt(LocalDateTime.now()); dropshipCartons.updateById(carton); }
+        OutboundPdaPick pick = new OutboundPdaPick(); pick.setId(IdWorker.getId()); pick.setCustomerId(customerId); pick.setTaskId(task.getId()); pick.setOutboundPalletItemId(item.getId()); pick.setInventoryPositionId(request.inventoryPositionId()); pick.setPackages(request.packages()); pick.setIdempotencyKey(request.idempotencyKey().trim()); pick.setPickedAt(LocalDateTime.now()); pdaPicks.insert(pick);
+        item.setPickedPackageCount(value(item.getPickedPackageCount()) + request.packages().intValue()); item.setStatus(item.getPickedPackageCount() >= item.getPackageCount() ? "PICKED" : "PARTIAL_PICKED"); outboundPallets.updateById(item);
+        List<OutboundPalletItem> pickedItems = outboundPallets.findByOutbound(customerId, outbound.getId());
+        if (!pickedItems.isEmpty() && pickedItems.stream().allMatch(i -> "PICKED".equals(i.getStatus()))) {
+            outbound.setStatus("PICKED"); outbound.setUpdatedAt(LocalDateTime.now()); outboundOrders.updateById(outbound);
+        }
+        task.setStatus("IN_PROGRESS"); task.setUpdatedAt(LocalDateTime.now()); pdaTasks.updateById(task);
+        return taskResult(outbound, task);
+    }
+
+    @Transactional
+    public DeliveryResponses.PdaTask completePda(String customerId, String taskNo) {
+        OutboundPdaTask task = pdaTasks.lockByNo(customerId, taskNo); if (task == null) throw notFound("PDA task not found");
+        OutboundOrder outbound = outboundOrders.selectById(task.getOutboundOrderId());
+        List<OutboundPalletItem> items = outboundPallets.findByOutbound(customerId, outbound.getId());
+        if (items.stream().anyMatch(i -> value(i.getPickedPackageCount()) < value(i.getPackageCount()))) throw conflict("All outbound pallets must be picked before completion");
+        task.setStatus("COMPLETED"); task.setCompletedAt(LocalDateTime.now()); task.setUpdatedAt(LocalDateTime.now()); pdaTasks.updateById(task); outbound.setStatus("OUTBOUNDED"); outbound.setUpdatedAt(LocalDateTime.now()); outboundOrders.updateById(outbound); return taskResult(outbound, task);
+    }
+
+    @Transactional
+    public void cancelOutbound(String customerId, String operatorId, String outboundNo, DeliveryRequests.Cancel request) {
+        OutboundOrder outbound = outboundOrders.lockByNo(customerId, outboundNo);
+        if (outbound == null) throw notFound("Outbound order not found");
+        if ("CANCELLED".equals(outbound.getStatus())) return;
+        List<OutboundPalletItem> outboundItems = outboundPallets.findByOutbound(customerId, outbound.getId());
+        if (outboundItems.isEmpty() || outboundItems.stream().anyMatch(i -> !"PICKED".equals(i.getStatus())))
+            throw conflict("Outbound order can only be cancelled after picking is completed");
+        DeliveryOrder existingDelivery = deliveryOrders.lockByOutbound(customerId, outbound.getId());
+        if (existingDelivery != null && !"WAIT_DELIVERY".equals(existingDelivery.getStatus()))
+            throw conflict("Outbound order cannot be cancelled while delivery is in progress");
+        LocalDateTime now = LocalDateTime.now();
+        for (OutboundPdaPick pick : pdaPicks.findByOutbound(customerId, outbound.getId())) {
+            inventoryCommands.adjust(customerId, operatorId,
+                new InventoryCommandRequests.Adjustment(pick.getInventoryPositionId(), pick.getPackages(), "OUTBOUND_CANCEL",
+                    outbound.getOutboundNo(), outbound.getOutboundNo() + ":CANCEL:" + pick.getId(), request.reason()));
+            OutboundPalletItem pickedItem = outboundItems.stream().filter(i -> Objects.equals(i.getId(), pick.getOutboundPalletItemId())).findFirst().orElse(null);
+            DropshipOrderProfile profile = dropshipProfiles.findPosition(customerId, pick.getInventoryPositionId());
+            if (profile != null && pickedItem != null) dropshipSkuInventory.restore(customerId, profile.getId(), pickedItem.getSkuCode(), pick.getPackages());
+        }
+        dropshipCartons.restoreOutbound(customerId, outbound.getOutboundNo());
+        DeliveryOrder delivery = existingDelivery;
+        if (delivery != null) { delivery.setStatus("CANCELLED"); delivery.setUpdatedAt(now); deliveryOrders.updateById(delivery); }
+        outbound.setStatus("CANCELLED"); outbound.setUpdatedAt(now); outboundOrders.updateById(outbound);
+        for (OutboundPalletItem item : outboundItems) { item.setStatus("CANCELLED"); outboundPallets.updateById(item); }
+        if (delivery != null) {
+            for (LastlegOrder order : tailOrders.selectList(new LambdaQueryWrapper<LastlegOrder>().eq(LastlegOrder::getCustomerId, customerId).eq(LastlegOrder::getOutboundOrderNo, outboundNo))) {
+                String from = order.getCurrentStatus(); order.setCurrentStatus("RECEIVED"); order.setSubOrderStatus(null); order.setOutboundOrderNo(null); order.setDeliveryOrderNo(null); order.setUpdatedAt(now); tailOrders.updateById(order);
+                LastlegOrderStatusHistory history = new LastlegOrderStatusHistory(); history.setCustomerId(customerId); history.setOrderId(order.getId()); history.setFromStatus(from); history.setToStatus("RECEIVED"); history.setEventId("CANCEL_OUTBOUND:" + outboundNo); history.setRemark(request.reason().trim()); history.setCreatedAt(now); histories.insert(history);
+            }
+        }
+    }
+
+    public List<DeliveryResponses.PdaTask> pdaTasks(String customerId, String status) { return pdaTasks.list(customerId, StringUtils.hasText(status) ? status : null).stream().map(task -> taskResult(outboundOrders.selectById(task.getOutboundOrderId()), task)).toList(); }
+
+    private DeliveryResponses.PdaTask taskResult(OutboundOrder outbound, OutboundPdaTask task) { return new DeliveryResponses.PdaTask(task.getId(), task.getTaskNo(), task.getStatus(), outbound.getOutboundNo(), task.getPushedAt(), task.getCompletedAt()); }
+    private String outboundNo(Long id) { OutboundOrder value = outboundOrders.selectById(id); return value == null ? "" : value.getOutboundNo(); }
+    private int value(Integer value) { return value == null ? 0 : value; }
+    private long value(Long value) { return value == null ? 0L : value; }
+
     public PageResult<DeliveryResponses.OutboundRow> outboundPage(String customerId, DeliveryRequests.Query query) {
         Page<OutboundOrder> page = outboundOrders.selectPage(new Page<>(query.page(), query.size()),
-            new LambdaQueryWrapper<OutboundOrder>().eq(OutboundOrder::getCustomerId, customerId)
+            new LambdaQueryWrapper<OutboundOrder>().eq(StringUtils.hasText(customerId), OutboundOrder::getCustomerId, customerId)
                 .like(StringUtils.hasText(query.documentNo()), OutboundOrder::getOutboundNo, query.documentNo())
                 .eq(StringUtils.hasText(query.warehouseId()), OutboundOrder::getOverseasWarehouseId, query.warehouseId())
                 .eq(StringUtils.hasText(query.status()), OutboundOrder::getStatus, query.status())
@@ -141,21 +326,34 @@ public class DeliveryTransferService {
 
     public PageResult<DeliveryResponses.DeliveryRow> deliveryPage(String customerId, DeliveryRequests.Query query) {
         Page<DeliveryOrder> page = deliveryOrders.selectPage(new Page<>(query.page(), query.size()),
-            new LambdaQueryWrapper<DeliveryOrder>().eq(DeliveryOrder::getCustomerId, customerId)
+            new LambdaQueryWrapper<DeliveryOrder>().eq(StringUtils.hasText(customerId), DeliveryOrder::getCustomerId, customerId)
                 .like(StringUtils.hasText(query.documentNo()), DeliveryOrder::getDeliveryNo, query.documentNo())
                 .eq(StringUtils.hasText(query.warehouseId()), DeliveryOrder::getOverseasWarehouseId, query.warehouseId())
                 .eq(StringUtils.hasText(query.status()), DeliveryOrder::getStatus, query.status())
+                .like(StringUtils.hasText(query.dispatchNo()), DeliveryOrder::getDispatchNo, query.dispatchNo())
+                .like(StringUtils.hasText(query.waybillNo()), DeliveryOrder::getWaybillNo, query.waybillNo())
+                .like(StringUtils.hasText(query.vehiclePlate()), DeliveryOrder::getVehiclePlate, query.vehiclePlate())
+                .like(StringUtils.hasText(query.driverName()), DeliveryOrder::getDriverName, query.driverName())
+                .eq(StringUtils.hasText(query.deliveryMethod()), DeliveryOrder::getDeliveryMethod, query.deliveryMethod())
+                .ge(query.plannedFrom() != null, DeliveryOrder::getPlannedDeliveryAt, query.plannedFrom())
+                .le(query.plannedTo() != null, DeliveryOrder::getPlannedDeliveryAt, query.plannedTo())
                 .orderByDesc(DeliveryOrder::getCreatedAt));
         return page(page, page.getRecords().stream().map(this::deliveryRow).toList());
     }
 
-    public DeliveryResponses.OutboundDetail deliveryDetail(String customerId, String deliveryNo,
+    public DeliveryResponses.DeliveryDetail deliveryDetail(String customerId, String deliveryNo) {
-                                                             DeliveryRequests.PalletQuery query) {
         DeliveryOrder delivery = deliveryOrders.findByNo(customerId, deliveryNo);
         if (delivery == null) throw notFound("Delivery order not found");
-        OutboundOrder outbound = outboundOrders.selectById(delivery.getOutboundOrderId());
+        List<DispatchItem> items = dispatchItems.findByDispatchOrder(customerId, delivery.getDispatchOrderId());
-        if (outbound == null || !customerId.equals(outbound.getCustomerId())) throw notFound("Outbound order not found");
+        List<Long> orderIds = items.stream().map(DispatchItem::getOrderId).filter(Objects::nonNull).distinct().toList();
-        return outboundDetail(customerId, outbound.getOutboundNo(), query);
+        Map<Long, LastlegOrder> ordersById = orderIds.isEmpty() ? Map.of() : tailOrders.selectBatchIds(orderIds).stream()
+            .filter(order -> customerId.equals(order.getCustomerId())).collect(java.util.stream.Collectors.toMap(LastlegOrder::getId, order -> order));
+        List<LastlegOrderDetail> details = orderIds.isEmpty() ? List.of() : tailOrderDetails.selectList(
+            new LambdaQueryWrapper<LastlegOrderDetail>().eq(LastlegOrderDetail::getCustomerId, customerId).in(LastlegOrderDetail::getOrderId, orderIds));
+        List<DeliveryResponses.DeliverySku> skus = details.stream().map(detail -> sku(detail, ordersById.get(detail.getOrderId()))).toList();
+        return new DeliveryResponses.DeliveryDetail(deliveryRow(delivery), skus,
+            deliveryFees.findByDelivery(customerId, delivery.getId()).stream().map(this::feeRow).toList(),
+            deliveryOperations.findByDelivery(customerId, delivery.getId()).stream().map(this::operationRow).toList());
     }
 
     private void bindTailOrders(String customerId, List<DispatchItem> items, String outboundNo, String deliveryNo,
@@ -180,7 +378,7 @@ public class DeliveryTransferService {
             order.setDeliveryOrderNo(deliveryNo); order.setCurrentStatus("WAIT_OUTBOUND"); order.setUpdatedAt(now);
             order.setSubOrderStatus("OUTBOUND:WAIT_OUTBOUND;DELIVERY:WAIT_DELIVERY");
             tailOrders.updateById(order);
-            LastlegOrderStatusHistory history = new LastlegOrderStatusHistory(); history.setOrderId(order.getId());
+            LastlegOrderStatusHistory history = new LastlegOrderStatusHistory(); history.setCustomerId(customerId); history.setOrderId(order.getId());
             history.setFromStatus(from); history.setToStatus("WAIT_OUTBOUND");
             history.setEventId("TRANSFER_DELIVERY:" + deliveryNo);
             history.setRemark(StringUtils.hasText(remark) ? remark.trim() : "Transferred to outbound and delivery documents");
@@ -198,7 +396,15 @@ public class DeliveryTransferService {
             d.getDeliveryNo(), d.getStatus(), o.getPalletCount(), o.getPackageCount(), replayed);
     }
     private DeliveryResponses.OutboundRow outboundRow(OutboundOrder o) { return new DeliveryResponses.OutboundRow(o.getId(), o.getOutboundNo(), o.getDispatchNo(), o.getOverseasWarehouseId(), o.getStatus(), o.getPalletCount(), o.getPackageCount(), o.getCreatedAt()); }
-    private DeliveryResponses.DeliveryRow deliveryRow(DeliveryOrder d) { return new DeliveryResponses.DeliveryRow(d.getId(), d.getDeliveryNo(), d.getOutboundNo(), d.getDispatchNo(), d.getOverseasWarehouseId(), d.getStatus(), d.getPalletCount(), d.getPackageCount(), d.getCreatedAt()); }
+    private DeliveryResponses.DeliveryRow deliveryRow(DeliveryOrder d) { return new DeliveryResponses.DeliveryRow(d.getId(), d.getCustomerId(), d.getCustomerName(), d.getDeliveryNo(), d.getOutboundNo(), d.getDispatchNo(), d.getOverseasWarehouseId(), d.getOverseasWarehouseName(), d.getStatus(), d.getWaybillNo(), d.getDeliveryMethod(), d.getCarrierName(), d.getPickupMethod(), d.getLoadingType(), d.getVehicleType(), d.getVehicleSize(), d.getVehiclePlate(), d.getDriverName(), d.getDriverPhone(), d.getAppointmentAccount(), d.getSellerName(), value(d.getPalletCount()), value(d.getPackageCount()), d.getTotalWeightKg(), d.getTotalVolumeCbm(), d.getPlannedDeliveryAt(), d.getDispatchedAt(), d.getExpectedArrivalAt(), d.getSignedAt(), d.getRemark(), d.getCreatedAt()); }
+    private DeliveryResponses.DeliverySku sku(LastlegOrderDetail d, LastlegOrder order) { return new DeliveryResponses.DeliverySku(order == null ? null : order.getInboundCode(), order == null ? null : order.getCustomerName(), d.getDestinationWarehouseCode(), null, d.getShipmentNo(), d.getFbaTrackingNo(), d.getSkuCode(), firstText(d.getProductNameZh(), d.getProductNameEn()), value(d.getPackageCount()), d.getGrossWeightKg(), d.getVolumeCbm()); }
+    private DeliveryResponses.DeliveryFeeRow feeRow(DeliveryFee f) { return new DeliveryResponses.DeliveryFeeRow(f.getId(), f.getFeeDirection(), f.getFeeType(), f.getCurrency(), f.getAmount(), f.getRemark()); }
+    private DeliveryResponses.DeliveryOperationRow operationRow(DeliveryOperation o) { return new DeliveryResponses.DeliveryOperationRow(o.getId(), o.getCreatedAt(), o.getOperationNode(), firstText(o.getOperatorName(), o.getOperatorId()), o.getResult()); }
+    private void recordOperation(String customerId, Long deliveryId, String operatorId, String node, String result, LocalDateTime now) { DeliveryOperation operation = new DeliveryOperation(); operation.setCustomerId(customerId); operation.setDeliveryOrderId(deliveryId); operation.setOperationNode(node); operation.setOperatorId(operatorId); operation.setOperatorName(operatorId); operation.setResult(result); operation.setCreatedAt(now); deliveryOperations.insert(operation); }
+    private LastlegOrder firstTailOrder(String customerId, List<DispatchItem> items) { return items.stream().map(DispatchItem::getOrderId).filter(Objects::nonNull).map(tailOrders::selectById).filter(Objects::nonNull).filter(order -> customerId.equals(order.getCustomerId())).findFirst().orElse(null); }
+    private BigDecimal totalWeight(String customerId, List<DispatchItem> items) { List<Long> ids = items.stream().map(DispatchItem::getOrderId).filter(Objects::nonNull).distinct().toList(); if (ids.isEmpty()) return BigDecimal.ZERO; return tailOrderDetails.selectList(new LambdaQueryWrapper<LastlegOrderDetail>().eq(LastlegOrderDetail::getCustomerId, customerId).in(LastlegOrderDetail::getOrderId, ids)).stream().map(LastlegOrderDetail::getGrossWeightKg).filter(Objects::nonNull).reduce(BigDecimal.ZERO, BigDecimal::add); }
+    private static String trim(String value) { return StringUtils.hasText(value) ? value.trim() : null; }
+    private static String firstText(String primary, String fallback) { return StringUtils.hasText(primary) ? primary.trim() : trim(fallback); }
     private static <T> PageResult<T> page(Page<?> page, List<T> records) { return new PageResult<>(records, page.getCurrent(), page.getSize(), page.getTotal(), page.getPages()); }
     private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT, message); }
     private static ResponseStatusException notFound(String message) { return new ResponseStatusException(HttpStatus.NOT_FOUND, message); }

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

@@ -44,6 +44,7 @@ import java.util.Set;
 
 @Service
 public class CargoDiscardService {
+    @Resource private com.baiyue.lastleg.service.LastlegOrderNoGenerator orderNoGenerator;
     public static final String APPROVAL_PERMISSION = "lastleg:cargo-discard:approve";
     public static final String PENDING_REVIEW = "PENDING_REVIEW";
     public static final String APPROVED = "APPROVED";
@@ -105,7 +106,7 @@ public class CargoDiscardService {
         LocalDateTime now = LocalDateTime.now();
         CargoDiscardApplication application = new CargoDiscardApplication();
         application.setId(IdWorker.getId()); application.setCustomerId(customerId);
-        application.setDiscardNo("FH" + now.format(DateTimeFormatter.BASIC_ISO_DATE) + application.getId());
+        application.setDiscardNo(orderNoGenerator.next("DISCARD", warehouseId, application.getId()));
         application.setOverseasWarehouseId(warehouseId); application.setOverseasWarehouseName(warehouseName);
         application.setInboundCodes(orderCache.values().stream().map(LastlegOrder::getInboundCode)
             .distinct().sorted().collect(java.util.stream.Collectors.joining(",")));

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

@@ -13,7 +13,6 @@ import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.annotation.Resource;
 import jakarta.validation.Valid;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.http.HttpStatus;
 import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.web.bind.annotation.DeleteMapping;
@@ -27,7 +26,6 @@ import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.server.ResponseStatusException;
 
 @RestController
-@ConditionalOnProperty(name = "lastleg.future-outbound-api.enabled", havingValue = "true")
 @RequestMapping("/api/platform/v1/last-leg/dispatches")
 @Tag(name = "Tail-leg vehicle dispatch")
 public class DispatchController {

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

@@ -7,14 +7,12 @@ import com.baiyue.lastleg.dispatch.pda.dto.DispatchPdaResponses;
 import com.baiyue.lastleg.dispatch.pda.service.DispatchPdaWorkflowService;
 import jakarta.annotation.Resource;
 import jakarta.validation.Valid;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.http.HttpStatus;
 import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.server.ResponseStatusException;
 
 @RestController
-@ConditionalOnProperty(name = "lastleg.future-outbound-api.enabled", havingValue = "true")
 @RequestMapping("/api/pda/v1/last-leg/dispatches/{dispatchNo}")
 public class DispatchPdaController {
     public static final String OPERATE_PERMISSION = "lastleg:pda:operate";

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

@@ -7,7 +7,8 @@ public final class DispatchPdaResponses {
     public record Task(Long id, String taskNo, String dispatchNo, String vehiclePlate, String warehouseId, String status,
                        List<Item> items) {}
     public record Item(Long dispatchItemId, String palletNo, String destinationWarehouseCode,
-                       String destinationWarehouseName, String fbaWarehouseCode, int scheduledPackages,
+                       String destinationWarehouseName, String fbaWarehouseCode, String warehouseRouteLabel,
+                       int scheduledPackages,
                        long pickedPackages, List<Position> positions) {}
     public record Position(Long id, Long balanceId, long availablePackages, long allocatedPackages,
                            long pickedPackages) {}

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

@@ -119,6 +119,11 @@ public class DispatchPdaWorkflowService {
         inventory.pick(customerId, operatorId, new InventoryCommandRequests.Move(request.positionId(),
             request.packages(), order.getDispatchNo(), order.getDispatchNo(), null,
             keyBase + ":PICK", request.remark()));
+        // A successful PDA scan is the inventory deduction point. Departure only
+        // changes outbound/dispatch facts and must not deduct the same quantity again.
+        inventory.ship(customerId, operatorId, new InventoryCommandRequests.Move(request.positionId(),
+            request.packages(), order.getDispatchNo(), order.getDispatchNo(), null,
+            keyBase + ":SHIP", request.remark()));
         DispatchPdaPick pick = new DispatchPdaPick();
         pick.setId(IdWorker.getId()); pick.setCustomerId(customerId); pick.setTaskId(task.getId());
         pick.setDispatchItemId(itemId); pick.setInventoryPositionId(request.positionId()); pick.setPackages(request.packages());
@@ -149,6 +154,14 @@ public class DispatchPdaWorkflowService {
         if (replay != null) return read(replay, DispatchPdaResponses.PickingCompleted.class).withReplay();
         requireVehicle(order);
         DispatchPdaTask task = tasks.lockByDispatch(customerId, order.getId());
+        if (task != null && "COMPLETED".equals(task.getStatus())) {
+            List<DispatchItem> completedItems = items.findByDispatchOrder(customerId, order.getId());
+            long planned = completedItems.stream().map(DispatchItem::getPackageCount).filter(Objects::nonNull)
+                .mapToLong(Integer::longValue).sum();
+            long picked = picks.listTask(customerId, task.getId()).stream().mapToLong(p -> n(p.getPackages())).sum();
+            return new DispatchPdaResponses.PickingCompleted(order.getDispatchNo(), order.getStatus(), planned,
+                picked, Math.max(0, planned - picked), picked < planned, true);
+        }
         if (task == null || !("PDA_PENDING".equals(task.getStatus()) || "PICKING".equals(task.getStatus()))) {
             throw conflict("Dispatch PDA task is not available for completion");
         }
@@ -197,14 +210,7 @@ public class DispatchPdaWorkflowService {
         }
         List<DispatchPdaPick> dispatchPicks = picks.listTask(customerId, task.getId());
         if (dispatchPicks.isEmpty()) throw conflict("Dispatch has no PDA picks to ship");
-        long shipped = 0;
+        long shipped = dispatchPicks.stream().mapToLong(p -> n(p.getPackages())).sum();
-        for (DispatchPdaPick pick : dispatchPicks) {
-            String key = "DISPATCH:" + order.getDispatchNo() + ":PICK:" + pick.getId() + ":SHIP";
-            inventory.ship(customerId, operatorId, new InventoryCommandRequests.Move(
-                pick.getInventoryPositionId(), n(pick.getPackages()),
-                outbound.getOutboundNo(), outbound.getOutboundNo(), null, key, request.remark()));
-            shipped += n(pick.getPackages());
-        }
         LocalDateTime now = LocalDateTime.now();
         pickAttribution.depart(customerId, outbound.getOutboundNo(), order.getDispatchNo(), dispatchPicks, now);
         outbound.setStatus("OUTBOUNDED");
@@ -227,7 +233,8 @@ public class DispatchPdaWorkflowService {
             List<InventoryPosition> palletPositions = item.getWarehousePalletId() == null ? List.of()
                 : positions.listPallet(customerId, item.getWarehousePalletId());
             values.add(new DispatchPdaResponses.Item(item.getId(), item.getPalletNo(), item.getDestinationWarehouseCode(),
-                item.getDestinationWarehouseName(), item.getFbaWarehouseCode(), item.getPackageCount(),
+                item.getDestinationWarehouseName(), item.getFbaWarehouseCode(),
+                warehouseRouteLabel(item.getFbaWarehouseCode(), item.getDestinationWarehouseCode()), item.getPackageCount(),
                 picks.totalItem(customerId, task.getId(), item.getId()), palletPositions.stream().map(p ->
                 new DispatchPdaResponses.Position(p.getId(), p.getBalanceId(), n(p.getAvailablePackages()),
                     n(p.getAllocatedPackages()), n(p.getPickedPackages()))).toList()));
@@ -270,6 +277,12 @@ public class DispatchPdaWorkflowService {
     private String json(Object value) { try { return objectMapper.writeValueAsString(value); } catch (Exception e) { throw new IllegalStateException(e); } }
     private static long n(Long value) { return value == null ? 0 : value; }
     private static long n(Integer value) { return value == null ? 0 : value; }
+    static String warehouseRouteLabel(String originalFbaWarehouseCode, String destinationWarehouseCode) {
+        String original = trim(originalFbaWarehouseCode);
+        String destination = trim(destinationWarehouseCode);
+        return original != null && destination != null && !original.equalsIgnoreCase(destination)
+            ? original + " -> " + destination : null;
+    }
     private static String trim(String value) { return value == null || value.trim().isEmpty() ? null : value.trim(); }
     private static String required(String value, String message) { String result = trim(value); if (result == null) throw new ResponseStatusException(HttpStatus.BAD_REQUEST, message); return result; }
     private static ResponseStatusException conflict(String message) { return new ResponseStatusException(HttpStatus.CONFLICT, message); }

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

@@ -84,6 +84,7 @@ public class DispatchPickOrderAttributionService {
             long shipped = value(before.getShippedPackageCount()) + entry.getValue();
             String to = shipped == value(before.getPackageCount()) ? "COMPLETED" : "PARTIALLY_SHIPPED";
             LastlegOrderStatusHistory row = new LastlegOrderStatusHistory();
+            row.setCustomerId(customerId);
             row.setOrderId(entry.getKey());
             row.setFromStatus(before.getCurrentStatus());
             row.setToStatus(to);

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

@@ -31,6 +31,7 @@ import org.springframework.web.server.ResponseStatusException;
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
+import com.baiyue.lastleg.service.LastlegOrderNoGenerator;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
@@ -48,6 +49,7 @@ public class DispatchService {
     @Resource private DispatchDraftMapper drafts;
     @Resource private DispatchDraftContainerMapper draftContainers;
     @Resource private DispatchCandidateMapper candidates;
+    @Resource private LastlegOrderNoGenerator orderNoGenerator;
 
     public String resolveCustomerScopeForPlans(List<Long> planIds) {
         return requireSingleCustomerScope(candidates.findCustomerScopesByPlanIds(normalizeIds(planIds, "Plan IDs")),
@@ -239,7 +241,7 @@ public class DispatchService {
         DispatchOrder dispatch = new DispatchOrder();
         dispatch.setId(IdWorker.getId());
         dispatch.setCustomerId(customerId);
-        dispatch.setDispatchNo("PC" + now.format(DateTimeFormatter.BASIC_ISO_DATE) + dispatch.getId());
+        dispatch.setDispatchNo(orderNoGenerator.next("DISPATCH", selected.get(0).overseasWarehouseId(), dispatch.getId()));
         dispatch.setOverseasWarehouseId(selected.get(0).overseasWarehouseId());
         dispatch.setOverseasWarehouseName(selected.get(0).overseasWarehouseName());
         dispatch.setRoute(StringUtils.hasText(request.route()) ? request.route().trim() : route(selected));

lastleg-service/src/main/java/com/baiyue/lastleg/dropship/mapper/DropshipCartonMapper.java

@@ -15,4 +15,8 @@ public interface DropshipCartonMapper extends BaseMapper<DropshipCarton> {
 
     @Select("SELECT * FROM ll_dropship_carton WHERE customer_id=#{customerId} AND order_id=#{orderId} ORDER BY profile_id,carton_sequence")
     List<DropshipCarton> listOrder(@Param("customerId") String customerId, @Param("orderId") Long orderId);
+    @Select("SELECT * FROM ll_dropship_carton WHERE customer_id=#{customerId} AND profile_id=#{profileId} AND sku_code=#{sku} AND status='AVAILABLE' ORDER BY carton_sequence LIMIT #{packages} FOR UPDATE")
+    List<DropshipCarton> lockAvailable(@Param("customerId") String customerId, @Param("profileId") Long profileId, @Param("sku") String sku, @Param("packages") long packages);
+    @Update("UPDATE ll_dropship_carton SET status='AVAILABLE', outbound_order_no=NULL, updated_at=NOW(3) WHERE customer_id=#{customerId} AND outbound_order_no=#{outboundNo} AND status='SHIPPED'")
+    int restoreOutbound(@Param("customerId") String customerId, @Param("outboundNo") String outboundNo);
 }

lastleg-service/src/main/java/com/baiyue/lastleg/dropship/mapper/DropshipOrderProfileMapper.java

@@ -9,4 +9,6 @@ import java.util.List;
 public interface DropshipOrderProfileMapper extends BaseMapper<DropshipOrderProfile> {
     @Select("SELECT * FROM ll_dropship_order_profile WHERE customer_id=#{customerId} AND order_id=#{orderId} ORDER BY source_pallet_no")
     List<DropshipOrderProfile> listOrder(@Param("customerId") String customerId, @Param("orderId") Long orderId);
+    @Select("SELECT * FROM ll_dropship_order_profile WHERE customer_id=#{customerId} AND inventory_position_id=#{positionId} LIMIT 1")
+    DropshipOrderProfile findPosition(@Param("customerId") String customerId, @Param("positionId") Long positionId);
 }

lastleg-service/src/main/java/com/baiyue/lastleg/dropship/mapper/DropshipSkuInventoryMapper.java

@@ -6,6 +6,7 @@ import com.baiyue.lastleg.dropship.entity.DropshipSkuInventory;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.Select;
+import org.apache.ibatis.annotations.Update;
 
 import java.util.List;
 
@@ -13,4 +14,8 @@ import java.util.List;
 public interface DropshipSkuInventoryMapper extends BaseMapper<DropshipSkuInventory> {
     @Select("SELECT * FROM ll_dropship_sku_inventory WHERE customer_id=#{customerId} AND order_id=#{orderId} ORDER BY profile_id,sku_code")
     List<DropshipSkuInventory> listOrder(@Param("customerId") String customerId, @Param("orderId") Long orderId);
+    @Update("UPDATE ll_dropship_sku_inventory SET package_count=package_count-#{packages},updated_at=NOW(3) WHERE customer_id=#{customerId} AND profile_id=#{profileId} AND sku_code=#{sku} AND package_count>=#{packages}")
+    int deduct(@Param("customerId") String customerId, @Param("profileId") Long profileId, @Param("sku") String sku, @Param("packages") long packages);
+    @Update("UPDATE ll_dropship_sku_inventory SET package_count=package_count+#{packages},updated_at=NOW(3) WHERE customer_id=#{customerId} AND profile_id=#{profileId} AND sku_code=#{sku}")
+    int restore(@Param("customerId") String customerId, @Param("profileId") Long profileId, @Param("sku") String sku, @Param("packages") long packages);
 }

lastleg-service/src/main/java/com/baiyue/lastleg/dropship/model/DropshipPalletSnapshot.java

@@ -0,0 +1,8 @@
+package com.baiyue.lastleg.dropship.model;
+
+import java.util.List;
+
+public record DropshipPalletSnapshot(String sourcePalletNo, long packageCount,
+                                     List<Sku> skus) {
+    public record Sku(String skuCode, String productName, long packageCount, long productQuantity) {}
+}

lastleg-service/src/main/java/com/baiyue/lastleg/dropship/service/DropshipOrderService.java

@@ -7,6 +7,7 @@ import com.baiyue.lastleg.dropship.mapper.*;
 import com.baiyue.lastleg.entity.LastlegOrder;
 import com.baiyue.lastleg.inboundplan.pda.entity.InboundStockReceipt;
 import com.baiyue.lastleg.mapper.LastlegOrderMapper;
+import com.baiyue.lastleg.dropship.model.DropshipPalletSnapshot;
 import jakarta.annotation.Resource;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
@@ -109,6 +110,21 @@ public class DropshipOrderService {
         return profile;
     }
 
+    @Transactional(readOnly = true)
+    public List<DropshipPalletSnapshot> palletSnapshots(String customerId, Long orderId) {
+        List<DropshipOrderProfile> orderProfiles = profiles.listOrder(customerId, orderId);
+        Map<Long, List<DropshipSkuInventory>> skusByProfile = skuInventory.listOrder(customerId, orderId).stream()
+            .collect(Collectors.groupingBy(DropshipSkuInventory::getProfileId));
+        return orderProfiles.stream().map(profile -> {
+            List<DropshipPalletSnapshot.Sku> skus = skusByProfile.getOrDefault(profile.getId(), List.of()).stream()
+                .map(sku -> new DropshipPalletSnapshot.Sku(sku.getSkuCode(), sku.getProductName(),
+                    value(sku.getPackageCount()), value(sku.getProductQuantity())))
+                .toList();
+            return new DropshipPalletSnapshot(profile.getSourcePalletNo(),
+                skus.stream().mapToLong(DropshipPalletSnapshot.Sku::packageCount).sum(), skus);
+        }).toList();
+    }
+
     @Transactional
     public void activateAfterStockIn(String customerId, Long orderId, Long taskId,
                                      List<InboundStockReceipt> receipts) {
@@ -118,20 +134,18 @@ public class DropshipOrderService {
         if (profilesForOrder.stream().anyMatch(profile -> "ACTIVE".equals(profile.getStatus()))) {
             throw conflict("Dropship pallet activation is incomplete; repair profiles before retrying");
         }
-        Map<Long, List<InboundStockReceipt>> receiptsByPallet = receipts.stream()
+        Map<String, List<InboundStockReceipt>> receiptsByPallet = receipts.stream()
-            .filter(receipt -> receipt.getWarehousePalletId() != null)
+            .filter(receipt -> receipt.getPalletNo() != null)
-            .collect(Collectors.groupingBy(InboundStockReceipt::getWarehousePalletId));
+            .collect(Collectors.groupingBy(InboundStockReceipt::getPalletNo));
         if (receiptsByPallet.size() != profilesForOrder.size()) {
             throw conflict("PDA pallet count does not match dropship source pallet count");
         }
-        List<DropshipOrderProfile> orderedProfiles = profilesForOrder.stream()
-            .sorted(java.util.Comparator.comparing(DropshipOrderProfile::getSourcePalletNo)).toList();
-        List<List<InboundStockReceipt>> orderedReceipts = receiptsByPallet.values().stream()
-            .sorted(java.util.Comparator.comparing(value -> value.get(0).getWarehousePalletId())).toList();
         LocalDateTime now = LocalDateTime.now();
-        for (int index = 0; index < orderedProfiles.size(); index++) {
+        for (DropshipOrderProfile profile : profilesForOrder) {
-            DropshipOrderProfile profile = orderedProfiles.get(index);
+            List<InboundStockReceipt> actual = receiptsByPallet.get(profile.getSourcePalletNo());
-            List<InboundStockReceipt> actual = orderedReceipts.get(index);
+            if (actual == null || actual.isEmpty()) {
+                throw conflict("PDA receipt is missing for dropship source pallet " + profile.getSourcePalletNo());
+            }
             List<DropshipCarton> profileCartons = cartons.listProfile(customerId, profile.getId());
             long expected = profileCartons.size();
             long received = actual.stream().mapToLong(value -> value.getReceivedPackages() == null ? 0 : value.getReceivedPackages()).sum();

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

@@ -1,6 +1,7 @@
 package com.baiyue.lastleg.dto;
 
 import com.baiyue.lastleg.entity.LastlegOrderDetail;
+import com.baiyue.lastleg.entity.LastlegOrderFee;
 
 import java.time.LocalDateTime;
 
@@ -9,7 +10,10 @@ import java.util.List;
 public record LastlegOrderDetailResponse(
     LastlegOrderSummary order,
     List<LastlegOrderDetail> cargo,
-    List<History> statusHistory
+    List<History> statusHistory,
+    List<LastlegOrderFee> fees,
+    List<Operation> operationHistory
 ) {
     public record History(Long id, String fromStatus, String toStatus, String remark, LocalDateTime createdAt) {}
+    public record Operation(Long id, String operationNode, String operatorName, String result, LocalDateTime createdAt) {}
 }

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

@@ -5,7 +5,11 @@ import jakarta.validation.constraints.Min;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotEmpty;
 import jakarta.validation.constraints.Size;
+import jakarta.validation.constraints.DecimalMin;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.NotNull;
 
+import java.math.BigDecimal;
 import java.time.LocalDateTime;
 import java.util.List;
 
@@ -14,8 +18,8 @@ public final class LastlegOrderRequests {
     }
 
     public record Query(
-        @Min(1) long page,
+        @Min(1) Long page,
-        @Min(1) @Max(200) long size,
+        @Min(1) @Max(200) Long size,
         String orderNo,
         String orderType,
         String inboundCode,
@@ -31,8 +35,8 @@ public final class LastlegOrderRequests {
         LocalDateTime createdTo
     ) {
         public Query {
-            if (page == 0) page = 1;
+            if (page == null || page == 0) page = 1L;
-            if (size == 0) size = 20;
+            if (size == null || size == 0) size = 20L;
         }
     }
 
@@ -68,4 +72,30 @@ public final class LastlegOrderRequests {
             return new TransferDestination(List.of(orderId), warehouseId, warehouseCode, warehouseName, remark);
         }
     }
+
+    public record CreateFee(
+        @NotBlank @Size(max = 128) String feeItem,
+        @NotBlank @Pattern(regexp = "[A-Z]{3}") String currency,
+        @NotNull @DecimalMin(value = "0.01") BigDecimal amount,
+        @NotBlank @Pattern(regexp = "PENDING_REVIEW|APPROVED|REJECTED") String status,
+        @Size(max = 500) String supplierDescription
+    ) {
+    }
+
+    public record SetDetained(
+        @NotNull Boolean detained,
+        @NotBlank @Size(max = 500) String remark
+    ) {
+    }
+
+    public record SetPalletMergeRequired(
+        @NotNull Boolean palletMergeRequired
+    ) {
+    }
+
+    public record SetPalletMergeBatch(
+        @NotEmpty @Size(max = 200) List<Long> orderIds,
+        @NotNull Boolean palletMergeRequired
+    ) {
+    }
 }

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

@@ -4,6 +4,7 @@ import io.swagger.v3.oas.annotations.media.Schema;
 
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
+import java.util.List;
 
 @Schema(description = "按入仓单编码粒度展示的尾程订单列表行")
 public record LastlegOrderSummary(
@@ -40,6 +41,9 @@ public record LastlegOrderSummary(
     String relabelOrderNo,
     String relabelStatus,
     String palletMergeFlag,
+    String palletMergeBatchId,
+    @Schema(description = "同一合托组内其他来源入仓单的入仓码")
+    List<String> palletMergeInboundNos,
     String currentStatus,
     String subOrderStatus,
     String privateRemark,

lastleg-service/src/main/java/com/baiyue/lastleg/entity/LastlegOrder.java

@@ -52,6 +52,7 @@ public class LastlegOrder {
     private String relabelOrderNo;
     private String relabelStatus;
     private String palletMergeFlag;
+    private String palletMergeBatchId;
     private String currentStatus;
     private String subOrderStatus;
     private String privateRemark;

lastleg-service/src/main/java/com/baiyue/lastleg/entity/LastlegOrderFee.java

@@ -0,0 +1,25 @@
+package com.baiyue.lastleg.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+@Data
+@TableName("ll_order_fee")
+public class LastlegOrderFee {
+    @TableId(type = IdType.INPUT) private Long id;
+    private String customerId;
+    private Long orderId;
+    private String feeItem;
+    private String currency;
+    private BigDecimal amount;
+    private String status;
+    private String supplierDescription;
+    private String createdBy;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}

lastleg-service/src/main/java/com/baiyue/lastleg/entity/LastlegOrderOperationLog.java

@@ -0,0 +1,20 @@
+package com.baiyue.lastleg.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Data
+@TableName("ll_order_operation_log")
+public class LastlegOrderOperationLog {
+    @TableId(type = IdType.INPUT) private Long id;
+    private String customerId;
+    private Long orderId;
+    private String operationNode;
+    private String operatorName;
+    private String result;
+    private LocalDateTime createdAt;
+}

lastleg-service/src/main/java/com/baiyue/lastleg/exceptionorder/controller/ExceptionOrderController.java

@@ -0,0 +1,73 @@
+package com.baiyue.lastleg.exceptionorder.controller;
+
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.common.core.api.PageResult;
+import com.baiyue.common.security.AuthenticatedUser;
+import com.baiyue.lastleg.exceptionorder.dto.ExceptionOrderRequests;
+import com.baiyue.lastleg.exceptionorder.dto.ExceptionOrderResponses;
+import com.baiyue.lastleg.exceptionorder.service.ExceptionOrderService;
+import jakarta.annotation.Resource;
+import jakarta.validation.Valid;
+import org.springframework.http.HttpStatus;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/platform/v1/last-leg")
+public class ExceptionOrderController {
+    @Resource private ExceptionOrderService service;
+
+    @GetMapping("/exception-orders")
+    public ApiResponse<PageResult<ExceptionOrderResponses.Row>> page(@AuthenticationPrincipal AuthenticatedUser user,
+                                                                     @Valid ExceptionOrderRequests.Query query) {
+        return ApiResponse.success(service.page(scope(user), query));
+    }
+
+    @GetMapping("/exception-orders/resolve")
+    public ApiResponse<ExceptionOrderResponses.Relation> resolve(@AuthenticationPrincipal AuthenticatedUser user,
+                                                                  @RequestParam(required = false) String customerId,
+                                                                  @RequestParam(required = false) String inboundCode,
+                                                                  @RequestParam(required = false) String lastMileOrderNo) {
+        return ApiResponse.success(service.resolve(scope(user), customerId, inboundCode, lastMileOrderNo));
+    }
+
+    @PostMapping("/exception-orders")
+    public ApiResponse<ExceptionOrderResponses.Created> create(@AuthenticationPrincipal AuthenticatedUser user,
+                                                                @Valid @RequestBody ExceptionOrderRequests.Create request) {
+        return ApiResponse.success(service.create(scope(user), operator(user), request));
+    }
+
+    @GetMapping("/delivery-orders/{deliveryNo}/return-inbound-options")
+    public ApiResponse<List<ExceptionOrderResponses.Relation>> returnOptions(@AuthenticationPrincipal AuthenticatedUser user,
+                                                                              @RequestParam(required = false) String customerId,
+                                                                              @PathVariable String deliveryNo) {
+        return ApiResponse.success(service.returnCandidates(requiredScope(user, customerId), deliveryNo));
+    }
+
+    @PostMapping("/delivery-orders/{deliveryNo}/mark-return")
+    public ApiResponse<ExceptionOrderResponses.Created> markReturn(@AuthenticationPrincipal AuthenticatedUser user,
+                                                                   @RequestParam(required = false) String customerId,
+                                                                   @PathVariable String deliveryNo,
+                                                                   @Valid @RequestBody ExceptionOrderRequests.MarkReturn request) {
+        return ApiResponse.success(service.markReturn(requiredScope(user, customerId), operator(user), deliveryNo, request));
+    }
+
+    private String scope(AuthenticatedUser user) {
+        if (user == null || user.tenantId() == null) throw new ResponseStatusException(HttpStatus.UNAUTHORIZED);
+        return "PLATFORM".equals(user.appCode()) && user.tenantId() == 0L ? null : String.valueOf(user.tenantId());
+    }
+
+    private String requiredScope(AuthenticatedUser user, String requestedCustomer) {
+        String own = scope(user);
+        if (own != null) return own;
+        if (requestedCustomer == null || requestedCustomer.isBlank()) throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "请选择客户");
+        return requestedCustomer.trim();
+    }
+
+    private String operator(AuthenticatedUser user) {
+        return user.userId() == null ? user.username() : String.valueOf(user.userId());
+    }
+}