2026-10-23 10:51:28 +08:00
39 changed files with 1093 additions and 120 deletions
@@ -108,7 +108,8 @@ describe('four-type appointment calendar', () => {
    expect(wrapper.text()).toContain('正在读取安排')
    expect(wrapper.text()).not.toContain('当天暂无安排')
    await wrapper.setProps({ loading: false, incomplete: true })
-    expect(wrapper.text()).toContain('部分数据不可用')
+    expect(wrapper.get('[aria-label="当天安排"] header').text()).toContain('当前已加载 0 项安排')
+    expect(wrapper.text()).not.toContain('部分数据不可用')
    expect(wrapper.text()).not.toContain('当天暂无安排')
  })
 })
@@ -70,9 +70,9 @@ function changeMode(next: CalendarMode) {
      </div>
    </div>
    <aside class="calendar-detail workbench-panel is-flush" aria-label="当天安排">
-      <header><strong>{{ undated ? '未定日期' : selectedDate }}</strong><p v-if="loading">正在读取安排…</p><p v-else>{{ incomplete ? '当前已加载' : undated ? '共有' : '当天共有' }} <b>{{ selectedEvents.length }}</b> 项安排<span v-if="incomplete">（部分数据不可用）</span></p></header>
+      <header><strong>{{ undated ? '未定日期' : selectedDate }}</strong><p v-if="loading">正在读取安排…</p><p v-else>{{ incomplete ? '当前已加载' : undated ? '共有' : '当天共有' }} <b>{{ selectedEvents.length }}</b> 项安排</p></header>
      <div class="detail-events" aria-live="polite">
-        <p v-if="!selectedEvents.length && !loading" class="empty-day">{{ incomplete ? '已加载数据中没有安排，请先处理上方数据提示。' : undated ? '没有未定日期的安排' : '当天暂无安排' }}</p>
+        <p v-if="!selectedEvents.length && !loading" class="empty-day">{{ incomplete ? '已加载数据中没有安排。' : undated ? '没有未定日期的安排' : '当天暂无安排' }}</p>
        <article v-for="event in selectedEvents" :key="event.key" class="detail-event">
          <div class="event-heading"><span class="event-type" :class="event.type">{{ scheduleLabels[event.type] }}</span><span>{{ event.time || (event.date ? '日期计划' : '日期未定') }}</span></div>
          <h3>{{ event.title }}</h3><p v-if="event.subtitle" class="event-subtitle">{{ event.subtitle }}</p>
@@ -161,7 +161,7 @@ describe('simplified appointment entry', () => {
    expect(routing.push).toHaveBeenCalledWith({ path: '/overseas-warehouse/dispatches/DS%2F1', query: { appointmentReturn: '/appointment-calendar?date=2026-10-21&mode=week' } })
    wrapper.unmount()
  })
-  it('retains a complete dispatch with its container search fields while naming a different unresolved dispatch and its reason', async () => {
+  it('retains a complete dispatch with its container search fields without showing an unresolved dispatch notice', async () => {
    const good = dispatchEntry()
    const unknown = dispatchEntry({ dispatchNo: 'PC-TIMEZONE-MISSING', containerNumbers: ['OTHER7654321'], originTimezone: null, incompleteReasons: ['ORIGIN_TIMEZONE_UNKNOWN'] })
    vi.mocked(listTripCalendar).mockResolvedValueOnce({ records: [good, good, unknown], unresolvedRecords: [] })
@@ -173,11 +173,7 @@ describe('simplified appointment entry', () => {
    expect(dispatches[0]!.fields).toContainEqual({ label: '关联柜号', value: 'TSTU1234567、TSTU7654321' })
    expect(dispatches[0]!.fields).toContainEqual({ label: '计划出发（起运仓当地）', value: '2026-10-22 09:00' })
    expect(panel.props('incomplete')).toBe(true)
-    const notice = wrapper.get('.data-notice').text()
-    expect(notice).toContain('1 条排车未能定位到日历日期')
-    expect(notice).toContain('PC-TIMEZONE-MISSING：起运仓时区待核实')
-    expect(notice).toContain('无法确定当地日期')
-    expect(notice).not.toContain('PC-CALENDAR-001')
+    expect(wrapper.find('.data-notice').exists()).toBe(false)
    expect(dispatches.some(event => event.key === 'dispatch-PC-TIMEZONE-MISSING')).toBe(false)
    expect(listTripCalendar).toHaveBeenCalledTimes(1)
    wrapper.unmount()
@@ -16,7 +16,7 @@ import AppointmentCalendarPanel from './AppointmentCalendarPanel.vue'
 import { calendarRange, dateKey, type CalendarMode } from './calendar'
 import { getCalendarSources, getWarehouseArrivals, saveWarehouseArrival, type CalendarSources, type ScheduleRange, type WarehouseArrival, type WarehouseArrivalChange } from './scheduleApi'
 import { projectContainerSchedule, type ScheduleEvent } from './schedule'
-import { listTripCalendar, projectTripCalendar, tripIssues } from './tripCalendar'
+import { listTripCalendar, projectTripCalendar } from './tripCalendar'
 import { rejectedCommand, type LeaveGuard } from './useWorkDraft'
 import type { PlanningSourceLookup } from './planningApi'
 import type { WorkAction } from './workApi'
@@ -37,7 +37,8 @@ const selectedDate = ref(initialDate()), mode = ref<CalendarMode>(route.query.mo
 const range = ref<ScheduleRange>(calendarRange(selectedDate.value, mode.value))
 const sources = ref<CalendarSources | null>(null), warehouses = ref<WarehouseArrival[] | null>(null), trips = ref<ScheduleEvent[]>([])
 const errors = ref<Array<{ title: string; details: ApiErrorDetails }>>([]), notices = ref<string[]>([]), loading = ref(false), active = ref(true)
-const incomplete = computed(() => !!errors.value.length || !!notices.value.length)
+const hasUnresolvedTrips = ref(false)
+const incomplete = computed(() => !!errors.value.length || !!notices.value.length || hasUnresolvedTrips.value)
 const events = computed(() => [...projectContainerSchedule(sources.value || { containers: [], emptyReturns: [], emptyReturnsReadable: true },
  warehouses.value, range.value, access.can('platform:firstleg:terminal-drayage:list')), ...trips.value])
 let generation = 0, controller: AbortController | null = null
@@ -46,6 +47,7 @@ async function load(next = range.value) {
  const request = ++generation; controller?.abort(); controller = new AbortController()
  const signal = controller.signal
  loading.value = true; sources.value = null; warehouses.value = null; trips.value = []; errors.value = []; notices.value = []
+  hasUnresolvedTrips.value = false
  const fail = (title: string, cause: unknown) => { if (request === generation) errors.value.push({ title, details: getApiErrorDetails(cause, title) }) }
  await Promise.allSettled([
    (async () => {
@@ -71,10 +73,7 @@ async function load(next = range.value) {
        const result = projectTripCalendar(await listTripCalendar(next, signal), next)
        if (request !== generation) return
        trips.value = result.events
-        if (result.unresolved.length) {
-          const details = result.unresolved.slice(0, 3).map(row => `${row.dispatchNo?.trim() || '排车单号缺失'}：${tripIssues(row) || '资料待核实'}`).join('；')
-          notices.value.push(`${result.unresolved.length} 条排车未能定位到日历日期（${details}${result.unresolved.length > 3 ? '；其余请到排车列表核对' : ''}）。`)
-        }
+        hasUnresolvedTrips.value = result.unresolved.length > 0
      } catch (cause) { fail('排车读取失败', cause) }
    })(),
  ])
@@ -18,7 +18,7 @@ beforeEach(() => { vi.clearAllMocks(); access.write = true; vi.mocked(previewPla
 it('shows readable preview requirements without exposing missing-field machine codes', async () => {
  vi.mocked(previewPlanningBatch).mockResolvedValue({ ...preview, missingFields: ['READY_WINDOW_UNVERIFIED', 'CARGO_QUANTITY_REVIEW'] })
  const wrapper = render(); await flushPromises()
-  expect(wrapper.text()).toContain('货物备妥窗口待核实')
+  expect(wrapper.text()).not.toContain('货物备妥窗口待核实')
  expect(wrapper.text()).toContain('货量或重复关联需要核对。')
  expect(wrapper.text()).not.toContain('READY_WINDOW_UNVERIFIED')
  expect(wrapper.text()).not.toContain('CARGO_QUANTITY_REVIEW')
@@ -19,6 +19,7 @@ const form = reactive(createAppointmentForm()), baseline = ref(JSON.stringify(fo
 const loading = ref(false), saving = ref(false), error = ref<ApiErrorDetails | null>(null), saveError = ref<ApiErrorDetails | null>(null)
 const pending = ref<SourceAppointmentPayload | null>(null)
 const writable = computed(() => props.canWrite && access.can(overseasWarehousePermissions.inboundOrderAppointment))
+const visibleMissingFields = computed(() => preview.value?.missingFields.filter(field => field !== 'READY_WINDOW_UNVERIFIED') || [])
 useWorkDraft(computed(() => baseline.value !== JSON.stringify(form)), computed(() => saving.value || !!pending.value))
 async function load() {
  if (!props.sources.length || props.sources.some(source => !source.customerId || !source.sourceKey || !source.destinationKey)) { error.value = { message: '缺少完整货源、客户或目的仓范围，无法新建预约。' }; return }
@@ -60,8 +61,7 @@ onMounted(load)
          <tr><th scope="row">票数</th><td>{{ preview.group.sourceCount }}</td><th scope="row">箱数</th><td>{{ preview.group.packages ?? '箱数待核实' }}</td></tr>
          <tr><th scope="row">货物业务号</th><td colspan="3"><template v-for="(source, index) in preview.sources" :key="`${source.customerId}:${source.sourceKey}`">{{ index ? '、' : '' }}{{ source.inboundCode || source.bookingNo || '原票业务号未提供' }}</template></td></tr>
        </tbody></table>
-        <p v-for="field in preview.missingFields" :key="field" role="status" class="density-dialog-note">{{ workReason(field) }}</p>
-        <p v-if="preview.group.readinessIncomplete" role="status" class="density-dialog-note">货物备妥窗口待核实。</p>
+        <p v-for="field in visibleMissingFields" :key="field" role="status" class="density-dialog-note">{{ workReason(field) }}</p>
      </section>
      <FbaAppointmentFields continuous ref="appointmentFields" :sources="sources.map(source => ({ ...source, destinationKey: source.destinationKey || undefined }))" @confirmation-ready="confirmationReady = $event" :model="form" :timezone="preview.destinationTimezone" :disabled="!writable || loading || saving || !!pending" />
      <LoadErrorState v-if="saveError" title="预约尚未创建" :message="saveError.message" :show-retry="false"><template #details><ApiErrorMeta :details="saveError" /></template></LoadErrorState>
@@ -286,7 +286,8 @@ function optional(value: string | null) { return value?.trim() || null }
 function statusText(status: ContainerPlanStatus) { return ({ WAIT_LOADING: '待装柜', EDITING: '预装柜中', LOADING: '拣货中', COMPLETED: '装柜完成' })[status] }
 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 defaultArrivalDate(row: ContainerWorkbenchRow) {
+function defaultArrivalDate(source: object) {
+  const row = source as ContainerWorkbenchRow
  const arrival = arrivalTimes.value[row.id]
  const projected = projectWarehouseArrival(row.actualFacts?.arrivedDestinationPortAt || row.actualPortArrivalAt || row.estimatedPortArrivalAt,
    arrival ? { ...arrival, plannedAt: arrival.estimatedWarehouseArrivalAt } : undefined)
@@ -22,11 +22,12 @@
 | 退货预报审核、退货驳回 | `pages/LastMileOrdersView.vue`、`api/lastMileOrders.ts` 的 `reviewReturnOrder` | 尾程订单内 `RETURN_RELABEL + PENDING_REVIEW` 行进入审核，来源退货号取 `sourceOrderNo`；请求 `/platform/v1/last-leg/return-orders/{returnNo}/review` 携带 `X-Customer-Id`，结论 `APPROVE/REJECT`，驳回必填原因。按钮权限入口为 `permissions.ts` 的 `returnOrderReview`；服务端归 `returnreceipt/`，通过后才能签收，不是仓储转运审核或换标完工确认 |
 | 换标申请审核、待审核按钮与驳回原因 | `pages/RelabelOrdersView.vue`、`pages/RelabelOrderDetailView.vue`、`api/relabelOrders.ts` | 列表审核动作仅在 `PENDING_REVIEW` 显示，动作选择为审核通过/已驳回，驳回原因必填；审核后不再显示审核按钮。回归见 `pages/RelabelOrdersView.test.ts`、`pages/RelabelOrderDetailView.test.ts`；PDA 完工、客户确认与申请审核分别定位，不混用状态入口 |
 | 排车资源、草稿容器与实际容量 | `components/DispatchResourceFields.vue`、`components/SmartDispatchDialog.vue`、`dispatchContracts.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` 提交订单版本与幂等键；预计到仓时间只读展示来源柜冻结值，不进入人工计划请求，服务端按整柜校验并写入同一日期；入仓码只读展示并提交订单冻结值，不允许人工改写。新增暂扣只在 `INBOUND_COMPLETED` 开放，解除暂扣保持可用；暂扣不阻断入库计划，只限制后续排车和出库。人工节点一经保存不得回退柜级节点。转仓候选只取 `../iam/api/platformIam.ts` 的平台公共 `ACTIVE + FBA` 仓主档；Backend `lastleg-service/` |
+| 仓储转运审核、审核通过 | `pages/LastMileOrdersView.vue`、`components/WarehouseTransferReviewDialog.vue` | `permissions.ts` 的 `warehouseTransferApprove`；仅 `WAREHOUSE_TRANSFER + PENDING_REVIEW` 行开放。当前弹框仅提交 `APPROVE`，携带该行客户和转运单号；无驳回按钮 |
+| 转运驳回、REJECT 接口能力 | `api/warehouseTransfers.ts` 的 `reviewWarehouseTransfer` | API 支持 `APPROVE/REJECT` 与 `remark`；不据此推定当前弹框提供驳回操作，界面能力沿上一行组件核对 |
+| 尾程订单控制与柜级入仓计划转换 | `pages/LastMileOrdersView.vue`、`pages/LastMileOrderDetailView.vue` | `api/lastMileOrders.ts`；[入仓计划页面约束](../../../../../docs/业务实现边界.md#admin-入仓计划页面约束)，仅计划/状态/请求行为变化时查 |
 | 入仓单、入仓计划、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`、`components/SmartDispatchExistingCargo.vue`、`components/DispatchWorkflowDialog.vue` | `api/dispatches.ts`、`dispatchContracts.ts`、`dispatchCommandRecovery.ts`；Backend `lastleg-service/dispatch/`、`delivery/`。一单一趟、同仓多客户多目的地，空单或先选货均可；候选使用来源版本，草稿走服务器token及公共版本，全部容器原子转换。当前规则见`../../../../../docs/海外仓业务/排车列表统一作业改造契约.md`，不恢复旧单客户预排协议 |
-| 海外出库与派送 | `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/DispatchesView.vue`、`pages/DispatchDetailView.vue`、`components/SmartDispatchDialog.vue`、`components/SmartDispatchExistingCargo.vue`、`components/DispatchWorkflowDialog.vue` | `api/dispatches.ts`、`dispatchContracts.ts`、`dispatchCommandRecovery.ts`；Backend `lastleg-service/dispatch/`、`delivery/`。一单一趟、同仓多客户多目的地，空单或先选货均可；候选使用来源版本，草稿走服务器token及公共版本，全部容器原子转换。当前规则见`../../../../../docs/海外仓业务/排车列表统一作业改造契约.md`，不恢复旧单客户预排协议 |
+| 海外出库与派送 | `pages/OutboundsView.vue`、`pages/OutboundDetailView.vue`、`pages/DeliveryOrdersView.vue`、`pages/DeliveryOrderDetailView.vue` | `api/outbounds.ts`、`api/deliveryOrders.ts`；[出库与派送页面约束](../../../../../docs/业务实现边界.md#admin-出库与派送页面约束)，候选选择另查下表 |
 | 异常退回与客户回访 | `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/LocationsView.vue`、`api/locations.ts` | 按海外仓分页或多仓查询库位，支持库区/库位编码、类型和状态筛选；`NORMAL` 库位可编辑、停用或删除，`A0/SHARED_OVERFLOW`、`VIRTUAL` 由服务端事实保护，不能按普通库位修改。接口经 `/platform/v1/warehouse-admin/{warehouseId}/locations`，权限沿 `permissions.ts` 的库位维护/删除入口 |
@@ -34,24 +35,33 @@

 ## 履约硬边界

- 排车详情固定四个彩色图标页签：车辆信息、排车信息、单据信息、关联订单明细。四个作业阶段及审核分区、逐动作Gate由服务端返回；取消独立于阶段。装车完成须真实PDA拣货核平，装车完成自动生成派送单并直接进入派送中，无独立安排派送或发车确认；Admin和PDA共用正式版本化命令。已有单写入提交recordVersion（0合法）、原幂等键和完整载荷；未知结果保留原请求核对，成功后另读当前事实。
+- 排车详情固定四个彩色图标页签：车辆信息、排车信息、单据信息、关联订单明细。五个作业阶段及审核分区、逐动作Gate由服务端返回；取消独立于阶段。装车完成须真实PDA拣货核平，装车中可同步上传五张装车照片，确认装车完成且资料齐全自动生成派送单并进入派送中，资料未齐时留在装车后，无独立安排派送或发车确认；Admin和PDA共用正式版本化命令。已有单写入提交recordVersion（0合法）、原幂等键和完整载荷；未知结果保留原请求核对，成功后另读当前事实。
 - 智能排车来源支持 `RELABEL`（待出库换标单），按服务端候选的`selection.relabelNo/sourceVersion`提交，不用展示订单号或原入仓号替代换标身份；沿用真实库存、托盘与箱唛，不生成新入库单。客户和仓库归属由服务端核验，不在前端拼接客户子排车。

- 托盘管理单张打印：`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`。不在前端生成标签、改码或维护第二套模板。
+- 托盘标签从 `pages/PalletsView.vue` → `api/pallets.ts` 的 `getPalletLabelPdf` 下载服务端 PDF，传该行仓库与托盘 ID，复用列表权限；不在前端生成标签或维护模板、尺寸、编码。模板/接口变化才查 [Print 指引](../../../../../baiyue-firstleg/print/AGENTS.md)的托盘入口及[标签维护](../../../../../docs/打印标签维护/README.md)，纯按钮文案不追加打印资料。

- API 为 `api/dispatches.ts`、`api/outbounds.ts`、`api/deliveryOrders.ts`；Backend `lastleg-service/dispatch/`、`delivery/`、`dropship/`。一件代发独立出库，从服务端库存位置选择并携带幂等键；换标只有平台卡车进入排车，普通自提、亚马逊自提、客户自提及快递由客户确认直接创建出库任务。整车派送在装车完成事务内自动生成；每客户一张出库单，每客户每目的地一张派送单，公开完整数组，不能回退为单个outboundNo或按客户拆排车头。
+- API 为 `api/dispatches.ts`、`api/outbounds.ts`、`api/deliveryOrders.ts`；Backend `lastleg-service/dispatch/`、`delivery/`、`dropship/`。一件代发独立出库，从服务端库存位置选择并携带幂等键；换标只有平台卡车进入排车，普通自提、亚马逊自提、客户自提及快递由客户确认直接创建出库任务。出库/派送建单时机按[排车现行契约](../../../../../docs/海外仓业务/排车列表统一作业改造契约.md)执行；每客户一张出库单，每客户每目的地一张派送单，公开完整数组，不能回退为单个outboundNo或按客户拆排车头。
 - API 为 `api/exceptionOrders.ts`、`api/customerVisits.ts`；Backend `lastleg-service/exceptionorder/`、`customervisit/`。异常处理只消费服务端 `allowedActions/version`；完成时至少上传一份异常证据。派送退回先从服务端原出库拣货事实选择入仓单和可退箱数，不允许自由填写 SKU/数量；退回海外仓时必须选择服务端校验的目标托盘和库位，库存恢复、异常完成与派送 `RETURNED` 由服务端原子推进。回访附件和派送完成/状态均走海外真实 API

+## 作业细则按需入口
+
+仅接口、状态、权限或业务行为变化时读命中段；纯文案、样式沿当前代码，不逐条读取。
+
+| 任务 | 规则正文 |
+|---|---|
+| 排车审核附件 | [对应条款](../../../../../docs/业务实现边界.md#admin-排车审核附件) |
+| 一件代发出库候选 | [对应条款](../../../../../docs/业务实现边界.md#admin-一件代发出库候选) |
+| 货物计划与装车命令 | [对应条款](../../../../../docs/业务实现边界.md#admin-货物计划与装车命令) |
+| 取消与费用展示 | [对应条款](../../../../../docs/业务实现边界.md#admin-取消与费用展示) |
+| 业务导出 | [对应条款](../../../../../docs/业务实现边界.md#admin-业务导出) |
+| 装车照片与资料入口 | [对应条款](../../../../../docs/业务实现边界.md#admin-装车照片与资料入口) |
+
 ## 验证

 - 排车调度／理货审核分区仅显示审核、详情；车辆图片、司机照片和驾驶证照片在维护车辆司机时通过既有本车附件接口上传，随资源编辑命令保存，司机照片使用 `driver.evidence.photoFileIds`。三类照片横向并排、名称显示在照片下方；审核弹框只读预览，合并展示资源照片及历史审核附件。维护权限与服务端 Gate 控制上传及保存，审核权限控制审核提交，列表查看权限控制读取。

- 一件代发出库候选选择：`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 与审核入口权限、状态。
- 装车完成通过`completeDispatchLoading`一次提交，结果仅接受`DELIVERING`；原请求恢复不重建单据。未知费用保持未确认，由既有后台费用管理维护，不按金额推断覆盖或重复记费。已有排车加货和移货仅从`SmartDispatchDialog.vue`内的`SmartDispatchExistingCargo.vue`进入；移货必须使用`GET items`返回的真实dispatchItemId及逐项remove Gate；路线仅重排`GET route`返回的既有全部目的地，包含外接点，不能新增或猜测目的地。附件沿`DispatchEvidenceFiles.vue`的本车鉴权上传/读取，上传与主单引用保存分开。
- 出库取消提示先解除车次关联，取消后仍须在排车列表释放原排车占用；不提示库存已自动回滚。派送详情费用读取reviewStatus/sourceStatus/voidStatus，同一详情响应展示待财务确认、待财务处理、确认作废，不逐行查询，也不把取消成功视为费用作废。货柜费用面板直接消费同一费用来源接口，待确认时同样禁止调整和重复作废，沿用原页面/弹框承载。
- 排车列表车辆信息编辑、BOL PDF 和装车完成从 `pages/DispatchesView.vue` → `api/dispatches.ts` 进入；列表和详情不另设添加／移除货物入口。货物计划统一由 `components/SmartDispatchDialog.vue` 承载：新建使用候选、草稿及托盘锁，已有排车经 `components/SmartDispatchExistingCargo.vue` 读取实际明细并按版本增减；两类服务端命令不得混用。原加货／移货未知请求也在智能排车恢复。回归为对应组件测试、`pages/DispatchesView.test.ts`、`pages/DispatchDetailView.test.ts` 及 `pages/prototypeContract.test.ts`。
- 从应用根按目标页面选择相邻测试：`pnpm test src/modules/overseas-warehouse/<目标测试路径>`；API 或类型变化同时运行 `pnpm typecheck`。应用完整门禁继续遵循上层指引。
- 索引变更从后端根运行 `./scripts/agents-index-contract.ps1`。离线检查不代替真实 HTTP 和人工截图验收。
-
- 尾程订单、库存余额与进销存记录导出统一使用 `../downloads/` 的 `useExportTask` 创建 XLSX 任务；保留当前筛选和业务导出权限，并要求 `platform:download:list`。Lastleg 内部 Provider 契约为 `lastleg-exports-v1.yaml`，业务页面不再请求同步 CSV。
+- 纯文案/纯展示只核对差异；业务逻辑变化选择直接对应测试，不因文档引用某测试就自动执行。
+- 转运审核组件/请求逻辑变化：定向选择 `components/WarehouseTransferReviewDialog.test.ts`、`api/warehouseTransfers.test.ts`；入口、权限或状态变化再加 `pages/prototypeContract.test.ts`。
+- 出库候选/选择变化选 `pages/OutboundsView.selection.test.ts`；状态/取消变化选 `pages/OutboundsView.test.ts`、`pages/OutboundDetailView.test.ts`。排车选择受影响组件或详情页测试，入口变化再加原型合同。
+- 命令从应用根按 `pnpm test src/modules/overseas-warehouse/<目标测试路径>` 运行，并经工作区限流入口；类型关系、模板绑定或模块引用受影响时按应用根选择最小类型检查，不自动升级全量。
+- 指引/索引修改后从后端根运行一次 `./scripts/agents-index-contract.ps1`；不以离线结果代替真实 HTTP 或人工截图验收。
@@ -1,5 +1,17 @@
 # 海外仓原型核对矩阵

+## 2026-10-21 智能排车区域入口替代仓库搜索
+
+用户明确删除查询区海外仓选择，仅保留“全部／洛杉矶／纽约”。界面移除顶部仓库框，区域筛选直接提交服务端；候选 warehouseId 不传时跨仓数据库分页，首托确定草稿仓并继续同仓安排，已有排车／预约仍显式指定仓库。空单模式在排车设置中保留起运仓，避免无来源时猜测仓库。正式业务边界维护于《排车列表统一作业改造契约》的区域入口确认段。
+
+自动检查：前端7文件134项中旧区域断言调整后，相关3文件57项复验通过，其余77项结果复用；排车样式合同通过，应用类型检查通过。后端3个精确测试类10项通过，覆盖区域HTTP参数、服务校验、Mapper统计/分页范围及OpenAPI；未运行全量回归。未部署、未访问测试环境数据；需Admin与Lastleg同步发布，视觉与真实HTTP待验收。
+
+## 2026-10-21 智能排车全屏空间利用
+
+依据用户截图 `codex-clipboard-df3ac2ac-0fa1-4e30-98e6-e508074c0d66.png` 与 `codex-clipboard-4833c2b8-d6a3-4e34-bb5c-0099a3fc8fcf.png`：区域按钮并入待排订单标题行，移除中栏订单号 65% 宽度上限；全屏新建选货模式沿弹框可用空间分配三栏高度，待排表格取消原 390px/40vh 上限，分页位于下方，三栏各自按内容滚动。退出全屏、空单与已有排车沿用各自布局。计划时间及备注迁移至列表尚处于用户要求的梳理阶段，本轮未删除其填写区；现有列表“维护车辆信息”已支持三字段，计划发车审核前补齐。
+
+自动检查：受影响布局、选货及排车样式合同共 41 项通过，69 项无关样式用例未执行，未跑全量；先前样式合同整文件运行另发现 DispatchesView 的取货车辆弹框缺少密度类，两项失败与本轮改动无关，未扩散修改。差异检查通过；全屏实际高度及滚动待人工截图确认。
+
 ## 2026-10-21 智能排车查询与三栏统一对齐

 用户确认保留蓝白配色，按最初第二张原型恢复区块与控件位置；最新截图 `codex-clipboard-40f3fcdc-8093-4fd1-8b0e-bd1abb147b3e.png` 确认已有排车查询散落、三栏错位，上轮不构成视觉验收通过。
@@ -31,15 +43,15 @@

 本轮定向7文件178项：排车6文件108项全部通过；共享样式70项中68项通过，2项失败为预约消费者的`<FbaAppointmentFields continuous`属性顺序断言，未改动这些预约实现。`pnpm build`在预约模块`WorkCreateAppointmentForm.vue:63`被`SourceReference.destinationKey`的`null`与`PlanningSourceLookup`不兼容阻断；不据此宣称构建通过，也不扩大范围修复其他在途业务。本轮全量`pnpm test`完成：468文件中465通过、3失败；4324项中4305通过、19失败，另3个未处理错误。失败集中于预约属性顺序断言、预约组件Mock缺少`AppointmentConfirmationCargo`／`canLeave`及其卸载连带错误，未修改对应在途预约代码。排车组件输入在检查期间未变，差异空白检查通过。未部署，视觉仍待1920×1080、100%人工截图确认。

-## 2026-10-21 装车完成直接进入派送中
+## 2026-10-21 装车后资料与自动派送

-依据用户本轮明确确认“PDA装完货后车就开走”，覆盖早期截图中的装车后等待阶段；沿用原装车完成居中弹框及实载字段，不新增操作入口。
+依据用户最新提供的排车五阶段截图和“管理资料／装车资料”五张照片截图，替代同日此前装完即派送的确认。规则以排车正式契约为准。

-| 页面／操作 | 当前调整 | 验收 |
+| 页面／操作 | 截图承载与当前实现 | 验证 |
 |---|---|---|
-| 排车列表／阶段与动作 | 显示装车前、装车中、派送中、派送完成；移除人工安排派送、确认发车，路线在派送中可读 | 定向回归通过；1920×1080人工截图待确认 |
-| 排车详情／装车完成 | 继续使用原装车完成弹框；真实拣货与实载条件保留，单次成功直接进入派送中 | 交互、原请求恢复与阶段校验通过；人工截图待确认 |
-| 装车完成／异常恢复 | 仅接受最终DELIVERING结果；读详情失败只刷新，不重复创建单据 | 定向回归及类型检查通过 |
+| 排车列表／装车后页签 | 在装车中与派送中之间显示；计数与分页按服务端AFTER_LOADING查询，行内管理资料进入原居中弹框 | 定向自动检查；待1920×1080、100%人工截图确认 |
+| 管理资料／装车资料 | 原居中弹框内两列共五个装车照片框；装车后默认打开，Admin与PDA共享整车照片；第五张保存后自动进入派送中 | 上传恢复、权限和服务端事务定向检查；待人工截图及PDA真机确认 |
+| 装车完成／原请求恢复 | 装车结果为AFTER_LOADING；已确认结果重读失败不重复POST，当前派送状态另读 | 定向恢复检查 |

 ## 2026-10-21 智能排车恢复10月18日布局

@@ -418,3 +430,9 @@
 - 2026-10-21 取货详情：按用户截图在转运单号后展示对应取货地址、联系人和联系电话，缺失值显示“—”；沿现有取货明细接口读取，不跨行复用联系人。`TransportExecutionPanel.test.ts` 6 项通过，含两张转运单地址和联系人分别展示的回归；真实页面待人工截图确认。

 - 2026-10-21 取货装货留痕：列表及执行面板统一使用“上传装货照片”，沿居中弹框展示预报箱数并要求手填实际取货箱数（1—5000），未填数量或未上传照片不能确认；到仓仅展示已保存取货数量，不改写取货事实。数量与照片通过既有版本化命令同次确认，复用服务端操作人和时间历史。执行面板 7 项自动回归通过；真实页面待人工截图确认。
+
+## 排车管理资料统一入口（2026-10-21）
+
+| 页面 | 操作 | 原型／确认依据 | 承载与实现 | 验收 |
+|---|---|---|---|---|
+| 排车列表：装车中、装车后、派送中、配送完成 | 管理资料 | 用户管理资料截图及同车／派送单资料共用确认；签收完成即可，其他可补 | 1100px居中可全屏弹框，签收文件／油耗图片／装车资料三个页签；装车中及装车后默认打开装车资料，可同步上传，确认装车且资料齐全后自动派送；按关联派送单切换，共用原派送资料编辑器；油耗沿本车附加照片保存 | 自动回归单独报告；1920×1080、100%待人工截图确认 |
@@ -0,0 +1,27 @@
+import { http, unwrapApiResponse, type ApiEnvelope } from '@/shared/api/http'
+import type { DispatchStage } from '../dispatchContracts'
+
+export const loadingPhotoSlots = ['LOADING_SCENE', 'LOADING_LIST', 'PRE_DEPARTURE_CHECK', 'DRIVER_LICENSE', 'RECEIPT'] as const
+export type LoadingPhotoSlot = typeof loadingPhotoSlots[number]
+export interface LoadingPhoto { slot: LoadingPhotoSlot; fileId: string; fileName: string; contentType: string; savedAt: string | null }
+export interface LoadingDocuments { dispatchNo: string; recordVersion: string; dispatchRecordVersion: string; stage: DispatchStage; editable: boolean; complete: boolean; photos: LoadingPhoto[] }
+export interface BindLoadingPhoto { recordVersion: string; idempotencyKey: string; fileId: string }
+const path = (no: string) => `/platform/v1/last-leg/dispatches/${encodeURIComponent(no)}/loading-documents`
+export async function getLoadingDocuments(no: string) {
+  return unwrapApiResponse(await http.get<ApiEnvelope<LoadingDocuments>, ApiEnvelope<LoadingDocuments>>(path(no)))
+}
+export async function uploadLoadingPhoto(no: string, slot: LoadingPhotoSlot, file: File, key: string) {
+  const form = new FormData(); form.append('file', file); form.append('idempotencyKey', key)
+  return unwrapApiResponse(await http.post<ApiEnvelope<LoadingPhoto>, ApiEnvelope<LoadingPhoto>>(`${path(no)}/${slot}/uploads`, form))
+}
+export async function recoverLoadingPhoto(no: string, key: string) {
+  return unwrapApiResponse(await http.get<ApiEnvelope<LoadingPhoto>, ApiEnvelope<LoadingPhoto>>(`${path(no)}/uploads/${encodeURIComponent(key)}`))
+}
+export async function bindLoadingPhoto(no: string, slot: LoadingPhotoSlot, body: BindLoadingPhoto) {
+  return unwrapApiResponse(await http.put<ApiEnvelope<LoadingDocuments>, ApiEnvelope<LoadingDocuments>>(`${path(no)}/${slot}`, body))
+}
+export async function readLoadingPhoto(no: string, photo: LoadingPhoto) {
+  const blob = await http.get<Blob, Blob>(`${path(no)}/${photo.slot}/files/${encodeURIComponent(photo.fileId)}/content`, { responseType: 'blob' })
+  if (!(blob instanceof Blob) || !['image/jpeg', 'image/png'].includes(blob.type) || !blob.size) throw new Error('图片读取失败，请重新核对')
+  return blob
+}
@@ -0,0 +1,25 @@
+import { http, unwrapApiResponse, type ApiEnvelope } from '@/shared/api/http'
+
+export type FuelSlot = 'FUEL_START' | 'FUEL_END'
+export interface VehiclePhoto { slot: FuelSlot; fileId: string; fileName: string; contentType: string; savedAt: string | null }
+export interface VehicleDocuments { dispatchNo: string; recordVersion: string; editable: boolean; photos: VehiclePhoto[] }
+export interface BindVehiclePhoto { recordVersion: string; idempotencyKey: string; fileId: string }
+const path = (no: string) => `/platform/v1/last-leg/dispatches/${encodeURIComponent(no)}/vehicle-documents`
+export async function getVehicleDocuments(no: string) {
+  return unwrapApiResponse(await http.get<ApiEnvelope<VehicleDocuments>, ApiEnvelope<VehicleDocuments>>(path(no)))
+}
+export async function uploadVehiclePhoto(no: string, slot: FuelSlot, file: File, key: string) {
+  const form = new FormData(); form.append('file', file); form.append('idempotencyKey', key)
+  return unwrapApiResponse(await http.post<ApiEnvelope<VehiclePhoto>, ApiEnvelope<VehiclePhoto>>(`${path(no)}/${slot}/uploads`, form))
+}
+export async function recoverVehiclePhoto(no: string, key: string) {
+  return unwrapApiResponse(await http.get<ApiEnvelope<VehiclePhoto>, ApiEnvelope<VehiclePhoto>>(`${path(no)}/uploads/${encodeURIComponent(key)}`))
+}
+export async function bindVehiclePhoto(no: string, slot: FuelSlot, body: BindVehiclePhoto) {
+  return unwrapApiResponse(await http.put<ApiEnvelope<VehicleDocuments>, ApiEnvelope<VehicleDocuments>>(`${path(no)}/${slot}`, body))
+}
+export async function readVehiclePhoto(no: string, photo: VehiclePhoto) {
+  const blob = await http.get<Blob, Blob>(`${path(no)}/${photo.slot}/files/${encodeURIComponent(photo.fileId)}/content`, { responseType: 'blob' })
+  if (!(blob instanceof Blob) || !['image/jpeg', 'image/png'].includes(blob.type) || !blob.size) throw new Error('图片读取失败，请重新核对')
+  return blob
+}
@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import '@/styles/adminWorkbench.css'
 import '@/styles/adminDensity.css'
-import { computed, ref, watch } from 'vue'
+import { computed, onBeforeUnmount, ref, watch } from 'vue'
 import { ElMessage, ElMessageBox, type UploadFile } from 'element-plus'
 import AppDialog from '@/shared/components/AppDialog.vue'
 import LineClampText from '@/shared/components/LineClampText.vue'
@@ -12,7 +12,7 @@ import { useAccessPreviewStore } from '@/core/access/accessPreview'
 import { overseasWarehousePermissions as permission } from '../permissions'
 import { deliveryDocumentCategories, getDeliveryDocuments, saveDeliveryDocuments, uploadDeliveryDocument, downloadDeliveryDocument, type DeliveryDocuments, type DeliveryDocumentCategory, type DeliveryDocumentFile } from '../api/deliveryDocuments'

-const props = defineProps<{ deliveryNo: string; customerId: string }>()
+const props = defineProps<{ deliveryNo: string; customerId: string; embedded?: boolean; categories?: DeliveryDocumentCategory[] }>()
 const open = defineModel<boolean>({ default: false })
 const emit = defineEmits<{ saved: [] }>()
 const access = useAccessPreviewStore()
@@ -29,7 +29,11 @@ const conflict = ref(false)
 const canEdit = computed(() => access.can(permission.deliveryDocuments) && Boolean(snapshot.value?.allowedActions.includes('MANAGE_DOCUMENTS')))
 const busy = computed(() => saving.value || uploading.value)
 const uploadedCount = computed(() => draft.value.filter(item => item.files.length > 0).length)
+const visibleGroups = computed(() => draft.value.filter(item => !props.categories || props.categories.includes(item.category)))
+const dirty = computed(() => Boolean(snapshot.value) && (bolNo.value !== (snapshot.value?.bolNo || '') || draft.value.some(group => JSON.stringify(group.files.map(file => file.fileId)) !== JSON.stringify(snapshot.value?.categories.find(item => item.category === group.category)?.files.map(file => file.fileId) || []))))
+defineExpose({ busy, dirty, canEdit, loading, conflict, save })
 let sequence = 0
+onBeforeUnmount(() => { sequence++ })
 function isCurrent(current: number, deliveryNo: string, customerId: string) { return current === sequence && open.value && props.deliveryNo === deliveryNo && props.customerId === customerId }
 let attempt: { body: string; key: string } | null = null
 async function load() {
@@ -97,23 +101,27 @@ async function save() {
  saving.value = true; error.value = null
  const current = sequence; const { deliveryNo, customerId } = props
  try {
-    await saveDeliveryDocuments(deliveryNo, customerId, { ...body, idempotencyKey: attempt.key })
+    const result = await saveDeliveryDocuments(deliveryNo, customerId, { ...body, idempotencyKey: attempt.key })
    if (!isCurrent(current, deliveryNo, customerId)) return
    const hasReceipt = body.documents.some(item => item.category === 'RECEIPT' && item.fileIds.length > 0)
-    open.value = false; emit('saved'); ElMessage.success(hasReceipt ? '签收文件已保存，派送单已自动完成' : '派送资料已保存')
+    if (props.embedded) {
+      snapshot.value = result; bolNo.value = result.bolNo || ''; attempt = null
+      draft.value = deliveryDocumentCategories.map(item => ({ ...item, files: (result.categories.find(group => group.category === item.category)?.files || []).map(file => ({ ...file })) }))
+    } else open.value = false
+    emit('saved'); ElMessage.success(hasReceipt ? '签收文件已保存，派送单已自动完成' : '派送资料已保存')
  } catch (cause) { if (isCurrent(current, deliveryNo, customerId)) { error.value = getApiErrorDetails(cause, '派送资料保存失败'); conflict.value = error.value.code === 'A0409' } }
  finally { if (current === sequence) saving.value = false }
 }
 </script>

 <template>
-  <AppDialog class="admin-density-dialog admin-workbench is-dialog" v-model="open" :title="'派送单所需资料 · ' + (deliveryNo || '—')" width="min(1040px, calc(100vw - 40px))" fullscreenable confirm-text="保存资料" cancel-text="关闭" :loading="loading" :show-confirm="canEdit" :confirm-loading="busy || loading" :confirm-disabled="conflict || loading" @confirm="save">
+  <component :is="embedded ? 'div' : AppDialog" class="admin-density-dialog admin-workbench is-dialog" v-model="open" :title="embedded ? undefined : '派送单所需资料 · ' + (deliveryNo || '—')" width="min(1040px, calc(100vw - 40px))" fullscreenable confirm-text="保存资料" cancel-text="关闭" :loading="loading" :show-confirm="canEdit" :confirm-loading="busy || loading" :confirm-disabled="conflict || loading" @confirm="save">
    <div class="density-dialog-sections">
      <LoadErrorState v-if="error" compact title="派送资料操作失败" :message="error.message" :loading="busy || loading" :show-retry="!snapshot || conflict" @retry="reload"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
      <section class="density-dialog-section" data-tone="summary" aria-label="派送资料摘要"><h3 class="density-dialog-section__title">资料核对</h3><table class="density-table"><tbody><tr><th scope="row">派送单号</th><td>{{ deliveryNo || '—' }}</td><th scope="row">资料类别</th><td>{{ snapshot ? uploadedCount + '/3 已上传' : loading ? '正在读取…' : '资料未返回' }}</td></tr></tbody></table><p v-if="snapshot" class="density-dialog-note">{{ canEdit ? '上传、替换和删除将在保存资料后生效；关闭将放弃未保存修改。' : '当前账号仅可查看已保存资料。' }}</p></section>
      <template v-if="snapshot">
-        <section class="density-dialog-section" data-tone="work" aria-label="BOL资料登记"><h3 class="density-dialog-section__title">BOL资料</h3><el-form class="density-form" label-position="left" label-width="80px" :disabled="busy || conflict || loading"><table class="density-table density-table--editable"><tbody><tr><td><el-form-item label="BOL号"><el-input v-if="canEdit" v-model="bolNo" :disabled="busy || conflict || loading" /><span v-else>{{ bolNo || '—' }}</span></el-form-item></td></tr></tbody></table></el-form></section>
-        <section v-for="group in draft" :key="group.category" class="document-group density-dialog-section" data-tone="source" :data-category="group.category">
+        <section v-if="!categories || categories.includes('BOL')" class="density-dialog-section" data-tone="work" aria-label="BOL资料登记"><h3 class="density-dialog-section__title">BOL资料</h3><el-form class="density-form" label-position="left" label-width="80px" :disabled="busy || conflict || loading"><table class="density-table density-table--editable"><tbody><tr><td><el-form-item label="BOL号"><el-input v-if="canEdit" v-model="bolNo" :disabled="busy || conflict || loading" /><span v-else>{{ bolNo || '—' }}</span></el-form-item></td></tr></tbody></table></el-form></section>
+        <section v-for="group in visibleGroups" :key="group.category" class="document-group density-dialog-section" data-tone="source" :data-category="group.category">
          <header><h3 class="density-dialog-section__title">{{ group.label }}</h3><el-tag :type="group.files.length ? 'success' : 'info'">{{ group.files.length ? '已上传' : '待上传' }}</el-tag><span>{{ group.files.length }}/20</span><el-upload v-if="canEdit" :key="uploadKey" :auto-upload="false" :show-file-list="false" :disabled="busy || conflict || group.files.length >= 20" :on-change="(file: UploadFile) => upload(group.category, file)"><el-button class="density-action" data-tone="primary" :disabled="busy || conflict || group.files.length >= 20">上传</el-button></el-upload></header>
          <p v-if="!group.files.length" class="density-dialog-note">尚未上传文件</p>
          <table v-else class="density-table document-files"><thead><tr><th class="document-file-actions">操作</th><th>文件名称</th><th class="document-file-time">上传时间</th><th class="document-file-state">保存状态</th></tr></thead><tbody>
@@ -125,7 +133,7 @@ async function save() {
        </section>
      </template>
    </div>
-  </AppDialog>
+  </component>
 </template>

 <style scoped>
@@ -0,0 +1,70 @@
+import ElementPlus, { ElMessageBox } from 'element-plus'
+import { defineComponent, h } from 'vue'
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, expect, it, vi } from 'vitest'
+import DispatchDocumentsDialog from './DispatchDocumentsDialog.vue'
+import DeliveryDocumentsDialog from './DeliveryDocumentsDialog.vue'
+import { detail } from '../dispatchTestFixtures'
+import { getDispatch } from '../api/dispatches'
+import { deliveryDocumentCategories, getDeliveryDocuments, saveDeliveryDocuments, type DeliveryDocuments } from '../api/deliveryDocuments'
+const can = vi.hoisted(() => vi.fn(() => true))
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can }) }))
+vi.mock('../api/dispatches', () => ({ getDispatch: vi.fn() }))
+vi.mock('../api/deliveryDocuments', async original => ({ ...await original<typeof import('../api/deliveryDocuments')>(), getDeliveryDocuments: vi.fn(), saveDeliveryDocuments: vi.fn() }))
+const dialogStub = defineComponent({ props: ['modelValue', 'showConfirm'], emits: ['confirm'], setup(props, { slots, emit }) { return () => props.modelValue ? h('section', [slots.default?.(), props.showConfirm ? h('button', { class: 'save', onClick: () => emit('confirm') }, '保存资料') : null]) : null } })
+function documents(no = 'DL-1', customerId = '101'): DeliveryDocuments {
+  return { deliveryNo: no, customerId, version: 1, bolNo: 'BOL-ORIGINAL', uploadedCategoryCount: 1, totalCategoryCount: 3, allowedActions: ['MANAGE_DOCUMENTS'], replayed: false, categories: deliveryDocumentCategories.map(item => ({ category: item.category, status: item.category === 'RECEIPT' ? 'UPLOADED' : 'MISSING', fileCount: item.category === 'RECEIPT' ? 1 : 0, files: item.category === 'RECEIPT' ? [{ fileId: '99', fileName: 'existing-pod.pdf', contentType: 'application/pdf', sizeBytes: 10, uploadedAt: '2026-10-21T00:00:00' }] : [] })) }
+}
+function setup() { return mount(DispatchDocumentsDialog, { props: { modelValue: true, dispatchNo: 'PC/1' }, global: { plugins: [ElementPlus], stubs: { AppDialog: dialogStub, DispatchVehicleDocuments: true, DispatchLoadingDocuments: true, DispatchEvidenceFiles: true } } }) }
+beforeEach(() => {
+  vi.clearAllMocks(); can.mockReturnValue(true)
+  const value = detail(); value.stage = 'DELIVERING'
+  value.documents.deliveries = [
+    { deliveryNo: 'DL-1', customerId: '101', customerName: '客户甲', groupKey: 'A', outboundNo: 'OB-1', destination: { key: 'FBA:A', type: 'FBA', warehouseId: null, warehouseCode: 'A', warehouseName: null, address: null, postalCode: null, contactName: null, contactPhone: null }, status: 'DELIVERING', packageCount: 1, palletCount: 1 },
+    { deliveryNo: 'DL-2', customerId: '102', customerName: '客户乙', groupKey: 'B', outboundNo: 'OB-2', destination: { key: 'FBA:B', type: 'FBA', warehouseId: null, warehouseCode: 'B', warehouseName: null, address: null, postalCode: null, contactName: null, contactPhone: null }, status: 'DELIVERING', packageCount: 1, palletCount: 1 },
+  ]
+  vi.mocked(getDispatch).mockResolvedValue(value)
+  vi.mocked(getDeliveryDocuments).mockImplementation(async (no, customer) => documents(no, customer))
+  vi.mocked(saveDeliveryDocuments).mockResolvedValue({ ...documents(), version: 2 })
+})
+it.each(['LOADING', 'AFTER_LOADING'] as const)('opens loading documents in %s before delivery orders exist and without delivery-list permission', async stage => {
+  vi.mocked(getDispatch).mockResolvedValue(detail({ stage }))
+  can.mockImplementation((value?: string) => value !== 'platform:overseas-warehouse:delivery:list')
+  const wrapper = setup(); await flushPromises()
+  expect(wrapper.find('dispatch-loading-documents-stub').exists()).toBe(true)
+  expect(wrapper.findAll('[role="tab"]').find(tab => tab.text() === '装车资料')!.attributes('aria-selected')).toBe('true')
+  expect(getDeliveryDocuments).not.toHaveBeenCalled(); wrapper.unmount()
+})
+it('reads existing delivery files in one dialog and saves receipt without requiring loading or BOL files', async () => {
+  const wrapper = setup(); await flushPromises()
+  expect(getDeliveryDocuments).toHaveBeenCalledWith('DL-1', '101')
+  expect(wrapper.text()).toContain('existing-pod.pdf')
+  expect(wrapper.findAllComponents(DeliveryDocumentsDialog)).toHaveLength(1)
+  await wrapper.get('.save').trigger('click'); await flushPromises()
+  expect(saveDeliveryDocuments).toHaveBeenCalledWith('DL-1', '101', expect.objectContaining({ bolNo: 'BOL-ORIGINAL', documents: [{ category: 'LOADING_PHOTO', fileIds: [] }, { category: 'BOL', fileIds: [] }, { category: 'RECEIPT', fileIds: ['99'] }] }))
+  expect(wrapper.emitted('saved')).toHaveLength(1)
+  expect(wrapper.getComponent(DeliveryDocumentsDialog).props('modelValue')).toBe(true)
+  wrapper.unmount()
+})
+it('switches customer scope exactly and keeps unsaved delivery edits when switching tabs', async () => {
+  const wrapper = setup(); await flushPromises()
+  await wrapper.findAll('[role="tab"]').find(tab => tab.text() === '装车资料')!.trigger('click')
+  await wrapper.getComponent(DeliveryDocumentsDialog).find('input').setValue('BOL-CHANGED')
+  await wrapper.findAll('[role="tab"]').find(tab => tab.text() === '油耗图片')!.trigger('click')
+  expect(getDeliveryDocuments).toHaveBeenCalledTimes(1)
+  const confirmation = vi.spyOn(ElMessageBox, 'confirm').mockRejectedValue('cancel')
+  wrapper.getComponent({ name: 'ElSelect' }).vm.$emit('update:modelValue', 'DL-2'); await flushPromises()
+  expect(getDeliveryDocuments).toHaveBeenCalledTimes(1)
+  confirmation.mockResolvedValue('confirm' as Awaited<ReturnType<typeof ElMessageBox.confirm>>)
+  wrapper.getComponent({ name: 'ElSelect' }).vm.$emit('update:modelValue', 'DL-2'); await flushPromises()
+  expect(getDeliveryDocuments).toHaveBeenLastCalledWith('DL-2', '102')
+  expect(saveDeliveryDocuments).not.toHaveBeenCalled()
+  confirmation.mockRestore(); wrapper.unmount()
+})
+it('does not request delivery documents without delivery list permission', async () => {
+  can.mockImplementation((value?: string) => value !== 'platform:overseas-warehouse:delivery:list')
+  const wrapper = setup(); await flushPromises()
+  expect(getDeliveryDocuments).not.toHaveBeenCalled()
+  expect(wrapper.text()).toContain('当前账号无派送资料查看权限')
+  wrapper.unmount()
+})
@@ -0,0 +1,78 @@
+<script setup lang="ts">
+import '@/styles/adminDensity.css'
+import { computed, onBeforeUnmount, ref, watch } from 'vue'
+import { ElMessageBox } from 'element-plus'
+import AppDialog from '@/shared/components/AppDialog.vue'
+import LoadErrorState from '@/shared/components/LoadErrorState.vue'
+import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
+import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
+import { useAccessPreviewStore } from '@/core/access/accessPreview'
+import { overseasWarehousePermissions as permission } from '../permissions'
+import { getDispatch } from '../api/dispatches'
+import type { DispatchDetail } from '../dispatchContracts'
+import { dispatchReviewAttachmentFields, dispatchReviewEvidence } from '../dispatchPresentation'
+import DeliveryDocumentsDialog from './DeliveryDocumentsDialog.vue'
+import DispatchVehicleDocuments from './DispatchVehicleDocuments.vue'
+import DispatchLoadingDocuments from './DispatchLoadingDocuments.vue'
+import DispatchEvidenceFiles from './DispatchEvidenceFiles.vue'
+
+const open = defineModel<boolean>({ default: false })
+const props = defineProps<{ dispatchNo: string }>()
+const emit = defineEmits<{ saved: [] }>()
+const access = useAccessPreviewStore()
+const detail = ref<DispatchDetail | null>(null), loading = ref(false), error = ref<ApiErrorDetails | null>(null)
+const tab = ref('RECEIPT'), selected = ref(''), fuelVisited = ref(false)
+const editor = ref<InstanceType<typeof DeliveryDocumentsDialog>>(), vehicleEditor = ref<InstanceType<typeof DispatchVehicleDocuments>>()
+const loadingEditor = ref<InstanceType<typeof DispatchLoadingDocuments>>()
+const deliveries = computed(() => detail.value?.documents.deliveries || [])
+const beforeDeparture = computed(() => ['LOADING', 'AFTER_LOADING'].includes(detail.value?.stage || ''))
+const delivery = computed(() => deliveries.value.find(item => item.deliveryNo === selected.value))
+const reviewEvidence = computed(() => dispatchReviewEvidence(detail.value))
+const busy = computed(() => Boolean(editor.value?.busy || vehicleEditor.value?.busy || loadingEditor.value?.busy))
+let sequence = 0
+onBeforeUnmount(() => { sequence++ })
+async function load() {
+  const current = ++sequence; loading.value = true; error.value = null
+  try {
+    const value = await getDispatch(props.dispatchNo)
+    if (current !== sequence || !open.value) return
+    if (value.dispatchNo !== props.dispatchNo) throw new Error('资料与当前排车单不一致')
+    if (value.status !== 'ACTIVE' || !['LOADING', 'AFTER_LOADING', 'DELIVERING', 'DELIVERED'].includes(value.stage)) throw new Error('进入装车中后可管理资料')
+    if (!detail.value && ['LOADING', 'AFTER_LOADING'].includes(value.stage)) tab.value = 'LOADING'
+    detail.value = value
+    if (!value.documents.deliveries.some(item => item.deliveryNo === selected.value)) selected.value = value.documents.deliveries[0]?.deliveryNo || ''
+  } catch (cause) { if (current === sequence) error.value = getApiErrorDetails(cause, '排车资料读取失败') }
+  finally { if (current === sequence) loading.value = false }
+}
+async function canLeave() {
+  if (busy.value) return false
+  if (!editor.value?.dirty) return true
+  try { await ElMessageBox.confirm('有尚未保存的派送资料，是否放弃修改？', '未保存资料', { customClass: 'admin-density-confirm admin-workbench is-dialog', confirmButtonText: '放弃修改', cancelButtonText: '继续编辑' }); return true } catch { return false }
+}
+async function selectDelivery(value: string) { if (value !== selected.value && await canLeave()) selected.value = value }
+async function beforeClose(done: () => void) { if (await canLeave()) done() }
+function selectTab(value: string) { if (!busy.value) { tab.value = value; if (value === 'FUEL') fuelVisited.value = true } }
+function saved() { emit('saved') }
+async function loadingSaved() { emit('saved'); await load() }
+watch(() => [open.value, props.dispatchNo] as const, ([visible]) => {
+  sequence++; detail.value = null; selected.value = ''; tab.value = 'RECEIPT'; fuelVisited.value = false; error.value = null
+  if (visible && props.dispatchNo) void load()
+}, { immediate: true })
+</script>
+<template>
+  <AppDialog v-model="open" class="admin-density-dialog admin-workbench is-dialog" :title="'管理资料 · ' + (dispatchNo || '—')" width="min(1100px, calc(100vw - 40px))" fullscreenable :loading="loading" :confirm-loading="busy" :before-close="beforeClose" :show-confirm="tab !== 'FUEL' && Boolean(editor?.canEdit)" :confirm-disabled="loading || editor?.loading || editor?.conflict" confirm-text="保存资料" cancel-text="关闭" @confirm="editor?.save()">
+    <LoadErrorState v-if="error" compact title="排车资料读取失败" :message="error.message" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
+    <template v-if="detail">
+      <div class="density-status-tabs" role="tablist" aria-label="排车资料类别"><button v-for="item in [{ key: 'RECEIPT', label: '签收文件' }, { key: 'FUEL', label: '油耗图片' }, { key: 'LOADING', label: '装车资料' }]" :key="item.key" role="tab" :aria-selected="tab === item.key" :disabled="busy" :class="{ 'is-active': tab === item.key }" @click="selectTab(item.key)">{{ item.label }}</button></div>
+      <DispatchLoadingDocuments v-if="tab === 'LOADING'" ref="loadingEditor" :key="dispatchNo" :dispatch-no="dispatchNo" @saved="loadingSaved" />
+      <div v-show="tab !== 'FUEL'" v-if="!beforeDeparture">
+        <el-form class="density-form" label-position="left" label-width="80px"><el-form-item label="派送单"><el-select :model-value="selected" :disabled="busy || !access.can(permission.deliveryList)" aria-label="选择派送单" @update:model-value="selectDelivery"><el-option v-for="item in deliveries" :key="item.deliveryNo" :value="item.deliveryNo" :label="item.deliveryNo" /></el-select></el-form-item></el-form>
+        <DeliveryDocumentsDialog v-if="delivery && access.can(permission.deliveryList)" ref="editor" :key="delivery.customerId + ':' + delivery.deliveryNo" :model-value="open" embedded :delivery-no="delivery.deliveryNo" :customer-id="delivery.customerId" :categories="tab === 'RECEIPT' ? ['RECEIPT'] : ['BOL']" @saved="saved" />
+        <p v-else>{{ access.can(permission.deliveryList) ? '暂无关联派送单' : '当前账号无派送资料查看权限' }}</p>
+      </div>
+      <p v-if="beforeDeparture && tab !== 'LOADING'">完成装车并补齐装车资料后，进入派送中管理{{ tab === 'FUEL' ? '油耗图片' : '签收文件' }}。</p>
+      <DispatchVehicleDocuments v-if="fuelVisited && !beforeDeparture" v-show="tab === 'FUEL'" ref="vehicleEditor" :key="dispatchNo" :dispatch-no="dispatchNo" @saved="saved" />
+      <section v-if="tab === 'LOADING'" class="density-dialog-section"><h3 class="density-dialog-section__title">车辆及司机附件</h3><DispatchEvidenceFiles v-for="field in dispatchReviewAttachmentFields" :key="field.key" :model-value="reviewEvidence[field.key]" :dispatch-no="dispatchNo" :kind="field.kind" :label="field.label" readonly /></section>
+    </template>
+  </AppDialog>
+</template>
@@ -34,6 +34,38 @@ it('does not render a late thumbnail from the previous dispatch or an invalid im
  expect(URL.createObjectURL).not.toHaveBeenCalled(); expect(wrapper.find('img').exists()).toBe(false)
  wrapper.unmount()
 })
+it('uses the dialog body for the image and keeps loading until the browser decodes it', async () => {
+  const wrapper = mount(DispatchEvidenceFiles, options); await flushPromises()
+  await button(wrapper, '预览').trigger('click'); await flushPromises()
+  const dialog = wrapper.get('[role="dialog"]')
+  expect(dialog.find('table').exists()).toBe(false)
+  expect(dialog.get('.evidence-preview').attributes('aria-busy')).toBe('true')
+  const image = dialog.get('img')
+  Object.defineProperties(image.element, { naturalWidth: { value: 1200 }, naturalHeight: { value: 800 } })
+  await image.trigger('load')
+  expect(dialog.get('.evidence-preview').attributes('aria-busy')).toBe('false')
+  expect(image.attributes('src')).toBe('blob:authenticated')
+  expect(dialog.text()).not.toContain('图片无法预览')
+  wrapper.unmount()
+})
+it.each(['single-pixel', 'decode-error'])('explains %s images inside the preview and retries the owned content', async failure => {
+  const wrapper = mount(DispatchEvidenceFiles, options); await flushPromises()
+  await button(wrapper, '预览').trigger('click'); await flushPromises()
+  const image = wrapper.get('[role="dialog"] img')
+  if (failure === 'single-pixel') {
+    Object.defineProperties(image.element, { naturalWidth: { value: 1 }, naturalHeight: { value: 1 } })
+    await image.trigger('load')
+  } else await image.trigger('error')
+  expect(wrapper.get('[role="dialog"]').text()).toContain(failure === 'single-pixel' ? '1 × 1 像素' : '图片无法解码或加载')
+  expect(wrapper.get('.evidence-preview').attributes('aria-busy')).toBe('false')
+  expect(wrapper.find('[role="dialog"] img').exists()).toBe(false)
+  await button(wrapper, '重新预览').trigger('click'); await flushPromises()
+  expect(api.getDispatchEvidenceContent).toHaveBeenCalledTimes(2)
+  expect(URL.revokeObjectURL).toHaveBeenCalledWith('blob:authenticated')
+  expect(wrapper.get('[role="dialog"] img').attributes('src')).toBe('blob:authenticated')
+  expect(wrapper.emitted('update:modelValue')).toBeUndefined()
+  wrapper.unmount()
+})
 it('keeps previously provided references read-only and only submits newly uploaded audit files', async () => {
  const wrapper = mount(DispatchEvidenceFiles, { ...options, props: { ...options.props, modelValue: [], referenceIds: ['301'], kind: 'DRIVER_PHOTO', label: '司机照片' } }); await flushPromises()
  expect(wrapper.findAll('tbody button').map(item => item.text())).toEqual(['预览'])
@@ -17,6 +17,8 @@ const emit = defineEmits<{ busy: [value: boolean] }>()
 const metadata = ref<Record<string, DispatchEvidenceFile>>({}), error = ref<ApiErrorDetails | null>(null), uploading = ref(false), input = ref<HTMLInputElement | null>(null)
 const imageOpen = ref(false), imageUrl = ref(''), imageName = ref(''), previewLoading = ref(false)
 const thumbnails = ref<Record<string, string>>({})
+const previewId = ref(''), imageDecoding = ref(false), imageFailure = ref('')
+const previewBusy = computed(() => previewLoading.value || imageDecoding.value)
 const label = computed(() => props.label || (props.kind === 'VEHICLE' ? '本趟车辆证据' : props.kind === 'DRIVER_PHOTO' ? '司机照片' : '本趟司机证照'))
 const types = ['application/pdf', 'image/jpeg', 'image/png'], maximum = 10 * 1024 * 1024, urls = new Set<string>()
 const uploadTypes = computed(() => ['DRIVER_PHOTO', 'EXCEPTION'].includes(props.kind) ? types.slice(1) : types)
@@ -27,7 +29,18 @@ function valid(value: DispatchEvidenceFile, expected?: string) {
  return { ...value, fileId: String(value.fileId) }
 }
 function fail(cause: unknown, fallback: string) { error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : fallback) }
-function closePreview() { previewGeneration++; pendingPopup?.close(); pendingPopup = null; imageOpen.value = false; previewLoading.value = false; if (imageUrl.value) { URL.revokeObjectURL(imageUrl.value); urls.delete(imageUrl.value); imageUrl.value = '' } }
+function closePreview() { previewGeneration++; pendingPopup?.close(); pendingPopup = null; imageOpen.value = false; previewLoading.value = false; imageDecoding.value = false; imageFailure.value = ''; if (imageUrl.value) { URL.revokeObjectURL(imageUrl.value); urls.delete(imageUrl.value); imageUrl.value = '' } }
+function imageLoaded(event: Event) {
+  const image = event.target as HTMLImageElement
+  if (!imageOpen.value || image.getAttribute('src') !== imageUrl.value) return
+  imageDecoding.value = false
+  if (image.naturalWidth <= 1 && image.naturalHeight <= 1) imageFailure.value = '原图片仅为 1 × 1 像素，无法查看有效内容，请核对上传的原附件。'
+}
+function imageFailed(event: Event) {
+  if (!imageOpen.value || (event.target as HTMLImageElement).getAttribute('src') !== imageUrl.value) return
+  imageDecoding.value = false
+  imageFailure.value = '图片无法解码或加载，请重新预览；若仍失败，请核对原附件是否损坏。'
+}
 async function load() {
  const current = ++generation, no = props.dispatchNo, kind = props.kind, values = [...allIds.value]
  for (const url of Object.values(thumbnails.value)) { URL.revokeObjectURL(url); urls.delete(url) }
@@ -78,6 +91,7 @@ async function readContent(no: string, kind: DispatchEvidenceKind, id: string, f
 async function preview(id: string) {
  const file = metadata.value[id]; if (!file || previewLoading.value) return
  closePreview(); const current = ++previewGeneration, scope = generation
+  previewId.value = id
  error.value = null; previewLoading.value = true
  if (file.contentType === 'application/pdf') { pendingPopup = window.open('', '_blank'); if (!pendingPopup) { previewLoading.value = false; fail(new DispatchInputError('请允许本站打开PDF预览窗口'), 'PDF预览未打开'); return } }
  else { imageName.value = file.fileName; imageOpen.value = true }
@@ -86,7 +100,7 @@ async function preview(id: string) {
    if (current !== previewGeneration || scope !== generation) return
    const url = URL.createObjectURL(blob); urls.add(url)
    if (file.contentType === 'application/pdf') { pendingPopup!.location.href = url; pendingPopup = null; window.setTimeout(() => { URL.revokeObjectURL(url); urls.delete(url) }, 60_000) }
-    else imageUrl.value = url
+    else { imageDecoding.value = true; imageUrl.value = url }
  } catch (cause) { if (current === previewGeneration) { closePreview(); fail(cause, '本车附件预览失败，原引用已保留') } }
  finally { if (current === previewGeneration) previewLoading.value = false }
 }
@@ -111,8 +125,11 @@ onBeforeUnmount(() => { generation++; closePreview(); for (const url of urls) UR
      <p v-else class="density-dialog-note">暂无本趟附件。</p>
    </template>
    <template v-if="!readonly"><input ref="input" class="evidence-input" type="file" :accept="uploadTypes.join(',')" :aria-label="'上传' + label" :disabled="disabled || uploading || !dispatchNo" @change="upload"><el-button :disabled="disabled || uploading || !dispatchNo" :loading="uploading" @click="choose()">上传{{ label }}</el-button></template>
-    <AppDialog append-to-body class="admin-density-dialog admin-workbench is-dialog" :model-value="imageOpen" :title="imageName || '附件预览'" width="min(900px, calc(100vw - 28px))" fullscreenable :loading="previewLoading" :show-confirm="false" cancel-text="关闭" @update:model-value="closePreview">
-      <div class="density-dialog-sections"><section class="density-dialog-section" data-tone="source" aria-label="本车附件预览信息"><h3 class="density-dialog-section__title">附件信息</h3><table class="density-table"><tbody><tr><th scope="row">排车单号</th><td>{{ dispatchNo || '—' }}</td></tr><tr><th scope="row">附件名称</th><td>{{ imageName || '—' }}</td></tr></tbody></table></section><p v-if="previewLoading" class="density-dialog-note" role="status">正在读取本车附件…</p><img v-if="imageUrl" class="evidence-image" :src="imageUrl" :alt="imageName"></div>
+    <AppDialog append-to-body class="admin-density-dialog admin-workbench is-dialog" :model-value="imageOpen" :title="imageName || '附件预览'" width="min(900px, calc(100vw - 28px))" fullscreenable :loading="previewBusy" :show-confirm="false" cancel-text="关闭" @update:model-value="closePreview">
+      <div class="evidence-preview" :aria-busy="previewBusy">
+        <LoadErrorState v-if="imageFailure" title="图片无法预览" :message="imageFailure" compact retry-text="重新预览" @retry="preview(previewId)" />
+        <img v-else-if="imageUrl" class="evidence-image" :src="imageUrl" :alt="imageName" @load="imageLoaded" @error="imageFailed">
+      </div>
    </AppDialog>
  </section>
 </template>
@@ -122,11 +139,12 @@ onBeforeUnmount(() => { generation++; closePreview(); for (const url of urls) UR
 .dispatch-evidence--readonly .dispatch-evidence__actions { width: 76px; }
 .dispatch-evidence > .el-button { margin-top: var(--admin-space-3); }
 .evidence-input { display: none; }
-.evidence-image { display: block; max-width: 100%; max-height: 72vh; margin: auto; object-fit: contain; }
 .evidence-photo-card { margin: 0; text-align: center; }
 .evidence-photo-list { display: grid; gap: var(--admin-space-3); }
 .evidence-photo-preview, .evidence-photo-empty { box-sizing: border-box; width: 100%; height: 150px; display: flex; align-items: center; justify-content: center; border: 1px solid var(--el-border-color-lighter); border-radius: var(--el-border-radius-base); color: var(--el-text-color-secondary); }
 .evidence-photo-preview { padding: 0; cursor: pointer; }
 .evidence-photo-preview img { width: 100%; height: 100%; object-fit: contain; }
 .evidence-photo-card figcaption { margin-top: var(--admin-space-3); font-weight: 600; }
+.evidence-preview { display: grid; place-items: center; height: min(60vh, 600px); min-width: 0; }
+.evidence-image { display: block; width: 100%; height: 100%; min-height: 0; object-fit: contain; }
 </style>
@@ -0,0 +1,73 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import ElementPlus from 'element-plus'
+import { beforeEach, expect, it, vi } from 'vitest'
+import { ApiResponseError } from '@/shared/api/http'
+import DispatchLoadingDocuments from './DispatchLoadingDocuments.vue'
+import * as api from '../api/dispatchLoadingDocuments'
+
+const can = vi.hoisted(() => vi.fn(() => true))
+vi.mock('@/core/auth/auth', () => ({ useAuthStore: () => ({ user: { id: 'operator' } }) }))
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can }) }))
+vi.mock('../api/dispatchLoadingDocuments', async importOriginal => ({ ...await importOriginal<typeof api>(), getLoadingDocuments: vi.fn(), uploadLoadingPhoto: vi.fn(), recoverLoadingPhoto: vi.fn(), bindLoadingPhoto: vi.fn(), readLoadingPhoto: vi.fn() }))
+const photo: api.LoadingPhoto = { slot: 'LOADING_SCENE', fileId: '101', fileName: 'loading.png', contentType: 'image/png', savedAt: null }
+const data = (extra: Partial<api.LoadingDocuments> = {}): api.LoadingDocuments => ({ dispatchNo: 'PC/1', recordVersion: '0', dispatchRecordVersion: '3', stage: 'AFTER_LOADING', editable: true, complete: false, photos: [], ...extra })
+function setup() { return mount(DispatchLoadingDocuments, { props: { dispatchNo: 'PC/1' }, global: { plugins: [ElementPlus] } }) }
+async function upload(wrapper: ReturnType<typeof setup>) {
+  const input = wrapper.get('input[aria-label="装车照片 1"]')
+  Object.defineProperty(input.element, 'files', { configurable: true, value: [new File(['image'], 'loading.png', { type: 'image/png' })] })
+  await input.trigger('change'); await flushPromises()
+}
+beforeEach(() => {
+  vi.clearAllMocks(); sessionStorage.clear(); can.mockReturnValue(true)
+  vi.mocked(api.getLoadingDocuments).mockResolvedValue(data())
+  vi.mocked(api.uploadLoadingPhoto).mockResolvedValue(photo)
+  vi.mocked(api.bindLoadingPhoto).mockResolvedValue(data({ recordVersion: '1', photos: [photo] }))
+  vi.mocked(api.readLoadingPhoto).mockRejectedValue(new Error('preview unavailable'))
+})
+it('offers five whole-dispatch slots and only reports saved after binding succeeds', async () => {
+  const wrapper = setup(); await flushPromises()
+  expect(wrapper.findAll('input[type="file"]')).toHaveLength(5)
+  await upload(wrapper)
+  expect(api.uploadLoadingPhoto).toHaveBeenCalledWith('PC/1', 'LOADING_SCENE', expect.any(File), expect.any(String))
+  expect(api.bindLoadingPhoto).toHaveBeenCalledWith('PC/1', 'LOADING_SCENE', expect.objectContaining({ recordVersion: '0', fileId: '101' }))
+  expect(wrapper.emitted('saved')).toHaveLength(1)
+  expect(wrapper.text()).toContain('图片读取失败')
+  wrapper.unmount()
+})
+it('keeps the original binding and file after an unknown result and never uploads again', async () => {
+  vi.mocked(api.bindLoadingPhoto).mockRejectedValueOnce(new Error('network unknown'))
+  const wrapper = setup(); await flushPromises(); await upload(wrapper)
+  expect(wrapper.emitted('saved')).toBeUndefined()
+  const original = vi.mocked(api.bindLoadingPhoto).mock.calls[0]![2]
+  await wrapper.findAll('button').find(item => item.text() === '核对原请求并继续保存')!.trigger('click'); await flushPromises()
+  expect(api.bindLoadingPhoto).toHaveBeenLastCalledWith('PC/1', 'LOADING_SCENE', original)
+  expect(api.uploadLoadingPhoto).toHaveBeenCalledTimes(1)
+  expect(wrapper.emitted('saved')).toHaveLength(1); wrapper.unmount()
+})
+it('refreshes a definitive version conflict while retaining the uploaded file', async () => {
+  vi.mocked(api.bindLoadingPhoto).mockRejectedValueOnce(new ApiResponseError('version conflict', 'A0409'))
+  const wrapper = setup(); await flushPromises(); await upload(wrapper)
+  const original = vi.mocked(api.bindLoadingPhoto).mock.calls[0]![2]
+  vi.mocked(api.getLoadingDocuments).mockResolvedValue(data({ recordVersion: '4' }))
+  vi.mocked(api.bindLoadingPhoto).mockResolvedValue(data({ stage: 'DELIVERING', complete: true, recordVersion: '5' }))
+  await wrapper.findAll('button').find(item => item.text() === '刷新并重试保存')!.trigger('click'); await flushPromises()
+  expect(api.bindLoadingPhoto).toHaveBeenLastCalledWith('PC/1', 'LOADING_SCENE', expect.objectContaining({ recordVersion: '4', fileId: '101' }))
+  expect(vi.mocked(api.bindLoadingPhoto).mock.calls[1]![2].idempotencyKey).not.toBe(original.idempotencyKey)
+  expect(api.uploadLoadingPhoto).toHaveBeenCalledTimes(1); expect(wrapper.emitted('saved')).toHaveLength(1); wrapper.unmount()
+})
+it('shows existing photos without exposing upload for a read-only account', async () => {
+  can.mockReturnValue(false)
+  const wrapper = setup(); await flushPromises()
+  expect(wrapper.find('input[type="file"]').exists()).toBe(false)
+  expect(api.uploadLoadingPhoto).not.toHaveBeenCalled(); wrapper.unmount()
+})
+
+it('allows saving photos while loading and keeps the loading stage', async () => {
+  vi.mocked(api.getLoadingDocuments).mockResolvedValue(data({ stage: 'LOADING' }))
+  vi.mocked(api.bindLoadingPhoto).mockResolvedValue(data({ stage: 'LOADING', recordVersion: '1', photos: [photo] }))
+  const wrapper = setup(); await flushPromises()
+  expect(wrapper.text()).toContain('可边装车边上传')
+  await upload(wrapper)
+  expect(wrapper.emitted('saved')).toHaveLength(1)
+  expect(wrapper.text()).toContain('可边装车边上传'); wrapper.unmount()
+})
@@ -0,0 +1,109 @@
+<script setup lang="ts">
+import { computed, onBeforeUnmount, onMounted, ref } from 'vue'
+import { ElMessage } from 'element-plus'
+import { useAuthStore } from '@/core/auth/auth'
+import { useAccessPreviewStore } from '@/core/access/accessPreview'
+import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
+import LoadErrorState from '@/shared/components/LoadErrorState.vue'
+import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
+import { overseasWarehousePermissions as permission } from '../permissions'
+import { bindLoadingPhoto, getLoadingDocuments, loadingPhotoSlots, readLoadingPhoto, recoverLoadingPhoto, uploadLoadingPhoto, type BindLoadingPhoto, type LoadingDocuments, type LoadingPhoto, type LoadingPhotoSlot } from '../api/dispatchLoadingDocuments'
+
+const props = defineProps<{ dispatchNo: string }>()
+const emit = defineEmits<{ saved: [] }>()
+const auth = useAuthStore(), access = useAccessPreviewStore()
+const snapshot = ref<LoadingDocuments | null>(null), busy = ref(false), error = ref<ApiErrorDetails | null>(null)
+interface Pending { slot: LoadingPhotoSlot; key: string; photo?: LoadingPhoto; binding?: BindLoadingPhoto; conflict?: boolean }
+const pending = ref<Pending | null>(null), corrupted = ref(false), images = ref<Record<string, string>>({})
+const actor = auth.user?.id || '', number = props.dispatchNo, storageKey = `dispatch-loading-documents:${actor}:${number}`
+const editable = computed(() => !corrupted.value && access.can(permission.dispatchEdit) && snapshot.value?.editable === true)
+let active = true
+function ensureScope() { if (!active || auth.user?.id !== actor || props.dispatchNo !== number) throw new Error('资料操作身份已变化，请重新打开') }
+function persist() { if (pending.value) sessionStorage.setItem(storageKey, JSON.stringify(pending.value)); else sessionStorage.removeItem(storageKey) }
+function accept(value: LoadingDocuments) { ensureScope(); if (value.dispatchNo !== number) throw new Error('装车资料与排车单不一致'); snapshot.value = value }
+async function previews() {
+  const photos = snapshot.value?.photos || []
+  await Promise.allSettled(photos.map(async photo => {
+    if (images.value[photo.fileId]) return
+    const blob = await readLoadingPhoto(number, photo); ensureScope(); images.value[photo.fileId] = URL.createObjectURL(blob)
+  }))
+}
+async function load() {
+  busy.value = true; error.value = null
+  try { accept(await getLoadingDocuments(number)); await previews() }
+  catch (cause) { if (active) error.value = getApiErrorDetails(cause, '装车资料读取失败') }
+  finally { if (active) busy.value = false }
+}
+async function bind() {
+  const item = pending.value
+  if (!item?.photo || !snapshot.value) return
+  if (item.photo.slot !== item.slot) throw new Error('上传结果与装车照片框不一致')
+  if (!item.binding) { item.binding = { recordVersion: snapshot.value.recordVersion, idempotencyKey: crypto.randomUUID(), fileId: item.photo.fileId }; persist() }
+  try {
+    const result = await bindLoadingPhoto(number, item.slot, item.binding)
+    accept(result); pending.value = null; persist(); emit('saved')
+    ElMessage.success(result.stage === 'DELIVERING' && result.complete ? '装车资料已齐全，本车已进入派送中' : '装车照片已保存')
+    await previews()
+  } catch (cause) {
+    const failure = getApiErrorDetails(cause, '装车照片保存失败')
+    if (pending.value && /^(?:A0|HTTP_)?409$/.test(String(failure.code))) { pending.value.conflict = true; persist() }
+    throw cause
+  }
+}
+async function recover() {
+  if (busy.value || !editable.value || !pending.value) return
+  busy.value = true; error.value = null
+  try {
+    ensureScope()
+    if (pending.value.conflict) { accept(await getLoadingDocuments(number)); pending.value.binding = undefined; pending.value.conflict = false; persist() }
+    if (!pending.value.photo) { pending.value.photo = await recoverLoadingPhoto(number, pending.value.key); ensureScope(); persist() }
+    await bind()
+  } catch (cause) { if (active) error.value = getApiErrorDetails(cause, '原上传或保存结果尚未确认') }
+  finally { if (active) busy.value = false }
+}
+async function upload(slot: LoadingPhotoSlot, event: Event) {
+  const input = event.target as HTMLInputElement, file = input.files?.[0]; input.value = ''
+  if (!file || busy.value || pending.value || !editable.value) return
+  if (!['image/jpeg', 'image/png'].includes(file.type) || !file.size || file.size > 10 * 1024 * 1024) { ElMessage.warning('请选择不超过10MiB的JPG或PNG图片'); return }
+  busy.value = true; error.value = null
+  try {
+    ensureScope(); pending.value = { slot, key: crypto.randomUUID() }; persist()
+    pending.value.photo = await uploadLoadingPhoto(number, slot, file, pending.value.key); ensureScope(); persist(); await bind()
+  } catch (cause) { if (active) error.value = getApiErrorDetails(cause, '装车照片上传或保存失败，请核对原请求') }
+  finally { if (active) busy.value = false }
+}
+onMounted(() => {
+  try {
+    const raw = sessionStorage.getItem(storageKey)
+    if (raw) { const value = JSON.parse(raw) as Pending; if (!loadingPhotoSlots.includes(value.slot) || typeof value.key !== 'string' || !value.key) throw new Error('原装车照片请求记录无法读取'); pending.value = value }
+  } catch (cause) { corrupted.value = true; error.value = getApiErrorDetails(cause, '原装车照片请求记录无法读取') }
+  if (!corrupted.value) void load()
+})
+onBeforeUnmount(() => { active = false; Object.values(images.value).forEach(URL.revokeObjectURL) })
+defineExpose({ busy })
+</script>
+<template>
+  <div v-loading="busy" class="density-dialog-sections">
+    <p v-if="snapshot?.stage === 'LOADING'">可边装车边上传 5 张装车照片；装车确认完成且照片齐全后自动进入派送中。</p>
+    <p v-if="snapshot?.stage === 'AFTER_LOADING'">请上传 5 张装车照片，全部保存成功后自动进入派送中。</p>
+    <LoadErrorState v-if="error" compact title="装车资料操作失败" :message="error.message" :show-retry="!pending && !corrupted" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
+    <div v-if="pending" role="status">有装车照片尚未确认保存。<el-button :disabled="busy || !editable" @click="recover">{{ pending.conflict ? '刷新并重试保存' : '核对原请求并继续保存' }}</el-button></div>
+    <div class="loading-photo-grid">
+      <section v-for="(slot, index) in loadingPhotoSlots" :key="slot" class="density-dialog-section loading-photo-card">
+        <h3 class="density-dialog-section__title">装车照片 {{ index + 1 }}</h3>
+        <template v-for="photo in snapshot?.photos.filter(item => item.slot === slot) || []" :key="photo.fileId">
+          <el-image v-if="images[photo.fileId]" :src="images[photo.fileId]" :preview-src-list="[images[photo.fileId]!]" fit="contain" class="loading-photo-image" preview-teleported />
+          <el-button v-else link :disabled="busy" @click="load">图片读取失败，点击重试</el-button>
+        </template>
+        <div v-if="!snapshot?.photos.some(item => item.slot === slot)" class="loading-photo-empty">未上传</div>
+        <label v-if="editable">上传／替换图片<input type="file" accept="image/jpeg,image/png" :aria-label="`装车照片 ${index + 1}`" :disabled="busy || Boolean(pending)" @change="upload(slot, $event)" /></label>
+      </section>
+    </div>
+  </div>
+</template>
+<style scoped>
+.loading-photo-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: var(--admin-space-4); }
+.loading-photo-image, .loading-photo-empty { width: 100%; height: 150px; margin-bottom: var(--admin-space-3); }
+.loading-photo-empty { display: grid; place-items: center; background: var(--cc-bg-soft, #f3f7ff); color: var(--cc-text-secondary, #64748b); }
+.loading-photo-card input { display: block; margin-top: var(--admin-space-2); max-width: 100%; }
+</style>
@@ -0,0 +1,63 @@
+import ElementPlus from 'element-plus'
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, expect, it, vi } from 'vitest'
+import { ApiResponseError } from '@/shared/api/http'
+import DispatchVehicleDocuments from './DispatchVehicleDocuments.vue'
+import { bindVehiclePhoto, getVehicleDocuments, recoverVehiclePhoto, uploadVehiclePhoto, type VehicleDocuments, type VehiclePhoto } from '../api/dispatchVehicleDocuments'
+const can = vi.hoisted(() => vi.fn(() => true))
+vi.mock('@/core/auth/auth', () => ({ useAuthStore: () => ({ user: { id: 'operator' } }) }))
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can }) }))
+vi.mock('../api/dispatchVehicleDocuments', () => ({ bindVehiclePhoto: vi.fn(), getVehicleDocuments: vi.fn(), recoverVehiclePhoto: vi.fn(), uploadVehiclePhoto: vi.fn(), readVehiclePhoto: vi.fn() }))
+const photo: VehiclePhoto = { slot: 'FUEL_START', fileId: '9007199254740995', fileName: 'fuel.png', contentType: 'image/png', savedAt: null }
+function response(version = '3'): VehicleDocuments { return { dispatchNo: 'PC/1', recordVersion: version, editable: true, photos: [] } }
+function setup() { return mount(DispatchVehicleDocuments, { props: { dispatchNo: 'PC/1' }, global: { plugins: [ElementPlus] } }) }
+async function upload(wrapper: ReturnType<typeof setup>) { const input = wrapper.get('input'); Object.defineProperty(input.element, 'files', { value: [new File(['image'], 'fuel.png', { type: 'image/png' })], configurable: true }); await input.trigger('change'); await flushPromises() }
+beforeEach(() => {
+  vi.clearAllMocks(); sessionStorage.clear(); can.mockReturnValue(true)
+  vi.mocked(getVehicleDocuments).mockResolvedValue(response())
+  vi.mocked(uploadVehiclePhoto).mockResolvedValue(photo)
+  vi.mocked(recoverVehiclePhoto).mockResolvedValue(photo)
+  vi.mocked(bindVehiclePhoto).mockResolvedValue({ ...response('4'), photos: [{ ...photo, savedAt: '2026-10-21T00:00:00Z' }] })
+})
+it('binds the uploaded file to the car and restores the original binding after reopening without uploading twice', async () => {
+  vi.mocked(bindVehiclePhoto).mockRejectedValueOnce(new Error('network timeout'))
+  const first = setup(); await flushPromises(); await upload(first)
+  const original = vi.mocked(bindVehiclePhoto).mock.calls[0]![2]
+  expect(original).toMatchObject({ recordVersion: '3', fileId: photo.fileId })
+  first.unmount()
+  const reopened = setup(); await flushPromises()
+  await reopened.findAll('button').find(button => button.text() === '核对原请求并继续保存')!.trigger('click'); await flushPromises()
+  expect(bindVehiclePhoto).toHaveBeenLastCalledWith('PC/1', 'FUEL_START', original)
+  expect(uploadVehiclePhoto).toHaveBeenCalledTimes(1)
+  expect(reopened.text()).toContain('fuel.png')
+  expect(sessionStorage.length).toBe(0)
+  reopened.unmount()
+})
+it('keeps uncertain uploads for original-key recovery and never resubmits the file', async () => {
+  vi.mocked(uploadVehiclePhoto).mockRejectedValueOnce(new Error('connection lost'))
+  const wrapper = setup(); await flushPromises(); await upload(wrapper)
+  const originalKey = vi.mocked(uploadVehiclePhoto).mock.calls[0]![3]
+  await wrapper.findAll('button').find(button => button.text() === '核对原请求并继续保存')!.trigger('click'); await flushPromises()
+  expect(recoverVehiclePhoto).toHaveBeenCalledWith('PC/1', originalKey)
+  expect(uploadVehiclePhoto).toHaveBeenCalledTimes(1)
+  expect(bindVehiclePhoto).toHaveBeenCalledTimes(1)
+  wrapper.unmount()
+})
+it('refreshes only a known version conflict and reuses the uploaded file', async () => {
+  vi.mocked(bindVehiclePhoto).mockRejectedValueOnce(new ApiResponseError('运营记录版本已变化，请刷新后重试', 'A0409', 409))
+  const wrapper = setup(); await flushPromises(); await upload(wrapper)
+  const originalKey = vi.mocked(bindVehiclePhoto).mock.calls[0]![2].idempotencyKey
+  vi.mocked(getVehicleDocuments).mockResolvedValue(response('8'))
+  await wrapper.findAll('button').find(button => button.text() === '刷新版本并保存已上传图片')!.trigger('click'); await flushPromises()
+  expect(bindVehiclePhoto).toHaveBeenLastCalledWith('PC/1', 'FUEL_START', { recordVersion: '8', fileId: photo.fileId, idempotencyKey: expect.any(String) })
+  expect(vi.mocked(bindVehiclePhoto).mock.calls[1]![2].idempotencyKey).not.toBe(originalKey)
+  expect(uploadVehiclePhoto).toHaveBeenCalledTimes(1)
+  wrapper.unmount()
+})
+it('does not offer upload with list permission alone', async () => {
+  can.mockReturnValue(false)
+  const wrapper = setup(); await flushPromises()
+  expect(wrapper.find('input[type="file"]').exists()).toBe(false)
+  expect(uploadVehiclePhoto).not.toHaveBeenCalled()
+  wrapper.unmount()
+})
@@ -0,0 +1,109 @@
+<script setup lang="ts">
+import { computed, onBeforeUnmount, onMounted, ref } from 'vue'
+import { ElMessage } from 'element-plus'
+import { useAuthStore } from '@/core/auth/auth'
+import { useAccessPreviewStore } from '@/core/access/accessPreview'
+import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
+import LoadErrorState from '@/shared/components/LoadErrorState.vue'
+import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
+import { overseasWarehousePermissions as permission } from '../permissions'
+import { bindVehiclePhoto, getVehicleDocuments, readVehiclePhoto, recoverVehiclePhoto, uploadVehiclePhoto, type BindVehiclePhoto, type FuelSlot, type VehicleDocuments, type VehiclePhoto } from '../api/dispatchVehicleDocuments'
+
+const props = defineProps<{ dispatchNo: string }>()
+const auth = useAuthStore(), access = useAccessPreviewStore()
+const emit = defineEmits<{ saved: [] }>()
+const snapshot = ref<VehicleDocuments | null>(null), busy = ref(false), error = ref<ApiErrorDetails | null>(null)
+interface Pending { slot: FuelSlot; key: string; photo?: VehiclePhoto; binding?: BindVehiclePhoto; versionConflict?: boolean }
+const pending = ref<Pending | null>(null), preview = ref(''), corrupted = ref(false)
+const actor = auth.user?.id || '', number = props.dispatchNo
+const storageKey = `dispatch-vehicle-documents:${actor}:${number}`
+const editable = computed(() => !corrupted.value && access.can(permission.dispatchEdit) && snapshot.value?.editable === true)
+const roles: Array<{ slot: FuelSlot; label: string }> = [{ slot: 'FUEL_START', label: '起始油耗表盘' }, { slot: 'FUEL_END', label: '结束油耗表盘' }]
+let active = true
+function ensureScope() { if (!active || auth.user?.id !== actor || props.dispatchNo !== number) throw new Error('资料操作身份已变化，请重新打开') }
+function persist() { if (pending.value) sessionStorage.setItem(storageKey, JSON.stringify(pending.value)); else sessionStorage.removeItem(storageKey) }
+async function load() {
+  busy.value = true; error.value = null
+  try { const result = await getVehicleDocuments(number); ensureScope(); if (result.dispatchNo !== number) throw new Error('车辆资料与排车单不一致'); snapshot.value = result }
+  catch (cause) { if (active) error.value = getApiErrorDetails(cause, '车辆资料读取失败') }
+  finally { if (active) busy.value = false }
+}
+async function bind() {
+  const item = pending.value
+  if (!item?.photo || !snapshot.value) return
+  if (item.photo.slot !== item.slot) throw new Error('上传结果与图片分类不一致')
+  if (!item.binding) { item.binding = { recordVersion: snapshot.value.recordVersion, idempotencyKey: crypto.randomUUID(), fileId: item.photo.fileId }; persist() }
+  let result: VehicleDocuments
+  try { result = await bindVehiclePhoto(number, item.slot, item.binding) }
+  catch (cause) {
+    const details = getApiErrorDetails(cause, '图片保存失败')
+    if (details.code === 'A0409' && /记录版本已变化|记录版本竞争失败/.test(details.message)) { item.versionConflict = true; persist() }
+    throw cause
+  }
+  ensureScope(); snapshot.value = result; pending.value = null; persist(); emit('saved'); ElMessage.success('油耗图片已保存')
+}
+async function recover() {
+  if (busy.value || !editable.value || !pending.value) return
+  busy.value = true; error.value = null
+  try { ensureScope(); if (!pending.value.photo) { pending.value.photo = await recoverVehiclePhoto(number, pending.value.key); ensureScope(); persist() }; await bind() }
+  catch (cause) { if (active) error.value = getApiErrorDetails(cause, '原上传或保存结果尚未确认') }
+  finally { if (active) busy.value = false }
+}
+async function refreshBinding() {
+  if (busy.value || !editable.value || !pending.value?.versionConflict) return
+  await load()
+  if (error.value || !pending.value) return
+  pending.value.binding = undefined; pending.value.versionConflict = false; persist()
+  await recover()
+}
+async function upload(slot: FuelSlot, event: Event) {
+  const input = event.target as HTMLInputElement, file = input.files?.[0]; input.value = ''
+  if (!file || busy.value || pending.value || !editable.value) return
+  if (!['image/jpeg', 'image/png'].includes(file.type) || !file.size || file.size > 10 * 1024 * 1024) { ElMessage.warning('请选择不超过10MiB的JPG或PNG图片'); return }
+  busy.value = true; error.value = null
+  try {
+    ensureScope(); pending.value = { slot, key: crypto.randomUUID() }; persist()
+    pending.value.photo = await uploadVehiclePhoto(number, slot, file, pending.value.key); ensureScope(); persist(); await bind()
+  } catch (cause) {
+    if (active) {
+      error.value = getApiErrorDetails(cause, '图片上传或保存失败，请核对原请求')
+      if (!pending.value?.photo && ['A0400', 'A0403'].includes(error.value.code || '')) { pending.value = null; persist() }
+    }
+  }
+  finally { if (active) busy.value = false }
+}
+async function view(photo: VehiclePhoto) {
+  if (busy.value) return
+  busy.value = true; error.value = null
+  try { const blob = await readVehiclePhoto(number, photo); ensureScope(); if (preview.value) URL.revokeObjectURL(preview.value); preview.value = URL.createObjectURL(blob) }
+  catch (cause) { if (active) error.value = getApiErrorDetails(cause, '图片读取失败') }
+  finally { if (active) busy.value = false }
+}
+onMounted(() => {
+  try {
+    const raw = sessionStorage.getItem(storageKey)
+    if (raw) { const value = JSON.parse(raw) as Pending; if (!roles.some(role => role.slot === value.slot) || typeof value.key !== 'string' || !value.key) throw new Error('原图片请求记录无法读取'); pending.value = value }
+  } catch (cause) { corrupted.value = true; error.value = getApiErrorDetails(cause, '原图片请求记录无法读取') }
+  if (!corrupted.value) void load()
+})
+onBeforeUnmount(() => { active = false; if (preview.value) URL.revokeObjectURL(preview.value) })
+defineExpose({ busy })
+</script>
+<template>
+  <div v-loading="busy" class="density-dialog-sections">
+    <LoadErrorState v-if="error" compact title="车辆资料操作失败" :message="error.message" :show-retry="!pending && !corrupted" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
+    <div v-if="pending" role="status">有图片尚未确认保存。<el-button v-if="pending.versionConflict" :disabled="busy || !editable" @click="refreshBinding">刷新版本并保存已上传图片</el-button><el-button v-else :disabled="busy || !editable" @click="recover">核对原请求并继续保存</el-button></div>
+    <section v-for="role in roles" :key="role.slot" class="density-dialog-section">
+      <h3 class="density-dialog-section__title">{{ role.label }}</h3>
+      <div v-for="photo in snapshot?.photos.filter(item => item.slot === role.slot) || []" :key="photo.fileId"><el-button link :disabled="busy" @click="view(photo)">{{ photo.fileName }}</el-button></div>
+      <span v-if="snapshot && !snapshot.photos.some(item => item.slot === role.slot)">未上传</span>
+      <label v-if="editable" class="photo-upload">上传／替换<input type="file" accept="image/jpeg,image/png" :aria-label="role.label" :disabled="busy || Boolean(pending)" @change="upload(role.slot, $event)" /></label>
+    </section>
+    <img v-if="preview" :src="preview" alt="油耗图片预览" class="photo-preview" />
+  </div>
+</template>
+<style scoped>
+.photo-upload { display: block; margin-top: var(--admin-space-3); }
+.photo-upload input { margin-left: var(--admin-space-3); }
+.photo-preview { display: block; max-width: 100%; max-height: 400px; object-fit: contain; }
+</style>
@@ -217,8 +217,11 @@ describe('dispatch workflow native layout', () => {
    await files.get('button.evidence-photo-preview').trigger('click'); await flushPromises()
    const image = files.findComponent(AppDialog)
    expect(image.props('modelValue')).toBe(true)
-    const preview = new DOMWrapper(document.querySelector('[aria-label="本车附件预览信息"]')!.closest('.el-dialog')!)
+    const preview = new DOMWrapper(document.querySelector('.evidence-preview')!.closest('.el-dialog')!)
    expect(preview.get('img').attributes('src')).toBe('blob:owned-dispatch')
+    Object.defineProperties(preview.get('img').element, { naturalWidth: { value: 1200 }, naturalHeight: { value: 800 } })
+    await preview.get('img').trigger('load'); await flushPromises()
+    expect(preview.get('.evidence-preview').attributes('aria-busy')).toBe('false')
    await preview.get('button[aria-label="展开全屏"]').trigger('click'); await flushPromises()
    expect(preview.classes()).toContain('is-fullscreen')
    await preview.findAll('button').find(button => button.text() === '关闭')!.trigger('click'); await flushPromises()
@@ -152,7 +152,7 @@ async function submit() {
    const reviewReturned = ['DISPATCH_REVIEW', 'LOADING_REVIEW'].includes(pending.value?.action || '') && pending.value?.body.decision === 'REJECTED'
    const result = await recovery.execute(send, api.getDispatch, api.getDispatchCommand)
    if (!result) return
-    ElMessage.success(reviewReturned ? '已退回客服处理（车辆信息），修改后需重新提交调度审核' : result.action === 'LOADING_COMPLETE' ? '装车完成，已进入派送中' : routeCommand ? '卸货顺序调整已确认，请重新核对两级审核' : result.alreadyArranged ? '已引用本车原派送安排，未重复生成单据和费用' : result.replayed ? '原操作结果已核对' : `${dispatchActionLabels[result.action]}已确认`)
+    ElMessage.success(reviewReturned ? '已退回客服处理（车辆信息），修改后需重新提交调度审核' : result.action === 'LOADING_COMPLETE' ? result.stage === 'DELIVERING' ? '装车完成、资料齐全，已进入派送中' : '装车完成，请在装车后补齐装车资料' : routeCommand ? '卸货顺序调整已确认，请重新核对两级审核' : result.alreadyArranged ? '已引用本车原派送安排，未重复生成单据和费用' : result.replayed ? '原操作结果已核对' : `${dispatchActionLabels[result.action]}已确认`)
    emit('saved'); open.value = false
  } catch (cause) {
    error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : pending.value?.result ? '操作已完成，页面资料待刷新' : pending.value ? '操作结果尚未确认，请保留原请求核对' : '本次操作未通过，请核对后再提交')
@@ -11,6 +11,7 @@ const props = defineProps<{
  capacity: number
  disabled: boolean
  warehouseSelected: boolean
+  addVehicleDisabled?: boolean
  page: number
  size: number
  total: number
@@ -161,7 +162,7 @@ watch(() => [props.disabled, props.warehouseSelected, props.draft, props.activeC
 <template>
  <div class="dispatch-cargo-board" aria-label="智能排车三栏选货">
    <section class="cargo-board-panel cargo-board-orders" aria-label="待排订单">
-      <header class="cargo-board-heading"><h3>待排订单</h3><span class="cargo-board-muted">本页 {{ orders.length }} 单</span></header>
+      <header class="cargo-board-heading"><h3>待排订单</h3><span class="cargo-board-muted">本页 {{ orders.length }} 单</span><div v-if="slots['order-controls']" class="cargo-board-order-tools"><slot name="order-controls" /></div></header>
      <div class="cargo-board-order-content">
      <div class="cargo-board-table-wrap">
        <table class="density-table cargo-board-table">
@@ -204,7 +205,7 @@ watch(() => [props.disabled, props.warehouseSelected, props.draft, props.activeC
    </section>

    <section class="cargo-board-panel cargo-board-vehicles" aria-label="车辆装载">
-      <header class="cargo-board-heading"><slot name="vehicle-heading"><template v-if="!slots.vehicles"><h3>装车托盘</h3><InlineHelp title="车辆装载说明"><p>将中间托盘拖入任意车辆，或选中车辆后点击托盘号。已装货物需先移除才能加入其他车辆。计划托位仅用于新车辆预排，不代表真实载重或容积；体积、重量以装车核对为准。</p></InlineHelp><div class="cargo-board-vehicle-tools"><slot name="vehicle-controls" /><el-button type="primary" :disabled="disabled || !warehouseSelected" @click="emit('addVehicle')">添加车辆</el-button></div></template></slot></header>
+      <header class="cargo-board-heading"><slot name="vehicle-heading"><template v-if="!slots.vehicles"><h3>装车托盘</h3><InlineHelp title="车辆装载说明"><p>将中间托盘拖入任意车辆，或选中车辆后点击托盘号。已装货物需先移除才能加入其他车辆。计划托位仅用于新车辆预排，不代表真实载重或容积；体积、重量以装车核对为准。</p></InlineHelp><div class="cargo-board-vehicle-tools"><slot name="vehicle-controls" /><el-button type="primary" :disabled="disabled || !warehouseSelected || addVehicleDisabled" @click="emit('addVehicle')">添加车辆</el-button></div></template></slot></header>
      <div class="cargo-board-vehicle-content">
      <slot name="vehicles" :drag-over="dragOver" :drop="drop" :drop-target="dropTarget">
      <div class="cargo-board-vehicle-list">
@@ -250,7 +251,10 @@ watch(() => [props.disabled, props.warehouseSelected, props.draft, props.activeC
 .cargo-board-table tr.is-selected td { background: var(--admin-action-primary-hover); }
 .cargo-board-business-no { font-weight: 600; }
 .cargo-board-pagination { display: flex; align-items: center; padding-top: var(--admin-space-5); overflow-x: auto; }
-.cargo-board-order-caption { margin-left: auto; max-width: 65%; overflow-wrap: anywhere; color: var(--cc-muted); font-size: var(--admin-font-caption); }
+.cargo-board-pallets > .cargo-board-heading { flex-wrap: nowrap; }
+.cargo-board-pallets > .cargo-board-heading h3 { flex-shrink: 0; }
+.cargo-board-order-tools { margin-left: auto; }
+.cargo-board-order-caption { margin-left: auto; min-width: 0; text-align: right; overflow-wrap: anywhere; color: var(--cc-muted); font-size: var(--admin-font-caption); }
 .cargo-board-order-caption small { display: block; }
 .cargo-board-empty { padding: var(--admin-space-7); color: var(--cc-muted); text-align: center; margin: 0; }
 .cargo-board-pallet-list { max-height: min(500px, 48vh); overflow-y: auto; border: 1px solid var(--admin-table-border); border-radius: var(--admin-dialog-section-radius); }
@@ -47,31 +47,54 @@ beforeEach(() => {
 async function render() { const wrapper = mount(SmartDispatchDialog, { attachTo: document.body, props: { modelValue: true, orders: [] }, global: { plugins: [ElementPlus] } }); await flushPromises(); return { wrapper, dialog: wrapper.findComponent(AppDialog) } }
 function view(dialog: VueWrapper) { return dialog.getComponent({ name: 'ElDialogContent' }) }
 function field(dialog: VueWrapper, label: string) { return dialog.findAllComponents({ name: 'ElFormItem' }).find(item => item.props('label') === label)! }
-async function selectWarehouse(dialog: VueWrapper) { const select = dialog.findAllComponents({ name: 'ElSelect' }).find(select => select.props('placeholder') === '请选择起运仓')!; select.vm.$emit('update:modelValue', '321'); select.vm.$emit('change', '321'); await flushPromises() }
+async function selectWarehouse(dialog: VueWrapper) {
+  const select = dialog.findAllComponents({ name: 'ElSelect' }).find(select => select.props('placeholder') === '请选择起运仓')
+  if (select) { select.vm.$emit('update:modelValue', '321'); select.vm.$emit('change', '321') }
+  await flushPromises()
+}
 async function emptyMode(dialog: VueWrapper) { field(dialog, '建单方式').getComponent({ name: 'ElRadioGroup' }).vm.$emit('update:modelValue', 'empty'); await flushPromises() }
 async function restore(dialog: VueWrapper) { dialog.findAllComponents({ name: 'ElSelect' }).find(select => select.props('placeholder') === '继续待完成排车')!.vm.$emit('change', 'server-token'); await flushPromises() }
 async function selectFirstOrder(dialog: VueWrapper) { await view(dialog).get('[aria-label="待排订单"] tbody tr button').trigger('click'); await flushPromises() }
 describe('new dispatch native layout', () => {
-  it('selects the first warehouse and loads its cargo immediately without creating a draft', async () => {
-    vi.mocked(listAllPlatformWarehouses).mockResolvedValue([warehouse, { ...warehouse, id: '654', warehouseName: '纽约仓' }])
+  it('opens all regional cargo without a warehouse picker or a silently selected warehouse', async () => {
+    vi.mocked(listAllPlatformWarehouses).mockResolvedValue([warehouse, { ...warehouse, id: '654', warehouseCode: 'NYC', warehouseName: '纽约仓' }])
    const { dialog } = await render()
-    const picker = dialog.findAllComponents({ name: 'ElSelect' }).find(select => select.props('placeholder') === '请选择起运仓')!
-    expect(picker.props('modelValue')).toBe('321')
-    expect(api.listDispatchCandidates).toHaveBeenCalledWith(expect.objectContaining({ warehouseId: '321', page: 1 }))
+    expect(view(dialog).get('[aria-label="候选货物查询"]').find('[aria-label="起运仓"]').exists()).toBe(false)
+    expect(api.listDispatchCandidates).toHaveBeenCalledWith(expect.objectContaining({ warehouseId: undefined, warehouseTab: 'ALL', page: 1 }))
+    expect(view(dialog).get('[aria-label="候选仓库展示"]').findAll('button').map(button => button.text())).toEqual(['全部', '洛杉矶', '纽约'])
    expect(api.createDispatchDraft).not.toHaveBeenCalled()
  })
-  it('keeps the warehouse empty and skips cargo loading when no warehouse is available', async () => {
+  it('reads regional candidates independently of the optional empty-dispatch warehouse directory', async () => {
    vi.mocked(listAllPlatformWarehouses).mockResolvedValue([])
    const { dialog } = await render()
-    expect(api.listDispatchCandidates).not.toHaveBeenCalled()
-    expect(view(dialog).text()).toContain('请先选择起运仓')
+    expect(api.listDispatchCandidates).toHaveBeenCalledWith(expect.objectContaining({ warehouseId: undefined }))
+    expect(view(dialog).text()).toContain('待排订单')
+  })
+  it('takes the first selected pallet warehouse instead of the first directory entry and locks the draft to that warehouse', async () => {
+    vi.mocked(listAllPlatformWarehouses).mockResolvedValue([warehouse, { ...warehouse, id: '654', warehouseCode: 'NYC', warehouseName: '纽约仓' }])
+    const row = candidate({ warehouseId: '654', warehouseCode: 'NYC', warehouseName: '纽约仓' })
+    vi.mocked(api.listDispatchCandidates).mockResolvedValue({ candidates: [row], total: 1, page: 1, size: 20, pages: 1, complete: true, snapshotAt: '' })
+    const empty = { ...draft(), warehouseId: '654', sources: [], containers: [] }
+    const car = { draftContainerId: 'ny-car', sequenceNo: 1, capacity: 30, sourceKeys: [] as string[] }
+    vi.mocked(api.createDispatchDraft).mockResolvedValue(empty)
+    vi.mocked(api.createDispatchDraftContainer).mockResolvedValue({ ...empty, recordVersion: 1, containers: [car] })
+    vi.mocked(api.lockDispatchDraftPallet).mockResolvedValue({ ...empty, recordVersion: 2, sources: [row], containers: [{ ...car, sourceKeys: [row.sourceKey] }] })
+    const { dialog } = await render(); await selectFirstOrder(dialog)
+    await view(dialog).get('button[aria-label^="将托盘 "]').trigger('click'); await flushPromises()
+    expect(api.createDispatchDraft).toHaveBeenCalledWith(expect.objectContaining({ warehouseId: '654' }))
+    expect(api.listDispatchCandidates).toHaveBeenLastCalledWith(expect.objectContaining({ warehouseId: '654', draftToken: 'server-token' }))
+    const tabs = view(dialog).get('[aria-label="候选仓库展示"]').findAll('button')
+    expect(tabs[1]!.attributes('disabled')).toBeDefined()
+    expect(tabs[2]!.attributes('disabled')).toBeUndefined()
  })
  it('retains the restored draft warehouse instead of selecting the first warehouse on reopen', async () => {
    vi.mocked(listAllPlatformWarehouses).mockResolvedValue([warehouse, { ...warehouse, id: '654', warehouseName: '纽约仓' }])
    vi.mocked(api.listDispatchDrafts).mockResolvedValue([{ ...draft(), warehouseId: '654', sources: [], containers: [] }])
    vi.mocked(api.listDispatchCandidates).mockResolvedValue({ total: 0, page: 1, size: 20, pages: 0, candidates: [], complete: true, snapshotAt: '' })
    const { wrapper, dialog } = await render()
+    await view(dialog).get('[aria-label="候选仓库展示"]').findAll('button').find(button => button.text() === '洛杉矶')!.trigger('click'); await flushPromises()
    await restore(dialog)
+    expect(api.listDispatchCandidates).toHaveBeenLastCalledWith(expect.objectContaining({ warehouseId: '654', warehouseTab: 'ALL' }))
    await wrapper.setProps({ modelValue: false }); await wrapper.setProps({ modelValue: true }); await flushPromises()
    expect(api.listDispatchCandidates).toHaveBeenLastCalledWith(expect.objectContaining({ warehouseId: '654' }))
  })
@@ -81,7 +104,7 @@ describe('new dispatch native layout', () => {
    const content = view(dialog)
    const searchPanel = content.get('[aria-label="候选货物查询"]')
    expect(searchPanel.find('.el-form-item__label').exists()).toBe(false)
-    expect(searchPanel.find('[aria-label="起运仓"]').exists()).toBe(true)
+    expect(searchPanel.find('[aria-label="起运仓"]').exists()).toBe(false)
    expect(searchPanel.find('input[placeholder="订单号／入仓码"]').exists()).toBe(true)
    const settingsToggle = searchPanel.findAll('button').find(button => button.text() === '排车设置')!
    expect(content.get('[aria-label="排车设置"]').isVisible()).toBe(false)
@@ -284,7 +307,7 @@ describe('new dispatch native layout', () => {
    await view(dialog).get('input[placeholder="目的仓码"]').setValue('ONT8')
    dialog.findAllComponents({ name: 'ElSelect' }).find(select => select.props('placeholder') === '全部来源')!.vm.$emit('update:modelValue', sourceStage); await flushPromises()
    await view(dialog).findAll('button').find(button => button.text() === '查询')!.trigger('click'); await flushPromises()
-    expect(api.listDispatchCandidates).toHaveBeenLastCalledWith({ page: 1, size: 20, warehouseTab: 'ALL', warehouseId: '321', orderNo: 'IN-QUERY', destinationWarehouseCode: 'ONT8', sourceStage, draftToken: undefined })
+    expect(api.listDispatchCandidates).toHaveBeenLastCalledWith({ page: 1, size: 20, warehouseTab: 'ALL', warehouseId: undefined, orderNo: 'IN-QUERY', destinationWarehouseCode: 'ONT8', sourceStage, draftToken: undefined })
    const calls = vi.mocked(api.listDispatchCandidates).mock.calls.length
    await view(dialog).get('[aria-label="候选仓库展示"]').findAll('button').find(button => button.text() === '纽约')!.trigger('click'); await flushPromises()
    expect(view(dialog).get('[aria-label="候选仓库展示"]').findAll('button').find(button => button.text() === '纽约')!.attributes('aria-selected')).toBe('true')
@@ -89,9 +89,10 @@ async function selectOrder(dialog: VueWrapper, palletNo: string) {
  await row.get('button').trigger('click'); await flushPromises()
 }
 async function warehouseSelected(dialog: VueWrapper) {
-  const picker = dialog.findAllComponents({ name: 'ElSelect' }).find(select => select.props('placeholder') === '请选择起运仓')!
-  picker.vm.$emit('update:modelValue', '321'); picker.vm.$emit('change', '321'); await flushPromises()
+  expect(view(dialog).get('[aria-label="候选仓库展示"]').text()).toContain('全部')
+  await flushPromises()
 }
+
 async function join(dialog: VueWrapper, palletNo: string) { await selectOrder(dialog, palletNo); await cargoRow(dialog, palletNo).get('button[aria-label^="将托盘 "]').trigger('click'); await flushPromises() }
 async function chooseCar(dialog: VueWrapper, index: number) { await car(dialog, index).get('input[type="radio"]').setValue(true); await flushPromises() }
 describe('three-column cargo planning through visible controls', () => {
@@ -167,7 +167,7 @@ it('keeps server draft cargo across pages, resets filters and sends regional tab
    state.query.orderNo = 'query'; await state.search()
    expect(api.listDispatchCandidates).toHaveBeenLastCalledWith(expect.objectContaining({ page: 1, orderNo: 'query' }))
    state.changeTab('NYC'); await flushPromises()
-    expect(api.listDispatchCandidates).toHaveBeenLastCalledWith(expect.objectContaining({ page: 1, warehouseTab: 'NYC' }))
+    expect(api.listDispatchCandidates).toHaveBeenLastCalledWith(expect.objectContaining({ page: 1, warehouseId: '321', warehouseTab: 'ALL' }))
    state.changeSize(10); await flushPromises()
    expect(api.listDispatchCandidates).toHaveBeenLastCalledWith(expect.objectContaining({ page: 1, size: 10 }))
    state.changePage(2); await flushPromises(); await state.submit()
@@ -21,7 +21,7 @@ import { useDispatchCommandRecovery, validateCurrentDispatch, isDefiniteDispatch
 import type { InboundOrderListItem } from '../types'
 import SmartDispatchCargoBoard from './SmartDispatchCargoBoard.vue'
 import SmartDispatchExistingCargo from './SmartDispatchExistingCargo.vue'
-import type { SmartDispatchWarehouseTab } from '../smartDispatchWarehouseTab'
+import { matchesSmartDispatchWarehouseTab, type SmartDispatchWarehouseTab } from '../smartDispatchWarehouseTab'

 const props = defineProps<{ modelValue: boolean; orders: InboundOrderListItem[] }>()
 const emit = defineEmits<{ 'update:modelValue': [value: boolean]; created: [] }>()
@@ -39,7 +39,7 @@ const settingsExpanded = ref(false)
 const mode = ref<'cargo' | 'empty'>('cargo'), warehouseId = ref(''), warehouses = ref<PlatformWarehouseResource[]>([])
 const draft = ref<DispatchDraft | null>(null), drafts = ref<DispatchDraft[]>([]), activeContainerId = ref(''), capacity = ref(30)
 const working = ref(false), saving = ref(false), preparing = ref(false), error = ref<ApiErrorDetails | null>(null)
-const candidatePage = useDispatchCandidates(error)
+const candidatePage = useDispatchCandidates(error, api.listDispatchCandidates, true)
 const { candidates, page, size, total } = candidatePage
 const loading = computed(() => working.value || candidatePage.loading.value)
 const query = reactive({ orderNo: '', destinationWarehouseCode: '', sourceStage: '' })
@@ -71,11 +71,13 @@ async function ensureFirstVehicle(sequence: number): Promise<string | null> {
  return currentContainer.value?.draftContainerId || null
 }
 async function addCargo(source: Candidate, targetContainerId = activeContainerId.value) {
-  if (frozen.value || loading.value || !warehouseId.value || assignedGroup(source)) return
+  if (frozen.value || loading.value || assignedGroup(source)) return
  const sequence = generation, target = targetContainerId
  preparing.value = true
  try {
    requireSelectionGroup(source); candidatePage.assertCurrent([source])
+    if (draft.value && source.warehouseId !== draft.value.warehouseId) throw new DispatchInputError('同一次排车安排只能选择同一起运仓的货物')
+    if (!draft.value) warehouseId.value = source.warehouseId
    const containerId = target || await ensureFirstVehicle(sequence)
    if (!containerId || sequence !== generation || !props.modelValue) return
    if (!draft.value?.containers.some(row => row.draftContainerId === containerId)) throw new DispatchInputError('所选车辆已变化，请重新选择')
@@ -85,7 +87,8 @@ async function addCargo(source: Candidate, targetContainerId = activeContainerId
  finally { preparing.value = false }
 }
 async function addVehicle() {
-  if (frozen.value || loading.value || !warehouseId.value) return
+  if (frozen.value || loading.value || !vehicleWarehouse.value) return
+  if (!draft.value) warehouseId.value = vehicleWarehouse.value
  const sequence = generation
  preparing.value = true
  try {
@@ -94,7 +97,17 @@ async function addVehicle() {
  } finally { preparing.value = false }
 }
 function changeWarehouse() { candidatePage.reset(); warehouseTab.value = 'ALL'; void search() }
-function changeTab(tab: SmartDispatchWarehouseTab) { warehouseTab.value = tab; void search() }
+function changeTab(tab: SmartDispatchWarehouseTab) { if (tabDisabled(tab)) return; warehouseTab.value = tab; void search() }
+function tabDisabled(tab: SmartDispatchWarehouseTab) {
+  if (!draft.value || tab === 'ALL') return false
+  const warehouse = warehouses.value.find(row => String(row.id) === draft.value!.warehouseId)
+  return !warehouse || !matchesSmartDispatchWarehouseTab(warehouse, tab)
+}
+const vehicleWarehouse = computed(() => {
+  if (draft.value) return draft.value.warehouseId
+  const matches = warehouses.value.filter(row => matchesSmartDispatchWarehouseTab(row, warehouseTab.value))
+  return matches.length === 1 ? String(matches[0]!.id) : ''
+})
 function changePage(value: number) { page.value = value; void loadCandidates() }
 function changeSize(value: number) { size.value = value; void search() }

@@ -125,7 +138,7 @@ async function init() {
      if (selectedWarehouses.size === 1 && directory.some(row => String(row.id) === [...selectedWarehouses][0])) warehouseId.value = [...selectedWarehouses][0]!
      else if (directory[0]) warehouseId.value = String(directory[0].id)
    }
-    if (warehouseId.value) await loadCandidates(sequence)
+    await loadCandidates(sequence)
  } catch (cause) { if (sequence === generation) error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : '排车候选或草稿恢复失败，请保留原选择重试') }
  finally { if (sequence === generation) working.value = false }
 }
@@ -138,13 +151,14 @@ function switchWorkspace(value: 'create' | 'existing') {
 }
 async function loadCandidates(sequence = generation) {
  if (sequence !== generation) return
-  const filterKey = JSON.stringify([warehouseId.value, query, warehouseTab.value, planIds.value, draft.value?.draftToken])
+  const candidateWarehouse = draft.value?.warehouseId
+  const filterKey = JSON.stringify([candidateWarehouse, query, warehouseTab.value, planIds.value, draft.value?.draftToken])
  if (filterKey !== candidateFilterKey) { page.value = 1; candidateFilterKey = filterKey }
-  await candidatePage.load({ warehouseId: warehouseId.value, page: page.value, size: size.value, warehouseTab: warehouseTab.value, orderNo: query.orderNo || undefined, destinationWarehouseCode: query.destinationWarehouseCode || undefined, sourceStage: query.sourceStage || undefined, ...(query.sourceStage !== 'RELABEL' && planIds.value.length ? { planIds: planIds.value } : {}), draftToken: draft.value?.draftToken })
+  await candidatePage.load({ warehouseId: candidateWarehouse, page: page.value, size: size.value, warehouseTab: warehouseTab.value, orderNo: query.orderNo || undefined, destinationWarehouseCode: query.destinationWarehouseCode || undefined, sourceStage: query.sourceStage || undefined, ...(query.sourceStage !== 'RELABEL' && planIds.value.length ? { planIds: planIds.value } : {}), draftToken: draft.value?.draftToken })
 }
 function resetSearch() { if (frozen.value) return; query.orderNo = ''; query.destinationWarehouseCode = ''; query.sourceStage = ''; warehouseTab.value = 'ALL'; void search() }
 async function search() { if (frozen.value) return; page.value = 1; await loadCandidates() }
-function restoreDraft(token: string) { if (frozen.value) return; const value = drafts.value.find(row => row.draftToken === token); if (!value) return; draft.value = value; warehouseId.value = value.warehouseId; activeContainerId.value = value.containers[0]?.draftContainerId || ''; void search() }
+function restoreDraft(token: string) { if (frozen.value) return; const value = drafts.value.find(row => row.draftToken === token); if (!value) return; draft.value = value; warehouseId.value = value.warehouseId; warehouseTab.value = 'ALL'; activeContainerId.value = value.containers[0]?.draftContainerId || ''; void search() }
 function creation(cargo: Candidate[], containerId?: string): CreateDispatch {
  candidatePage.assertCurrent(cargo)
  requireBatchVersions(cargo.flatMap(row => row.appointmentBatches))
@@ -221,6 +235,7 @@ async function retryDraft() {
      addedContainerId = added[0]!.draftContainerId
    }
    draft.value = command.action === 'RELEASE' ? null : result as DispatchDraft
+    if (draft.value) warehouseId.value = draft.value.warehouseId
    activeContainerId.value = addedContainerId || draft.value?.containers.find(row => row.draftContainerId === activeContainerId.value)?.draftContainerId || draft.value?.containers[0]?.draftContainerId || ''
    // No new source mutation before the original response has been validated.
    pending.value = null; persist()
@@ -246,7 +261,7 @@ async function submit() {
 watch(() => props.modelValue, value => { if (value) void init(); else { generation++; candidatePage.reset() } }, { immediate: true })
 </script>
 <template>
-  <AppDialog class="admin-density-dialog admin-density admin-workbench is-dialog" append-to-body :lock-scroll="true" :model-value="modelValue" title="智能排车" width="min(1800px, calc(100vw - 40px))" fullscreenable default-fullscreen :loading="working" :show-confirm="workspace === 'create'" :confirm-loading="saving || recovery.busy.value || existingBusy" :confirm-disabled="confirmDisabled" :confirm-text="needsRecovery ? '重试原请求' : mode === 'empty' ? '保存空排车单' : '生成排车单'" @update:model-value="emit('update:modelValue', $event)" @confirm="submit">
+  <AppDialog class="admin-density-dialog admin-density admin-workbench is-dialog smart-dispatch-dialog" :class="{ 'is-cargo-workspace': workspace === 'create' && mode === 'cargo' }" append-to-body :lock-scroll="true" :model-value="modelValue" title="智能排车" width="min(1800px, calc(100vw - 40px))" fullscreenable default-fullscreen :loading="working" :show-confirm="workspace === 'create'" :confirm-loading="saving || recovery.busy.value || existingBusy" :confirm-disabled="confirmDisabled" :confirm-text="needsRecovery ? '重试原请求' : mode === 'empty' ? '保存空排车单' : '生成排车单'" @update:model-value="emit('update:modelValue', $event)" @confirm="submit">
    <div class="density-status-tabs" role="tablist" aria-label="智能排车工作方式">
      <button v-if="canCreate" type="button" role="tab" :aria-selected="workspace === 'create'" :class="{ 'is-active': workspace === 'create' }" :disabled="workspaceFrozen" @click="switchWorkspace('create')">新建排车</button>
      <button v-if="canEditCargo" type="button" role="tab" :aria-selected="workspace === 'existing'" :class="{ 'is-active': workspace === 'existing' }" :disabled="workspaceFrozen" @click="switchWorkspace('existing')">调整已有排车货物</button>
@@ -258,11 +273,11 @@ watch(() => props.modelValue, value => { if (value) void init(); else { generati
      <el-alert v-if="needsRecovery" role="status" title="原请求结果尚待核对，请勿更改选择、版本或重新建单。" type="warning" :closable="false" show-icon />
        <section class="density-dialog-section dispatch-search" aria-label="候选货物查询">
          <div class="dispatch-candidate-query">
-            <el-select class="dispatch-warehouse-picker" aria-label="起运仓" v-model="warehouseId" :disabled="frozen || loading || Boolean(draft)" placeholder="请选择起运仓" @change="changeWarehouse"><el-option v-for="warehouse in warehouses" :key="String(warehouse.id)" :value="String(warehouse.id)" :label="warehouse.warehouseName" /></el-select>
-            <template v-if="mode === 'cargo'"><el-input v-model="query.orderNo" :disabled="frozen || loading" placeholder="订单号／入仓码" /><el-input v-model="query.destinationWarehouseCode" :disabled="frozen || loading" placeholder="目的仓码" /><el-select v-model="query.sourceStage" :disabled="frozen || loading" clearable placeholder="全部来源"><el-option label="在途预排（已离港）" value="PLAN" /><el-option label="已收货实物" value="RECEIVED" /><el-option label="待出库换标" value="RELABEL" /></el-select><el-button type="primary" :disabled="frozen || loading || !warehouseId" @click="search">查询</el-button><el-button :disabled="frozen || loading || !warehouseId" @click="resetSearch">重置</el-button></template><el-button :aria-expanded="settingsExpanded" aria-controls="smart-dispatch-settings" @click="settingsExpanded = !settingsExpanded">排车设置</el-button></div>
+            <template v-if="mode === 'cargo'"><el-input v-model="query.orderNo" :disabled="frozen || loading" placeholder="订单号／入仓码" /><el-input v-model="query.destinationWarehouseCode" :disabled="frozen || loading" placeholder="目的仓码" /><el-select v-model="query.sourceStage" :disabled="frozen || loading" clearable placeholder="全部来源"><el-option label="在途预排（已离港）" value="PLAN" /><el-option label="已收货实物" value="RECEIVED" /><el-option label="待出库换标" value="RELABEL" /></el-select><el-button type="primary" :disabled="frozen || loading" @click="search">查询</el-button><el-button :disabled="frozen || loading" @click="resetSearch">重置</el-button></template><el-button :aria-expanded="settingsExpanded" aria-controls="smart-dispatch-settings" @click="settingsExpanded = !settingsExpanded">排车设置</el-button></div>
        </section>
      <section v-show="settingsExpanded" id="smart-dispatch-settings" class="dispatch-context-toolbar" aria-label="排车设置">
        <el-form inline label-position="left" label-width="70px" class="density-form dispatch-setup-fields" :disabled="frozen || loading">
+          <el-form-item v-if="mode === 'empty'" label="起运仓"><el-select class="dispatch-warehouse-picker" aria-label="起运仓" v-model="warehouseId" :disabled="frozen || loading || Boolean(draft)" placeholder="请选择起运仓" @change="changeWarehouse"><el-option v-for="warehouse in warehouses" :key="String(warehouse.id)" :value="String(warehouse.id)" :label="warehouse.warehouseName" /></el-select></el-form-item>
          <el-form-item label="建单方式"><el-radio-group v-model="mode" :disabled="frozen || loading"><el-radio value="cargo">先选货再建单</el-radio><el-radio value="empty">先建空单后加货</el-radio></el-radio-group></el-form-item>
        </el-form>
        <div v-if="mode === 'cargo'" class="dispatch-draft-tools density-actions" aria-label="车辆选货安排">
@@ -273,9 +288,11 @@ watch(() => props.modelValue, value => { if (value) void init(); else { generati
      </section>
      <el-alert v-if="mode === 'empty'" title="空单暂不能核平、装车或发车。" type="info" :closable="false" show-icon />
      <template v-if="mode === 'cargo'">
-        <div class="warehouse-tabs density-actions" role="tablist" aria-label="候选仓库展示"><el-button v-for="tab in ([{ value: 'ALL', label: '全美' }, { value: 'LAX', label: '洛杉矶' }, { value: 'NYC', label: '纽约' }] as const)" :key="tab.value" role="tab" :aria-selected="warehouseTab === tab.value" :class="{ active: warehouseTab === tab.value }" :type="warehouseTab === tab.value ? 'primary' : undefined" :disabled="frozen || loading" @click="changeTab(tab.value)">{{ tab.label }}</el-button></div>
-        <SmartDispatchCargoBoard :aria-busy="candidatePage.loading.value || saving || preparing" :candidates="candidates" :draft="draft" :active-container-id="activeContainerId" :capacity="capacity" :disabled="frozen || loading" :warehouse-selected="Boolean(warehouseId)" :page="page" :size="size" :total="total"
+        <SmartDispatchCargoBoard :aria-busy="candidatePage.loading.value || saving || preparing" :candidates="candidates" :draft="draft" :active-container-id="activeContainerId" :capacity="capacity" :disabled="frozen || loading" :warehouse-selected="true" :add-vehicle-disabled="!vehicleWarehouse" :page="page" :size="size" :total="total"
          @add="addCargo" @select-container="activeContainerId = $event" @add-vehicle="addVehicle" @remove-cargo="(source, id) => draftAction('UNLOCK', source, id)" @remove-container="id => draftAction('DELETE', undefined, id)" @change-page="changePage" @change-size="changeSize">
+          <template #order-controls>
+        <div class="warehouse-tabs density-actions" role="tablist" aria-label="候选仓库展示"><el-button v-for="tab in ([{ value: 'ALL', label: '全部' }, { value: 'LAX', label: '洛杉矶' }, { value: 'NYC', label: '纽约' }] as const)" :key="tab.value" role="tab" :aria-selected="warehouseTab === tab.value" :class="{ active: warehouseTab === tab.value }" :type="warehouseTab === tab.value ? 'primary' : undefined" :disabled="frozen || loading || tabDisabled(tab.value)" @click="changeTab(tab.value)">{{ tab.label }}</el-button></div>
+          </template>
          <template #vehicle-controls>
            <label class="dispatch-capacity-field"><span>托位</span><el-select aria-label="下一辆车计划托位" class="dispatch-capacity-picker" v-model="capacity" :disabled="frozen || loading" placeholder="计划托位"><el-option label="30托位" :value="30" /><el-option label="15托位" :value="15" /></el-select></label>
          </template>
@@ -295,6 +312,20 @@ watch(() => props.modelValue, value => { if (value) void init(); else { generati
  </AppDialog>
 </template>
 <style scoped>
+/* In fullscreen, allocate the remaining body space to cargo instead of capping it at 390px. */
+:global(.smart-dispatch-dialog.is-fullscreen.is-cargo-workspace > .el-dialog__body) { display: flex; flex-direction: column; }
+:global(.smart-dispatch-dialog.is-fullscreen.is-cargo-workspace > .el-dialog__body > .app-dialog__body) { display: flex; flex-direction: column; flex: 1; }
+:global(.smart-dispatch-dialog.is-fullscreen.is-cargo-workspace .dispatch-workspace) { display: flex; flex-direction: column; flex: 1; min-height: 0; }
+:global(.smart-dispatch-dialog.is-fullscreen.is-cargo-workspace .dispatch-workspace > :not(.dispatch-cargo-board)) { flex-shrink: 0; }
+:global(.smart-dispatch-dialog.is-fullscreen.is-cargo-workspace .dispatch-cargo-board) { flex: 1; min-height: 280px; grid-template-rows: auto minmax(0, 1fr); }
+:global(.smart-dispatch-dialog.is-fullscreen.is-cargo-workspace .cargo-board-panel) { min-height: 0; }
+:global(.smart-dispatch-dialog.is-fullscreen.is-cargo-workspace .cargo-board-order-content) { align-self: stretch; display: flex; flex-direction: column; min-height: 0; }
+:global(.smart-dispatch-dialog.is-fullscreen.is-cargo-workspace .cargo-board-table-wrap) { flex: 1; min-height: 0; max-height: none; }
+:global(.smart-dispatch-dialog.is-fullscreen.is-cargo-workspace .cargo-board-pagination) { flex-shrink: 0; }
+:global(.smart-dispatch-dialog.is-fullscreen.is-cargo-workspace .cargo-board-pallet-list),
+:global(.smart-dispatch-dialog.is-fullscreen.is-cargo-workspace .cargo-board-vehicle-content) { min-height: 0; max-height: 100%; overflow-y: auto; }
+:global(.smart-dispatch-dialog.is-fullscreen.is-cargo-workspace .cargo-board-vehicle-list) { max-height: none; overflow: visible; }
+
 .dispatch-create-table { table-layout: fixed; }
 .dispatch-create-table td:not([colspan]) { width: 50%; }
 .dispatch-context-toolbar { display: flex; align-items: center; flex-wrap: wrap; gap: var(--admin-space-3) var(--admin-space-6); }
@@ -3,11 +3,11 @@ import { ApiResponseError } from '@/shared/api/http'
 import { useDispatchCommandRecovery } from './dispatchCommandRecovery'
 import { command } from './dispatchTestFixtures'
 beforeEach(() => sessionStorage.clear())
-it('does not accept an intermediate loading stage as completion of the original command', async () => {
+it('rejects a loading result that has not completed loading', async () => {
  const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
  recovery.begin('PC/1', 'LOADING_COMPLETE', { recordVersion: 0, idempotencyKey: 'key' })
  const read = vi.fn()
-  await expect(recovery.execute(vi.fn().mockResolvedValue({ ...command('LOADING_COMPLETE'), stage: 'AFTER_LOADING' }), read, vi.fn())).rejects.toThrow('派送中')
+  await expect(recovery.execute(vi.fn().mockResolvedValue({ ...command('LOADING_COMPLETE'), stage: 'LOADING' }), read, vi.fn())).rejects.toThrow('装车完成')
  expect(read).not.toHaveBeenCalled()
  expect(recovery.pending.value?.result).toBeNull()
  expect(recovery.pending.value?.body.idempotencyKey).toBe('key')
@@ -27,7 +27,7 @@ it('keeps a proven result across GET failure and does not send the command a sec
  recovery.begin('PC/1', 'LOADING_COMPLETE', { recordVersion: 0, idempotencyKey: 'key' })
  const send = vi.fn().mockResolvedValue(command('LOADING_COMPLETE')), read = vi.fn().mockRejectedValueOnce(new Error('read failed')).mockResolvedValueOnce({ dispatchNo: 'PC/1', recordVersion: 1 }), find = vi.fn()
  await expect(recovery.execute(send, read, find)).rejects.toThrow('read failed')
-  expect(recovery.pending.value?.result?.stage).toBe('DELIVERING')
+  expect(recovery.pending.value?.result?.stage).toBe('AFTER_LOADING')
  expect(JSON.parse(sessionStorage.getItem(`dispatch-command:${owner}`)!).result).toEqual(command('LOADING_COMPLETE'))
  const reopened = useDispatchCommandRecovery(() => owner)
  expect(reopened.pending.value?.result).toEqual(command('LOADING_COMPLETE'))
@@ -143,3 +143,14 @@ it('only rereads a restored proven result and keeps it when the detail read stil
  expect(send).not.toHaveBeenCalled(); expect(find).not.toHaveBeenCalled(); expect(read).toHaveBeenCalledTimes(2)
  expect(recovery.pending.value).toBeNull(); expect(sessionStorage.getItem(key)).toBeNull()
 })
+
+it('accepts a loading confirmation that already departed and recovers it without resubmitting', async () => {
+  const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
+  recovery.begin('PC/1', 'LOADING_COMPLETE', { recordVersion: 0, idempotencyKey: 'key' })
+  const send = vi.fn().mockResolvedValue({ ...command('LOADING_COMPLETE'), stage: 'DELIVERING', recordVersion: 3 })
+  const read = vi.fn().mockRejectedValueOnce(new Error('read failed')).mockResolvedValue({ dispatchNo: 'PC/1', recordVersion: 3 })
+  await expect(recovery.execute(send, read, vi.fn())).rejects.toThrow('read failed')
+  expect(recovery.pending.value?.result?.stage).toBe('DELIVERING')
+  await recovery.execute(send, read, vi.fn())
+  expect(send).toHaveBeenCalledTimes(1); expect(recovery.pending.value).toBeNull()
+})
@@ -15,7 +15,7 @@ export function validateCommandResult(result: CommandResult, pending: PendingDis
    || result.action !== pending.action || result.idempotencyKey !== pending.body.idempotencyKey
    || !result.dispatchNo || !result.result) throw new Error('操作结果与原排车请求不一致，请保留原请求核对')
  requireVersion(result.recordVersion)
-  if (pending.action === 'LOADING_COMPLETE' && result.stage !== 'DELIVERING') throw new Error('装车结果未确认派送中，请核对原请求')
+  if (pending.action === 'LOADING_COMPLETE' && !['AFTER_LOADING', 'DELIVERING'].includes(result.stage)) throw new Error('装车结果未确认装车完成，请核对原请求')
 }
 export function validateCurrentDispatch(value: unknown, result: CommandResult) {
  const current = value as { dispatchNo?: string; recordVersion?: unknown } | null
@@ -85,6 +85,7 @@ export type CommandResult = CommandBase & (

 export const dispatchStages: Array<{ value: DispatchStage; label: string }> = [
  { value: 'BEFORE_LOADING', label: '装车前' }, { value: 'LOADING', label: '装车中' },
+  { value: 'AFTER_LOADING', label: '装车后' },
  { value: 'DELIVERING', label: '派送中' }, { value: 'DELIVERED', label: '派送完成' },
 ]
 export const stageLabel = (stage: DispatchStage) => dispatchStages.find(row => row.value === stage)?.label || '—'
@@ -13,7 +13,7 @@ export function listRow(overrides: Partial<DispatchListRow> = {}): DispatchListR
 export function page(records = [listRow()]): DispatchPage { return { records, total: records.length, page: 1, size: 10, pages: 1, snapshotAt: '2026-10-19T10:00:00Z', statistics: { matchedTotal: 8, activeTotal: 7, cancelledTotal: 1, stageCounts: { BEFORE_LOADING: 3, LOADING: 1, AFTER_LOADING: 1, DELIVERING: 1, DELIVERED: 1 }, beforeLoadingReviewCounts: { vehicleInfoTotal: 3, dispatchReview: { notSubmitted: 1, pending: 1, approved: 1, rejected: 0 }, loadingReview: { notSubmitted: 2, pending: 0, approved: 1, rejected: 0 } } } } }
 export function candidate(overrides: Partial<Candidate> = {}): Candidate { const value = { selection: { sourceType: 'INBOUND_PLAN' as const, planPalletId: '11', returnReceiptId: null, relabelNo: null, warehousePalletId: '21', sourceVersion: 'source-hash' }, sourceKey: 'source-1', sourceVersion: 'source-hash', customerId: 'C1', customerName: '客户甲', warehouseId: '321', warehouseCode: 'LAX', warehouseName: '洛杉矶仓', orderNo: 'LM-1', inboundCode: 'IN-1', planNo: 'PLAN-1', palletNo: 'PALLET-1', containerNo: 'CSLU1234567', destination: destination(), availablePackages: 2, suggestedWeightKg: 100, suggestedVolumeCbm: 1, measurementSource: 'ORDER_SNAPSHOT_ALLOCATION', appointmentBatches: [], blockReasons: [], ...overrides }; return { ...value, selectionGroup: overrides.selectionGroup ?? { groupKey: value.sourceKey, groupVersion: 'group-version-1', complete: true, blockReasons: [], sources: [{ selection: value.selection, sourceKey: value.sourceKey, customerId: value.customerId, customerName: value.customerName, sourceBusinessType: value.selection.sourceType === 'RELABEL' ? 'RELABEL_ORDER' : null, sourceBusinessNo: value.selection.relabelNo, packages: value.availablePackages }], pallets: [{ warehousePalletId: value.selection.warehousePalletId, palletNo: value.palletNo, sourceKeys: [value.sourceKey], packageCount: value.availablePackages }] } } }
 export function command(action: CommandResult['action'], key = 'key', no = 'PC/1'): CommandResult {
-  const base = { dispatchNo: no, action, idempotencyKey: key, recordVersion: 1, status: 'ACTIVE' as const, stage: action === 'DEPART' ? 'DELIVERING' as const : action === 'LOADING_COMPLETE' ? 'DELIVERING' as const : 'BEFORE_LOADING' as const, occurredAt: '2026-10-19T10:00:00Z', effect: 'APPLIED' as const, counts: counts(), replayed: false, alreadyArranged: false }
+  const base = { dispatchNo: no, action, idempotencyKey: key, recordVersion: 1, status: 'ACTIVE' as const, stage: action === 'DEPART' ? 'DELIVERING' as const : action === 'LOADING_COMPLETE' ? 'AFTER_LOADING' as const : 'BEFORE_LOADING' as const, occurredAt: '2026-10-19T10:00:00Z', effect: 'APPLIED' as const, counts: counts(), replayed: false, alreadyArranged: false }
  return { ...base, result: action === 'DEPART' ? { departedAt: '2026-10-19T10:00:00Z', shippedPackages: 2, outbounds: [], deliveries: [] } : action === 'LOADING_COMPLETE' ? { loadingCompletionHash: 'load-hash', loadingCompletedAt: '2026-10-19T10:00:00Z', confirmedLoad: { manifestHash: 'manifest', pallets: [], operatorId: 'operator', confirmedAt: '2026-10-19T10:00:00Z' } } : { dispatchNo: no, changedItemIds: [] } } as CommandResult
 }
 export function loadingPreview(): LoadingPreview { return { dispatchNo: 'PC/1', recordVersion: 0, status: 'ACTIVE', stage: 'LOADING', manifestHash: 'manifest', pickingReconciled: true, resources: resources(), pallets: [{ warehousePalletId: '21', palletNo: 'PALLET-1', scheduledPackages: 2, pickedPackages: 2, palletSpaces: 1, weightKg: null, volumeCbm: null, deliveryIndex: 1, missingFields: ['weightKg', 'volumeCbm'], evidence: [{ field: 'weightKg', sourceType: 'ORDER_SNAPSHOT_ALLOCATION', sourceBusinessNo: 'IN-1', observedAt: null, value: 100, actual: false }] }], confirmedLoad: null, loadingComplete: { allowed: true, blockCode: null, blockReason: null }, missingFields: ['weightKg', 'volumeCbm'] } }
@@ -19,6 +19,28 @@ vi.mock('@/modules/overseas-master-data', async () => ({
 const options = { global: { plugins: [ElementPlus], stubs: { DataTable: DataTableStub, DispatchWorkflowDialog: true, TransportExecutionPanel: true } } }
 beforeEach(() => { vi.clearAllMocks(); vi.mocked(getDispatch).mockResolvedValue(detail()); can.mockReturnValue(false); push.mockReset(); Object.keys(query).forEach(key => delete query[key]) })
 describe('whole-dispatch four-tab detail', () => {
+  it.each(['omitted', 'null', 'invalid'] as const)('keeps schedule fields readable when exception records are %s and allows retry', async state => {
+    const value = detail()
+    if (state === 'omitted') Reflect.deleteProperty(value.dispatchInfo, 'exceptions')
+    else Reflect.set(value.dispatchInfo, 'exceptions', state === 'null' ? null : {})
+    vi.mocked(getDispatch).mockResolvedValueOnce(value)
+    const renderError = vi.fn()
+    const wrapper = mount(DispatchDetailView, { global: { ...options.global, config: { errorHandler: renderError } } })
+    await flushPromises()
+    await wrapper.get('#tab-dispatch').trigger('click'); await flushPromises()
+    expect(renderError).not.toHaveBeenCalled()
+    const pane = wrapper.get('#pane-dispatch')
+    expect(pane.isVisible()).toBe(true)
+    expect(pane.text()).toContain('LAX → ONT8')
+    expect(pane.text()).toContain('派送异常记录读取失败')
+    expect(pane.findAll('dt').map(field => field.text())).toEqual(['路线', '发车时间', '预计到达时间', 'FBA预约'])
+    expect(pane.find('[aria-label="派送异常记录"]').exists()).toBe(false)
+    await pane.get('button').trigger('click'); await flushPromises()
+    expect(getDispatch).toHaveBeenCalledTimes(2)
+    expect(wrapper.get('#pane-dispatch').isVisible()).toBe(true)
+    expect(wrapper.get('#pane-dispatch').text()).not.toContain('派送异常记录读取失败')
+    wrapper.unmount()
+  })
  it('shows saved review attachments beside resource evidence without providing upload controls', async () => {
    const value = detail(); value.vehicleInfo.vehicle!.evidenceFileIds = ['301']
    value.reviews.dispatchReview.attachments = { vehicleFileIds: ['301', '302'], driverPhotoFileIds: ['303'], licenseFileIds: [] }
@@ -60,6 +82,29 @@ describe('whole-dispatch four-tab detail', () => {
    expect(wrapper.findAll('[role="tab"]')).toHaveLength(0)
    expect(wrapper.find('[aria-label="排车操作"]').exists()).toBe(false); wrapper.unmount()
  })
+  it('keeps detail tabs read-only when return-to-review is available from the list', async () => {
+    can.mockReturnValue(true)
+    vi.mocked(getDispatch).mockResolvedValueOnce(detail({ stage: 'LOADING', actions: { RETURN_TO_REVIEW: { allowed: true, blockCode: null, blockReason: null } } }))
+    const wrapper = mount(DispatchDetailView, options); await flushPromises()
+    await wrapper.findAll('[role="tab"]')[1]!.trigger('click'); await flushPromises()
+    expect(wrapper.find('footer[aria-label="排车操作"]').exists()).toBe(false)
+    expect(wrapper.findAll('button').map(button => button.text())).not.toContain('退回装车前重审')
+    expect(wrapper.findComponent({ name: 'DispatchWorkflowDialog' }).exists()).toBe(false)
+    wrapper.unmount()
+  })
+  it('keeps dispatch labels and placeholders visible when no schedule or appointments are recorded', async () => {
+    const value = detail()
+    value.dispatchInfo = { ...value.dispatchInfo, route: null, fbaAppointments: [] }
+    vi.mocked(getDispatch).mockResolvedValueOnce(value)
+    const wrapper = mount(DispatchDetailView, options); await flushPromises()
+    for (const name of ['dispatch', 'documents', 'vehicle', 'dispatch']) {
+      await wrapper.get(`#tab-${name}`).trigger('click'); await flushPromises()
+      expect(wrapper.get(`#pane-${name}`).isVisible()).toBe(true)
+    }
+    expect(wrapper.get('#pane-dispatch').findAll('dd').map(field => field.text())).toEqual(['—', '—', '—', '—'])
+    expect(wrapper.find('[aria-label="排车操作"]').exists()).toBe(false)
+    wrapper.unmount()
+  })
  it('returns to the original appointment date and view from the dispatch detail', async () => {
    query.appointmentReturn = '/appointment-calendar?date=2026-10-21&mode=week'
    const wrapper = mount(DispatchDetailView, options); await flushPromises()
@@ -86,6 +131,8 @@ describe('whole-dispatch four-tab detail', () => {
    await tabs[1]!.trigger('click'); await flushPromises()
    expect(tabs[1]!.attributes('aria-selected')).toBe('true')
    const dispatchInfo = wrapper.get(`#${tabs[1]!.attributes('aria-controls')}`)
+    expect(dispatchInfo.isVisible()).toBe(true)
+    expect(dispatchInfo.get('dl').isVisible()).toBe(true)
    expect(dispatchInfo.text()).toContain('LAX → ONT8'); expect(dispatchInfo.text()).toContain('FBA预约'); expect(dispatchInfo.text()).toContain('ONT8 · FBA-AP-1 · CONFIRMED')
    expect(dispatchInfo.findAll('dt').map(field => field.text())).toEqual(['路线', '发车时间', '预计到达时间', 'FBA预约'])
    expect(getDispatch).toHaveBeenCalledTimes(1); expect(wrapper.text()).toContain('装车前'); wrapper.unmount()
@@ -76,9 +76,11 @@ onBeforeUnmount(() => { generation++ })
    <div v-else v-loading="loading" class="dispatch-detail" :aria-busy="loading">
      <TransportExecutionPanel v-if="detail?.taskType && detail.taskType !== 'DELIVERY'" readonly :dispatch-no="dispatchNo" :pickup-approved="detail.reviewState === 'APPROVED'" :pickup-review-state="detail.reviewState" />
      <el-alert v-if="dispatchRejectionReason(detail?.reviews)" title="已退回客服处理（车辆信息），请核对原因后重新提交调度审核。" :description="dispatchRejectionReason(detail?.reviews)" type="warning" :closable="false" show-icon />
-      <el-tabs v-if="!detail?.taskType || detail.taskType === 'DELIVERY'" v-model="activeTab" class="density-element-tabs density-contained-tabs">
-        <el-tab-pane name="vehicle"><template #label><span class="density-tab-icon" aria-hidden="true">🚚</span><span>车辆信息</span></template><dl class="detail-fields density-fields"><div v-for="field in vehicleFields" :key="field[0]"><dt>{{ field[0] }}</dt><dd>{{ field[1] }}</dd></div></dl><DispatchEvidenceFiles v-for="field in dispatchReviewAttachmentFields" :key="field.key" :model-value="reviewEvidence[field.key]" :dispatch-no="dispatchNo" :kind="field.kind" :label="field.label" readonly /></el-tab-pane>
-        <el-tab-pane name="dispatch"><template #label><span class="density-tab-icon" aria-hidden="true">📋</span><span>排车信息</span></template><dl class="detail-fields density-fields"><div v-for="field in dispatchFields" :key="field[0]"><dt>{{ field[0] }}</dt><dd>{{ field[1] }}</dd></div></dl><section v-if="detail && detail.dispatchInfo.exceptions.length" class="detail-section" aria-label="派送异常记录">
+      <el-tabs v-if="!detail?.taskType || detail.taskType === 'DELIVERY'" v-model="activeTab" class="density-element-tabs density-contained-tabs density-contained-tabs--flush">
+        <el-tab-pane name="vehicle"><template #label><span class="density-tab-icon" aria-hidden="true">🚚</span><span>车辆信息</span></template><dl class="detail-fields density-fields vehicle-fields"><div v-for="field in vehicleFields" :key="field[0]"><dt>{{ field[0] }}</dt><dd>{{ field[1] }}</dd></div></dl><DispatchEvidenceFiles v-for="field in dispatchReviewAttachmentFields" :key="field.key" :model-value="reviewEvidence[field.key]" :dispatch-no="dispatchNo" :kind="field.kind" :label="field.label" readonly /></el-tab-pane>
+        <el-tab-pane name="dispatch"><template #label><span class="density-tab-icon" aria-hidden="true">📋</span><span>排车信息</span></template><dl class="detail-fields density-fields"><div v-for="field in dispatchFields" :key="field[0]"><dt>{{ field[0] }}</dt><dd>{{ field[1] }}</dd></div></dl>
+        <LoadErrorState v-if="detail && !Array.isArray(detail.dispatchInfo.exceptions)" compact title="派送异常记录读取失败" message="排车详情返回的异常记录不完整，请重新加载。" :loading="loading" @retry="load" />
+        <section v-else-if="detail && detail.dispatchInfo.exceptions.length" class="detail-section" aria-label="派送异常记录">
          <h3>派送异常记录</h3>
          <article v-for="(record, index) in detail.dispatchInfo.exceptions" :key="index">
            <dl class="density-fields"><div class="density-field"><dt>异常类型</dt><dd>{{ dispatchExceptionLabels[record.exceptionType] }}</dd></div><div class="density-field"><dt>登记时间</dt><dd>{{ time(record.occurredAt) }}</dd></div><div class="density-field"><dt>退货去向</dt><dd>{{ record.returnDirection ? dispatchReturnDirectionLabels[record.returnDirection] : '—' }}</dd></div><div class="density-field"><dt>异常说明</dt><dd>{{ record.description || '—' }}</dd></div></dl>
@@ -86,7 +88,7 @@ onBeforeUnmount(() => { generation++ })
          </article>
        </section></el-tab-pane>
        <el-tab-pane name="documents"><template #label><span class="density-tab-icon" aria-hidden="true">📝</span><span>单据信息</span></template>
-          <dl class="detail-fields density-fields"><div v-for="field in documentFields" :key="field[0]"><dt>{{ field[0] }}</dt><dd>{{ field[1] }}</dd></div><div class="linked-documents"><dt>关联派送单</dt><dd><template v-for="delivery in detail?.documents.deliveries || []" :key="delivery.deliveryNo"><el-button v-if="access.can(permission.deliveryList)" link type="primary" @click="router.push({ name: 'overseas-delivery-order-detail', params: { deliveryNo: delivery.deliveryNo } })">{{ delivery.deliveryNo }}</el-button><span v-else>{{ text(delivery.deliveryNo) }}</span></template><span v-if="!detail?.documents.deliveries.length">—</span></dd></div></dl>
+          <dl class="detail-fields density-fields"><div v-for="field in documentFields" :key="field[0]"><dt>{{ field[0] }}</dt><dd>{{ field[1] }}</dd></div><div class="linked-documents"><dt>关联派送单</dt><dd><template v-for="delivery in detail?.documents.deliveries || []" :key="delivery.deliveryNo"><el-button v-if="access.can(permission.deliveryList)" link type="primary" @click="router.push({ name: 'overseas-delivery-order-detail', params: { deliveryNo: delivery.deliveryNo }, query: { customerId: delivery.customerId } })">{{ delivery.deliveryNo }}</el-button><span v-else>{{ text(delivery.deliveryNo) }}</span></template><span v-if="!detail?.documents.deliveries.length">—</span></dd></div></dl>
          <div class="density-actions"><el-button v-for="outbound in detail?.documents.outbounds || []" v-show="access.can(permission.outboundList)" :key="outbound.outboundNo" link @click="router.push({ name: 'overseas-outbounds', query: { documentNo: outbound.outboundNo } })">查看出库 {{ outbound.outboundNo }}</el-button></div>
        </el-tab-pane>
        <el-tab-pane name="orders"><template #label><span class="density-tab-icon" aria-hidden="true">📦</span><span>关联订单明细</span></template><div class="workbench-table"><DataTable :data="relatedOrders" :columns="orderColumns" column-settings-mode="hide" row-key="sourceKey" empty-text="暂无关联订单明细" /></div></el-tab-pane>
@@ -97,7 +99,9 @@ onBeforeUnmount(() => { generation++ })

 <style scoped>
 .dispatch-detail { min-width: 0; min-height: 0; }
+.dispatch-detail .vehicle-fields { grid-template-columns: minmax(0, 1.3fr) minmax(0, 1.6fr) minmax(0, 1.2fr) minmax(0, 1.5fr) minmax(0, 0.8fr); }
+.dispatch-detail .vehicle-fields > div { grid-template-columns: max-content minmax(0, 1fr); }
 .linked-documents { grid-column: 1 / -1; }
 .linked-documents dd { display: flex; flex-wrap: wrap; gap: var(--admin-space-4); overflow-wrap: anywhere; }
-@media (max-width: 960px) { .detail-fields { grid-template-columns: 1fr; } .detail-fields > div { grid-template-columns: 132px minmax(0, 1fr); } }
+@media (max-width: 960px) { .dispatch-detail .detail-fields { grid-template-columns: 1fr; } .dispatch-detail .detail-fields > div { grid-template-columns: 132px minmax(0, 1fr); } }
 </style>
@@ -1,9 +1,10 @@
 import { createPinia } from 'pinia'
-import ElementPlus, { ElMessageBox } from 'element-plus'
+import ElementPlus, { ElMessageBox, ElSelect, ElTag } from 'element-plus'
 import { flushPromises, mount } from '@vue/test-utils'
 import { beforeEach, expect, it, vi } from 'vitest'
 import DispatchesView from './DispatchesView.vue'
 import QueryToolbar from '@/shared/components/QueryToolbar.vue'
+import DataTable from '@/shared/components/DataTable.vue'
 import RowActions from '@/shared/components/RowActions.vue'
 import { getDispatch, getDispatchBolPdf, listDispatches } from '../api/dispatches'
 import { cancelTransport, getTransport } from '../api/transportTasks'
@@ -79,7 +80,7 @@ it('never offers a second arrangement or departure after loading completion', as
  const gate = { allowed: true, blockCode: null, blockReason: null }
  vi.mocked(listDispatches).mockResolvedValueOnce(page([listRow({ stage: 'DELIVERING', actions: { ARRANGE_DELIVERY: gate, DEPART: gate } })]))
  const wrapper = mount(DispatchesView, options); await flushPromises()
-  expect(wrapper.findAll('[role="tab"]').some(tab => tab.text().startsWith('装车后'))).toBe(false)
+  expect(wrapper.findAll('[role="tab"]').some(tab => tab.text().startsWith('装车后'))).toBe(true)
  const row = wrapper.findAllComponents(RowActions).find(entry => entry.props('moreLabel') === '更多操作 · PC/1')!
  const keys = (row.props('actions') as Array<{ key: string }>).map(action => action.key)
  expect(keys).not.toContain('ARRANGE_DELIVERY'); expect(keys).not.toContain('DEPART')
@@ -87,6 +88,22 @@ it('never offers a second arrangement or departure after loading completion', as
  expect(wrapper.getComponent({ name: 'DispatchWorkflowDialog' }).props('modelValue')).toBe(false)
  wrapper.unmount()
 })
+it('keeps return-to-review on the loading list with its service gate and permission', async () => {
+  const allowed = { allowed: true, blockCode: null, blockReason: null }
+  vi.mocked(listDispatches).mockResolvedValue(page([listRow({ stage: 'LOADING', actions: { RETURN_TO_REVIEW: allowed } })]))
+  const wrapper = mount(DispatchesView, options); await flushPromises()
+  const row = wrapper.findAllComponents(RowActions).find(entry => entry.props('moreLabel') === '更多操作 · PC/1')!
+  expect(row.props('actions')).toEqual(expect.arrayContaining([expect.objectContaining({ key: 'RETURN_TO_REVIEW' })]))
+  row.vm.$emit('action', 'RETURN_TO_REVIEW'); await flushPromises()
+  expect(wrapper.getComponent({ name: 'DispatchWorkflowDialog' }).props()).toMatchObject({ modelValue: true, action: 'RETURN_TO_REVIEW', dispatchNo: 'PC/1' })
+  wrapper.unmount(); can.mockReturnValue(false)
+  const denied = mount(DispatchesView, options); await flushPromises()
+  const deniedRow = denied.findAllComponents(RowActions).find(entry => entry.props('moreLabel') === '更多操作 · PC/1')!
+  expect(deniedRow.props('actions').map((item: { key: string }) => item.key)).not.toContain('RETURN_TO_REVIEW')
+  deniedRow.vm.$emit('action', 'RETURN_TO_REVIEW'); await flushPromises()
+  expect(denied.getComponent({ name: 'DispatchWorkflowDialog' }).props('modelValue')).toBe(false)
+  denied.unmount()
+})
 it('offers recovery of the original pending command independently of the filtered list rows', async () => {
  const pending = useDispatchCommandRecovery(() => identity.id); pending.begin('PC-OTHER', 'LOADING_COMPLETE', { recordVersion: 0, idempotencyKey: 'original-key' })
  const wrapper = mount(DispatchesView, options); await flushPromises()
@@ -156,15 +173,126 @@ it.each([1, 2])('keeps only details in audit tab %s without its review permissio
  expect((row.props('actions') as Array<{ key: string }>).map(item => item.key)).toEqual(['detail'])
  wrapper.unmount()
 })
-it('shows four working phases and uses server stage counts instead of current page length', async () => {
+it('shows five working phases and uses server stage counts instead of current page length', async () => {
  const wrapper = mount(DispatchesView, options); await flushPromises()
  const tabs = wrapper.get('.data-table__toolbar-start .workbench-list-tabs[aria-label="排车执行阶段"]').findAll('button')
  expect(wrapper.find('.data-table__filters [aria-label="装车前审核分区"]').exists()).toBe(true)
-  expect(tabs.map(tab => tab.text())).toEqual(['装车前 3', '装车中 1', '派送中 1', '派送完成 1'])
+  expect(tabs.map(tab => tab.text())).toEqual(['装车前 3', '装车中 1', '装车后 1', '派送中 1', '派送完成 1'])
  expect(listDispatches).toHaveBeenCalledWith(expect.objectContaining({ stage: 'BEFORE_LOADING', status: 'ACTIVE', beforeLoadingSection: 'VEHICLE_INFO' }))
-  await tabs[2]!.trigger('click'); await flushPromises()
+  await tabs[3]!.trigger('click'); await flushPromises()
  expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ stage: 'DELIVERING' })); expect(wrapper.find('[aria-label="装车前审核分区"]').exists()).toBe(false); wrapper.unmount()
 })
+it.each([0, 1, 2])('preserves section %s and its query after clearing the active dispatch filter', async index => {
+  const wrapper = mount(DispatchesView, options); await flushPromises()
+  const sectionValues = ['VEHICLE_INFO', 'DISPATCH_REVIEW', 'LOADING_REVIEW']
+  const sectionSelector = '[aria-label="装车前审核分区"]'
+  await wrapper.get(sectionSelector).findAll('button')[index]!.trigger('click'); await flushPromises()
+  const toolbar = wrapper.getComponent(QueryToolbar)
+  await toolbar.findAll('button').find(button => button.text() === '高级筛选')!.trigger('click')
+  toolbar.findAllComponents(ElSelect).find(select => select.props('placeholder') === '单据范围')!.vm.$emit('update:modelValue', '')
+  await flushPromises()
+  expect(wrapper.get(sectionSelector).findAll('button').map(button => button.text())).toEqual(['车辆信息', '调度审核', '理货员审核'])
+  expect(wrapper.get(sectionSelector).findAll('button')[index]!.attributes('aria-selected')).toBe('true')
+  await toolbar.findAll('button').find(button => button.text() === '查询')!.trigger('click'); await flushPromises()
+  expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ status: 'ACTIVE', beforeLoadingSection: sectionValues[index] }))
+  const nextIndex = (index + 1) % 3
+  await wrapper.get(sectionSelector).findAll('button')[nextIndex]!.trigger('click'); await flushPromises()
+  expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ status: 'ACTIVE', beforeLoadingSection: sectionValues[nextIndex] }))
+  await toolbar.findAll('button').find(button => button.text() === '重置')!.trigger('click'); await flushPromises()
+  expect(wrapper.get(sectionSelector).findAll('button')).toHaveLength(3)
+  expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ status: 'ACTIVE', beforeLoadingSection: sectionValues[nextIndex] }))
+  await wrapper.get('[aria-label="排车执行阶段"]').findAll('button')[1]!.trigger('click'); await flushPromises()
+  expect(wrapper.find(sectionSelector).exists()).toBe(false)
+  expect(vi.mocked(listDispatches).mock.calls.at(-1)?.[0]).not.toHaveProperty('beforeLoadingSection')
+  wrapper.unmount()
+})
+it.each([
+  ['WAIT_DEPARTURE', 'BEFORE_LOADING', '装车前'],
+  ['DELIVERING', 'DELIVERING', '派送中'],
+  ['DELIVERED', 'DELIVERED', '派送完成'],
+] as const)('queries %s through server pagination and selects the corresponding stage', async (vehicleStatus, stage, label) => {
+  const wrapper = mount(DispatchesView, options); await flushPromises()
+  await wrapper.get('[aria-label="排车执行阶段"]').findAll('button')[3]!.trigger('click'); await flushPromises()
+  const table = wrapper.getComponent(DataTable)
+  table.vm.$emit('update:page', 3); await flushPromises()
+  const result = { ...page([listRow({ stage })]), total: 21, pages: 3 }
+  vi.mocked(listDispatches).mockResolvedValueOnce(result)
+  const toolbar = wrapper.getComponent(QueryToolbar)
+  const select = toolbar.findAllComponents(ElSelect).find(item => item.props('placeholder') === '车辆状态')!
+  select.vm.$emit('update:modelValue', vehicleStatus); select.vm.$emit('change', vehicleStatus); await flushPromises()
+  await toolbar.findAll('button').find(button => button.text() === '查询')!.trigger('click'); await flushPromises()
+  expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ page: 1, size: 10, stage, status: 'ACTIVE' }))
+  expect(vi.mocked(listDispatches).mock.calls.at(-1)?.[0]).not.toHaveProperty('vehicleStatus')
+  expect(wrapper.get('[aria-label="排车执行阶段"] [aria-selected="true"]').text()).toContain(label)
+  expect(table.props('total')).toBe(21)
+  expect(table.props('data')).toEqual(result.records)
+  expect(wrapper.find('[aria-label="装车前审核分区"]').exists()).toBe(stage === 'BEFORE_LOADING')
+  wrapper.unmount()
+})
+it('keeps waiting vehicles in the current loading phase and synchronizes an active status when changing phases', async () => {
+  const wrapper = mount(DispatchesView, options); await flushPromises()
+  const tabs = wrapper.get('[aria-label="排车执行阶段"]').findAll('button')
+  await tabs[1]!.trigger('click'); await flushPromises()
+  const toolbar = wrapper.getComponent(QueryToolbar)
+  toolbar.vm.$emit('search', { vehicleStatus: 'WAIT_DEPARTURE', status: 'ACTIVE' }); await flushPromises()
+  expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ stage: 'LOADING' }))
+  expect(vi.mocked(listDispatches).mock.calls.at(-1)?.[0]).not.toHaveProperty('beforeLoadingSection')
+  await tabs[3]!.trigger('click'); await flushPromises()
+  expect(toolbar.props('modelValue').vehicleStatus).toBe('DELIVERING')
+  await tabs[0]!.trigger('click'); await flushPromises()
+  expect(toolbar.props('modelValue').vehicleStatus).toBe('WAIT_DEPARTURE')
+  wrapper.unmount()
+})
+it('shows trip progress independently of master vehicle status and leaves cancelled vehicles without progress', async () => {
+  const records = [
+    listRow({ dispatchNo: 'PC-WAIT', stage: 'BEFORE_LOADING' }),
+    listRow({ dispatchNo: 'PC-LOADING', stage: 'LOADING' }),
+    listRow({ dispatchNo: 'PC-DELIVERING', stage: 'DELIVERING' }),
+    listRow({ dispatchNo: 'PC-DELIVERED', stage: 'DELIVERED' }),
+    listRow({ dispatchNo: 'PC-CANCELLED', status: 'CANCELLED' }),
+  ]
+  for (const row of records) row.resources.vehicle!.vehicleStatus = 'MAINTENANCE'
+  vi.mocked(listDispatches).mockResolvedValueOnce(page(records))
+  const wrapper = mount(DispatchesView, options); await flushPromises()
+  const toolbar = wrapper.getComponent(QueryToolbar)
+  expect(toolbar.props('fields').map(field => field.key)).toEqual(['dispatchNo', 'vehiclePlate', 'vehicleStatus'])
+  expect(toolbar.props('fields').find(field => field.key === 'vehicleStatus')?.options?.map(option => option.label)).toEqual(['待发车', '配送中', '已送达'])
+  expect(wrapper.getComponent(DataTable).props('columns').some(column => column.key === 'vehicleStatus' && column.label === '车辆状态')).toBe(true)
+  expect(wrapper.findAllComponents(ElTag).map(tag => tag.text())).toEqual(['待发车', '待发车', '配送中', '已送达'])
+  expect(wrapper.text()).toContain('已取消')
+  expect(wrapper.text()).not.toContain('维修中')
+  wrapper.unmount()
+})
+it.each(['CANCELLED', 'ALL'])('retains advanced %s lookup and resets its hidden value', async status => {
+  const wrapper = mount(DispatchesView, options); await flushPromises()
+  const toolbar = wrapper.getComponent(QueryToolbar)
+  toolbar.vm.$emit('search', { status: 'ACTIVE', vehicleStatus: 'WAIT_DEPARTURE' }); await flushPromises()
+  await toolbar.findAll('button').find(button => button.text() === '高级筛选')!.trigger('click')
+  const select = toolbar.findAllComponents(ElSelect).find(item => item.props('placeholder') === '单据范围')!
+  select.vm.$emit('update:modelValue', status); select.vm.$emit('change', status); await flushPromises()
+  await toolbar.findAll('button').find(button => button.text() === '查询')!.trigger('click'); await flushPromises()
+  expect(toolbar.props('modelValue').vehicleStatus).toBe('')
+  expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ status }))
+  expect(vi.mocked(listDispatches).mock.calls.at(-1)?.[0]).not.toHaveProperty('beforeLoadingSection')
+  await toolbar.findAll('button').find(button => button.text().startsWith('收起筛选'))!.trigger('click')
+  expect(toolbar.props('fields').some(field => field.key === 'status')).toBe(false)
+  expect(toolbar.text()).toContain(status === 'CANCELLED' ? '高级筛选 · 已取消' : '高级筛选 · 全部单据')
+  await toolbar.findAll('button').find(button => button.text() === '重置')!.trigger('click'); await flushPromises()
+  expect(toolbar.props('modelValue')).toMatchObject({ status: 'ACTIVE', vehicleStatus: '' })
+  expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ page: 1, status: 'ACTIVE', beforeLoadingSection: 'VEHICLE_INFO' }))
+  wrapper.unmount()
+})
+it('returns to active dispatches when selecting vehicle progress from cancelled lookup', async () => {
+  const wrapper = mount(DispatchesView, options); await flushPromises()
+  const toolbar = wrapper.getComponent(QueryToolbar)
+  toolbar.vm.$emit('search', { status: 'CANCELLED', vehicleStatus: '' }); await flushPromises()
+  const select = toolbar.findAllComponents(ElSelect).find(item => item.props('placeholder') === '车辆状态')!
+  select.vm.$emit('update:modelValue', 'DELIVERING'); select.vm.$emit('change', 'DELIVERING'); await flushPromises()
+  await toolbar.findAll('button').find(button => button.text() === '查询')!.trigger('click'); await flushPromises()
+  expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ status: 'ACTIVE', stage: 'DELIVERING' }))
+  expect(toolbar.props('modelValue')).toMatchObject({ status: 'ACTIVE', vehicleStatus: 'DELIVERING' })
+  wrapper.unmount()
+})
 it('queries the current review queue without offering historical result filters', async () => {
  const wrapper = mount(DispatchesView, options); await flushPromises()
  await wrapper.get('[aria-label="装车前审核分区"]').findAll('button')[1]!.trigger('click'); await flushPromises()
@@ -27,6 +27,7 @@ import TransportExecutionPanel from '../components/TransportExecutionPanel.vue'
 import { cancelTransport, getTransport, transportLabels, type TransportType } from '../api/transportTasks'
 import SmartDispatchDialog from '../components/SmartDispatchDialog.vue'
 import DispatchWorkflowDialog from '../components/DispatchWorkflowDialog.vue'
+import DispatchDocumentsDialog from '../components/DispatchDocumentsDialog.vue'
 import { useDispatchCommandRecovery } from '../dispatchCommandRecovery'

 const route = useRoute(), router = useRouter(), access = useAccessPreviewStore()
@@ -40,26 +41,40 @@ const transportEditTitle = ref('维护取货车辆信息'), transportResourceMod
 const activeTransport = computed(() => rows.value.find(row => row.dispatchNo === transportEditNo.value))
 const cancellingPickup = ref('')
 function createTransport(type: TransportType) { transportType.value = type; transportOpen.value = true }
+const documentsOpen = ref(false), documentsNo = ref('')
 const page = ref(1)
 const pageSize = ref(10)
 const total = ref(0)
 const stage = ref<DispatchStage>('BEFORE_LOADING'), section = ref<BeforeLoadingSection>('VEHICLE_INFO')
-const model = ref<QueryModel>({ dispatchNo: String(route.query.dispatchNo || ''), vehiclePlate: '', status: 'ACTIVE' })
+const model = ref<QueryModel>({ dispatchNo: String(route.query.dispatchNo || ''), vehiclePlate: '', vehicleStatus: '', status: 'ACTIVE' })
+const showAdvancedFilters = ref(false)
+const vehicleStatuses = [
+  { value: 'WAIT_DEPARTURE', label: '待发车', type: 'warning' },
+  { value: 'DELIVERING', label: '配送中', type: 'primary' },
+  { value: 'DELIVERED', label: '已送达', type: 'success' },
+] as const
+function vehicleStatusForStage(value: DispatchStage) {
+  if (value === 'BEFORE_LOADING' || value === 'LOADING' || value === 'AFTER_LOADING') return vehicleStatuses[0]
+  return vehicleStatuses.find(item => item.value === value)
+}
 const operation = ref<'ROUTE' | undefined>()
 const action = ref<DispatchAction>('EDIT'), actionNo = ref(''), actionOpen = ref(false), createOpen = ref(false), bolLoadingNo = ref('')
 const routeOpen = ref(false), routeOrigin = ref<RouteLocation>(routeLocation('')), routeDestinations = ref<RouteLocation[]>([])
 const sections: Array<{ value: BeforeLoadingSection; label: string }> = [{ value: 'VEHICLE_INFO', label: '车辆信息' }, { value: 'DISPATCH_REVIEW', label: '调度审核' }, { value: 'LOADING_REVIEW', label: '理货员审核' }]
-const showSections = computed(() => stage.value === 'BEFORE_LOADING' && model.value.status === 'ACTIVE')
-const fields = computed<QueryField[]>(() => [
+const showSections = computed(() => stage.value === 'BEFORE_LOADING' && (model.value.status || 'ACTIVE') === 'ACTIVE')
+const availableFields = computed<QueryField[]>(() => [
  { key: 'dispatchNo', label: '排车单号', type: 'input', width: 180, placeholder: '请输入排车单号' },
  { key: 'vehiclePlate', label: '车牌号', type: 'input', width: 150, placeholder: '请输入车牌号' },
-  { key: 'status', label: '单据范围', type: 'select', width: 140, options: [{ value: 'ACTIVE', label: '有效排车' }, { value: 'CANCELLED', label: '已取消' }, { value: 'ALL', label: '全部单据' }] },
+  { key: 'vehicleStatus', label: '车辆状态', placeholder: '车辆状态', type: 'select', width: 140, options: [...vehicleStatuses], props: { 'aria-label': '车辆状态', onChange: (value: unknown) => { if (value) model.value.status = 'ACTIVE' } } },
+  { key: 'status', label: '单据范围', placeholder: '单据范围', type: 'select', width: 140, options: [{ value: 'ACTIVE', label: '有效排车' }, { value: 'CANCELLED', label: '已取消' }, { value: 'ALL', label: '全部单据' }], props: { 'aria-label': '单据范围', onChange: (value: unknown) => { if (value && value !== 'ACTIVE') model.value.vehicleStatus = '' } } },
 ])
+const fields = computed(() => availableFields.value.filter(field => showAdvancedFilters.value || field.key !== 'status'))
 const columns = computed<DataTableColumn[]>(() => [
  { key: 'actions', label: '操作', width: rows.value.some(row => row.taskType === 'PICKUP') ? 330 : 220, fixed: 'left', slotName: 'actions' },
  { key: 'taskType', label: '排车类型', width: 115, slotName: 'taskType' },
  { key: 'dispatchNo', prop: 'dispatchNo', label: '排车单号', minWidth: 190 },
  { key: 'vehicle', label: '车牌号', minWidth: 130, slotName: 'vehicle' }, { key: 'driver', label: '司机／联系电话', minWidth: 170, slotName: 'driver' },
+  { key: 'vehicleStatus', label: '车辆状态', minWidth: 110, slotName: 'vehicleStatus' },
  { key: 'warehouseName', prop: 'warehouseName', label: '起运仓', minWidth: 160 },
  ...(showSections.value && section.value === 'VEHICLE_INFO' ? [{ key: 'returnReason', label: '退回原因', minWidth: 240, slotName: 'returnReason' }] : []),
  ...(showSections.value && section.value !== 'VEHICLE_INFO' ? [{ key: 'review', label: section.value === 'DISPATCH_REVIEW' ? '调度审核' : '理货员审核', minWidth: 210, slotName: 'review' }] : []),
@@ -80,11 +95,27 @@ async function load() {
  } catch (cause) { if (current === sequence) { rows.value = []; total.value = 0; statistics.value = null; loadError.value = getApiErrorDetails(cause, '排车列表加载失败，请重试') } }
  finally { if (current === sequence) loading.value = false }
 }
-function search(value: QueryModel) { model.value = value; page.value = 1; void load() }
-function switchStage(value: DispatchStage) { stage.value = value; section.value = 'VEHICLE_INFO'; page.value = 1; void load() }
+function search(value: QueryModel) {
+  model.value = { ...value, status: value.status || 'ACTIVE' }
+  const selected = vehicleStatuses.find(item => item.value === model.value.vehicleStatus)
+  if (model.value.status !== 'ACTIVE') model.value.vehicleStatus = ''
+  else if (selected && vehicleStatusForStage(stage.value)?.value !== selected.value) {
+    // 车辆运输进度与阶段联动，查询仍由服务端按阶段分页，避免交叉条件恒为空。
+    stage.value = selected.value === 'WAIT_DEPARTURE' ? 'BEFORE_LOADING' : selected.value
+    section.value = 'VEHICLE_INFO'
+  }
+  page.value = 1; void load()
+}
+function resetSearch() { search({ dispatchNo: '', vehiclePlate: '', vehicleStatus: '', status: 'ACTIVE' }) }
+function switchStage(value: DispatchStage) {
+  stage.value = value
+  if (model.value.vehicleStatus) model.value.vehicleStatus = vehicleStatusForStage(value)?.value || ''
+  section.value = 'VEHICLE_INFO'; page.value = 1; void load()
+}
 function switchSection(value: BeforeLoadingSection) { section.value = value; page.value = 1; void load() }
 function openDetail(row: DispatchListRow) { void router.push({ name: 'overseas-dispatch-detail', params: { dispatchNo: row.dispatchNo } }) }
 const rowActionOrder: DispatchAction[] = ['EDIT', 'SUBMIT_REVIEW', 'DISPATCH_REVIEW', 'LOADING_REVIEW', 'RETURN_TO_REVIEW', 'LOADING_COMPLETE', 'MARK_EXCEPTION', 'CANCEL']
+function canManageDocuments(row: DispatchListRow) { return (row.taskType || 'DELIVERY') === 'DELIVERY' && row.status === 'ACTIVE' && ['LOADING', 'AFTER_LOADING', 'DELIVERING', 'DELIVERED'].includes(row.stage) }
 function rowActions(row: DispatchListRow): RowActionItem[] {
  if (showSections.value && section.value !== 'VEHICLE_INFO') {
    const review = section.value
@@ -94,7 +125,7 @@ function rowActions(row: DispatchListRow): RowActionItem[] {
  const available = rowActionOrder.filter(value => canDispatchAction(row.actions, value, access.can))
  const primaryAction = available.find(value => value === 'EDIT') ?? available[0]
  const execution = pickupExecutionLabel(row)
-  return [...(execution ? [{ key: 'transport', label: execution, priority: 650 }] : []), ...available.map((value, index) => ({
+  return [...(execution ? [{ key: 'transport', label: execution, priority: 650 }] : []), ...(canManageDocuments(row) ? [{ key: 'documents', label: '管理资料', priority: 700 }] : []), ...available.map((value, index) => ({
    key: value,
    label: dispatchActionLabels[value],
    ariaLabel: dispatchActionLabels[value],
@@ -119,6 +150,7 @@ function handleAction(value: string, row: DispatchListRow) {
  if (value === 'detail') return openDetail(row)
  if (showSections.value && section.value !== 'VEHICLE_INFO' && value !== section.value) return
  if (value === 'transport') { if (rowActions(row).some(item => item.key === value)) openTransport(row); return }
+  if (value === 'documents') { if (canManageDocuments(row)) { documentsNo.value = row.dispatchNo; documentsOpen.value = true }; return }
  if (value === 'bol') return void openBol(row)
  rejectionError.value = null
  if (value === 'route-order') { if (!canDispatchAction(row.actions, 'EDIT', access.can)) return; operation.value = 'ROUTE'; action.value = 'EDIT'; actionNo.value = row.dispatchNo; actionOpen.value = true; return }
@@ -174,11 +206,12 @@ onBeforeUnmount(() => { sequence++ })
    <div class="workbench-table is-page-surface"><DataTable v-model:page="page" v-model:page-size="pageSize" appearance="integrated" :data="rows" :columns="columns" :loading="loading" :total="total" :preference-key="preferenceKey" row-key="dispatchNo" empty-text="暂无排车记录" @update:page="load()" @update:page-size="page = 1; load()">
      <template #toolbar-start><el-button v-if="appointmentReturnTarget(route.query)" link @click="router.push(appointmentReturnTarget(route.query)!)">返回预约工作</el-button><div class="density-status-tabs workbench-list-tabs" role="tablist" aria-label="排车执行阶段"><button v-for="item in dispatchStages" :key="item.value" role="tab" :aria-selected="stage === item.value" :class="{ 'is-active': stage === item.value }" @click="switchStage(item.value)">{{ item.label }} <span>{{ statistics?.stageCounts[item.value] ?? '—' }}</span></button></div></template>
      <template #toolbar-end><el-button v-if="access.can(dispatchActionPermissions.CREATE)" @click="createTransport('PICKUP')">安排到仓取货</el-button><el-button v-if="access.can(dispatchActionPermissions.CREATE)" @click="createTransport('LOCAL_TRUCK')">安排本土卡车</el-button><el-button v-if="access.can(dispatchActionPermissions.CREATE) || access.can(dispatchActionPermissions.ADD_CARGO)" type="primary" @click="createOpen = true">智能排车</el-button></template>
-      <template #filters><div class="integrated-query-group"><div v-if="showSections" class="density-status-tabs" role="tablist" aria-label="装车前审核分区"><button v-for="item in sections" :key="item.value" role="tab" :aria-selected="section === item.value" :class="{ 'is-active': section === item.value }" @click="switchSection(item.value)">{{ item.label }}</button></div><QueryToolbar v-model="model" :fields="fields" :loading="loading" ariaLabel="排车列表筛选" preference-key="overseas-dispatches-query" :search-on-reset="false" @search="search" @reset="search" /></div></template>
+      <template #filters><div class="integrated-query-group"><div v-if="showSections" class="density-status-tabs" role="tablist" aria-label="装车前审核分区"><button v-for="item in sections" :key="item.value" role="tab" :aria-selected="section === item.value" :class="{ 'is-active': section === item.value }" @click="switchSection(item.value)">{{ item.label }}</button></div><QueryToolbar id="dispatch-query-filters" v-model="model" :fields="fields" :available-fields="availableFields" :loading="loading" ariaLabel="排车列表筛选" preference-key="overseas-dispatches-query" :search-on-reset="false" @search="search" @reset="resetSearch"><template #actions><el-button :aria-expanded="showAdvancedFilters" aria-controls="dispatch-query-filters" @click="showAdvancedFilters = !showAdvancedFilters">{{ showAdvancedFilters ? '收起筛选' : '高级筛选' }}{{ model.status === 'CANCELLED' ? ' · 已取消' : model.status === 'ALL' ? ' · 全部单据' : '' }}</el-button></template></QueryToolbar></div></template>
      <template v-if="loadError" #state><LoadErrorState title="排车列表加载失败" :message="loadError.message" :loading="loading" @retry="load"><template #details><ApiErrorMeta :details="loadError" /></template></LoadErrorState></template>
      <template #actions="{ row }"><RowActions text-actions :actions="rowActions(row as DispatchListRow)" :max-visible="row.taskType === 'PICKUP' ? 3 : 2" :more-label="`更多操作 · ${row.dispatchNo}`" @action="handleAction($event, row as DispatchListRow)" /><p v-if="!row.actions">操作资格未返回，请刷新核对</p></template>
      <template #taskType="{ row }">{{ transportLabels[(row.taskType || 'DELIVERY') as keyof typeof transportLabels] }}</template>
      <template #vehicle="{ row }">{{ row.resources.vehicle?.plate || '—' }}</template><template #driver="{ row }">{{ row.resources.driver?.name || '—' }}<br>{{ row.resources.driver?.phone || '—' }}</template>
+      <template #vehicleStatus="{ row }"><el-tag v-if="row.status === 'ACTIVE' && vehicleStatusForStage(row.stage)" :type="vehicleStatusForStage(row.stage)?.type">{{ vehicleStatusForStage(row.stage)?.label }}</el-tag><span v-else>—</span></template>
      <template #review="{ row }"><template v-for="review in [section === 'DISPATCH_REVIEW' ? row.reviews.dispatchReview : row.reviews.loadingReview]" :key="review.reviewRound"><div>{{ reviewLabels[review.status as ReviewStatus] }}</div><div v-if="review.reason">{{ review.reason }}</div><div v-if="review.invalidatedReason">{{ review.invalidatedReason }}</div><div>{{ time(review.reviewedAt) }}</div></template></template>
      <template #returnReason="{ row }">{{ dispatchRejectionReason(row.reviews) || '—' }}</template>
      <template #counts="{ row }">{{ row.counts.palletCount }}托／{{ row.counts.packageCount }}箱／已拣{{ row.counts.pickedPackageCount }}箱</template><template #planned="{ row }">{{ time(row.plannedDepartureAt) }}</template><template #departure="{ row }">{{ time(row.departedAt) }}</template><template #stage="{ row }">{{ row.status === 'CANCELLED' ? '已取消' : stageLabel(row.stage) }}</template><template #routeMap="{ row }"><el-button link @click="openRoute(row as DispatchListRow)">查看路线</el-button></template>
@@ -188,5 +221,6 @@ onBeforeUnmount(() => { sequence++ })
  <AppDialog v-model="transportEditOpen" class="admin-density-dialog" :title="transportEditTitle" width="1000px" :show-confirm="false" cancel-text="关闭"><TransportExecutionPanel v-if="transportEditOpen" :dispatch-no="transportEditNo" :edit-resources="transportResourceMode" :pickup-approved="activeTransport?.reviewState === 'APPROVED'" :pickup-review-state="activeTransport?.reviewState" @saved="load" /></AppDialog>
  <SmartDispatchDialog v-model="createOpen" :orders="[]" @created="load" />
  <DispatchWorkflowDialog v-model="actionOpen" :dispatch-no="actionNo" :action="action" :operation="operation" @saved="handleSaved" @rejected="handleRejection" />
+  <DispatchDocumentsDialog v-model="documentsOpen" :dispatch-no="documentsNo" @saved="load" />
  <TransportRouteDialog v-model="routeOpen" :origin="routeOrigin" :destinations="routeDestinations" />
 </template>
@@ -93,3 +93,19 @@ it.each(['success', 'failure'])('keeps rows stable during a refresh but rejects
    expect(() => state.assertCurrent(previous)).toThrow('尚未读取完成')
  }
 })
+
+it('allows mixed-warehouse pages only for the explicitly regional workspace and pins restored drafts to their warehouse', async () => {
+  const error = ref<ApiErrorDetails | null>(null)
+  const state = useDispatchCandidates(error, listDispatchCandidates, true)
+  const second = candidate({ sourceKey: 'ny-source', warehouseId: '654' })
+  vi.mocked(listDispatchCandidates).mockResolvedValueOnce(response({ candidates: [candidate(), second] }))
+  await state.load({ warehouseTab: 'ALL' })
+  expect(state.candidates.value).toHaveLength(2)
+  expect(() => state.assertCurrent([second])).not.toThrow()
+  vi.mocked(listDispatchCandidates).mockResolvedValueOnce(response({ candidates: [candidate()] }))
+  await state.load({ warehouseId: '321', warehouseTab: 'ALL', draftToken: 'server-token' })
+  expect(() => state.assertCurrent([second])).toThrow('组成已变化')
+  const scoped = setup()
+  await scoped.load({ warehouseTab: 'ALL' })
+  expect(listDispatchCandidates).toHaveBeenCalledTimes(2)
+})
@@ -4,7 +4,7 @@ import { listDispatchCandidates } from './api/dispatches'
 import { DispatchInputError, assertSelectionGroupVersions, type Candidate, type CandidateQuery } from './dispatchContracts'

 /** One visible server page; selected cargo remains owned by the caller or server draft. */
-export function useDispatchCandidates(error: Ref<ApiErrorDetails | null>, fetchCandidates = listDispatchCandidates) {
+export function useDispatchCandidates(error: Ref<ApiErrorDetails | null>, fetchCandidates = listDispatchCandidates, allowAllWarehouses = false) {
  const candidates = ref<Candidate[]>([]), page = ref(1), size = ref(20), total = ref(0), loading = ref(false)
  let generation = 0, warehouse = '', current = false
  let pending: { key: string; promise: Promise<void> } | undefined
@@ -21,7 +21,7 @@ export function useDispatchCandidates(error: Ref<ApiErrorDetails | null>, fetchC
    assertSelectionGroupVersions(rows, candidates.value)
    for (const row of rows) {
      const group = row.selectionGroup
-      if (row.warehouseId !== warehouse || (groupVersions.has(group.groupKey) && groupVersions.get(group.groupKey) !== group.groupVersion)
+      if ((warehouse && row.warehouseId !== warehouse) || (groupVersions.has(group.groupKey) && groupVersions.get(group.groupKey) !== group.groupVersion)
        || group.sources.some(source => {
          const latest = sourceGroups.get(source.sourceKey)
          return latest && (latest.groupKey !== group.groupKey || latest.sourceVersion !== source.selection.sourceVersion)
@@ -29,8 +29,8 @@ export function useDispatchCandidates(error: Ref<ApiErrorDetails | null>, fetchC
    }
  }
  function load(query: CandidateQuery): Promise<void> {
-    if (!query.warehouseId) { reset(); return Promise.resolve() }
-    if (warehouse !== query.warehouseId) { reset(); warehouse = query.warehouseId }
+    if (!query.warehouseId && !allowAllWarehouses) { reset(); return Promise.resolve() }
+    if (warehouse !== (query.warehouseId || '')) { reset(); warehouse = query.warehouseId || '' }
    const request = { ...query, page: query.page ?? page.value, size: query.size ?? size.value, warehouseTab: query.warehouseTab ?? 'ALL' }
    const key = JSON.stringify(request)
    if (pending?.key === key) return pending.promise
@@ -43,7 +43,7 @@ export function useDispatchCandidates(error: Ref<ApiErrorDetails | null>, fetchC
        const result = await fetchCandidates(request)
        if (sequence !== generation) return
        if (result.page !== request.page || result.size !== request.size) throw new DispatchInputError('候选响应页码不一致，请重新读取')
-        if (result.candidates.some(row => row.warehouseId !== request.warehouseId || !row.sourceVersion || row.selection.sourceVersion !== row.sourceVersion)) throw new DispatchInputError('候选起运仓或来源版本不完整，请重新读取')
+        if (result.candidates.some(row => !row.warehouseId || (request.warehouseId && row.warehouseId !== request.warehouseId) || !row.sourceVersion || row.selection.sourceVersion !== row.sourceVersion)) throw new DispatchInputError('候选起运仓或来源版本不完整，请重新读取')
        for (const row of result.candidates) {
          groupVersions.set(row.selectionGroup.groupKey, row.selectionGroup.groupVersion)
          for (const source of row.selectionGroup.sources) sourceGroups.set(source.sourceKey, { groupKey: row.selectionGroup.groupKey, sourceVersion: source.selection.sourceVersion })
@@ -33,7 +33,7 @@
 .admin-density .el-empty__description { margin-top: 0; }
 .admin-density .el-empty__description p { font-size: var(--admin-font-body, 13px); }
 .admin-density-dialog .el-form-item__label { line-height: 22px; }
-.admin-density-dialog .el-form--inline .el-form-item__label { align-items: center; }
+.admin-density-dialog .el-form-item:not(.el-form-item--label-top) .el-form-item__label { align-items: center; }
 :is(.admin-density, .admin-density-dialog, .admin-density-drawer) .el-table th.el-table__cell {
  background: var(--cc-list-table-header-bg);
  color: var(--cc-list-table-header-text);
@@ -243,6 +243,7 @@


 .admin-density .density-contained-tabs > .el-tabs__content { padding: var(--admin-space-5); }
+.admin-density .density-contained-tabs.density-contained-tabs--flush > .el-tabs__content { padding: 0; }

 /* Explicit page descriptions share the teleported detail table scale. */
 :is(.admin-density, .admin-density-dialog) .density-descriptions .el-descriptions__label.el-descriptions__cell { width: var(--admin-label-width); font-size: var(--admin-font-caption); background: var(--admin-label-bg); }
@@ -836,7 +836,7 @@ describe('approved Admin density ownership', () => {

  it('keeps contained overseas tab content and external cargo tab bodies separate', () => {
    expect(shared).toContain('.density-element-tabs:not(.density-contained-tabs) > .el-tabs__content { display: none; }')
-    for (const file of ['LastMileOrderDetailView', 'DeliveryOrderDetailView']) {
+    for (const file of ['LastMileOrderDetailView', 'DeliveryOrderDetailView', 'DispatchDetailView']) {
      const source = read('modules/overseas-warehouse/pages/' + file + '.vue')
      const ast = parse(source).descriptor.template!.ast!
      let panes = 0
@@ -855,6 +855,24 @@ describe('approved Admin density ownership', () => {
    }
  })

+  it('fits the five dispatch vehicle fields in one desktop row with read-only detail tabs', () => {
+    const source = read('modules/overseas-warehouse/pages/DispatchDetailView.vue')
+    const css = parse(source).descriptor.styles.map(style => style.content).join('\n')
+    const declarations = (source: string, selector: string) => {
+      const values: Record<string, string> = {}
+      cssRoot(source).walkRules(rule => {
+        if (rule.selector === selector && rule.parent?.type !== 'atrule') rule.walkDecls(decl => { values[decl.prop] = decl.value })
+      })
+      return values
+    }
+    expect(declarations(css, '.dispatch-detail .vehicle-fields')['grid-template-columns']).toBe('minmax(0, 1.3fr) minmax(0, 1.6fr) minmax(0, 1.2fr) minmax(0, 1.5fr) minmax(0, 0.8fr)')
+    expect(declarations(css, '.dispatch-detail .vehicle-fields > div')['grid-template-columns']).toBe('max-content minmax(0, 1fr)')
+    expect(css).not.toContain('.dispatch-actions')
+    expect(declarations(shared, '.admin-density .density-contained-tabs > .el-tabs__content').padding).toBe('var(--admin-space-5)')
+    expect(declarations(shared, '.admin-density .density-contained-tabs.density-contained-tabs--flush > .el-tabs__content').padding).toBe('0')
+    expect(elementsOf(source, 'el-tabs').every(node => classesOf(node).includes('density-contained-tabs--flush'))).toBe(true)
+  })
+
  it('opts shared overseas detail and relationship wrappers in only at approved callers', () => {
    for (const file of ['modules/overseas-warehouse/components/OverseasDetailShell.vue', 'modules/overseas-warehouse/components/OverseasReadOnlyDetail.vue', 'shared/components/InboundCodeRelationshipDialog.vue']) {
      const source = read(file)
@@ -1099,7 +1117,17 @@ describe('approved Admin density ownership', () => {
    cell.innerHTML = '<table class="el-table__body"><tbody><tr><td class="el-table__cell"></td></tr></tbody></table>'
    expect(cell.querySelector('td')!.matches(stripeSelector)).toBe(false)
    expect(rules.get('.admin-density-dialog .el-descriptions__label.el-descriptions__cell')?.background).toBe('var(--admin-label-bg)')
-    expect(rules.get('.admin-density-dialog .el-form--inline .el-form-item__label')?.['align-items']).toBe('center')
+    const horizontalLabelSelector = '.admin-density-dialog .el-form-item:not(.el-form-item--label-top) .el-form-item__label'
+    expect(rules.get(horizontalLabelSelector)?.['align-items']).toBe('center')
+    const labelFixture = document.createElement('div')
+    labelFixture.innerHTML = '<div class="admin-density-dialog"><form class="el-form"><div class="el-form-item el-form-item--label-left"><label class="el-form-item__label">计划送仓日期</label></div></form></div>'
+    const formItem = labelFixture.querySelector('.el-form-item')!
+    const label = labelFixture.querySelector('label')!
+    expect(label.matches(horizontalLabelSelector)).toBe(true)
+    formItem.className = 'el-form-item el-form-item--label-right'
+    expect(label.matches(horizontalLabelSelector)).toBe(true)
+    formItem.className = 'el-form-item el-form-item--label-top'
+    expect(label.matches(horizontalLabelSelector)).toBe(false)
    expect(rules.get('.admin-density-dialog.el-dialog.admin-density-workspace > .el-dialog__body')?.flex).toBe('1 1 auto')
    for (const tone of ['warning', 'purple', 'primary', 'success', 'danger']) {
      expect(rules.get(`:is(.admin-density, .admin-density-dialog) .density-action[data-tone="${tone}"]`)?.['--action-hover-bg']).toBe(`var(--admin-action-${tone}-hover)`)
@@ -1302,7 +1330,8 @@ describe('approved Admin density ownership', () => {
    expect(source).not.toContain('class="density-dialog-section dispatch-draft-toolbar"')
    expect(source).toContain('<template #vehicle-controls>')
    expect(source).toContain('class="density-form dispatch-setup-fields"')
-    expect(source).toContain('class="dispatch-warehouse-picker" aria-label="起运仓"')
+    expect(source).toContain('<el-form-item v-if="mode === \'empty\'" label="起运仓">')
+    expect(source).toContain('<template #order-controls>')
    expect(source).not.toContain('class="dispatch-warehouse-field" label="起运仓"')
    expect(source).not.toContain('data-tone="work"')
    expect(source).not.toContain('data-tone="summary"')
@@ -1352,7 +1381,10 @@ describe('approved Admin density ownership', () => {
    }
    expect(workflow).not.toMatch(/max-height="(?:380|420)"/)
    expect(evidence).toContain('class="density-table dispatch-evidence-table"')
-    expect(evidence).toContain('fullscreenable :loading="previewLoading"')
+    expect(evidence).toContain('fullscreenable :loading="previewBusy"')
+    expect(evidence).toContain('class="evidence-preview" :aria-busy="previewBusy"')
+    expect(evidence).not.toContain('aria-label="本车附件预览信息"')
+    expect(evidence).not.toContain('正在读取本车附件…')
    expect(evidence).toContain('<LoadErrorState')
    expect(evidence).toContain('<LineClampText')
    for (const source of [workflow, evidence]) {