Merge release/test into dev

2026-09-17 16:42:02 +08:00
parent b6a839a3c6 dbbaa44f92
commit 579a4b7353
53 changed files with 864 additions and 162 deletions
@@ -55,12 +55,12 @@
 | 入库单扣货、解除、凭证与历史 | `modules/inbounds/pages/InboundOrdersView.vue`、详情工作区、`modules/inbounds/core/api.ts` | 列表展示服务端 `holdFlag/currentHoldReason` 并支持筛选；详情只按 `canHold/canRelease/actionBlockReason` 开放操作。扣货与解除提交当前 `version`、原因和独立幂等键，可选凭证先按明确客户与入库单上传；历史文件只调用专用下载入口，不把上传成功但未提交命令的文件冒充扣货证据 |
 | 客户专属价格簿、柜级阶梯运费与受控调价 | 列表/上传 `modules/fba-pricing/carrier-rates/pages/CarrierRatesView.vue`，版本详情/仓库映射/确认 `modules/fba-pricing/carrier-rates/pages/CarrierRateDetailView.vue`，路由 `modules/fba-pricing/routes.ts`；`modules/inbounds/fee/`、`modules/unified-orders/components/InboundFeeDetailManager.vue` | 列表与上传后按 `versionId` 进入 `fba-carrier-rate-detail` 独立详情页，价格行只读；回归入口 `modules/fba-pricing/carrier-rates/pages/CarrierRatesView.test.ts`。价格簿页面显式选择公共报价或具体客户；列表、上传、确认只作用于该 `customerId`，不得混合版本。计价优先消费客户专属 ACTIVE 版本，无专属版本才回退公共 ACTIVE；柜级阶梯金额和各客户分摊只展示服务端结果。调整计费量只能在服务端返回的上下 10% 范围内并提交当前费用版本、原因与二次确认；私人仓尾程派送费使用稳定 `PRIVATE_LAST_MILE_DELIVERY` 代码且只对 `PRIVATE` 目的地开放；一件代发须在预装确认前完成试算，计价后保持服务端 `WAIT_PALLETIZE` 状态 |
 | 财务、客户资金账户与柜级公共费用分摊 | `modules/finance/`，继续读该目录 `AGENTS.md`；客户账户 `pages/FinanceCustomerAccountsView.vue`，柜费 `modules/loading-lists/components/ContainerFeesPanel.vue`、`api/containerFees.ts` | `finance/`、`firstleg/`、`file/`、`docs/财务管理/`；实际、冻结、可用余额、授信与流水只消费 Finance 权威结果，充值审核和手工充扣携带版本与幂等键。跨客户公共柜费只按服务端柜内客户/订单事实分摊，金额必须守恒，创建与审核、驳回、调整、作废均整组原子处理 |
-| 货柜双工作台、排柜、预装/装柜清单、真实柜号后补与整柜报关 | 国内 `modules/container-loading/pages/DomesticContainersView.vue`、海外 `OverseasContainersView.vue`，共享详情实现 `ContainerDetailView.vue`；预装详情 `modules/loading-lists/pages/PreloadPlanDetailView.vue`，资料/PDA 证据 `components/ContainerOverviewPanel.vue`，报关 `components/ContainerCustomsPanel.vue` | 国内“送柜报关”只消费 `/containers/domestic` 与服务端 `allowedActions`，承载模拟柜、订舱关联、智能装柜；模拟柜创建选择与智能装柜一致的 9 类计划渠道，未关联订舱前实际渠道为空，订舱关联候选按计划渠道组匹配、装柜清单页签、出口报关和国内出仓；创建柜次时自动生成唯一预装计划，预装详情先调用 `/loading-plans/{planId}/lifecycle`，完成后深链进入国内货柜详情的装柜清单页签，不再注册独立正式清单导航和路由。订舱关联允许真实集装箱号为空，但 PDA 最终完成前必须补齐；全买单柜继续使用 `complete-all-buy`。海外“清关提柜”只消费 `/containers/overseas`，承载船节点、目的港清关、DO/PU、码头车队、提柜和还空；还空截止事实由服务端基于卸柜完成时间加 72 小时计算，前端不重算。两端统一使用 `containerBookingId`，列表范围由服务端 `scope=ACTIVE/HISTORY` 分页，禁止浏览器筛选或本地推导写资格。后端为 `LoadingListService`、`firstleg/customs/container/`、`firstleg/terminaldrayage/`，文件归 `file/` |
+| 货柜双工作台、排柜、预装/装柜清单、真实柜号后补与整柜报关 | 国内 `modules/container-loading/pages/DomesticContainersView.vue`、海外 `OverseasContainersView.vue`，共享详情实现 `ContainerDetailView.vue`；预装详情 `modules/loading-lists/pages/PreloadPlanDetailView.vue`，资料/PDA 证据 `components/ContainerOverviewPanel.vue`，报关 `components/ContainerCustomsPanel.vue` | 国内“送柜报关”只消费 `/containers/domestic` 与服务端 `allowedActions`，承载模拟柜、订舱关联、智能装柜；模拟柜创建选择与智能装柜一致的 9 类计划渠道，未关联订舱前实际渠道为空，订舱关联候选按计划渠道组匹配、装柜清单页签、出口报关和国内出仓；创建柜次时自动生成唯一预装计划，预装详情先调用 `/loading-plans/{planId}/lifecycle`，完成后深链进入国内货柜详情的装柜清单页签，不再注册独立正式清单导航和路由。订舱关联允许真实集装箱号为空，但确认预装和创建 PDA 任务前必须补齐；历史已建但缺号的任务仍可在预装详情首次补录，保存后恢复 PDA 可进入状态；全买单柜继续使用 `complete-all-buy`。海外“清关提柜”只消费 `/containers/overseas`，承载船节点、目的港清关、DO/PU、码头车队和还空；原预约/实际提柜展示位改为整柜预计/实际到仓，预计到仓在列表内人工快捷维护并经海外接口同步整柜尾程订单，实际到仓只读海外 PDA 首次开始收货时间。还空截止事实由服务端基于卸柜完成时间加 72 小时计算，前端不重算。两端统一使用 `containerBookingId`，列表范围由服务端 `scope=ACTIVE/HISTORY` 分页，禁止浏览器筛选或本地推导写资格。后端为 `LoadingListService`、`firstleg/customs/container/`、`firstleg/terminaldrayage/` 和 `lastleg-service/`，文件归 `file/` |
 | 合柜报关 / 同柜不可拆组 | `modules/unified-orders/api/coLoadGroups.ts`、`pages/UnifiedOrdersView.vue`；装柜消费 `modules/container-loading/pages/SmartLoadingWorkbenchView.vue` | 前端只提交订单 ID；Backend `firstleg/loading/coload/` 展开并冻结每票全部可用入仓片段。成员数是入仓片段数，不等于订单票数；只要求同国内仓、同渠道，允许跨客户及不同目的仓港；分配、移除、取消均整组处理 |
 | 全局智能装柜工作台、入仓码候选与箱数分配 | `modules/container-loading/components/SmartLoadingDialog.vue` 内嵌 `pages/GlobalSmartLoadingView.vue`，柜次页 `SmartLoadingWorkbenchView.vue`，以及 `smartLoadingChannelGroups.ts`、`smartLoadingItems.ts`、`api/platformContainerLoading.ts`；全局页当前不注册独立路由 | Backend `firstleg/` 的 `/inbound-candidates`、`/containers`、`/inbound-assignments`、`/plans/{planId}/pending-review-assignments`、`/group-assignments`、`/unpicked-items`。`orderStatuses` 最多四项且未传表示全部未完成状态；候选状态多选覆盖待审核、待测量、待分柜、装柜中，状态只用于筛选展示，按钮资格以服务端 `canAssign` 为准；待审核/待测量可提前占位但不得提前确认预装或启动 PDA。计划箱数编辑上限、已用和未用展示只消费服务端 `totalPackageCount/remainingPackageCount`，不得从候选页或本地规格重新拼算。人工加入允许跨渠道，智能推荐仍按柜次渠道。柜次容量和限重取服务端字段；同柜组作为单卡整组分页、分配和移除，任一成员已拣时整组保留 |
 | 国内货柜履约订舱资料、打印、关联候选与出仓前船期 | `modules/ocean-bookings/` 的 `components/OceanBookingDocumentsPanel.vue`、`OceanBookingPrintDialog.vue`，以及 `modules/container-loading/`、`modules/port-schedules/` | 订舱草稿按当前版本维护资料，放舱后资料与表单只读；打印对草稿与已放舱订舱均开放，按当前已保存资料生成，未填写字段显示“—”。`platformOceanBookings.ts` 的 `/link-candidates` 只消费服务端分页，`containerCount` 是柜型需求 `quantity` 总和；Backend `firstleg/oceanbooking/`、`file/`、`print/`、`firstleg/portschedule/` |
-| 订舱级拖车预约 | `modules/trucking/api/platformTrucking.ts` 的 `/candidates`、`components/TruckAppointmentForm.vue`、`pages/TruckAppointmentCreateView.vue`、`TruckAppointmentsView.vue` | 表单只选择服务端返回的 `RELEASED` 订舱与拖车供应商，不选择或提交客户、柜次、装柜计划或真实集装箱号；提单号和仓库由订舱冻结事实带入。一个订舱最多一张非终态拖车单，重复创建转入现有单继续编辑；PDA 完成不自动推进拖车。附件为平台作用域且不重复提单文件；Backend `TruckAppointmentService`、`truck-appointments-v1.yaml` |
-| 目的港码头拖车与还空预警 | 海外清关提柜工作台/详情 `modules/container-loading/pages/OverseasContainersView.vue`、`OverseasContainerDetailView.vue`，API `modules/container-loading/api/terminalDrayages.ts` | 按 `containerBookingId` 读取服务端状态、`allowedActions` 和历史，不能复用订舱级拖车表单或自行推进状态；实际到港后选择 `ACTIVE + TRUCKING` 车队，再预约提柜、确认实际提柜与实际还柜。还空截止、超时天/小时只展示服务端基于权威卸柜完成时间加 72 小时计算的结果；Backend `firstleg/terminaldrayage/`、`terminal-drayage-v1.yaml` 列表消费 `SEND_PICKUP_EMAIL`，邮件记录通过 `terminalDrayages.ts` 查询与重试；发送及换队成功只提示已入队，发送权限复用码头车队编辑权限。 |
+| 订舱级拖车预约 | `modules/trucking/api/platformTrucking.ts` 的 `/candidates`、`components/TruckAppointmentForm.vue`、`pages/TruckAppointmentCreateView.vue`、`TruckAppointmentsView.vue` | 表单只选择服务端返回的 `RELEASED` 订舱与 `TRUCKING + truckingScope=DOMESTIC` 国内拖车供应商，不选择或提交客户、柜次、装柜计划或真实集装箱号；清关提柜固定选择 `OVERSEAS` 海外车队，类型在供应商主档单选维护；提单号和仓库由订舱冻结事实带入。一个订舱最多一张非终态拖车单，重复创建转入现有单继续编辑；PDA 完成不自动推进拖车。附件为平台作用域且不重复提单文件；Backend `TruckAppointmentService`、`truck-appointments-v1.yaml` |
+| 目的港码头拖车与还空预警 | 海外清关提柜工作台/详情 `modules/container-loading/pages/OverseasContainersView.vue`、`OverseasContainerDetailView.vue`，API `modules/container-loading/api/terminalDrayages.ts`、`containerArrivalTimes.ts` | 与订舱级拖车预约是不同生命周期；按 `containerBookingId` 读取服务端状态、`allowedActions` 和历史，不能复用订舱级拖车表单或自行推进状态。列表“预计到仓”列直接提供人工日期时间选择器，保存时通过 Lastleg 柜级版本和幂等键原子更新该柜全部尾程订单，已有入库计划后禁止修改；“实际到仓”只读 `ll_receiving_container_session.receiving_at`，即海外 PDA 首次开始收货时间。还空截止、超时天/小时只展示服务端基于权威卸柜完成时间加 72 小时计算的结果；Backend `firstleg/terminaldrayage/`、`lastleg-service/`，邮件记录通过 `terminalDrayages.ts` 查询与重试。 |
 | 历史报关协同与国内出仓 | `modules/customs/`、`modules/outbound-dispatch/` | `modules/customs/` 是历史报关案件/清单/代理提交与回执入口；装柜完成后的整柜退税/买单资料从货柜详情进入，不在旧模块复制；Backend `firstleg/outbound/dispatch/`、`firstleg/customs/`、`file/` |
 | 主数据、下载、退避任务重试、审计 | `modules/master-data/`、`modules/downloads/pages/DownloadCenterView.vue`、`modules/audit/` | File 导出任务返回 `attemptCount/maxAttempts/nextRetryAt`；仅失败或已进入自动退避的等待任务显示重试，等待任务重试用于立即执行当前投递，不创建新任务；联查 `warehouse/`、`file/`、`audit-service/` |
 | 海外接柜、入库、库存与库内服务 | `modules/overseas-warehouse/` | `gateway-overseas/`、`lastleg-service/`、`warehouse-overseas-service/`；与排车、出库、派送、异常退回和一件代发共同组成海外仓全流程 |
@@ -1,6 +1,6 @@
 pipeline {
  agent {
-    label "${env.JOB_BASE_NAME?.endsWith('-dev') ? 'java-dev' : 'java-test'}"
+    label "${env.JOB_BASE_NAME?.endsWith('-prod') ? 'java-builder' : (env.JOB_BASE_NAME?.endsWith('-dev') ? 'java-dev' : 'java-test')}"
  }

  environment {
@@ -10,6 +10,7 @@ pipeline {
    REGISTRY_CREDENTIALS = 'gitea-registry-token'
    NODE_BASE_IMAGE = '172.31.198.7:10082/java-project/node:22-alpine'
    NGINX_BASE_IMAGE = '172.31.198.7:10082/java-project/nginx:1.27-alpine'
+    PRODUCTION_IMAGE_REPOSITORY = 'git.buggoglobal.com/html/admin-web'
  }

  options {
@@ -22,6 +23,17 @@ pipeline {
      steps {
        script {
          env.IS_DEVELOPMENT = env.JOB_BASE_NAME?.endsWith('-dev') ? 'true' : 'false'
+          env.IS_PRODUCTION = env.JOB_BASE_NAME?.endsWith('-prod') ? 'true' : 'false'
+          if (env.IS_PRODUCTION == 'true') {
+            sh '''
+              set -eu
+              git fetch --no-tags origin +refs/heads/main:refs/remotes/origin/main
+              test "$(git rev-parse HEAD)" = "$(git rev-parse origin/main)" || {
+                echo "生产部署只允许 origin/main 当前提交；请先合并代码到 main" >&2
+                exit 1
+              }
+            '''
+          }
          env.SOURCE_TAG = sh(script: 'git rev-parse --short=12 HEAD', returnStdout: true).trim()
        }
        sh 'git log -1 --oneline'
@@ -29,7 +41,7 @@ pipeline {
    }

    stage('构建并部署测试前端') {
-      when { expression { env.IS_DEVELOPMENT != 'true' } }
+      when { expression { env.IS_DEVELOPMENT != 'true' && env.IS_PRODUCTION != 'true' } }
      steps {
        withCredentials([usernamePassword(credentialsId: env.REGISTRY_CREDENTIALS, usernameVariable: 'REGISTRY_USER', passwordVariable: 'REGISTRY_PASSWORD')]) {
          sh '''
@@ -50,6 +62,61 @@ pipeline {
      }
    }

+    stage('构建并发布生产镜像') {
+      when { expression { env.IS_PRODUCTION == 'true' } }
+      steps {
+        withCredentials([usernamePassword(credentialsId: env.REGISTRY_CREDENTIALS, usernameVariable: 'REGISTRY_USER', passwordVariable: 'REGISTRY_PASSWORD')]) {
+          sh '''
+            set -eu
+            export DOCKER_CONFIG="${WORKSPACE}@tmp/docker-auth"
+            rm -rf "$DOCKER_CONFIG"
+            mkdir -p "$DOCKER_CONFIG"
+            cleanup_registry() {
+              docker logout git.buggoglobal.com >/dev/null 2>&1 || true
+              rm -rf "$DOCKER_CONFIG"
+            }
+            trap cleanup_registry EXIT HUP INT TERM
+            printf %s "$REGISTRY_PASSWORD" | docker login -u "$REGISTRY_USER" --password-stdin git.buggoglobal.com
+            image="$PRODUCTION_IMAGE_REPOSITORY:$SOURCE_TAG"
+            docker build \
+              --build-arg NODE_IMAGE="$NODE_BASE_IMAGE" \
+              --build-arg NGINX_IMAGE="$NGINX_BASE_IMAGE" \
+              --build-arg VITE_CLIENT_WEB_URL=https://app.buggoglobal.com/ \
+              -t "$image" .
+            docker push "$image"
+          '''
+        }
+      }
+    }
+
+    stage('确认部署生产前端') {
+      when { expression { env.IS_PRODUCTION == 'true' } }
+      steps {
+        input message: "确认将 main 提交 ${env.SOURCE_TAG} 部署到 admin.buggoglobal.com？", ok: '确认部署'
+      }
+    }
+
+    stage('部署生产前端') {
+      when { expression { env.IS_PRODUCTION == 'true' } }
+      steps {
+        lock(resource: 'firstleg-production-admin-web-deploy', inversePrecedence: true) {
+          withCredentials([
+            usernamePassword(credentialsId: 'gitea-production-pull-token', usernameVariable: 'REGISTRY_USER', passwordVariable: 'REGISTRY_PASSWORD'),
+            sshUserPrivateKey(credentialsId: 'firstleg-production-ssh', keyFileVariable: 'TARGET_SSH_KEY', usernameVariable: 'TARGET_SSH_USER'),
+            string(credentialsId: 'firstleg-production-host', variable: 'TARGET_SSH_HOST'),
+            file(credentialsId: 'firstleg-production-known-hosts', variable: 'TARGET_SSH_KNOWN_HOSTS')
+          ]) {
+            withEnv([
+              'TARGET_DEPLOY_DIR=/data/firstleg/deploy/frontend',
+              'TARGET_SSH_TARGET=' + env.TARGET_SSH_USER + '@' + env.TARGET_SSH_HOST
+            ]) {
+              sh "sh scripts/deploy-production.sh admin-web '${env.PRODUCTION_IMAGE_REPOSITORY}' '${env.SOURCE_TAG}' docker-compose.production.yml"
+            }
+          }
+        }
+      }
+    }
+
    stage('构建并部署开发前端') {
      when { expression { env.IS_DEVELOPMENT == 'true' } }
      steps {
@@ -82,7 +149,7 @@ pipeline {
    }

    stage('部署检查') {
-      when { expression { env.IS_DEVELOPMENT != 'true' } }
+      when { expression { env.IS_DEVELOPMENT != 'true' && env.IS_PRODUCTION != 'true' } }
      steps {
        sh '''
          set -eu
@@ -96,7 +163,9 @@ pipeline {
  post {
    failure {
      sh '''
-        if [ "${IS_DEVELOPMENT:-false}" = "true" ]; then
+        if [ "${IS_PRODUCTION:-false}" = "true" ]; then
+          echo "生产部署失败，请查看上方远程部署日志"
+        elif [ "${IS_DEVELOPMENT:-false}" = "true" ]; then
          docker logs --tail=100 admin-web-development || true
        else
          docker compose -f docker-compose.test.yml logs --tail=100 || true
@@ -0,0 +1,20 @@
+name: firstleg-prod-admin-web
+
+services:
+  admin-web:
+    image: ${IMAGE_REPOSITORY:?IMAGE_REPOSITORY is required}:${IMAGE_TAG:?IMAGE_TAG is required}
+    container_name: firstleg-prod-admin-web
+    restart: unless-stopped
+    ports:
+      - "127.0.0.1:${HOST_PORT:-9001}:80"
+    environment:
+      CLIENT_WEB_URL: "https://app.buggoglobal.com/"
+      API_UPSTREAM: "http://gateway:9000"
+      OVERSEAS_API_UPSTREAM: "http://gateway-overseas:9300"
+    networks:
+      - infra-network
+
+networks:
+  infra-network:
+    external: true
+    name: firstleg-prod-infra-network
@@ -11,9 +11,11 @@ services:
    restart: unless-stopped
    ports:
      - "${HOST_PORT:-9001}:80"
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
    environment:
      # Runtime URL used by the secure customer-workbench handoff. Each
      # environment may override it without rebuilding the Admin image.
      CLIENT_WEB_URL: "${CLIENT_WEB_URL:-https://test-app.buggoglobal.com/}"
-      API_UPSTREAM: "http://test-api-cn.buggoglobal.com"
-      OVERSEAS_API_UPSTREAM: "http://test-api-global.buggoglobal.com"
+      API_UPSTREAM: "${API_UPSTREAM:-http://host.docker.internal:9000}"
+      OVERSEAS_API_UPSTREAM: "${OVERSEAS_API_UPSTREAM:-http://host.docker.internal:9300}"
@@ -0,0 +1,93 @@
+#!/usr/bin/env sh
+set -eu
+
+if [ "$#" -ne 4 ]; then
+  echo "用法: $0 <服务名> <镜像仓库> <镜像标签> <Compose 文件>" >&2
+  exit 2
+fi
+
+SERVICE="$1"
+IMAGE_REPOSITORY="$2"
+IMAGE_TAG="$3"
+COMPOSE_FILE="$4"
+IMAGE="$IMAGE_REPOSITORY:$IMAGE_TAG"
+REGISTRY_HOST="${IMAGE_REPOSITORY%%/*}"
+SSH_TARGET="${TARGET_SSH_TARGET:?TARGET_SSH_TARGET 未设置}"
+SSH_KEY="${TARGET_SSH_KEY:?TARGET_SSH_KEY 未设置}"
+SSH_KNOWN_HOSTS="${TARGET_SSH_KNOWN_HOSTS:?TARGET_SSH_KNOWN_HOSTS 未设置}"
+REMOTE_DIR="${TARGET_DEPLOY_DIR:?TARGET_DEPLOY_DIR 未设置}"
+: "${REGISTRY_USER:?REGISTRY_USER 未设置}"
+: "${REGISTRY_PASSWORD:?REGISTRY_PASSWORD 未设置}"
+
+run_ssh() {
+  ssh -i "$SSH_KEY" -o BatchMode=yes -o StrictHostKeyChecking=yes \
+    -o UserKnownHostsFile="$SSH_KNOWN_HOSTS" -o ConnectTimeout=10 "$SSH_TARGET" "$@"
+}
+
+run_scp() {
+  scp -i "$SSH_KEY" -o BatchMode=yes -o StrictHostKeyChecking=yes \
+    -o UserKnownHostsFile="$SSH_KNOWN_HOSTS" -o ConnectTimeout=10 "$@"
+}
+
+run_ssh install -d -m 750 "$REMOTE_DIR"
+REMOTE_COMPOSE="$REMOTE_DIR/docker-compose.$SERVICE.yml"
+run_scp "$COMPOSE_FILE" "$SSH_TARGET:$REMOTE_COMPOSE.tmp"
+run_ssh sh -s -- "$REMOTE_COMPOSE.tmp" "$REMOTE_COMPOSE" <<'REMOTE_PREPARE'
+set -eu
+compose_tmp="$1"
+compose_target="$2"
+chmod 644 "$compose_tmp"
+mv -f "$compose_tmp" "$compose_target"
+REMOTE_PREPARE
+
+printf '%s' "$REGISTRY_PASSWORD" | run_ssh docker login -u "$REGISTRY_USER" --password-stdin "$REGISTRY_HOST"
+trap 'run_ssh docker logout "$REGISTRY_HOST" >/dev/null 2>&1 || true' EXIT HUP INT TERM
+run_ssh docker pull "$IMAGE"
+
+run_ssh sh -s -- "$REMOTE_DIR" "$SERVICE" "$IMAGE_REPOSITORY" "$IMAGE_TAG" <<'REMOTE_DEPLOY'
+set -eu
+remote_dir="$1"
+service="$2"
+image_repository="$3"
+image_tag="$4"
+compose_file="docker-compose.$service.yml"
+project_name="firstleg-prod-$service"
+cd "$remote_dir"
+export IMAGE_REPOSITORY="$image_repository" IMAGE_TAG="$image_tag"
+
+compose() {
+  docker compose --project-name "$project_name" -f "$compose_file" "$@"
+}
+
+container_id="$(compose ps --all --quiet "$service" | head -n 1)"
+previous_image=""
+if [ -n "$container_id" ]; then
+  previous_image="$(docker inspect --format '{{.Config.Image}}' "$container_id")"
+fi
+
+if compose up -d --no-deps --pull never "$service" && \
+   compose exec -T "$service" wget -qO- http://127.0.0.1/healthz >/dev/null; then
+  echo "生产前端部署成功: $image_repository:$image_tag"
+  compose ps "$service"
+  exit 0
+fi
+
+echo "生产前端健康检查失败，准备回滚" >&2
+compose logs --tail=100 "$service" >&2 || true
+case "$previous_image" in
+  "$image_repository:"*) ;;
+  '') echo "首次部署无旧镜像可回滚" >&2; exit 1 ;;
+  *) echo "旧镜像不属于当前应用，拒绝回滚: $previous_image" >&2; exit 1 ;;
+esac
+previous_tag="${previous_image#"$image_repository:"}"
+if [ "$previous_tag" = "$image_tag" ]; then
+  echo "旧镜像与新镜像一致，无法回滚" >&2
+  exit 1
+fi
+docker pull "$previous_image"
+export IMAGE_TAG="$previous_tag"
+compose up -d --no-deps --pull never "$service"
+compose exec -T "$service" wget -qO- http://127.0.0.1/healthz >/dev/null || true
+echo "已回滚至: $previous_image" >&2
+exit 1
+REMOTE_DEPLOY
@@ -5,6 +5,7 @@ import { describe, expect, it } from 'vitest'
 const config = readFileSync(resolve(process.cwd(), 'nginx/default.conf.template'), 'utf8')
 const testCompose = readFileSync(resolve(process.cwd(), 'docker-compose.test.yml'), 'utf8')
 const developmentCompose = readFileSync(resolve(process.cwd(), 'docker-compose.development.yml'), 'utf8')
+const productionCompose = readFileSync(resolve(process.cwd(), 'docker-compose.production.yml'), 'utf8')
 const jenkinsfile = readFileSync(resolve(process.cwd(), 'Jenkinsfile'), 'utf8')
 const dockerfile = readFileSync(resolve(process.cwd(), 'Dockerfile'), 'utf8')

@@ -38,8 +39,11 @@ describe('admin nginx deployment config', () => {
  })

  it('declares an explicit overseas gateway upstream in container deployments', () => {
-    expect(testCompose).toContain('API_UPSTREAM: "http://test-api-cn.buggoglobal.com"')
-    expect(testCompose).toContain('OVERSEAS_API_UPSTREAM: "http://test-api-global.buggoglobal.com"')
+    expect(testCompose).toContain('- "host.docker.internal:host-gateway"')
+    expect(testCompose).toContain('API_UPSTREAM: "${API_UPSTREAM:-http://host.docker.internal:9000}"')
+    expect(testCompose).toContain('OVERSEAS_API_UPSTREAM: "${OVERSEAS_API_UPSTREAM:-http://host.docker.internal:9300}"')
+    expect(testCompose).not.toContain('http://test-api-cn.buggoglobal.com')
+    expect(testCompose).not.toContain('http://test-api-global.buggoglobal.com')
    expect(testCompose).toContain('CLIENT_WEB_URL: "${CLIENT_WEB_URL:-https://test-app.buggoglobal.com/}"')
    expect(testCompose).not.toContain('CLIENT_WEB_URL: "http://8.163.')
    expect(developmentCompose).toContain('CLIENT_WEB_URL: "${CLIENT_WEB_URL:-https://dev-app.buggoglobal.com/}"')
@@ -47,13 +51,17 @@ describe('admin nginx deployment config', () => {
    expect(config).toContain('proxy_set_header Host $proxy_host;')
  })

-  it('runs each deployment on its target node without controller-local SSH files', () => {
-    expect(jenkinsfile).toContain("env.JOB_BASE_NAME?.endsWith('-dev') ? 'java-dev' : 'java-test'")
+  it('keeps local environments on target nodes and uses credential-managed SSH for production', () => {
+    expect(jenkinsfile).toContain("env.JOB_BASE_NAME?.endsWith('-prod') ? 'java-builder'")
    expect(jenkinsfile).toContain("DEVELOPMENT_COMPOSE_PROJECT = 'admin-web'")
    expect(jenkinsfile).toContain('docker compose -p "$DEVELOPMENT_COMPOSE_PROJECT" -f "$DEVELOPMENT_COMPOSE_FILE" up -d')
    expect(jenkinsfile).not.toContain('/var/jenkins_home/.ssh')
    expect(jenkinsfile).not.toContain('docker save')
-    expect(jenkinsfile).not.toMatch(/\bssh\b/)
+    expect(jenkinsfile).toContain("credentialsId: 'firstleg-production-ssh'")
+    expect(jenkinsfile).toContain('git rev-parse origin/main')
+    expect(productionCompose).toContain('127.0.0.1:${HOST_PORT:-9001}:80')
+    expect(productionCompose).toContain('API_UPSTREAM: "http://gateway:9000"')
+    expect(productionCompose).toContain('name: firstleg-prod-infra-network')
  })

  it('uses authenticated internal base images in CI instead of pulling from Docker Hub', () => {
@@ -0,0 +1,20 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { overseasHttp } from '@/shared/api/overseasHttp'
+import { listContainerArrivalTimes, updateContainerExpectedArrival } from './containerArrivalTimes'
+
+vi.mock('@/shared/api/overseasHttp', () => ({ overseasHttp: { post: vi.fn(), put: vi.fn() } }))
+
+describe('container arrival-time overseas API', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('queries visible containers and updates the whole-container expected arrival', async () => {
+    vi.mocked(overseasHttp.post).mockResolvedValue({ code: '200', data: [{ sourceContainerBookingId: '9001', estimatedWarehouseArrivalAt: null, actualWarehouseArrivalAt: null, version: 0 }] })
+    vi.mocked(overseasHttp.put).mockResolvedValue({ code: '200', data: { sourceContainerBookingId: '9001', estimatedWarehouseArrivalAt: '2026-09-25T15:31:00', actualWarehouseArrivalAt: null, version: 1 } } as never)
+
+    await listContainerArrivalTimes(['9001'])
+    await updateContainerExpectedArrival('9001', { estimatedWarehouseArrivalAt: '2026-09-25T15:31:00', expectedVersion: 0 })
+
+    expect(overseasHttp.post).toHaveBeenCalledWith('/platform/v1/last-leg/orders/container-arrival-times/query', { sourceContainerBookingIds: ['9001'] })
+    expect(overseasHttp.put).toHaveBeenCalledWith('/platform/v1/last-leg/orders/container-summaries/9001/expected-arrival', { estimatedWarehouseArrivalAt: '2026-09-25T15:31:00', expectedVersion: 0 }, { headers: { 'Idempotency-Key': expect.stringContaining('container-expected-arrival-9001-') } })
+  })
+})
@@ -0,0 +1,37 @@
+import { overseasHttp } from '@/shared/api/overseasHttp'
+import { unwrapApiResponse, type ApiEnvelope } from '@/shared/api/http'
+
+export interface ContainerArrivalTime {
+  sourceContainerBookingId: string
+  estimatedWarehouseArrivalAt: string | null
+  actualWarehouseArrivalAt: string | null
+  version: number
+}
+
+const queryPath = '/platform/v1/last-leg/orders/container-arrival-times/query'
+
+function operationId(containerBookingId: string) {
+  return `container-expected-arrival-${containerBookingId}-${Date.now()}-${crypto.randomUUID()}`
+}
+
+export async function listContainerArrivalTimes(sourceContainerBookingIds: string[]) {
+  if (!sourceContainerBookingIds.length) return []
+  const response = await overseasHttp.post<ApiEnvelope<ContainerArrivalTime[]>, ApiEnvelope<ContainerArrivalTime[]>>(
+    queryPath,
+    { sourceContainerBookingIds },
+  )
+  return (unwrapApiResponse(response) || []).map((item) => ({ ...item, version: Number(item.version || 0) }))
+}
+
+export async function updateContainerExpectedArrival(
+  sourceContainerBookingId: string,
+  body: { estimatedWarehouseArrivalAt: string; expectedVersion: number; remark?: string },
+) {
+  const response = await overseasHttp.put<ApiEnvelope<ContainerArrivalTime>, ApiEnvelope<ContainerArrivalTime>>(
+    `/platform/v1/last-leg/orders/container-summaries/${encodeURIComponent(sourceContainerBookingId)}/expected-arrival`,
+    body,
+    { headers: { 'Idempotency-Key': operationId(sourceContainerBookingId) } },
+  )
+  const result = unwrapApiResponse(response)
+  return { ...result, version: Number(result.version || 0) }
+}
@@ -159,6 +159,14 @@ function plan(raw: SmartLoadingPlan): SmartLoadingPlan {
      fullPackageCount: numberValue(group.fullPackageCount),
      memberInboundIds: (group.memberInboundIds || []).map(id),
    })),
+    palletMembers: (raw.palletMembers || []).map((pallet) => ({
+      palletId: id(pallet.palletId),
+      members: (pallet.members || []).map((member) => ({
+        ...member,
+        accountId: id(member.accountId), inboundId: id(member.inboundId), orderId: id(member.orderId),
+        availablePackageCount: numberValue(member.availablePackageCount),
+      })),
+    })),
    items: (raw.items || []).map(item),
  }
 }
@@ -57,4 +57,23 @@ describe('OceanBookingLinkDialog', () => {
    expect(wrapper.emitted('linked')).toHaveLength(1)
    wrapper.unmount()
  })
+
+  it('prefills and preserves a real container number recorded before booking linkage', async () => {
+    const existingContainer = { ...container, containerNo: 'MSCU6639870' }
+    const wrapper = mount(OceanBookingLinkDialog, {
+      props: { modelValue: true, container: existingContainer },
+      global: { plugins: [ElementPlus] },
+    })
+    await flushPromises()
+    const vm = wrapper.vm as unknown as { candidateKey: string; containerNo: string; save: () => Promise<void> }
+    expect(vm.containerNo).toBe('MSCU6639870')
+
+    vm.candidateKey = '101:202'
+    await vm.save()
+
+    expect(linkContainerOceanBooking).toHaveBeenCalledExactlyOnceWith('9001', {
+      oceanBookingId: '101', requirementId: '202', containerNo: 'MSCU6639870', expectedVersion: 7,
+    })
+    wrapper.unmount()
+  })
 })
@@ -31,7 +31,7 @@ function close() { emit('update:modelValue', false) }
 async function loadCandidates() {
  const target = props.container
  candidateKey.value = ''
-  containerNo.value = ''
+  containerNo.value = normalizeContainerNo(target?.containerNo)
  candidates.value = []
  error.value = null
  if (!target) return
@@ -0,0 +1,32 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+import SmartLoadingCandidateInbounds from './SmartLoadingCandidateInbounds.vue'
+import type { SmartLoadingCandidate } from '../types'
+
+describe('sealed pallet composition', () => {
+  it('shows the two inbound portions, not the whole pallet count twice', async () => {
+    const candidate = { unitType: 'SEALED_PALLET', inboundCode: 'I180', availablePackageCount: 13,
+      groupMembers: [{ accountId: '1', inboundId: '180', inboundCode: 'I180', availablePackageCount: 3 },
+        { accountId: '1', inboundId: '181', inboundCode: 'I181', availablePackageCount: 10 }] } as SmartLoadingCandidate
+    const wrapper = mount(SmartLoadingCandidateInbounds, { props: { candidate } })
+    expect(wrapper.get('summary').text()).toBe('2 个入仓码 · 展开')
+    expect(wrapper.text()).toContain('I180：3 箱')
+    expect(wrapper.text()).toContain('I181：10 箱')
+    expect(wrapper.text()).not.toContain('13 箱')
+    expect(wrapper.findAll('button')).toHaveLength(0)
+  })
+
+  it('renders the same composition when it comes from an assigned plan pallet', () => {
+    const wrapper = mount(SmartLoadingCandidateInbounds, { props: {
+      sealedPallet: true,
+      fallbackInboundCode: 'I180',
+      members: [
+        { accountId: '1', inboundId: '180', orderId: '280', orderNo: 'O180', inboundCode: 'I180', customerName: '客户', availablePackageCount: 6, orderStatusSnapshot: null, expectedArrivalAt: null },
+        { accountId: '1', inboundId: '181', orderId: '281', orderNo: 'O181', inboundCode: 'I181', customerName: '客户', availablePackageCount: 5, orderStatusSnapshot: null, expectedArrivalAt: null },
+      ],
+    } })
+    expect(wrapper.get('summary').text()).toBe('2 个入仓码 · 展开')
+    expect(wrapper.text()).toContain('I180：6 箱')
+    expect(wrapper.text()).toContain('I181：5 箱')
+  })
+})
@@ -0,0 +1,26 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+import type { SmartLoadingCandidate, SmartLoadingCandidateGroupMember } from '../types'
+
+const props = defineProps<{
+  candidate?: SmartLoadingCandidate
+  members?: SmartLoadingCandidateGroupMember[]
+  sealedPallet?: boolean
+  fallbackInboundCode?: string | null
+}>()
+const displayedMembers = computed(() => props.members || props.candidate?.groupMembers || [])
+const isSealedPallet = computed(() => props.candidate
+  ? props.candidate.unitType === 'SEALED_PALLET'
+  : props.sealedPallet === true)
+const inboundCode = computed(() => props.fallbackInboundCode ?? props.candidate?.inboundCode)
+</script>
+
+<template>
+  <details v-if="isSealedPallet && displayedMembers.length">
+    <summary>{{ displayedMembers.length }} 个入仓码 · 展开</summary>
+    <div v-for="member in displayedMembers" :key="`${member.accountId}:${member.inboundId}`">
+      {{ member.inboundCode || '—' }}：{{ member.availablePackageCount }} 箱
+    </div>
+  </details>
+  <span v-else>{{ inboundCode || '—' }}</span>
+</template>
@@ -6,6 +6,7 @@ import ContainerDetailView from './ContainerDetailView.vue'
 import { getContainer, getContainerOverview, linkContainerOceanBooking } from '../api/platformContainerLoading'
 import { listOceanBookingLinkCandidates } from '@/modules/ocean-bookings'
 import { recordTerminalDrayageEmptyReturn } from '../api/terminalDrayages'
+import { listContainerArrivalTimes } from '../api/containerArrivalTimes'
 import { getContainerOutboundDispatch } from '@/modules/outbound-dispatch'
 import { ref } from 'vue'
 import { getConfirmedLoadingList, getPreloadPlan } from '@/modules/loading-lists'
@@ -22,6 +23,7 @@ vi.mock('@/modules/outbound-dispatch', () => ({ confirmContainerOutboundDispatch
 vi.mock('@/modules/port-schedules', () => ({ CarrierScheduleQueryPanel: { template: '<div />' } }))
 vi.mock('../api/platformContainerLoading', () => ({ getContainer: vi.fn(), getContainerOverview: vi.fn(), linkContainerOceanBooking: vi.fn(), cancelContainerException: vi.fn(), completeContainerClearance: vi.fn(), downloadContainerClearance: vi.fn(), downloadContainerDocument: vi.fn(), getContainerClearance: vi.fn(), markContainerException: vi.fn(), uploadContainerClearance: vi.fn(), uploadContainerDocument: vi.fn(), updateContainerPickupCode: vi.fn() }))
 vi.mock('../api/terminalDrayages', () => ({ recordTerminalDrayageEmptyReturn: vi.fn() }))
+vi.mock('../api/containerArrivalTimes', () => ({ listContainerArrivalTimes: vi.fn() }))

 const base = { id: '9001', cabinetNo: 'CB-1', containerNo: 'MSCU-1', planNo: 'LP-1', planStatus: 'COMPLETED', warehouseName: '义乌仓', destinationWarehouseCode: 'LAX01', destinationWarehouseName: '洛杉矶接柜仓', workbenchStage: 'UNLOADED', statusSummary: { terminalDrayageStatus: 'UNLOADED' }, allowedActions: ['RECORD_EMPTY_RETURN'], terminalDrayage: { containerBookingId: '9001', status: 'UNLOADED', version: 3, fleetSupplierId: '501', fleetSupplierName: '港运车队', pickupAppointmentAt: '2026-09-07T08:00:00', actualPickupAt: '2026-09-07T09:00:00', estimatedEmptyReturnAt: '2026-09-10T10:00:00', actualEmptyReturnAt: null, unloadingCompletedAt: '2026-09-07T10:00:00', emptyReturnWarning: { status: 'PENDING', deadlineAt: '2026-09-10T10:00:00', overdueHours: 0, overdueDays: 0 }, allowedActions: ['RECORD_EMPTY_RETURN'], updatedAt: '2026-09-09T10:00:00' }, actualFacts: { unloadingCompletedAt: '2026-09-07T10:00:00' } }
 const overview = { container: { id: '9001', version: 1 }, loadingPlanId: null, documents: [], exception: { active: false }, timeline: [] }
@@ -51,6 +53,7 @@ describe('ContainerDetailView empty return', () => {
    vi.mocked(getContainerOverview).mockReset().mockResolvedValue(overview as never)
    vi.mocked(getConfirmedLoadingList).mockReset().mockResolvedValue({ planNo: 'LP-1', items: [] } as never)
    vi.mocked(recordTerminalDrayageEmptyReturn).mockReset().mockResolvedValue({ ...base.terminalDrayage, status: 'EMPTY_RETURNED', version: 4, actualEmptyReturnAt: '2026-09-09T12:00:00', allowedActions: [] } as never)
+    vi.mocked(listContainerArrivalTimes).mockReset().mockResolvedValue([{ sourceContainerBookingId: '9001', estimatedWarehouseArrivalAt: '2026-09-25T15:31:00', actualWarehouseArrivalAt: '2026-09-26T09:00:00', version: 0 }])
  })

  it('loads departed gates exactly once when read permission arrives after the container detail', async () => {
@@ -38,6 +38,7 @@ import {
  updateContainerPickupCode,
 } from '../api/platformContainerLoading'
 import { recordTerminalDrayageEmptyReturn } from '../api/terminalDrayages'
+import { listContainerArrivalTimes, type ContainerArrivalTime } from '../api/containerArrivalTimes'
 import type { BusinessDocument, ContainerBookingResource, ContainerOverview, ContainerOverviewDocument, ContainerPlanStatus, ContainerWorkbenchAction, ContainerWorkbenchRow } from '../types'

 const props = withDefaults(defineProps<{ workbench?: 'DOMESTIC' | 'OVERSEAS' }>(), { workbench: 'DOMESTIC' })
@@ -82,6 +83,7 @@ async function rememberWorkbenchTab(tabName: string | number) {
  }
 }
 const workbenchDetail = ref<ContainerWorkbenchRow | null>(null)
+const arrivalTime = ref<ContainerArrivalTime | null>(null)
 const hasAction = (action: ContainerWorkbenchAction) => Boolean(workbenchDetail.value?.allowedActions?.includes(action))
 const canEdit = computed(() => isDomestic.value && access.can('platform:firstleg:container:edit') && hasAction('EDIT_CONTAINER'))
 const canManageCustoms = computed(() => isDomestic.value && access.can('platform:firstleg:customs:manage') && hasAction('MANAGE_CUSTOMS'))
@@ -294,8 +296,13 @@ async function load() {
  if (!containerId.value) return
  loading.value = true; error.value = null; overviewError.value = null
  try {
-    const [resource, aggregate] = await Promise.all([getContainer(containerId.value, props.workbench), getContainerOverview(containerId.value)])
+    const [resource, aggregate, arrivals] = await Promise.all([
+      getContainer(containerId.value, props.workbench),
+      getContainerOverview(containerId.value),
+      isOverseas.value ? listContainerArrivalTimes([containerId.value]) : Promise.resolve([]),
+    ])
    workbenchDetail.value = resource; detail.value = resource; overview.value = aggregate
+    arrivalTime.value = arrivals[0] || null
    if (activeTab.value === 'loading-list' && !canViewCurrentLoadingList.value) activeTab.value = 'overview'
    if (isDomestic.value && activeTab.value === 'loading-list') await loadLoadingDetail(resource, aggregate)
    if (isOverseas.value && resource.planStatus === 'COMPLETED' && canViewLoadingList.value) {
@@ -575,7 +582,7 @@ onMounted(async () => { await load(); if (isOverseas.value && route.query.action

      <section v-if="isOverseas" v-show="activeTab === 'overview'" class="detail-section surface-panel" aria-labelledby="container-overseas-receiving-heading">
        <header class="detail-section__heading"><h2 id="container-overseas-receiving-heading">提柜、卸柜与还空</h2><el-button v-if="canRecordEmptyReturn" type="primary" :loading="emptyReturnSaving" @click="openEmptyReturn">确认还柜</el-button></header>
-        <div class="detail-fields"><dl class="density-fields"><div><dt>码头拖车状态</dt><dd>{{ workbenchDetail?.statusSummary?.terminalDrayageStatus || '—' }}</dd></div><div><dt>码头车队</dt><dd>{{ workbenchDetail?.terminalDrayage?.fleetSupplierName || '—' }}</dd></div><div><dt>预约提柜</dt><dd>{{ formatTime(workbenchDetail?.terminalDrayage?.pickupAppointmentAt) }}</dd></div><div><dt>实际提柜</dt><dd>{{ formatTime(workbenchDetail?.terminalDrayage?.actualPickupAt) }}</dd></div><div><dt>卸柜完成</dt><dd>{{ formatTime((workbenchDetail?.actualFacts?.unloadingCompletedAt || workbenchDetail?.terminalDrayage?.unloadingCompletedAt) as string | null) }}</dd></div><div><dt>实际还柜</dt><dd>{{ formatTime(workbenchDetail?.terminalDrayage?.actualEmptyReturnAt) }}</dd></div></dl></div>
+        <div class="detail-fields"><dl class="density-fields"><div><dt>码头拖车状态</dt><dd>{{ workbenchDetail?.statusSummary?.terminalDrayageStatus || '—' }}</dd></div><div><dt>码头车队</dt><dd>{{ workbenchDetail?.terminalDrayage?.fleetSupplierName || '—' }}</dd></div><div><dt>预计到仓</dt><dd>{{ formatTime(arrivalTime?.estimatedWarehouseArrivalAt) }}</dd></div><div><dt>实际到仓</dt><dd>{{ formatTime(arrivalTime?.actualWarehouseArrivalAt) }}</dd></div><div><dt>卸柜完成</dt><dd>{{ formatTime((workbenchDetail?.actualFacts?.unloadingCompletedAt || workbenchDetail?.terminalDrayage?.unloadingCompletedAt) as string | null) }}</dd></div><div><dt>实际还柜</dt><dd>{{ formatTime(workbenchDetail?.terminalDrayage?.actualEmptyReturnAt) }}</dd></div></dl></div>
      </section>

      <section v-if="isDomestic && activeTab === 'loading-list'" class="detail-section surface-panel" aria-labelledby="container-loading-list-heading">
@@ -14,6 +14,7 @@ import { getOceanBooking, listOceanBookingLinkCandidates, listOceanBookings } fr
 import { getContainer, getContainerOverview, listContainers, updateContainer } from '../api/platformContainerLoading'
 import OceanBookingLinkDialog from '../components/OceanBookingLinkDialog.vue'
 import { getTerminalDrayage, getTerminalDrayageHistory, recordTerminalDrayageEmptyReturn, selectTerminalDrayageFleet, sendTerminalDrayageEmail, getTerminalDrayageEmails } from '../api/terminalDrayages'
+import { listContainerArrivalTimes, updateContainerExpectedArrival } from '../api/containerArrivalTimes'
 import AppDialog from '@/shared/components/AppDialog.vue'
 import { containerLoadingRoutes } from '../routes'

@@ -26,6 +27,7 @@ const accessCan = vi.hoisted(() => vi.fn())
 vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: accessCan }) }))
 vi.mock('../api/platformContainerLoading', () => ({ listContainers: vi.fn(), getContainer: vi.fn(), getContainerOverview: vi.fn(), getContainerClearance: vi.fn(), uploadContainerClearance: vi.fn(), completeContainerClearance: vi.fn(), uploadContainerDocument: vi.fn(), downloadContainerDocument: vi.fn(), downloadContainerPdaPhoto: vi.fn(), markContainerException: vi.fn(), cancelContainerException: vi.fn(), createContainerSimulation: vi.fn(), linkContainerOceanBooking: vi.fn(), unlinkContainerOceanBooking: vi.fn(), updateContainer: vi.fn() }))
 vi.mock('../api/terminalDrayages', () => ({ sendTerminalDrayageEmail: vi.fn(), getTerminalDrayageEmails: vi.fn(), retryTerminalDrayageEmail: vi.fn(), listTerminalDrayages: vi.fn(), getTerminalDrayage: vi.fn(), getTerminalDrayageHistory: vi.fn(), selectTerminalDrayageFleet: vi.fn(), scheduleTerminalDrayagePickup: vi.fn(), recordTerminalDrayageEmptyReturn: vi.fn() }))
+vi.mock('../api/containerArrivalTimes', () => ({ listContainerArrivalTimes: vi.fn(), updateContainerExpectedArrival: vi.fn() }))

 const drayage = {
  containerBookingId: '9001', containerNo: 'MSCU-1', oceanBookingId: '101', status: 'UNLOADED' as const, version: 3,
@@ -71,6 +73,8 @@ describe('ContainersView', () => {
    vi.mocked(getTerminalDrayageHistory).mockResolvedValue([])
    vi.mocked(selectTerminalDrayageFleet).mockResolvedValue({ ...drayage, fleetSupplierId: '502', fleetSupplierName: '新车队', version: 4, allowedActions: [...drayage.allowedActions] })
    vi.mocked(recordTerminalDrayageEmptyReturn).mockReset().mockResolvedValue({ ...drayage, status: 'EMPTY_RETURNED', actualEmptyReturnAt: '2026-09-11T13:00:00', version: 4, emptyReturnWarning: { status: 'RESOLVED', deadlineAt: '2026-09-10T10:00:00', overdueHours: 0, overdueDays: 0 }, allowedActions: ['SELECT_FLEET'] })
+    vi.mocked(listContainerArrivalTimes).mockReset().mockResolvedValue([{ sourceContainerBookingId: '9001', estimatedWarehouseArrivalAt: '2026-09-25T15:31:00', actualWarehouseArrivalAt: '2026-09-26T09:00:00', version: 0 }])
+    vi.mocked(updateContainerExpectedArrival).mockReset().mockResolvedValue({ sourceContainerBookingId: '9001', estimatedWarehouseArrivalAt: '2026-09-25T16:00:00', actualWarehouseArrivalAt: '2026-09-26T09:00:00', version: 1 })
    vi.mocked(listContainers).mockResolvedValue({ records: [{ id: '9001', planId: null, bookingNo: 'BK-1', cabinetNo: 'CB-1', containerNo: 'MSCU-1', sourceType: 'SIMULATION', allowedActions: ['EDIT_CONTAINER', 'SELECT_FLEET', 'SCHEDULE_PICKUP', 'RECORD_EMPTY_RETURN'], terminalDrayage: drayage, oceanBookingId: null, warehouseId: '8', warehouseName: '义乌仓', channelGroupCode: 'MATSON_CLX', channelCode: null, channelName: null, containerType: '40HQ', planStatus: 'WAIT_LOADING', version: 0, billOfLadingNo: null, vesselName: null, voyageNo: null, shippingCompanyId: null, shippingCompanyName: null, departurePortCode: null, departurePortName: '宁波', destinationPortCode: null, destinationPortName: '长滩', destinationWarehouseCode: null, destinationWarehouseName: null, capacityCbm: 68, maxWeightKg: 19500, terminalTruckingCompanyId: null, terminalTruckingCompany: null, loadingAt: null, estimatedSailingAt: null, actualSailingAt: null, estimatedPortArrivalAt: null, actualPortArrivalAt: null, estimatedWarehouseArrivalAt: null, actualWarehouseArrivalAt: null }], page: 1, size: 20, total: 1, pages: 1 })
    vi.mocked(getContainer).mockResolvedValue({ id: '9001', planId: null, bookingNo: 'BK-1', cabinetNo: 'CB-1', containerNo: 'MSCU-1', sourceType: 'SIMULATION', allowedActions: ['EDIT_CONTAINER'], oceanBookingId: null, warehouseId: '8', warehouseName: '义乌仓', channelGroupCode: 'MATSON_CLX', channelCode: null, channelName: null, containerType: '40HQ', planStatus: 'WAIT_LOADING', version: 0, billOfLadingNo: null, vesselName: null, voyageNo: null, shippingCompanyId: null, shippingCompanyName: null, departurePortCode: null, departurePortName: '宁波', destinationPortCode: null, destinationPortName: '长滩', destinationWarehouseCode: null, destinationWarehouseName: null, capacityCbm: 68, maxWeightKg: 19500, terminalTruckingCompanyId: null, terminalTruckingCompany: null, loadingAt: null, estimatedSailingAt: null, actualSailingAt: null, estimatedPortArrivalAt: null, actualPortArrivalAt: null, estimatedWarehouseArrivalAt: null, actualWarehouseArrivalAt: null })
    vi.mocked(getContainerOverview).mockResolvedValue({ container: { id: '9001', bookingNo: 'BK-1', cabinetNo: 'CB-1', containerNo: 'MSCU-1', status: 'WAIT_LOADING', warehouseId: '8', warehouseName: '义乌仓', voyageNo: null, vesselName: null, version: 0 }, loadingPlanId: null, pda: null, documents: [], exception: { active: false, reason: null, markedBy: null, markedByName: null, markedAt: null }, exceptionHistory: [], timeline: [] })
@@ -463,7 +467,7 @@ describe('ContainersView', () => {
  })

  it('updates an ACTIVE TRUCKING fleet inline and records actual empty return once', async () => {
-    vi.mocked(listSuppliers).mockResolvedValue({ records: [{ id: '502', name: '新车队', category: 'TRUCKING', status: 'ACTIVE' } as never], page: 1, size: 200, total: 1, pages: 1 })
+    vi.mocked(listSuppliers).mockResolvedValue({ records: [{ id: '502', name: '新车队', category: 'TRUCKING', truckingScope: 'OVERSEAS', status: 'ACTIVE' } as never], page: 1, size: 200, total: 1, pages: 1 })
    const router = createTestRouter()
    await router.push('/'); await router.isReady()
    const wrapper = mount(ContainersView, { props: { workbench: 'OVERSEAS' }, global: { plugins: [ElementPlus, router] } })
@@ -510,11 +514,11 @@ describe('ContainersView', () => {

    const oldSearch = vm.searchTerminalFleets('旧关键词')
    const latestSearch = vm.searchTerminalFleets('新车队')
-    expect(listSuppliers).toHaveBeenNthCalledWith(1, { page: 1, size: 20, category: 'TRUCKING', status: 'ACTIVE', keyword: '旧关键词' })
-    expect(listSuppliers).toHaveBeenNthCalledWith(2, { page: 1, size: 20, category: 'TRUCKING', status: 'ACTIVE', keyword: '新车队' })
-    resolveLatest({ records: [{ id: '503', name: '新车队', category: 'TRUCKING', status: 'ACTIVE' } as never], page: 1, size: 20, total: 1, pages: 1 })
+    expect(listSuppliers).toHaveBeenNthCalledWith(1, { page: 1, size: 20, category: 'TRUCKING', truckingScope: 'OVERSEAS', status: 'ACTIVE', keyword: '旧关键词' })
+    expect(listSuppliers).toHaveBeenNthCalledWith(2, { page: 1, size: 20, category: 'TRUCKING', truckingScope: 'OVERSEAS', status: 'ACTIVE', keyword: '新车队' })
+    resolveLatest({ records: [{ id: '503', name: '新车队', category: 'TRUCKING', truckingScope: 'OVERSEAS', status: 'ACTIVE' } as never, { id: '504', name: '国内车队', category: 'TRUCKING', truckingScope: 'DOMESTIC', status: 'ACTIVE' } as never], page: 1, size: 20, total: 2, pages: 1 })
    await latestSearch
-    resolveOld({ records: [{ id: '502', name: '旧车队', category: 'TRUCKING', status: 'ACTIVE' } as never], page: 1, size: 20, total: 1, pages: 1 })
+    resolveOld({ records: [{ id: '502', name: '旧车队', category: 'TRUCKING', truckingScope: 'OVERSEAS', status: 'ACTIVE' } as never], page: 1, size: 20, total: 1, pages: 1 })
    await oldSearch
    expect(vm.terminalFleetOptions).toEqual([expect.objectContaining({ id: '503', name: '新车队' })])
    wrapper.unmount()
@@ -541,6 +545,27 @@ describe('ContainersView', () => {
    expect(source).not.toContain('linkContainerId')
  })

+  it('edits the whole-container expected arrival inline and shows PDA receiving start as actual arrival', async () => {
+    const wrapper = await mountOverseasRoute()
+    expect(wrapper.text()).toContain('预计到仓')
+    expect(wrapper.text()).toContain('实际到仓')
+    expect(wrapper.text()).toContain('2026-09-26 09:00')
+    const picker = wrapper.findAllComponents({ name: 'ElDatePicker' })
+      .find((item) => item.props('placeholder') === '选择预计到仓')
+    expect(picker).toBeDefined()
+
+    const vm = wrapper.findComponent(ContainersView).vm as unknown as {
+      rows: Array<Record<string, unknown>>
+      saveExpectedArrival: (row: Record<string, unknown>, value: string) => Promise<void>
+    }
+    await vm.saveExpectedArrival(vm.rows[0], '2026-09-25T16:00:00')
+    await flushPromises()
+
+    expect(updateContainerExpectedArrival).toHaveBeenCalledWith('9001', {
+      estimatedWarehouseArrivalAt: '2026-09-25T16:00:00', expectedVersion: 0,
+    })
+  })
+
  it.each(['EDITING', 'LOADING', 'COMPLETED'] as const)('keeps released-booking linking reachable alongside the %s process action', async (planStatus) => {
    const page = await listContainers({ page: 1, size: 20 }, 'DOMESTIC')
    vi.mocked(listContainers).mockResolvedValue({ ...page, records: page.records.map((row) => ({
@@ -717,7 +742,7 @@ describe('ContainersView', () => {
  })

  it('backfills a legacy trucking supplier name and submits the frozen id-name pair', async () => {
-    vi.mocked(listSuppliers).mockResolvedValue({ records: [{ id: '9007199254740998', tenantId: '1', name: '测试拖车供应商', category: 'TRUCKING', carrierCodes: [], region: 'CN', legalRepresentative: '张三', contactName: '李四', phone: '13800000000', email: null, address: null, businessLicenseNo: null, licenseFileId: null, status: 'ACTIVE', settlementPeriod: 'MONTHLY_30', remark: null, createdBy: null, createdAt: '2026-08-25T10:00:00', updatedBy: null, updatedAt: '2026-08-25T10:00:00', deleted: false, version: 0 }], page: 1, size: 200, total: 1, pages: 1 })
+    vi.mocked(listSuppliers).mockResolvedValue({ records: [{ id: '9007199254740998', tenantId: '1', name: '测试拖车供应商', category: 'TRUCKING', truckingScope: 'OVERSEAS', carrierCodes: [], region: 'CN', legalRepresentative: '张三', contactName: '李四', phone: '13800000000', email: null, address: null, businessLicenseNo: null, licenseFileId: null, status: 'ACTIVE', settlementPeriod: 'MONTHLY_30', remark: null, createdBy: null, createdAt: '2026-08-25T10:00:00', updatedBy: null, updatedAt: '2026-08-25T10:00:00', deleted: false, version: 0 }], page: 1, size: 200, total: 1, pages: 1 })
    vi.mocked(getContainer).mockResolvedValueOnce({ id: '9001', allowedActions: ['EDIT_CONTAINER'], planStatus: 'WAIT_LOADING', containerType: '40HQ', warehouseId: '8', terminalTruckingCompanyId: null, terminalTruckingCompany: '测试拖车供应商' } as never)
    vi.mocked(updateContainer).mockResolvedValue({} as never)
    const router = createTestRouter()
@@ -737,7 +762,7 @@ describe('ContainersView', () => {
  })

  it('clears the trucking supplier id and name together', async () => {
-    vi.mocked(listSuppliers).mockResolvedValue({ records: [{ id: '9007199254740998', tenantId: '1', name: '测试拖车供应商', category: 'TRUCKING', carrierCodes: [], region: 'CN', legalRepresentative: '张三', contactName: '李四', phone: '13800000000', email: null, address: null, businessLicenseNo: null, licenseFileId: null, status: 'ACTIVE', settlementPeriod: 'MONTHLY_30', remark: null, createdBy: null, createdAt: '2026-08-25T10:00:00', updatedBy: null, updatedAt: '2026-08-25T10:00:00', deleted: false, version: 0 }], page: 1, size: 200, total: 1, pages: 1 })
+    vi.mocked(listSuppliers).mockResolvedValue({ records: [{ id: '9007199254740998', tenantId: '1', name: '测试拖车供应商', category: 'TRUCKING', truckingScope: 'OVERSEAS', carrierCodes: [], region: 'CN', legalRepresentative: '张三', contactName: '李四', phone: '13800000000', email: null, address: null, businessLicenseNo: null, licenseFileId: null, status: 'ACTIVE', settlementPeriod: 'MONTHLY_30', remark: null, createdBy: null, createdAt: '2026-08-25T10:00:00', updatedBy: null, updatedAt: '2026-08-25T10:00:00', deleted: false, version: 0 }], page: 1, size: 200, total: 1, pages: 1 })
    vi.mocked(getContainer).mockResolvedValueOnce({ id: '9001', allowedActions: ['EDIT_CONTAINER'], planStatus: 'WAIT_LOADING', containerType: '40HQ', warehouseId: '8', terminalTruckingCompanyId: '9007199254740998', terminalTruckingCompany: '测试拖车供应商' } as never)
    vi.mocked(updateContainer).mockResolvedValue({} as never)
    const router = createTestRouter()
@@ -797,9 +822,9 @@ describe('ContainersView trucking supplier contract', () => {

  it('uses active TRUCKING suppliers without allowing free-text carrier names', () => {
    const source = readFileSync(resolve(process.cwd(), 'src/modules/container-loading/pages/ContainersView.vue'), 'utf8')
-    expect(source).toContain("listSuppliers({ page: 1, size: 200, category: 'TRUCKING', status: 'ACTIVE' })")
-    expect(source).toContain("page: 1, size: 20, category: 'TRUCKING', status: 'ACTIVE', keyword: keyword.trim() || undefined")
-    expect(source).toContain("supplier.category === 'TRUCKING' && supplier.status === 'ACTIVE'")
+    expect(source).toContain("listSuppliers({ page: 1, size: 200, category: 'TRUCKING', truckingScope: 'OVERSEAS', status: 'ACTIVE' })")
+    expect(source).toContain("page: 1, size: 20, category: 'TRUCKING', truckingScope: 'OVERSEAS', status: 'ACTIVE', keyword: keyword.trim() || undefined")
+    expect(source).toContain("supplier.category === 'TRUCKING' && supplier.truckingScope === 'OVERSEAS' && supplier.status === 'ACTIVE'")
    expect(source).toContain('filterable remote reserve-keyword remote-show-suffix')
    expect(source).toContain(':remote-method="searchTerminalFleets"')
    expect(source).toContain('selectTruckingSupplier')
@@ -31,12 +31,12 @@ import {
  getTerminalDrayage,
  getTerminalDrayageHistory,
  recordTerminalDrayageEmptyReturn,
-  scheduleTerminalDrayagePickup,
  selectTerminalDrayageFleet,
  type TerminalDrayageAction,
  type TerminalDrayageHistory,
  type TerminalDrayageView,
 } from '../api/terminalDrayages'
+import { listContainerArrivalTimes, updateContainerExpectedArrival, type ContainerArrivalTime } from '../api/containerArrivalTimes'
 import type { ContainerBookingResource, ContainerDocumentStatus, ContainerPlanStatus, ContainerSaveRequest, ContainerWorkbenchAction, ContainerWorkbenchRow } from '../types'

 type Filters = QueryModel & { customerId: string; keyword: string; containerType: string; status: ContainerPlanStatus | ''; sailingRange: string[] }
@@ -78,6 +78,9 @@ const linkTarget = ref<ContainerBookingResource | null>(null)
 const selectedTruckingSupplierId = ref('')
 const unresolvedTruckingSupplierName = ref<string | null>(null)
 const drayages = ref<Record<string, TerminalDrayageView>>({})
+const arrivalTimes = ref<Record<string, ContainerArrivalTime>>({})
+const arrivalInputs = ref<Record<string, string>>({})
+const arrivalSavingIds = ref<string[]>([])
 const drayageSavingIds = ref<string[]>([])
 const drayageActionOpen = ref(false)
 const drayageAction = ref<Exclude<TerminalDrayageAction, 'SELECT_FLEET' | 'SEND_PICKUP_EMAIL'>>('SCHEDULE_PICKUP')
@@ -187,13 +190,14 @@ const canCreate = computed(() => access.can('platform:firstleg:container:create'
 const canOverseasDocumentEdit = computed(() => access.can('platform:firstleg:terminal-drayage:document:edit'))
 const canFleetEdit = computed(() => access.can('platform:firstleg:terminal-drayage:fleet:edit'))
 const canPickupAppointmentEdit = computed(() => access.can('platform:firstleg:terminal-drayage:pickup-appointment:edit'))
+const canExpectedArrivalEdit = computed(() => access.can('platform:overseas-warehouse:last-mile-order:edit'))
 const canEmptyReturnConfirm = computed(() => access.can('platform:firstleg:terminal-drayage:empty-return:confirm'))
 const canSmartLoading = computed(() => access.can('platform:firstleg:smart-loading:list'))
 const canViewPreload = computed(() => access.can('platform:firstleg:preload:list'))
 const canViewLoadingList = computed(() => access.can('platform:firstleg:loading-list:list'))
 const editorTitle = computed(() => form.id ? '编辑' : '新增')
 const shippingCompanies = computed(() => partners.value.filter((partner) => partner.status === 'ACTIVE' && partner.types.includes('CARRIER')))
-const truckingCompanies = computed(() => truckingSuppliers.value.filter((supplier) => supplier.status === 'ACTIVE' && supplier.category === 'TRUCKING'))
+const truckingCompanies = computed(() => truckingSuppliers.value.filter((supplier) => supplier.status === 'ACTIVE' && supplier.category === 'TRUCKING' && supplier.truckingScope === 'OVERSEAS'))
 interface PortOption { value: string; code: string | null; name: string | null }
 function portValue(code: string | null | undefined, name: string | null | undefined) { return code || name ? JSON.stringify([code || '', name || '']) : '' }
 function collectPorts(direction: 'departure' | 'destination'): PortOption[] {
@@ -242,8 +246,8 @@ const allColumns: DataTableColumn[] = [
  { key: 'channelGroupCode', label: '计划渠道', minWidth: 140, formatter: (row: ContainerBookingResource) => getSmartLoadingChannelGroup(row.channelGroupCode)?.name || '—' },
  { key: 'channelName', label: '实际渠道', minWidth: 160, formatter: (row: ContainerBookingResource) => row.channelName || '待关联订舱' },
  { key: 'terminalTruckingCompany', label: '码头车队', width: 190, slotName: 'terminalTruckingCompany' },
-  { key: 'pickupAppointmentAt', label: '预约提柜', width: 165, slotName: 'pickupAppointmentAt' },
-  { key: 'actualPickupAt', label: '实际提柜', width: 165, slotName: 'actualPickupAt' },
+  { key: 'pickupAppointmentAt', label: '预计到仓', width: 210, slotName: 'pickupAppointmentAt' },
+  { key: 'actualPickupAt', label: '实际到仓', width: 165, slotName: 'actualPickupAt' },
  { key: 'estimatedEmptyReturnAt', label: '预计还柜', width: 165, slotName: 'estimatedEmptyReturnAt' },
  { key: 'actualEmptyReturnAt', label: '实际还柜', width: 165, slotName: 'actualEmptyReturnAt' },
  { key: 'billOfLadingNo', prop: 'billOfLadingNo', label: '提单号', minWidth: 150 },
@@ -278,8 +282,8 @@ function statusText(status: ContainerPlanStatus) { return ({ WAIT_LOADING: '待
 function documentStatusText(status: ContainerDocumentStatus | null | undefined) { return status ? ({ MISSING: '未上传', UPLOADED: '已上传', COMPLETED: '已完成' })[status] : '—' }
 function formatTime(value: string | null | undefined) { return value?.replace('T', ' ').slice(0, 16) || '—' }
 function drayageFor(containerBookingId: string) { return drayages.value[containerBookingId] }
-function drayageStatusText(status?: string | null) { return ({ WAITING_FOR_ARRIVAL: '待到港', ARRIVED: '已到港', PICKUP_SCHEDULED: '已约提柜', PICKED_UP: '已提柜', UNLOADED: '已卸柜', EMPTY_RETURNED: '已还柜' } as Record<string, string>)[status || ''] || status || '—' }
-function drayageActionText(action: TerminalDrayageAction) { return ({ SELECT_FLEET: '选择码头车队', SCHEDULE_PICKUP: '预约提柜', RECORD_EMPTY_RETURN: '确认还柜', SEND_PICKUP_EMAIL: '发送提柜邮件' } as Record<TerminalDrayageAction, string>)[action] }
+function drayageStatusText(status?: string | null) { return ({ WAITING_FOR_ARRIVAL: '待到港', ARRIVED: '已到港', PICKUP_SCHEDULED: '已设置预计到仓', PICKED_UP: '已实际到仓', UNLOADED: '已卸柜', EMPTY_RETURNED: '已还柜' } as Record<string, string>)[status || ''] || status || '—' }
+function drayageActionText(action: TerminalDrayageAction) { return ({ SELECT_FLEET: '选择码头车队', SCHEDULE_PICKUP: '修改预计到仓', RECORD_EMPTY_RETURN: '确认还柜', SEND_PICKUP_EMAIL: '发送提柜邮件' } as Record<TerminalDrayageAction, string>)[action] }
 function hasAction(row: ContainerWorkbenchRow, action: ContainerWorkbenchAction) { return Boolean(row.allowedActions?.includes(action)) }
 function canDrayage(row: ContainerWorkbenchRow, action: TerminalDrayageAction) {
  const permission = action === 'SELECT_FLEET' || action === 'SEND_PICKUP_EMAIL' ? canFleetEdit.value : action === 'SCHEDULE_PICKUP' ? canPickupAppointmentEdit.value : canEmptyReturnConfirm.value
@@ -461,8 +465,8 @@ async function loadTruckingSuppliers(): Promise<Supplier[]> {
  if (truckingSuppliersLoaded) return truckingSuppliers.value
  if (truckingSuppliersPromise) return truckingSuppliersPromise
  truckingSuppliersPromise = (async () => {
-    const result = await listSuppliers({ page: 1, size: 200, category: 'TRUCKING', status: 'ACTIVE' })
-    const records = result.records.filter((supplier) => supplier.category === 'TRUCKING' && supplier.status === 'ACTIVE')
+    const result = await listSuppliers({ page: 1, size: 200, category: 'TRUCKING', truckingScope: 'OVERSEAS', status: 'ACTIVE' })
+    const records = result.records.filter((supplier) => supplier.category === 'TRUCKING' && supplier.truckingScope === 'OVERSEAS' && supplier.status === 'ACTIVE')
    truckingSuppliers.value = records
    truckingSuppliersLoaded = true
    return records
@@ -475,10 +479,10 @@ async function searchTerminalFleets(keyword = '') {
  terminalFleetLoading.value = true
  try {
    const result = await listSuppliers({
-      page: 1, size: 20, category: 'TRUCKING', status: 'ACTIVE', keyword: keyword.trim() || undefined,
+      page: 1, size: 20, category: 'TRUCKING', truckingScope: 'OVERSEAS', status: 'ACTIVE', keyword: keyword.trim() || undefined,
    })
    if (sequence !== terminalFleetSearchSequence) return
-    terminalFleetOptions.value = result.records.filter((supplier) => supplier.category === 'TRUCKING' && supplier.status === 'ACTIVE')
+    terminalFleetOptions.value = result.records.filter((supplier) => supplier.category === 'TRUCKING' && supplier.truckingScope === 'OVERSEAS' && supplier.status === 'ACTIVE')
  } catch (error) {
    if (sequence !== terminalFleetSearchSequence) return
    terminalFleetOptions.value = []
@@ -555,9 +559,7 @@ async function saveDrayageAction() {
  drayageActionSaving.value = true; drayageActionError.value = null
  try {
    const reason = drayageReason.value.trim() || undefined
-    const next = drayageAction.value === 'SCHEDULE_PICKUP'
-      ? await scheduleTerminalDrayagePickup(row.id, { expectedVersion: current.version, pickupAppointmentAt: drayageActionAt.value, reason })
-      : await recordTerminalDrayageEmptyReturn(row.id, { expectedVersion: current.version, actualAt: drayageActionAt.value, remark: reason })
+    const next = await recordTerminalDrayageEmptyReturn(row.id, { expectedVersion: current.version, actualAt: drayageActionAt.value, remark: reason })
    replaceDrayage(next); drayageActionOpen.value = false
    ElMessage.success(`${drayageActionText(drayageAction.value)}成功`)
    await loadRows()
@@ -569,6 +571,27 @@ async function saveDrayageAction() {
    } else drayageActionError.value = details
  } finally { drayageActionSaving.value = false }
 }
+async function saveExpectedArrival(row: ContainerBookingResource, value: string | null) {
+  const current = arrivalTimes.value[row.id]
+  if (!value || !current || current.version < 0 || arrivalSavingIds.value.includes(row.id)) return
+  arrivalSavingIds.value.push(row.id)
+  try {
+    const updated = await updateContainerExpectedArrival(row.id, {
+      estimatedWarehouseArrivalAt: value,
+      expectedVersion: current.version,
+    })
+    arrivalTimes.value = { ...arrivalTimes.value, [row.id]: updated }
+    arrivalInputs.value = { ...arrivalInputs.value, [row.id]: updated.estimatedWarehouseArrivalAt || '' }
+    ElMessage.success('预计到仓时间已同步整柜，后续入库计划将自动带出')
+  } catch (error) {
+    ElMessage.error(getApiErrorDetails(error, '预计到仓时间保存失败').message)
+    const latest = await listContainerArrivalTimes([row.id]).catch(() => [])
+    if (latest[0]) {
+      arrivalTimes.value = { ...arrivalTimes.value, [row.id]: latest[0] }
+      arrivalInputs.value = { ...arrivalInputs.value, [row.id]: latest[0].estimatedWarehouseArrivalAt || '' }
+    }
+  } finally { arrivalSavingIds.value = arrivalSavingIds.value.filter((id) => id !== row.id) }
+}
 async function openDrayageHistory(row: ContainerBookingResource) {
  drayageTarget.value = row; drayageHistory.value = []; drayageHistoryError.value = null; drayageHistoryOpen.value = true; drayageHistoryLoading.value = true
  try {
@@ -592,6 +615,10 @@ async function loadRows() {
    if (sequence !== listSequence) return
    rows.value = result.records as ContainerWorkbenchRow[]; total.value = result.total
    drayages.value = Object.fromEntries(rows.value.flatMap((row) => row.terminalDrayage ? [[row.id, row.terminalDrayage as TerminalDrayageView]] : []))
+    const arrivalValues = isOverseas.value ? await listContainerArrivalTimes(rows.value.map((row) => row.id)) : []
+    if (sequence !== listSequence) return
+    arrivalTimes.value = Object.fromEntries(arrivalValues.map((item) => [item.sourceContainerBookingId, item]))
+    arrivalInputs.value = Object.fromEntries(arrivalValues.map((item) => [item.sourceContainerBookingId, item.estimatedWarehouseArrivalAt || '']))
  } catch (error) {
    if (sequence !== listSequence) return
    rows.value = []; total.value = 0; loadError.value = getApiErrorDetails(error, '货柜列表加载失败，请稍后重试')
@@ -694,14 +721,14 @@ onMounted(async () => { await Promise.all([loadCustomers(), loadRows()]) })
        <section v-if="!loadError" id="container-workbench-results" class="surface-panel table-panel">
          <DataTable v-model:page="page" v-model:page-size="pageSize" :data="rows" :columns="columns" :total="total" :loading="loading" stripe preference-key="container-loading-table" empty-text="暂无货柜">
            <template #toolbar-actions><ContainerSimulationCreate dense v-if="isDomestic && canCreate" :load-warehouse-options="loadSimulationWarehouses" @created="loadRows" /></template>
-            <template #actions="{ row }"><div class="row-actions density-actions"><el-button class="density-action" v-if="canView" size="small" type="primary" plain :aria-label="containerViewLabel(row as ContainerBookingResource)" @click="openDetail(row)">查看</el-button><template v-if="isDomestic"><el-button class="density-action" v-if="canEdit && hasAction(row as ContainerWorkbenchRow, 'EDIT_CONTAINER')" size="small" @click="openEdit(row)">编辑</el-button><el-button data-tone="primary" class="density-action" v-if="row.planStatus === 'EDITING' && canSmartLoading" size="small" type="primary" @click="goContainerProcess(row)">装柜</el-button><el-button class="density-action" v-else-if="row.planStatus === 'LOADING' && canViewPreload" size="small" type="primary" plain @click="goContainerProcess(row)">预装清单</el-button><el-button class="density-action" v-else-if="row.planStatus === 'COMPLETED' && canViewLoadingList" size="small" type="primary" plain @click="goContainerProcess(row)">装柜清单</el-button></template><el-button data-tone="primary" class="density-action" v-if="canDrayage(row as ContainerWorkbenchRow, 'RECORD_EMPTY_RETURN')" size="small" type="primary" @click="openDrayageAction(row as ContainerBookingResource, 'RECORD_EMPTY_RETURN')">确认还柜</el-button><el-button data-tone="primary" class="density-action" v-if="canDrayage(row as ContainerWorkbenchRow, 'SEND_PICKUP_EMAIL')" size="small" type="primary" :loading="drayageSavingIds.includes(row.id)" @click="sendPickupEmail(row as ContainerWorkbenchRow)">发送邮件</el-button><el-dropdown v-if="canView" trigger="click" @command="handleMoreAction($event, row)"><el-button class="density-action" size="small" plain aria-label="更多货柜操作" title="更多货柜操作"><MoreHorizontal :size="16" /></el-button><template #dropdown><el-dropdown-menu><el-dropdown-item command="overview">轨迹与日志</el-dropdown-item><template v-if="isOverseas"><el-dropdown-item command="email-history">邮件记录</el-dropdown-item><el-dropdown-item command="drayage-history">码头拖车记录</el-dropdown-item><el-dropdown-item v-if="canDrayage(row as ContainerWorkbenchRow, 'SCHEDULE_PICKUP')" command="drayage:SCHEDULE_PICKUP">预约提柜</el-dropdown-item><el-dropdown-item v-if="canOverseasDocumentEdit && hasAction(row as ContainerWorkbenchRow, 'MANAGE_DESTINATION_DOCUMENTS')" command="documents">清关 / DO / PU</el-dropdown-item></template><el-dropdown-item v-if="isDomestic && canEdit && hasAction(row as ContainerWorkbenchRow, 'EDIT_CONTAINER') && row.sourceType === 'SIMULATION' && !row.oceanBookingId" command="link">关联已放舱订舱</el-dropdown-item></el-dropdown-menu></template></el-dropdown></div></template>
+            <template #actions="{ row }"><div class="row-actions density-actions"><el-button class="density-action" v-if="canView" size="small" type="primary" plain :aria-label="containerViewLabel(row as ContainerBookingResource)" @click="openDetail(row)">查看</el-button><template v-if="isDomestic"><el-button class="density-action" v-if="canEdit && hasAction(row as ContainerWorkbenchRow, 'EDIT_CONTAINER')" size="small" @click="openEdit(row)">编辑</el-button><el-button data-tone="primary" class="density-action" v-if="row.planStatus === 'EDITING' && canSmartLoading" size="small" type="primary" @click="goContainerProcess(row)">装柜</el-button><el-button class="density-action" v-else-if="row.planStatus === 'LOADING' && canViewPreload" size="small" type="primary" plain @click="goContainerProcess(row)">预装清单</el-button><el-button class="density-action" v-else-if="row.planStatus === 'COMPLETED' && canViewLoadingList" size="small" type="primary" plain @click="goContainerProcess(row)">装柜清单</el-button></template><el-button data-tone="primary" class="density-action" v-if="canDrayage(row as ContainerWorkbenchRow, 'RECORD_EMPTY_RETURN')" size="small" type="primary" @click="openDrayageAction(row as ContainerBookingResource, 'RECORD_EMPTY_RETURN')">确认还柜</el-button><el-button data-tone="primary" class="density-action" v-if="canDrayage(row as ContainerWorkbenchRow, 'SEND_PICKUP_EMAIL')" size="small" type="primary" :loading="drayageSavingIds.includes(row.id)" @click="sendPickupEmail(row as ContainerWorkbenchRow)">发送邮件</el-button><el-dropdown v-if="canView" trigger="click" @command="handleMoreAction($event, row)"><el-button class="density-action" size="small" plain aria-label="更多货柜操作" title="更多货柜操作"><MoreHorizontal :size="16" /></el-button><template #dropdown><el-dropdown-menu><el-dropdown-item command="overview">轨迹与日志</el-dropdown-item><template v-if="isOverseas"><el-dropdown-item command="email-history">邮件记录</el-dropdown-item><el-dropdown-item command="drayage-history">码头拖车记录</el-dropdown-item><el-dropdown-item v-if="canOverseasDocumentEdit && hasAction(row as ContainerWorkbenchRow, 'MANAGE_DESTINATION_DOCUMENTS')" command="documents">清关 / DO / PU</el-dropdown-item></template><el-dropdown-item v-if="isDomestic && canEdit && hasAction(row as ContainerWorkbenchRow, 'EDIT_CONTAINER') && row.sourceType === 'SIMULATION' && !row.oceanBookingId" command="link">关联已放舱订舱</el-dropdown-item></el-dropdown-menu></template></el-dropdown></div></template>
            <template #emptyReturnWarning="{ row }"><el-tag :type="drayageWarningType(row as ContainerBookingResource)" effect="light" :title="drayageWarningTitle(row as ContainerBookingResource)">{{ drayageWarningText(row as ContainerBookingResource) }}</el-tag></template>
            <template #cabinet="{ row }"><strong>{{ row.cabinetNo }}</strong><small>系统生成</small></template>
            <template #oceanBooking="{ row }"><span v-if="row.oceanBookingId"><strong>{{ row.billOfLadingNo || '已关联订舱' }}</strong><small>{{ row.containerNo ? `集装箱号：${row.containerNo}` : '集装箱号：待补录' }}</small></span><span v-else>未关联</span></template>
            <template #containerNo="{ row }">{{ row.containerNo || '待补录' }}</template>
            <template #terminalTruckingCompany="{ row }"><el-select class="fleet-select" :model-value="drayageFor(row.id)?.fleetSupplierId || ''" filterable remote reserve-keyword remote-show-suffix placeholder="输入车队名称或联系人搜索" :remote-method="searchTerminalFleets" :loading="terminalFleetLoading || drayageSavingIds.includes(row.id)" :disabled="!canDrayage(row as ContainerBookingResource, 'SELECT_FLEET') || drayageSavingIds.includes(row.id)" no-data-text="未找到合作中的码头车队" @visible-change="handleTerminalFleetVisible" @update:model-value="selectRowFleet(row, $event)"><el-option v-if="drayageFor(row.id)?.fleetSupplierName && !terminalFleetOptions.some((item) => item.id === drayageFor(row.id)?.fleetSupplierId)" :label="drayageFor(row.id)?.fleetSupplierName || '原码头车队'" :value="drayageFor(row.id)?.fleetSupplierId || ''" disabled /><el-option v-for="supplier in terminalFleetOptions" :key="supplier.id" :label="supplier.name" :value="supplier.id" /></el-select></template>
-            <template #pickupAppointmentAt="{ row }">{{ formatTime(drayageFor(row.id)?.pickupAppointmentAt) }}</template>
-            <template #actualPickupAt="{ row }">{{ formatTime(drayageFor(row.id)?.actualPickupAt) }}</template>
+            <template #pickupAppointmentAt="{ row }"><div class="arrival-time-cell"><el-date-picker v-model="arrivalInputs[row.id]" class="arrival-time-picker" type="datetime" value-format="YYYY-MM-DDTHH:mm:ss" format="YYYY-MM-DD HH:mm" placeholder="选择预计到仓" :disabled="!canExpectedArrivalEdit || !arrivalTimes[row.id] || arrivalTimes[row.id].version < 0 || arrivalSavingIds.includes(row.id)" @change="saveExpectedArrival(row as ContainerBookingResource, $event as string | null)" /></div></template>
+            <template #actualPickupAt="{ row }">{{ formatTime(arrivalTimes[row.id]?.actualWarehouseArrivalAt) }}</template>
            <template #estimatedEmptyReturnAt="{ row }">{{ formatTime(drayageFor(row.id)?.estimatedEmptyReturnAt) }}</template>
            <template #actualEmptyReturnAt="{ row }">{{ formatTime(drayageFor(row.id)?.actualEmptyReturnAt) }}</template>
            <template #status="{ row }"><el-tag :type="row.planStatus === 'COMPLETED' ? 'success' : row.planStatus === 'LOADING' ? 'warning' : 'info'">{{ statusText(row.planStatus) }}</el-tag></template>
@@ -745,7 +772,7 @@ onMounted(async () => { await Promise.all([loadCustomers(), loadRows()]) })
    </AppDialog>

    <AppDialog class="admin-density-dialog" v-model="drayageActionOpen" :title="drayageActionText(drayageAction)" width="min(520px, calc(100vw - 28px))" :confirm-text="drayageActionText(drayageAction)" cancel-text="取消" :confirm-loading="drayageActionSaving" :confirm-disabled="!drayageActionAt" @confirm="saveDrayageAction">
-      <el-form class="density-form" label-position="top"><el-form-item :label="drayageAction === 'SCHEDULE_PICKUP' ? '预约提柜时间' : '实际还柜时间'" required><el-date-picker v-model="drayageActionAt" type="datetime" value-format="YYYY-MM-DDTHH:mm:ss" placeholder="请选择时间" /></el-form-item><el-form-item label="原因/备注"><el-input v-model="drayageReason" type="textarea" :rows="3" maxlength="500" show-word-limit placeholder="选填" /></el-form-item></el-form>
+      <el-form class="density-form" label-position="top"><el-form-item label="实际还柜时间" required><el-date-picker v-model="drayageActionAt" type="datetime" value-format="YYYY-MM-DDTHH:mm:ss" placeholder="请选择时间" /></el-form-item><el-form-item label="原因/备注"><el-input v-model="drayageReason" type="textarea" :rows="3" maxlength="500" show-word-limit placeholder="选填" /></el-form-item></el-form>
      <LoadErrorState v-if="drayageActionError" compact :title="`${drayageActionText(drayageAction)}失败`" :message="drayageActionError.message" :show-retry="false"><template #details><ApiErrorMeta :details="drayageActionError" /></template></LoadErrorState>
    </AppDialog>

@@ -768,7 +795,10 @@ onMounted(async () => { await Promise.all([loadCustomers(), loadRows()]) })
 </template>

 <style scoped>
-.container-page { display: grid; gap: var(--admin-space-5); min-width: 0; }.container-page small { display: block; margin-top: var(--admin-space-1); color: var(--cc-muted); }.container-query-panel { overflow: hidden; border: 1px solid var(--cc-border); border-radius: var(--admin-radius); background: var(--admin-surface); }.container-scope-tabs { display: flex; max-width: 100%; overflow-x: auto; margin-bottom: 0; border-bottom: 1px solid #e5e7eb; scrollbar-width: thin; }.container-query-toolbar { border: 0; }.row-actions { flex-wrap: nowrap; white-space: nowrap; }.row-actions :deep(.el-button + .el-button) { margin-left: 0; }.form-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 0 var(--admin-space-5); }.form-grid :deep(.el-select),.form-grid :deep(.el-date-editor),.form-grid :deep(.el-input-number),.simulation-form :deep(.el-select),.simulation-form :deep(.el-input-number),.fleet-select { width: 100%; }.details :deep(.el-descriptions__label) { width: 120px; }.drayage-load-alert { margin-bottom: var(--admin-space-5); }.drayage-summary { margin-bottom: var(--admin-space-5); }
+.container-page { display: grid; gap: var(--admin-space-5); min-width: 0; }.container-page small { display: block; margin-top: var(--admin-space-1); color: var(--cc-muted); }.container-query-panel { overflow: hidden; border: 1px solid var(--cc-border); border-radius: var(--admin-radius); background: var(--admin-surface); }.container-scope-tabs { display: flex; max-width: 100%; overflow-x: auto; margin-bottom: 0; border-bottom: 1px solid #e5e7eb; scrollbar-width: thin; }.container-query-toolbar { border: 0; }.row-actions { flex-wrap: nowrap; white-space: nowrap; }.row-actions :deep(.el-button + .el-button) { margin-left: 0; }.form-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 0 var(--admin-space-5); }.form-grid :deep(.el-select),.form-grid :deep(.el-date-editor),.form-grid :deep(.el-input-number),.simulation-form :deep(.el-select),.simulation-form :deep(.el-input-number),.fleet-select { width: 100%; }.arrival-time-cell { display: flex; align-items: center; width: 100%; min-width: 0; padding-right: var(--admin-space-1); box-sizing: border-box; }.arrival-time-picker { width: 200px !important; max-width: 100%; min-width: 0; box-sizing: border-box; }.details :deep(.el-descriptions__label) { width: 120px; }.drayage-load-alert { margin-bottom: var(--admin-space-5); }.drayage-summary { margin-bottom: var(--admin-space-5); }
+.container-query-panel { width: 100%; max-width: 100%; min-width: 0; box-sizing: border-box; }
+.container-query-toolbar :deep(.query-toolbar__tail) { width: 100%; flex: 0 0 100%; }
+.container-page .table-panel { width: 100%; max-width: 100%; min-width: 0; }
@media(max-width:720px){.details :deep(.el-descriptions__body table),.details :deep(tbody),.details :deep(tr),.details :deep(td){display:block;width:100%!important}.row-actions { min-width: 180px; }}
@media(max-width:720px){.form-grid{grid-template-columns:1fr}}
 </style>
@@ -77,6 +77,7 @@ const plan = {
  canAssign: true, canEdit: true, blockedReason: null, finalCompletionStatus: 'NOT_STARTED' as const,
  pdaTaskId: null, pdaTaskStatus: null, pdaTaskVersion: null,
  coLoadGroups: [],
+  palletMembers: [],
  items: [{ id: '101', loadingPlanId: '99', accountId: '1', inboundId: '2', inboundDetailId: '3', orderId: '4', orderNo: 'ORD-1', inboundCode: 'IN-1', customerName: '示例企业', destinationWarehouseId: '9', destinationWarehouseCode: 'LAX9', destinationWarehouseName: 'LAX9', skuCode: 'SKU-1', productNameZh: '服装', unitType: 'PACKAGE' as const, palletId: null, palletNo: null, indivisible: false, packageCount: 6, productQuantity: 6, grossWeightKg: 60, volumeCbm: 1.2, loadSequence: 1, version: 1, pickedPackageCount: 0, minPackageCount: 1, canAdjust: true, canRemove: true }],
 }
 const candidate = {
@@ -492,7 +493,7 @@ describe('GlobalSmartLoadingView', () => {
    expect(wrapper.text()).toContain('CLG-2093539779795795969 · 2 票')
    expect(wrapper.text()).toContain('3 个入仓片段')
    expect(wrapper.text()).toContain('ORD-201：NYEXX2608290051、NYEXX2608290051-B')
-    const buttons = wrapper.findAll('button').filter((button) => button.text().includes('整组分配'))
+    const buttons = wrapper.findAll('.el-table__body-wrapper button').filter((button) => button.text() === '加入')
    expect(buttons).toHaveLength(1)
    await buttons[0].trigger('click')
    await flushPromises()
@@ -560,7 +561,7 @@ describe('GlobalSmartLoadingView', () => {

    expect(wrapper.text()).toContain('CLG-9900 · 3 票')
    expect(wrapper.text()).toContain('同柜不可拆组成员候选不齐，缺少 1 票')
-    const button = wrapper.findAll('button').find((item) => item.text().includes('整组分配'))!
+    const button = wrapper.findAll('.el-table__body-wrapper button').find((item) => item.text() === '加入')!
    expect(button.attributes('disabled')).toBeDefined()
    expect(assignSmartLoadingGroup).not.toHaveBeenCalled()
  })
@@ -599,6 +600,73 @@ describe('GlobalSmartLoadingView', () => {
    expect(adjustSmartLoadingItem).toHaveBeenCalledWith(plan.id, plan.items[0].id, 4, plan.version, plan.items[0].version)
  })

+  it('shows a shared pallet once with exact members and a text-only join action', async () => {
+    vi.mocked(listSmartLoadingCandidates).mockResolvedValue(candidatePage([{
+      ...candidate, unitType: 'SEALED_PALLET', palletId: '801', palletNo: 'DP-0025', indivisible: true,
+      availablePackageCount: 13, unitGrossWeightKg: 10,
+      groupMembers: [
+        { accountId: '1', inboundId: '180', orderId: '180', orderNo: 'O180', inboundCode: 'I180', customerName: '客户', availablePackageCount: 3, orderStatusSnapshot: 'WAIT_SPLIT', expectedArrivalAt: null },
+        { accountId: '1', inboundId: '181', orderId: '181', orderNo: 'O181', inboundCode: 'I181', customerName: '客户', availablePackageCount: 10, orderStatusSnapshot: 'WAIT_SPLIT', expectedArrivalAt: null },
+      ],
+    }]))
+    const wrapper = mount(GlobalSmartLoadingView, { global: { plugins: [ElementPlus] } })
+    await flushPromises()
+    const buttons = wrapper.findAll('.el-table__body-wrapper button').filter(button => button.text() === '加入')
+    expect(buttons).toHaveLength(1)
+    expect(buttons[0].find('svg').exists()).toBe(false)
+    expect(wrapper.text()).toContain('I180：3 箱')
+    expect(wrapper.text()).toContain('I181：10 箱')
+    expect(wrapper.text()).toContain('130 kg')
+    expect(wrapper.get('.candidate-pane').text()).toContain('整托加入 · 不可拆')
+    expect(wrapper.get('.plan-pane').text()).toContain('按箱加入')
+    expect(wrapper.text()).toContain('装柜规则')
+    expect(wrapper.text()).not.toContain('分配单位')
+    wrapper.unmount()
+  })
+
+  it('uses one loading-rule column and expandable group details in both workbenches', () => {
+    for (const page of ['GlobalSmartLoadingView.vue', 'SmartLoadingWorkbenchView.vue']) {
+      const source = readFileSync(resolve(process.cwd(), `src/modules/container-loading/pages/${page}`), 'utf8')
+      expect(source.match(/label: '装柜规则'/g)).toHaveLength(2)
+      expect(source).not.toContain("label: '分配单位'")
+      expect(source).not.toContain('<template #unitType=')
+      expect(source.match(/<summary>整组加入 · 不可拆<\/summary>/g)).toHaveLength(2)
+      expect(source.match(/'整托加入 · 不可拆' : '按箱加入'/g)).toHaveLength(2)
+      expect(source).toContain("row.memberOrderSummaries.join('；')")
+    }
+  })
+
+  it('searches any shared-pallet inbound, retains its complete composition across pages, and resets the search', async () => {
+    const sharedPallet = {
+      ...candidate, inboundId: '180', inboundCode: 'I180', unitType: 'SEALED_PALLET' as const,
+      palletId: '801', palletNo: 'DP-0025', indivisible: true, availablePackageCount: 13,
+      groupMembers: [
+        { accountId: '1', inboundId: '180', orderId: '180', orderNo: 'O180', inboundCode: 'I180', customerName: '客户', availablePackageCount: 3, orderStatusSnapshot: 'WAIT_SPLIT', expectedArrivalAt: null },
+        { accountId: '1', inboundId: '181', orderId: '181', orderNo: 'O181', inboundCode: 'I181', customerName: '客户', availablePackageCount: 10, orderStatusSnapshot: 'WAIT_SPLIT', expectedArrivalAt: null },
+      ],
+    }
+    vi.mocked(listSmartLoadingCandidates).mockResolvedValue(candidatePage([sharedPallet], 1, 20, 21))
+    const wrapper = mount(GlobalSmartLoadingView, { global: { plugins: [ElementPlus] } })
+    await flushPromises()
+    const filters = { warehouseId: '', customerId: '', inboundCode: '  I181  ', createdRange: [], expectedArrivalRange: [], orderStatuses: [] }
+    wrapper.getComponent(QueryToolbar).vm.$emit('search', filters)
+    await flushPromises()
+    expect(listSmartLoadingCandidates).toHaveBeenLastCalledWith({ channelGroupCodes: ['MATSON_CLX'], inboundCode: 'I181', page: 1, size: 20 })
+    const pane = wrapper.get('.candidate-pane')
+    expect(pane.text()).toContain('I180：3 箱')
+    expect(pane.text()).toContain('I181：10 箱')
+    expect(pane.findAll('.el-table__body-wrapper button').filter(button => button.text() === '加入')).toHaveLength(1)
+
+    await pane.get('button[aria-label="下一页"]').trigger('click')
+    await flushPromises()
+    expect(listSmartLoadingCandidates).toHaveBeenLastCalledWith({ channelGroupCodes: ['MATSON_CLX'], inboundCode: 'I181', page: 2, size: 20 })
+
+    wrapper.getComponent(QueryToolbar).vm.$emit('reset', { ...filters, inboundCode: '' })
+    await flushPromises()
+    expect(listSmartLoadingCandidates).toHaveBeenLastCalledWith({ channelGroupCodes: ['MATSON_CLX'], page: 1, size: 20 })
+    wrapper.unmount()
+  })
+
  it('rounds capacity percentages and hides column settings in embedded tables', async () => {
    vi.mocked(getSmartLoadingPlanByBooking).mockResolvedValue({
      ...plan,
@@ -607,8 +675,8 @@ describe('GlobalSmartLoadingView', () => {
    const wrapper = mount(GlobalSmartLoadingView, { global: { plugins: [ElementPlus] } })
    await flushPromises()

-    expect(wrapper.text()).toContain('0.16%')
-    expect(wrapper.text()).toContain('0.03%')
+    expect(wrapper.text()).toContain('0.18%')
+    expect(wrapper.text()).toContain('0.05%')
    expect(wrapper.text()).not.toContain('0.169999999')
    expect(wrapper.findAll('button[aria-label="列设置"]')).toHaveLength(0)
  })
@@ -886,6 +954,31 @@ describe('GlobalSmartLoadingView', () => {
    expect(removeSmartLoadingItem).not.toHaveBeenCalled()
  })

+  it('shows every inbound code and its box count for an assigned sealed pallet', async () => {
+    const palletItem = {
+      ...plan.items[0], inboundId: '180', inboundCode: 'I180', unitType: 'SEALED_PALLET' as const,
+      palletId: '801', palletNo: 'DP-260914-0025', indivisible: true, packageCount: 11,
+      pickedPackageCount: 0, minPackageCount: 11, canAdjust: false, canRemove: true,
+    }
+    vi.mocked(getSmartLoadingPlanByBooking).mockResolvedValue({
+      ...plan,
+      items: [palletItem],
+      palletMembers: [{ palletId: '801', members: [
+        { accountId: '1', inboundId: '180', orderId: '280', orderNo: 'O180', inboundCode: 'I180', customerName: '客户', availablePackageCount: 6, orderStatusSnapshot: null, expectedArrivalAt: null },
+        { accountId: '1', inboundId: '181', orderId: '281', orderNo: 'O181', inboundCode: 'I181', customerName: '客户', availablePackageCount: 5, orderStatusSnapshot: null, expectedArrivalAt: null },
+      ] }],
+    })
+
+    const wrapper = mount(GlobalSmartLoadingView, { global: { plugins: [ElementPlus] } })
+    await flushPromises()
+
+    const row = wrapper.findAll('.plan-pane .el-table__body-wrapper tr').find((candidateRow) => candidateRow.text().includes('DP-260914-0025'))
+    expect(row).toBeDefined()
+    expect(row!.text()).toContain('2 个入仓码 · 展开')
+    expect(row!.text()).toContain('I180：6 箱')
+    expect(row!.text()).toContain('I181：5 箱')
+  })
+
  it('renders final completion capability as read-only with the server reason', async () => {
    vi.mocked(getSmartLoadingPlanByBooking).mockResolvedValue({
      ...plan,
@@ -1,6 +1,7 @@
 <script setup lang="ts">
 import { computed, onMounted, reactive, ref } from 'vue'
-import { Pencil, Plus, RefreshCw, Sparkles, Trash2 } from '@lucide/vue'
+import { Pencil, RefreshCw, Sparkles, Trash2 } from '@lucide/vue'
+import SmartLoadingCandidateInbounds from '../components/SmartLoadingCandidateInbounds.vue'
 import { ElMessage, ElMessageBox } from 'element-plus'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
 import { listPlatformTenants, type PlatformTenantResource } from '@/modules/iam'
@@ -30,6 +31,7 @@ import {
 } from '../api/platformContainerLoading'
 import type {
  SmartLoadingCandidate,
+  SmartLoadingCandidateGroupMember,
  SmartLoadingPlan,
  SmartLoadingWorkbenchContainer,
 } from '../types'
@@ -121,7 +123,6 @@ function groupMemberLabel(group: SmartLoadingPlanCoLoadGroup) {
    : `${group.memberOrderCount} 票 · ${group.inboundFragmentCount} 个入仓片段`
 }
 function candidateTotalGrossWeight(candidate: SmartLoadingCandidate) {
-  if (candidate.unitType === 'SEALED_PALLET') return candidate.unitGrossWeightKg
  return candidate.unitGrossWeightKg == null ? null : Number(candidate.unitGrossWeightKg) * Number(candidate.availablePackageCount || 0)
 }
 function candidateTotalVolume(candidate: SmartLoadingCandidate) {
@@ -146,7 +147,10 @@ const displayedCandidates = computed<SmartLoadingCandidateRow[]>(() => {
    }
  })
 })
-type SmartLoadingPlanRow = SmartLoadingInboundItem & { coLoadGroup: SmartLoadingPlanCoLoadGroup | null; memberInboundCodes: string[]; memberOrderSummaries: string[] }
+const planPalletMembersByPalletId = computed(() => new Map(
+  (plan.value?.palletMembers || []).map((entry) => [entry.palletId, entry.members]),
+))
+type SmartLoadingPlanRow = SmartLoadingInboundItem & { coLoadGroup: SmartLoadingPlanCoLoadGroup | null; palletMembers: SmartLoadingCandidateGroupMember[]; memberInboundCodes: string[]; memberOrderSummaries: string[] }
 const displayedPlanItems = computed<SmartLoadingPlanRow[]>(() => {
  const inboundRows = groupSmartLoadingItems(plan.value?.items || [])
  const result: SmartLoadingPlanRow[] = []
@@ -154,7 +158,7 @@ const displayedPlanItems = computed<SmartLoadingPlanRow[]>(() => {
  for (const row of inboundRows) {
    const group = planGroupsByInboundId.value.get(row.inboundId)
    if (!group) {
-      result.push({ ...row, coLoadGroup: null, memberInboundCodes: [row.inboundCode || '入仓码暂缺'], memberOrderSummaries: memberOrderSummaries([row]) })
+      result.push({ ...row, coLoadGroup: null, palletMembers: row.palletId ? planPalletMembersByPalletId.value.get(row.palletId) || [] : [], memberInboundCodes: [row.inboundCode || '入仓码暂缺'], memberOrderSummaries: memberOrderSummaries([row]) })
      continue
    }
    grouped.set(group.groupId, [...(grouped.get(group.groupId) || []), row])
@@ -178,6 +182,7 @@ const displayedPlanItems = computed<SmartLoadingPlanRow[]>(() => {
      sourceItems: rows.flatMap((row) => row.sourceItems),
      detailCount: rows.reduce((sum, row) => sum + row.detailCount, 0),
      coLoadGroup: group,
+      palletMembers: [],
      memberInboundCodes: rows.map((row) => row.inboundCode || '入仓码暂缺'),
      memberOrderSummaries: memberOrderSummaries(rows),
    })
@@ -228,10 +233,9 @@ function preferredContainerId() {

 const candidateColumns: DataTableColumn[] = [
  { key: 'actions', label: '操作', width: 90, fixed: 'left', slotName: 'actions' },
-  { key: 'inboundCode', prop: 'inboundCode', label: '入仓码', minWidth: 140, fixed: 'left', showOverflowTooltip: true },
+  { key: 'inboundCode', label: '入仓码', minWidth: 220, fixed: 'left', slotName: 'candidateInbounds' },
  { key: 'palletNo', prop: 'palletNo', label: '托盘号', minWidth: 145, showOverflowTooltip: true },
-  { key: 'unitType', label: '分配单位', width: 105, slotName: 'unitType' },
-  { key: 'coLoadGroup', label: '同柜', minWidth: 80, slotName: 'coLoadGroup' },
+  { key: 'coLoadGroup', label: '装柜规则', minWidth: 170, slotName: 'coLoadGroup' },
  { key: 'customerName', prop: 'customerName', label: '客户', minWidth: 70, slotName: 'customerName' },
  { key: 'orderStatusSnapshot', prop: 'orderStatusSnapshot', label: '订单状态', width: 100, slotName: 'orderStatusSnapshot' },
  { key: 'availablePackageCount', prop: 'availablePackageCount', label: '箱数', width: 80 },
@@ -244,9 +248,9 @@ const candidateColumns: DataTableColumn[] = [
 ]
 const itemColumns: DataTableColumn[] = [
  { key: 'actions', label: '操作', width: 90, fixed: 'left', slotName: 'actions' },
-  { key: 'inboundCode', prop: 'inboundCode', label: '入仓码', minWidth: 140, fixed: 'left', showOverflowTooltip: true },
+  { key: 'inboundCode', label: '入仓码', minWidth: 220, fixed: 'left', slotName: 'planInbounds' },
  { key: 'palletNo', prop: 'palletNo', label: '托盘号', minWidth: 145, showOverflowTooltip: true },
-  { key: 'coLoadGroup', label: '同柜', minWidth: 80, slotName: 'coLoadGroup' },
+  { key: 'coLoadGroup', label: '装柜规则', minWidth: 170, slotName: 'coLoadGroup' },
  { key: 'customerName', prop: 'customerName', label: '客户', minWidth: 70, slotName: 'customerName' },
  { key: 'packageCount', label: '分配箱数', width: 140, slotName: 'packageCount' },
  { key: 'grossWeightKg', label: '毛重', width: 90, slotName: 'weight' },
@@ -745,10 +749,11 @@ onMounted(() => { void load(); void loadCustomers() })
                  plain
                  :disabled="mutating || candidateBlocked(row as SmartLoadingCandidateRow)"
                  @click="openAssign(row)"
-                ><Plus :size="15" />{{ row.unitType === 'SEALED_PALLET' ? '整托分配' : row.coLoadGroupId ? '整组分配' : '加入' }}</el-button>
+                >加入</el-button>
              </template>
+              <template #candidateInbounds="{ row }"><SmartLoadingCandidateInbounds :candidate="row as SmartLoadingCandidate" /></template>
              <template #customerName="{ row }"><LineClampText :content="row.customerName" /></template>
-              <template #coLoadGroup="{ row }"><div v-if="row.coLoadGroupId" class="candidate-group"><el-tag size="small" type="warning"><LineClampText :content="`${row.groupNo} · ${row.memberOrderCount} 票 · ${row.inboundFragmentCount} 个入仓片段`" /></el-tag><LineClampText :content="row.memberOrderSummaries.join('；')" /><LineClampText :content="`整组 ${row.groupTotalBoxes} 箱，必须全量进入同一柜`" /><LineClampText v-if="row.blockReason" class="candidate-block" :content="row.blockReason" /><LineClampText v-else-if="row.locked" content="该组已锁定，不能重复分配" /></div><LineClampText v-else :content="row.unitType === 'SEALED_PALLET' ? '封托不可拆' : '普通单票'" /></template>
+              <template #coLoadGroup="{ row }"><details v-if="row.coLoadGroupId" class="candidate-group"><summary>整组加入 · 不可拆</summary><el-tag size="small" type="warning"><LineClampText :content="`${row.groupNo} · ${row.memberOrderCount} 票 · ${row.inboundFragmentCount} 个入仓片段`" /></el-tag><LineClampText :content="row.memberOrderSummaries.join('；')" /><LineClampText :content="`整组 ${row.groupTotalBoxes} 箱，必须全量进入同一柜`" /><LineClampText v-if="row.blockReason" class="candidate-block" :content="row.blockReason" /><LineClampText v-else-if="row.locked" content="该组已锁定，不能重复分配" /></details><LineClampText v-else :content="row.unitType === 'SEALED_PALLET' ? '整托加入 · 不可拆' : '按箱加入'" /></template>
              <template #orderStatusSnapshot="{ row }"><el-tag size="small" effect="plain">{{ candidateStatusLabel(row.orderStatusSnapshot) }}</el-tag></template>
              <template #unitGrossWeight="{ row }">{{ formatMeasurement(row.unitGrossWeightKg, 'kg', 1) }}</template>
              <template #candidateTotalWeight="{ row }">{{ formatMeasurement(row.totalGrossWeightKg, 'kg', 1) }}</template>
@@ -821,10 +826,10 @@ onMounted(() => { void load(); void loadCustomers() })
              </div>
              <DataTable :data="displayedPlanItems" :columns="itemColumns" :loading="selectionLoading || mutating" stripe preference-key="global-smart-loading-items" column-settings-mode="hide" empty-text="当前柜次暂无装柜明细">
                <template #actions="{ row }"><div class="row-actions"><el-button v-if="canDelete && editable && row.canRemove" size="small" type="danger" text :disabled="mutating" @click="remove(row)"><Trash2 :size="15" />删除</el-button></div></template>
+                <template #planInbounds="{ row }"><SmartLoadingCandidateInbounds :members="row.palletMembers" :sealed-pallet="row.unitType === 'SEALED_PALLET'" :fallback-inbound-code="row.inboundCode" /></template>
                <template #customerName="{ row }"><LineClampText :content="row.customerName" /></template>
-                <template #coLoadGroup="{ row }"><div v-if="row.coLoadGroup" class="candidate-group"><el-tag size="small" type="warning"><LineClampText :content="`${row.coLoadGroup.groupNo} · ${groupMemberLabel(row.coLoadGroup)}`" /></el-tag><LineClampText :content="row.memberOrderSummaries.join('；')" /><LineClampText :content="`固定 ${row.coLoadGroup.fullPackageCount} 箱 · ${row.coLoadGroup.lockedPlanId ? '已锁定' : '未锁定'}`" /></div><LineClampText v-else :content="row.unitType === 'SEALED_PALLET' ? '封托不可拆' : '普通单票'" /></template>
+                <template #coLoadGroup="{ row }"><details v-if="row.coLoadGroup" class="candidate-group"><summary>整组加入 · 不可拆</summary><el-tag size="small" type="warning"><LineClampText :content="`${row.coLoadGroup.groupNo} · ${groupMemberLabel(row.coLoadGroup)}`" /></el-tag><LineClampText :content="row.memberOrderSummaries.join('；')" /><LineClampText :content="`固定 ${row.coLoadGroup.fullPackageCount} 箱 · ${row.coLoadGroup.lockedPlanId ? '已锁定' : '未锁定'}`" /></details><LineClampText v-else :content="row.unitType === 'SEALED_PALLET' ? '整托加入 · 不可拆' : '按箱加入'" /></template>
                <template #packageCount="{ row }"><LineClampText v-if="row.unitType === 'SEALED_PALLET'" :content="`${row.packageCount} 箱（整托固定）`" /><LineClampText v-else-if="row.coLoadGroup" :content="`${row.packageCount} 箱（整组固定）`" /><div v-else class="package-count-editor"><el-input-number v-if="editingQuantityId === row.id" v-model="quantityDrafts[row.id]" :min="row.minPackageCount" :max="adjustmentMax(row)" :step="1" :controls="false" :disabled="mutating" placeholder="请输入使用箱数" @blur="adjust(row)" @keyup.enter="adjust(row)" /><div v-else class="package-count-summary"><div class="package-count-used"><strong>使用：{{ row.packageCount }}</strong><el-button v-if="canAssign && editable && row.canAdjust" link circle :disabled="mutating" aria-label="调整箱数" @click="startQuantityEdit(row)"><Pencil :size="14" /></el-button></div><small v-if="(row.remainingPackageCount ?? 0) > 0">未用：{{ row.remainingPackageCount }}</small></div><LineClampText v-if="row.detailCount > 1 && editable" content="多规格，需删除后重加" /><LineClampText v-if="row.pickedPackageCount > 0" :content="`已拣 ${row.pickedPackageCount} 箱`" /></div></template>
-                <template #unitType="{ row }"><el-tag size="small" :type="row.unitType === 'SEALED_PALLET' ? 'success' : 'info'">{{ row.unitType === 'SEALED_PALLET' ? '封托托盘' : '箱件' }}</el-tag></template>
                <template #weight="{ row }">{{ formatNumber(Number(row.grossWeightKg || 0), 1) }} kg</template>
                <template #volume="{ row }">{{ formatNumber(Number(row.volumeCbm || 0)) }} m³</template>
              </DataTable>
@@ -845,7 +850,8 @@ onMounted(() => { void load(); void loadCustomers() })
              <el-alert :title="selectedCandidate.blockReason || '同柜且不可拆：全部订单及其入仓片段按完整箱数一次加入，不能部分输入、单独分配或单独移除。'" :type="selectedCandidate.blockReason ? 'error' : 'warning'" :closable="false" />
            </template>
            <template v-else-if="selectedCandidate.unitType === 'SEALED_PALLET'">
-              <p>托盘号 {{ selectedCandidate.palletNo || '—' }} · 入仓码 {{ selectedCandidate.inboundCode || '—' }} · {{ selectedCandidate.availablePackageCount }} 箱</p>
+              <p>托盘号 {{ selectedCandidate.palletNo || '—' }} · 整托 {{ selectedCandidate.availablePackageCount }} 箱</p>
+              <SmartLoadingCandidateInbounds :candidate="selectedCandidate" />
              <el-alert title="该封托托盘将作为一个不可拆分单元整托加入；装柜阶段复用此托盘，不会重新生成工作托盘。" type="warning" :closable="false" />
            </template>
            <template v-else>
@@ -29,7 +29,7 @@ const container = {
 const planResponse = {
  id: '99', bookingId: container.id, planNo: 'LP-99', status: 'EDITING' as const, containerNo: 'MSCU-1', voyageNo: null, version: 2,
  canAssign: true, canEdit: true, blockedReason: null, finalCompletionStatus: 'NOT_STARTED' as const,
-  pdaTaskId: null, pdaTaskStatus: null, pdaTaskVersion: null, coLoadGroups: [], items: [],
+  pdaTaskId: null, pdaTaskStatus: null, pdaTaskVersion: null, coLoadGroups: [], palletMembers: [], items: [],
 }
 const candidate = { accountId: '1', inboundId: '2', orderId: '4', orderNo: 'ORD-1', inboundCode: 'IN-1', warehouseId: '8', channelCode: 'ZBYHK', channelName: '美森正班海卡包税', destinationWarehouseId: '9', destinationWarehouseCode: 'LAX9', destinationWarehouseName: 'LAX9', customerName: '示例企业', goodsSummary: '服装', availablePackageCount: 12, unitGrossWeightKg: 10, unitNetWeightKg: 9, averageUnitVolumeCbm: 0.2, availableVolumeCbm: 2.4, coLoadGroupId: null, groupNo: null, memberCount: null, groupTotalBoxes: null, locked: null, blockReason: null }
 function candidatePage(records: unknown[]) {
@@ -78,6 +78,33 @@ describe('SmartLoadingWorkbenchView', () => {
    expect(wrapper.text()).toContain('150% 容量上限')
  })

+  it('shows the full inbound composition for an assigned sealed pallet', async () => {
+    vi.mocked(getSmartLoadingPlanByBooking).mockResolvedValue({
+      ...planResponse,
+      items: [{
+        id: '101', loadingPlanId: '99', accountId: '1', inboundId: '180', inboundDetailId: '201', orderId: '280',
+        orderNo: 'O180', inboundCode: 'I180', customerName: '客户', destinationWarehouseId: '9',
+        destinationWarehouseCode: 'LAX9', destinationWarehouseName: 'LAX9', skuCode: 'SKU-1', productNameZh: '货物',
+        unitType: 'SEALED_PALLET', palletId: '801', palletNo: 'DP-260914-0025', indivisible: true,
+        packageCount: 11, productQuantity: 110, grossWeightKg: 109.2, volumeCbm: 1.87, loadSequence: 1,
+        version: 1, pickedPackageCount: 0, minPackageCount: 11, canAdjust: false, canRemove: true,
+      }],
+      palletMembers: [{ palletId: '801', members: [
+        { accountId: '1', inboundId: '180', orderId: '280', orderNo: 'O180', inboundCode: 'I180', customerName: '客户', availablePackageCount: 6, orderStatusSnapshot: null, expectedArrivalAt: null },
+        { accountId: '1', inboundId: '181', orderId: '281', orderNo: 'O181', inboundCode: 'I181', customerName: '客户', availablePackageCount: 5, orderStatusSnapshot: null, expectedArrivalAt: null },
+      ] }],
+    })
+    const router = createRouter({ history: createMemoryHistory(), routes: [{ path: '/container-loading/:containerId/smart-loading', component: SmartLoadingWorkbenchView }] })
+    await router.push(`/container-loading/${container.id}/smart-loading`); await router.isReady()
+    const wrapper = mount(SmartLoadingWorkbenchView, { global: { plugins: [ElementPlus, router] } })
+    await flushPromises()
+
+    const row = wrapper.findAll('.el-table__body-wrapper tr').find((candidateRow) => candidateRow.text().includes('DP-260914-0025'))
+    expect(row).toBeDefined()
+    expect(row!.text()).toContain('I180：6 箱')
+    expect(row!.text()).toContain('I181：5 箱')
+  })
+
  it('uses loading plan capabilities to keep PDA increments editable', async () => {
    vi.mocked(getContainer).mockResolvedValue({ ...container, planStatus: 'LOADING' })
    vi.mocked(getSmartLoadingPlanByBooking).mockResolvedValue({ ...planResponse, status: 'LOADING', pdaTaskId: '700', pdaTaskStatus: 'LOADING', pdaTaskVersion: 4 })
@@ -159,8 +186,8 @@ describe('SmartLoadingWorkbenchView', () => {
    expect(wrapper.text()).toContain('3 个入仓片段')
    expect(wrapper.text()).toContain('ORD-1：IN-201、IN-203')
    expect(wrapper.text()).toContain('整组 12 箱')
-    expect(wrapper.findAll('button').filter((button) => button.text().includes('整组分配'))).toHaveLength(1)
-    await wrapper.findAll('button').find((button) => button.text().includes('整组分配'))!.trigger('click')
+    expect(wrapper.findAll('.el-table__body-wrapper button').filter((button) => button.text() === '加入')).toHaveLength(1)
+    await wrapper.findAll('.el-table__body-wrapper button').find((button) => button.text() === '加入')!.trigger('click')
    await flushPromises()
    ;([...document.body.querySelectorAll('button')].find((button) => button.textContent?.includes('确认整组分配')) as HTMLButtonElement).click()
    await flushPromises()
@@ -181,7 +208,7 @@ describe('SmartLoadingWorkbenchView', () => {
    await flushPromises()
    expect(wrapper.text()).toContain('CLG-9900 · 3 票')
    expect(wrapper.text()).toContain('同柜不可拆组成员候选不齐，缺少 1 票')
-    const button = wrapper.findAll('button').find((item) => item.text().includes('整组分配'))!
+    const button = wrapper.findAll('.el-table__body-wrapper button').find((item) => item.text() === '加入')!
    expect(button.attributes('disabled')).toBeDefined()
    expect(wrapper.text()).not.toContain('本次计划装柜箱数')
  })
@@ -1,4 +1,5 @@
 <script setup lang="ts">
+import SmartLoadingCandidateInbounds from '../components/SmartLoadingCandidateInbounds.vue'
 import '@/styles/adminDensity.css'
 import { computed, onMounted, reactive, ref } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
@@ -17,7 +18,7 @@ import {
  getSmartLoadingPlanByBooking, listSmartLoadingCandidates,
  recommendSmartLoading, removeSmartLoadingGroup, removeSmartLoadingItem,
 } from '../api/platformContainerLoading'
-import type { ContainerBookingResource, SmartLoadingCandidate, SmartLoadingPlan } from '../types'
+import type { ContainerBookingResource, SmartLoadingCandidate, SmartLoadingCandidateGroupMember, SmartLoadingPlan } from '../types'
 import { groupSmartLoadingItems, type SmartLoadingInboundItem } from '../smartLoadingItems'
 import { loadSmartLoadingPlanCoLoadGroups, type SmartLoadingPlanCoLoadGroup } from '../smartLoadingPlanGroups'
 import { getSmartLoadingChannelGroup } from '../smartLoadingChannelGroups'
@@ -79,7 +80,10 @@ const displayedCandidates = computed<SmartLoadingCandidateRow[]>(() => {
    }
  })
 })
-type SmartLoadingPlanRow = SmartLoadingInboundItem & { coLoadGroup: SmartLoadingPlanCoLoadGroup | null; memberInboundCodes: string[]; memberOrderSummaries: string[] }
+const planPalletMembersByPalletId = computed(() => new Map(
+  (plan.value?.palletMembers || []).map((entry) => [entry.palletId, entry.members]),
+))
+type SmartLoadingPlanRow = SmartLoadingInboundItem & { coLoadGroup: SmartLoadingPlanCoLoadGroup | null; palletMembers: SmartLoadingCandidateGroupMember[]; memberInboundCodes: string[]; memberOrderSummaries: string[] }
 const displayedPlanItems = computed<SmartLoadingPlanRow[]>(() => {
  const inboundRows = groupSmartLoadingItems(plan.value?.items || [])
  const result: SmartLoadingPlanRow[] = []
@@ -87,7 +91,7 @@ const displayedPlanItems = computed<SmartLoadingPlanRow[]>(() => {
  for (const row of inboundRows) {
    const group = planGroupsByInboundId.value.get(row.inboundId)
    if (!group) {
-      result.push({ ...row, coLoadGroup: null, memberInboundCodes: [row.inboundCode || '入仓码暂缺'], memberOrderSummaries: memberOrderSummaries([row]) })
+      result.push({ ...row, coLoadGroup: null, palletMembers: row.palletId ? planPalletMembersByPalletId.value.get(row.palletId) || [] : [], memberInboundCodes: [row.inboundCode || '入仓码暂缺'], memberOrderSummaries: memberOrderSummaries([row]) })
      continue
    }
    grouped.set(group.groupId, [...(grouped.get(group.groupId) || []), row])
@@ -113,6 +117,7 @@ const displayedPlanItems = computed<SmartLoadingPlanRow[]>(() => {
      sourceItems: rows.flatMap((row) => row.sourceItems),
      detailCount: rows.reduce((sum, row) => sum + row.detailCount, 0),
      coLoadGroup: group,
+      palletMembers: [],
      memberInboundCodes: rows.map((row) => row.inboundCode || '入仓码暂缺'),
      memberOrderSummaries: memberOrderSummaries(rows),
    })
@@ -133,7 +138,7 @@ const itemColumns: DataTableColumn[] = [
  { key: 'sequence', prop: 'loadSequence', label: '顺序', width: 75 },
  { key: 'order', label: '入仓码', minWidth: 190, slotName: 'order' },
  { key: 'palletNo', prop: 'palletNo', label: '托盘号', minWidth: 150, showOverflowTooltip: true },
-  { key: 'coLoadGroup', label: '同柜不可拆', minWidth: 210, slotName: 'coLoadGroup' },
+  { key: 'coLoadGroup', label: '装柜规则', minWidth: 170, slotName: 'coLoadGroup' },
  { key: 'customerName', prop: 'customerName', label: '客户', minWidth: 150, slotName: 'customerName' },
  { key: 'goods', label: '货物', minWidth: 190, slotName: 'goods' },
  { key: 'packageCount', label: '分配箱数', width: 150, slotName: 'packageCount' },
@@ -142,10 +147,9 @@ const itemColumns: DataTableColumn[] = [
 ]
 const candidateColumns: DataTableColumn[] = [
  { key: 'actions', label: '操作', width: 110, fixed: 'left', slotName: 'actions' },
-  { key: 'inboundCode', prop: 'inboundCode', label: '入仓码', minWidth: 190, fixed: 'left', showOverflowTooltip: true },
+  { key: 'inboundCode', label: '入仓码', minWidth: 220, fixed: 'left', slotName: 'candidateInbounds' },
  { key: 'palletNo', prop: 'palletNo', label: '托盘号', minWidth: 150, showOverflowTooltip: true },
-  { key: 'unitType', label: '分配单位', width: 110, slotName: 'unitType' },
-  { key: 'coLoadGroup', label: '同柜不可拆', minWidth: 210, slotName: 'coLoadGroup' },
+  { key: 'coLoadGroup', label: '装柜规则', minWidth: 170, slotName: 'coLoadGroup' },
  { key: 'customerName', prop: 'customerName', label: '客户', minWidth: 150, slotName: 'customerName' },
  { key: 'goodsSummary', prop: 'goodsSummary', label: '货物摘要', minWidth: 180, slotName: 'goodsSummary' },
  { key: 'availablePackageCount', prop: 'availablePackageCount', label: '箱数', width: 90 },
@@ -384,27 +388,27 @@ onMounted(load)
        <DataTable :data="displayedPlanItems" :columns="itemColumns" :loading="loading || mutating" stripe preference-key="smart-loading-items" column-settings-mode="hide" empty-text="暂无已分配货物">
          <template #toolbar-start><div><h2>{{ displayContainerNo(container) }} 装柜方案</h2><p>智能建议必须经人工核对。</p></div></template>
          <template #actions="{ row }"><div class="row-actions density-actions"><el-button data-tone="danger" class="density-action" v-if="canDelete && editable && row.canRemove" size="small" type="danger" plain @click="remove(row)">删除</el-button></div></template>
-          <template #order="{ row }"><strong>{{ row.inboundCode || '—' }}</strong></template>
+          <template #order="{ row }"><SmartLoadingCandidateInbounds :members="row.palletMembers" :sealed-pallet="row.unitType === 'SEALED_PALLET'" :fallback-inbound-code="row.inboundCode" /></template>
          <template #customerName="{ row }"><LineClampText :content="row.customerName" /></template>
-          <template #coLoadGroup="{ row }"><div v-if="row.coLoadGroup" class="candidate-group"><el-tag size="small" type="warning"><LineClampText :content="`${row.coLoadGroup.groupNo} · ${groupMemberLabel(row.coLoadGroup)}`" /></el-tag><LineClampText :content="row.memberOrderSummaries.join('；')" /><LineClampText :content="`全部入仓片段联动，固定 ${row.coLoadGroup.fullPackageCount} 箱`" /></div><LineClampText v-else :content="row.unitType === 'SEALED_PALLET' ? '封托不可拆' : '普通单票'" /></template>
+          <template #coLoadGroup="{ row }"><details v-if="row.coLoadGroup" class="candidate-group"><summary>整组加入 · 不可拆</summary><el-tag size="small" type="warning"><LineClampText :content="`${row.coLoadGroup.groupNo} · ${groupMemberLabel(row.coLoadGroup)}`" /></el-tag><LineClampText :content="row.memberOrderSummaries.join('；')" /><LineClampText :content="`全部入仓片段联动，固定 ${row.coLoadGroup.fullPackageCount} 箱`" /></details><LineClampText v-else :content="row.unitType === 'SEALED_PALLET' ? '整托加入 · 不可拆' : '按箱加入'" /></template>
          <template #goods="{ row }"><div class="goods-cell"><LineClampText :content="row.productNameZh || '未命名货物'" /><LineClampText class="goods-cell__sku" :content="row.skuCode || '无 SKU'" /></div></template>
          <template #packageCount="{ row }"><LineClampText v-if="row.unitType === 'SEALED_PALLET'" :content="`${row.packageCount} 箱（整托固定）`" /><LineClampText v-else-if="row.coLoadGroup" :content="`${row.packageCount} 箱（整组固定）`" /><div v-else class="package-count-editor"><el-input-number v-if="editingQuantityId === row.id" v-model="quantityDrafts[row.id]" :min="row.minPackageCount" :max="adjustmentMax(row)" :step="1" :controls="false" :disabled="mutating" placeholder="请输入使用箱数" @blur="adjust(row)" @keyup.enter="adjust(row)" /><div v-else class="package-count-summary"><div class="package-count-used"><strong>使用：{{ row.packageCount }}</strong><el-button v-if="canAssign && editable && row.canAdjust" class="density-action" :disabled="mutating" aria-label="调整箱数" @click="startQuantityEdit(row)">调整</el-button></div><small v-if="(row.remainingPackageCount ?? 0) > 0">未用：{{ row.remainingPackageCount }}</small></div><LineClampText v-if="row.detailCount > 1 && editable" :content="`含 ${row.detailCount} 个规格，需删除后重加`" /><LineClampText v-if="row.pickedPackageCount > 0" :content="`已拣 ${row.pickedPackageCount} 箱`" /></div></template>
          <template #volume="{ row }">{{ formatNumber(Number(row.volumeCbm || 0)) }} m³</template><template #weight="{ row }">{{ formatNumber(Number(row.grossWeightKg || 0),1) }} kg</template>
        </DataTable>
        <DataTable :data="displayedCandidates" :columns="candidateColumns" :loading="loading || mutating" stripe preference-key="smart-loading-candidates" column-settings-mode="hide" empty-text="当前仓库暂无可装柜货物">
          <template #toolbar-start><div><h2>候选货物</h2><p>系统基于装柜仓库、物流渠道、可用箱数及 150% 容量上限校验。</p></div></template>
-          <template #actions="{ row }"><el-button data-tone="primary" class="density-action" v-if="canAssign && assignable" size="small" type="primary" plain :disabled="candidateBlocked(row as SmartLoadingCandidateRow)" @click="openAssign(row)">{{ row.unitType === 'SEALED_PALLET' ? '整托分配' : row.coLoadGroupId ? '整组分配' : '分配' }}</el-button></template>
+          <template #actions="{ row }"><el-button data-tone="primary" class="density-action" v-if="canAssign && assignable" size="small" type="primary" plain :disabled="candidateBlocked(row as SmartLoadingCandidateRow)" @click="openAssign(row)">加入</el-button></template>
+          <template #candidateInbounds="{ row }"><SmartLoadingCandidateInbounds :candidate="row as SmartLoadingCandidate" /></template>
          <template #customerName="{ row }"><LineClampText :content="row.customerName" /></template>
          <template #goodsSummary="{ row }"><LineClampText :content="row.goodsSummary || '—'" /></template>
-          <template #coLoadGroup="{ row }"><div v-if="row.coLoadGroupId" class="candidate-group"><el-tag size="small" type="warning"><LineClampText :content="`${row.groupNo} · ${row.memberOrderCount} 票 · ${row.inboundFragmentCount} 个入仓片段`" /></el-tag><LineClampText :content="row.memberOrderSummaries.join('；')" /><LineClampText :content="`整组 ${row.groupTotalBoxes} 箱，必须全量进入同一柜`" /><LineClampText v-if="row.blockReason" class="candidate-block" :content="row.blockReason" /><LineClampText v-else-if="row.locked" content="该组已锁定，不能重复分配" /></div><LineClampText v-else :content="row.unitType === 'SEALED_PALLET' ? '封托不可拆' : '普通单票'" /></template>
-          <template #unitType="{ row }"><el-tag size="small" :type="row.unitType === 'SEALED_PALLET' ? 'success' : 'info'">{{ row.unitType === 'SEALED_PALLET' ? '封托托盘' : '箱件' }}</el-tag></template>
+          <template #coLoadGroup="{ row }"><details v-if="row.coLoadGroupId" class="candidate-group"><summary>整组加入 · 不可拆</summary><el-tag size="small" type="warning"><LineClampText :content="`${row.groupNo} · ${row.memberOrderCount} 票 · ${row.inboundFragmentCount} 个入仓片段`" /></el-tag><LineClampText :content="row.memberOrderSummaries.join('；')" /><LineClampText :content="`整组 ${row.groupTotalBoxes} 箱，必须全量进入同一柜`" /><LineClampText v-if="row.blockReason" class="candidate-block" :content="row.blockReason" /><LineClampText v-else-if="row.locked" content="该组已锁定，不能重复分配" /></details><LineClampText v-else :content="row.unitType === 'SEALED_PALLET' ? '整托加入 · 不可拆' : '按箱加入'" /></template>
          <template #averageUnitVolume="{ row }">{{ formatNumber(Number(row.averageUnitVolumeCbm || 0)) }} m³</template><template #unitGrossWeight="{ row }">{{ formatNumber(Number(row.unitGrossWeightKg || 0),1) }} kg</template>
          <template #cartonIdentityStatus><el-tag size="small" type="info" effect="plain">未核验</el-tag></template>
        </DataTable>
      </template>
      </template>
    </template>
-    <AppDialog class="admin-density-dialog" v-model="assignOpen" :title="selectedCandidate?.unitType === 'SEALED_PALLET' ? '整托加入当前柜次' : selectedCandidate?.coLoadGroupId ? '整组加入当前柜次' : '按入仓码分配箱数'" :confirm-loading="mutating" :confirm-disabled="Boolean(selectedCandidate?.blockReason || selectedCandidate?.locked)" :confirm-text="selectedCandidate?.unitType === 'SEALED_PALLET' ? '确认整托分配' : selectedCandidate?.coLoadGroupId ? '确认整组分配' : '确认分配'" @confirm="assign"><div v-if="selectedCandidate" class="assign-dialog"><p><strong>{{ selectedCandidate.palletNo || selectedCandidate.groupNo || selectedCandidate.inboundCode || '入仓码暂缺' }}</strong></p><template v-if="selectedCandidate.coLoadGroupId"><p>组内 {{ selectedCandidate.memberOrderCount }} 票、{{ selectedCandidate.inboundFragmentCount }} 个入仓片段，共 {{ selectedCandidate.groupTotalBoxes }} 箱</p><p v-for="summary in selectedCandidate.memberOrderSummaries" :key="summary">{{ summary }}</p><el-alert :title="selectedCandidate.blockReason || '同柜且不可拆：全部订单及其入仓片段按完整箱数一次加入，不能部分输入或单独移除。'" :type="selectedCandidate.blockReason ? 'error' : 'warning'" :closable="false" /></template><template v-else-if="selectedCandidate.unitType === 'SEALED_PALLET'"><p>托盘号 {{ selectedCandidate.palletNo || '—' }} · 入仓码 {{ selectedCandidate.inboundCode || '—' }} · {{ selectedCandidate.availablePackageCount }} 箱</p><el-alert title="该封托托盘将作为一个不可拆分单元整托加入；装柜阶段复用此托盘，不会重新生成工作托盘。" type="warning" :closable="false" /></template><template v-else><p>{{ selectedCandidate.goodsSummary || '货物摘要暂缺' }} · 可用 {{ selectedCandidate.availablePackageCount }} 箱</p><el-form class="density-form" label-position="top"><el-form-item label="本次计划装柜箱数" required><el-input-number v-model="assignForm.packageCount" :min="1" :max="selectedCandidate.availablePackageCount" :step="1" controls-position="right" placeholder="请输入本次分配箱数" /></el-form-item></el-form><el-alert :title="explainCandidate(selectedCandidate)" type="info" :closable="false" /><small>只记录数量，具体上柜箱号未核验。</small></template></div></AppDialog>
+    <AppDialog class="admin-density-dialog" v-model="assignOpen" :title="selectedCandidate?.unitType === 'SEALED_PALLET' ? '整托加入当前柜次' : selectedCandidate?.coLoadGroupId ? '整组加入当前柜次' : '按入仓码分配箱数'" :confirm-loading="mutating" :confirm-disabled="Boolean(selectedCandidate?.blockReason || selectedCandidate?.locked)" :confirm-text="selectedCandidate?.unitType === 'SEALED_PALLET' ? '确认整托分配' : selectedCandidate?.coLoadGroupId ? '确认整组分配' : '确认分配'" @confirm="assign"><div v-if="selectedCandidate" class="assign-dialog"><p><strong>{{ selectedCandidate.palletNo || selectedCandidate.groupNo || selectedCandidate.inboundCode || '入仓码暂缺' }}</strong></p><template v-if="selectedCandidate.coLoadGroupId"><p>组内 {{ selectedCandidate.memberOrderCount }} 票、{{ selectedCandidate.inboundFragmentCount }} 个入仓片段，共 {{ selectedCandidate.groupTotalBoxes }} 箱</p><p v-for="summary in selectedCandidate.memberOrderSummaries" :key="summary">{{ summary }}</p><el-alert :title="selectedCandidate.blockReason || '同柜且不可拆：全部订单及其入仓片段按完整箱数一次加入，不能部分输入或单独移除。'" :type="selectedCandidate.blockReason ? 'error' : 'warning'" :closable="false" /></template><template v-else-if="selectedCandidate.unitType === 'SEALED_PALLET'"><p>托盘号 {{ selectedCandidate.palletNo || '—' }} · 整托 {{ selectedCandidate.availablePackageCount }} 箱</p><SmartLoadingCandidateInbounds :candidate="selectedCandidate" /><el-alert title="该封托托盘将作为一个不可拆分单元整托加入；装柜阶段复用此托盘，不会重新生成工作托盘。" type="warning" :closable="false" /></template><template v-else><p>{{ selectedCandidate.goodsSummary || '货物摘要暂缺' }} · 可用 {{ selectedCandidate.availablePackageCount }} 箱</p><el-form class="density-form" label-position="top"><el-form-item label="本次计划装柜箱数" required><el-input-number v-model="assignForm.packageCount" :min="1" :max="selectedCandidate.availablePackageCount" :step="1" controls-position="right" placeholder="请输入本次分配箱数" /></el-form-item></el-form><el-alert :title="explainCandidate(selectedCandidate)" type="info" :closable="false" /><small>只记录数量，具体上柜箱号未核验。</small></template></div></AppDialog>
  </section>
  </AdminPage>
 </template>
@@ -15,6 +15,7 @@ const plan = {
  pdaTaskStatus: null, pdaTaskVersion: null,
  coLoadGroups: [{ groupId: '9001', groupNo: 'CLG-9001', lockedPlanId: '99', memberOrderCount: 2,
    inboundFragmentCount: 2, fullPackageCount: 12, memberInboundIds: ['201', '202'] }],
+  palletMembers: [],
  items: [item, { ...item, id: '702', inboundId: '202', inboundDetailId: '802', orderId: '302', orderNo: 'ORD-2', inboundCode: 'IN-202', packageCount: 7 }],
 } satisfies SmartLoadingPlan

@@ -332,6 +332,7 @@ export interface SmartLoadingCandidate {
  groupTotalBoxes: number | null
  locked: boolean | null
  blockReason: string | null
+  /** Complete co-load group or sealed-pallet membership; pallet member counts are inbound-specific. */
  groupMembers: SmartLoadingCandidateGroupMember[]
 }

@@ -453,5 +454,9 @@ export interface SmartLoadingPlan {
    fullPackageCount: number
    memberInboundIds: string[]
  }>
+  palletMembers: Array<{
+    palletId: string
+    members: SmartLoadingCandidateGroupMember[]
+  }>
  items: SmartLoadingItem[]
 }
@@ -79,7 +79,7 @@ describe('Finance G3/G4 views', () => {
    document.body.innerHTML = ''
    const customer = { id: '10001', tenantName: '客户A', status: 'ACTIVE' } as PlatformTenantResource
    vi.mocked(listPlatformTenants).mockReset().mockResolvedValue({ records: [customer], page: 1, size: 200, total: 1, pages: 1 })
-    vi.mocked(listSuppliers).mockReset().mockResolvedValue({ records: [{ id: '301', tenantId: '0', name: '拖车供应商A', category: 'TRUCKING', carrierCodes: [], scope: 'DOMESTIC', region: '宁波', legalRepresentative: '', contactName: '', phone: '', email: null, address: null, businessLicenseNo: null, licenseFileId: null, status: 'ACTIVE', settlementPeriod: 'MONTHLY_30', remark: null, createdBy: null, createdAt: '2026-08-01', updatedBy: null, updatedAt: '2026-08-01', deleted: false, version: 0 } as Supplier], page: 1, size: 200, total: 1, pages: 1 })
+    vi.mocked(listSuppliers).mockReset().mockResolvedValue({ records: [{ id: '301', tenantId: '0', name: '拖车供应商A', category: 'TRUCKING', truckingScope: 'DOMESTIC', carrierCodes: [], scope: 'DOMESTIC', region: '宁波', legalRepresentative: '', contactName: '', phone: '', email: null, address: null, businessLicenseNo: null, licenseFileId: null, status: 'ACTIVE', settlementPeriod: 'MONTHLY_30', remark: null, createdBy: null, createdAt: '2026-08-01', updatedBy: null, updatedAt: '2026-08-01', deleted: false, version: 0 } as Supplier], page: 1, size: 200, total: 1, pages: 1 })
    vi.mocked(listFinanceStatements).mockReset().mockResolvedValue([statement])
    vi.mocked(getReconciliationStatement).mockReset().mockResolvedValue(statementDetail)
    vi.mocked(actionReconciliationStatement).mockReset().mockResolvedValue(statementDetail)
@@ -5,6 +5,12 @@ import { describe, expect, it } from 'vitest'
 const source = readFileSync(resolve(process.cwd(), 'src/modules/inbounds/core/DropshipPalletPrintPanel.vue'), 'utf8')

 describe('DropshipPalletPrintPanel', () => {
+  it('explains whole-pallet box totals and distinct SKU codes rather than item quantities', () => {
+    expect(source).toContain('prop="cartonCount" label="整托箱数"')
+    expect(source).toContain('prop="skuCount" label="SKU 种类数"')
+    expect(source).toContain('包含合托的其他入仓码')
+    expect(source).toContain('相同 SKU 编码只计一种，不代表商品件数')
+  })
  it('provides desktop batch printing and single-pallet reprinting', () => {
    expect(source).toContain('一件代发托盘打印')
    expect(source).toContain('打印全部托盘')
@@ -90,6 +90,7 @@ onBeforeUnmount(() => { disposed = true; requestSerial += 1 })
      <div>
        <h3 id="dropship-print-title">一件代发托盘打印</h3>
        <p>测量审核生成托盘码后，在电脑端打印并贴到空托盘，再交由 PDA 扫码组托。</p>
+        <p>箱数与 SKU 种类数按整托统计，包含合托的其他入仓码；相同 SKU 编码只计一种，不代表商品件数。</p>
      </div>
      <div class="print-actions">
        <el-button :disabled="loading || Boolean(printing)" @click="loadPallets"><RefreshCw :size="15" />刷新</el-button>
@@ -108,8 +109,8 @@ onBeforeUnmount(() => { disposed = true; requestSerial += 1 })
      </el-table-column>
      <el-table-column prop="palletNo" label="托盘码" min-width="210" />
      <el-table-column label="状态" width="110"><template #default="{ row }"><el-tag size="small" :type="row.status === 'SEALED' ? 'success' : 'warning'" effect="plain">{{ statusLabel(row.status) }}</el-tag></template></el-table-column>
-      <el-table-column prop="cartonCount" label="已归托箱数" width="120" align="right" />
-      <el-table-column prop="skuCount" label="SKU 数" width="100" align="right" />
+      <el-table-column prop="cartonCount" label="整托箱数" width="120" align="right" />
+      <el-table-column prop="skuCount" label="SKU 种类数" width="120" align="right" />
    </el-table>
    <el-empty v-else-if="!loading" description="测量审核通过并生成托盘码后，可在这里打印" :image-size="64" />
    <div v-else class="loading-state"><el-skeleton :rows="4" animated /></div>
@@ -121,6 +121,28 @@ describe('InboundFeePanel', () => {
    expect(wrapper.find('.surface-panel').exists()).toBe(false)
  })

+  it('keeps the compact title and refresh action on one heading row', async () => {
+    const pinia = setupPermissions(['firstleg:fba-pricing:view'])
+    const wrapper = mount(InboundFeePanel, {
+      props: { customerId: '10001', inboundId: '88', compact: true, displayOnly: true },
+      global: { plugins: [pinia, ElementPlus] },
+    })
+    await flushPromises()
+
+    const heading = wrapper.get('.fee-heading--compact')
+    expect(heading.get('#inbound-fee-title').text()).toBe('头程自动初算')
+    expect(heading.find('button[aria-label="刷新费用快照"]').exists()).toBe(true)
+  })
+
+  it('keeps the refresh icon visible and spinning while the snapshot reloads', () => {
+    const source = readFileSync(resolve(process.cwd(), 'src/modules/inbounds/fee/InboundFeePanel.vue'), 'utf8')
+    expect(source).toContain('class="fee-refresh-button"')
+    expect(source).toContain(':aria-busy="loading"')
+    expect(source).toContain(`<RefreshCw :size="16" :class="{ 'is-spinning': loading }" />`)
+    expect(source).not.toMatch(/aria-label="刷新费用快照"[^>]*:loading=/)
+    expect(source).toContain('@keyframes fee-refresh-spin')
+  })
+
  it('supports a display-only fee snapshot without calculation or transition actions', async () => {
    vi.mocked(getLatestInboundFee).mockResolvedValue({ ...snapshot, feeStatus: 'CALCULATED', confirmedAt: null, sentAt: null })
    const pinia = setupPermissions([
@@ -364,7 +364,8 @@ defineExpose({ reload: loadFee })
 <template>
  <section class="inbound-fee-panel" :aria-busy="loading" aria-labelledby="inbound-fee-title">
    <header class="fee-heading" :class="{ 'fee-heading--compact': compact }">
-      <div v-if="!compact" class="fee-heading-copy">
+      <h3 v-if="compact" id="inbound-fee-title" class="fee-heading-title--compact">头程自动初算</h3>
+      <div v-else class="fee-heading-copy">
        <span class="fee-heading-icon" aria-hidden="true"><CircleDollarSign :size="20" /></span>
        <div>
          <h3 id="inbound-fee-title">入库费用快照</h3>
@@ -374,12 +375,13 @@ defineExpose({ reload: loadFee })
      <div class="fee-heading-actions">
        <el-tooltip content="刷新费用快照" placement="top">
          <el-button
+            class="fee-refresh-button"
            circle
            aria-label="刷新费用快照"
-            :loading="loading"
-            :disabled="!customerContextId || !normalizedInboundId || !canView"
+            :aria-busy="loading"
+            :disabled="loading || !customerContextId || !normalizedInboundId || !canView"
            @click="loadFee()"
-          ><RefreshCw :size="16" /></el-button>
+          ><RefreshCw :size="16" :class="{ 'is-spinning': loading }" /></el-button>
        </el-tooltip>
        <el-button
          v-if="!displayOnly && canCalculate"
@@ -584,7 +586,8 @@ defineExpose({ reload: loadFee })
 <style scoped>
 .inbound-fee-panel { min-width: 0; color: var(--cc-text); }
 .fee-heading { display: flex; align-items: flex-start; justify-content: space-between; gap: 16px; padding-bottom: 16px; }
-.fee-heading--compact { justify-content: flex-end; padding-bottom: 6px; }
+.fee-heading--compact { align-items: center; justify-content: space-between; padding: 12px 0 8px; }
+.fee-heading h3.fee-heading-title--compact { color: #344054; font-size: var(--admin-font-section, 14px); line-height: 1.4; }
 .fee-heading-copy { display: flex; min-width: 0; align-items: flex-start; gap: 12px; }
 .fee-heading-icon { display: grid; width: 38px; height: 38px; flex: 0 0 38px; place-items: center; border-radius: 10px; background: #eef4ff; color: var(--cc-primary); }
 .fee-heading h3, .section-title h4 { margin: 0; }
@@ -592,6 +595,7 @@ defineExpose({ reload: loadFee })
 .fee-heading p, .section-title p { margin: 5px 0 0; color: var(--cc-muted); font-size: 12px; line-height: 1.55; }
 .fee-heading-actions { display: flex; flex-wrap: wrap; justify-content: flex-end; gap: 8px; }
 .fee-heading-actions .el-button { margin-left: 0; }
+.fee-refresh-button .is-spinning { animation: fee-refresh-spin 0.8s linear infinite; }
 .fee-loading { padding: 20px 0; }
 .inbound-fee-panel :deep(.el-alert p) { margin: 5px 0 0; line-height: 1.55; }
 .inbound-fee-panel :deep(.el-alert .el-button) { margin-top: 8px; }
@@ -605,6 +609,7 @@ defineExpose({ reload: loadFee })
 .fee-total strong { color: #0f5c49; font-size: 21px; letter-spacing: -.01em; }
 .fee-summary-item strong { font-size: 15px; }
 .version-status { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; }
+@keyframes fee-refresh-spin { to { transform: rotate(360deg); } }
 .calculation-section, .fee-timeline { padding: 10px 0; border-bottom: 1px solid var(--cc-border); }
 .section-title { display: flex; align-items: flex-start; justify-content: space-between; gap: 16px; }
 .calculation-tags { display: flex; flex-wrap: wrap; justify-content: flex-end; gap: 6px; }
@@ -11,6 +11,7 @@ export type PreloadConfirmationStatus = 'PENDING' | 'PARTIALLY_CONFIRMED' | 'CON
 export type PreloadBlockingReason =
  | 'LOADING_PLAN_NOT_EDITING'
  | 'PRELOAD_LINK_MISSING'
+  | 'CONTAINER_NO_MISSING'
  | 'OCEAN_BOOKING_NOT_LINKED'
  | 'OCEAN_BOOKING_NOT_RELEASED'
  | 'PDA_TASK_ALREADY_CREATED'
@@ -104,6 +104,7 @@ const visibleHistories = computed(() => {
 const blockingReasonLabels: Record<string, string> = {
  LOADING_PLAN_NOT_EDITING: '装柜计划已不在可确认的编辑状态',
  PRELOAD_LINK_MISSING: '装柜明细尚未完整关联入库预装票据',
+  CONTAINER_NO_MISSING: '尚未录入真实集装箱号，请先补录后再确认预装',
  OCEAN_BOOKING_NOT_LINKED: '尚未关联真实订舱',
  OCEAN_BOOKING_NOT_RELEASED: '关联订舱尚未放舱',
  PDA_TASK_ALREADY_CREATED: 'PDA 任务已创建，无需重复确认',
@@ -63,22 +63,21 @@ describe('PreloadPlanDetailView prototype contract', () => {
    expect(source).toContain(':confirm-loading="remarkSaving"')
  })

-  it('supports first entry and reasoned correction before PDA claim without blocking earlier flow', () => {
+  it('requires first entry before confirmation and still repairs historical tasks that were created without it', () => {
    expect(source).toContain("{ required: true, message: '请输入集装箱号'")
-    expect(source).toContain("summary?.status === 'EDITING'")
-    expect(source).toContain("(!pdaStatus || pdaStatus === 'PENDING')")
+    expect(source).toContain("['EDITING', 'LOADING'].includes(summary.status)")
+    expect(source).toContain('if (!summary.containerNo) return true')
    expect(source).not.toContain('summary?.containerNo && summary.status')
    expect(source).toContain('PDA 已领取或作业已开始，真实集装箱号只读。')
+    expect(source).toContain('该历史 PDA 任务缺少真实集装箱号；补录保存后即可进入任务。')
+    expect(source).toContain('确认预装前必须补录真实集装箱号。')
    expect(source).toContain("isContainerCorrection.value ? '纠正集装箱号 / 航次' : '补录集装箱号 / 航次'")
    expect(source).toContain("isContainerCorrection.value && !String(value || '').trim() ? new Error('纠错时请输入操作原因')")
    expect(source).toContain("String(value || '').trim().toUpperCase()")
    expect(source).toContain('operationReason: editForm.operationReason.trim() || null')
    expect(detailSource).toContain('v-if="canEditTransport"')
    expect(detailSource).toContain("summary.containerNo || '待补录'")
-    expect(source).toContain('由服务端按真实条件创建唯一 PDA 任务')
-    expect(source).toContain('缺号不阻断此前流程')
-    expect(source).toContain('PDA 确认装柜完成前由服务端执行最终门禁')
-    expect(source).not.toContain('真实集装箱号未录入时不能确认')
+    expect(detailSource).toContain("CONTAINER_NO_MISSING: '尚未录入真实集装箱号，请先补录后再确认预装'")
  })

  it('uses a flat blocking note instead of repeated colored page alerts', () => {
@@ -97,8 +96,7 @@ describe('PreloadPlanDetailView prototype contract', () => {
    expect(source).toContain('confirmSaving.value')
    expect(source).toContain('await loadDetail()')
    expect(source).toContain('本操作将确认整份预装计划')
-    expect(source).toContain('全部入库预装票据')
-    expect(source).toContain('当前页面不会伪造 PDA 成功')
+    expect(source).toContain(':confirm-disabled="!detail?.summary.readiness.canConfirm"')
    expect(source).not.toContain('/inbounds/')
  })

@@ -52,16 +52,18 @@ const canEdit = computed(() => access.can('platform:firstleg:preload:edit'))
 const canCorrectTransport = computed(() => {
  const summary = detail.value?.summary
  const pdaStatus = summary?.readiness.pdaTaskStatus
-  return Boolean(canEdit.value && summary?.status === 'EDITING'
-    && (!pdaStatus || pdaStatus === 'PENDING'))
+  if (!canEdit.value || !summary || !['EDITING', 'LOADING'].includes(summary.status)) return false
+  if (!summary.containerNo) return true
+  return !pdaStatus || pdaStatus === 'PENDING'
 })
 const isContainerCorrection = computed(() => Boolean(detail.value?.summary.containerNo))
 const transportCorrectionNote = computed(() => {
  const summary = detail.value?.summary
  if (!summary) return ''
+  if (!summary.containerNo && summary.readiness.pdaTaskId) return '该历史 PDA 任务缺少真实集装箱号；补录保存后即可进入任务。'
  if (summary.readiness.pdaTaskStatus && summary.readiness.pdaTaskStatus !== 'PENDING') return 'PDA 已领取或作业已开始，真实集装箱号只读。'
  if (!canCorrectTransport.value) return '当前服务端阶段不允许纠正真实集装箱号。'
-  if (!summary.containerNo) return '真实集装箱号待补录；可在预装详情首次录入，PDA 领取或作业开始后只读。'
+  if (!summary.containerNo) return '确认预装前必须补录真实集装箱号。'
  return '真实集装箱号仅可在 PDA 领取前纠错，纠错保存时必须填写操作原因。'
 })
 const editDialogTitle = computed(() => isContainerCorrection.value ? '纠正集装箱号 / 航次' : '补录集装箱号 / 航次')
@@ -17,11 +17,12 @@

 | 关键词 | 页面/路由入口 | API 与联查 |
 |---|---|---|
+| 排车车型、托位容量与限重提示 | `dispatchVehicleSpecs.ts`、`components/SmartDispatchDialog.vue`、`pages/DispatchesView.vue` | 预排车型与排车编辑选项共用规格入口：大车 30 托/40000 LB，小车 15 托/10000 LB；超重提示在预排组件，不能把前端提示当作服务端允许提交的依据。回归见 `pages/DispatchesView.test.ts`、`pages/prototypeContract.test.ts` |
 | 仓储转运审核、通过与驳回 | `pages/LastMileOrdersView.vue`、`components/WarehouseTransferReviewDialog.vue` | `api/warehouseTransfers.ts` 的列表、详情及 `/warehouse-transfers/{transferNo}/review`；审核按钮要求 `permissions.ts` 的 `warehouseTransferApprove` 且行类型为 `WAREHOUSE_TRANSFER`、状态为 `PENDING_REVIEW`。请求携带该行客户范围和转运单号，审核结论为 `APPROVE/REJECT`，驳回原因必填；这是尾程订单内的审核弹框，不是独立审核路由或排车转派送入口 |
 | 尾程订单控制与柜级入仓计划转换 | `pages/LastMileOrdersView.vue`、`pages/LastMileOrderDetailView.vue` | 柜子工作台按 `sourceContainerBookingId` 消费 `/orders/container-summaries`；服务端分页返回全部稳定来源柜，计划已经齐全的柜仍保留用于接柜仓查询和修改，并按冻结 `plannedArrivalAt` 升序、空值最后排序。详情返回全柜订单且不受列表分页截断；单票手工计划保存后，由服务端在整柜最后一票计划齐全时自动生成并绑定全柜托盘码，一票柜立即生成；`resourcePendingPlanCount` 只表示自动生成异常的重试入口，不是正常人工步骤。柜级确认弹框先调用 `/inbound-plans/container-preview`，按服务端 FBA/一件代发/私人地址分组展示头程已有、海外仓补充和最终托数以及 `readiness/blockers`；散货最终托数不得少于头程已有托盘码，差额连续补码且不阻断流程；一件代发必须严格按不可变头程封托托盘数整体入库，单票表单托数锁定且服务端再次失败关闭校验。前端不计算托数、不逐票建计划、不预占托盘，再把同一 `snapshotVersion/snapshotHash` 原样提交 `/inbound-plans/convert-container`，快照冲突后重新获取预览。服务端只为剩余订单逐票生成独立计划，并为异常遗留的人工计划补齐真实托盘，整批原子且重放不得产生第二批资源。单票完整入库计划、暂扣/解除和八行人工节点均从 `api/lastMileOrders.ts` 提交订单版本与幂等键；预计到仓时间只读展示来源柜冻结值，不进入人工计划请求，服务端按整柜校验并写入同一日期；入仓码只读展示并提交订单冻结值，不允许人工改写，暂扣资格、接柜仓锁定原因和操作能力只消费服务端结果，人工节点一经保存不得回退柜级节点。转仓候选只取 `../iam/api/platformIam.ts` 的平台公共 `ACTIVE + FBA` 仓主档；Backend `lastleg-service/` |
 | 入仓单、入仓计划、FBA 预约 | `pages/InboundOrdersView.vue`、`pages/InboundOrderDetailView.vue` | 列表/预约 `api/inboundOrders.ts`，计划列表/详情 `api/inboundPlans.ts`；Backend `lastleg-service/inboundplan/` |
 | 排车查询、智能预排与转派送 | `pages/DispatchesView.vue`、`pages/DispatchDetailView.vue`、`components/SmartDispatchDialog.vue` | `api/dispatches.ts`；Backend `lastleg-service/dispatch/`、`delivery/`；覆盖详情、候选、草稿柜、托盘锁、`pre-arrange` 和 `transfer-delivery`。路线只读并由已排托盘关联的 FBA 仓去重后以英文逗号连接，预排和普通编辑均不接收人工路线。一次转派送仍生成一张车辆级出库单，响应的 `deliveries` 按目的 FBA 仓返回多张派送单。页面能力必须由正式路由、API 调用和测试共同证明 |
-| 海外出库与派送 | `pages/OutboundsView.vue`、`pages/OutboundDetailView.vue`、`pages/DeliveryOrdersView.vue`、`pages/DeliveryOrderDetailView.vue` | `api/outbounds.ts`、`api/deliveryOrders.ts`；出库详情使用 `deliveries` 展示按目的 FBA 仓拆出的全部派送单，派送列表和详情必须显示目的 FBA 仓。人工状态入口不提供完成派送；签收资料保存成功后提示自动完成并刷新列表。出库列表按类型筛选并展示中文类型。一件代发新建弹窗直接跨客户加载服务端可用候选，不单独展示客户筛选，海外仓必选并优先默认洛杉矶仓；订单条件可按订单号、入库单号、客户、托盘号、SKU 或品名查询/重置，以托盘+SKU 行分页多选。提交时从所选行解析唯一客户，并校验所选行属于当前唯一海外仓，不要求先选客户。退货出库客户下拉同时展示客户名称与联系电话并支持手机号检索，客户和仓库选项独立容错加载；选择客户后须立即按当前默认/已选海外仓加载库存。SKU 与箱号查询均使用输入态/已查询态分离，只允许点击查询按钮后生效；支持英文逗号批量条件，查询时清除空格并按任一条件命中，左右列表分别提供每页 5/10/20/50 条选择。SKU 列表只展示 `availableQuantity > 0` 的未占用可用数量，合箱后已扣减为零的 SKU 不再作为可选库存显示，实际作业以可用箱唛选择和箱内 SKU 明细扣减为准。取消、派送列表/详情及退回入口对应 Backend `lastleg-service/delivery/`、`dropship/` |
+| 海外出库与派送 | `pages/OutboundsView.vue`、`pages/OutboundDetailView.vue`、`pages/DeliveryOrdersView.vue`、`pages/DeliveryOrderDetailView.vue` | `api/outbounds.ts`、`api/deliveryOrders.ts`；出库详情使用 `deliveries` 展示按目的 FBA 仓拆出的全部派送单，派送列表和详情必须显示目的 FBA 仓。人工状态入口不提供完成派送；签收资料保存成功后提示自动完成并刷新列表。出库列表按类型筛选并展示中文类型，状态须覆盖 `WAIT_PICK/待拣货`、`PICKING/拣货中`、`PICKED/已拣货`、`WAIT_OUTBOUND/待出库`、`OUTBOUNDED/已出库` 和 `CANCELLED/已取消`；仅未开始的 `WAIT_PICK/WAIT_OUTBOUND` 允许取消。一件代发新建弹窗直接跨客户加载服务端可用候选，不单独展示客户筛选，海外仓必选并优先默认洛杉矶仓；订单条件可按订单号、入库单号、客户、托盘号、SKU 或品名查询/重置，以托盘+SKU 行分页多选。提交时从所选行解析唯一客户，并校验所选行属于当前唯一海外仓，不要求先选客户。退货出库客户下拉同时展示客户名称与联系电话并支持手机号检索，客户和仓库选项独立容错加载；选择客户后须立即按当前默认/已选海外仓加载库存。SKU 与箱号查询均使用输入态/已查询态分离，只允许点击查询按钮后生效；支持英文逗号批量条件，查询时清除空格并按任一条件命中，左右列表分别提供每页 5/10/20/50 条选择。SKU 列表只展示 `availableQuantity > 0` 的未占用可用数量，合箱后已扣减为零的 SKU 不再作为可选库存显示，实际作业以可用箱唛选择和箱内 SKU 明细扣减为准。取消、派送列表/详情及退回入口对应 Backend `lastleg-service/delivery/`、`dropship/` |
 | 异常退回与客户回访 | `pages/ExceptionOrdersView.vue`、`pages/CustomerVisitsView.vue` | `api/exceptionOrders.ts`、`api/customerVisits.ts`；异常关系解析、异常建档、派送退回、完成/状态和回访附件对应 Backend `lastleg-service/exceptionorder/`、`customervisit/` |
 | 库存余额、库位与流水 | `pages/InventoryView.vue`、`pages/InventoryDetailView.vue`、`pages/InventoryTransactionsView.vue` | `api/inventory.ts`；业务库存归 `lastleg-service/inventory/`，实物资源归 `warehouse-overseas-service/` |
 | 托盘、箱唛、产品与换标 | `pages/PalletsView.vue`、`pages/CartonsView.vue`、`pages/ProductsView.vue`、`pages/RelabelOrdersView.vue` 及详情页 | `api/pallets.ts`、`api/relabelOrders.ts`；换标详情展示 PDA 完工照片与复核人，状态区分待客户确认和待出库；路由是否公开以 `routes.ts` 为准 |
@@ -30,13 +31,14 @@

 - 智能排车来源支持 `RELABEL`（待出库换标单），切换后不传已选入库计划 ID，按客户已确认、卡车派送且未排车的换标库存查询。提交换标号从候选 `orderRefs` 读取，不能把展示的原入库单号 `orderNo` 当换标号；沿用来源库存、托盘与箱唛，不生成新入库单。

- 托盘管理单张打印：`pages/PalletsView.vue` 每行“打印”经 `api/pallets.ts` 的 `getPalletLabelPdf` 下载当前托盘一页 PDF；使用该行仓库 ID 与托盘 ID，权限复用托盘列表。Backend `warehouse-overseas-service` 的 `PalletLabelPrintService` 读取公共托盘并调用现有 Print `INBOUND_MARK_V1`，不在前端生成标签、改码或维护第二套模板。
+- 托盘管理单张打印：`pages/PalletsView.vue` 每行“打印”经 `api/pallets.ts` 的 `getPalletLabelPdf` 下载当前托盘一页 PDF；使用该行仓库 ID 与托盘 ID，权限复用托盘列表。Backend `warehouse-overseas-service` 的 `PalletLabelPrintService` 读取公共托盘；有 FBA 仓码的托盘与国内统一使用 Print `FBA_PALLET_A4_LANDSCAPE_V1`（297×210 mm，FBA 仓码、完整托盘号 Code 128、托盘号文字），其他托盘使用 `INBOUND_MARK_V1`。不在前端生成标签、改码或维护第二套模板。

 - API 为 `api/dispatches.ts`、`api/outbounds.ts`、`api/deliveryOrders.ts`；Backend `lastleg-service/dispatch/`、`delivery/`、`dropship/`。一件代发独立出库，从服务端库存位置选择并携带幂等键；普通出库及换标单经头程排车转出库，按托盘快照绑定头程箱唛，PDA 按托盘作业，详情展示箱唛与已拣数量；排车转派送按稳定 `dispatchNo` 进入服务端命令，可在 `PENDING_DEPARTURE`、`PICKING`、`READY_TO_DEPART` 状态执行并须在 PDA 发车前生成一张待出库单及按目的 FBA 仓拆分的派送单
 - API 为 `api/exceptionOrders.ts`、`api/customerVisits.ts`；Backend `lastleg-service/exceptionorder/`、`customervisit/`。异常处理只消费服务端 `allowedActions/version`；完成时至少上传一份异常证据。派送退回先从服务端原出库拣货事实选择入仓单和可退箱数，不允许自由填写 SKU/数量；退回海外仓时必须选择服务端校验的目标托盘和库位，库存恢复、异常完成与派送 `RETURNED` 由服务端原子推进。回访附件和派送完成/状态均走海外真实 API

 ## 验证

+- 一件代发出库候选选择：`pages/OutboundsView.vue` 按 `inventoryPositionId + skuCode` 保留跨页选择，只提供本页全选；查询/重置回到第一页，切换海外仓清空选择。提交仍校验同客户、同海外仓，数量取所选行的 `availablePackages`（箱数），不能按 SKU 件数替代。候选交互回归见 `pages/OutboundsView.selection.test.ts`；状态展示与取消门禁见 `pages/OutboundsView.test.ts`、`pages/OutboundDetailView.test.ts`。
 - 转运审核定向测试：从应用根运行 `pnpm test src/modules/overseas-warehouse/api/warehouseTransfers.test.ts src/modules/overseas-warehouse/pages/prototypeContract.test.ts`，分别核对客户作用域/API 与审核入口权限、状态。
 - 排车列表编辑、托盘移除、BOL PDF 和转派送从 `pages/DispatchesView.vue` → `api/dispatches.ts` 进入；智能预排的候选、草稿柜与托盘锁从 `components/SmartDispatchDialog.vue` 进入。回归为 `pages/DispatchesView.test.ts`、`pages/prototypeContract.test.ts`，不要把列表操作与预排草稿当作同一入口。
 - 从应用根按目标页面选择相邻测试：`pnpm test src/modules/overseas-warehouse/<目标测试路径>`；API 或类型变化同时运行 `pnpm typecheck`。应用完整门禁继续遵循上层指引。
@@ -3,6 +3,7 @@ import { flushPromises, mount } from '@vue/test-utils'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { getOutbound } from '../api/outbounds'
 import OutboundDetailView from './OutboundDetailView.vue'
+import StatusBadge from '@/shared/components/StatusBadge.vue'

 const canPermission = vi.hoisted(() => vi.fn((_code: string) => false))
 vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: canPermission }) }))
@@ -10,6 +11,19 @@ vi.mock('vue-router', () => ({ useRoute: () => ({ params: { outboundNo: 'OUT/1'
 vi.mock('../api/outbounds', () => ({ getOutbound: vi.fn(), cancelOutbound: vi.fn() }))

 describe('OutboundDetailView', () => {
+  it.each([
+    ['WAIT_PICK', '待拣货', 'warning'], ['WAIT_OUTBOUND', '待出库', 'warning'], ['PICKING', '拣货中', 'info'],
+    ['PICKED', '已拣货', 'warning'], ['OUTBOUNDED', '已出库', 'success'], ['CANCELLED', '已取消', 'danger'],
+  ])('uses the same shared status tone as the list for %s', async (status, label, tone) => {
+    vi.mocked(getOutbound).mockResolvedValueOnce({ outbound: { id: '1', outboundNo: 'OUT/1', status }, pallets: [], deliveries: [] })
+    const wrapper = mount(OutboundDetailView, { global: { plugins: [ElementPlus] } })
+    await flushPromises()
+    const badge = wrapper.findComponent(StatusBadge)
+    expect(badge.text()).toBe(label)
+    expect(badge.classes()).toContain(`is-${tone}`)
+    wrapper.unmount()
+  })
+
  beforeEach(() => {
    canPermission.mockReset().mockReturnValue(false)
    vi.mocked(getOutbound).mockReset().mockResolvedValue({
@@ -64,8 +78,9 @@ describe('OutboundDetailView', () => {
    emptyWrapper.unmount()
  })

-  it('shows cancellation only for PICKED with the independent permission', async () => {
+  it('shows cancellation only before picking with the independent permission', async () => {
    canPermission.mockImplementation((code: string) => code === 'platform:overseas-warehouse:outbound:cancel')
+    vi.mocked(getOutbound).mockResolvedValueOnce({ outbound: { id: '1', outboundNo: 'OUT/1', status: 'WAIT_PICK' }, pallets: [], deliveries: [] })
    const wrapper = mount(OutboundDetailView, { global: { plugins: [ElementPlus] } })
    await flushPromises()
    expect(wrapper.text()).toContain('取消出库单')
@@ -21,7 +21,7 @@ const route = useRoute(); const router = useRouter(); const access = useAccessPr
 const outboundNo = computed(() => String(route.params.outboundNo || '').trim())
 const detail = ref<OutboundDetail | null>(null); const loading = ref(false); const cancelling = ref(false)
 const loadError = ref<ApiErrorDetails | null>(null); const mutationError = ref<ApiErrorDetails | null>(null)
-const statusLabels: Record<string, string> = { WAIT_OUTBOUND: '待出库', PICKING: '拣货中', PICKED: '已拣货', OUTBOUNDED: '已出库', CANCELLED: '已取消' }
+const statusLabels: Record<string, string> = { WAIT_PICK: '待拣货', WAIT_OUTBOUND: '待出库', PICKING: '拣货中', PICKED: '已拣货', OUTBOUNDED: '已出库', CANCELLED: '已取消' }
 const palletColumns: DataTableColumn[] = [
  { key: 'palletNo', label: '托盘码', width: 220 },
  { key: 'inboundCode', label: '入仓码', width: 190 },
@@ -42,7 +42,7 @@ const warehouseLabel = computed(() => {
 })
 function statusLabel(value: unknown) { const code = String(value || ''); return statusLabels[code] || show(code) }
 function outboundTypeLabel(value?: string | null) { return value === 'WAREHOUSE_TRANSFER_OUTBOUND' ? '仓储转运出库' : value === 'ONE_CLICK_DROPSHIP' ? '一件代发出库' : value === 'RETURN_OUTBOUND' ? '退货出库' : value === 'DISPATCH_DELIVERY' ? '派送出库' : show(value) }
-const canCancel = computed(() => access.can(permission.outboundCancel) && ['WAIT_OUTBOUND', 'WAIT_PICK', 'PICKED'].includes(String(detail.value?.outbound.status || '')))
+const canCancel = computed(() => access.can(permission.outboundCancel) && ['WAIT_PICK', 'WAIT_OUTBOUND'].includes(String(detail.value?.outbound.status || '')))
 async function load() { if (!outboundNo.value) { loadError.value = { message: '详情缺少出库单号，请从出库单列表重新进入' }; return } loading.value = true; loadError.value = null; try { detail.value = await getOutbound(outboundNo.value) } catch (cause) { detail.value = null; loadError.value = getApiErrorDetails(cause, '出库单详情加载失败，请重试') } finally { loading.value = false } }
 async function cancel() { if (!canCancel.value || cancelling.value) return; let reason = ''; try { const result = await ElMessageBox.prompt(`确认取消出库单 ${outboundNo.value}？`, '取消出库单', { customClass: 'admin-density-confirm', inputType: 'textarea', inputPlaceholder: '请输入取消原因', inputPattern: /\S+/, inputErrorMessage: '请输入取消原因', confirmButtonText: '确认取消', cancelButtonText: '返回', type: 'warning' }); reason = result.value.trim() } catch { return } cancelling.value = true; mutationError.value = null; try { await cancelOutbound(outboundNo.value, reason); ElMessage.success('出库单已取消'); await load() } catch (cause) { mutationError.value = getApiErrorDetails(cause, '取消出库单失败，请重试') } finally { cancelling.value = false } }
 function back() { void router.push({ name: 'overseas-outbounds' }) }
@@ -36,6 +36,14 @@ async function openCreate() {
 }
 function candidatePagination() { return wrapper.findAllComponents(ElPagination).find(item => item.props('total') === 7)! }
 function pageCheckbox() { return wrapper.findAllComponents(ElCheckbox).find(item => item.props('ariaLabel') === '全选本页订单')! }
+async function selectBothPages() {
+  pageCheckbox().vm.$emit('change', true)
+  await flushPromises()
+  candidatePagination().vm.$emit('update:current-page', 2)
+  await flushPromises()
+  pageCheckbox().vm.$emit('change', true)
+  await flushPromises()
+}

 describe('outbound candidate search and selection', () => {
  beforeEach(() => {
@@ -71,29 +79,40 @@ describe('outbound candidate search and selection', () => {
    }))
  })

-  it('searches on query, selects every filtered page, shows partial page selection and clears the selection', async () => {
+  it('keeps searches on one row without bulk buttons and preserves filtered selection across pages', async () => {
    await openCreate()
+    expect(wrapper.get('.dropship-search-row').findAll('.el-form-item')).toHaveLength(2)
+    expect(wrapper.find('.candidate-selection').exists()).toBe(false)
+    expect(wrapper.text()).not.toContain('全选筛选结果')
+    expect(wrapper.text()).not.toContain('清空选择')
    const query = wrapper.findAllComponents(ElInput).find(item => item.props('ariaLabel') === '搜索可出库订单')!
    await query.get('input').setValue('MATCH')
    await flushPromises()
-    expect(wrapper.text()).toContain('全选筛选结果（7）')
+    expect(candidatePagination().props('total')).toBe(7)
    await query.get('input').trigger('keyup', { key: 'Enter' })
    await flushPromises()
-    expect(wrapper.text()).toContain('全选筛选结果（6）')
-    await clickButton('全选筛选结果')
+    const filteredPagination = wrapper.findAllComponents(ElPagination).find(item => item.props('total') === 6)!
+    expect(filteredPagination).toBeDefined()
+    pageCheckbox().vm.$emit('change', true)
+    await flushPromises()
+    filteredPagination.vm.$emit('update:current-page', 2)
+    await flushPromises()
+    pageCheckbox().vm.$emit('change', true)
+    await flushPromises()
    expect(wrapper.text()).toContain('已选择 6 条')
    await wrapper.get('.candidate-query').findAll('button').find(item => item.text() === '重置')!.trigger('click')
    await flushPromises()
    candidatePagination().vm.$emit('update:current-page', 2)
    await flushPromises()
    expect(pageCheckbox().props('indeterminate')).toBe(true)
-    await clickButton('清空选择')
-    expect(wrapper.text()).toContain('已选择 0 条')
+    pageCheckbox().vm.$emit('change', false)
+    await flushPromises()
+    expect(wrapper.get('.candidate-pagination').text()).toContain('已选择 5 条')
  })

  it('resets the page after page-size changes and clears selection when changing searchable warehouses', async () => {
    await openCreate()
-    await clickButton('全选筛选结果')
+    await selectBothPages()
    const pagination = candidatePagination()
    pagination.vm.$emit('update:current-page', 2)
    await flushPromises()
@@ -115,7 +134,8 @@ describe('outbound candidate search and selection', () => {
  it('warns about a multi-customer bulk selection and preserves the submit restriction', async () => {
    api.candidates.mockResolvedValue([{ ...fixtures[0] }, { ...fixtures[1], customerId: 'customer-b', customerName: '客户乙' }])
    await openCreate()
-    await clickButton('全选筛选结果')
+    pageCheckbox().vm.$emit('change', true)
+    await flushPromises()
    expect(wrapper.text()).toContain('当前选择包含多个客户')
    await wrapper.get('[data-test="submit-outbound"]').trigger('click')
    await flushPromises()
@@ -5,6 +5,7 @@ import { flushPromises, mount } from '@vue/test-utils'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { listOutbounds } from '../api/outbounds'
 import OutboundsView from './OutboundsView.vue'
+import StatusBadge from '@/shared/components/StatusBadge.vue'

 const canPermission = vi.hoisted(() => vi.fn((_code: string) => true))
 const routerPush = vi.hoisted(() => vi.fn())
@@ -16,10 +17,28 @@ vi.mock('../api/inventory', () => ({ listInventoryBalances: vi.fn(), listInvento
 class ResizeObserverStub { observe() {} unobserve() {} disconnect() {} }

 describe('OutboundsView permissions and navigation', () => {
+  it('distinguishes outbound stages and does not present unknown states as picking', async () => {
+    const statuses = [
+      ['WAIT_PICK', '待拣货', 'warning'], ['WAIT_OUTBOUND', '待出库', 'warning'], ['PICKING', '拣货中', 'info'],
+      ['PICKED', '已拣货', 'warning'], ['OUTBOUNDED', '已出库', 'success'],
+      ['CANCELLED', '已取消', 'danger'], ['FUTURE_STATE', '未知状态', 'neutral'],
+    ]
+    vi.mocked(listOutbounds).mockResolvedValueOnce({ records: statuses.map(([status], index) => ({ id: String(index), outboundNo: `OUT-${index}`, status })), page: 1, size: 20, total: statuses.length, pages: 1 })
+    const wrapper = mount(OutboundsView, { global: { plugins: [ElementPlus] } })
+    await flushPromises()
+    const badges = wrapper.findAllComponents(StatusBadge).filter(badge => badge.element.closest('tbody'))
+    expect(badges).toHaveLength(statuses.length)
+    statuses.forEach(([, label, tone], index) => {
+      expect(badges[index].text()).toBe(label)
+      expect(badges[index].classes()).toContain(`is-${tone}`)
+    })
+    wrapper.unmount()
+  })
+
  beforeEach(() => {
    vi.stubGlobal('ResizeObserver', ResizeObserverStub)
    vi.stubGlobal('localStorage', { getItem: () => null, setItem: () => undefined, removeItem: () => undefined })
-    vi.mocked(listOutbounds).mockReset().mockResolvedValue({ records: [{ id: '1', outboundNo: 'OUT-1', dispatchNo: 'PC-1', status: 'PICKED', palletCount: 1, packageCount: 2 }], page: 1, size: 20, total: 1, pages: 1 })
+    vi.mocked(listOutbounds).mockReset().mockResolvedValue({ records: [{ id: '1', outboundNo: 'OUT-1', dispatchNo: 'PC-1', status: 'WAIT_PICK', palletCount: 1, packageCount: 2 }], page: 1, size: 20, total: 1, pages: 1 })
    canPermission.mockReset().mockReturnValue(true)
    routerPush.mockReset()
  })
@@ -82,11 +82,10 @@ const selectedDropshipKeys = computed(() => new Set(selectedDropshipIds.value))
 const selectedPageCount = computed(() => pagedDropshipCandidates.value.filter(item => selectedDropshipKeys.value.has(dropshipCandidateKey(item))).length)
 const allPageSelected = computed(() => pagedDropshipCandidates.value.length > 0 && selectedPageCount.value === pagedDropshipCandidates.value.length)
 const somePageSelected = computed(() => selectedPageCount.value > 0 && !allPageSelected.value)
-const allFilteredSelected = computed(() => filteredDropshipCandidates.value.length > 0 && filteredDropshipCandidates.value.every(item => selectedDropshipKeys.value.has(dropshipCandidateKey(item))))
 const selectedDropshipCustomerCount = computed(() => new Set(dropshipCandidates.value.filter(item => selectedDropshipKeys.value.has(dropshipCandidateKey(item))).map(item => item.customerId).filter(Boolean)).size)
 const oneClickMarks = computed(() => typeof cartonMarks.value === 'string' ? cartonMarks.value.split(/[,\n，]+/).map(value => value.trim()).filter(Boolean) : [])
 const columns: DataTableColumn[] = [{ key: 'actions', label: '操作', width: 180, fixed: 'left', slotName: 'actions' }, { key: 'outboundNo', prop: 'outboundNo', label: '出库单号', minWidth: 180 }, { key: 'outboundType', prop: 'outboundType', label: '出库类型', width: 150, slotName: 'outboundType' }, { key: 'lxCodes', prop: 'lxCodes', label: 'LX代码', minWidth: 180 }, { key: 'dispatchNo', prop: 'dispatchNo', label: '关联排车单', minWidth: 160 }, { key: 'status', prop: 'status', label: '状态', width: 130, slotName: 'status' }, { key: 'palletCount', prop: 'palletCount', label: '托盘数', width: 100 }, { key: 'packageCount', prop: 'packageCount', label: '箱数', width: 100 }, { key: 'createdAt', prop: 'createdAt', label: '创建时间', minWidth: 180 }]
-const fields: QueryField[] = [{ key: 'documentNo', type: 'input', label: '出库单号', placeholder: '请输入出库单号', width: 220 }, { key: 'lxCode', type: 'input', label: 'LX代码', placeholder: '请输入领星入库单代码', width: 220 }, { key: 'warehouseId', type: 'input', label: '目的仓', placeholder: '请输入目的仓', width: 220 }, { key: 'status', type: 'select', label: '状态', placeholder: '全部状态', width: 160, options: [{ label: '全部', value: '' }, { label: '待出库', value: 'WAIT_OUTBOUND' }, { label: '已出库', value: 'OUTBOUNDED' }] }, { key: 'outboundType', type: 'select', label: '出库类型', placeholder: '全部出库类型', width: 170, options: [{ label: '全部', value: '' }, { label: '仓储转运出库', value: 'WAREHOUSE_TRANSFER_OUTBOUND' }, { label: '一件代发出库', value: 'ONE_CLICK_DROPSHIP' }, { label: '退货出库', value: 'RETURN_OUTBOUND' }, { label: '派送出库', value: 'DISPATCH_DELIVERY' }] }]
+const fields: QueryField[] = [{ key: 'documentNo', type: 'input', label: '出库单号', placeholder: '请输入出库单号', width: 220 }, { key: 'lxCode', type: 'input', label: 'LX代码', placeholder: '请输入领星入库单代码', width: 220 }, { key: 'warehouseId', type: 'input', label: '目的仓', placeholder: '请输入目的仓', width: 220 }, { key: 'status', type: 'select', label: '状态', placeholder: '全部状态', width: 160, options: [{ label: '全部', value: '' }, { label: '待拣货', value: 'WAIT_PICK' }, { label: '拣货中', value: 'PICKING' }, { label: '已拣货', value: 'PICKED' }, { label: '待出库', value: 'WAIT_OUTBOUND' }, { label: '已出库', value: 'OUTBOUNDED' }, { label: '已取消', value: 'CANCELLED' }] }, { key: 'outboundType', type: 'select', label: '出库类型', placeholder: '全部出库类型', width: 170, options: [{ label: '全部', value: '' }, { label: '仓储转运出库', value: 'WAREHOUSE_TRANSFER_OUTBOUND' }, { label: '一件代发出库', value: 'ONE_CLICK_DROPSHIP' }, { label: '退货出库', value: 'RETURN_OUTBOUND' }, { label: '派送出库', value: 'DISPATCH_DELIVERY' }] }]

 async function load(model: QueryModel = filters.value) { Object.assign(filters.value, model); loading.value = true; error.value = null; try { const result = await listOutbounds({ page: page.value, size: pageSize.value, documentNo: String(filters.value.documentNo || '').trim() || undefined, lxCode: String(filters.value.lxCode || '').trim() || undefined, warehouseId: String(filters.value.warehouseId || '').trim() || undefined, status: String(filters.value.status || '').trim() || undefined, outboundType: String(filters.value.outboundType || '').trim() || undefined }); rows.value = result.records.map((row) => ({ ...row, createdAt: formatOverseasDateTime(row.createdAt) })); total.value = result.total } catch (cause) { error.value = getApiErrorDetails(cause, '出库单列表加载失败') } finally { loading.value = false } }
 function outboundTypeLabel(value?: string | null) { return value === 'WAREHOUSE_TRANSFER_OUTBOUND' ? '仓储转运出库' : value === 'ONE_CLICK_DROPSHIP' ? '一件代发出库' : value === 'RETURN_OUTBOUND' ? '退货出库' : value === 'DISPATCH_DELIVERY' ? '派送出库' : value || '—' }
@@ -188,7 +187,7 @@ async function submit() {
  } catch (cause) { ElMessage.error(getApiErrorDetails(cause, '出库单创建失败').message) } finally { saving.value = false }
 }
 function openDetail(row: OutboundRow) { void router.push({ name: 'overseas-outbound-detail', params: { outboundNo: row.outboundNo } }) }
-function canCancel(row: OutboundRow) { return access.can(permission.outboundCancel) && ['WAIT_OUTBOUND', 'WAIT_PICK', 'PICKED'].includes(String(row.status || '')) }
+function canCancel(row: OutboundRow) { return access.can(permission.outboundCancel) && ['WAIT_PICK', 'WAIT_OUTBOUND'].includes(String(row.status || '')) }
 async function cancel(row: OutboundRow) { if (!canCancel(row)) return; let reason = ''; try { const result = await ElMessageBox.prompt(`出库单 ${row.outboundNo} · 出库数量 ${row.packageCount ?? 0}`, '取消出库单', { customClass: 'admin-density-confirm', inputType: 'textarea', inputPlaceholder: '请输入取消原因', inputPattern: /\S+/, inputErrorMessage: '请输入取消原因', confirmButtonText: '确认取消', cancelButtonText: '返回', type: 'warning' }); reason = result.value.trim() } catch { return }; mutationError.value = null; try { await cancelOutbound(row.outboundNo, reason); ElMessage.success('出库单已取消，库存及关联单据已回滚'); await load() } catch (cause) { mutationError.value = getApiErrorDetails(cause, '取消出库单失败') } }
 function search(model: QueryModel) { page.value = 1; void load(model) }
 function reset(model: QueryModel) { page.value = 1; void load(model) }
@@ -203,7 +202,7 @@ onMounted(load)
      <template #toolbar-actions><el-button v-if="access.can(permission.outboundCreate)" type="primary" @click="openCreate"><Plus :size="16" />新建出库单</el-button></template>
      <template #actions="{ row }"><div class="density-actions"><el-button class="density-action" data-tone="neutral" size="small" @click="openDetail(row as OutboundRow)">详情</el-button><el-button class="density-action" data-tone="danger" v-if="canCancel(row as OutboundRow)" size="small" @click="cancel(row as OutboundRow)">取消</el-button></div></template>
      <template #outboundType="{ row }">{{ outboundTypeLabel(row.outboundType) }}</template>
-      <template #status="{ row }"><StatusBadge :status="row.status === 'CANCELLED' ? '已取消' : row.status === 'OUTBOUNDED' ? '已出库' : row.status === 'PICKED' ? '已拣货' : '拣货中'" /></template>
+      <template #status="{ row }"><StatusBadge :status="row.status === 'CANCELLED' ? '已取消' : row.status === 'OUTBOUNDED' ? '已出库' : row.status === 'PICKED' ? '已拣货' : row.status === 'WAIT_OUTBOUND' ? '待出库' : row.status === 'PICKING' ? '拣货中' : row.status === 'WAIT_PICK' ? '待拣货' : '未知状态'" /></template>
    </DataTable></section>
  </ListPageLayout></AdminPage>
  <AppDialog class="admin-density-dialog" v-model="createOpen" title="新建出库单" width="min(1320px, calc(100vw - 32px))" :confirm-text="outboundType === 'WAREHOUSE_TRANSFER_OUTBOUND' ? '绑定目的地并进入排车' : '生成出库单并推送PDA'" :confirm-loading="saving" @confirm="submit">
@@ -221,22 +220,21 @@ onMounted(load)
        </el-select>
      </el-form-item>
      <template v-if="outboundType === 'ONE_CLICK_DROPSHIP'">
+        <div class="dropship-search-row">
        <el-form-item label="海外仓" required>
          <el-select v-model="selectedWarehouseId" filterable clearable default-first-option aria-label="搜索海外仓" placeholder="输入仓库名称或编码搜索" @change="changeDropshipWarehouse">
            <el-option v-for="item in warehouseOptions" :key="item.value" :value="item.value" :label="item.label" />
          </el-select>
        </el-form-item>
-        <el-form-item label="已完成入库的一件代发订单">
+        <el-form-item label="一件代发订单">
          <div class="candidate-query">
-            <el-input v-model="dropshipQueryInput" :prefix-icon="Search" clearable aria-label="搜索可出库订单" placeholder="按订单号、入库单号、客户、托盘号、SKU或品名筛选" @keyup.enter="searchDropshipCandidates" />
+            <el-input v-model="dropshipQueryInput" :prefix-icon="Search" clearable aria-label="搜索可出库订单" placeholder="订单号 / 入库单号 / 客户 / 托盘 / SKU / 品名" @keyup.enter="searchDropshipCandidates" />
            <el-button type="primary" :loading="inventoryLoading" @click="searchDropshipCandidates">查询</el-button>
            <el-button @click="resetDropshipCandidates">重置</el-button>
          </div>
-          <div class="candidate-selection" aria-label="订单批量选择">
-            <el-button :disabled="inventoryLoading || !filteredDropshipCandidates.length || allFilteredSelected" @click="selectDropshipRows(filteredDropshipCandidates, true)">全选筛选结果（{{ filteredDropshipCandidates.length }}）</el-button>
-            <el-button :disabled="!selectedDropshipIds.length" @click="selectedDropshipIds = []">清空选择</el-button>
-            <span aria-live="polite">已选择 {{ selectedDropshipIds.length }} 条，翻页保留选择</span>
-          </div>
+        </el-form-item>
+        </div>
+        <section class="candidate-results" aria-label="已完成入库的一件代发订单">
          <el-table v-loading="inventoryLoading" :data="pagedDropshipCandidates" border stripe class="dropship-candidate-table" max-height="360">
            <el-table-column label="选择" width="68" align="center">
              <template #header><el-checkbox aria-label="全选本页订单" :model-value="allPageSelected" :indeterminate="somePageSelected" :disabled="inventoryLoading || !pagedDropshipCandidates.length" @change="selectDropshipRows(pagedDropshipCandidates, $event)" /></template>
@@ -251,13 +249,13 @@ onMounted(load)
            <el-table-column prop="availablePackages" label="可出箱数" width="95" align="right" />
          </el-table>
          <div v-if="!inventoryLoading && !filteredDropshipCandidates.length" class="form-hint">暂无可直接出库的已完成入库订单</div>
-          <div v-if="filteredDropshipCandidates.length" class="candidate-pagination">
-            <span>第 {{ dropshipPage }} / {{ Math.max(1, Math.ceil(filteredDropshipCandidates.length / dropshipPageSize)) }} 页</span>
+          <div class="candidate-pagination">
+            <span aria-live="polite" title="翻页保留选择">已选择 {{ selectedDropshipIds.length }} 条 · 第 {{ dropshipPage }} / {{ Math.max(1, Math.ceil(filteredDropshipCandidates.length / dropshipPageSize)) }} 页</span>
            <el-pagination v-model:current-page="dropshipPage" v-model:page-size="dropshipPageSize" :page-sizes="[5, 10, 20, 50]" :pager-count="5" :total="filteredDropshipCandidates.length" layout="total, sizes, prev, pager, next, jumper" @size-change="dropshipPage = 1" />
          </div>
          <el-alert v-if="selectedDropshipCustomerCount > 1" title="当前选择包含多个客户，请按客户搜索后选择；一张出库单只能属于同一客户。" type="warning" :closable="false" />
-          <el-alert v-else title="一件代发按托盘与SKU选择；数量默认使用所选行全部可用箱数，同一张出库单只能选择同一客户、同一海外仓。" type="info" :closable="false" />
-        </el-form-item>
+          <p v-else class="candidate-hint">按托盘与 SKU 选择，默认出库全部可用箱数；仅限同一客户、同一海外仓，翻页保留选择。</p>
+        </section>
      </template>
      <template v-else-if="outboundType === 'WAREHOUSE_TRANSFER_OUTBOUND'">
        <el-alert title="仅展示已完成入库、换标已完成或无需换标，并且尚未设置目的地的仓储转运单。绑定后将从此列表移除并进入智能排车候选。" type="info" :closable="false" />
@@ -301,7 +299,7 @@ onMounted(load)
        </div>
        <el-alert title="退货出库支持按客户选择单个或多个箱子；SKU数量直接从所选箱唛明细扣减。" type="info" :closable="false" />
      </template>
-      <el-form-item label="备注"><el-input v-model="remark" type="textarea" placeholder="请输入备注（选填）" /></el-form-item>
+      <el-form-item label="备注"><el-input v-model="remark" type="textarea" :autosize="{ minRows: 1, maxRows: 3 }" placeholder="请输入备注（选填）" /></el-form-item>
    </el-form>
  </AppDialog>
 </template>
@@ -317,9 +315,11 @@ onMounted(load)
 .candidate-query { display: flex; width: 100%; gap: var(--admin-space-4); }
 .candidate-query :deep(.el-input) { flex: 1; }
 .candidate-query :deep(.el-button) { flex: 0 0 auto; min-width: 78px; margin-left: 0; }
-.candidate-selection { display: flex; align-items: center; flex-wrap: wrap; gap: var(--admin-space-3); width: 100%; margin-top: var(--admin-space-3); color: var(--cc-muted); font-size: var(--admin-font-caption); }
-.candidate-selection :deep(.el-button + .el-button) { margin-left: 0; }
-.dropship-candidate-table { margin-top: var(--admin-space-5); width: 100%; }
+.dropship-search-row { display: grid; grid-template-columns: minmax(0, 280px) minmax(0, 640px); align-items: end; gap: var(--admin-space-5); }
+.dropship-search-row :deep(.el-form-item) { min-width: 0; margin-bottom: var(--admin-space-3); }
+.candidate-results { min-width: 0; }
+.candidate-hint { margin: 0 0 var(--admin-space-3); color: var(--cc-muted); font-size: var(--admin-font-caption); line-height: 1.5; }
+.dropship-candidate-table { width: 100%; }
 .candidate-pagination { display: flex; width: 100%; align-items: center; justify-content: space-between; gap: var(--admin-space-5); padding: var(--admin-space-5) 0; color: var(--cc-muted); font-size: var(--admin-font-caption); }
 .candidate-pagination, .return-pagination { flex-wrap: wrap; }
 .candidate-pagination > span, .return-pagination > span { flex-shrink: 0; white-space: nowrap; }
@@ -8,7 +8,7 @@ vi.mock('@/shared/api/http', async (original) => ({
  http: { get: vi.fn(), post: vi.fn(), put: vi.fn(), patch: vi.fn() },
 }))

-const payload: SaveSupplierRequest = { name: '测试供应商', category: 'BOOKING', carrierCodes: ['MATSON', 'SML'], region: '宁波', legalRepresentative: '张三', contactName: '李四', phone: '13800000000', email: null, address: null, businessLicenseNo: null, licenseFileId: '9007199254740995', status: 'ACTIVE', settlementPeriod: 'MONTHLY_30', remark: null }
+const payload: SaveSupplierRequest = { name: '测试供应商', category: 'BOOKING', truckingScope: null, carrierCodes: ['MATSON', 'SML'], region: '宁波', legalRepresentative: '张三', contactName: '李四', phone: '13800000000', email: null, address: null, businessLicenseNo: null, licenseFileId: '9007199254740995', status: 'ACTIVE', settlementPeriod: 'MONTHLY_30', remark: null }
 const resource = { id: 9007199254740993, tenantId: 0, ...payload, createdBy: 9007199254740994, createdAt: '2026-08-13T10:00:00', updatedBy: null, updatedAt: '2026-08-13T10:00:00', deleted: false, version: 1 }

 describe('platform supplier API', () => {
@@ -37,4 +37,11 @@ describe('platform supplier API', () => {
    expect(http.put).toHaveBeenCalledWith('/platform/v1/suppliers/77', payload, { params: { tenantId: 0 } })
    expect(http.patch).toHaveBeenCalledWith('/platform/v1/suppliers/77/status', { status: 'INACTIVE' }, { params: { tenantId: 0 } })
  })
+  it('passes the trucking scope filter and keeps the authoritative type in resources', async () => {
+    vi.mocked(http.get).mockResolvedValue({ code: '200', data: { records: [{ ...resource, category: 'TRUCKING', carrierCodes: [], truckingScope: 'OVERSEAS' }], page: 1, size: 20, total: 1, pages: 1 } })
+    const page = await listSuppliers({ category: 'TRUCKING', truckingScope: 'OVERSEAS', status: 'ACTIVE' })
+    expect(http.get).toHaveBeenCalledWith('/platform/v1/suppliers', { params: expect.objectContaining({ category: 'TRUCKING', truckingScope: 'OVERSEAS', status: 'ACTIVE' }) })
+    expect(page.records[0]?.truckingScope).toBe('OVERSEAS')
+  })
+
 })
@@ -21,7 +21,7 @@ export async function listSuppliers(query: SupplierQuery): Promise<SupplierPage>
      page: query.page ?? 1, size: query.size ?? 20, category: query.category,
      region: query.region?.trim() || undefined,
      status: query.status || undefined, keyword: query.keyword?.trim() || undefined,
-      carrierCode: query.carrierCode || undefined,
+      carrierCode: query.carrierCode || undefined, truckingScope: query.truckingScope,
    },
  })
  const data = unwrapApiResponse(response)
@@ -12,7 +12,7 @@ import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
 import SupplierLicenseDialog from '@/modules/suppliers/components/SupplierLicenseDialog.vue'
 import { getSupplier } from '@/modules/suppliers/api/platformSuppliers'
-import { categoryLabels, formatCarrierCodes, settlementLabels, statusLabels, type Supplier } from '@/modules/suppliers/types'
+import { formatTruckingScope, categoryLabels, formatCarrierCodes, settlementLabels, statusLabels, type Supplier } from '@/modules/suppliers/types'

 const route = useRoute(); const router = useRouter(); const access = useAccessPreviewStore()
 const canView = computed(() => access.can('platform:supplier:list'))
@@ -21,6 +21,7 @@ const supplier = ref<Supplier | null>(null); const loading = ref(false); const e
 let loadSequence = 0
 const items = computed(() => supplier.value ? [
  ['供应商名称', supplier.value.name], ['供应商类别', categoryLabels[supplier.value.category]], ['可代理船公司', supplier.value.category === 'BOOKING' ? formatCarrierCodes(supplier.value.carrierCodes) : '—'], ['地区', supplier.value.region],
+  ...(supplier.value.category === 'TRUCKING' ? [['拖车类型', formatTruckingScope(supplier.value.truckingScope)]] : []),
  ['法人代表', supplier.value.legalRepresentative], ['联系人', supplier.value.contactName], ['联系电话', supplier.value.phone], ['电子邮箱', supplier.value.email || '—'],
  ['营业执照号', supplier.value.businessLicenseNo || '—'], ['结算周期', settlementLabels[supplier.value.settlementPeriod]], ['公司地址', supplier.value.address || '—'], ['备注', supplier.value.remark || '—'],
 ] : [])
@@ -14,7 +14,7 @@ import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
 import { useUnsavedWorkRegistration } from '@/core/unsaved-work/useUnsavedWorkRegistration'
 import { createSupplier, getSupplier, updateSupplier } from '@/modules/suppliers/api/platformSuppliers'
-import { carrierCodeOptions, categoryLabels, settlementLabels, statusLabels, type SaveSupplierRequest } from '@/modules/suppliers/types'
+import { truckingScopeLabels, carrierCodeOptions, categoryLabels, settlementLabels, statusLabels, type TruckingScope, type SaveSupplierRequest } from '@/modules/suppliers/types'

 const route = useRoute()
 const router = useRouter()
@@ -27,10 +27,13 @@ const loading = ref(false)
 const saving = ref(false)
 const loadError = ref<ApiErrorDetails | null>(null)
 const submitError = ref<ApiErrorDetails | null>(null)
-const initial = (): SaveSupplierRequest => ({ name: '', category: 'BOOKING', carrierCodes: [], region: '', legalRepresentative: '', contactName: '', phone: '', email: null, address: null, businessLicenseNo: null, licenseFileId: null, status: 'ACTIVE', settlementPeriod: 'MONTHLY_30', remark: null })
+const initial = (): SaveSupplierRequest => ({ name: '', category: 'BOOKING', truckingScope: null, carrierCodes: [], region: '', legalRepresentative: '', contactName: '', phone: '', email: null, address: null, businessLicenseNo: null, licenseFileId: null, status: 'ACTIVE', settlementPeriod: 'MONTHLY_30', remark: null })
 const form = reactive(initial())
+const saveAttempted = ref(false)
+const truckingScopeError = computed(() => saveAttempted.value && form.category === 'TRUCKING' && !form.truckingScope ? '请选择国内拖车或海外车队' : '')
 const rules: FormRules<SaveSupplierRequest> = {
  name: [{ required: true, message: '请输入供应商名称', trigger: 'blur' }], category: [{ required: true, message: '请选择供应商类别', trigger: 'change' }],
+  truckingScope: [{ required: true, type: 'enum', enum: ['DOMESTIC', 'OVERSEAS'], message: '请选择国内拖车或海外车队', trigger: 'change' }],
  carrierCodes: [{ validator: (_rule, value, callback) => form.category === 'BOOKING' && (!Array.isArray(value) || value.length === 0) ? callback(new Error('请至少选择一家可代理船公司')) : callback(), trigger: 'change' }],
  region: [{ required: true, message: '请输入地区', trigger: 'blur' }], legalRepresentative: [{ required: true, message: '请输入法人代表', trigger: 'blur' }],
  contactName: [{ required: true, message: '请输入联系人', trigger: 'blur' }], phone: [{ required: true, message: '请输入联系电话', trigger: 'blur' }],
@@ -42,11 +45,11 @@ const { captureBaseline } = useUnsavedWorkRegistration({ key: 'supplier-editor',
 function optional(value: string | null) { return value?.trim() || null }
 function payload(): SaveSupplierRequest {
  const { carrierCodes, ...fields } = form
-  const normalized = { ...fields, name: form.name.trim(), region: form.region.trim(), legalRepresentative: form.legalRepresentative.trim(), contactName: form.contactName.trim(), phone: form.phone.trim(), email: optional(form.email), address: optional(form.address), businessLicenseNo: optional(form.businessLicenseNo), licenseFileId: form.licenseFileId, remark: optional(form.remark) }
+  const normalized = { ...fields, truckingScope: form.category === 'TRUCKING' ? form.truckingScope : null, name: form.name.trim(), region: form.region.trim(), legalRepresentative: form.legalRepresentative.trim(), contactName: form.contactName.trim(), phone: form.phone.trim(), email: optional(form.email), address: optional(form.address), businessLicenseNo: optional(form.businessLicenseNo), licenseFileId: form.licenseFileId, remark: optional(form.remark) }
  return form.category === 'BOOKING' ? { ...normalized, carrierCodes: [...(carrierCodes || [])] } : normalized
 }
 let loadSequence = 0
-function resetForm() { Object.assign(form, initial()) }
+function resetForm() { Object.assign(form, initial()); saveAttempted.value = false }
 async function load() {
  const requestedId = supplierId.value
  const sequence = ++loadSequence
@@ -59,7 +62,7 @@ async function load() {
  try {
    const data = await getSupplier(requestedId)
    if (sequence !== loadSequence || requestedId !== supplierId.value) return
-    Object.assign(form, { name: data.name, category: data.category, carrierCodes: data.category === 'BOOKING' ? [...data.carrierCodes] : [], region: data.region, legalRepresentative: data.legalRepresentative, contactName: data.contactName, phone: data.phone, email: data.email, address: data.address, businessLicenseNo: data.businessLicenseNo, licenseFileId: data.licenseFileId, status: data.status, settlementPeriod: data.settlementPeriod, remark: data.remark })
+    Object.assign(form, { name: data.name, category: data.category, truckingScope: data.truckingScope, carrierCodes: data.category === 'BOOKING' ? [...data.carrierCodes] : [], region: data.region, legalRepresentative: data.legalRepresentative, contactName: data.contactName, phone: data.phone, email: data.email, address: data.address, businessLicenseNo: data.businessLicenseNo, licenseFileId: data.licenseFileId, status: data.status, settlementPeriod: data.settlementPeriod, remark: data.remark })
    captureBaseline()
  } catch (error) {
    if (sequence === loadSequence && requestedId === supplierId.value) loadError.value = getApiErrorDetails(error, '供应商详情加载失败')
@@ -67,6 +70,8 @@ async function load() {
 }
 async function save() {
  if (!access.can(requiredPermission.value)) return
+  saveAttempted.value = true
+  if (truckingScopeError.value) return
  if (!await formRef.value?.validate().catch(() => false)) return
  saving.value = true; submitError.value = null
  try {
@@ -86,7 +91,7 @@ onActivated(() => {
  else activatedOnce = true
 })
 onDeactivated(() => { active = false })
-watch(() => form.category, (category) => { if (category !== 'BOOKING') form.carrierCodes = [] })
+watch(() => form.category, (category) => { if (category !== 'BOOKING') form.carrierCodes = []; if (category !== 'TRUCKING') form.truckingScope = null })
 </script>

 <template>
@@ -103,6 +108,7 @@ watch(() => form.category, (category) => { if (category !== 'BOOKING') form.carr
              <el-form-item label="供应商名称" prop="name"><el-input v-model="form.name" maxlength="160" placeholder="请输入供应商名称" /></el-form-item>
              <el-form-item label="供应商类别" prop="category"><el-select v-model="form.category"><el-option v-for="(label, value) in categoryLabels" :key="value" :label="label" :value="value" /></el-select></el-form-item>
              <el-form-item v-if="form.category === 'BOOKING'" label="可代理船公司" prop="carrierCodes"><el-select v-model="form.carrierCodes" multiple collapse-tags collapse-tags-tooltip placeholder="请选择可代理船公司"><el-option v-for="option in carrierCodeOptions" :key="option.value" :label="option.label" :value="option.value" /></el-select></el-form-item>
+              <el-form-item v-if="form.category === 'TRUCKING'" label="拖车类型" prop="truckingScope" :error="truckingScopeError" required><el-radio-group :model-value="form.truckingScope ?? undefined" @update:model-value="form.truckingScope = $event as TruckingScope"><el-radio v-for="(label, value) in truckingScopeLabels" :key="value" :value="value">{{ label }}</el-radio></el-radio-group></el-form-item>
              <el-form-item label="地区" prop="region"><el-input v-model="form.region" maxlength="80" placeholder="请输入地区" /></el-form-item>
              <el-form-item label="法人代表" prop="legalRepresentative"><el-input v-model="form.legalRepresentative" maxlength="80" placeholder="请输入法人代表" /></el-form-item>
              <el-form-item label="联系人" prop="contactName"><el-input v-model="form.contactName" maxlength="80" placeholder="请输入联系人" /></el-form-item>
@@ -26,7 +26,7 @@ vi.mock('@/modules/suppliers/api/platformSuppliers', () => ({
 }))

 function supplier(id: string, name: string): Supplier {
-  return { id, tenantId: '0', name, category: 'BOOKING', carrierCodes: ['MATSON', 'SML'], region: '宁波', legalRepresentative: '法人', contactName: '联系人', phone: '13800000000', email: null, address: null, businessLicenseNo: null, licenseFileId: null, status: 'ACTIVE', settlementPeriod: 'MONTHLY_30', remark: null, createdBy: null, createdAt: '', updatedBy: null, updatedAt: '', deleted: false, version: 1 }
+  return { id, tenantId: '0', name, category: 'BOOKING', truckingScope: null, carrierCodes: ['MATSON', 'SML'], region: '宁波', legalRepresentative: '法人', contactName: '联系人', phone: '13800000000', email: null, address: null, businessLicenseNo: null, licenseFileId: null, status: 'ACTIVE', settlementPeriod: 'MONTHLY_30', remark: null, createdBy: null, createdAt: '', updatedBy: null, updatedAt: '', deleted: false, version: 1 }
 }

 function deferred<T>() {
@@ -152,4 +152,24 @@ describe('supplier route reuse', () => {
    expect(mocks.listSuppliers).toHaveBeenCalledTimes(2)
    expect(mocks.getSupplierStats).toHaveBeenCalledTimes(2)
  })
+  it('requires one trucking type, saves overseas and clears the type after changing category', async () => {
+    mocks.getSupplier.mockResolvedValue({ ...supplier('A', '车队'), category: 'TRUCKING', carrierCodes: [], truckingScope: null })
+    const wrapper = mount(SupplierFormView, { global: { plugins: [ElementPlus], stubs } })
+    await flushPromises()
+    const save = wrapper.findAll('button').find((button) => button.text().includes('保存'))!
+    await save.trigger('click'); await flushPromises()
+    expect(mocks.updateSupplier).not.toHaveBeenCalled()
+    expect(wrapper.findAllComponents({ name: 'ElFormItem' }).find(item => item.props('prop') === 'truckingScope')?.props('error')).toBe('请选择国内拖车或海外车队')
+    const radios = wrapper.findComponent({ name: 'ElRadioGroup' })
+    expect(radios.text()).toContain('国内拖车')
+    expect(radios.text()).toContain('海外车队')
+    radios.vm.$emit('update:modelValue', 'OVERSEAS')
+    await flushPromises(); await save.trigger('click'); await flushPromises()
+    expect(mocks.updateSupplier).toHaveBeenLastCalledWith('A', expect.objectContaining({ category: 'TRUCKING', truckingScope: 'OVERSEAS' }))
+    wrapper.findAllComponents({ name: 'ElSelect' })[0]!.vm.$emit('update:modelValue', 'CUSTOMS')
+    await flushPromises(); await save.trigger('click'); await flushPromises()
+    expect(wrapper.findComponent({ name: 'ElRadioGroup' }).exists()).toBe(false)
+    expect(mocks.updateSupplier).toHaveBeenLastCalledWith('A', expect.objectContaining({ category: 'CUSTOMS', truckingScope: null }))
+  })
+
 })
@@ -16,7 +16,7 @@ import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
 import SupplierLicenseDialog from '@/modules/suppliers/components/SupplierLicenseDialog.vue'
 import { changeSupplierStatus, getSupplierStats, listSuppliers } from '@/modules/suppliers/api/platformSuppliers'
-import { carrierCodeOptions, categoryLabels, formatCarrierCodes, settlementLabels, statusLabels, type CarrierCode, type Supplier, type SupplierCategory, type SupplierStats, type SupplierStatus } from '@/modules/suppliers/types'
+import { truckingScopeOptions, formatTruckingScope, type TruckingScope, carrierCodeOptions, categoryLabels, formatCarrierCodes, settlementLabels, statusLabels, type CarrierCode, type Supplier, type SupplierCategory, type SupplierStats, type SupplierStatus } from '@/modules/suppliers/types'

 const router = useRouter()
 const access = useAccessPreviewStore()
@@ -32,14 +32,15 @@ const loadError = ref<ApiErrorDetails | null>(null)
 const actionId = ref('')
 const licenseOpen = ref(false)
 const licenseSupplier = ref<Supplier | null>(null)
-type Filters = QueryModel & { status: SupplierStatus | ''; region: string; keyword: string; carrierCode: CarrierCode | '' }
-const filters = ref<Filters>({ status: '', region: '', keyword: '', carrierCode: '' })
+type Filters = QueryModel & { status: SupplierStatus | ''; region: string; keyword: string; carrierCode: CarrierCode | ''; truckingScope: TruckingScope | '' }
+const filters = ref<Filters>({ status: '', region: '', keyword: '', carrierCode: '', truckingScope: '' })
 const applied = ref<Filters>({ ...filters.value })
 let sequence = 0

 const queryFields = computed<QueryField[]>(() => [
  { key: 'status', type: 'select', label: '状态', placeholder: '全部状态', width: 150, options: [{ label: '合作中', value: 'ACTIVE' }, { label: '停用', value: 'INACTIVE' }] },
  ...(activeCategory.value === 'BOOKING' ? [{ key: 'carrierCode', type: 'select' as const, label: '可代理船公司', placeholder: '全部船公司', width: 190, options: carrierCodeOptions }] : []),
+  ...(activeCategory.value === 'TRUCKING' ? [{ key: 'truckingScope', type: 'select' as const, label: '拖车类型', placeholder: '全部拖车类型', width: 170, options: truckingScopeOptions }] : []),
  { key: 'region', type: 'input', label: '地区', placeholder: '请输入地区', width: 170, props: { maxlength: 80 } },
  { key: 'keyword', type: 'input', label: '名称或联系人', placeholder: '供应商名称/联系人', width: 220, props: { maxlength: 160 } },
 ])
@@ -48,7 +49,8 @@ const columns = computed<DataTableColumn[]>(() => [
  { key: 'actions', label: '操作', width: 260, fixed: 'left', slotName: 'actions' },
  { key: 'name', label: '供应商名称', minWidth: 200, slotName: 'name' },
  { key: 'category', label: '类别', width: 70, slotName: 'category' },
-  { key: 'carrierCodes', label: '可代理船公司', minWidth: 200, slotName: 'carrierCodes' },
+  ...(activeCategory.value === 'BOOKING' ? [{ key: 'carrierCodes', label: '可代理船公司', minWidth: 200, slotName: 'carrierCodes' }] : []),
+  ...(activeCategory.value === 'TRUCKING' ? [{ key: 'truckingScope', label: '拖车类型', width: 110, slotName: 'truckingScope' }] : []),
  { key: 'region', label: '地区', minWidth: 100 },
  { key: 'legalRepresentative', label: '法人', minWidth: 100 },
  { key: 'contactName', label: '联系人', minWidth: 120 },
@@ -72,7 +74,7 @@ async function load() {
  loadError.value = null
  try {
    const [result, counts] = await Promise.all([
-      listSuppliers({ page: page.value, size: pageSize.value, category: activeCategory.value, status: applied.value.status, region: applied.value.region, keyword: applied.value.keyword, carrierCode: activeCategory.value === 'BOOKING' ? applied.value.carrierCode || undefined : undefined }),
+      listSuppliers({ page: page.value, size: pageSize.value, category: activeCategory.value, status: applied.value.status, region: applied.value.region, keyword: applied.value.keyword, truckingScope: activeCategory.value === 'TRUCKING' ? applied.value.truckingScope || undefined : undefined, carrierCode: activeCategory.value === 'BOOKING' ? applied.value.carrierCode || undefined : undefined }),
      getSupplierStats(),
    ])
    if (current !== sequence) return
@@ -152,6 +154,7 @@ onActivated(() => {
          </template>
          <template #name="{ row }"><LineClampText :content="row.name" /></template>
          <template #category="{ row }">{{ categoryLabels[row.category as SupplierCategory] }}</template>
+          <template #truckingScope="{ row }">{{ formatTruckingScope(supplierRow(row).truckingScope) }}</template>
          <template #carrierCodes="{ row }"><LineClampText :content="supplierRow(row).category === 'BOOKING' ? formatCarrierCodes(supplierRow(row).carrierCodes) : null" /></template>
          <template #license="{ row }"><el-button data-tone="neutral" class="density-action" size="small"   @click="showLicense(supplierRow(row))">查看</el-button></template>
          <template #status="{ row }"><StatusBadge :status="statusLabels[supplierRow(row).status] ?? '—'" /></template>
@@ -1,4 +1,8 @@
 export type SupplierCategory = 'BOOKING' | 'CUSTOMS' | 'TRUCKING' | 'CERTIFICATE'
+export type TruckingScope = 'DOMESTIC' | 'OVERSEAS'
+export const truckingScopeLabels: Record<TruckingScope, string> = { DOMESTIC: '国内拖车', OVERSEAS: '海外车队' }
+export const truckingScopeOptions = Object.entries(truckingScopeLabels).map(([value, label]) => ({ value, label }))
+export function formatTruckingScope(scope: TruckingScope | null) { return scope ? truckingScopeLabels[scope] : '—' }
 export type SupplierStatus = 'ACTIVE' | 'INACTIVE'
 export type SettlementPeriod = 'MONTHLY_30' | 'MONTHLY_45' | 'MONTHLY_60' | 'MONTHLY_90' | 'PER_TRANSACTION' | 'IMMEDIATE'
 export type CarrierCode = 'MATSON' | 'SML' | 'ZIM' | 'COSCO' | 'EMC' | 'HEDE' | 'OTHER'
@@ -8,6 +12,7 @@ export interface Supplier {
  tenantId: string
  name: string
  category: SupplierCategory
+  truckingScope: TruckingScope | null
  carrierCodes: CarrierCode[]
  region: string
  legalRepresentative: string
@@ -42,6 +47,7 @@ export interface SupplierQuery {
  page?: number
  size?: number
  category?: SupplierCategory
+  truckingScope?: TruckingScope
  region?: string
  status?: SupplierStatus | ''
  keyword?: string
@@ -51,6 +57,7 @@ export interface SupplierQuery {
 export interface SaveSupplierRequest {
  name: string
  category: SupplierCategory
+  truckingScope: TruckingScope | null
  carrierCodes?: CarrierCode[]
  region: string
  legalRepresentative: string
@@ -9,7 +9,7 @@ import { getOceanBooking } from '@/modules/ocean-bookings'
 import { listTruckAppointmentCandidates } from '../api/platformTrucking'

 vi.mock('@/modules/suppliers', () => ({
-  listSuppliers: vi.fn().mockResolvedValue({ records: [{ id: 'carrier-1', name: '平台拖车公司', category: 'TRUCKING', status: 'ACTIVE', contactName: '张调度', phone: '13800000001' }, { id: 'carrier-2', name: '第二车队', category: 'TRUCKING', status: 'ACTIVE', contactName: '李调度', phone: '13800000002' }] }),
+  listSuppliers: vi.fn().mockResolvedValue({ records: [{ id: 'carrier-1', name: '平台拖车公司', category: 'TRUCKING', truckingScope: 'DOMESTIC', status: 'ACTIVE', contactName: '张调度', phone: '13800000001' }, { id: 'carrier-2', name: '第二车队', category: 'TRUCKING', truckingScope: 'DOMESTIC', status: 'ACTIVE', contactName: '李调度', phone: '13800000002' }, { id: 'overseas-1', name: '海外车队候选', category: 'TRUCKING', truckingScope: 'OVERSEAS', status: 'ACTIVE' }] }),
 }))
 vi.mock('@/modules/ocean-bookings', () => ({
  getOceanBooking: vi.fn(),
@@ -172,8 +172,9 @@ describe('TruckAppointmentForm booking-only behavior', () => {
  it('copies supplier contacts and replaces or clears them when switching suppliers', async () => {
    const wrapper = mount(TruckAppointmentForm, { props: { modelValue: { ...model } }, global: { plugins: [ElementPlus] } })
    await flushPromises()
-    expect(listSuppliers).toHaveBeenCalledWith({ page: 1, size: 200, category: 'TRUCKING', status: 'ACTIVE' })
+    expect(listSuppliers).toHaveBeenCalledWith({ page: 1, size: 200, category: 'TRUCKING', truckingScope: 'DOMESTIC', status: 'ACTIVE' })
    const supplier = wrapper.findAllComponents({ name: 'ElSelect' })[1]!
+    expect(supplier.findAllComponents({ name: 'ElOption' }).map(option => option.props('value'))).not.toContain('overseas-1')
    supplier.vm.$emit('update:modelValue', 'carrier-1')
    await flushPromises()
    expect(wrapper.emitted('update:modelValue')!.at(-1)![0]).toMatchObject({ carrierId: 'carrier-1', fleetContact: '张调度', fleetPhone: '13800000001', currency: 'RMB' })
@@ -53,7 +53,7 @@ const optionsError = ref('')
 let bookingLoadSequence = 0
 let optionsLoadSequence = 0
 const selectableCarriers = computed(() => carriers.value.filter((item) => (
-  item.status === 'ACTIVE'
+  item.status === 'ACTIVE' && item.truckingScope === 'DOMESTIC'
 )))
 const bookings = computed(() => {
  const result = new Map<string, { id: string; bookingNo: string; billOfLadingNo: string | null; warehouseId: string; warehouseName: string | null; bookingDocumentReady: boolean }>()
@@ -130,11 +130,11 @@ async function loadOptions() {
  optionsLoading.value = true; optionsError.value = ''
  candidates.value = []
  const results = await Promise.allSettled([
-    listSuppliers({ page: 1, size: 200, category: 'TRUCKING', status: 'ACTIVE' }),
+    listSuppliers({ page: 1, size: 200, category: 'TRUCKING', truckingScope: 'DOMESTIC', status: 'ACTIVE' }),
    relationLocked.value ? Promise.resolve({ records: [] as TruckAppointmentCandidate[] }) : listTruckAppointmentCandidates({ page: 1, size: 200 }),
  ])
  if (sequence !== optionsLoadSequence) return
-  if (results[0].status === 'fulfilled') carriers.value = results[0].value.records.filter((item) => item.category === 'TRUCKING' && item.status === 'ACTIVE')
+  if (results[0].status === 'fulfilled') carriers.value = results[0].value.records.filter((item) => item.category === 'TRUCKING' && item.status === 'ACTIVE' && item.truckingScope === 'DOMESTIC')
  if (results[1].status === 'fulfilled') candidates.value = results[1].value.records
  const failed = ['拖车供应商', '可用订舱'].filter((_, index) => results[index]?.status === 'rejected')
  if (failed.length) optionsError.value = `${failed.join('、')}选项加载失败`
@@ -182,6 +182,7 @@ describe('InboundFeeDetailManager', () => {
  })

  it('spins only the refresh icon while fee rows are loading', () => {
+    expect(source).toContain('class="fee-refresh-button" circle aria-label="刷新费用明细"')
    expect(source).toContain(':aria-busy="loading" :disabled="loading"')
    expect(source).toContain(`<RefreshCw :size="16" :class="{ 'is-spinning': loading }" />`)
    expect(source).not.toMatch(/aria-label="刷新费用明细"[^>]*:loading=/)
@@ -276,7 +276,7 @@ onMounted(() => void load())
    <div class="fee-toolbar">
      <span>共 {{ rows.length }} 条应收应付费用明细</span>
      <div>
-        <el-tooltip content="刷新费用明细" placement="top"><el-button circle aria-label="刷新费用明细" :aria-busy="loading" :disabled="loading" @click="load"><RefreshCw :size="16" :class="{ 'is-spinning': loading }" /></el-button></el-tooltip>
+        <el-tooltip content="刷新费用明细" placement="top"><el-button class="fee-refresh-button" circle aria-label="刷新费用明细" :aria-busy="loading" :disabled="loading" @click="load"><RefreshCw :size="16" :class="{ 'is-spinning': loading }" /></el-button></el-tooltip>
        <el-button v-if="access.can('firstleg:inbound:fee-detail:edit') && canViewFeeItems" type="primary" @click="openEditor('create')"><Plus :size="16" />新增费用</el-button>
      </div>
    </div>
@@ -365,7 +365,7 @@ onMounted(() => void load())
 .fee-toolbar { display: flex; align-items: center; justify-content: space-between; gap: var(--admin-space-5); color: var(--el-text-color-secondary); font-size: var(--admin-font-body); }
 .fee-toolbar > div { display: flex; flex-wrap: wrap; gap: var(--admin-space-3); }
 .fee-toolbar :deep(.el-button + .el-button) { margin-left: 0; }
-.fee-toolbar .is-spinning { animation: fee-refresh-spin 0.8s linear infinite; }
+.fee-refresh-button .is-spinning { animation: fee-refresh-spin 0.8s linear infinite; }
 .fee-form { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 0 var(--admin-space-6); margin-top: var(--admin-space-5); }
 .fee-form :deep(.el-select), .fee-form :deep(.el-date-editor), .fee-form :deep(.el-input-number) { width: 100%; }
 .fee-form :deep(.el-form-item:last-child) { grid-column: 1 / -1; }
@@ -199,6 +199,7 @@ describe('UnifiedOrdersView list request coordination', () => {
    vi.mocked(listPlatformUnifiedOrders).mockResolvedValue({
      records: [{
        orderId: '2089223263733518337', orderVersion: 7, tenantId: '2089176869176389634',
+        internalOrderStatus: 'SUBMITTED',
        inboundCode: 'NYEXX2609030001', expectedArrivalAt: '2026-09-10T08:30:00', estimatedVolumeCbm: 0.25,
      }], page: 1, size: 20, total: 1, pages: 1,
    } as never)
@@ -235,4 +236,23 @@ describe('UnifiedOrdersView list request coordination', () => {
      showClose: true,
    }))
  })
+
+  it('shows planning values without editors after the order enters irreversible fulfillment', async () => {
+    vi.mocked(listPlatformUnifiedOrders).mockResolvedValue({
+      records: [{
+        orderId: '2099751993783402497', orderVersion: 7, tenantId: '2097708157074210818',
+        internalOrderStatus: 'PROCESSING', mainStatus: 'LOADED', inboundCode: 'AT0E9B5BF2839C6944CFA3',
+        expectedArrivalAt: '2026-10-15T00:00:00', estimatedVolumeCbm: 220,
+      }], page: 1, size: 20, total: 1, pages: 1,
+    } as never)
+
+    const wrapper = mountView()
+    await flushPromises()
+
+    expect(wrapper.findComponent({ name: 'ElInputNumber' }).exists()).toBe(false)
+    expect(wrapper.findComponent({ name: 'ElDatePicker' }).exists()).toBe(false)
+    expect(wrapper.text()).toContain('220')
+    expect(wrapper.text()).toContain('2026-10-15 00:00')
+    expect(updatePlatformUnifiedOrderPlanning).not.toHaveBeenCalled()
+  })
 })
@@ -602,7 +602,7 @@ describe('UnifiedOrdersView contract', () => {
    expect(source).toContain('display-only')
    expect(source).toContain(':key="`fee-${normalizedInboundId}-${feePanelRevision}`"')
    expect(source).toContain('feePanelRevision.value += 1')
-    expect(source).toContain('头程自动初算')
+    expect(source).not.toContain('<h3 class="fee-section-title">头程自动初算</h3>')
    expect(source).toContain('其他费用明细')
    expect(source).toContain('@changed="loadDetail(true)"')
    expect(source).toContain('firstLegTransportModeLabel(detail.order.order?.transportMode)')
@@ -627,6 +627,9 @@ describe('UnifiedOrdersView contract', () => {
  })

  it('only exposes declaration editing before loading and marks channel changes', () => {
+    expect(source).toContain("new Set(['DRAFT', 'REJECTED', 'SUBMITTED', 'APPROVED'])")
+    expect(source).toContain("planningEditableOrderStatuses.has(row.internalOrderStatus || '')")
+    expect(source).toContain('v-if="canEditPlanning(row as UnifiedOrderResource)"')
    expect(source).toContain("new Set<UnifiedOrderMainStatus>(['PENDING_REVIEW', 'WAIT_MEASURE', 'WAIT_SPLIT'])")
    expect(source).toContain('declarationEditableStatuses.has(detail.value.summary.mainStatus)')
    expect(source).not.toContain("detail.value.summary.mainStatus === 'WAIT_MEASURE'")
@@ -733,7 +733,7 @@ function planningDraft(row: UnifiedOrderResource) {

 async function savePlanning(row: UnifiedOrderResource) {
  const draft = planningDraft(row)
-  if (!can('platform:order:declaration:edit') || draft.saving) return
+  if (!canEditPlanning(row) || draft.saving) return
  const estimatedVolumeCbm = draft.estimatedVolumeCbm ?? null
  draft.estimatedVolumeCbm = estimatedVolumeCbm
  if (!Number.isInteger(row.orderVersion)) {
@@ -777,6 +777,13 @@ async function savePlanning(row: UnifiedOrderResource) {
  }
 }

+const planningEditableOrderStatuses = new Set(['DRAFT', 'REJECTED', 'SUBMITTED', 'APPROVED'])
+
+function canEditPlanning(row: UnifiedOrderResource) {
+  return can('platform:order:declaration:edit')
+    && planningEditableOrderStatuses.has(row.internalOrderStatus || '')
+}
+
 const declarationEditableStatuses = new Set<UnifiedOrderMainStatus>(['PENDING_REVIEW', 'WAIT_MEASURE', 'WAIT_SPLIT'])
 const canEditDeclaration = computed(() => Boolean(
  detail.value
@@ -2380,7 +2387,6 @@ onBeforeUnmount(() => {
                <div><dt>对客费用合计</dt><dd>{{ feeMoney(customerFeeTotal) }}</dd><small>已发布头程费用 + 已审核其他应收</small></div>
                <div><dt>已审核其他应付</dt><dd>{{ feeMoney(otherFeeSummary.approvedPayable) }}</dd><small>单列展示，不计入对客费用</small></div>
              </dl>
-              <h3 class="fee-section-title">头程自动初算</h3>
              <InboundFeePanel
                :key="`fee-${normalizedInboundId}-${feePanelRevision}`"
                :customer-id="String(detail.summary.tenantId)"
@@ -2673,7 +2679,7 @@ onBeforeUnmount(() => {
        <template #estimatedVolume="{ row }">
          <div class="planning-cell">
            <el-input-number
-              v-if="can('platform:order:declaration:edit')"
+              v-if="canEditPlanning(row as UnifiedOrderResource)"
              v-model="planningDraft(row as UnifiedOrderResource).estimatedVolumeCbm"
              class="planning-volume-input"
              :min="0.0001"
@@ -2692,7 +2698,7 @@ onBeforeUnmount(() => {
          <div class="planning-cell">
            <el-date-picker
              style="width: 100%;"
-              v-if="can('platform:order:declaration:edit')"
+              v-if="canEditPlanning(row as UnifiedOrderResource)"
              v-model="planningDraft(row as UnifiedOrderResource).expectedArrivalAt"
              class="planning-arrival-input"
              type="datetime"
@@ -4,8 +4,8 @@ import { computed } from 'vue'
 const props = defineProps<{ status: string }>()

 const tone = computed(() => {
-  if (['正常', '启用', '已完成', '已审核', '审核通过', '已入库', '装柜完成', '派送完成', '已确认', '已放舱'].includes(props.status)) return 'success'
-  if (['待审核', '草稿', '待处理', '待分配', '未提交', '未录入', '待测量数据', '待分柜', '待装柜', '预装柜中', '变更中'].includes(props.status)) return 'warning'
+  if (['正常', '启用', '已完成', '已审核', '审核通过', '已入库', '已出库', '装柜完成', '派送完成', '已确认', '已放舱'].includes(props.status)) return 'success'
+  if (['待审核', '草稿', '待处理', '待分配', '未提交', '未录入', '待测量数据', '待分柜', '待装柜', '预装柜中', '待拣货', '待出库', '已拣货', '变更中'].includes(props.status)) return 'warning'
  if (['已受理', '已订舱', '已提交', '运输中', '处理中', '拣货中', '装柜中'].includes(props.status)) return 'info'
  if (['停用', '已取消', '已驳回', '审核驳回', '失败', '订舱失败'].includes(props.status)) return 'danger'
  return 'neutral'